ai-cli-mcp 2.14.1 → 2.16.0

package/dist/__tests__/process-management.test.js

@@ -60,7 +60,7 @@ describe('Process Management Tests', () => {
     });
     async function setupServer() {
         const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
-        vi.mocked(Server).mockImplementation(() => {
+        vi.mocked(Server).mockImplementation(function () {
             mockServerInstance = {
                 setRequestHandler: vi.fn((schema, handler) => {
                     handlers.set(schema.name, handler);
@@ -101,6 +101,165 @@ describe('Process Management Tests', () => {
             expect(response.status).toBe('started');
             expect(response.message).toBe('claude process started successfully');
         });
+        it('should peek only natural-language messages observed after registration', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12345;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt',
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            mockProcess.stdout.emit('data', '{"type":"assistant","message":{"content":[{"type":"text","text":"old message"}]}}\n');
+            const peekPromise = callToolHandler({
+                params: {
+                    name: 'peek',
+                    arguments: {
+                        pids: [12345, 12345, 99999],
+                        peek_time_sec: 1,
+                    }
+                }
+            });
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', '{"type":"assistant","message":{"content":[{"type":"text","text":"new message"},{"type":"tool_use","id":"tool-1","name":"Read","input":{"file_path":"/tmp/a"}}]}}\n');
+                mockProcess.stdout.emit('data', '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":"secret"}]}}\n');
+                mockProcess.emit('close', 0);
+            }, 10);
+            const result = await peekPromise;
+            const response = JSON.parse(result.content[0].text);
+            expect(response.processes).toHaveLength(2);
+            expect(response.processes[0]).toMatchObject({
+                pid: 12345,
+                agent: 'claude',
+                status: 'completed',
+                messages: [
+                    {
+                        ts: expect.any(String),
+                        text: 'new message',
+                    },
+                ],
+                truncated: false,
+                error: null,
+            });
+            expect(response.processes[1]).toEqual({
+                pid: 99999,
+                agent: null,
+                status: 'not_found',
+                messages: [],
+                truncated: false,
+                error: 'process not found',
+            });
+        });
+        it('should peek OpenCode text events and exclude OpenCode tool output', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12346;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'opencode peek prompt',
+                        workFolder: '/tmp',
+                        model: 'opencode',
+                    }
+                }
+            });
+            const peekPromise = callToolHandler({
+                params: {
+                    name: 'peek',
+                    arguments: {
+                        pids: [12346],
+                        peek_time_sec: 1,
+                    }
+                }
+            });
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', '{"type":"text","timestamp":1775918783605,"sessionID":"ses-1","part":{"type":"text","text":"OpenCode visible text"}}\n');
+                mockProcess.stdout.emit('data', '{"type":"tool_use","timestamp":1775918783606,"sessionID":"ses-1","part":{"type":"tool","state":{"output":"secret command output"},"metadata":{"output":"secret metadata output"}}}\n');
+                mockProcess.emit('close', 0);
+            }, 10);
+            const result = await peekPromise;
+            const response = JSON.parse(result.content[0].text);
+            expect(response.processes).toHaveLength(1);
+            expect(response.processes[0]).toMatchObject({
+                pid: 12346,
+                agent: 'opencode',
+                status: 'completed',
+                messages: [
+                    {
+                        ts: expect.any(String),
+                        text: 'OpenCode visible text',
+                    },
+                ],
+                truncated: false,
+                error: null,
+            });
+        });
+        it('should peek Gemini assistant message events and exclude tool output', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12347;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'gemini peek prompt',
+                        workFolder: '/tmp',
+                        model: 'gemini-2.5-pro',
+                    }
+                }
+            });
+            const peekPromise = callToolHandler({
+                params: {
+                    name: 'peek',
+                    arguments: {
+                        pids: [12347],
+                        peek_time_sec: 1,
+                    }
+                }
+            });
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}\n');
+                mockProcess.stdout.emit('data', '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Visible Gemini text","delta":true}\n');
+                mockProcess.stdout.emit('data', '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}\n');
+                mockProcess.emit('close', 0);
+            }, 10);
+            const result = await peekPromise;
+            const response = JSON.parse(result.content[0].text);
+            expect(response.processes).toHaveLength(1);
+            expect(response.processes[0]).toMatchObject({
+                pid: 12347,
+                agent: 'gemini',
+                status: 'completed',
+                messages: [
+                    {
+                        ts: expect.any(String),
+                        text: 'Visible Gemini text',
+                    },
+                ],
+                truncated: false,
+                error: null,
+            });
+        });
         it('should handle process with model parameter', async () => {
             const { handlers } = await setupServer();
             const mockProcess = new EventEmitter();

package/dist/__tests__/server.test.js

@@ -174,6 +174,37 @@ describe('ClaudeCodeServer Unit Tests', () => {
             expect(() => findClaudeCli()).toThrow('Invalid CLAUDE_CLI_NAME: Relative paths are not allowed');
         });
     });
