@cspeach/cli 0.6.3 → 0.6.4

package/dist/agent/__tests__/maybe-build-project-context.test.js

@@ -0,0 +1,247 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { PROJECT_CONTEXT_ENV_FLAG, __resetProjectContextCacheForTests, isFlagOn, maybeBuildProjectContext, resetProjectContextCache, } from '../maybe-build-project-context.js';
+let root;
+const originalEnv = process.env[PROJECT_CONTEXT_ENV_FLAG];
+beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-pctx-loop-'));
+    __resetProjectContextCacheForTests();
+    delete process.env[PROJECT_CONTEXT_ENV_FLAG];
+});
+afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true });
+    if (originalEnv === undefined) {
+        delete process.env[PROJECT_CONTEXT_ENV_FLAG];
+    }
+    else {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = originalEnv;
+    }
+    __resetProjectContextCacheForTests();
+});
+async function writeFile(rel, content = '') {
+    const full = path.join(root, rel);
+    await fs.mkdir(path.dirname(full), { recursive: true });
+    await fs.writeFile(full, content, 'utf-8');
+}
+describe('isFlagOn', () => {
+    it('returns false when the env var is unset', () => {
+        delete process.env[PROJECT_CONTEXT_ENV_FLAG];
+        expect(isFlagOn()).toBe(false);
+    });
+    it('returns true only for the exact value "on"', () => {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+        expect(isFlagOn()).toBe(true);
+    });
+    it('returns false for "ON", "true", "1", or any other value', () => {
+        for (const v of ['ON', 'On', 'true', '1', 'yes', 'enabled', '']) {
+            process.env[PROJECT_CONTEXT_ENV_FLAG] = v;
+            expect(isFlagOn()).toBe(false);
+        }
+    });
+});
+describe('maybeBuildProjectContext — flag off (default)', () => {
+    it('returns empty string and does no work when env var is unset', async () => {
+        await writeFile('.abapgit.xml', '<xml/>');
+        await writeFile('src/zhello.prog.abap', '');
+        const block = await maybeBuildProjectContext({ cwd: root });
+        expect(block).toBe('');
+    });
+    it('returns empty string when env var is set to a non-on value', async () => {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'true';
+        await writeFile('.abapgit.xml', '<xml/>');
+        const block = await maybeBuildProjectContext({ cwd: root });
+        expect(block).toBe('');
+    });
+});
+describe('maybeBuildProjectContext — flag on', () => {
+    beforeEach(() => {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+    });
+    it('builds a project_context block for a recognized abapgit project', async () => {
+        await writeFile('.abapgit.xml', '<xml/>');
+        await writeFile('src/zhello.prog.abap', '');
+        const block = await maybeBuildProjectContext({ cwd: root });
+        expect(block).toContain('<project_context type="abapgit">');
+        expect(block).toContain('ZHELLO');
+        expect(block).toContain('</project_context>');
+    });
+    it('builds a project_context block for an unknown directory (since 1F)', async () => {
+        // Phase 1F changed the contract: getProjectContext returns a real
+        // ProjectContext for unknown directories rather than null. The
+        // helper should surface the rendered block in that case too —
+        // the model still gets useful info (file index, git state) even
+        // without a recognized project shape.
+        await writeFile('random.txt', 'just a file');
+        const block = await maybeBuildProjectContext({ cwd: root });
+        expect(block).toContain('<project_context type="unknown">');
+    });
+    it('returns empty string when getProjectContext returns null (cwd unreadable)', async () => {
+        const block = await maybeBuildProjectContext({
+            cwd: path.join(root, 'this-does-not-exist'),
+        });
+        expect(block).toBe('');
+    });
+});
+describe('maybeBuildProjectContext — caching', () => {
+    beforeEach(() => {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+    });
+    it('caches the rendered block at module scope (one walk per process)', async () => {
+        await writeFile('.abapgit.xml', '<xml/>');
+        await writeFile('src/zalpha.prog.abap', '');
+        const first = await maybeBuildProjectContext({ cwd: root });
+        expect(first).toContain('ZALPHA');
+        // Mutate the project AFTER the first call — the cache should hide
+        // the change. (This is the documented Phase 2 behavior; the
+        // refresh-on-demand tool is Phase 3.)
+        await writeFile('src/zbeta.prog.abap', '');
+        const second = await maybeBuildProjectContext({ cwd: root });
+        expect(second).toBe(first);
+        expect(second).not.toContain('ZBETA');
+    });
+    it('caches even the empty case so a missing-cwd does not retry', async () => {
+        const bogus = path.join(root, 'nope');
+        const first = await maybeBuildProjectContext({ cwd: bogus });
+        expect(first).toBe('');
+        // Create the dir AFTER the first call — cache should still be empty.
+        await fs.mkdir(bogus, { recursive: true });
+        await fs.writeFile(path.join(bogus, '.abapgit.xml'), '<xml/>', 'utf-8');
+        const second = await maybeBuildProjectContext({ cwd: bogus });
+        expect(second).toBe('');
+    });
+    it('test-only reset hook lets tests drive the helper from a clean state', async () => {
+        await writeFile('.abapgit.xml', '<xml/>');
+        const first = await maybeBuildProjectContext({ cwd: root });
+        expect(first).not.toBe('');
+        __resetProjectContextCacheForTests();
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'off';
+        const after = await maybeBuildProjectContext({ cwd: root });
+        expect(after).toBe('');
+    });
+});
+describe('maybeBuildProjectContext — fault tolerance', () => {
+    it('does not throw on null-byte cwd (hostile input)', async () => {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+        const block = await maybeBuildProjectContext({ cwd: '\0\0\0' });
+        expect(block).toBe('');
+    });
+    it('returns empty for empty-string cwd without walking the test runner CWD', async () => {
+        // Reviewer flagged this edge case: Node fs APIs resolve '' to
+        // process.cwd(), which would silently walk wherever the test
+        // runner was launched from. The helper must reject empty cwd
+        // explicitly.
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+        const block = await maybeBuildProjectContext({ cwd: '' });
+        expect(block).toBe('');
+        // And it should not have populated the cache — a subsequent call
+        // with a real cwd must still do real work.
+        await writeFile('.abapgit.xml', '<xml/>');
+        await writeFile('src/zhello.prog.abap', '');
+        const real = await maybeBuildProjectContext({ cwd: root });
+        expect(real).toContain('<project_context type="abapgit">');
+    });
+});
+describe('error path — never-throws contract violation', () => {
+    // We use vi.spyOn on process.stderr.write rather than mocking the
+    // project-context module (which would force every other test to
+    // re-mock). The trigger is a hostile input that the helper's own
+    // logic forwards to getProjectContext; getProjectContext itself
+    // returns null on hostile input rather than throwing, so we
+    // additionally spy + force a throw via vi.spyOn on the imported
+    // function. See test below.
+    it('emits a one-shot stderr warning if getProjectContext violates never-throws', async () => {
+        const projectContextModule = await import('../../project-context/index.js');
+        const stderrWrites = [];
+        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            stderrWrites.push(typeof chunk === 'string' ? chunk : chunk.toString());
+            return true;
+        });
+        const getCtxSpy = vi
+            .spyOn(projectContextModule, 'getProjectContext')
+            .mockImplementation(async () => {
+            throw new Error('synthetic regression — never-throws contract violated');
+        });
+        try {
+            process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+            // First call — should warn, return ''.
+            const first = await maybeBuildProjectContext({ cwd: root });
+            expect(first).toBe('');
+            const warnLines = stderrWrites.filter((s) => s.includes('[project-context] disabled for this session'));
+            expect(warnLines).toHaveLength(1);
+            expect(warnLines[0]).toContain('synthetic regression');
+            // Second call — must NOT re-warn (one-shot latch). Cached '' is
+            // returned without re-calling getProjectContext.
+            const second = await maybeBuildProjectContext({ cwd: root });
+            expect(second).toBe('');
+            const warnLinesAfter = stderrWrites.filter((s) => s.includes('[project-context] disabled for this session'));
+            expect(warnLinesAfter).toHaveLength(1); // still 1, not 2
+        }
+        finally {
+            stderrSpy.mockRestore();
+            getCtxSpy.mockRestore();
+        }
+    });
+    it('public reset clears the warned-once latch so a fresh attempt can warn anew', async () => {
+        const projectContextModule = await import('../../project-context/index.js');
+        const stderrWrites = [];
+        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            stderrWrites.push(typeof chunk === 'string' ? chunk : chunk.toString());
+            return true;
+        });
+        const getCtxSpy = vi
+            .spyOn(projectContextModule, 'getProjectContext')
+            .mockImplementation(async () => {
+            throw new Error('first failure');
+        });
+        try {
+            process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+            await maybeBuildProjectContext({ cwd: root });
+            expect(stderrWrites.filter((s) => s.includes('[project-context]')).length).toBe(1);
+            // Reset clears both the cache AND the warned-once latch (per the
+            // public API's contract).
+            resetProjectContextCache();
+            getCtxSpy.mockImplementation(async () => {
+                throw new Error('second failure');
+            });
+            await maybeBuildProjectContext({ cwd: root });
+            const allWarnings = stderrWrites.filter((s) => s.includes('[project-context]'));
+            expect(allWarnings).toHaveLength(2);
+            expect(allWarnings[1]).toContain('second failure');
+        }
+        finally {
+            stderrSpy.mockRestore();
+            getCtxSpy.mockRestore();
+        }
+    });
+});
+describe('resetProjectContextCache (public API for Phase 3 refresh)', () => {
+    beforeEach(() => {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+    });
+    it('forces the next call to recompute, surfacing fresh project state', async () => {
+        await writeFile('.abapgit.xml', '<xml/>');
+        await writeFile('src/zfirst.prog.abap', '');
+        const before = await maybeBuildProjectContext({ cwd: root });
+        expect(before).toContain('ZFIRST');
+        expect(before).not.toContain('ZSECOND');
+        // Add a new object AFTER the first call. Without reset, the cache
+        // would hide it.
+        await writeFile('src/zsecond.prog.abap', '');
+        resetProjectContextCache();
+        const after = await maybeBuildProjectContext({ cwd: root });
+        expect(after).toContain('ZFIRST');
+        expect(after).toContain('ZSECOND');
+    });
+    it('is what the test-only alias delegates to (single source of truth)', async () => {
+        await writeFile('.abapgit.xml', '<xml/>');
+        await writeFile('src/zhello.prog.abap', '');
+        await maybeBuildProjectContext({ cwd: root });
+        // Both should produce the same effect: the next call recomputes.
+        __resetProjectContextCacheForTests();
+        await writeFile('src/zafter.prog.abap', '');
+        const out = await maybeBuildProjectContext({ cwd: root });
+        expect(out).toContain('ZAFTER');
+    });
+});

