ai-cli-mcp 2.15.0 → 2.17.0

package/src/__tests__/parsers.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseCodexOutput, parseClaudeOutput, parseForgeOutput, parseOpenCodeOutput } from '../parsers.js';
+import { parseCodexOutput, parseClaudeOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput, PeekMessageExtractor } from '../parsers.js';
 
 describe('parseCodexOutput', () => {
   it('should parse basic Codex output with message and session_id', () => {
@@ -65,6 +65,193 @@ INVALID_JSON
   });
 });
 
+describe('PeekMessageExtractor', () => {
+  const ts = '2026-04-11T12:34:56.789Z';
+
+  it('extracts only Codex agent_message text', () => {
+    const extractor = new PeekMessageExtractor('codex');
+    const output = [
+      '{"type":"item.completed","item":{"type":"reasoning","text":"hidden"}}',
+      '{"type":"item.completed","item":{"type":"command_execution","aggregated_output":"secret command output"}}',
+      '{"type":"item.completed","item":{"type":"agent_message","text":"Visible Codex message"}}',
+      '{"msg":{"type":"token_count","total":123}}',
+      '{"msg":{"type":"agent_message","message":"Visible legacy Codex message"}}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { ts, text: 'Visible Codex message' },
+      { ts, text: 'Visible legacy Codex message' },
+    ]);
+  });
+
+  it('extracts only Claude assistant text content', () => {
+    const extractor = new PeekMessageExtractor('claude');
+    const output = [
+      '{"type":"assistant","message":{"content":[{"type":"text","text":"Visible Claude text"},{"type":"tool_use","id":"tool-1","name":"Read","input":{"file_path":"/tmp/a"}}]}}',
+      '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":"secret"}]}}',
+      '{"type":"result","result":"Final result is not peek assistant text"}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { ts, text: 'Visible Claude text' },
+    ]);
+  });
+
+  it('extracts only Gemini assistant message content', () => {
+    const extractor = new PeekMessageExtractor('gemini');
+    const output = [
+      '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}',
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Visible Gemini text","delta":true}',
+      '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.821Z","tool_name":"run_shell_command","parameters":{"command":"echo secret"}}',
+      '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}',
+      '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Final result is not peek assistant text"}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { ts, text: 'Visible Gemini text' },
+    ]);
+  });
+
+  it('joins split Gemini assistant chunks into one peek message on flush', () => {
+    const extractor = new PeekMessageExtractor('gemini');
+    const output = [
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Step 2 done. Starting step ","delta":true}',
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.821Z","role":"assistant","content":"3.","delta":true}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([]);
+    expect(extractor.flush('2026-04-11T12:34:59.000Z')).toEqual([
+      { ts: '2026-04-11T12:34:59.000Z', text: 'Step 2 done. Starting step 3.' },
+    ]);
+  });
+
+  it('emits separate Gemini peek messages when a boundary separates logical messages', () => {
+    const extractor = new PeekMessageExtractor('gemini');
+    const output = [
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Starting step ","delta":true}',
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.821Z","role":"assistant","content":"1.","delta":true}',
+      '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.822Z","tool_name":"run_shell_command","parameters":{"command":"echo secret"}}',
+      '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}',
+      '{"type":"message","timestamp":"2026-04-11T14:45:10.315Z","role":"assistant","content":"Final ","delta":true}',
+      '{"type":"message","timestamp":"2026-04-11T14:45:10.316Z","role":"assistant","content":"answer.","delta":true}',
+      '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Final result response is not peek text","stats":{"total_tokens":21999}}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { ts, text: 'Starting step 1.' },
+      { ts, text: 'Final answer.' },
+    ]);
+    expect(extractor.flush(ts)).toEqual([]);
+  });
+
+  it('does not emit Gemini user, tool, tool result, stats, or result response text', () => {
+    const extractor = new PeekMessageExtractor('gemini');
+    const output = [
+      '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}',
+      '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.821Z","tool_name":"run_shell_command","parameters":{"command":"echo secret"}}',
+      '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}',
+      '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Final result response is not peek text","stats":{"total_tokens":21999}}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([]);
+    expect(extractor.flush(ts)).toEqual([]);
+  });
+
+  it('denies unsupported agents and invalid shapes by default', () => {
+    const extractor = new PeekMessageExtractor('forge');
+    const output = [
+      '{"type":"assistant","message":{"content":[{"type":"text","text":"not supported here"}]}}',
+      '{"type":"item.completed","item":{"type":"agent_message","text":"not supported here"}}',
+      '{"type":"text","part":{"type":"text","text":"not supported here"}}',
+      '{"type":"message","role":"assistant","content":"not supported here"}',
+      'plain stdout',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([]);
+  });
+
+  it('extracts only OpenCode natural-language text events', () => {
+    const extractor = new PeekMessageExtractor('opencode');
+    const output = [
+      '{"type":"text","timestamp":1775918783605,"sessionID":"ses-1","part":{"type":"text","text":"OpenCode visible text"}}',
+      '{"type":"tool_use","timestamp":1775918783606,"sessionID":"ses-1","part":{"type":"tool","state":{"output":"secret command output"},"metadata":{"output":"secret metadata output"}}}',
+      '{"type":"text","timestamp":1775918783607,"sessionID":"ses-1","part":{"type":"tool","text":"wrong part type"}}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { ts, text: 'OpenCode visible text' },
+    ]);
+  });
+
+  it('can flush a complete JSON event without a trailing newline', () => {
+    const extractor = new PeekMessageExtractor('codex');
+    expect(extractor.push('{"type":"item.completed","item":{"type":"agent_message","text":"pending"}}', ts)).toEqual([]);
+    expect(extractor.flush(ts)).toEqual([{ ts, text: 'pending' }]);
+  });
+});
+
+describe('parseGeminiOutput', () => {
+  it('should parse legacy final JSON output', () => {
+    const output = JSON.stringify({
+      session_id: 'gemini-session-json',
+      response: 'Legacy Gemini final response',
+      stats: {
+        total_tokens: 123,
+      },
+    });
+
+    expect(parseGeminiOutput(output)).toEqual({
+      session_id: 'gemini-session-json',
+      response: 'Legacy Gemini final response',
+      stats: {
+        total_tokens: 123,
+      },
+    });
+  });
+
+  it('should normalize a single-line Gemini assistant stream event', () => {
+    const output = '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Only answer","delta":true}';
+
+    const result = parseGeminiOutput(output);
+
+    expect(result).toMatchObject({
+      message: 'Only answer',
+      session_id: null,
+    });
+    expect(result).not.toHaveProperty('type');
+    expect(result).not.toHaveProperty('content');
+  });
+
+  it('should parse Gemini stream-json NDJSON output', () => {
+    const output = [
+      '{"type":"init","timestamp":"2026-04-11T14:44:42.293Z","session_id":"gemini-session-stream","model":"gemini-3.1-pro-preview"}',
+      '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}',
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"First logical assistant response.","delta":true}',
+      '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.821Z","tool_name":"run_shell_command","tool_id":"tool-1","parameters":{"command":"echo hidden"}}',
+      '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","tool_id":"tool-1","status":"success","output":"hidden command output"}',
+      '{"type":"message","timestamp":"2026-04-11T14:45:10.315Z","role":"assistant","content":"Final assistant ","delta":true}',
+      '{"type":"message","timestamp":"2026-04-11T14:45:10.316Z","role":"assistant","content":"response.","delta":true}',
+      '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Result response is not the parsed message","stats":{"total_tokens":21999}}',
+    ].join('\n') + '\n';
+
+    expect(parseGeminiOutput(output)).toEqual({
+      message: 'Final assistant response.',
+      session_id: 'gemini-session-stream',
+      stats: {
+        total_tokens: 21999,
+      },
+      tools: [
+        {
+          tool: 'run_shell_command',
+          input: { command: 'echo hidden' },
+          output: 'hidden command output',
+          status: 'success',
+        },
+      ],
+    });
+  });
+});
+
 describe('parseClaudeOutput', () => {
   it('should parse legacy JSON output', () => {
     const output = JSON.stringify({

package/src/__tests__/peek.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { appendPeekMessages, validatePeekPids, validatePeekTimeSec, type PeekProcessResult } from '../peek.js';
+
+describe('peek helpers', () => {
+  it('dedupes pids while preserving first occurrence order', () => {
+    expect(validatePeekPids([3, 1, 3, 2, 1])).toEqual([3, 1, 2]);
+  });
+
+  it('validates pid and time limits', () => {
+    expect(() => validatePeekPids([])).toThrow(/1..32/);
+    expect(() => validatePeekPids([1.5])).toThrow(/positive safe integers/);
+    expect(() => validatePeekPids([Number.MAX_SAFE_INTEGER + 1])).toThrow(/positive safe integers/);
+    expect(validatePeekTimeSec(undefined)).toBe(10);
+    expect(validatePeekTimeSec(60)).toBe(60);
+    expect(() => validatePeekTimeSec(0)).toThrow(/positive integer/);
+    expect(() => validatePeekTimeSec(1.5)).toThrow(/positive integer/);
+    expect(() => validatePeekTimeSec(61)).toThrow(/positive integer/);
+  });
+
+  it('keeps the first 50 messages and marks truncation when later messages are dropped', () => {
+    const process: PeekProcessResult = {
+      pid: 123,
+      agent: 'codex',
+      status: 'running',
+      messages: [],
+      truncated: false,
+      error: null,
+    };
+
+    appendPeekMessages(
+      process,
+      Array.from({ length: 55 }, (_, index) => ({
+        ts: '2026-04-11T12:34:56.789Z',
+        text: `message ${index}`,
+      })),
+    );
+
+    expect(process.messages).toHaveLength(50);
+    expect(process.messages[0].text).toBe('message 0');
+    expect(process.messages[49].text).toBe('message 49');
+    expect(process.truncated).toBe(true);
+  });
+});

package/src/__tests__/process-management.test.ts

@@ -118,6 +118,190 @@ describe('Process Management Tests', () => {
       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() as any;
+      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() as any;
+      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() as any;
+      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();
       

package/src/__tests__/server.test.ts

@@ -497,14 +497,15 @@ describe('ClaudeCodeServer Unit Tests', () => {
       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 () => {

package/src/app/cli.ts

@@ -2,12 +2,14 @@ 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
@@ -58,6 +60,17 @@ Options:
   --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.
@@ -118,6 +131,7 @@ interface CliDeps {
   listProcesses: () => Promise<any>;
   getProcessResult: (pid: number, verbose: boolean) => Promise<any>;
   waitForProcesses: (pids: number[], timeoutSeconds?: number, verbose?: boolean) => Promise<any>;
+  peekProcesses: (pids: number[], peekTimeSec?: number) => Promise<any>;
   killProcess: (pid: number) => Promise<any>;
   cleanupProcesses: () => Promise<any>;
   getDoctorStatus: () => any;
@@ -140,6 +154,7 @@ const defaultDeps: CliDeps = {
   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(),
@@ -204,6 +219,10 @@ function hasHelpFlag(flags: Record<string, string>): boolean {
   return 'help' in flags || 'h' in flags;
 }
 
+function parsePeekCliPids(values: string[]): number[] {
+  return validatePeekPids(values.map((value) => Number(value)));
+}
+
 export async function runCli(argv: string[], deps: Partial<CliDeps> = {}): Promise<number> {
   const {
     stdout,
@@ -213,6 +232,7 @@ export async function runCli(argv: string[], deps: Partial<CliDeps> = {}): Promi
     listProcesses,
     getProcessResult,
     waitForProcesses,
+    peekProcesses,
     killProcess,
     cleanupProcesses,
     getDoctorStatus,
@@ -323,6 +343,34 @@ export async function runCli(argv: string[], deps: Partial<CliDeps> = {}): Promi
     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: number[];
+    let peekTimeSec: number;
+    try {
+      pids = parsePeekCliPids(positionals);
+      const timeRaw = getFirstFlag(flags, ['time']);
+      peekTimeSec = validatePeekTimeSec(timeRaw === undefined ? undefined : Number(timeRaw));
+    } catch (error: any) {
+      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/src/app/mcp.ts

@@ -10,6 +10,7 @@ import {
 import { spawn } from 'node:child_process';
 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
@@ -230,6 +231,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.',
@@ -270,6 +290,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':
@@ -359,6 +381,30 @@ ${getSupportedModelsDescription()}
     }
   }
 
+  private async handlePeek(toolArguments: any): Promise<ServerResult> {
+    let pids: number[];
+    let peekTimeSec: number;
+
+    try {
+      pids = validatePeekPids(toolArguments.pids);
+      peekTimeSec = validatePeekTimeSec(toolArguments.peek_time_sec);
+    } catch (error: any) {
+      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: any) {
+      throw new McpError(ErrorCode.InternalError, `Failed to peek processes: ${error.message}`);
+    }
+  }
+
   private async handleKillProcess(toolArguments: any): Promise<ServerResult> {
     if (!toolArguments.pid || typeof toolArguments.pid !== 'number') {
       throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pid');

package/src/cli-builder.ts

@@ -216,10 +216,10 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
       args.push('--model', resolvedModel);
     }
 
-    args.push('--skip-git-repo-check', '--full-auto', '--json', prompt);
+    args.push('--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', '--json', prompt);
   } else if (agent === 'gemini') {
     cliPath = options.cliPaths.gemini;
-    args = ['-y', '--output-format', 'json'];
+    args = ['-y', '--output-format', 'stream-json'];
 
     if (options.session_id && typeof options.session_id === 'string') {
       args.push('-r', options.session_id);