squeezr-ai 1.81.2 → 1.99.2

package/dist/__tests__/jsonCrush.test.js

@@ -0,0 +1,168 @@
+import { describe, it, expect } from 'vitest';
+import { crushJsonArrays, TABLE_MARKER_RE, simhash32, hammingDistance } from '../jsonCrush.js';
+import { retrieveOriginal } from '../expand.js';
+function makeRows(n) {
+    const rows = [];
+    for (let i = 0; i < n; i++) {
+        rows.push({ id: i, name: `service-${i}`, status: i % 2 === 0 ? 'running' : 'stopped', region: 'us-east-1' });
+    }
+    return JSON.stringify(rows);
+}
+describe('crushJsonArrays', () => {
+    it('crushes a uniform array of >=5 objects and saves chars', () => {
+        const input = makeRows(20);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBeGreaterThan(0);
+        expect(text.length).toBeLessThan(input.length);
+        expect(TABLE_MARKER_RE.test(text)).toBe(true);
+    });
+    it('embeds a recoverable squeezr_expand id that returns the ORIGINAL json', () => {
+        const input = makeRows(20);
+        const { text } = crushJsonArrays(input);
+        const m = text.match(TABLE_MARKER_RE);
+        expect(m).not.toBeNull();
+        const id = m[1];
+        expect(retrieveOriginal(id)).toBe(input);
+    });
+    it('keeps every value present in the table body (lossless representation)', () => {
+        const input = makeRows(6);
+        const { text } = crushJsonArrays(input);
+        expect(text.includes('service-0')).toBe(true);
+        expect(text.includes('service-5')).toBe(true);
+        expect(text.includes('running')).toBe(true);
+        expect(text.includes('stopped')).toBe(true);
+    });
+    it('lists the column names once in the header, not per row', () => {
+        const input = makeRows(10);
+        const { text } = crushJsonArrays(input);
+        // "region" appears once as a column header, never repeated as a JSON key
+        expect((text.match(/"region"/g) ?? []).length).toBe(0);
+        expect(text.includes('region')).toBe(true);
+    });
+    it('does NOT crush arrays below the minimum item count', () => {
+        const input = JSON.stringify([{ a: 1 }, { a: 2 }]);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBe(0);
+        expect(text).toBe(input);
+    });
+    it('does NOT crush a single JSON object', () => {
+        const input = JSON.stringify({ id: 1, name: 'x', status: 'ok', region: 'eu' });
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBe(0);
+        expect(text).toBe(input);
+    });
+    it('does NOT crush an array of scalars (no keys to factor out)', () => {
+        const input = JSON.stringify([1, 2, 3, 4, 5, 6, 7, 8]);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBe(0);
+        expect(text).toBe(input);
+    });
+    it('leaves non-JSON text unchanged', () => {
+        const input = 'this is just a log line\nand another one';
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBe(0);
+        expect(text).toBe(input);
+    });
+    it('does NOT crush when the columnar form would not save enough', () => {
+        // few rows, tiny keys → little repeated-key overhead → not worth it
+        const input = JSON.stringify([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }]);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBe(0);
+        expect(text).toBe(input);
+    });
+    it('handles heterogeneous objects (missing keys) and stays recoverable', () => {
+        const arr = [
+            { id: 1, name: 'a', status: 'ok', extra: 'z' },
+            { id: 2, name: 'b', status: 'ok' },
+            { id: 3, name: 'c', status: 'fail', region: 'eu' },
+            { id: 4, name: 'd', status: 'ok' },
+            { id: 5, name: 'e', status: 'ok' },
+            { id: 6, name: 'f', status: 'ok' },
+        ];
+        const input = JSON.stringify(arr);
+        const { text } = crushJsonArrays(input);
+        const m = text.match(TABLE_MARKER_RE);
+        expect(m).not.toBeNull();
+        expect(retrieveOriginal(m[1])).toBe(input);
+    });
+    it('renders nested objects inline as compact JSON', () => {
+        const arr = Array.from({ length: 6 }, (_, i) => ({
+            id: i,
+            meta: { region: 'us', tier: 'gold' },
+            name: `n${i}`,
+        }));
+        const input = JSON.stringify(arr);
+        const { text } = crushJsonArrays(input);
+        expect(text.includes('{"region":"us","tier":"gold"}')).toBe(true);
+    });
+    it('is deterministic — same input yields byte-identical output (cache-safe)', () => {
+        const input = makeRows(15);
+        const a = crushJsonArrays(input).text;
+        const b = crushJsonArrays(input).text;
+        expect(a).toBe(b);
+    });
+    // ── Lossy row-drop (SimHash near-dup collapse) for large arrays ──────────────
+    function manyRows(n) {
+        return Array.from({ length: n }, (_, i) => ({
+            id: i,
+            name: `svc-${i}`,
+            status: i % 2 === 0 ? 'running' : 'stopped',
+            region: 'us-east-1',
+        }));
+    }
+    it('drops near-duplicate rows in a large array but keeps the original recoverable', () => {
+        const rows = manyRows(120);
+        const input = JSON.stringify(rows);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBeGreaterThan(0);
+        // the inline table shows far fewer than 120 rows
+        const bodyLines = text.split('\n').filter(l => l.includes('\t'));
+        expect(bodyLines.length).toBeLessThan(120);
+        // an omitted-rows note is present
+        expect(/of 120 rows|rows omitted|near-duplicate/i.test(text)).toBe(true);
+        // ALL 120 rows still recoverable via expand
+        const m = text.match(TABLE_MARKER_RE);
+        expect(JSON.parse(retrieveOriginal(m[1])).length).toBe(120);
+    });
+    it('ALWAYS keeps an anomalous/error row inline even amid near-duplicates', () => {
+        const rows = manyRows(120);
+        rows[63] = { id: 63, name: 'svc-63', status: 'CrashLoopBackOff', region: 'us-east-1', error: 'OOMKilled' };
+        const input = JSON.stringify(rows);
+        const { text } = crushJsonArrays(input);
+        expect(text.includes('CrashLoopBackOff')).toBe(true);
+        expect(text.includes('OOMKilled')).toBe(true);
+    });
+    it('keeps ALL rows for arrays below the lossy threshold (no row-drop)', () => {
+        const input = JSON.stringify(manyRows(30));
+        const { text } = crushJsonArrays(input);
+        expect(/rows omitted|near-duplicate/i.test(text)).toBe(false);
+        // lines after the marker (0) and header (1) are the data rows
+        const dataRows = text.split('\n').slice(2);
+        expect(dataRows.length).toBe(30);
+    });
+    it('row-drop is deterministic', () => {
+        const input = JSON.stringify(manyRows(150));
+        expect(crushJsonArrays(input).text).toBe(crushJsonArrays(input).text);
+    });
+    it('crushes a pretty-printed (indented) JSON array too', () => {
+        const input = JSON.stringify(Array.from({ length: 8 }, (_, i) => ({ id: i, name: `x${i}`, status: 'ok', region: 'us' })), null, 2);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBeGreaterThan(0);
+        expect(TABLE_MARKER_RE.test(text)).toBe(true);
+    });
+});
+describe('simhash32 / hammingDistance', () => {
+    it('identical text → identical fingerprint (distance 0)', () => {
+        expect(hammingDistance(simhash32('the quick brown fox'), simhash32('the quick brown fox'))).toBe(0);
+    });
+    it('near-identical rows are closer than unrelated ones (the property that matters)', () => {
+        // Realistic row strings (many shared tokens) — SimHash's signal is strongest here.
+        const base = simhash32('id 1 name svc-1 status running region us-east-1 node ip-10-0-1-5');
+        const near = simhash32('id 2 name svc-2 status running region us-east-1 node ip-10-0-1-5');
+        const far = simhash32('completely unrelated payload about quarterly revenue and marketing spend');
+        expect(hammingDistance(base, near)).toBeLessThan(hammingDistance(base, far));
+    });
+    it('is deterministic', () => {
+        expect(simhash32('same input here')).toBe(simhash32('same input here'));
+    });
+});

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

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

