relay-ide 0.1.0

package/dist/test/diff-summary.test.js

@@ -0,0 +1,98 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { generateFileSummary } from '../frontend/src/lib/diff-summary.js';
+describe('generateFileSummary', () => {
+    it('returns "deleted file" for deleted status', () => {
+        assert.equal(generateFileSummary('', 'foo.ts', 'deleted'), 'deleted file');
+    });
+    it('returns "new file" for untracked with no meaningful content', () => {
+        const diff = [
+            '+++ b/empty.ts',
+            '+import foo from "bar"',
+            '+// just a comment',
+        ].join('\n');
+        assert.equal(generateFileSummary(diff, 'empty.ts', 'untracked'), 'new file');
+    });
+    it('returns "new file: <line>" for untracked with meaningful content', () => {
+        const diff = [
+            '+++ b/handler.ts',
+            '+import express from "express"',
+            '+export function handleRequest(req: Request) {',
+        ].join('\n');
+        const result = generateFileSummary(diff, 'handler.ts', 'untracked');
+        assert.match(result, /^new file: export function handleRequest/);
+    });
+    it('detects a single added function', () => {
+        const diff = [
+            '--- a/server.ts',
+            '+++ b/server.ts',
+            '@@ -10,0 +11,3 @@',
+            '+function validateInput(data: unknown) {',
+            '+  return data != null;',
+            '+}',
+        ].join('\n');
+        assert.equal(generateFileSummary(diff, 'server.ts', 'modified'), 'added validateInput()');
+    });
+    it('detects multiple added functions', () => {
+        const diff = [
+            '--- a/utils.ts',
+            '+++ b/utils.ts',
+            '@@ -10,0 +11,6 @@',
+            '+function first() {',
+            '+  return 1;',
+            '+}',
+            '+function second() {',
+            '+  return 2;',
+            '+}',
+        ].join('\n');
+        assert.equal(generateFileSummary(diff, 'utils.ts', 'modified'), 'added 2 functions');
+    });
+    it('detects modified function from hunk headers', () => {
+        const diff = [
+            '--- a/api.ts',
+            '+++ b/api.ts',
+            '@@ -5,3 +5,4 @@ handleRequest',
+            ' const x = 1;',
+            '+const y = 2;',
+            ' return x;',
+        ].join('\n');
+        const result = generateFileSummary(diff, 'api.ts', 'modified');
+        assert.match(result, /modified \d+ lines? in handleRequest\(\)/);
+    });
+    it('detects multiple modified functions from hunk headers', () => {
+        const diff = [
+            '--- a/api.ts',
+            '+++ b/api.ts',
+            '@@ -5,3 +5,4 @@ parseInput',
+            ' const x = 1;',
+            '+const y = 2;',
+            '@@ -20,3 +21,4 @@ formatOutput',
+            ' const a = 1;',
+            '+const b = 2;',
+        ].join('\n');
+        assert.equal(generateFileSummary(diff, 'api.ts', 'modified'), 'modified 2 functions');
+    });
+    it('falls back to +N -N lines when no functions detected', () => {
+        const diff = [
+            '--- a/config.json',
+            '+++ b/config.json',
+            '@@ -1,3 +1,4 @@',
+            ' {',
+            '+  "newKey": true,',
+            '   "existing": false',
+            '-  "removed": true',
+            ' }',
+        ].join('\n');
+        assert.equal(generateFileSummary(diff, 'config.json', 'modified'), '+1 -1 lines');
+    });
+    it('truncates long first meaningful line for untracked files', () => {
+        const longLine = 'x'.repeat(100);
+        const diff = [
+            '+++ b/long.ts',
+            '+import foo from "bar"',
+            `+${longLine}`,
+        ].join('\n');
+        const result = generateFileSummary(diff, 'long.ts', 'untracked');
+        assert.ok(result.length <= 72, `Expected truncated result but got length ${result.length}`);
+    });
+});

package/dist/test/display-state.test.js

