ai-cli-mcp 2.12.0 → 2.14.0

package/src/__tests__/mcp-contract.test.ts

@@ -1,5 +1,5 @@
 import { afterAll, afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { chmodSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { cleanupSharedMock, getSharedMock } from './utils/persistent-mock.js';
@@ -19,6 +19,53 @@ function expectProcessSummaryShape(processInfo: any): void {
   });
 }
 
+function createForgeMockScript(dir: string, argsLogPath: string): string {
+  const scriptPath = join(dir, 'mock-forge');
+  writeFileSync(
+    scriptPath,
+    `#!/bin/bash
+set -euo pipefail
+
+log_file="${argsLogPath}"
+prompt=""
+conversation_id=""
+
+printf '%s\\n' "$*" >> "$log_file"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -C)
+      shift 2
+      ;;
+    -p)
+      prompt="$2"
+      shift 2
+      ;;
+    --conversation-id)
+      conversation_id="$2"
+      shift 2
+      ;;
+    *)
+      shift
+      ;;
+  esac
+done
+
+if [[ -n "$conversation_id" ]]; then
+  printf '● [21:09:33] Continue %s\\n' "$conversation_id"
+  printf 'Resumed: %s\\n' "$prompt"
+  printf '● [21:09:37] Finished %s\\n' "$conversation_id"
+else
+  printf '● [21:09:01] Initialize forge-session-1\\n'
+  printf 'Initial: %s\\n' "$prompt"
+  printf '● [21:09:08] Finished forge-session-1\\n'
+fi
+`
+  );
+  chmodSync(scriptPath, 0o755);
+  return scriptPath;
+}
+
 describe('MCP Contract Tests', () => {
   let client: MCPTestClient;
   let testDir: string;
@@ -75,6 +122,7 @@ describe('MCP Contract Tests', () => {
     expect(Object.keys(waitTool.inputSchema.properties).sort()).toEqual([
       'pids',
       'timeout',
+      'verbose',
     ]);
   });
 
@@ -108,22 +156,32 @@ describe('MCP Contract Tests', () => {
       pid: runData.pid,
       agent: 'claude',
       status: expect.any(String),
-      startTime: expect.any(String),
-      workFolder: testDir,
-      prompt: 'create a file called contract.txt with content "hello"',
       model: 'haiku',
       stdout: expect.any(String),
       stderr: expect.any(String),
     });
+    expect(getResultData).toHaveProperty('exitCode');
+    expect(getResultData).not.toHaveProperty('startTime');
+    expect(getResultData).not.toHaveProperty('workFolder');
+    expect(getResultData).not.toHaveProperty('prompt');
 
     const waitResponse = await client.callTool('wait', { pids: [runData.pid], timeout: 5 });
     const waitData = parseToolJson(waitResponse);
 
     expect(Array.isArray(waitData)).toBe(true);
     expect(waitData).toHaveLength(1);
-    expect(waitData[0].pid).toBe(runData.pid);
-    expect(waitData[0].agent).toBe('claude');
-    expect(waitData[0].status).toBe('completed');
+    expect(waitData[0]).toMatchObject({
+      pid: runData.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: 0,
+      model: 'haiku',
+      stdout: expect.any(String),
+      stderr: expect.any(String),
+    });
+    expect(waitData[0]).not.toHaveProperty('startTime');
+    expect(waitData[0]).not.toHaveProperty('workFolder');
+    expect(waitData[0]).not.toHaveProperty('prompt');
 
     const cleanupResponse = await client.callTool('cleanup_processes', {});
     const cleanupData = parseToolJson(cleanupResponse);
@@ -136,13 +194,14 @@ describe('MCP Contract Tests', () => {
     expect(cleanupData.removedPids).toContain(runData.pid);
   });
 
-  it('accepts prompt_file and keeps the run response shape stable', async () => {
+  it('preserves successful prompt_file execution through the MCP process path', async () => {
     const promptFile = join(testDir, 'prompt.txt');
-    writeFileSync(promptFile, 'create a file called from-file.txt');
+    writeFileSync(promptFile, 'Create a file from prompt_file');
 
     const runResponse = await client.callTool('run', {
       prompt_file: promptFile,
       workFolder: testDir,
+      model: 'haiku',
     });
     const runData = parseToolJson(runResponse);
 
@@ -152,6 +211,263 @@ describe('MCP Contract Tests', () => {
       agent: 'claude',
       message: expect.any(String),
     });
+
+    const waitResponse = await client.callTool('wait', { pids: [runData.pid], timeout: 5 });
+    const waitData = parseToolJson(waitResponse);
+
+    expect(waitData).toHaveLength(1);
+    expect(waitData[0]).toMatchObject({
+      pid: runData.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: 0,
+      model: 'haiku',
+      stdout: expect.stringContaining('Created file successfully'),
+      stderr: '',
+    });
+    expect(waitData[0]).not.toHaveProperty('prompt');
+    expect(waitData[0]).not.toHaveProperty('workFolder');
+    expect(waitData[0]).not.toHaveProperty('startTime');
+  });
+
+  it('returns compact results by default and full results when verbose is true for parsed output', async () => {
+    await client.disconnect();
+
+    const verboseMockPath = join(testDir, 'verbose-claude');
+    writeFileSync(
+      verboseMockPath,
+      `#!/bin/bash
+printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"tool_use","id":"tool-1","name":"Read","input":{"file_path":"/tmp/demo.txt"}}]}}'
+printf '%s\n' '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":[{"type":"text","text":"demo output"}]}]}}'
+printf '%s\n' '{"type":"result","result":"Completed contract verbose test"}'
+printf '%s\n' '{"type":"system","session_id":"session-verbose-1"}'
+`
+    );
+    chmodSync(verboseMockPath, 0o755);
+
+    client = createTestClient({ claudeCliName: verboseMockPath, debug: false });
+    await client.connect();
+
+    const runResponse = await client.callTool('run', {
+      prompt: 'verbose-shape-test',
+      workFolder: testDir,
+    });
+    const runData = parseToolJson(runResponse);
+
+    const completedWait = parseToolJson(await client.callTool('wait', { pids: [runData.pid], timeout: 5 }));
+    expect(completedWait).toHaveLength(1);
+    expect(completedWait[0].status).toBe('completed');
+
+    const compactResult = parseToolJson(await client.callTool('get_result', { pid: runData.pid }));
+    expect(compactResult).toMatchObject({
+      pid: runData.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: 0,
+      model: null,
+      session_id: 'session-verbose-1',
+      agentOutput: {
+        message: 'Completed contract verbose test',
+        session_id: 'session-verbose-1',
+      },
+    });
+    expect(compactResult).not.toHaveProperty('startTime');
+    expect(compactResult).not.toHaveProperty('workFolder');
+    expect(compactResult).not.toHaveProperty('prompt');
+    expect(compactResult.agentOutput).not.toHaveProperty('tools');
+
+    const verboseResult = parseToolJson(await client.callTool('get_result', { pid: runData.pid, verbose: true }));
+    expect(verboseResult).toMatchObject({
+      pid: runData.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: 0,
+      model: null,
+      startTime: expect.any(String),
+      workFolder: testDir,
+      prompt: 'verbose-shape-test',
+      session_id: 'session-verbose-1',
+      agentOutput: {
+        message: 'Completed contract verbose test',
+        session_id: 'session-verbose-1',
+        tools: [
+          {
+            tool: 'Read',
+            input: { file_path: '/tmp/demo.txt' },
+            output: 'demo output',
+          },
+        ],
+      },
+    });
+
+    const compactWait = parseToolJson(await client.callTool('wait', { pids: [runData.pid], timeout: 5 }));
+    expect(compactWait).toHaveLength(1);
+    expect(compactWait[0]).toMatchObject({
+      pid: runData.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: 0,
+      model: null,
+      session_id: 'session-verbose-1',
+      agentOutput: {
+        message: 'Completed contract verbose test',
+        session_id: 'session-verbose-1',
+      },
+    });
+    expect(compactWait[0]).not.toHaveProperty('startTime');
+    expect(compactWait[0]).not.toHaveProperty('workFolder');
+    expect(compactWait[0]).not.toHaveProperty('prompt');
+    expect(compactWait[0].agentOutput).not.toHaveProperty('tools');
+
+    const verboseWait = parseToolJson(await client.callTool('wait', { pids: [runData.pid], timeout: 5, verbose: true }));
+    expect(verboseWait).toHaveLength(1);
+    expect(verboseWait[0]).toMatchObject({
+      pid: runData.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: 0,
+      model: null,
+      startTime: expect.any(String),
+      workFolder: testDir,
+      prompt: 'verbose-shape-test',
+      session_id: 'session-verbose-1',
+      agentOutput: {
+        message: 'Completed contract verbose test',
+        session_id: 'session-verbose-1',
+        tools: [
+          {
+            tool: 'Read',
+            input: { file_path: '/tmp/demo.txt' },
+            output: 'demo output',
+          },
+        ],
+      },
+    });
+  });
+
+  it('covers forge end-to-end through the MCP process path', async () => {
+    await client.disconnect();
+
+    const forgeArgsLogPath = join(testDir, 'forge-args.log');
+    const forgeMockPath = createForgeMockScript(testDir, forgeArgsLogPath);
+
+    client = createTestClient({
+      debug: false,
+      env: {
+        FORGE_CLI_NAME: forgeMockPath,
+      },
+    });
+    await client.connect();
+
+    const initialRunResponse = await client.callTool('run', {
+      prompt: 'forge-initial-prompt',
+      workFolder: testDir,
+      model: 'forge',
+    });
+    const initialRunData = parseToolJson(initialRunResponse);
+
+    expect(initialRunData).toEqual({
+      pid: expect.any(Number),
+      status: 'started',
+      agent: 'forge',
+      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: 'forge',
+      status: 'completed',
+      session_id: 'forge-session-1',
+      agentOutput: {
+        message: 'Initial: forge-initial-prompt',
+        session_id: 'forge-session-1',
+      },
+    });
+
+    const initialResultResponse = await client.callTool('get_result', { pid: initialRunData.pid });
+    const initialResultData = parseToolJson(initialResultResponse);
+
+    expect(initialResultData).toMatchObject({
+      pid: initialRunData.pid,
+      agent: 'forge',
+      status: 'completed',
+      session_id: 'forge-session-1',
+      agentOutput: {
+        message: 'Initial: forge-initial-prompt',
+        session_id: 'forge-session-1',
+      },
+    });
+
+    const resumedRunResponse = await client.callTool('run', {
+      prompt: 'forge-resume-prompt',
+      workFolder: testDir,
+      model: 'forge',
+      session_id: 'forge-session-1',
+    });
+    const resumedRunData = parseToolJson(resumedRunResponse);
+
+    expect(resumedRunData).toEqual({
+      pid: expect.any(Number),
+      status: 'started',
+      agent: 'forge',
+      message: expect.any(String),
+    });
+
+    const resumedWaitResponse = await client.callTool('wait', { pids: [resumedRunData.pid], timeout: 5 });
+    const resumedWaitData = parseToolJson(resumedWaitResponse);
+
+    expect(resumedWaitData).toHaveLength(1);
+    expect(resumedWaitData[0]).toMatchObject({
+      pid: resumedRunData.pid,
+      agent: 'forge',
+      status: 'completed',
+      session_id: 'forge-session-1',
+      agentOutput: {
+        message: 'Resumed: forge-resume-prompt',
+        session_id: 'forge-session-1',
+      },
+    });
+
+    const resumedResultResponse = await client.callTool('get_result', { pid: resumedRunData.pid });
+    const resumedResultData = parseToolJson(resumedResultResponse);
+
+    expect(resumedResultData).toMatchObject({
+      pid: resumedRunData.pid,
+      agent: 'forge',
+      status: 'completed',
+      session_id: 'forge-session-1',
+      agentOutput: {
+        message: 'Resumed: forge-resume-prompt',
+        session_id: 'forge-session-1',
+      },
+    });
+
+    const forgeInvocations = readFileSync(forgeArgsLogPath, 'utf-8').trim().split('\n');
+    expect(forgeInvocations).toHaveLength(2);
+    expect(forgeInvocations[0]).toContain(`-C ${testDir}`);
+    expect(forgeInvocations[0]).toContain('-p forge-initial-prompt');
+    expect(forgeInvocations[0]).not.toContain('--model');
+    expect(forgeInvocations[0]).not.toContain('--agent');
+    expect(forgeInvocations[0]).not.toContain('--conversation-id');
+
+    expect(forgeInvocations[1]).toContain(`-C ${testDir}`);
+    expect(forgeInvocations[1]).toContain('--conversation-id forge-session-1');
+    expect(forgeInvocations[1]).toContain('-p forge-resume-prompt');
+    expect(forgeInvocations[1]).not.toContain('--model');
+    expect(forgeInvocations[1]).not.toContain('--agent');
+
+    await expect(
+      client.callTool('run', {
+        prompt: 'forge-invalid-reasoning',
+        workFolder: testDir,
+        model: 'forge',
+        reasoning_effort: 'high',
+      })
+    ).rejects.toThrow(/reasoning_effort is not supported for forge/i);
   });
 
   it('keeps key invalid-input errors stable', async () => {

package/src/__tests__/parsers.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseCodexOutput, parseClaudeOutput } from '../parsers.js';
+import { parseCodexOutput, parseClaudeOutput, parseForgeOutput } from '../parsers.js';
 
 describe('parseCodexOutput', () => {
   it('should parse basic Codex output with message and session_id', () => {
@@ -106,3 +106,46 @@ INVALID_LINE
     expect(result.message).toBe("Success");
   });
 });
+
+describe('parseForgeOutput', () => {
+  it('should parse initialized forge output with a conversation id', () => {
+    const output = `● [21:09:01] Initialize 123e4567-e89b-12d3-a456-426614174000
+Hello from Forge
+● [21:09:08] Finished 123e4567-e89b-12d3-a456-426614174000
+`;
+
+    expect(parseForgeOutput(output)).toEqual({
+      message: 'Hello from Forge',
+      session_id: '123e4567-e89b-12d3-a456-426614174000',
+    });
+  });
+
+  it('should parse resumed forge output with multiline assistant content', () => {
+    const output = `● [21:09:33] Continue conv-123
+Line one
+
+Line three
+● [21:09:37] Finished conv-123
+`;
+
+    expect(parseForgeOutput(output)).toEqual({
+      message: 'Line one\n\nLine three',
+      session_id: 'conv-123',
+    });
+  });
+
+  it('should return the current message while forge output is still in progress', () => {
+    const output = `● [21:09:33] Continue conv-456
+Partial answer
+still streaming`;
+
+    expect(parseForgeOutput(output)).toEqual({
+      message: 'Partial answer\nstill streaming',
+      session_id: 'conv-456',
+    });
+  });
+
+  it('should return null for unrelated forge output', () => {
+    expect(parseForgeOutput('plain text')).toBeNull();
+  });
+});

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

@@ -191,7 +191,8 @@ describe('Process Management Tests', () => {
         params: {
           name: 'get_result',
           arguments: {
-            pid: 12360
+            pid: 12360,
+            verbose: true
           }
         }
       });

package/src/app/cli.ts

@@ -26,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)
+  --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
+  --reasoning-effort <level>   Reasoning level for Claude/Codex only
   --help, -h                   Show this help message
 
 Compatibility aliases:
@@ -41,18 +41,20 @@ Compatibility aliases:
 export const WAIT_HELP_TEXT = `Usage: ai-cli wait <pid...> [options]
 
 Wait for one or more tracked processes to finish.
+By default each result uses the compact shape; set --verbose to include full metadata and detailed parsed output.
 
 Options:
   --timeout <seconds>          Maximum wait time in seconds
+  --verbose                    Return full metadata and detailed parsed output
   --help, -h                   Show this help message
 `;
 
 export const RESULT_HELP_TEXT = `Usage: ai-cli result <pid> [options]
 
-Get the current result for a tracked process.
+Get the current output and status of a tracked process. By default this returns a compact result shape; set --verbose to include full metadata and detailed parsed output.
 
 Options:
-  --verbose                    Include verbose parsed output
+  --verbose                    Return full metadata and detailed parsed output
   --help, -h                   Show this help message
 `;
 
@@ -115,7 +117,7 @@ interface CliDeps {
   }) => Promise<any>;
   listProcesses: () => Promise<any>;
   getProcessResult: (pid: number, verbose: boolean) => Promise<any>;
-  waitForProcesses: (pids: number[], timeoutSeconds?: number) => Promise<any>;
+  waitForProcesses: (pids: number[], timeoutSeconds?: number, verbose?: boolean) => Promise<any>;
   killProcess: (pid: number) => Promise<any>;
   cleanupProcesses: () => Promise<any>;
   getDoctorStatus: () => any;
@@ -137,7 +139,7 @@ const defaultDeps: CliDeps = {
   runProcess: (options) => getCliProcessService().startProcess(options),
   listProcesses: () => getCliProcessService().listProcesses(),
   getProcessResult: (pid, verbose) => getCliProcessService().getProcessResult(pid, verbose),
-  waitForProcesses: (pids, timeoutSeconds) => getCliProcessService().waitForProcesses(pids, timeoutSeconds),
+  waitForProcesses: (pids, timeoutSeconds, verbose) => getCliProcessService().waitForProcesses(pids, timeoutSeconds, verbose),
   killProcess: (pid) => getCliProcessService().killProcess(pid),
   cleanupProcesses: () => getCliProcessService().cleanupProcesses(),
   getDoctorStatus: () => getCliDoctorStatus(),
@@ -317,7 +319,7 @@ export async function runCli(argv: string[], deps: Partial<CliDeps> = {}): Promi
       return 1;
     }
 
-    writeJson(stdout, await waitForProcesses(pids as number[], timeout));
+    writeJson(stdout, await waitForProcesses(pids as number[], timeout, 'verbose' in flags));
     return 0;
   }
 

package/src/app/mcp.ts

@@ -8,7 +8,7 @@ import {
   type ServerResult,
 } from '@modelcontextprotocol/sdk/types.js';
 import { spawn } from 'node:child_process';
-import { debugLog, findClaudeCli, findCodexCli, findGeminiCli } from '../cli-utils.js';
+import { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from '../cli-utils.js';
 import { getModelParameterDescription, getSupportedModelsDescription } from '../model-catalog.js';
 import { ProcessService } from '../process-service.js';
 
@@ -72,6 +72,7 @@ export class ClaudeCodeServer {
   private claudeCliPath: string;
   private codexCliPath: string;
   private geminiCliPath: string;
+  private forgeCliPath: string;
   private processService: ProcessService;
   private sigintHandler?: () => Promise<void>;
   private packageVersion: string;
@@ -80,15 +81,18 @@ export class ClaudeCodeServer {
     this.claudeCliPath = findClaudeCli();
     this.codexCliPath = findCodexCli();
     this.geminiCliPath = findGeminiCli();
+    this.forgeCliPath = findForgeCli();
     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}`);
     this.packageVersion = SERVER_VERSION;
     this.processService = new ProcessService({
       cliPaths: {
         claude: this.claudeCliPath,
         codex: this.codexCliPath,
         gemini: this.geminiCliPath,
+        forge: this.forgeCliPath,
       },
     });
 
@@ -119,7 +123,7 @@ export class ClaudeCodeServer {
       tools: [
         {
           name: 'run',
-          description: `AI Agent Runner: Starts a Claude, Codex, or Gemini 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, or Forge 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
@@ -163,11 +167,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".',
+                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.',
               },
               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.',
+                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.',
               },
             },
             required: ['workFolder'],
@@ -183,7 +187,7 @@ ${getSupportedModelsDescription()}
         },
         {
           name: 'get_result',
-          description: 'Get the current output and status of an AI agent process by PID. Returns the output from the agent including session_id (if applicable), along with process metadata.',
+          description: 'Get the current output and status of an AI agent process by PID. Defaults to a compact result shape; set verbose to true for full metadata and detailed parsed output.',
           inputSchema: {
             type: 'object',
             properties: {
@@ -193,7 +197,7 @@ ${getSupportedModelsDescription()}
               },
               verbose: {
                 type: 'boolean',
-                description: 'Optional: If true, returns detailed execution information including tool usage history. Defaults to false.',
+                description: 'Optional: If true, returns the full result shape including metadata fields and detailed parsed output such as tool usage history. Defaults to false.',
               }
             },
             required: ['pid'],
@@ -201,7 +205,7 @@ ${getSupportedModelsDescription()}
         },
         {
           name: 'wait',
-          description: 'Wait for multiple AI agent processes to complete and return their results. Blocks until all specified PIDs finish or timeout occurs.',
+          description: 'Wait for multiple AI agent processes to complete and return their results. Defaults to compact result items; set verbose to true for full metadata and detailed parsed output.',
           inputSchema: {
             type: 'object',
             properties: {
@@ -214,6 +218,10 @@ ${getSupportedModelsDescription()}
                 type: 'number',
                 description: 'Optional: Maximum time to wait in seconds. Defaults to 180 (3 minutes).',
               },
+              verbose: {
+                type: 'boolean',
+                description: 'Optional: If true, each result item uses the full result shape including metadata fields and detailed parsed output. Defaults to false.',
+              },
             },
             required: ['pids'],
           },
