discoclaw 0.1.0

package/dist/runtime/codex-cli.test.js

@@ -0,0 +1,862 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+// We mock execa at the module level so createCodexCliRuntime uses our mock.
+const mockExeca = vi.fn();
+vi.mock('execa', () => ({
+    execa: (...args) => mockExeca(...args),
+}));
+// Import after mock setup.
+const { createCodexCliRuntime, killActiveCodexSubprocesses } = await import('./codex-cli.js');
+async function collectEvents(iter) {
+    const events = [];
+    for await (const evt of iter) {
+        events.push(evt);
+    }
+    return events;
+}
+/** Create a mock subprocess that mimics execa's ResultPromise shape. */
+function createMockSubprocess(opts) {
+    const stdoutChunks = opts.stdout ? [Buffer.from(opts.stdout)] : [];
+    const stdoutListeners = {};
+    const stderrListeners = {};
+    let thenCb = null;
+    let catchCb = null;
+    const mockStdout = {
+        on(event, cb) {
+            if (!stdoutListeners[event])
+                stdoutListeners[event] = [];
+            stdoutListeners[event].push(cb);
+            return mockStdout;
+        },
+    };
+    const mockStderr = {
+        on(event, cb) {
+            if (!stderrListeners[event])
+                stderrListeners[event] = [];
+            stderrListeners[event].push(cb);
+            return mockStderr;
+        },
+    };
+    const mockStdin = {
+        write: vi.fn(),
+        end: vi.fn(),
+    };
+    const subprocess = {
+        stdout: mockStdout,
+        stderr: mockStderr,
+        stdin: mockStdin,
+        pid: 12345,
+        kill: vi.fn(),
+        then(cb) {
+            thenCb = cb;
+            return { catch(cb2) { catchCb = cb2; } };
+        },
+    };
+    // Simulate async process completion.
+    // Use queueMicrotask to fire after the generator sets up listeners.
+    queueMicrotask(() => {
+        // Emit stdout data
+        for (const chunk of stdoutChunks) {
+            for (const cb of (stdoutListeners['data'] || [])) {
+                cb(chunk);
+            }
+        }
+        // Emit stderr data
+        if (opts.stderr) {
+            for (const cb of (stderrListeners['data'] || [])) {
+                cb(Buffer.from(opts.stderr));
+            }
+        }
+        // End streams
+        for (const cb of (stdoutListeners['end'] || []))
+            cb();
+        for (const cb of (stderrListeners['end'] || []))
+            cb();
+        // Resolve/reject the process promise.
+        if (opts.rejectWith) {
+            catchCb?.(opts.rejectWith);
+        }
+        else if (opts.timedOut) {
+            catchCb?.({
+                timedOut: true,
+                message: 'timed out',
+                originalMessage: 'timed out',
+                shortMessage: 'timed out',
+            });
+        }
+        else {
+            const exitCode = opts.exitCode ?? 0;
+            const result = {
+                exitCode,
+                stdout: opts.stdout ?? '',
+                stderr: opts.stderr ?? '',
+                timedOut: false,
+                failed: exitCode !== 0 || (opts.failed ?? false),
+                ...opts.resultExtra,
+            };
+            thenCb?.(result);
+        }
+    });
+    return subprocess;
+}
+describe('Codex CLI runtime adapter', () => {
+    beforeEach(() => {
+        mockExeca.mockReset();
+    });
+    it('happy path: stdout text emits text_delta + text_final + done', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'Hello world',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Say hello',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const deltas = events.filter((e) => e.type === 'text_delta');
+        expect(deltas.length).toBeGreaterThan(0);
+        expect(deltas.map((d) => d.text).join('')).toBe('Hello world');
+        const final = events.find((e) => e.type === 'text_final');
+        expect(final).toBeDefined();
+        expect(final.text).toBe('Hello world');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('error path: non-zero exit code emits error + done', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            stderr: 'model not found',
+            exitCode: 1,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Say hello',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        expect(errorEvt.message).toContain('model not found');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('timeout path: timedOut flag emits timeout error + done', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            timedOut: true,
+            exitCode: undefined,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Say hello',
+            model: '',
+            cwd: '/tmp',
+            timeoutMs: 5000,
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        expect(errorEvt.message).toContain('timed out');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('model override: params.model takes precedence over defaultModel', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: 'gpt-4o',
+            cwd: '/tmp',
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        const modelIdx = callArgs.indexOf('-m');
+        expect(callArgs[modelIdx + 1]).toBe('gpt-4o');
+    });
+    it('inserts -- argument terminator before prompt to prevent flag parsing', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        await collectEvents(rt.invoke({
+            prompt: '--- SOUL.md ---\ntext',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const callArgs = mockExeca.mock.calls[0][1];
+        const dashdashIdx = callArgs.indexOf('--');
+        expect(dashdashIdx).toBeGreaterThan(-1);
+        expect(callArgs[dashdashIdx + 1]).toBe('--- SOUL.md ---\ntext');
+    });
+    it('empty model fallback: params.model="" resolves to defaultModel', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        const modelIdx = callArgs.indexOf('-m');
+        expect(callArgs[modelIdx + 1]).toBe('gpt-5.3-codex');
+    });
+    it('large prompt uses stdin instead of positional arg', async () => {
+        const largePrompt = 'x'.repeat(200_000);
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        await collectEvents(rt.invoke({
+            prompt: largePrompt,
+            model: '',
+            cwd: '/tmp',
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        expect(callArgs).toContain('--');
+        // Should end with `-` (stdin flag) instead of the large prompt text.
+        expect(callArgs[callArgs.length - 1]).toBe('-');
+        // Should NOT contain the large prompt as a positional arg.
+        expect(callArgs).not.toContain(largePrompt);
+        // Verify stdin was used.
+        const execaOpts = mockExeca.mock.calls[0][2];
+        expect(execaOpts.stdin).toBe('pipe');
+    });
+    it('shutdown cleanup: killActiveCodexSubprocesses kills tracked processes', async () => {
+        const sub = createMockSubprocess({
+            stdout: '',
+            exitCode: 0,
+        });
+        // Prevent the subprocess from resolving immediately so it stays tracked.
+        sub.then = () => ({ catch: () => { } });
+        mockExeca.mockReturnValue(sub);
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        // Start invoke but don't consume fully — just trigger subprocess creation.
+        const iter = rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        });
+        // Pull one event to start the generator (which adds the subprocess to tracking).
+        const iterResult = iter;
+        // Actually call .next() to enter the generator body — the subprocess is
+        // added to activeSubprocesses inside the generator, before the first yield.
+        iterResult.next(); // don't await — we just need it to run up to the first yield/await
+        await new Promise(r => setTimeout(r, 10));
+        // Kill all tracked subprocesses.
+        killActiveCodexSubprocesses();
+        expect(sub.kill).toHaveBeenCalledWith('SIGKILL');
+    });
+    it('runtime has correct id and capabilities', () => {
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        expect(rt.id).toBe('codex');
+        expect(rt.capabilities.has('streaming_text')).toBe(true);
+        expect(rt.capabilities.has('tools_fs')).toBe(true);
+        expect(rt.capabilities.has('tools_exec')).toBe(true);
+        expect(rt.capabilities.has('tools_web')).toBe(true);
+        expect(rt.capabilities.has('sessions')).toBe(true);
+    });
+    it('disableSessions removes sessions capability and forces ephemeral mode', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+            disableSessions: true,
+        });
+        expect(rt.capabilities.has('sessions')).toBe(false);
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+            sessionKey: 'should-be-ignored',
+        }));
+        const callArgs = mockExeca.mock.calls[0][1];
+        expect(callArgs).toContain('--ephemeral');
+        expect(callArgs).not.toContain('--json');
+        expect(callArgs).not.toContain('resume');
+    });
+    it('empty stdout emits done without text_final', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        // No text_final for empty response.
+        expect(events.find((e) => e.type === 'text_final')).toBeUndefined();
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('error messages are sanitized: multi-line stderr truncated to first line', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            stderr: 'auth token expired\nfull prompt: You are a helpful assistant...\nsession: /tmp/codex/abc123',
+            exitCode: 1,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Say hello',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        const msg = errorEvt.message;
+        // Should contain first line only.
+        expect(msg).toContain('auth token expired');
+        // Should NOT contain prompt or session content from subsequent lines.
+        expect(msg).not.toContain('full prompt');
+        expect(msg).not.toContain('session:');
+    });
+    it('error sanitization skips Codex banner/chatter and surfaces actionable error line', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            stderr: [
+                'OpenAI Codex v0.101.0 (research preview)',
+                '--------',
+                'workdir: /tmp',
+                'model: gpt-5-mini',
+                'user',
+                'TOP SECRET PROMPT DATA',
+                'Reconnecting... 5/5 (stream disconnected before completion)',
+                'ERROR: stream disconnected before completion: error sending request for url (https://api.openai.com/v1/responses)',
+            ].join('\n'),
+            exitCode: 1,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'TOP SECRET PROMPT DATA',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        const msg = errorEvt.message;
+        expect(msg).toContain('stream disconnected before completion');
+        expect(msg).not.toContain('OpenAI Codex');
+        expect(msg).not.toContain('TOP SECRET');
+    });
+    it('error sanitization maps rollout path corruption to a clear remediation message', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            stderr: '2026-02-16T23:36:26.244364Z ERROR codex_core::rollout::list: state db missing rollout path for thread 019c5957-beea-7e92-aca4-42b5c15af63d',
+            exitCode: 1,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Say hello',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        const msg = errorEvt.message;
+        expect(msg).toContain('codex session state appears corrupted');
+        expect(msg).toContain('CODEX_HOME');
+    });
+    it('ENOENT via tryFinalize: uses fixed message, never leaks prompt', async () => {
+        // Simulates execa resolving (reject: false) with failed=true, exitCode=null, code=ENOENT.
+        // The real execa shortMessage would contain the full command line including the prompt.
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            exitCode: undefined,
+            failed: true,
+            resultExtra: {
+                exitCode: null,
+                failed: true,
+                code: 'ENOENT',
+                originalMessage: 'spawn codex ENOENT',
+                shortMessage: "Command failed: codex exec -m gpt-5.3-codex --skip-git-repo-check --ephemeral -s read-only 'TOP SECRET PROMPT DATA'\nspawn codex ENOENT",
+            },
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'TOP SECRET PROMPT DATA',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        const msg = errorEvt.message;
+        // Should use the fixed "not found" message.
+        expect(msg).toContain('codex binary not found');
+        // Must never contain prompt text.
+        expect(msg).not.toContain('TOP SECRET');
+        expect(msg).not.toContain('Command failed');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('ENOENT via catch handler: uses fixed message, never leaks prompt', async () => {
+        // Simulates the .catch() path — execa rejects with an error that includes the command line.
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            rejectWith: {
+                code: 'ENOENT',
+                originalMessage: 'spawn codex ENOENT',
+                shortMessage: "Command failed: codex exec -m gpt-5.3-codex --skip-git-repo-check --ephemeral -s read-only 'TOP SECRET PROMPT DATA'\nspawn codex ENOENT",
+                message: "Command failed: codex exec -m gpt-5.3-codex --skip-git-repo-check --ephemeral -s read-only 'TOP SECRET PROMPT DATA'\nspawn codex ENOENT",
+            },
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'TOP SECRET PROMPT DATA',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        const msg = errorEvt.message;
+        // Should use the fixed "not found" message.
+        expect(msg).toContain('codex binary not found');
+        // Must never contain prompt text.
+        expect(msg).not.toContain('TOP SECRET');
+        expect(msg).not.toContain('Command failed');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('non-ENOENT spawn failure via catch handler: generic message, no raw error', async () => {
+        // Simulates a non-ENOENT rejection (e.g. EACCES) — should get generic message.
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            rejectWith: {
+                code: 'EACCES',
+                originalMessage: 'spawn codex EACCES',
+                shortMessage: "Command failed: codex exec -m gpt-5.3-codex --skip-git-repo-check --ephemeral -s read-only 'secret prompt'\nspawn codex EACCES",
+                message: "Command failed: codex exec ...",
+            },
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'secret prompt',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        const msg = errorEvt.message;
+        // Should use the generic fixed message with error code.
+        expect(msg).toBe('codex process failed unexpectedly (EACCES)');
+        // Must never contain prompt text or raw command.
+        expect(msg).not.toContain('secret prompt');
+        expect(msg).not.toContain('Command failed');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('args include read-only sandbox flag', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        const sandboxIdx = callArgs.indexOf('-s');
+        expect(sandboxIdx).toBeGreaterThan(-1);
+        expect(callArgs[sandboxIdx + 1]).toBe('read-only');
+    });
+    it('dangerous bypass flag replaces read-only sandbox on exec', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+            dangerouslyBypassApprovalsAndSandbox: true,
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        expect(callArgs).toContain('--dangerously-bypass-approvals-and-sandbox');
+        expect(callArgs).not.toContain('-s');
+        expect(callArgs).not.toContain('read-only');
+    });
+    it('passes --add-dir flags from params.addDirs', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+            addDirs: ['/home/user/project', '/home/user/shared'],
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        // Should contain --add-dir /home/user/project --add-dir /home/user/shared
+        const firstIdx = callArgs.indexOf('--add-dir');
+        expect(firstIdx).toBeGreaterThan(-1);
+        expect(callArgs[firstIdx + 1]).toBe('/home/user/project');
+        const secondIdx = callArgs.indexOf('--add-dir', firstIdx + 2);
+        expect(secondIdx).toBeGreaterThan(-1);
+        expect(callArgs[secondIdx + 1]).toBe('/home/user/shared');
+    });
+    it('omits --add-dir when addDirs is empty', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+            addDirs: [],
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        expect(callArgs).not.toContain('--add-dir');
+    });
+    it('omits --add-dir when addDirs is undefined', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+            // addDirs intentionally omitted (undefined)
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        expect(callArgs).not.toContain('--add-dir');
+    });
+    // --- Session persistence tests ---
+    it('sessionKey omits --ephemeral and adds --json', async () => {
+        const jsonlOutput = [
+            '{"type":"thread.started","thread_id":"abc-123"}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"hello"}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: jsonlOutput,
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+            sessionKey: 'test-session-1',
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        // Should NOT have --ephemeral.
+        expect(callArgs).not.toContain('--ephemeral');
+        // Should have --json.
+        expect(callArgs).toContain('--json');
+        // Should start with 'exec' (not 'exec resume' on first call).
+        expect(callArgs[0]).toBe('exec');
+        expect(callArgs[1]).not.toBe('resume');
+        // Should extract text from JSONL.
+        const final = events.find((e) => e.type === 'text_final');
+        expect(final).toBeDefined();
+        expect(final.text).toBe('hello');
+    });
+    it('second call with same sessionKey uses codex exec resume', async () => {
+        const jsonlOutput1 = [
+            '{"type":"thread.started","thread_id":"thread-uuid-456"}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"first response"}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        const jsonlOutput2 = [
+            '{"type":"thread.started","thread_id":"thread-uuid-456"}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"second response"}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        // First call — establishes the session.
+        mockExeca.mockReturnValue(createMockSubprocess({ stdout: jsonlOutput1, exitCode: 0 }));
+        await collectEvents(rt.invoke({
+            prompt: 'Round 1',
+            model: '',
+            cwd: '/tmp',
+            sessionKey: 'audit-session',
+        }));
+        // Second call — should resume.
+        mockExeca.mockReturnValue(createMockSubprocess({ stdout: jsonlOutput2, exitCode: 0 }));
+        const events2 = await collectEvents(rt.invoke({
+            prompt: 'Round 2',
+            model: '',
+            cwd: '/tmp',
+            sessionKey: 'audit-session',
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(2);
+        const callArgs2 = mockExeca.mock.calls[1][1];
+        // Should use 'exec resume <thread_id>'.
+        expect(callArgs2[0]).toBe('exec');
+        expect(callArgs2[1]).toBe('resume');
+        expect(callArgs2[2]).toBe('thread-uuid-456');
+        const final2 = events2.find((e) => e.type === 'text_final');
+        expect(final2.text).toBe('second response');
+    });
+    it('dangerous bypass flag is passed on resume calls', async () => {
+        const jsonlOutput1 = [
+            '{"type":"thread.started","thread_id":"thread-danger-1"}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"first"}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        const jsonlOutput2 = [
+            '{"type":"thread.started","thread_id":"thread-danger-1"}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"second"}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+            dangerouslyBypassApprovalsAndSandbox: true,
+        });
+        mockExeca.mockReturnValue(createMockSubprocess({ stdout: jsonlOutput1, exitCode: 0 }));
+        await collectEvents(rt.invoke({
+            prompt: 'Round 1',
+            model: '',
+            cwd: '/tmp',
+            sessionKey: 'danger-session',
+        }));
+        mockExeca.mockReturnValue(createMockSubprocess({ stdout: jsonlOutput2, exitCode: 0 }));
+        await collectEvents(rt.invoke({
+            prompt: 'Round 2',
+            model: '',
+            cwd: '/tmp',
+            sessionKey: 'danger-session',
+        }));
+        const callArgs2 = mockExeca.mock.calls[1][1];
+        expect(callArgs2[0]).toBe('exec');
+        expect(callArgs2[1]).toBe('resume');
+        expect(callArgs2).toContain('--dangerously-bypass-approvals-and-sandbox');
+        expect(callArgs2).not.toContain('-s');
+    });
+    it('without sessionKey still uses --ephemeral (backward compat)', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+            // no sessionKey
+        }));
+        const callArgs = mockExeca.mock.calls[0][1];
+        expect(callArgs).toContain('--ephemeral');
+        expect(callArgs).not.toContain('--json');
+    });
+    it('reasoning items emit text_delta but text_final contains only agent_message', async () => {
+        const jsonlOutput = [
+            '{"type":"thread.started","thread_id":"reason-thread-1"}',
+            '{"type":"item.completed","item":{"type":"reasoning","summary":"Let me think step by step..."}}',
+            '{"type":"item.completed","item":{"type":"reasoning","text":"Considering the options..."}}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"The answer is 42."}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: jsonlOutput,
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'What is the answer?',
+            model: '',
+            cwd: '/tmp',
+            sessionKey: 'reason-session',
+        }));
+        // text_delta events should include reasoning text.
+        const deltas = events.filter((e) => e.type === 'text_delta');
+        const deltaTexts = deltas.map((d) => d.text);
+        expect(deltaTexts).toContain('Let me think step by step...');
+        expect(deltaTexts).toContain('Considering the options...');
+        expect(deltaTexts).toContain('The answer is 42.');
+        // text_final should contain only the agent_message, not reasoning text.
+        const final = events.find((e) => e.type === 'text_final');
+        expect(final).toBeDefined();
+        expect(final.text).toBe('The answer is 42.');
+        expect(final.text).not.toContain('Let me think');
+        expect(final.text).not.toContain('Considering the options');
+    });
+    it('reasoning item with empty or missing text is silently skipped', async () => {
+        const jsonlOutput = [
+            '{"type":"thread.started","thread_id":"reason-thread-2"}',
+            '{"type":"item.completed","item":{"type":"reasoning","summary":""}}',
+            '{"type":"item.completed","item":{"type":"reasoning"}}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"Done."}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: jsonlOutput,
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Do something',
+            model: '',
+            cwd: '/tmp',
+            sessionKey: 'reason-session-2',
+        }));
+        // Should not emit empty text_delta events.
+        const deltas = events.filter((e) => e.type === 'text_delta');
+        const emptyDeltas = deltas.filter((d) => !d.text);
+        expect(emptyDeltas).toHaveLength(0);
+        // Only the agent_message delta should be present.
+        const deltaTexts = deltas.map((d) => d.text);
+        expect(deltaTexts).toEqual(['Done.']);
+        // Streaming continues to completion.
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('reasoning item with non-string text field is silently skipped and streaming continues', async () => {
+        const jsonlOutput = [
+            '{"type":"thread.started","thread_id":"reason-thread-3"}',
+            '{"type":"item.completed","item":{"type":"reasoning","text":42}}',
+            '{"type":"item.completed","item":{"type":"reasoning","text":{"nested":"object"}}}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"Still works."}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: jsonlOutput,
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Do something',
+            model: '',
+            cwd: '/tmp',
+            sessionKey: 'reason-session-3',
+        }));
+        // Non-string text fields should produce no text_delta.
+        const deltas = events.filter((e) => e.type === 'text_delta');
+        const deltaTexts = deltas.map((d) => d.text);
+        expect(deltaTexts).toEqual(['Still works.']);
+        // No error events — streaming continues without error.
+        expect(events.find((e) => e.type === 'error')).toBeUndefined();
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('different sessionKeys get independent sessions', async () => {
+        const jsonlA = [
+            '{"type":"thread.started","thread_id":"thread-aaa"}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"a"}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        const jsonlB = [
+            '{"type":"thread.started","thread_id":"thread-bbb"}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"b"}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        const jsonlA2 = [
+            '{"type":"thread.started","thread_id":"thread-aaa"}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"a2"}}',
+            '{"type":"turn.completed","usage":{}}',
+        ].join('\n') + '\n';
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.3-codex',
+        });
+        mockExeca.mockReturnValue(createMockSubprocess({ stdout: jsonlA, exitCode: 0 }));
+        await collectEvents(rt.invoke({ prompt: 'a1', model: '', cwd: '/tmp', sessionKey: 'session-a' }));
+        mockExeca.mockReturnValue(createMockSubprocess({ stdout: jsonlB, exitCode: 0 }));
+        await collectEvents(rt.invoke({ prompt: 'b1', model: '', cwd: '/tmp', sessionKey: 'session-b' }));
+        mockExeca.mockReturnValue(createMockSubprocess({ stdout: jsonlA2, exitCode: 0 }));
+        await collectEvents(rt.invoke({ prompt: 'a2', model: '', cwd: '/tmp', sessionKey: 'session-a' }));
+        // Third call should resume session-a's thread, not session-b's.
+        const callArgs3 = mockExeca.mock.calls[2][1];
+        expect(callArgs3[1]).toBe('resume');
+        expect(callArgs3[2]).toBe('thread-aaa');
+    });
+});