@@ -0,0 +1,179 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { transitionDisplayState, shouldNotify, } from '../frontend/src/lib/state/display-state.js';
+describe('transitionDisplayState', () => {
+    const transitionTable = [
+        [
+            'initializing',
+            { type: 'backend-state-changed', state: 'running' },
+            'running',
+            'initializing + backend-state-changed(running) → running',
+        ],
+        [
+            'initializing',
+            { type: 'backend-state-changed', state: 'idle' },
+            'unseen-idle',
+            'initializing + backend-state-changed(idle) → unseen-idle',
+        ],
+        [
+            'running',
+            { type: 'backend-state-changed', state: 'idle' },
+            'unseen-idle',
+            'running + backend-state-changed(idle) → unseen-idle',
+        ],
+        [
+            'running',
+            { type: 'backend-state-changed', state: 'permission' },
+            'permission',
+            'running + backend-state-changed(permission) → permission',
+        ],
+        [
+            'unseen-idle',
+            { type: 'user-viewed' },
+            'seen-idle',
+            'unseen-idle + user-viewed → seen-idle',
+        ],
+        [
+            'seen-idle',
+            { type: 'backend-state-changed', state: 'running' },
+            'running',
+            'seen-idle + backend-state-changed(running) → running',
+        ],
+        [
+            'seen-idle',
+            { type: 'backend-state-changed', state: 'idle' },
+            'seen-idle',
+            'seen-idle + backend-state-changed(idle) → seen-idle (CRITICAL INVARIANT)',
+        ],
+        [
+            'permission',
+            { type: 'user-viewed' },
+            'permission',
+            'permission + user-viewed → permission (approval must be given, not just viewed)',
+        ],
+        [
+            'permission',
+            { type: 'backend-state-changed', state: 'running' },
+            'running',
+            'permission + backend-state-changed(running) → running',
+        ],
+        [
+            'running',
+            { type: 'session-ended' },
+            'inactive',
+            'running + session-ended → inactive',
+        ],
+        [
+            'unseen-idle',
+            { type: 'backend-state-changed', state: 'idle' },
+            'unseen-idle',
+            'unseen-idle + backend-state-changed(idle) → unseen-idle (idempotent)',
+        ],
+        [
+            'seen-idle',
+            { type: 'session-ended' },
+            'inactive',
+            'seen-idle + session-ended → inactive',
+        ],
+        [
+            'running',
+            {
+                type: 'backend-state-changed',
+                state: 'permission',
+                permissionType: 'question',
+            },
+            'needs-answer',
+            'running + backend-state-changed(permission, question) → needs-answer',
+        ],
+        [
+            'running',
+            {
+                type: 'backend-state-changed',
+                state: 'permission',
+                permissionType: 'approval',
+            },
+            'permission',
+            'running + backend-state-changed(permission, approval) → permission',
+        ],
+        [
+            'running',
+            { type: 'backend-state-changed', state: 'permission' },
+            'permission',
+            'running + backend-state-changed(permission, no type) → permission (backward compat)',
+        ],
+        [
+            'needs-answer',
+            { type: 'user-viewed' },
+            'needs-answer',
+            'needs-answer + user-viewed → needs-answer (question must be answered, not just viewed)',
+        ],
+        [
+            'needs-answer',
+            { type: 'backend-state-changed', state: 'running' },
+            'running',
+            'needs-answer + backend-state-changed(running) → running',
+        ],
+        [
+            'running',
+            { type: 'backend-state-changed', state: 'error' },
+            'error',
+            'running + backend-state-changed(error) → error',
+        ],
+        [
+            'error',
+            { type: 'session-ended' },
+            'inactive',
+            'error + session-ended → inactive',
+        ],
+        [
+            'error',
+            { type: 'user-viewed' },
+            'error',
+            'error + user-viewed → error (stays — error needs acknowledgment, not just viewing)',
+        ],
+        [
+            'permission',
+            { type: 'backend-state-changed', state: 'idle' },
+            'unseen-idle',
+            'permission + backend-state-changed(idle) → unseen-idle (escape stuck attention state)',
+        ],
+        [
+            'needs-answer',
+            { type: 'backend-state-changed', state: 'idle' },
+            'unseen-idle',
+            'needs-answer + backend-state-changed(idle) → unseen-idle (escape stuck attention state)',
+        ],
+        [
+            'error',
+            { type: 'backend-state-changed', state: 'idle' },
+            'unseen-idle',
+            'error + backend-state-changed(idle) → unseen-idle (escape stuck attention state)',
+        ],
+    ];
+    for (const [current, event, expected, description] of transitionTable) {
+        it(description, () => {
+            const result = transitionDisplayState(current, event);
+            assert.equal(result, expected);
+        });
+    }
+});
+describe('shouldNotify', () => {
+    it('running → unseen-idle → true', () => {
+        assert.equal(shouldNotify('running', 'unseen-idle'), true);
+    });
+    it('running → permission → true', () => {
+        assert.equal(shouldNotify('running', 'permission'), true);
+    });
+    it('initializing → unseen-idle → false', () => {
+        assert.equal(shouldNotify('initializing', 'unseen-idle'), false);
+    });
+    it('seen-idle → seen-idle → false', () => {
+        assert.equal(shouldNotify('seen-idle', 'seen-idle'), false);
+    });
+    it('running → needs-answer → true', () => {
+        assert.equal(shouldNotify('running', 'needs-answer'), true);
+    });
+    it('running → error → true', () => {
+        assert.equal(shouldNotify('running', 'error'), true);
+    });
+});

