relay-ide 0.1.0

package/dist/server/ws.js

@@ -0,0 +1,192 @@
+import { WebSocketServer } from 'ws';
+import * as sessions from './sessions.js';
+import { trackEvent } from './analytics.js';
+function replyPing(ws) {
+    if (ws.readyState === ws.OPEN)
+        ws.send('{"type":"pong"}');
+}
+function parseCookies(cookieHeader) {
+    const cookies = {};
+    if (!cookieHeader)
+        return cookies;
+    cookieHeader.split(';').forEach((part) => {
+        const idx = part.indexOf('=');
+        if (idx < 0)
+            return;
+        const key = part.slice(0, idx).trim();
+        const val = part.slice(idx + 1).trim();
+        cookies[key] = decodeURIComponent(val);
+    });
+    return cookies;
+}
+function setupWebSocket(server, authenticatedTokens, watcher, _configPath) {
+    const wss = new WebSocketServer({ noServer: true });
+    const eventClients = new Set();
+    function broadcastEvent(type, data) {
+        const msg = JSON.stringify({ type, ...data });
+        for (const client of eventClients) {
+            if (client.readyState === client.OPEN) {
+                client.send(msg);
+            }
+        }
+    }
+    function broadcastBranchChanged(cwdPath, branchName) {
+        const matchingSessions = sessions
+            .list()
+            .filter((session) => session.cwd === cwdPath ||
+            session.worktreePath === cwdPath ||
+            session.repoPath === cwdPath);
+        for (const session of matchingSessions) {
+            broadcastEvent('session-branch-changed', {
+                sessionId: session.id,
+                branch: branchName,
+                cwdPath,
+            });
+        }
+    }
+    if (watcher) {
+        watcher.on('worktrees-changed', function () {
+            broadcastEvent('worktrees-changed');
+        });
+    }
+    server.on('upgrade', (request, socket, head) => {
+        const cookies = parseCookies(request.headers.cookie);
+        if (!authenticatedTokens.has(cookies['token'] ?? '')) {
+            socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        // Event channel: /ws/events
+        if (request.url === '/ws/events') {
+            wss.handleUpgrade(request, socket, head, (ws) => {
+                const cleanup = () => {
+                    eventClients.delete(ws);
+                };
+                eventClients.add(ws);
+                ws.on('message', (msg) => {
+                    try {
+                        const parsed = JSON.parse(msg.toString());
+                        if (parsed.type === 'ping')
+                            replyPing(ws);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                });
+                ws.on('close', cleanup);
+                ws.on('error', cleanup);
+            });
+            return;
+        }
+        // PTY channel: /ws/:sessionId
+        const match = request.url && request.url.match(/^\/ws\/([a-f0-9]+)$/);
+        if (!match) {
+            socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        const sessionId = match[1];
+        const session = sessions.get(sessionId);
+        if (!session) {
+            socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            sessionMap.set(ws, session);
+            wss.emit('connection', ws, request);
+        });
+    });
+    const sessionMap = new WeakMap();
+    wss.on('connection', (ws, _request) => {
+        const session = sessionMap.get(ws);
+        if (!session)
+            return;
+        let dataDisposable = null;
+        let exitDisposable = null;
+        const attachToPty = (ptyProcess) => {
+            // Dispose previous handlers
+            dataDisposable?.dispose();
+            exitDisposable?.dispose();
+            // Replay scrollback
+            for (const chunk of session.scrollback) {
+                if (ws.readyState === ws.OPEN)
+                    ws.send(chunk);
+            }
+            dataDisposable = ptyProcess.onData((data) => {
+                if (ws.readyState === ws.OPEN)
+                    ws.send(data);
+            });
+            exitDisposable = ptyProcess.onExit(() => {
+                if (ws.readyState === ws.OPEN)
+                    ws.close(1000);
+            });
+        };
+        attachToPty(session.pty);
+        const ptyReplacedHandler = (newPty) => attachToPty(newPty);
+        session.onPtyReplacedCallbacks.push(ptyReplacedHandler);
+        let lastActivityBroadcast = 0;
+        ws.on('message', (msg) => {
+            const str = msg.toString();
+            try {
+                const parsed = JSON.parse(str);
+                if (parsed.type === 'ping') {
+                    replyPing(ws);
+                    return;
+                }
+                if (parsed.type === 'resize' && parsed.cols && parsed.rows) {
+                    sessions.resize(session.id, parsed.cols, parsed.rows);
+                    return;
+                }
+            }
+            catch (_) { }
+            // Use session.pty dynamically so writes go to current PTY
+            session.pty.write(str);
+            // Update activity timestamp on user input (throttled broadcast to avoid storm)
+            const now = Date.now();
+            session.lastActivity = new Date(now).toISOString();
+            if (now - lastActivityBroadcast >= 2000) {
+                lastActivityBroadcast = now;
+                broadcastEvent('session-activity-changed', {
+                    sessionId: session.id,
+                    timestamp: session.lastActivity,
+                });
+            }
+        });
+        ws.on('close', () => {
+            dataDisposable?.dispose();
+            exitDisposable?.dispose();
+            const idx = session.onPtyReplacedCallbacks.indexOf(ptyReplacedHandler);
+            if (idx !== -1)
+                session.onPtyReplacedCallbacks.splice(idx, 1);
+        });
+    });
+    sessions.onBackendStateChange((sessionId, state, permissionType) => {
+        broadcastEvent('session-backend-state-changed', {
+            sessionId,
+            state,
+            permissionType,
+        });
+        if (state === 'idle') {
+            trackEvent({
+                category: 'agent',
+                action: 'idle',
+                target: sessionId,
+                session_id: sessionId,
+            });
+        }
+        if (state === 'permission') {
+            trackEvent({
+                category: 'agent',
+                action: 'waiting-for-input',
+                target: sessionId,
+                session_id: sessionId,
+            });
+        }
+    });
+    sessions.onSessionEnd((sessionId, cwd, branchName) => {
+        broadcastEvent('session-ended', { sessionId, cwd, branchName });
+    });
+    return { wss, broadcastEvent, broadcastBranchChanged };
+}
+export { setupWebSocket };

package/dist/test/EmptyState.spec.js

@@ -0,0 +1,51 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+describe('EmptyState', () => {
+    const projectRoot = join(__dirname, '../../..');
+    const componentPath = join(projectRoot, 'frontend/src/components/EmptyState.tsx');
+    const cssPath = join(projectRoot, 'frontend/src/components/EmptyState.css');
+    it('EmptyState.tsx file exists', () => {
+        assert.ok(existsSync(componentPath), 'EmptyState.tsx should exist');
+    });
+    it('EmptyState.css file exists', () => {
+        assert.ok(existsSync(cssPath), 'EmptyState.css should exist');
+    });
+    it('exports EmptyState component', () => {
+        const content = readFileSync(componentPath, 'utf-8');
+        assert.ok(content.includes('export function EmptyState'), 'Should export EmptyState function');
+        assert.ok(content.includes('export default EmptyState'), 'Should have default export');
+    });
+    it('exports EmptyStateProps interface', () => {
+        const content = readFileSync(componentPath, 'utf-8');
+        assert.ok(content.includes('interface EmptyStateProps'), 'Should define EmptyStateProps interface');
+    });
+    it('has required props', () => {
+        const content = readFileSync(componentPath, 'utf-8');
+        assert.ok(content.includes('heading: string'), 'Should have heading prop');
+        assert.ok(content.includes('icon?:'), 'Should have optional icon prop');
+        assert.ok(content.includes('description?:'), 'Should have optional description prop');
+        assert.ok(content.includes('actionLabel?:'), 'Should have optional actionLabel prop');
+        assert.ok(content.includes('onAction?:'), 'Should have optional onAction prop');
+    });
+    it('imports TuiButton', () => {
+        const content = readFileSync(componentPath, 'utf-8');
+        assert.ok(content.includes("from './TuiButton'"), 'Should import TuiButton');
+    });
+    it('imports CSS', () => {
+        const content = readFileSync(componentPath, 'utf-8');
+        assert.ok(content.includes("import './EmptyState.css'"), 'Should import EmptyState.css');
+    });
+    it('CSS has required classes', () => {
+        const content = readFileSync(cssPath, 'utf-8');
+        assert.ok(content.includes('.empty-state'), 'Should have .empty-state class');
+        assert.ok(content.includes('.empty-icon'), 'Should have .empty-icon class');
+        assert.ok(content.includes('.empty-heading'), 'Should have .empty-heading class');
+        assert.ok(content.includes('.empty-description'), 'Should have .empty-description class');
+    });
+});

package/dist/test/action-coverage.test.js

@@ -0,0 +1,139 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { registerGlobal, getAllActions, _resetForTesting, } from '../frontend/src/lib/actions/registry.js';
+import { sessionActions } from '../frontend/src/lib/actions/definitions/session.js';
+import { workspaceActions } from '../frontend/src/lib/actions/definitions/workspace.js';
+import { prActions } from '../frontend/src/lib/actions/definitions/pr.js';
+import { settingsActions } from '../frontend/src/lib/actions/definitions/settings.js';
+import { sidebarActions } from '../frontend/src/lib/actions/definitions/sidebar.js';
+import { dashboardActions } from '../frontend/src/lib/actions/definitions/dashboard.js';
+import { terminalActions } from '../frontend/src/lib/actions/definitions/terminal.js';
+import { navigationActions } from '../frontend/src/lib/actions/definitions/navigation.js';
+// Full allowlist: 60 palettable action IDs (15 Phase 2 + 45 Phase 3)
+const ACTION_ALLOWLIST = [
+    // Session (9)
+    'session.new-agent',
+    'session.new-terminal',
+    'session.close-active',
+    'session.kill',
+    'session.start-on-repo',
+    'session.start-on-ticket',
+    'session.customize',
+    'session.switch-to-tab',
+    'session.rename',
+    // Workspace (2)
+    'workspace.add',
+    'workspace.new-worktree',
+    // PR (11)
+    'pr.create',
+    'pr.push-branch',
+    'pr.switch-branch',
+    'pr.fix-conflicts',
+    'pr.archive-branch',
+    'pr.rename-branch',
+    'pr.copy-branch-name',
+    'pr.open-external',
+    'pr.refresh',
+    'pr.change-target',
+    'pr.skip-checks',
+    // Settings (16)
+    'settings.open',
+    'settings.connect-github',
+    'settings.toggle-yolo',
+    'settings.check-updates',
+    'settings.disconnect-github',
+    'settings.setup-webhooks',
+    'settings.remove-webhook',
+    'settings.test-webhook',
+    'settings.connect-jira',
+    'settings.disconnect-jira',
+    'settings.toggle-devtools',
+    'settings.clear-analytics',
+    'settings.toggle-continue',
+    'settings.toggle-tmux',
+    'settings.toggle-notifications',
+    'settings.change-default-agent',
+    // Sidebar (7)
+    'sidebar.collapse',
+    'sidebar.navigate-dashboard',
+    'sidebar.workspace-settings',
+    'sidebar.rename-session',
+    'sidebar.delete-worktree',
+    'sidebar.resume-session',
+    'sidebar.resume-yolo',
+    // Dashboard (3)
+    'dashboard.open-pr-session',
+    'dashboard.sort-prs',
+    'dashboard.clear-filters',
+    // Org (5)
+    'org.switch-tab',
+    'org.save-filter',
+    'org.delete-filter',
+    'org.toggle-pr-status',
+    'org.navigate-to-workspace',
+    // Ticket (2)
+    'ticket.switch-provider',
+    'ticket.open-external',
+    // Terminal (2)
+    'terminal.scroll-top',
+    'terminal.scroll-bottom',
+    // Navigation (4)
+    'navigation.previous-tab',
+    'navigation.next-tab',
+    'navigation.switch-to-tab',
+    'navigation.open-file',
+];
+const ALL_META = [
+    ...sessionActions,
+    ...workspaceActions,
+    ...prActions,
+    ...settingsActions,
+    ...sidebarActions,
+    ...dashboardActions,
+    ...terminalActions,
+    ...navigationActions,
+];
+function toAction(meta) {
+    return { ...meta, handler: () => { } };
+}
+describe('Action Coverage', () => {
+    beforeEach(() => {
+        _resetForTesting();
+    });
+    it('all allowlist IDs have corresponding definitions', () => {
+        const definedIds = new Set(ALL_META.map((a) => a.id));
+        const missing = ACTION_ALLOWLIST.filter((id) => !definedIds.has(id));
+        assert.deepStrictEqual(missing, [], `Missing action definitions: ${missing.join(', ')}`);
+    });
+    it('all defined actions are in the allowlist', () => {
+        const allowedIds = new Set(ACTION_ALLOWLIST);
+        const extra = ALL_META.filter((a) => !allowedIds.has(a.id)).map((a) => a.id);
+        assert.deepStrictEqual(extra, [], `Defined actions not in allowlist: ${extra.join(', ')}`);
+    });
+    it('all registered action IDs are unique', () => {
+        registerGlobal(ALL_META.map(toAction));
+        const all = getAllActions();
+        const ids = all.map((a) => a.id);
+        const dupes = ids.filter((id, i) => ids.indexOf(id) !== i);
+        assert.deepStrictEqual(dupes, [], `Duplicate action IDs: ${dupes.join(', ')}`);
+    });
+    it('all required Action fields are present and well-formed', () => {
+        for (const meta of ALL_META) {
+            assert.ok(meta.id, `Action missing id`);
+            assert.ok(meta.id.includes('.'), `Action id "${meta.id}" must use category.verb-noun format`);
+            assert.ok(meta.label, `Action "${meta.id}" missing label`);
+            assert.ok(meta.category, `Action "${meta.id}" missing category`);
+            assert.strictEqual(meta.label, meta.label.toLowerCase(), `Action "${meta.id}" label must be lowercase`);
+        }
+    });
+    it('no conflicting keyboard shortcuts', () => {
+        const shortcuts = ALL_META.filter((a) => a.shortcut).map((a) => ({ id: a.id, key: a.shortcut.key }));
+        const seen = new Map();
+        for (const { id, key } of shortcuts) {
+            if (seen.has(key)) {
+                assert.fail(`Shortcut conflict: "${key}" claimed by both "${seen.get(key)}" and "${id}"`);
+            }
+            seen.set(key, id);
+        }
+    });
+});

package/dist/test/actions/registry.test.js

@@ -0,0 +1,59 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { registerGlobal, registerContextual, unregisterContextual, getAction, getAllActions, getActionsByCategory, _resetForTesting, } from '../../frontend/src/lib/actions/registry.js';
+function makeAction(overrides) {
+    return {
+        label: overrides.id,
+        category: 'session',
+        handler: () => { },
+        ...overrides,
+    };
+}
+describe('ActionRegistry', () => {
+    beforeEach(() => {
+        _resetForTesting();
+    });
+    it('registerGlobal adds actions retrievable via getAction', () => {
+        const action = makeAction({ id: 'session.new-agent' });
+        registerGlobal([action]);
+        assert.deepStrictEqual(getAction('session.new-agent'), action);
+    });
+    it('registerGlobal with duplicate ID overwrites (idempotent for HMR)', () => {
+        const action1 = makeAction({ id: 'session.new-agent', label: 'v1' });
+        registerGlobal([action1]);
+        const action2 = makeAction({ id: 'session.new-agent', label: 'v2' });
+        registerGlobal([action2]);
+        assert.strictEqual(getAction('session.new-agent')?.label, 'v2');
+    });
+    it('registerContextual + unregisterContextual lifecycle', () => {
+        const action = makeAction({ id: 'session.temp' });
+        registerContextual([action]);
+        assert.deepStrictEqual(getAction('session.temp'), action);
+        unregisterContextual(['session.temp']);
+        assert.strictEqual(getAction('session.temp'), undefined);
+    });
+    it('unregister action that was never registered is a no-op', () => {
+        assert.doesNotThrow(() => unregisterContextual(['nonexistent']));
+    });
+    it('getAction returns undefined for unknown ID', () => {
+        assert.strictEqual(getAction('nope'), undefined);
+    });
+    it('getAllActions returns global + contextual', () => {
+        registerGlobal([makeAction({ id: 'session.a' })]);
+        registerContextual([makeAction({ id: 'session.b' })]);
+        const all = getAllActions();
+        assert.strictEqual(all.length, 2);
+        assert.ok(all.some((a) => a.id === 'session.a'));
+        assert.ok(all.some((a) => a.id === 'session.b'));
+    });
+    it('getActionsByCategory filters correctly', () => {
+        registerGlobal([
+            makeAction({ id: 'session.a', category: 'session' }),
+            makeAction({ id: 'pr.b', category: 'pr' }),
+            makeAction({ id: 'session.c', category: 'session' }),
+        ]);
+        const sessions = getActionsByCategory('session');
+        assert.strictEqual(sessions.length, 2);
+        assert.ok(sessions.every((a) => a.category === 'session'));
+    });
+});

package/dist/test/actions/shortcuts.test.js

@@ -0,0 +1,79 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseShortcut, matchesShortcut, formatShortcut, } from '../../frontend/src/lib/actions/shortcuts.js';
+describe('ShortcutListener', () => {
+    describe('parseShortcut', () => {
+        it('parses mod+t into platform-aware key combo', () => {
+            const result = parseShortcut('mod+t');
+            assert.deepStrictEqual(result, { mod: true, shift: false, key: 't' });
+        });
+        it('parses mod+shift+[ into key combo', () => {
+            const result = parseShortcut('mod+shift+[');
+            assert.deepStrictEqual(result, { mod: true, shift: true, key: '[' });
+        });
+        it('parses single key', () => {
+            const result = parseShortcut('escape');
+            assert.deepStrictEqual(result, {
+                mod: false,
+                shift: false,
+                key: 'escape',
+            });
+        });
+    });
+    describe('matchesShortcut', () => {
+        it('matches mod+t when metaKey is true on mac', () => {
+            const parsed = parseShortcut('mod+t');
+            const event = {
+                metaKey: true,
+                ctrlKey: false,
+                shiftKey: false,
+                key: 't',
+            };
+            assert.ok(matchesShortcut(event, parsed, true));
+        });
+        it('matches mod+t when ctrlKey is true on non-mac', () => {
+            const parsed = parseShortcut('mod+t');
+            const event = {
+                metaKey: false,
+                ctrlKey: true,
+                shiftKey: false,
+                key: 't',
+            };
+            assert.ok(matchesShortcut(event, parsed, false));
+        });
+        it('does not match when shift is required but not pressed', () => {
+            const parsed = parseShortcut('mod+shift+[');
+            const event = {
+                metaKey: true,
+                ctrlKey: false,
+                shiftKey: false,
+                key: '[',
+            };
+            assert.ok(!matchesShortcut(event, parsed, true));
+        });
+        it('matches mod+shift+[ when Linux/Windows produces { due to key transform', () => {
+            const parsed = parseShortcut('mod+shift+[');
+            const event = { metaKey: false, ctrlKey: true, shiftKey: true, key: '{' };
+            assert.ok(matchesShortcut(event, parsed, false));
+        });
+        it('matches mod+shift+] when Linux/Windows produces } due to key transform', () => {
+            const parsed = parseShortcut('mod+shift+]');
+            const event = { metaKey: false, ctrlKey: true, shiftKey: true, key: '}' };
+            assert.ok(matchesShortcut(event, parsed, false));
+        });
+    });
+    describe('formatShortcut', () => {
+        it('formats mod+t as ⌘T on mac', () => {
+            assert.strictEqual(formatShortcut('mod+t', true), '⌘T');
+        });
+        it('formats mod+t as ctrl+T on non-mac', () => {
+            assert.strictEqual(formatShortcut('mod+t', false), 'ctrl+T');
+        });
+        it('formats mod+shift+[ with shift symbol on mac', () => {
+            assert.strictEqual(formatShortcut('mod+shift+[', true), '⌘⇧[');
+        });
+        it('formats mod+w on non-mac', () => {
+            assert.strictEqual(formatShortcut('mod+w', false), 'ctrl+W');
+        });
+    });
+});

package/dist/test/agent-events.test.js

@@ -0,0 +1,151 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { createEventAdapter } from '../server/agent-events.js';
+function makeEvent(overrides = {}) {
+    return {
+        type: 'session.started',
+        sessionId: 'test-session-1',
+        timestamp: new Date().toISOString(),
+        source: 'hooks',
+        data: {},
+        ...overrides,
+    };
+}
+describe('createEventAdapter', () => {
+    describe('emit() with type-specific listeners', () => {
+        it('delivers events to type-specific listeners', () => {
+            const adapter = createEventAdapter();
+            const received = [];
+            adapter.on('session.started', (e) => received.push(e));
+            const event = makeEvent({ type: 'session.started' });
+            adapter.emit(event);
+            assert.strictEqual(received.length, 1);
+            assert.strictEqual(received[0], event);
+        });
+        it('does not deliver to listeners of other event types', () => {
+            const adapter = createEventAdapter();
+            const received = [];
+            adapter.on('session.ended', (e) => received.push(e));
+            adapter.emit(makeEvent({ type: 'session.started' }));
+            assert.strictEqual(received.length, 0);
+        });
+        it('fires multiple listeners on the same event type', () => {
+            const adapter = createEventAdapter();
+            let count = 0;
+            adapter.on('tool.started', () => count++);
+            adapter.on('tool.started', () => count++);
+            adapter.on('tool.started', () => count++);
+            adapter.emit(makeEvent({ type: 'tool.started' }));
+            assert.strictEqual(count, 3);
+        });
+    });
+    describe('emit() with wildcard (onAny) listeners', () => {
+        it('delivers events to wildcard listeners', () => {
+            const adapter = createEventAdapter();
+            const received = [];
+            adapter.onAny((e) => received.push(e));
+            const event = makeEvent({ type: 'prompt.submitted' });
+            adapter.emit(event);
+            assert.strictEqual(received.length, 1);
+            assert.strictEqual(received[0], event);
+        });
+        it('delivers every event type to wildcard listeners', () => {
+            const adapter = createEventAdapter();
+            const types = [];
+            adapter.onAny((e) => types.push(e.type));
+            const eventTypes = [
+                'session.started',
+                'tool.started',
+                'permission.requested',
+                'telemetry.updated',
+            ];
+            for (const type of eventTypes) {
+                adapter.emit(makeEvent({ type }));
+            }
+            assert.deepStrictEqual(types, eventTypes);
+        });
+    });
+    describe('emit() with no listeners', () => {
+        it('does not throw when no listeners are registered', () => {
+            const adapter = createEventAdapter();
+            assert.doesNotThrow(() => {
+                adapter.emit(makeEvent({ type: 'state.changed' }));
+            });
+        });
+        it('does not throw after removeAll() is called', () => {
+            const adapter = createEventAdapter();
+            adapter.on('session.idle', () => { });
+            adapter.onAny(() => { });
+            adapter.removeAll();
+            assert.doesNotThrow(() => {
+                adapter.emit(makeEvent({ type: 'session.idle' }));
+            });
+        });
+    });
+    describe('on() unsubscribe', () => {
+        it('returns an unsubscribe function that stops delivery', () => {
+            const adapter = createEventAdapter();
+            const received = [];
+            const unsub = adapter.on('tool.finished', (e) => received.push(e));
+            adapter.emit(makeEvent({ type: 'tool.finished' }));
+            assert.strictEqual(received.length, 1);
+            unsub();
+            adapter.emit(makeEvent({ type: 'tool.finished' }));
+            assert.strictEqual(received.length, 1); // still 1, not 2
+        });
+    });
+    describe('onAny() unsubscribe', () => {
+        it('returns an unsubscribe function that stops delivery', () => {
+            const adapter = createEventAdapter();
+            const received = [];
+            const unsub = adapter.onAny((e) => received.push(e));
+            adapter.emit(makeEvent({ type: 'permission.resolved' }));
+            assert.strictEqual(received.length, 1);
+            unsub();
+            adapter.emit(makeEvent({ type: 'permission.resolved' }));
+            assert.strictEqual(received.length, 1); // still 1, not 2
+        });
+    });
+    describe('removeAll()', () => {
+        it('clears all type-specific and wildcard listeners', () => {
+            const adapter = createEventAdapter();
+            let typeCount = 0;
+            let anyCount = 0;
+            adapter.on('session.ended', () => typeCount++);
+            adapter.on('session.started', () => typeCount++);
+            adapter.onAny(() => anyCount++);
+            adapter.emit(makeEvent({ type: 'session.started' }));
+            assert.strictEqual(typeCount, 1);
+            assert.strictEqual(anyCount, 1);
+            adapter.removeAll();
+            adapter.emit(makeEvent({ type: 'session.started' }));
+            adapter.emit(makeEvent({ type: 'session.ended' }));
+            assert.strictEqual(typeCount, 1); // unchanged
+            assert.strictEqual(anyCount, 1); // unchanged
+        });
+    });
+    describe('event shape', () => {
+        it('events have the correct shape: type, sessionId, timestamp, source, data', () => {
+            const adapter = createEventAdapter();
+            let received;
+            adapter.on('telemetry.updated', (e) => {
+                received = e;
+            });
+            const now = new Date().toISOString();
+            const event = {
+                type: 'telemetry.updated',
+                sessionId: 'session-abc',
+                timestamp: now,
+                source: 'parser',
+                data: { key: 'value', count: 42 },
+            };
+            adapter.emit(event);
+            assert.ok(received !== undefined);
+            assert.strictEqual(received.type, 'telemetry.updated');
+            assert.strictEqual(received.sessionId, 'session-abc');
+            assert.strictEqual(received.timestamp, now);
+            assert.strictEqual(received.source, 'parser');
+            assert.deepStrictEqual(received.data, { key: 'value', count: 42 });
+        });
+    });
+});