package/dist/agent/__tests__/project-context-injection.test.js

@@ -0,0 +1,161 @@
+/**
+ * Phase 2 of Track B — integration test for the project-context
+ * injection gate in runTurn.
+ *
+ * Covers two concerns:
+ *
+ *   1. `hasProjectContextBlock` (the dup-injection guard) — covers the
+ *      shape of the messages array (user/assistant, string/multimodal
+ *      content) the loop has to handle.
+ *
+ *   2. End-to-end behavior of the helper + guard composition: with
+ *      flag off, never inject. With flag on, inject exactly once per
+ *      session (subsequent turns short-circuit because the first turn's
+ *      injection is now visible in session.messages).
+ *
+ * We do NOT spin up a real LLM stream here. The runTurn integration
+ * surface is too wide for that to be worth the mock scaffolding. The
+ * helper + guard are the two new things Phase 2 added; they're tested
+ * in isolation. The wiring between them is one short block in loop.ts
+ * that's reviewed visually.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { hasProjectContextBlock } from '../loop.js';
+import { PROJECT_CONTEXT_ENV_FLAG, __resetProjectContextCacheForTests, maybeBuildProjectContext, } from '../maybe-build-project-context.js';
+const originalEnv = process.env[PROJECT_CONTEXT_ENV_FLAG];
+beforeEach(() => {
+    __resetProjectContextCacheForTests();
+    delete process.env[PROJECT_CONTEXT_ENV_FLAG];
+});
+afterEach(() => {
+    if (originalEnv === undefined) {
+        delete process.env[PROJECT_CONTEXT_ENV_FLAG];
+    }
+    else {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = originalEnv;
+    }
+    __resetProjectContextCacheForTests();
+});
+describe('hasProjectContextBlock', () => {
+    it('returns false on an empty session', () => {
+        expect(hasProjectContextBlock([])).toBe(false);
+    });
+    it('returns false when only assistant messages contain the block (defensive)', () => {
+        // Edge case: an assistant tool-result containing the literal string
+        // shouldn't count as "user already saw it." Phase 2 only injects on
+        // user turns, so the gate must check role.
+        expect(hasProjectContextBlock([
+            { role: 'assistant', content: 'I see <project_context type="abapgit"> in your project.' },
+        ])).toBe(false);
+    });
+    it('returns false when no message contains the block', () => {
+        expect(hasProjectContextBlock([
+            { role: 'user', content: 'just a plain message' },
+            { role: 'assistant', content: 'response' },
+            { role: 'user', content: '<session_context><package>ZFI</package></session_context>\n\nfollow-up' },
+        ])).toBe(false);
+    });
+    it('returns true when any user message contains <project_context', () => {
+        expect(hasProjectContextBlock([
+            { role: 'user', content: '<project_context type="abapgit">\n  <root>/x</root>\n</project_context>\n\nthe ask' },
+        ])).toBe(true);
+    });
+    it('returns true even when the project_context appears mid-turn (reroute case)', () => {
+        expect(hasProjectContextBlock([
+            { role: 'user', content: 'first turn — classifier injected this' },
+            { role: 'assistant', content: 'rerouted' },
+            { role: 'user', content: '<project_context type="cap-node">\n</project_context>\n\nfollow-up' },
+        ])).toBe(true);
+    });
+    it('safely handles non-string content (multimodal user message)', () => {
+        // The Anthropic messages API allows array-shaped content for
+        // multimodal turns. The current loop never produces those for the
+        // user side, but the guard must not throw if they appear.
+        expect(hasProjectContextBlock([
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            { role: 'user', content: [{ type: 'text', text: 'hello' }] },
+        ])).toBe(false);
+    });
+});
+/* ── Composition: helper + guard simulating runTurn's enrichment block ── */
+describe('Phase 2 enrichment composition (matches runTurn wiring)', () => {
+    let root;
+    beforeEach(async () => {
+        root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-pctx-int-'));
+        await fs.writeFile(path.join(root, '.abapgit.xml'), '<xml/>', 'utf-8');
+        await fs.mkdir(path.join(root, 'src'), { recursive: true });
+        await fs.writeFile(path.join(root, 'src', 'zhello.prog.abap'), '', 'utf-8');
+    });
+    afterEach(async () => {
+        await fs.rm(root, { recursive: true, force: true });
+    });
+    /**
+     * Mirrors the exact composition runTurn uses, so a regression in
+     * either helper OR the wiring shape is caught here. The test does
+     * not invoke runTurn — too much side-effect surface — but the logic
+     * being tested is the same three-line dance.
+     */
+    async function simulateEnrichment(messages, cwd, enrichedUserContent) {
+        let projectContextBlock = '';
+        if (!hasProjectContextBlock(messages)) {
+            projectContextBlock = await maybeBuildProjectContext({ cwd });
+        }
+        return projectContextBlock
+            ? `${projectContextBlock}\n\n${enrichedUserContent}`
+            : enrichedUserContent;
+    }
+    it('flag OFF: first turn — content is unchanged, no project_context prepended', async () => {
+        const messages = [];
+        const result = await simulateEnrichment(messages, root, 'create a new payment class');
+        expect(result).toBe('create a new payment class');
+        expect(result).not.toContain('<project_context');
+    });
+    it('flag ON: first turn — project_context prepended once', async () => {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+        const messages = [];
+        const result = await simulateEnrichment(messages, root, 'create a new payment class');
+        expect(result).toContain('<project_context type="abapgit">');
+        expect(result).toContain('ZHELLO');
+        expect(result).toContain('create a new payment class');
+        // Original user content is preserved verbatim after the block.
+        expect(result.endsWith('create a new payment class')).toBe(true);
+    });
+    it('flag ON: second turn — guard short-circuits, no duplicate injection', async () => {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+        const messages = [];
+        // Turn 1
+        const t1 = await simulateEnrichment(messages, root, 'first ask');
+        messages.push({ role: 'user', content: t1 });
+        messages.push({ role: 'assistant', content: 'first reply' });
+        // Turn 2
+        const t2 = await simulateEnrichment(messages, root, 'follow-up ask');
+        // Turn 2's content should NOT carry a second copy of project_context.
+        expect((t2.match(/<project_context/g) ?? []).length).toBe(0);
+        expect(t2).toBe('follow-up ask');
+    });
+    it('flag ON then OFF mid-session: still no inject on turn 2 because turn 1 has it', async () => {
+        // Realistic scenario: user starts session with flag on, exits the
+        // process or unsets the flag, comes back to the resumed session.
+        // The guard relies on session.messages, not the env var, so the
+        // resumed session keeps the block from turn 1 and doesn't try to
+        // re-add. (The cache is process-lifetime, so a fresh process with
+        // flag off won't even build the block.)
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+        const messages = [];
+        const t1 = await simulateEnrichment(messages, root, 'first');
+        messages.push({ role: 'user', content: t1 });
+        delete process.env[PROJECT_CONTEXT_ENV_FLAG];
+        __resetProjectContextCacheForTests();
+        const t2 = await simulateEnrichment(messages, root, 'second');
+        expect(t2).toBe('second');
+    });
+    it('flag ON: detection-fails path — no injection, content unchanged', async () => {
+        process.env[PROJECT_CONTEXT_ENV_FLAG] = 'on';
+        const messages = [];
+        const result = await simulateEnrichment(messages, '\0\0\0', 'the ask');
+        expect(result).toBe('the ask');
+    });
+});