package/dist/test/event-message-types.test.js

@@ -0,0 +1,32 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+function findTsc(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 5; i++) {
+        const candidate = path.join(dir, 'node_modules', '.bin', 'tsc');
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return 'tsc'; // fallback to PATH
+}
+test('EventMessage types compile without errors', () => {
+    const tscPath = findTsc(process.cwd());
+    try {
+        execFileSync(tscPath, ['--noEmit', '--strict', '-p', 'tsconfig.json'], {
+            cwd: process.cwd(),
+            encoding: 'utf-8',
+        });
+        assert.ok(true, 'TypeScript compilation succeeded');
+    }
+    catch (err) {
+        const e = err;
+        assert.fail(`TypeScript compilation failed:\n${e.stdout ?? ''}\n${e.stderr ?? ''}`);
+    }
+});

package/dist/test/file-tree-utils.test.js

@@ -0,0 +1,167 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildChangedFilesTree, flattenVisibleNodes, findMostRecentlyChanged, parseLineReference, statusToBadge, statusToBadgeColor, } from '../frontend/src/lib/file-tree-utils.js';
+describe('buildChangedFilesTree', () => {
+    test('returns empty array for no files', () => {
+        assert.deepStrictEqual(buildChangedFilesTree([]), []);
+    });
+    test('builds tree from flat file list', () => {
+        const files = [
+            {
+                path: 'src/index.ts',
+                status: 'modified',
+                additions: 5,
+                deletions: 2,
+                directory: 'src',
+            },
+            {
+                path: 'src/utils.ts',
+                status: 'added',
+                additions: 10,
+                deletions: 0,
+                directory: 'src',
+            },
+        ];
+        const tree = buildChangedFilesTree(files);
+        assert.equal(tree.length, 1); // single "src" directory
+        assert.equal(tree[0].name, 'src');
+        assert.equal(tree[0].isDirectory, true);
+        assert.equal(tree[0].children.length, 2);
+        assert.equal(tree[0].fileCount, 2);
+        assert.equal(tree[0].additions, 15);
+        assert.equal(tree[0].deletions, 2);
+    });
+    test('collapses single-child directories', () => {
+        const files = [
+            {
+                path: 'a/b/c/file.ts',
+                status: 'modified',
+                additions: 1,
+                deletions: 0,
+                directory: 'a/b/c',
+            },
+        ];
+        const tree = buildChangedFilesTree(files);
+        // a/b/c should collapse into one node "a/b/c"
+        assert.equal(tree.length, 1);
+        assert.ok(tree[0].name.includes('a'));
+        assert.ok(tree[0].name.includes('c'));
+    });
+    test('sorts directories before files', () => {
+        const files = [
+            {
+                path: 'z-file.ts',
+                status: 'modified',
+                additions: 1,
+                deletions: 0,
+                directory: '',
+            },
+            {
+                path: 'a-dir/inner.ts',
+                status: 'added',
+                additions: 1,
+                deletions: 0,
+                directory: 'a-dir',
+            },
+        ];
+        const tree = buildChangedFilesTree(files);
+        assert.equal(tree[0].isDirectory, true);
+        assert.equal(tree[1].isDirectory, false);
+    });
+    test('aggregates stats to parent directories', () => {
+        const files = [
+            {
+                path: 'src/a.ts',
+                status: 'modified',
+                additions: 3,
+                deletions: 1,
+                directory: 'src',
+            },
+            {
+                path: 'src/b.ts',
+                status: 'added',
+                additions: 7,
+                deletions: 0,
+                directory: 'src',
+            },
+        ];
+        const tree = buildChangedFilesTree(files);
+        const srcNode = tree[0];
+        assert.equal(srcNode.additions, 10);
+        assert.equal(srcNode.deletions, 1);
+        assert.equal(srcNode.fileCount, 2);
+    });
+});
+describe('flattenVisibleNodes', () => {
+    test('returns empty for empty tree', () => {
+        assert.deepStrictEqual(flattenVisibleNodes([]), []);
+    });
+    test('flattens expanded directories', () => {
+        const files = [
+            {
+                path: 'src/index.ts',
+                status: 'modified',
+                additions: 1,
+                deletions: 0,
+                directory: 'src',
+            },
+        ];
+        const tree = buildChangedFilesTree(files);
+        const flat = flattenVisibleNodes(tree);
+        assert.equal(flat.length, 2); // src dir + index.ts file
+    });
+    test('hides children of collapsed directories', () => {
+        const files = [
+            {
+                path: 'src/index.ts',
+                status: 'modified',
+                additions: 1,
+                deletions: 0,
+                directory: 'src',
+            },
+        ];
+        const tree = buildChangedFilesTree(files);
+        tree[0].expanded = false;
+        const flat = flattenVisibleNodes(tree);
+        assert.equal(flat.length, 1); // only src dir, child hidden
+    });
+});
+describe('findMostRecentlyChanged', () => {
+    test('returns new files not in previous set', () => {
+        const prev = ['a.ts', 'b.ts'];
+        const curr = ['a.ts', 'b.ts', 'c.ts'];
+        assert.deepStrictEqual(findMostRecentlyChanged(prev, curr), ['c.ts']);
+    });
+    test('returns empty when no new files', () => {
+        const prev = ['a.ts', 'b.ts'];
+        const curr = ['a.ts', 'b.ts'];
+        assert.deepStrictEqual(findMostRecentlyChanged(prev, curr), []);
+    });
+    test('returns all files when previous is empty', () => {
+        const result = findMostRecentlyChanged([], ['a.ts', 'b.ts']);
+        assert.deepStrictEqual(result, ['a.ts', 'b.ts']);
+    });
+});
+describe('parseLineReference', () => {
+    test('formats as backtick-wrapped filepath:linenum', () => {
+        assert.equal(parseLineReference('src/index.ts', 42), '`src/index.ts:42`');
+    });
+});
+describe('statusToBadge', () => {
+    test('maps all statuses to single characters', () => {
+        assert.equal(statusToBadge('added'), 'A');
+        assert.equal(statusToBadge('modified'), 'M');
+        assert.equal(statusToBadge('deleted'), 'D');
+        assert.equal(statusToBadge('renamed'), 'R');
+        assert.equal(statusToBadge('untracked'), '?');
+    });
+});
+describe('statusToBadgeColor', () => {
+    test('maps all statuses to CSS variables', () => {
+        assert.equal(statusToBadgeColor('added'), 'var(--status-success)');
+        assert.equal(statusToBadgeColor('modified'), 'var(--status-warning)');
+        assert.equal(statusToBadgeColor('deleted'), 'var(--status-error)');
+        assert.equal(statusToBadgeColor('renamed'), 'var(--status-info)');
+        assert.equal(statusToBadgeColor('untracked'), 'var(--text-muted)');
+    });
+});