package/dist/__tests__/learn.test.js

@@ -0,0 +1,159 @@
+import { describe, it, expect } from 'vitest';
+import { canonicalSignature, extractToolCalls, detectLoops, renderCorrections, writeMarkerBlock, LEARN_START, LEARN_END, } from '../learn.js';
+// ── canonicalSignature ───────────────────────────────────────────────────────
+describe('canonicalSignature', () => {
+    it('strips pipe-head/tail pagination so variants collapse', () => {
+        const a = canonicalSignature('Bash', { command: 'grep foo src | head -50' });
+        const b = canonicalSignature('Bash', { command: 'grep foo src | head -100' });
+        expect(a).toBe(b);
+    });
+    it('collapses LIMIT/OFFSET and bare integers to N', () => {
+        const a = canonicalSignature('Bash', { command: 'psql -c "select * from t LIMIT 20 OFFSET 0"' });
+        const b = canonicalSignature('Bash', { command: 'psql -c "select * from t LIMIT 50 OFFSET 40"' });
+        expect(a).toBe(b);
+    });
+    it('distinguishes genuinely different commands', () => {
+        const a = canonicalSignature('Bash', { command: 'ls -la' });
+        const b = canonicalSignature('Bash', { command: 'cat file.txt' });
+        expect(a).not.toBe(b);
+    });
+    it('uses tool name + input for non-Bash tools', () => {
+        const a = canonicalSignature('Grep', { pattern: 'foo', path: 'src' });
+        const b = canonicalSignature('Read', { file_path: 'src' });
+        expect(a).not.toBe(b);
+        expect(a.startsWith('grep')).toBe(true);
+    });
+});
+// ── extractToolCalls ─────────────────────────────────────────────────────────
+describe('extractToolCalls', () => {
+    const lines = [
+        JSON.stringify({ type: 'user', message: { content: [{ type: 'text', text: 'hi' }] } }),
+        JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', id: 't1', name: 'Bash', input: { command: 'npm test' } }] } }),
+        JSON.stringify({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 't1', content: 'FAIL', is_error: true }] } }),
+    ];
+    it('pairs tool_use with its tool_result (name, error flag, output size)', () => {
+        const calls = extractToolCalls(lines);
+        expect(calls.length).toBe(1);
+        expect(calls[0].tool).toBe('Bash');
+        expect(calls[0].isError).toBe(true);
+        expect(calls[0].outputBytes).toBe('FAIL'.length);
+    });
+    it('tolerates malformed / non-JSON lines', () => {
+        const calls = extractToolCalls([...lines, 'not json', '']);
+        expect(calls.length).toBe(1);
+    });
+    it('handles array-form tool_result content', () => {
+        const l = [
+            JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', id: 'x', name: 'Read', input: { file_path: 'a' } }] } }),
+            JSON.stringify({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'x', content: [{ type: 'text', text: 'hello' }] }] } }),
+        ];
+        const calls = extractToolCalls(l);
+        expect(calls[0].outputBytes).toBeGreaterThan(0);
+        expect(calls[0].isError).toBe(false);
+    });
+});
+// ── detectLoops ──────────────────────────────────────────────────────────────
+function call(tool, command, isError, outputBytes = 100) {
+    return { tool, signature: canonicalSignature(tool, { command }), raw: command, isError, outputBytes };
+}
+describe('detectLoops', () => {
+    it('flags an error loop when the same signature fails >=3 times', () => {
+        const calls = [
+            call('Bash', 'npm run build', true, 500),
+            call('Bash', 'npm run build', true, 500),
+            call('Bash', 'npm run build', true, 500),
+        ];
+        const loops = detectLoops(calls);
+        const err = loops.find(l => l.kind === 'error');
+        expect(err).toBeDefined();
+        expect(err.count).toBe(3);
+        expect(err.wastedBytes).toBe(1500);
+    });
+    it('does not flag fewer than the minimum occurrences', () => {
+        const calls = [call('Bash', 'npm run build', true), call('Bash', 'npm run build', true)];
+        expect(detectLoops(calls).length).toBe(0);
+    });
+    it('flags a refetch loop: same signature, different raw variants, all succeeding', () => {
+        const calls = [
+            call('Bash', 'grep foo src | head -50', false, 2000),
+            call('Bash', 'grep foo src | head -100', false, 4000),
+            call('Bash', 'grep foo src | head -200', false, 8000),
+        ];
+        const loops = detectLoops(calls);
+        const refetch = loops.find(l => l.kind === 'refetch');
+        expect(refetch).toBeDefined();
+        expect(refetch.count).toBe(3);
+        // wasted = redundant follow-ups (all but the first)
+        expect(refetch.wastedBytes).toBe(12000);
+    });
+    it('does not flag a refetch when the raw command is identical every time (that is caching, not a loop)', () => {
+        const calls = [
+            call('Bash', 'ls', false),
+            call('Bash', 'ls', false),
+            call('Bash', 'ls', false),
+        ];
+        expect(detectLoops(calls).find(l => l.kind === 'refetch')).toBeUndefined();
+    });
+    it('classifies a signature with errors as an error loop, not a refetch (even with raw variants)', () => {
+        // Same canonical signature (pagination stripped) + distinct raw + all errored:
+        // errors win → error loop, never also reported as a refetch.
+        const calls = [
+            call('Bash', 'grep foo | head -50', true),
+            call('Bash', 'grep foo | head -100', true),
+            call('Bash', 'grep foo | head -200', true),
+        ];
+        const loops = detectLoops(calls);
+        expect(loops.some(l => l.kind === 'error')).toBe(true);
+        expect(loops.some(l => l.kind === 'refetch')).toBe(false);
+    });
+    it('ranks loops by wasted bytes descending', () => {
+        const calls = [
+            call('Bash', 'small | head -1', false, 100),
+            call('Bash', 'small | head -2', false, 100),
+            call('Bash', 'small | head -3', false, 100),
+            call('Bash', 'big', true, 9000),
+            call('Bash', 'big', true, 9000),
+            call('Bash', 'big', true, 9000),
+        ];
+        const loops = detectLoops(calls);
+        expect(loops[0].wastedBytes).toBeGreaterThanOrEqual(loops[loops.length - 1].wastedBytes);
+    });
+});
+// ── renderCorrections ────────────────────────────────────────────────────────
+describe('renderCorrections', () => {
+    it('produces a bullet per loop mentioning the signature', () => {
+        const loops = detectLoops([
+            call('Bash', 'npm run build', true, 500),
+            call('Bash', 'npm run build', true, 500),
+            call('Bash', 'npm run build', true, 500),
+        ]);
+        const text = renderCorrections(loops);
+        expect(text.includes('npm run build')).toBe(true);
+        expect(text.split('\n').some(l => l.trim().startsWith('-'))).toBe(true);
+    });
+    it('returns empty string for no loops', () => {
+        expect(renderCorrections([])).toBe('');
+    });
+});
+// ── writeMarkerBlock ─────────────────────────────────────────────────────────
+describe('writeMarkerBlock', () => {
+    it('appends a marked block to fresh content', () => {
+        const out = writeMarkerBlock('# Project\n\nsome notes\n', 'rule one');
+        expect(out.includes(LEARN_START)).toBe(true);
+        expect(out.includes(LEARN_END)).toBe(true);
+        expect(out.includes('rule one')).toBe(true);
+        expect(out.startsWith('# Project')).toBe(true);
+    });
+    it('replaces an existing block instead of stacking (idempotent shape)', () => {
+        const first = writeMarkerBlock('base\n', 'rule one');
+        const second = writeMarkerBlock(first, 'rule two');
+        expect((second.match(new RegExp(LEARN_START, 'g')) ?? []).length).toBe(1);
+        expect(second.includes('rule two')).toBe(true);
+        expect(second.includes('rule one')).toBe(false);
+    });
+    it('re-applying the SAME block yields byte-identical content', () => {
+        const first = writeMarkerBlock('base\n', 'rule one');
+        const second = writeMarkerBlock(first, 'rule one');
+        expect(second).toBe(first);
+    });
+});

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

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