package/dist/agent/__tests__/repair-partial.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect } from 'vitest';
+import { repairPartialBlocks } from '../repair-partial.js';
+describe('repairPartialBlocks', () => {
+    it('keeps complete tool_use blocks (input parsed)', () => {
+        const blocks = [
+            { type: 'tool_use', name: 'sap_sql_query', input: { query: 'SELECT 1' } },
+        ];
+        expect(repairPartialBlocks(blocks)).toEqual(blocks);
+    });
+    it('drops tool_use blocks whose partial_json never finished parsing', () => {
+        const blocks = [
+            { type: 'tool_use', name: 'sap_sql_query', partial_json: '{"query":"SELECT * F' },
+        ];
+        expect(repairPartialBlocks(blocks)).toEqual([]);
+    });
+    it('drops tool_use blocks with neither input nor partial_json', () => {
+        const blocks = [
+            { type: 'tool_use', name: 'sap_sql_query' },
+        ];
+        expect(repairPartialBlocks(blocks)).toEqual([]);
+    });
+    it('keeps text blocks even if truncated mid-sentence', () => {
+        const blocks = [
+            { type: 'text', text: 'Starting analysis. The package contains 14 obj' },
+        ];
+        expect(repairPartialBlocks(blocks)).toEqual(blocks);
+    });
+    it('keeps thinking blocks for next-turn context preservation', () => {
+        const blocks = [
+            { type: 'thinking', thinking: 'Let me check TADIR for...' },
+        ];
+        expect(repairPartialBlocks(blocks)).toEqual(blocks);
+    });
+    it('handles a realistic mixed-content interruption', () => {
+        const blocks = [
+            { type: 'thinking', thinking: 'Plan: probe TDEVC, then TADIR.' },
+            { type: 'text', text: 'Running the package validation now.' },
+            // Two tool calls — the first completed, the second was mid-stream when
+            // the connection dropped.
+            { type: 'tool_use', name: 'sap_sql_query', input: { query: 'SELECT * FROM TDEVC' } },
+            { type: 'tool_use', name: 'sap_sql_query', partial_json: '{"query":"SEL' },
+        ];
+        expect(repairPartialBlocks(blocks)).toEqual([
+            { type: 'thinking', thinking: 'Plan: probe TDEVC, then TADIR.' },
+            { type: 'text', text: 'Running the package validation now.' },
+            { type: 'tool_use', name: 'sap_sql_query', input: { query: 'SELECT * FROM TDEVC' } },
+        ]);
+    });
+    it('returns empty array unchanged', () => {
+        expect(repairPartialBlocks([])).toEqual([]);
+    });
+    it('skips null / non-object entries defensively', () => {
+        const blocks = [
+            null,
+            undefined,
+            'not-a-block',
+            { type: 'text', text: 'real block' },
+        ];
+        expect(repairPartialBlocks(blocks)).toEqual([
+            { type: 'text', text: 'real block' },
+        ]);
+    });
+    it('REGRESSION: simulates the lost ZDPR_PAYMENTS turn — assistant message survives the crash', () => {
+        // Simulates the captured-from-disk state of session 17c04ce8: the model
+        // was streaming the final consulting report when Undici closed the HTTP
+        // stream. Accumulated content held a thinking block + the partial report
+        // text. No tool_use was in flight at that exact moment.
+        const blocks = [
+            { type: 'thinking', thinking: 'Synthesise findings for ZPAYMENTS / ZPAYMENTS_OLD.' },
+            { type: 'text', text: '## ABAP CCA — ZDPR_PAYMENTS\n\n## TL;DR\n\nHeadline: 13-object package...' },
+        ];
+        const repaired = repairPartialBlocks(blocks);
+        // Both blocks survive — the user's report text is recovered for resume.
+        expect(repaired).toHaveLength(2);
+        expect(repaired[0]?.type).toBe('thinking');
+        expect(repaired[1]?.type).toBe('text');
+        expect(repaired[1]?.text).toContain('ZDPR_PAYMENTS');
+    });
+});