+    describe('findOpencodeCli function', () => {
+        it('should fallback to PATH for OpenCode when no override is configured', async () => {
+            mockHomedir.mockReturnValue('/home/user');
+            mockExistsSync.mockImplementation((path) => path === '/usr/bin/opencode');
+            mockAccessSync.mockImplementation((filePath) => {
+                if (filePath === '/usr/bin/opencode')
+                    return undefined;
+                throw new Error('not executable');
+            });
+            process.env.PATH = '/usr/bin';
+            const module = await import('../server.js');
+            // @ts-ignore
+            const findOpencodeCli = module.default?.findOpencodeCli || module.findOpencodeCli;
+            expect(findOpencodeCli()).toBe('/usr/bin/opencode');
+        });
+        it('should use custom name from OPENCODE_CLI_NAME', async () => {
+            process.env.OPENCODE_CLI_NAME = 'opencode-custom';
+            mockHomedir.mockReturnValue('/home/user');
+            mockExistsSync.mockImplementation((path) => path === '/usr/bin/opencode-custom');
+            mockAccessSync.mockImplementation((filePath) => {
+                if (filePath === '/usr/bin/opencode-custom')
+                    return undefined;
+                throw new Error('not executable');
+            });
+            process.env.PATH = '/usr/bin';
+            const module = await import('../server.js');
+            // @ts-ignore
+            const findOpencodeCli = module.default?.findOpencodeCli || module.findOpencodeCli;
+            expect(findOpencodeCli()).toBe('opencode-custom');
+        });
+    });
     describe('spawnAsync function', () => {
         let mockProcess;
         beforeEach(() => {
@@ -276,13 +307,11 @@ describe('ClaudeCodeServer Unit Tests', () => {
             const server = new ClaudeCodeServer();
             expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('[Setup] Using Claude CLI command/path:'));
         });
-        it('should set up tool handlers', async () => {
+        it('should include OpenCode in setup logging', async () => {
             mockHomedir.mockReturnValue('/home/user');
             mockExistsSync.mockReturnValue(true);
-            const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
-            const mockSetRequestHandler = vi.fn();
             vi.mocked(Server).mockImplementation(function () {
-                this.setRequestHandler = mockSetRequestHandler;
+                this.setRequestHandler = vi.fn();
                 this.connect = vi.fn();
                 this.close = vi.fn();
                 this.onerror = undefined;
@@ -291,8 +320,8 @@ describe('ClaudeCodeServer Unit Tests', () => {
             const module = await import('../server.js');
             // @ts-ignore
             const { ClaudeCodeServer } = module;
-            const server = new ClaudeCodeServer();
-            expect(mockSetRequestHandler).toHaveBeenCalled();
+            new ClaudeCodeServer();
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('[Setup] Using OpenCode CLI command/path:'));
         });
         it('should set up error handler', async () => {
             mockHomedir.mockReturnValue('/home/user');
@@ -378,14 +407,15 @@ describe('ClaudeCodeServer Unit Tests', () => {
             // Test the handler
             const handler = listToolsCall[1];
             const result = await handler();
-            expect(result.tools).toHaveLength(6);
+            expect(result.tools).toHaveLength(7);
             expect(result.tools[0].name).toBe('run');
             expect(result.tools[0].description).toContain('AI Agent Runner');
             expect(result.tools[1].name).toBe('list_processes');
             expect(result.tools[2].name).toBe('get_result');
             expect(result.tools[3].name).toBe('wait');
-            expect(result.tools[4].name).toBe('kill_process');
-            expect(result.tools[5].name).toBe('cleanup_processes');
+            expect(result.tools[4].name).toBe('peek');
+            expect(result.tools[5].name).toBe('kill_process');
+            expect(result.tools[6].name).toBe('cleanup_processes');
         });
         it('should handle CallToolRequest', async () => {
             mockHomedir.mockReturnValue('/home/user');

package/dist/__tests__/utils/opencode-mock.js

@@ -0,0 +1,91 @@
+import { chmodSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function createOpenCodeMock(dir, options = {}) {
+    const scriptPath = join(dir, 'mock-opencode');
+    const defaultSessionId = options.defaultSessionId || 'ses-opencode-default';
+    const argsLogPath = options.argsLogPath;
+    const argsLogSection = argsLogPath
+        ? `printf '%s\n' "$*" >> "${argsLogPath}"\n`
+        : '';
+    writeFileSync(scriptPath, `#!/bin/bash
+set -euo pipefail
+
+prompt=""
+session_id=""
+session_provided=0
+model=""
+work_dir=""
+
+${argsLogSection}if [[ "\${1:-}" == "run" ]]; then
+  shift
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --format)
+      shift 2
+      ;;
+    --dir)
+      work_dir="$2"
+      shift 2
+      ;;
+    --session)
+      session_id="$2"
+      session_provided=1
+      shift 2
+      ;;
+    --model)
+      model="$2"
+      shift 2
+      ;;
+    *)
+      prompt="$1"
+      shift
+      ;;
+  esac
+done
+
+if [[ -z "$session_id" ]]; then
+  session_id="${defaultSessionId}"
+fi
+
+if [[ "$prompt" == *"sleep"* ]]; then
+  sleep 5
+fi
+
+if [[ "$prompt" == *"fail"* ]]; then
+  printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
+  printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"Partial failure output"}}\n' "$session_id"
+  printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":42},"cost":0}}\n' "$session_id"
+  printf 'OpenCode failed for %s in %s\n' "$model" "$work_dir" >&2
+  exit 7
+fi
+
+if [[ "$prompt" == *"multi-step"* ]]; then
+  printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
+  printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"First step"}}\n' "$session_id"
+  printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":11},"cost":0}}\n' "$session_id"
+  printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
+  printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"Second step"}}\n' "$session_id"
+  printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":22},"cost":1}}\n' "$session_id"
+  exit 0
+fi
+
+message_prefix="Initial"
+if [[ $session_provided -eq 1 ]]; then
+  message_prefix="Resumed"
+fi
+if [[ -n "$model" ]]; then
+  message_prefix="Model $model"
+  if [[ $session_provided -eq 1 ]]; then
+    message_prefix="Resumed model $model"
+  fi
+fi
+
+printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
+printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"%s: %s"}}\n' "$session_id" "$message_prefix" "$prompt"
+printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":11833},"cost":0}}\n' "$session_id"
+`, 'utf8');
+    chmodSync(scriptPath, 0o755);
+    return { scriptPath, argsLogPath };
+}

package/dist/__tests__/validation.test.js

@@ -63,7 +63,6 @@ describe('Argument Validation Tests', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         vi.resetModules();
-        vi.unmock('../server.js');
         consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
         // Set up process.env
         process.env = { ...process.env };
@@ -73,6 +72,7 @@ describe('Argument Validation Tests', () => {
             mockHomedir.mockReturnValue('/home/user');
             mockExistsSync.mockReturnValue(true);
             setupServerMock();
+            vi.doUnmock('../server.js');
             const module = await import('../server.js');
             // @ts-ignore
             const { ClaudeCodeServer } = module;
@@ -99,6 +99,7 @@ describe('Argument Validation Tests', () => {
             mockHomedir.mockReturnValue('/home/user');
             mockExistsSync.mockReturnValue(true);
             setupServerMock();
+            vi.doUnmock('../server.js');
             const module = await import('../server.js');
             // @ts-ignore
             const { ClaudeCodeServer } = module;
@@ -183,7 +184,7 @@ describe('Argument Validation Tests', () => {
             vi.mocked(existsSync).mockReturnValue(true);
             vi.mocked(homedir).mockReturnValue('/home/user');
             const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
-            vi.mocked(Server).mockImplementation(() => {
+            vi.mocked(Server).mockImplementation(function () {
                 mockServerInstance = {
                     setRequestHandler: vi.fn((schema, handler) => {
                         handlers.set(schema.name, handler);
@@ -194,6 +195,7 @@ describe('Argument Validation Tests', () => {
                 };
                 return mockServerInstance;
             });
+            vi.doUnmock('../server.js');
             const module = await import('../server.js');
             // @ts-ignore
             const { ClaudeCodeServer } = module;
@@ -266,5 +268,41 @@ describe('Argument Validation Tests', () => {
                 }
             })).rejects.toThrow(/reasoning_effort/i);
         });
+        it.each([
+            'oc-',
+            'oc-openai',
+            'oc-/gpt-5.4',
+            'oc-openai/',
+            ' oc-openai/gpt-5.4',
+            'oc-openai/gpt-5.4 ',
+        ])('should reject malformed OpenCode model syntax at runtime: %s', async (model) => {
+            await setupServer();
+            const handler = handlers.get('callTool');
+            await expect(handler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test',
+                        workFolder: '/tmp',
+                        model,
+                    }
+                }
+            })).rejects.toThrow('Invalid OpenCode model. Expected exact syntax oc-<provider/model>.');
+        });
+        it('should reject reasoning_effort for OpenCode runtime requests', async () => {
+            await setupServer();
+            const handler = handlers.get('callTool');
+            await expect(handler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test',
+                        workFolder: '/tmp',
+                        model: 'opencode',
+                        reasoning_effort: 'high',
+                    }
+                }
+            })).rejects.toThrow('reasoning_effort is not supported for opencode.');
+        });
     });
 });

package/dist/app/cli.js

@@ -2,11 +2,13 @@ import { runMcpServer } from './mcp.js';
 import { CliProcessService } from '../cli-process-service.js';
 import { getCliDoctorStatus } from '../cli-utils.js';
 import { getModelsPayload } from '../model-catalog.js';
+import { validatePeekPids, validatePeekTimeSec } from '../peek.js';
 export const CLI_HELP_TEXT = `Usage: ai-cli <command> [options]
 
 Commands:
   run       Start an AI CLI process in the background
   wait      Wait for one or more pids
+  peek      Observe new natural-language agent messages for a short window
   ps        List tracked processes
   result    Get the current result for a pid
   kill      Terminate a tracked pid
@@ -24,9 +26,9 @@ Options:
   --cwd <path>                 Working directory
   --prompt <text>              Prompt text
   --prompt-file <path>         Path to a prompt file
-  --model <model>              Model name or alias (e.g. sonnet, claude-ultra, gpt-5.2-codex, codex-ultra, gemini-2.5-pro, gemini-ultra, forge)
-  --session-id <id>            Resume a previous session
-  --reasoning-effort <level>   Reasoning level for Claude/Codex only
+  --model <model>              Model name or alias (e.g. sonnet, claude-ultra, gpt-5.2-codex, codex-ultra, gemini-2.5-pro, gemini-ultra, forge, opencode, oc-openai/gpt-5.4)
+  --session-id <id>            Resume a previous session, including OpenCode in-place resumes
+  --reasoning-effort <level>   Reasoning level for Claude/Codex only; unsupported for Gemini, Forge, and OpenCode
   --help, -h                   Show this help message
 
 Compatibility aliases:
@@ -53,6 +55,16 @@ Options:
   --verbose                    Return full metadata and detailed parsed output
   --help, -h                   Show this help message
 `;
+export const PEEK_HELP_TEXT = `Usage: ai-cli peek <pid...> [options]
+
+Observe new natural-language agent messages for a short one-shot window.
+In v1, message extraction is supported for Codex, Claude, OpenCode, and Gemini; Forge returns status with messages: [].
+This is not a history API, gapless streaming, or stdout/stderr tailing. No --follow mode is available in v1.
+
+Options:
+  --time <seconds>             Observation window in seconds. Defaults to 10, maximum 60
+  --help, -h                   Show this help message
+`;
 export const KILL_HELP_TEXT = `Usage: ai-cli kill <pid>
 
 Terminate a tracked process.
@@ -83,7 +95,7 @@ Options:
 `;
 export const DOCTOR_HELP_TEXT = `Usage: ai-cli doctor
 
-Check whether supported AI CLI binaries are available.
+Check whether supported AI CLI binaries are available, including OpenCode.
 
 Options:
   --help, -h                   Show this help message
@@ -107,6 +119,7 @@ const defaultDeps = {
     listProcesses: () => getCliProcessService().listProcesses(),
     getProcessResult: (pid, verbose) => getCliProcessService().getProcessResult(pid, verbose),
     waitForProcesses: (pids, timeoutSeconds, verbose) => getCliProcessService().waitForProcesses(pids, timeoutSeconds, verbose),
+    peekProcesses: (pids, peekTimeSec) => getCliProcessService().peekProcesses(pids, peekTimeSec),
     killProcess: (pid) => getCliProcessService().killProcess(pid),
     cleanupProcesses: () => getCliProcessService().cleanupProcesses(),
     getDoctorStatus: () => getCliDoctorStatus(),
@@ -161,8 +174,11 @@ function writeJson(stdout, value) {
 function hasHelpFlag(flags) {
     return 'help' in flags || 'h' in flags;
 }
+function parsePeekCliPids(values) {
+    return validatePeekPids(values.map((value) => Number(value)));
+}
 export async function runCli(argv, deps = {}) {
-    const { stdout, stderr, startMcpServer, runProcess, listProcesses, getProcessResult, waitForProcesses, killProcess, cleanupProcesses, getDoctorStatus, } = { ...defaultDeps, ...deps };
+    const { stdout, stderr, startMcpServer, runProcess, listProcesses, getProcessResult, waitForProcesses, peekProcesses, killProcess, cleanupProcesses, getDoctorStatus, } = { ...defaultDeps, ...deps };
     const [command] = argv;
     if (!command || command === 'help' || command === '--help' || command === '-h') {
         stdout(CLI_HELP_TEXT);
@@ -258,6 +274,32 @@ export async function runCli(argv, deps = {}) {
         writeJson(stdout, await waitForProcesses(pids, timeout, 'verbose' in flags));
         return 0;
     }
+    if (command === 'peek') {
+        const { positionals, flags } = parseArgs(argv.slice(1));
+        if (hasHelpFlag(flags)) {
+            stdout(PEEK_HELP_TEXT);
+            return 0;
+        }
+        if ('follow' in flags) {
+            stderr('peek does not support --follow in v1\n');
+            stdout(CLI_HELP_TEXT);
+            return 1;
+        }
+        let pids;
+        let peekTimeSec;
+        try {
+            pids = parsePeekCliPids(positionals);
+            const timeRaw = getFirstFlag(flags, ['time']);
+            peekTimeSec = validatePeekTimeSec(timeRaw === undefined ? undefined : Number(timeRaw));
+        }
+        catch (error) {
+            stderr(`${error.message}\n`);
+            stdout(CLI_HELP_TEXT);
+            return 1;
+        }
+        writeJson(stdout, await peekProcesses(pids, peekTimeSec));
+        return 0;
+    }
     if (command === 'kill') {
         const { positionals, flags } = parseArgs(argv.slice(1));
         if (hasHelpFlag(flags)) {

package/dist/app/mcp.js

@@ -2,8 +2,9 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { spawn } from 'node:child_process';
-import { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from '../cli-utils.js';
+import { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from '../cli-utils.js';
 import { getModelParameterDescription, getSupportedModelsDescription } from '../model-catalog.js';
+import { validatePeekPids, validatePeekTimeSec } from '../peek.js';
 import { ProcessService } from '../process-service.js';
 // Server version - update this when releasing new versions
 const SERVER_VERSION = "2.2.0";
@@ -59,6 +60,7 @@ export class ClaudeCodeServer {
     codexCliPath;
     geminiCliPath;
     forgeCliPath;
+    opencodeCliPath;
     processService;
     sigintHandler;
     packageVersion;
@@ -67,10 +69,12 @@ export class ClaudeCodeServer {
         this.codexCliPath = findCodexCli();
         this.geminiCliPath = findGeminiCli();
         this.forgeCliPath = findForgeCli();
+        this.opencodeCliPath = findOpencodeCli();
         console.error(`[Setup] Using Claude CLI command/path: ${this.claudeCliPath}`);
         console.error(`[Setup] Using Codex CLI command/path: ${this.codexCliPath}`);
         console.error(`[Setup] Using Gemini CLI command/path: ${this.geminiCliPath}`);
         console.error(`[Setup] Using Forge CLI command/path: ${this.forgeCliPath}`);
+        console.error(`[Setup] Using OpenCode CLI command/path: ${this.opencodeCliPath}`);
         this.packageVersion = SERVER_VERSION;
         this.processService = new ProcessService({
             cliPaths: {
@@ -78,6 +82,7 @@ export class ClaudeCodeServer {
                 codex: this.codexCliPath,
                 gemini: this.geminiCliPath,
                 forge: this.forgeCliPath,
+                opencode: this.opencodeCliPath,
             },
         });
         this.server = new Server({
@@ -101,7 +106,7 @@ export class ClaudeCodeServer {
             tools: [
                 {
                     name: 'run',
-                    description: `AI Agent Runner: Starts a Claude, Codex, Gemini, or Forge CLI process in the background and returns a PID immediately. Use list_processes and get_result to monitor progress.
+                    description: `AI Agent Runner: Starts a Claude, Codex, Gemini, Forge, or OpenCode CLI process in the background and returns a PID immediately. Use list_processes and get_result to monitor progress.
 
 • File ops: Create, read, (fuzzy) edit, move, copy, delete, list files, analyze/ocr images, file content analysis
 • Code: Generate / analyse / refactor / fix
@@ -145,11 +150,11 @@ ${getSupportedModelsDescription()}
                             },
                             reasoning_effort: {
                                 type: 'string',
-                                description: 'Reasoning control for Claude and Codex. Claude uses --effort with "low", "medium", "high". Codex uses model_reasoning_effort with "low", "medium", "high", "xhigh". Forge does not support reasoning_effort in this integration.',
+                                description: 'Reasoning control for Claude and Codex. Claude uses --effort with "low", "medium", "high". Codex uses model_reasoning_effort with "low", "medium", "high", "xhigh". Gemini, Forge, and OpenCode do not support reasoning_effort in this integration.',
                             },
                             session_id: {
                                 type: 'string',
-                                description: 'Optional session ID to resume a previous session. Supported for: haiku, sonnet, opus, gemini-2.5-pro, gemini-2.5-flash, gemini-3.1-pro-preview, gemini-3-pro-preview, gemini-3-flash-preview, forge.',
+                                description: '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.',
                             },
                         },
                         required: ['workFolder'],
@@ -204,6 +209,25 @@ ${getSupportedModelsDescription()}
                         required: ['pids'],
                     },
                 },
+                {
+                    name: 'peek',
+                    description: 'One-shot short observation window for running child agents. Returns only natural-language agent messages observed during this call; not a history API, not gapless streaming, and not stdout/stderr tailing. In v1, message extraction is supported for Codex, Claude, OpenCode, and Gemini; Forge returns status with messages: [].',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            pids: {
+                                type: 'array',
+                                items: { type: 'number' },
+                                description: 'Process IDs returned by run. Duplicates are deduplicated server-side, preserving first occurrence order. Unknown PIDs are returned per process as not_found.',
+                            },
+                            peek_time_sec: {
+                                type: 'number',
+                                description: 'Optional positive integer observation window in seconds. Defaults to 10; maximum is 60.',
+                            },
+                        },
+                        required: ['pids'],
+                    },
+                },
                 {
                     name: 'kill_process',
                     description: 'Terminate a running AI agent process by PID.',
@@ -241,6 +265,8 @@ ${getSupportedModelsDescription()}
                     return this.handleGetResult(toolArguments);
                 case 'wait':
                     return this.handleWait(toolArguments);
+                case 'peek':
+                    return this.handlePeek(toolArguments);
                 case 'kill_process':
                     return this.handleKillProcess(toolArguments);
                 case 'cleanup_processes':
@@ -322,6 +348,29 @@ ${getSupportedModelsDescription()}
             throw new McpError(code, error.message);
         }
     }
+    async handlePeek(toolArguments) {
+        let pids;
+        let peekTimeSec;
+        try {
+            pids = validatePeekPids(toolArguments.pids);
+            peekTimeSec = validatePeekTimeSec(toolArguments.peek_time_sec);
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InvalidParams, error.message);
+        }
+        try {
+            const response = await this.processService.peekProcesses(pids, peekTimeSec);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(response, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to peek processes: ${error.message}`);
+        }
+    }
     async handleKillProcess(toolArguments) {
         if (!toolArguments.pid || typeof toolArguments.pid !== 'number') {
             throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pid');