package/dist/__tests__/outputSavings.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import { wordNgrams, echoRatio, extractAssistantTextFromSse } from '../outputSavings.js';
+describe('wordNgrams', () => {
+    it('builds word n-grams', () => {
+        expect(wordNgrams('a b c d', 3).has('a b c')).toBe(true);
+        expect(wordNgrams('a b c d', 3).has('b c d')).toBe(true);
+    });
+    it('empty for text shorter than n', () => {
+        expect(wordNgrams('a b', 3).size).toBe(0);
+    });
+});
+describe('echoRatio', () => {
+    it('~1 when the output only restates context', () => {
+        const context = 'the authentication middleware refreshes the token on every request cycle';
+        const output = 'the authentication middleware refreshes the token on every request cycle';
+        expect(echoRatio(output, context)).toBeGreaterThan(0.9);
+    });
+    it('~0 when the output is entirely novel', () => {
+        const context = 'the authentication middleware refreshes the token';
+        const output = 'completely different sentence about unrelated banana harvest logistics today';
+        expect(echoRatio(output, context)).toBeLessThan(0.1);
+    });
+    it('is 0 for empty output', () => {
+        expect(echoRatio('', 'some context here at all')).toBe(0);
+    });
+    it('is between 0 and 1 for partial restating', () => {
+        const context = 'shared preamble tokens appear here in the context block';
+        const output = 'shared preamble tokens appear here plus a brand new original tail clause';
+        const r = echoRatio(output, context);
+        expect(r).toBeGreaterThan(0);
+        expect(r).toBeLessThan(1);
+    });
+    it('is deterministic', () => {
+        expect(echoRatio('a b c d e', 'a b c d e f')).toBe(echoRatio('a b c d e', 'a b c d e f'));
+    });
+});
+describe('extractAssistantTextFromSse', () => {
+    it('concatenates text_delta events, unescaping', () => {
+        const sse = [
+            'event: content_block_delta',
+            'data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello "}}',
+            'data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"world\\n"}}',
+        ].join('\n');
+        expect(extractAssistantTextFromSse(sse)).toBe('Hello world\n');
+    });
+    it('returns empty string when there are no text deltas', () => {
+        expect(extractAssistantTextFromSse('data: {"type":"message_start"}')).toBe('');
+    });
+});

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

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