package/dist/test/framework-types.test.js

@@ -0,0 +1,183 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { BUILTIN_FRAMEWORKS, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, resolveFramework, } from '../server/types.js';
+// ── BUILTIN_FRAMEWORKS structure ──
+test('BUILTIN_FRAMEWORKS contains claude, codex, and opencode', () => {
+    assert.ok('claude' in BUILTIN_FRAMEWORKS);
+    assert.ok('codex' in BUILTIN_FRAMEWORKS);
+    assert.ok('opencode' in BUILTIN_FRAMEWORKS);
+});
+test('claude framework has correct values', () => {
+    const claude = BUILTIN_FRAMEWORKS['claude'];
+    assert.equal(claude.id, 'claude');
+    assert.equal(claude.displayName, 'Claude Code');
+    assert.equal(claude.command, 'claude');
+    assert.deepEqual(claude.continueArgs, ['--continue']);
+    assert.deepEqual(claude.yoloArgs, ['--dangerously-skip-permissions']);
+    assert.equal(claude.parserType, 'claude');
+    assert.equal(claude.eventSource, 'hooks');
+    assert.equal(claude.capabilities.supportsHooks, true);
+    assert.equal(claude.capabilities.supportsContinue, true);
+    assert.equal(claude.capabilities.supportsYolo, true);
+    assert.equal(claude.capabilities.supportsTelemetry, true);
+});
+test('codex framework has correct values', () => {
+    const codex = BUILTIN_FRAMEWORKS['codex'];
+    assert.equal(codex.id, 'codex');
+    assert.equal(codex.displayName, 'Codex');
+    assert.equal(codex.command, 'codex');
+    assert.deepEqual(codex.continueArgs, ['resume', '--last']);
+    assert.deepEqual(codex.yoloArgs, [
+        '--ask-for-approval',
+        'never',
+        '--sandbox',
+        'workspace-write',
+    ]);
+    assert.equal(codex.parserType, 'codex');
+    assert.equal(codex.eventSource, 'hooks');
+    assert.equal(codex.capabilities.supportsHooks, true);
+    assert.equal(codex.capabilities.supportsContinue, true);
+    assert.equal(codex.capabilities.supportsYolo, true);
+    assert.equal(codex.capabilities.supportsTelemetry, false);
+});
+test('opencode framework has correct values', () => {
+    const opencode = BUILTIN_FRAMEWORKS['opencode'];
+    assert.equal(opencode.id, 'opencode');
+    assert.equal(opencode.displayName, 'OpenCode');
+    assert.equal(opencode.command, 'opencode');
+    assert.deepEqual(opencode.continueArgs, ['--continue']);
+    assert.deepEqual(opencode.yoloArgs, []);
+    assert.equal(opencode.parserType, 'opencode');
+    assert.equal(opencode.eventSource, 'plugin');
+    assert.equal(opencode.capabilities.supportsHooks, false);
+    assert.equal(opencode.capabilities.supportsContinue, true);
+    assert.equal(opencode.capabilities.supportsYolo, true);
+    assert.equal(opencode.capabilities.supportsTelemetry, true);
+});
+test('opencode yoloEnv contains OPENCODE_CONFIG_CONTENT with permission JSON', () => {
+    const opencode = BUILTIN_FRAMEWORKS['opencode'];
+    assert.ok(opencode.yoloEnv, 'yoloEnv should be defined');
+    assert.ok('OPENCODE_CONFIG_CONTENT' in opencode.yoloEnv);
+    const parsed = JSON.parse(opencode.yoloEnv['OPENCODE_CONFIG_CONTENT']);
+    assert.ok(parsed.permission, 'permission key should exist');
+    assert.equal(parsed.permission.read, 'allow');
+    assert.equal(parsed.permission.edit, 'allow');
+    assert.equal(parsed.permission.bash, 'allow');
+});
+// ── resolveFramework ──
+test('resolveFramework returns builtin framework unmodified when no config override', () => {
+    const result = resolveFramework({}, 'claude');
+    assert.deepEqual(result, BUILTIN_FRAMEWORKS['claude']);
+});
+test('resolveFramework returns builtin codex when no config override', () => {
+    const result = resolveFramework({}, 'codex');
+    assert.deepEqual(result, BUILTIN_FRAMEWORKS['codex']);
+});
+test('resolveFramework applies top-level overrides from config.frameworks', () => {
+    const result = resolveFramework({
+        frameworks: {
+            claude: {
+                commandOverride: '/usr/local/bin/claude',
+                displayName: 'My Claude',
+            },
+        },
+    }, 'claude');
+    assert.equal(result.commandOverride, '/usr/local/bin/claude');
+    assert.equal(result.displayName, 'My Claude');
+    // non-overridden fields remain unchanged
+    assert.equal(result.command, 'claude');
+    assert.deepEqual(result.continueArgs, ['--continue']);
+});
+test('resolveFramework deep merges capabilities from config.frameworks', () => {
+    const result = resolveFramework({
+        frameworks: {
+            claude: {
+                capabilities: {
+                    supportsHooks: false,
+                },
+            },
+        },
+    }, 'claude');
+    assert.equal(result.capabilities.supportsHooks, false);
+    // other capabilities should remain from builtin
+    assert.equal(result.capabilities.supportsContinue, true);
+    assert.equal(result.capabilities.supportsYolo, true);
+    assert.equal(result.capabilities.supportsTelemetry, true);
+});
+test('resolveFramework supports fully custom framework from config.frameworks', () => {
+    const customFramework = {
+        id: 'myagent',
+        displayName: 'My Agent',
+        command: 'myagent',
+        continueArgs: ['--resume'],
+        yoloArgs: [],
+        parserType: 'myagent',
+        eventSource: 'parser',
+        capabilities: {
+            supportsHooks: false,
+            supportsContinue: true,
+            supportsYolo: false,
+            supportsTelemetry: false,
+        },
+    };
+    const result = resolveFramework({ frameworks: { myagent: customFramework } }, 'myagent');
+    assert.equal(result.id, 'myagent');
+    assert.equal(result.displayName, 'My Agent');
+    assert.equal(result.command, 'myagent');
+});
+test('resolveFramework throws for unknown framework not in config', () => {
+    assert.throws(() => resolveFramework({}, 'nonexistent'), /unknown.*framework|framework.*unknown|nonexistent/i);
+});
+test('resolveFramework throws for unknown framework not in config.frameworks', () => {
+    assert.throws(() => resolveFramework({ frameworks: { other: { id: 'other' } } }, 'nonexistent'), /unknown.*framework|framework.*unknown|nonexistent/i);
+});
+test('resolveFramework throws for custom framework missing required fields', () => {
+    assert.throws(() => resolveFramework({ frameworks: { bad: { id: 'bad' } } }, 'bad'), /must define.*command|must define.*continueArgs|must define.*capabilities/i);
+});
+// ── Backward-compat aliases ──
+test('AGENT_COMMANDS is derived from BUILTIN_FRAMEWORKS', () => {
+    assert.equal(AGENT_COMMANDS['claude'], BUILTIN_FRAMEWORKS['claude'].command);
+    assert.equal(AGENT_COMMANDS['codex'], BUILTIN_FRAMEWORKS['codex'].command);
+    assert.equal(AGENT_COMMANDS['opencode'], BUILTIN_FRAMEWORKS['opencode'].command);
+});
+test('AGENT_CONTINUE_ARGS is derived from BUILTIN_FRAMEWORKS', () => {
+    assert.deepEqual(AGENT_CONTINUE_ARGS['claude'], BUILTIN_FRAMEWORKS['claude'].continueArgs);
+    assert.deepEqual(AGENT_CONTINUE_ARGS['codex'], BUILTIN_FRAMEWORKS['codex'].continueArgs);
+    assert.deepEqual(AGENT_CONTINUE_ARGS['opencode'], BUILTIN_FRAMEWORKS['opencode'].continueArgs);
+});
+test('AGENT_YOLO_ARGS is derived from BUILTIN_FRAMEWORKS', () => {
+    assert.deepEqual(AGENT_YOLO_ARGS['claude'], BUILTIN_FRAMEWORKS['claude'].yoloArgs);
+    assert.deepEqual(AGENT_YOLO_ARGS['codex'], BUILTIN_FRAMEWORKS['codex'].yoloArgs);
+    assert.deepEqual(AGENT_YOLO_ARGS['opencode'], BUILTIN_FRAMEWORKS['opencode'].yoloArgs);
+});
+test('AGENT_COMMANDS still has claude and codex for backward compat', () => {
+    assert.equal(AGENT_COMMANDS['claude'], 'claude');
+    assert.equal(AGENT_COMMANDS['codex'], 'codex');
+});
+test('AGENT_CONTINUE_ARGS still has claude and codex for backward compat', () => {
+    assert.deepEqual(AGENT_CONTINUE_ARGS['claude'], ['--continue']);
+    assert.deepEqual(AGENT_CONTINUE_ARGS['codex'], ['resume', '--last']);
+});
+test('AGENT_YOLO_ARGS still has claude and codex for backward compat', () => {
+    assert.deepEqual(AGENT_YOLO_ARGS['claude'], [
+        '--dangerously-skip-permissions',
+    ]);
+    assert.deepEqual(AGENT_YOLO_ARGS['codex'], [
+        '--ask-for-approval',
+        'never',
+        '--sandbox',
+        'workspace-write',
+    ]);
+});
+// ── EventSourceType type check ──
+test('EventSourceType values are used correctly in BUILTIN_FRAMEWORKS', () => {
+    const validSources = [
+        'hooks',
+        'plugin',
+        'parser',
+        'timer',
+    ];
+    for (const fw of Object.values(BUILTIN_FRAMEWORKS)) {
+        assert.ok(validSources.includes(fw.eventSource), `${fw.id} eventSource should be valid`);
+    }
+});