@@ -332,7 +340,8 @@ ${getSupportedModelsDescription()}
     try {
       const results = await this.processService.waitForProcesses(
         toolArguments.pids,
-        typeof toolArguments.timeout === 'number' ? toolArguments.timeout : 180
+        typeof toolArguments.timeout === 'number' ? toolArguments.timeout : 180,
+        !!toolArguments.verbose
       );
       return {
         content: [{

package/src/cli-builder.ts

@@ -5,7 +5,10 @@ import { MODEL_ALIASES } from './model-catalog.js';
 export const ALLOWED_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh']);
 const CLAUDE_REASONING_EFFORTS = new Set(['low', 'medium', 'high']);
 
-function getAgentForModel(model: string): 'codex' | 'claude' | 'gemini' {
+function getAgentForModel(model: string): 'codex' | 'claude' | 'gemini' | 'forge' {
+  if (model === 'forge') {
+    return 'forge';
+  }
   if (model.startsWith('gpt-')) {
     return 'codex';
   }
@@ -44,6 +47,9 @@ export function getReasoningEffort(model: string, rawValue: unknown): string {
     );
   }
   const agent = getAgentForModel(model);
+  if (agent === 'forge') {
+    throw new Error('reasoning_effort is not supported for forge.');
+  }
   if (agent === 'gemini') {
     throw new Error(
       'reasoning_effort is only supported for Claude and Codex models.'
@@ -61,7 +67,7 @@ export interface CliCommand {
   cliPath: string;
   args: string[];
   cwd: string;
-  agent: 'claude' | 'codex' | 'gemini';
+  agent: 'claude' | 'codex' | 'gemini' | 'forge';
   prompt: string;
   resolvedModel: string;
 }
@@ -73,7 +79,7 @@ export interface BuildCliCommandOptions {
   model?: string;
   session_id?: string;
   reasoning_effort?: string;
-  cliPaths: { claude: string; codex: string; gemini: string };
+  cliPaths: { claude: string; codex: string; gemini: string; forge: string };
 }
 
 /**
@@ -178,6 +184,15 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
 
     args.push(prompt);
 
+  } else if (agent === 'forge') {
+    cliPath = options.cliPaths.forge;
+    args = ['-C', cwd];
+
+    if (options.session_id && typeof options.session_id === 'string') {
+      args.push('--conversation-id', options.session_id);
+    }
+
+    args.push('-p', prompt);
   } else {
     cliPath = options.cliPaths.claude;
     args = ['--dangerously-skip-permissions', '--output-format', 'stream-json', '--verbose'];