ai-cli-mcp 2.14.0 → 2.15.0

package/dist/__tests__/cli-process-service.test.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { CliProcessService } from '../cli-process-service.js';
+import { createOpenCodeMock } from './utils/opencode-mock.js';
 function createMockCliScript(dir, name, options = {}) {
     const scriptPath = join(dir, name);
     writeFileSync(scriptPath, `#!/bin/bash
@@ -57,6 +58,7 @@ describe('CliProcessService', () => {
                 codex: scriptPath,
                 gemini: scriptPath,
                 forge: scriptPath,
+                opencode: scriptPath,
             },
         });
         const runResult = await service.startProcess({
@@ -126,6 +128,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
                 codex: scriptPath,
                 gemini: scriptPath,
                 forge: scriptPath,
+                opencode: scriptPath,
             },
         });
         const runResult = await service.startProcess({
@@ -229,6 +232,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
                 codex: scriptPath,
                 gemini: scriptPath,
                 forge: scriptPath,
+                opencode: scriptPath,
             },
         });
         const runResult = await service.startProcess({
@@ -262,6 +266,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
                 codex: '/bin/sh',
                 gemini: '/bin/sh',
                 forge: '/bin/sh',
+                opencode: '/bin/sh',
             },
         });
         writeFileSync(join(processDir, 'meta.json'), JSON.stringify({
@@ -294,6 +299,92 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
         expect(stored.status).toBe('running');
         killSpy.mockRestore();
     });
+    it('lists processes without crashing when a tracked work folder has been deleted', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'deleted-project');
+        mkdirSync(workFolder, { recursive: true });
+        const pid = 45678;
+        const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(pid));
+        mkdirSync(processDir, { recursive: true });
+        writeFileSync(join(processDir, 'meta.json'), JSON.stringify({
+            pid,
+            prompt: 'deleted cwd',
+            workFolder,
+            toolType: 'claude',
+            startTime: new Date().toISOString(),
+            stdoutPath: join(processDir, 'stdout.log'),
+            stderrPath: join(processDir, 'stderr.log'),
+            status: 'running',
+        }));
+        rmSync(workFolder, { recursive: true, force: true });
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: '/bin/sh',
+                codex: '/bin/sh',
+                gemini: '/bin/sh',
+                forge: '/bin/sh',
+                opencode: '/bin/sh',
+            },
+        });
+        const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target, signal) => {
+            if (signal === 0 && target === pid) {
+                throw Object.assign(new Error('not running'), { code: 'ESRCH' });
+            }
+            return true;
+        });
+        const listed = await service.listProcesses();
+        expect(listed).toEqual([
+            {
+                pid,
+                agent: 'claude',
+                status: 'completed',
+            },
+        ]);
+        expect(JSON.parse(readFileSync(join(processDir, 'meta.json'), 'utf-8')).status).toBe('completed');
+        killSpy.mockRestore();
+    });
+    it('cleans up finished process directories even when their work folder has been deleted', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'deleted-finished-project');
+        mkdirSync(workFolder, { recursive: true });
+        const pid = 56789;
+        const cwdDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)));
+        const processDir = join(cwdDir, String(pid));
+        mkdirSync(processDir, { recursive: true });
+        writeFileSync(join(processDir, 'meta.json'), JSON.stringify({
+            pid,
+            prompt: 'done',
+            workFolder,
+            toolType: 'claude',
+            startTime: new Date().toISOString(),
+            stdoutPath: join(processDir, 'stdout.log'),
+            stderrPath: join(processDir, 'stderr.log'),
+            status: 'completed',
+        }));
+        rmSync(workFolder, { recursive: true, force: true });
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: '/bin/sh',
+                codex: '/bin/sh',
+                gemini: '/bin/sh',
+                forge: '/bin/sh',
+                opencode: '/bin/sh',
+            },
+        });
+        const result = await service.cleanupProcesses();
+        expect(result).toEqual({
+            removed: 1,
+            message: 'Removed 1 processes',
+        });
+        expect(existsSync(processDir)).toBe(false);
+        expect(existsSync(cwdDir)).toBe(false);
+    });
     it('cleans up completed and failed process directories but preserves running ones', async () => {
         const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
         tempDirs.push(root);
@@ -345,6 +436,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
                 codex: '/bin/sh',
                 gemini: '/bin/sh',
                 forge: '/bin/sh',
+                opencode: '/bin/sh',
             },
         });
         const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target, signal) => {
@@ -395,6 +487,7 @@ Forge assistant reply
                 codex: '/bin/sh',
                 gemini: '/bin/sh',
                 forge: '/bin/sh',
+                opencode: '/bin/sh',
             },
         });
         const result = await service.getProcessResult(pid, false);
@@ -405,4 +498,98 @@ Forge assistant reply
             session_id: 'forge-conv-1',
         });
     });
+    it('parses successful OpenCode detached runs from stdout only', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'opencode-project');
+        mkdirSync(workFolder, { recursive: true });
+        const argsLogPath = join(root, 'opencode-args.log');
+        const { scriptPath } = createOpenCodeMock(root, { argsLogPath });
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: '/bin/sh',
+                codex: '/bin/sh',
+                gemini: '/bin/sh',
+                forge: '/bin/sh',
+                opencode: scriptPath,
+            },
+        });
+        const runResult = await service.startProcess({
+            prompt: 'hello opencode',
+            cwd: workFolder,
+            model: 'opencode',
+        });
+        const waited = await service.waitForProcesses([runResult.pid], 5);
+        expect(waited).toHaveLength(1);
+        expect(waited[0]).toMatchObject({
+            pid: runResult.pid,
+            agent: 'opencode',
+            status: 'completed',
+            exitCode: 0,
+            model: 'opencode',
+            session_id: 'ses-opencode-default',
+            agentOutput: {
+                message: 'Initial: hello opencode',
+                session_id: 'ses-opencode-default',
+                tokens: { total: 11833 },
+                cost: 0,
+            },
+        });
+        expect(waited[0]).not.toHaveProperty('stdout');
+        expect(waited[0]).not.toHaveProperty('stderr');
+        expect(readFileSync(argsLogPath, 'utf8')).toContain(`--dir ${workFolder}`);
+    });
+    it('preserves raw stdout and stderr for failed detached OpenCode runs', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'opencode-fail-project');
+        mkdirSync(workFolder, { recursive: true });
+        const { scriptPath } = createOpenCodeMock(root);
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: '/bin/sh',
+                codex: '/bin/sh',
+                gemini: '/bin/sh',
+                forge: '/bin/sh',
+                opencode: scriptPath,
+            },
+        });
+        const runResult = await service.startProcess({
+            prompt: 'please fail',
+            cwd: workFolder,
+            model: 'oc-openai/gpt-5.4',
+        });
+        const [compactResult] = await service.waitForProcesses([runResult.pid], 5);
+        expect(compactResult).toMatchObject({
+            pid: runResult.pid,
+            agent: 'opencode',
+            status: 'failed',
+            exitCode: 7,
+            model: 'oc-openai/gpt-5.4',
+            session_id: 'ses-opencode-default',
+            stdout: expect.stringContaining('Partial failure output'),
+            stderr: expect.stringContaining('OpenCode failed for openai/gpt-5.4'),
+        });
+        expect(compactResult).not.toHaveProperty('agentOutput');
+        const verboseResult = await service.getProcessResult(runResult.pid, true);
+        expect(verboseResult).toMatchObject({
+            pid: runResult.pid,
+            agent: 'opencode',
+            status: 'failed',
+            exitCode: 7,
+            session_id: 'ses-opencode-default',
+            stdout: expect.stringContaining('Partial failure output'),
+            stderr: expect.stringContaining('OpenCode failed for openai/gpt-5.4'),
+            agentOutput: {
+                message: 'Partial failure output',
+                session_id: 'ses-opencode-default',
+                tokens: { total: 42 },
+                cost: 0,
+            },
+        });
+    });
 });

package/dist/__tests__/cli-utils.test.js

@@ -16,6 +16,7 @@ describe('cli-utils doctor status', () => {
         delete process.env.CODEX_CLI_NAME;
         delete process.env.GEMINI_CLI_NAME;
         delete process.env.FORGE_CLI_NAME;
+        delete process.env.OPENCODE_CLI_NAME;
         process.env.PATH = '/mock/bin:/usr/bin';
     });
     afterEach(() => {
@@ -43,6 +44,12 @@ describe('cli-utils doctor status', () => {
             available: false,
             lookup: 'path',
         });
+        expect(status.opencode).toEqual({
+            configuredCommand: 'opencode',
+            resolvedPath: null,
+            available: false,
+            lookup: 'path',
+        });
     });
     it('does not mark non-executable PATH entries as available', async () => {
         mockAccessSync.mockImplementation(() => {
@@ -62,6 +69,12 @@ describe('cli-utils doctor status', () => {
             available: false,
             lookup: 'path',
         });
+        expect(status.opencode).toEqual({
+            configuredCommand: 'opencode',
+            resolvedPath: null,
+            available: false,
+            lookup: 'path',
+        });
     });
     it('reports invalid relative env paths as doctor errors', async () => {
         process.env.CLAUDE_CLI_NAME = './relative/claude';
@@ -137,4 +150,22 @@ describe('cli-utils doctor status', () => {
         });
         expect(findForgeCli()).toBe('forge-custom');
     });
+    it('supports OpenCode lookup via OPENCODE_CLI_NAME', async () => {
+        process.env.OPENCODE_CLI_NAME = 'opencode-custom';
+        mockAccessSync.mockImplementation((filePath) => {
+            if (filePath === '/mock/bin/opencode-custom') {
+                return undefined;
+            }
+            throw new Error('not executable');
+        });
+        const { getCliDoctorStatus, findOpencodeCli } = await import('../cli-utils.js');
+        const status = getCliDoctorStatus();
+        expect(status.opencode).toEqual({
+            configuredCommand: 'opencode-custom',
+            resolvedPath: '/mock/bin/opencode-custom',
+            available: true,
+            lookup: 'env',
+        });
+        expect(findOpencodeCli()).toBe('opencode-custom');
+    });
 });

package/dist/__tests__/e2e.test.js

@@ -1,9 +1,10 @@
 import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { createTestClient } from './utils/mcp-client.js';
 import { getSharedMock, cleanupSharedMock } from './utils/persistent-mock.js';
+import { createOpenCodeMock } from './utils/opencode-mock.js';
 describe('Claude Code MCP E2E Tests', () => {
     let client;
     let testDir;
@@ -30,40 +31,10 @@ describe('Claude Code MCP E2E Tests', () => {
             const tools = await client.listTools();
             expect(tools).toHaveLength(6);
             const claudeCodeTool = tools.find((t) => t.name === 'run');
-            expect(claudeCodeTool).toEqual({
-                name: 'run',
-                description: expect.stringContaining('AI Agent Runner'),
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        prompt: {
-                            type: 'string',
-                            description: expect.stringContaining('Either this or prompt_file is required'),
-                        },
-                        prompt_file: {
-                            type: 'string',
-                            description: expect.stringContaining('Path to a file containing the prompt'),
-                        },
-                        workFolder: {
-                            type: 'string',
-                            description: expect.stringContaining('working directory'),
-                        },
-                        model: {
-                            type: 'string',
-                            description: expect.stringContaining('sonnet'),
-                        },
-                        reasoning_effort: {
-                            type: 'string',
-                            description: expect.stringContaining('model_reasoning_effort'),
-                        },
-                        session_id: {
-                            type: 'string',
-                            description: expect.stringContaining('session ID'),
-                        },
-                    },
-                    required: ['workFolder'],
-                },
-            });
+            expect(claudeCodeTool.inputSchema.properties.model.description).toContain('sonnet');
+            expect(claudeCodeTool.inputSchema.properties.model.description).toContain('opencode');
+            expect(claudeCodeTool.inputSchema.properties.model.description).toContain('oc-<provider/model>');
+            expect(claudeCodeTool.inputSchema.properties.reasoning_effort.description).toContain('OpenCode');
             // Verify other tools exist
             expect(tools.some((t) => t.name === 'list_processes')).toBe(true);
             expect(tools.some((t) => t.name === 'get_result')).toBe(true);
@@ -180,6 +151,70 @@ describe('Claude Code MCP E2E Tests', () => {
                 }]);
         });
     });
+    describe('OpenCode flows', () => {
+        it('should execute and resume OpenCode runs through the MCP client', async () => {
+            await client.disconnect();
+            const opencodeArgsLogPath = join(testDir, 'opencode-args.log');
+            const { scriptPath } = createOpenCodeMock(testDir, {
+                argsLogPath: opencodeArgsLogPath,
+                defaultSessionId: 'ses-opencode-e2e',
+            });
+            client = createTestClient({
+                debug: false,
+                env: {
+                    OPENCODE_CLI_NAME: scriptPath,
+                },
+            });
+            await client.connect();
+            const runResponse = await client.callTool('run', {
+                prompt: 'e2e OpenCode initial prompt',
+                workFolder: testDir,
+                model: 'opencode',
+            });
+            const runData = JSON.parse(runResponse[0].text);
+            expect(runData.agent).toBe('opencode');
+            const initialWait = JSON.parse((await client.callTool('wait', { pids: [runData.pid], timeout: 5 }))[0].text);
+            expect(initialWait).toHaveLength(1);
+            expect(initialWait[0]).toMatchObject({
+                pid: runData.pid,
+                agent: 'opencode',
+                status: 'completed',
+                exitCode: 0,
+                model: 'opencode',
+                session_id: 'ses-opencode-e2e',
+                agentOutput: {
+                    message: 'Initial: e2e OpenCode initial prompt',
+                    session_id: 'ses-opencode-e2e',
+                },
+            });
+            const resumedResponse = await client.callTool('run', {
+                prompt: 'e2e OpenCode resumed prompt',
+                workFolder: testDir,
+                model: 'oc-openai/gpt-5.4',
+                session_id: 'ses-opencode-e2e',
+            });
+            const resumedRunData = JSON.parse(resumedResponse[0].text);
+            const resumedWait = JSON.parse((await client.callTool('wait', { pids: [resumedRunData.pid], timeout: 5 }))[0].text);
+            expect(resumedWait).toHaveLength(1);
+            expect(resumedWait[0]).toMatchObject({
+                pid: resumedRunData.pid,
+                agent: 'opencode',
+                status: 'completed',
+                exitCode: 0,
+                model: 'oc-openai/gpt-5.4',
+                session_id: 'ses-opencode-e2e',
+                agentOutput: {
+                    message: 'Resumed model openai/gpt-5.4: e2e OpenCode resumed prompt',
+                    session_id: 'ses-opencode-e2e',
+                },
+            });
+            const invocationLog = readFileSync(opencodeArgsLogPath, 'utf-8').trim().split('\n');
+            expect(invocationLog[0]).toContain(`--dir ${testDir}`);
+            expect(invocationLog[0]).not.toContain('--model');
+            expect(invocationLog[1]).toContain('--session ses-opencode-e2e');
+            expect(invocationLog[1]).toContain('--model openai/gpt-5.4');
+        });
+    });
     describe('Debug Mode', () => {
         it('should log debug information when enabled', async () => {
             // Debug logs go to stderr, which we capture in the client
@@ -205,25 +240,16 @@ describe('Integration Tests (Local Only)', () => {
         }
         rmSync(testDir, { recursive: true, force: true });
     });
-    // These tests will only run locally when Claude is available
-    it.skip('should create a file with real Claude CLI', async () => {
-        await client.connect();
-        const response = await client.callTool('run', {
-            prompt: 'Create a file called hello.txt with content "Hello from Claude"',
-            workFolder: testDir,
-        });
-        const filePath = join(testDir, 'hello.txt');
-        expect(existsSync(filePath)).toBe(true);
-        expect(readFileSync(filePath, 'utf-8')).toContain('Hello from Claude');
-    });
-    it.skip('should handle git operations with real Claude CLI', async () => {
+    // This smoke test only verifies that a real Claude CLI can be invoked.
+    it.skip('should invoke the real Claude CLI', async () => {
         await client.connect();
-        // Initialize git repo
         const response = await client.callTool('run', {
-            prompt: 'Initialize a git repository and create a README.md file',
+            prompt: 'Reply with hi',
             workFolder: testDir,
         });
-        expect(existsSync(join(testDir, '.git'))).toBe(true);
-        expect(existsSync(join(testDir, 'README.md'))).toBe(true);
+        expect(response).toEqual([{
+                type: 'text',
+                text: expect.stringContaining('pid'),
+            }]);
     });
 });

package/dist/__tests__/mcp-contract.test.js

@@ -3,6 +3,7 @@ import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'nod
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { cleanupSharedMock, getSharedMock } from './utils/persistent-mock.js';
+import { createOpenCodeMock } from './utils/opencode-mock.js';
 import { createTestClient } from './utils/mcp-client.js';
 function parseToolJson(content) {
     expect(content).toHaveLength(1);
@@ -96,6 +97,11 @@ describe('MCP Contract Tests', () => {
             'session_id',
             'workFolder',
         ]);
+        expect(runTool.description).toContain('OpenCode');
+        expect(runTool.inputSchema.properties.model.description).toContain('opencode');
+        expect(runTool.inputSchema.properties.model.description).toContain('oc-<provider/model>');
+        expect(runTool.inputSchema.properties.reasoning_effort.description).toContain('OpenCode do not support reasoning_effort');
+        expect(runTool.inputSchema.properties.session_id.description).toBe('Optional session ID to resume a previous session. Supported for Claude, Codex, Gemini, Forge, and OpenCode. OpenCode resumes in-place via --session and may also be combined with explicit oc-<provider/model> selection.');
         const getResultTool = tools.find((tool) => tool.name === 'get_result');
         expect(getResultTool.inputSchema.required).toEqual(['pid']);
         expect(Object.keys(getResultTool.inputSchema.properties).sort()).toEqual([
@@ -407,6 +413,154 @@ printf '%s\n' '{"type":"system","session_id":"session-verbose-1"}'
             reasoning_effort: 'high',
         })).rejects.toThrow(/reasoning_effort is not supported for forge/i);
     });
+    it('covers OpenCode end-to-end through the MCP process path', async () => {
+        await client.disconnect();
+        const opencodeArgsLogPath = join(testDir, 'opencode-args.log');
+        const { scriptPath: openCodeMockPath } = createOpenCodeMock(testDir, {
+            argsLogPath: opencodeArgsLogPath,
+            defaultSessionId: 'ses-opencode-contract',
+        });
+        client = createTestClient({
+            debug: false,
+            env: {
+                OPENCODE_CLI_NAME: openCodeMockPath,
+            },
+        });
+        await client.connect();
+        const initialRunResponse = await client.callTool('run', {
+            prompt: 'opencode-initial-prompt',
+            workFolder: testDir,
+            model: 'opencode',
+        });
+        const initialRunData = parseToolJson(initialRunResponse);
+        expect(initialRunData).toEqual({
+            pid: expect.any(Number),
+            status: 'started',
+            agent: 'opencode',
+            message: expect.any(String),
+        });
+        const initialWaitResponse = await client.callTool('wait', { pids: [initialRunData.pid], timeout: 5 });
+        const initialWaitData = parseToolJson(initialWaitResponse);
+        expect(initialWaitData).toHaveLength(1);
+        expect(initialWaitData[0]).toMatchObject({
+            pid: initialRunData.pid,
+            agent: 'opencode',
+            status: 'completed',
+            exitCode: 0,
+            model: 'opencode',
+            session_id: 'ses-opencode-contract',
+            agentOutput: {
+                message: 'Initial: opencode-initial-prompt',
+                session_id: 'ses-opencode-contract',
+                tokens: { total: 11833 },
+                cost: 0,
+            },
+        });
+        const resumedDefaultRunResponse = await client.callTool('run', {
+            prompt: 'opencode-resume-default',
+            workFolder: testDir,
+            model: 'opencode',
+            session_id: 'ses-opencode-contract',
+        });
+        const resumedDefaultRunData = parseToolJson(resumedDefaultRunResponse);
+        const resumedDefaultWaitResponse = await client.callTool('wait', { pids: [resumedDefaultRunData.pid], timeout: 5 });
+        const resumedDefaultWaitData = parseToolJson(resumedDefaultWaitResponse);
+        expect(resumedDefaultWaitData).toHaveLength(1);
+        expect(resumedDefaultWaitData[0]).toMatchObject({
+            pid: resumedDefaultRunData.pid,
+            agent: 'opencode',
+            status: 'completed',
+            exitCode: 0,
+            model: 'opencode',
+            session_id: 'ses-opencode-contract',
+            agentOutput: {
+                message: 'Resumed: opencode-resume-default',
+                session_id: 'ses-opencode-contract',
+                tokens: { total: 11833 },
+                cost: 0,
+            },
+        });
+        const resumedExplicitRunResponse = await client.callTool('run', {
+            prompt: 'opencode-resume-explicit',
+            workFolder: testDir,
+            model: 'oc-openai/gpt-5.4',
+            session_id: 'ses-opencode-contract',
+        });
+        const resumedExplicitRunData = parseToolJson(resumedExplicitRunResponse);
+        const resumedExplicitWaitResponse = await client.callTool('wait', { pids: [resumedExplicitRunData.pid], timeout: 5 });
+        const resumedExplicitWaitData = parseToolJson(resumedExplicitWaitResponse);
+        expect(resumedExplicitWaitData).toHaveLength(1);
+        expect(resumedExplicitWaitData[0]).toMatchObject({
+            pid: resumedExplicitRunData.pid,
+            agent: 'opencode',
+            status: 'completed',
+            exitCode: 0,
+            model: 'oc-openai/gpt-5.4',
+            session_id: 'ses-opencode-contract',
+            agentOutput: {
+                message: 'Resumed model openai/gpt-5.4: opencode-resume-explicit',
+                session_id: 'ses-opencode-contract',
+                tokens: { total: 11833 },
+                cost: 0,
+            },
+        });
+        const failedRunResponse = await client.callTool('run', {
+            prompt: 'please fail',
+            workFolder: testDir,
+            model: 'oc-openai/gpt-5.4',
+        });
+        const failedRunData = parseToolJson(failedRunResponse);
+        const compactFailedWait = parseToolJson(await client.callTool('wait', { pids: [failedRunData.pid], timeout: 5 }));
+        expect(compactFailedWait).toHaveLength(1);
+        expect(compactFailedWait[0]).toMatchObject({
+            pid: failedRunData.pid,
+            agent: 'opencode',
+            status: 'failed',
+            exitCode: 7,
+            model: 'oc-openai/gpt-5.4',
+            session_id: 'ses-opencode-contract',
+            stdout: expect.stringContaining('Partial failure output'),
+            stderr: expect.stringContaining('OpenCode failed for openai/gpt-5.4'),
+        });
+        expect(compactFailedWait[0]).not.toHaveProperty('agentOutput');
+        const verboseFailedResult = parseToolJson(await client.callTool('get_result', { pid: failedRunData.pid, verbose: true }));
+        expect(verboseFailedResult).toMatchObject({
+            pid: failedRunData.pid,
+            agent: 'opencode',
+            status: 'failed',
+            exitCode: 7,
+            model: 'oc-openai/gpt-5.4',
+            session_id: 'ses-opencode-contract',
+            stdout: expect.stringContaining('Partial failure output'),
+            stderr: expect.stringContaining('OpenCode failed for openai/gpt-5.4'),
+            agentOutput: {
+                message: 'Partial failure output',
+                session_id: 'ses-opencode-contract',
+                tokens: { total: 42 },
+                cost: 0,
+            },
+        });
+        const openCodeInvocations = readFileSync(opencodeArgsLogPath, 'utf-8').trim().split('\n');
+        expect(openCodeInvocations).toHaveLength(4);
+        expect(openCodeInvocations[0]).toContain('run --format json');
+        expect(openCodeInvocations[0]).toContain(`--dir ${testDir}`);
+        expect(openCodeInvocations[0]).not.toContain('--session');
+        expect(openCodeInvocations[0]).not.toContain('--model');
+        expect(openCodeInvocations[1]).toContain(`--dir ${testDir}`);
+        expect(openCodeInvocations[1]).toContain('--session ses-opencode-contract');
+        expect(openCodeInvocations[1]).not.toContain('--model');
+        expect(openCodeInvocations[2]).toContain(`--dir ${testDir}`);
+        expect(openCodeInvocations[2]).toContain('--session ses-opencode-contract');
+        expect(openCodeInvocations[2]).toContain('--model openai/gpt-5.4');
+        expect(openCodeInvocations[3]).toContain(`--dir ${testDir}`);
+        expect(openCodeInvocations[3]).toContain('--model openai/gpt-5.4');
+        await expect(client.callTool('run', {
+            prompt: 'opencode-invalid-reasoning',
+            workFolder: testDir,
+            model: 'opencode',
+            reasoning_effort: 'high',
+        })).rejects.toThrow(/reasoning_effort is not supported for opencode/i);
+    });
     it('keeps key invalid-input errors stable', async () => {
         await expect(client.callTool('run', {
             prompt: 'missing workFolder',