@cspeach/cli 0.6.2 → 0.6.4

package/dist/projects/__tests__/workspace.test.js

@@ -0,0 +1,337 @@
+import { afterAll, beforeAll, describe, it, expect } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import os from 'node:os';
+import { detectDesignShape, resolveAtToken, formatProjectFileList, findProjectRoot, defaultWorkspaceFor } from '../workspace.js';
+const FILES = [
+    {
+        path: '/ws/customer-aging-design-fd79-v1.cspeach.json',
+        filename: 'customer-aging-design-fd79-v1.cspeach.json',
+        kind: 'envelope',
+        artefactType: 'design',
+        version: 1,
+        title: 'Customer Aging',
+        sizeBytes: 4321,
+        mtimeMs: 1_700_000_000_000,
+    },
+    {
+        path: '/ws/sales-order-spec-gap-b9b0-v2.cspeach.json',
+        filename: 'sales-order-spec-gap-b9b0-v2.cspeach.json',
+        kind: 'envelope',
+        artefactType: 'spec-gap',
+        version: 2,
+        title: 'Sales Order',
+        sizeBytes: 8765,
+        mtimeMs: 1_700_000_500_000,
+    },
+    {
+        path: '/ws/sales-order-design-b9b0-v1.cspeach.json',
+        filename: 'sales-order-design-b9b0-v1.cspeach.json',
+        kind: 'envelope',
+        artefactType: 'design',
+        version: 1,
+        title: 'Sales Order',
+        sizeBytes: 5432,
+        mtimeMs: 1_700_000_900_000,
+    },
+    {
+        path: '/ws/customer-aging-spec.txt',
+        filename: 'customer-aging-spec.txt',
+        kind: 'text',
+        artefactType: 'unknown',
+        version: null,
+        title: null,
+        sizeBytes: 1200,
+        mtimeMs: 1_700_001_000_000,
+    },
+];
+describe('resolveAtToken', () => {
+    it('returns absolute paths verbatim — no workspace lookup', () => {
+        const r = resolveAtToken({
+            token: '/abs/path/to/file.cspeach.json',
+            cwd: '/some/cwd',
+            workspace: '/ws',
+            files: FILES,
+        });
+        expect(r).toEqual({ kind: 'path', path: '/abs/path/to/file.cspeach.json' });
+    });
+    it('returns Windows absolute paths verbatim', () => {
+        const r = resolveAtToken({
+            token: 'C:\\Users\\test\\file.cspeach.json',
+            cwd: 'C:\\cwd',
+            workspace: 'C:\\ws',
+            files: FILES,
+        });
+        // path.isAbsolute on Windows recognizes C:\... — on POSIX it does not.
+        // We only assert that on Windows the kind is 'path' and the path
+        // matches exactly. On POSIX this token would route through the
+        // path-with-slash branch instead.
+        if (process.platform === 'win32') {
+            expect(r.kind).toBe('path');
+            if (r.kind === 'path')
+                expect(r.path).toBe('C:\\Users\\test\\file.cspeach.json');
+        }
+    });
+    it('treats ./ and ../ tokens as cwd-relative', () => {
+        const r = resolveAtToken({
+            token: './foo.cspeach.json',
+            cwd: '/home/me',
+            workspace: '/ws',
+            files: FILES,
+        });
+        expect(r.kind).toBe('path');
+        if (r.kind === 'path') {
+            // path.join normalises ./ away on POSIX and produces backslashes on
+            // Windows — assert via endsWith on the platform-correct fragment.
+            expect(r.path.endsWith(join('home', 'me', 'foo.cspeach.json'))).toBe(true);
+        }
+    });
+    it('finds a unique match by substring on bare tokens', () => {
+        const r = resolveAtToken({
+            token: 'customer-aging-design',
+            cwd: '/cwd',
+            workspace: '/ws',
+            files: FILES,
+        });
+        expect(r).toEqual({
+            kind: 'path',
+            path: '/ws/customer-aging-design-fd79-v1.cspeach.json',
+        });
+    });
+    it('matches case-insensitively', () => {
+        const r = resolveAtToken({
+            token: 'CUSTOMER-AGING-DESIGN',
+            cwd: '/cwd',
+            workspace: '/ws',
+            files: FILES,
+        });
+        expect(r.kind).toBe('path');
+    });
+    it('returns ambiguous when multiple files match', () => {
+        const r = resolveAtToken({
+            token: 'sales-order',
+            cwd: '/cwd',
+            workspace: '/ws',
+            files: FILES,
+        });
+        expect(r.kind).toBe('ambiguous');
+        if (r.kind === 'ambiguous') {
+            expect(r.matches).toHaveLength(2);
+            expect(r.matches.map((m) => m.filename).sort()).toEqual([
+                'sales-order-design-b9b0-v1.cspeach.json',
+                'sales-order-spec-gap-b9b0-v2.cspeach.json',
+            ]);
+        }
+    });
+    it('returns notFound when no file matches', () => {
+        const r = resolveAtToken({
+            token: 'nonexistent',
+            cwd: '/cwd',
+            workspace: '/ws',
+            files: FILES,
+        });
+        expect(r).toEqual({ kind: 'notFound', token: 'nonexistent', workspace: '/ws' });
+    });
+    it('finds by an internal id fragment', () => {
+        // Generated filenames include a random id like b9b0; users should
+        // be able to type just that fragment.
+        const r = resolveAtToken({
+            token: 'fd79',
+            cwd: '/cwd',
+            workspace: '/ws',
+            files: FILES,
+        });
+        expect(r.kind).toBe('path');
+        if (r.kind === 'path') {
+            expect(r.path).toBe('/ws/customer-aging-design-fd79-v1.cspeach.json');
+        }
+    });
+    it('treats embedded slashes as cwd-relative paths', () => {
+        const r = resolveAtToken({
+            token: 'subdir/file.cspeach.json',
+            cwd: '/home/me',
+            workspace: '/ws',
+            files: FILES,
+        });
+        expect(r.kind).toBe('path');
+        if (r.kind === 'path') {
+            // Platform-correct separator from path.join (\\ on Windows, / on POSIX).
+            expect(r.path.endsWith(join('subdir', 'file.cspeach.json'))).toBe(true);
+        }
+    });
+    it('returns notFound with empty workspace', () => {
+        const r = resolveAtToken({
+            token: 'anything',
+            cwd: '/cwd',
+            workspace: '/ws',
+            files: [],
+        });
+        expect(r.kind).toBe('notFound');
+    });
+});
+describe('formatProjectFileList', () => {
+    it('renders an empty workspace with a hint', () => {
+        const out = formatProjectFileList([], '/ws');
+        expect(out).toContain('Workspace: /ws');
+        expect(out).toContain('empty');
+    });
+    it('renders files with type, version, and a usage hint', () => {
+        const out = formatProjectFileList(FILES, '/ws');
+        expect(out).toContain('Workspace: /ws');
+        expect(out).toContain('customer-aging-design-fd79-v1.cspeach.json');
+        expect(out).toContain('design');
+        expect(out).toContain('v1');
+        expect(out).toContain('Use @<partial-name>');
+        expect(out).toContain('4 file(s)');
+    });
+    it('renders text files with a "text" tag and byte size', () => {
+        const out = formatProjectFileList(FILES, '/ws');
+        expect(out).toContain('customer-aging-spec.txt');
+        expect(out).toContain('text');
+        // 1200 bytes → "1 KB" (rounded)
+        expect(out).toMatch(/customer-aging-spec\.txt[\s\S]*1 KB/);
+    });
+    it('finds bare-name matches across both envelope and text kinds', () => {
+        const r = resolveAtToken({
+            token: 'customer-aging-spec',
+            cwd: '/cwd',
+            workspace: '/ws',
+            files: FILES,
+        });
+        expect(r.kind).toBe('path');
+        if (r.kind === 'path') {
+            expect(r.path).toBe('/ws/customer-aging-spec.txt');
+        }
+    });
+});
+describe('detectDesignShape', () => {
+    let tmpDir;
+    beforeAll(() => {
+        tmpDir = mkdtempSync(join(os.tmpdir(), 'cspeach-detect-shape-'));
+    });
+    afterAll(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function writeEnvelope(name, content) {
+        const path = join(tmpDir, name);
+        writeFileSync(path, JSON.stringify({ artefactType: 'design', content }));
+        return path;
+    }
+    it('returns "rap" when an object type contains Behavior Definition', () => {
+        const p = writeEnvelope('rap-bdef.json', {
+            objects: [
+                { id: 'o1', name: 'ZTBL', type: 'TABL' },
+                { id: 'o2', name: 'ZBDEF_ORDER', type: 'Behavior Definition (BDEF)' },
+            ],
+        });
+        expect(detectDesignShape(p)).toBe('rap');
+    });
+    it('returns "rap" when only a Service Binding is present', () => {
+        const p = writeEnvelope('rap-srvb.json', {
+            objects: [
+                { id: 'o1', name: 'ZBND_ORDER_UI_V4', type: 'Service Binding' },
+            ],
+        });
+        expect(detectDesignShape(p)).toBe('rap');
+    });
+    it('returns "rap" for the abbreviated SRVD marker', () => {
+        const p = writeEnvelope('rap-srvd.json', {
+            objects: [
+                { id: 'o1', name: 'ZSRV_ORDER', type: 'SRVD' },
+            ],
+        });
+        expect(detectDesignShape(p)).toBe('rap');
+    });
+    it('returns "classic" for a report + class + interface design', () => {
+        const p = writeEnvelope('classic.json', {
+            objects: [
+                { id: 'o1', name: 'ZSD_R_OPEN_ORDERS', type: 'PROG (executable)' },
+                { id: 'o2', name: 'ZCL_SD_OPEN_ORDERS', type: 'CLAS (global class)' },
+                { id: 'o3', name: 'ZIF_SD_OPEN_ORDERS', type: 'INTF' },
+                { id: 'o4', name: 'ZI_SO_OPEN', type: 'DDLS (CDS interface view)' },
+            ],
+        });
+        expect(detectDesignShape(p)).toBe('classic');
+    });
+    it('returns "unknown" when content.objects is missing', () => {
+        const p = writeEnvelope('no-objects.json', {});
+        expect(detectDesignShape(p)).toBe('unknown');
+    });
+    it('returns "unknown" when content.objects is empty', () => {
+        const p = writeEnvelope('empty-objects.json', { objects: [] });
+        expect(detectDesignShape(p)).toBe('unknown');
+    });
+    it('returns "unknown" on malformed JSON', () => {
+        const p = join(tmpDir, 'bad.json');
+        writeFileSync(p, '{this is not JSON');
+        expect(detectDesignShape(p)).toBe('unknown');
+    });
+    it('returns "unknown" on missing file', () => {
+        expect(detectDesignShape(join(tmpDir, 'does-not-exist.json'))).toBe('unknown');
+    });
+    it('matches case-insensitively on the type field', () => {
+        const p = writeEnvelope('rap-mixed-case.json', {
+            objects: [
+                { id: 'o1', name: 'ZBP_ORDER', type: 'abap behavior pool' },
+            ],
+        });
+        expect(detectDesignShape(p)).toBe('rap');
+    });
+});
+describe('findProjectRoot', () => {
+    let tmpDir;
+    beforeAll(() => {
+        tmpDir = mkdtempSync(join(os.tmpdir(), 'cspeach-find-root-'));
+    });
+    afterAll(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('returns the dir containing .git when invoked there', () => {
+        const root = join(tmpDir, 'repo-1');
+        mkdirSync(root, { recursive: true });
+        mkdirSync(join(root, '.git'), { recursive: true });
+        expect(findProjectRoot(root)).toBe(root);
+    });
+    it('walks up from a deep subdirectory to the .git dir', () => {
+        const root = join(tmpDir, 'repo-2');
+        const deep = join(root, 'a', 'b', 'c', 'd');
+        mkdirSync(deep, { recursive: true });
+        mkdirSync(join(root, '.git'), { recursive: true });
+        expect(findProjectRoot(deep)).toBe(root);
+    });
+    it('finds a .git FILE (submodule case), not just .git dir', () => {
+        const root = join(tmpDir, 'repo-3');
+        const deep = join(root, 'sub');
+        mkdirSync(deep, { recursive: true });
+        writeFileSync(join(root, '.git'), 'gitdir: ../parent-repo/.git/modules/repo-3\n');
+        expect(findProjectRoot(deep)).toBe(root);
+    });
+    it('returns null when no .git is found anywhere up the tree', () => {
+        const orphan = join(tmpDir, 'no-git', 'deep');
+        mkdirSync(orphan, { recursive: true });
+        // No .git anywhere under tmpDir hierarchy except sibling dirs above.
+        // The walk hits the OS filesystem root without matching.
+        expect(findProjectRoot(orphan)).toBe(null);
+    });
+});
+describe('defaultWorkspaceFor', () => {
+    let tmpDir;
+    beforeAll(() => {
+        tmpDir = mkdtempSync(join(os.tmpdir(), 'cspeach-default-ws-'));
+    });
+    afterAll(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('returns <git-root>/.cspeach when cwd is inside a git repo', () => {
+        const root = join(tmpDir, 'repo');
+        const deep = join(root, 'sub', 'sub2');
+        mkdirSync(deep, { recursive: true });
+        mkdirSync(join(root, '.git'), { recursive: true });
+        expect(defaultWorkspaceFor(deep)).toBe(join(root, '.cspeach'));
+    });
+    it('falls back to <cwd>/.cspeach when no git root exists', () => {
+        const orphan = join(tmpDir, 'no-git-here');
+        mkdirSync(orphan, { recursive: true });
+        expect(defaultWorkspaceFor(orphan)).toBe(join(orphan, '.cspeach'));
+    });
+});

package/dist/repl/__tests__/current-transport.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { getCurrentTransport, setCurrentTransport, clearCurrentTransport, handleTransportCommand, } from '../current-transport.js';
+describe('current-transport', () => {
+    beforeEach(() => clearCurrentTransport());
+    it('getCurrentTransport() returns null on initial state', () => {
+        expect(getCurrentTransport()).toBeNull();
+    });
+    it('setCurrentTransport then getCurrentTransport returns the trkorr', () => {
+        setCurrentTransport('DEVK900123');
+        expect(getCurrentTransport()).toBe('DEVK900123');
+    });
+    it('clearCurrentTransport resets state to null', () => {
+        setCurrentTransport('DEVK900123');
+        clearCurrentTransport();
+        expect(getCurrentTransport()).toBeNull();
+    });
+    it('handleTransportCommand("") returns "No current transport set" when null', () => {
+        const msg = handleTransportCommand('');
+        expect(msg).toMatch(/No current transport set/);
+    });
+    it('handleTransportCommand("") returns "Current transport: TRKORR" when set', () => {
+        setCurrentTransport('DEVK900456');
+        const msg = handleTransportCommand('');
+        expect(msg).toBe('Current transport: DEVK900456');
+    });
+    it('handleTransportCommand("<trkorr>") sets transport and returns confirmation', () => {
+        const msg = handleTransportCommand('DEVK900123');
+        expect(getCurrentTransport()).toBe('DEVK900123');
+        expect(msg).toBe('Current transport set to DEVK900123.');
+    });
+    it('handleTransportCommand("clear") (lowercase) clears and returns confirmation', () => {
+        setCurrentTransport('DEVK900123');
+        const msg = handleTransportCommand('clear');
+        expect(getCurrentTransport()).toBeNull();
+        expect(msg).toBe('Current transport cleared.');
+    });
+    it('handleTransportCommand("CLEAR") (uppercase) also clears — case-insensitive', () => {
+        setCurrentTransport('DEVK900123');
+        const msg = handleTransportCommand('CLEAR');
+        expect(getCurrentTransport()).toBeNull();
+        expect(msg).toBe('Current transport cleared.');
+    });
+});

package/dist/repl/__tests__/diff-display.test.js

@@ -0,0 +1,59 @@
+// chalk strips colors when stdout isn't a TTY (vitest is not). Force colors
+// ON before chalk is imported so the ANSI assertions below are meaningful.
+process.env.FORCE_COLOR = '1';
+import { describe, it, expect } from 'vitest';
+import { renderDiff } from '../diff-display.js';
+describe('renderDiff', () => {
+    it('renders unified diff with header when sources differ', () => {
+        const out = renderDiff('foo\nbar', 'foo\nbaz', {
+            label: 'method dispatch',
+            syntaxHighlight: false,
+        });
+        // diff library uses \t between filename and header; assert via a regex
+        // that allows either tab or space and includes the label + role.
+        expect(out).toMatch(/^--- method dispatch[\s]+\(current\)/m);
+        expect(out).toMatch(/^\+\+\+ method dispatch[\s]+\(proposed\)/m);
+        expect(out).toMatch(/-bar/);
+        expect(out).toMatch(/\+baz/);
+    });
+    it('returns "No changes" message when sources are identical', () => {
+        const out = renderDiff('same\nsame', 'same\nsame', {
+            label: 'identity',
+            syntaxHighlight: false,
+        });
+        expect(out).toContain('No changes');
+        expect(out).toContain('identity');
+    });
+    it('strips ANSI when syntaxHighlight is false', () => {
+        const out = renderDiff('a', 'b', { label: 'x', syntaxHighlight: false });
+        // eslint-disable-next-line no-control-regex
+        expect(out).not.toMatch(/\x1b\[3[12]m/);
+    });
+    it('applies green/red ANSI when syntaxHighlight is true', () => {
+        const out = renderDiff('a', 'b', { label: 'x', syntaxHighlight: true });
+        // eslint-disable-next-line no-control-regex
+        expect(out).toMatch(/\x1b\[31m-a/);
+        // eslint-disable-next-line no-control-regex
+        expect(out).toMatch(/\x1b\[32m\+b/);
+    });
+    it('applies cyan ANSI to @@ hunk headers when syntaxHighlight is true', () => {
+        const out = renderDiff('line1\nline2\nline3', 'line1\nCHANGED\nline3', {
+            label: 'hunk',
+            syntaxHighlight: true,
+        });
+        // eslint-disable-next-line no-control-regex
+        expect(out).toMatch(/\x1b\[36m@@/);
+    });
+    it('does not colorize the +++ / --- file header lines', () => {
+        const out = renderDiff('a', 'b', { label: 'x', syntaxHighlight: true });
+        // The header lines should be plain, not green/red.
+        const headerCurrent = out.split('\n').find((l) => l.startsWith('--- x'));
+        const headerProposed = out.split('\n').find((l) => l.startsWith('+++ x'));
+        expect(headerCurrent).toBeDefined();
+        expect(headerProposed).toBeDefined();
+        // eslint-disable-next-line no-control-regex
+        expect(headerCurrent).not.toMatch(/\x1b\[31m/);
+        // eslint-disable-next-line no-control-regex
+        expect(headerProposed).not.toMatch(/\x1b\[32m/);
+    });
+});

package/dist/repl/__tests__/file-picker.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock @inquirer/prompts via vi.hoisted — same pattern as
+// safety-confirm.test.ts. The picker uses `search` for step 1 and
+// `select` for step 2; both are mocked independently so each test
+// can control which step fires.
+const searchMock = vi.hoisted(() => vi.fn());
+const selectMock = vi.hoisted(() => vi.fn());
+vi.mock('@inquirer/prompts', () => ({
+    search: searchMock,
+    select: selectMock,
+    __esModule: true,
+}));
+// Mock withInquirer as a pass-through — the real implementation
+// pauses the registered readline, but in unit tests there is no
+// registered readline and no stdin to manage.
+vi.mock('../inquirer-guard.js', () => ({
+    withInquirer: (fn) => fn(),
+    __esModule: true,
+}));
+// Mock the workspace helpers — listProjectFiles returns a controlled
+// fixture, detectDesignShape reports whatever the test wants.
+const listMock = vi.hoisted(() => vi.fn());
+const detectMock = vi.hoisted(() => vi.fn());
+vi.mock('../../projects/workspace.js', () => ({
+    listProjectFiles: listMock,
+    detectDesignShape: detectMock,
+    __esModule: true,
+}));
+const FILES = [
+    {
+        path: '/ws/sales-order-design-fd79-v1.cspeach.json',
+        filename: 'sales-order-design-fd79-v1.cspeach.json',
+        kind: 'envelope',
+        artefactType: 'design',
+        version: 1,
+        title: 'Sales Order',
+        sizeBytes: 4321,
+        mtimeMs: 1_700_000_000_000,
+    },
+];
+describe('openFilePicker', () => {
+    beforeEach(() => {
+        searchMock.mockReset();
+        selectMock.mockReset();
+        listMock.mockReset();
+        detectMock.mockReset();
+        detectMock.mockReturnValue('classic');
+    });
+    it('returns kind:"empty" when the workspace has no files', async () => {
+        listMock.mockResolvedValue([]);
+        const { openFilePicker } = await import('../file-picker.js');
+        const result = await openFilePicker();
+        expect(result).toEqual({ kind: 'empty' });
+        // search and select must NOT have been called — picker short-circuits
+        // before opening any inquirer prompt.
+        expect(searchMock).not.toHaveBeenCalled();
+        expect(selectMock).not.toHaveBeenCalled();
+    });
+    it('returns kind:"cancelled" when the file-search step is cancelled', async () => {
+        listMock.mockResolvedValue(FILES);
+        searchMock.mockResolvedValue('__cspeach_cancel__');
+        const { openFilePicker } = await import('../file-picker.js');
+        const result = await openFilePicker();
+        expect(result).toEqual({ kind: 'cancelled' });
+        expect(selectMock).not.toHaveBeenCalled();
+    });
+    it('returns kind:"cancelled" when the action-select step is cancelled', async () => {
+        listMock.mockResolvedValue(FILES);
+        searchMock.mockResolvedValue(FILES[0].filename);
+        selectMock.mockResolvedValue('__cspeach_cancel__');
+        const { openFilePicker } = await import('../file-picker.js');
+        const result = await openFilePicker();
+        expect(result).toEqual({ kind: 'cancelled' });
+    });
+    it('returns kind:"cancelled" when withInquirer throws (simulates Ctrl+C)', async () => {
+        listMock.mockResolvedValue(FILES);
+        searchMock.mockRejectedValue(new Error('User aborted'));
+        const { openFilePicker } = await import('../file-picker.js');
+        const result = await openFilePicker();
+        expect(result).toEqual({ kind: 'cancelled' });
+    });
+    it('returns kind:"command" with the synthesized slash command on a successful pick', async () => {
+        listMock.mockResolvedValue(FILES);
+        searchMock.mockResolvedValue(FILES[0].filename);
+        selectMock.mockResolvedValue('/abap-rap --from');
+        detectMock.mockReturnValue('rap');
+        const { openFilePicker } = await import('../file-picker.js');
+        const result = await openFilePicker();
+        expect(result).toEqual({
+            kind: 'command',
+            command: '/abap-rap --from @sales-order-design-fd79-v1.cspeach.json',
+        });
+        // detectDesignShape should be called for design envelopes so the
+        // action menu can recommend the right BUILD skill.
+        expect(detectMock).toHaveBeenCalledWith(FILES[0].path);
+    });
+});

package/dist/repl/__tests__/rule8-detector.test.js

@@ -0,0 +1,114 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { recordWriteOp, shouldGateRule8, resetRule8State, getWriteOpsThisTurn, renderPlanSummary, } from '../rule8-detector.js';
+// Module-scope singleton — must reset between tests to prevent leakage.
+beforeEach(() => resetRule8State());
+describe('rule8-detector — initial state', () => {
+    it('shouldGateRule8() returns false on a fresh turn', () => {
+        expect(shouldGateRule8()).toBe(false);
+    });
+    it('getWriteOpsThisTurn() is empty on a fresh turn', () => {
+        expect(getWriteOpsThisTurn().length).toBe(0);
+    });
+});
+describe('rule8-detector — after 1 recordWriteOp', () => {
+    it('shouldGateRule8() returns true after first write (gate fires on 2nd call)', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO' });
+        expect(shouldGateRule8()).toBe(true);
+    });
+    it('getWriteOpsThisTurn().length === 1', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO' });
+        expect(getWriteOpsThisTurn().length).toBe(1);
+    });
+    it('recorded op has correct tool and args', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO' });
+        const ops = getWriteOpsThisTurn();
+        expect(ops[0].tool).toBe('sap_set_source');
+        expect(ops[0].args).toEqual({ type: 'CLAS', name: 'ZCL_FOO' });
+    });
+    it('recorded op has a valid ISO timestamp', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO' });
+        const ops = getWriteOpsThisTurn();
+        expect(ops[0].ts).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+    });
+});
+describe('rule8-detector — after 2 recordWriteOps', () => {
+    it('shouldGateRule8() still returns true', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO' });
+        recordWriteOp('sap_create_object', { type: 'CLAS', name: 'ZCL_BAR' });
+        expect(shouldGateRule8()).toBe(true);
+    });
+    it('getWriteOpsThisTurn().length === 2', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO' });
+        recordWriteOp('sap_create_object', { type: 'CLAS', name: 'ZCL_BAR' });
+        expect(getWriteOpsThisTurn().length).toBe(2);
+    });
+});
+describe('rule8-detector — resetRule8State', () => {
+    it('clears the write-ops list', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO' });
+        resetRule8State();
+        expect(getWriteOpsThisTurn().length).toBe(0);
+    });
+    it('shouldGateRule8() returns false after reset', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO' });
+        resetRule8State();
+        expect(shouldGateRule8()).toBe(false);
+    });
+});
+describe('rule8-detector — renderPlanSummary', () => {
+    it('with no prior writes, summary has count=1 and shows proposed-next only', () => {
+        const summary = renderPlanSummary({ tool: 'sap_create_object', args: { type: 'CLAS', name: 'ZCL_NEW' } });
+        expect(summary).toContain('1 write ops this turn');
+        expect(summary).toContain('sap_create_object');
+        expect(summary).toContain('CLAS ZCL_NEW');
+        expect(summary).toContain('← about to dispatch');
+        // No prior entries — only the proposed-next line should appear
+        expect(summary.split('\n').filter((l) => l.includes('← about to dispatch')).length).toBe(1);
+    });
+    it('with 1 prior write, summary has count=2 and lists the prior op and proposed-next', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO', transport: 'DEVK900001' });
+        const summary = renderPlanSummary({ tool: 'sap_create_object', args: { type: 'INTF', name: 'ZIF_BAR' } });
+        expect(summary).toContain('2 write ops this turn');
+        // Prior write appears without the arrow marker
+        expect(summary).toContain('sap_set_source');
+        expect(summary).toContain('CLAS ZCL_FOO');
+        expect(summary).toContain('transport: DEVK900001');
+        // Proposed next
+        expect(summary).toContain('sap_create_object');
+        expect(summary).toContain('INTF ZIF_BAR');
+        expect(summary).toContain('← about to dispatch');
+    });
+    it('with 2 prior writes, summary has count=3 and shows all prior ops and proposed-next', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO' });
+        recordWriteOp('sap_create_object', { type: 'TABL', name: 'ZORDERS' });
+        const summary = renderPlanSummary({ tool: 'sap_activate', args: { type: 'CLAS', name: 'ZCL_FOO' } });
+        expect(summary).toContain('3 write ops this turn');
+        expect(summary).toContain('sap_set_source');
+        expect(summary).toContain('sap_create_object');
+        expect(summary).toContain('sap_activate');
+        expect(summary).toContain('← about to dispatch');
+    });
+    it('summarizeArgs with class_name+method_name fields formats correctly', () => {
+        const summary = renderPlanSummary({
+            tool: 'sap_update_method',
+            args: { class_name: 'ZCL_FOO', method_name: 'do_work', transport: 'DEVK900002' },
+        });
+        expect(summary).toContain('ZCL_FOO->do_work');
+        expect(summary).toContain('transport: DEVK900002');
+    });
+    it('summarizeArgs with no recognisable key fields falls back to "(no key args)"', () => {
+        const summary = renderPlanSummary({ tool: 'sap_activate', args: {} });
+        expect(summary).toContain('(no key args)');
+    });
+});
+describe('rule8-detector — getWriteOpsThisTurn is read-only', () => {
+    it('returns a ReadonlyArray (cannot mutate via the returned reference)', () => {
+        recordWriteOp('sap_set_source', { type: 'CLAS', name: 'ZCL_FOO' });
+        const ops = getWriteOpsThisTurn();
+        // TypeScript will prevent .push at compile time; at runtime the reference
+        // points to the internal array. We test that the length stays stable.
+        expect(ops.length).toBe(1);
+        // A second call returns the updated reference (length 1 still — no extra push)
+        expect(getWriteOpsThisTurn().length).toBe(1);
+    });
+});