package/dist/__tests__/outputShaper.test.js

@@ -0,0 +1,216 @@
+import { describe, it, expect } from 'vitest';
+import { classifyTurn, steeringText, applyVerbositySteering, routeEffort, shapeRequest, STEERING_START, STEERING_END, } from '../outputShaper.js';
+const DEFAULTS = {
+    enabled: true,
+    verbositySteering: true,
+    level: 2,
+    effortRouting: true,
+    mechanicalThinkingFloor: 1024,
+};
+function userText(t) {
+    return { role: 'user', content: [{ type: 'text', text: t }] };
+}
+function toolResult(id, content = 'ok', isError = false) {
+    return {
+        role: 'user',
+        content: [{ type: 'tool_result', tool_use_id: id, content, is_error: isError }],
+    };
+}
+function assistantToolUse(id) {
+    return { role: 'assistant', content: [{ type: 'tool_use', id, name: 'Bash', input: {} }] };
+}
+// ── classifyTurn ─────────────────────────────────────────────────────────────
+describe('classifyTurn', () => {
+    it('a clean tool_result as the last message → mechanical', () => {
+        const msgs = [userText('do a thing'), assistantToolUse('t1'), toolResult('t1', 'file contents')];
+        expect(classifyTurn(msgs)).toBe('mechanical');
+    });
+    it('a tool_result with is_error → error', () => {
+        const msgs = [userText('do a thing'), assistantToolUse('t1'), toolResult('t1', 'boom', true)];
+        expect(classifyTurn(msgs)).toBe('error');
+    });
+    it('a fresh user text message → new-ask', () => {
+        const msgs = [userText('first'), assistantToolUse('t1'), toolResult('t1'), userText('now do this')];
+        expect(classifyTurn(msgs)).toBe('new-ask');
+    });
+    it('string user content → new-ask', () => {
+        const msgs = [{ role: 'user', content: 'hello there' }];
+        expect(classifyTurn(msgs)).toBe('new-ask');
+    });
+    it('tool_result string content field on error flag detected → error', () => {
+        const msgs = [
+            { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'x', content: 'err', is_error: true }] },
+        ];
+        expect(classifyTurn(msgs)).toBe('error');
+    });
+    it('empty messages → unknown', () => {
+        expect(classifyTurn([])).toBe('unknown');
+    });
+    it('last message is assistant → unknown', () => {
+        const msgs = [userText('hi'), assistantToolUse('t1')];
+        expect(classifyTurn(msgs)).toBe('unknown');
+    });
+});
+// ── steeringText ─────────────────────────────────────────────────────────────
+describe('steeringText', () => {
+    it('is byte-stable for the same level', () => {
+        expect(steeringText(2)).toBe(steeringText(2));
+    });
+    it('higher levels are more aggressive (longer or different)', () => {
+        expect(steeringText(1)).not.toBe(steeringText(4));
+    });
+    it('is wrapped in the sentinel markers', () => {
+        const t = steeringText(2);
+        expect(t.startsWith(STEERING_START)).toBe(true);
+        expect(t.trimEnd().endsWith(STEERING_END)).toBe(true);
+    });
+});
+// ── applyVerbositySteering ───────────────────────────────────────────────────
+describe('applyVerbositySteering', () => {
+    it('appends a text block to an array system prompt', () => {
+        const body = {
+            system: [{ type: 'text', text: 'You are Claude.', cache_control: { type: 'ephemeral' } }],
+        };
+        const changed = applyVerbositySteering(body, 2);
+        expect(changed).toBe(true);
+        const sys = body.system;
+        expect(sys.length).toBe(2);
+        expect(sys[1].text.includes(STEERING_START)).toBe(true);
+    });
+    it('never mutates the existing cache_control block', () => {
+        const body = {
+            system: [{ type: 'text', text: 'You are Claude.', cache_control: { type: 'ephemeral' } }],
+        };
+        applyVerbositySteering(body, 2);
+        const sys = body.system;
+        expect(sys[0].text).toBe('You are Claude.');
+        expect(sys[0].cache_control).toEqual({ type: 'ephemeral' });
+    });
+    it('appends to a string system prompt', () => {
+        const body = { system: 'You are Claude.' };
+        applyVerbositySteering(body, 2);
+        expect(body.system.startsWith('You are Claude.')).toBe(true);
+        expect(body.system.includes(STEERING_START)).toBe(true);
+    });
+    it('is idempotent — applying twice yields byte-identical system (cache-safe)', () => {
+        const body = {
+            system: [{ type: 'text', text: 'You are Claude.', cache_control: { type: 'ephemeral' } }],
+        };
+        applyVerbositySteering(body, 2);
+        const afterFirst = JSON.stringify(body.system);
+        applyVerbositySteering(body, 2);
+        const afterSecond = JSON.stringify(body.system);
+        expect(afterSecond).toBe(afterFirst);
+    });
+    it('re-steering at a new level replaces the old block (no stacking)', () => {
+        const body = {
+            system: [{ type: 'text', text: 'You are Claude.' }],
+        };
+        applyVerbositySteering(body, 2);
+        applyVerbositySteering(body, 4);
+        const sys = body.system;
+        const steeringBlocks = sys.filter(b => (b.text ?? '').includes(STEERING_START));
+        expect(steeringBlocks.length).toBe(1);
+        expect(steeringBlocks[0].text).toBe(steeringText(4));
+    });
+});
+// ── routeEffort ──────────────────────────────────────────────────────────────
+describe('routeEffort', () => {
+    it('lowers an existing thinking.budget_tokens to the floor', () => {
+        const body = { thinking: { type: 'enabled', budget_tokens: 16000 } };
+        const lowered = routeEffort(body, 1024);
+        expect(lowered).toBe(true);
+        expect(body.thinking.budget_tokens).toBe(1024);
+    });
+    it('never toggles thinking.type', () => {
+        const body = { thinking: { type: 'enabled', budget_tokens: 16000 } };
+        routeEffort(body, 1024);
+        expect(body.thinking.type).toBe('enabled');
+    });
+    it('does not raise a budget already below the floor', () => {
+        const body = { thinking: { type: 'enabled', budget_tokens: 512 } };
+        const lowered = routeEffort(body, 1024);
+        expect(lowered).toBe(false);
+        expect(body.thinking.budget_tokens).toBe(512);
+    });
+    it('lowers an explicit output_config.effort but never injects one', () => {
+        const withEffort = { output_config: { effort: 'xhigh' } };
+        expect(routeEffort(withEffort, 1024)).toBe(true);
+        expect(withEffort.output_config.effort).toBe('low');
+        const withoutEffort = {};
+        expect(routeEffort(withoutEffort, 1024)).toBe(false);
+        expect(withoutEffort.output_config).toBeUndefined();
+    });
+    it('does nothing when no effort levers are present', () => {
+        const body = {};
+        expect(routeEffort(body, 1024)).toBe(false);
+        expect(body.thinking).toBeUndefined();
+    });
+});
+// ── shapeRequest (orchestration) ─────────────────────────────────────────────
+describe('shapeRequest', () => {
+    it('no-op when disabled — body untouched', () => {
+        const body = {
+            system: [{ type: 'text', text: 'You are Claude.' }],
+            thinking: { type: 'enabled', budget_tokens: 16000 },
+            messages: [toolResult('t1')],
+        };
+        const before = JSON.stringify(body);
+        const r = shapeRequest(body, { ...DEFAULTS, enabled: false });
+        expect(r.steered).toBe(false);
+        expect(r.effortLowered).toBe(false);
+        expect(JSON.stringify(body)).toBe(before);
+    });
+    it('mechanical turn: both steers and lowers effort', () => {
+        const body = {
+            system: [{ type: 'text', text: 'You are Claude.' }],
+            thinking: { type: 'enabled', budget_tokens: 16000 },
+            messages: [userText('go'), assistantToolUse('t1'), toolResult('t1', 'contents')],
+        };
+        const r = shapeRequest(body, DEFAULTS);
+        expect(r.turn).toBe('mechanical');
+        expect(r.steered).toBe(true);
+        expect(r.effortLowered).toBe(true);
+        expect(body.thinking.budget_tokens).toBe(1024);
+    });
+    it('new-ask turn: steers but keeps full effort', () => {
+        const body = {
+            system: [{ type: 'text', text: 'You are Claude.' }],
+            thinking: { type: 'enabled', budget_tokens: 16000 },
+            messages: [toolResult('t1'), userText('new question')],
+        };
+        const r = shapeRequest(body, DEFAULTS);
+        expect(r.turn).toBe('new-ask');
+        expect(r.steered).toBe(true);
+        expect(r.effortLowered).toBe(false);
+        expect(body.thinking.budget_tokens).toBe(16000);
+    });
+    it('error turn: keeps full effort', () => {
+        const body = {
+            system: [{ type: 'text', text: 'You are Claude.' }],
+            thinking: { type: 'enabled', budget_tokens: 16000 },
+            messages: [assistantToolUse('t1'), toolResult('t1', 'boom', true)],
+        };
+        const r = shapeRequest(body, DEFAULTS);
+        expect(r.turn).toBe('error');
+        expect(r.effortLowered).toBe(false);
+    });
+    it('effort routing disabled: never lowers even on mechanical turns', () => {
+        const body = {
+            thinking: { type: 'enabled', budget_tokens: 16000 },
+            messages: [toolResult('t1')],
+        };
+        const r = shapeRequest(body, { ...DEFAULTS, effortRouting: false });
+        expect(r.effortLowered).toBe(false);
+        expect(body.thinking.budget_tokens).toBe(16000);
+    });
+    it('verbosity steering disabled: never touches the system prompt', () => {
+        const body = {
+            system: [{ type: 'text', text: 'You are Claude.' }],
+            messages: [toolResult('t1')],
+        };
+        const r = shapeRequest(body, { ...DEFAULTS, verbositySteering: false });
+        expect(r.steered).toBe(false);
+        expect(body.system.length).toBe(1);
+    });
+});

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

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