package/dist/agent/__tests__/retry-key.test.js

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import { objectKeyFromInput } from '../retry-key.js';
+describe('objectKeyFromInput', () => {
+    describe('object-identifying tools (preserves original semantics)', () => {
+        it('keys by tool:name:type when both present', () => {
+            const k = objectKeyFromInput('sap_set_source', { name: 'ZFOO', type: 'PROG' });
+            expect(k).toBe('sap_set_source:ZFOO:PROG');
+        });
+        it('keys by tool:name: when only name present', () => {
+            const k = objectKeyFromInput('sap_activate', { name: 'ZBAR' });
+            expect(k).toBe('sap_activate:ZBAR:');
+        });
+        it('keys by tool::type when only type present', () => {
+            const k = objectKeyFromInput('sap_search_object', { type: 'CLAS' });
+            expect(k).toBe('sap_search_object::CLAS');
+        });
+        it('repeated calls with same name+type return identical keys (failure accumulation)', () => {
+            const k1 = objectKeyFromInput('sap_get_source', { name: 'ZBAZ', type: 'CLAS' });
+            const k2 = objectKeyFromInput('sap_get_source', { name: 'ZBAZ', type: 'CLAS' });
+            expect(k1).toBe(k2);
+        });
+    });
+    describe('object_name / object_type alternates', () => {
+        it('falls back to object_name when name absent', () => {
+            const k = objectKeyFromInput('sap_atc_run', { object_name: 'ZQUX', object_type: 'PROG' });
+            expect(k).toBe('sap_atc_run:ZQUX:PROG');
+        });
+        it('mixes name + object_type when only one alternate present', () => {
+            const k = objectKeyFromInput('sap_atc_run', { name: 'ZA', object_type: 'CLAS' });
+            expect(k).toBe('sap_atc_run:ZA:CLAS');
+        });
+    });
+    describe('argument-only tools (the bug fix)', () => {
+        it('different sap_sql_query queries get DIFFERENT keys', () => {
+            const k1 = objectKeyFromInput('sap_sql_query', { query: 'SELECT * FROM /SDF/MON_RECS' });
+            const k2 = objectKeyFromInput('sap_sql_query', { query: 'SELECT * FROM /SDF/MON_HEADER' });
+            const k3 = objectKeyFromInput('sap_sql_query', { query: 'SELECT * FROM ZQLREC' });
+            expect(k1).not.toBe(k2);
+            expect(k2).not.toBe(k3);
+            expect(k1).not.toBe(k3);
+        });
+        it('same sap_sql_query repeated returns the SAME key (still cap-able)', () => {
+            const args = { query: 'SELECT * FROM /SDF/MON_RECS' };
+            const k1 = objectKeyFromInput('sap_sql_query', args);
+            const k2 = objectKeyFromInput('sap_sql_query', args);
+            expect(k1).toBe(k2);
+        });
+        it('hash-fallback keys are namespaced by tool name', () => {
+            const sql = objectKeyFromInput('sap_sql_query', { query: 'SELECT 1 FROM DUAL' });
+            const search = objectKeyFromInput('sap_search_object', { query: 'SELECT 1 FROM DUAL' });
+            expect(sql).not.toBe(search);
+            expect(sql.startsWith('sap_sql_query:#')).toBe(true);
+            expect(search.startsWith('sap_search_object:#')).toBe(true);
+        });
+        it('empty args still produce a stable key per tool', () => {
+            const k1 = objectKeyFromInput('some_tool', {});
+            const k2 = objectKeyFromInput('some_tool', {});
+            expect(k1).toBe(k2);
+            expect(k1.startsWith('some_tool:#')).toBe(true);
+        });
+    });
+    describe('regression — the original bug', () => {
+        it('three different probe queries do NOT collapse onto one key', () => {
+            // Reproduce the exact failure from the live /abap-cca DISCOVER trip.
+            const probes = [
+                { query: 'SELECT * FROM "/SDF/MON_RECS"' },
+                { query: 'SELECT * FROM "/SDF/MON_HEADER"' },
+                { query: 'SELECT * FROM ZQLREC' },
+            ];
+            const keys = probes.map((p) => objectKeyFromInput('sap_sql_query', p));
+            const unique = new Set(keys);
+            // Pre-fix: all three keys were `sap_sql_query::` → set size 1 → cap tripped after 3 distinct probes.
+            // Post-fix: each probe gets its own hash → set size 3.
+            expect(unique.size).toBe(3);
+        });
+    });
+});