ai-cli-mcp 2.12.0 → 2.13.0

package/dist/__tests__/parsers.test.js

@@ -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', () => {
         const output = `
@@ -96,3 +96,39 @@ 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/dist/app/cli.js

@@ -24,9 +24,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:

package/dist/app/mcp.js

@@ -2,7 +2,7 @@ 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, 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';
 // Server version - update this when releasing new versions
@@ -58,6 +58,7 @@ export class ClaudeCodeServer {
     claudeCliPath;
     codexCliPath;
     geminiCliPath;
+    forgeCliPath;
     processService;
     sigintHandler;
     packageVersion;
@@ -65,15 +66,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,
             },
         });
         this.server = new Server({
@@ -97,7 +101,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
@@ -141,11 +145,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'],

package/dist/cli-builder.js

@@ -4,6 +4,9 @@ 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) {
+    if (model === 'forge') {
+        return 'forge';
+    }
     if (model.startsWith('gpt-')) {
         return 'codex';
     }
@@ -38,6 +41,9 @@ export function getReasoningEffort(model, rawValue) {
         throw new Error(`Invalid reasoning_effort: ${rawValue}. Allowed values: low, medium, high, xhigh.`);
     }
     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.');
     }
@@ -134,6 +140,14 @@ export function buildCliCommand(options) {
         }
         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'];

package/dist/cli-parse.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { parseClaudeOutput, parseCodexOutput, parseGeminiOutput } from './parsers.js';
-const AGENTS = ['claude', 'codex', 'gemini'];
-const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini>
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+const AGENTS = ['claude', 'codex', 'gemini', 'forge'];
+const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge>
 
 Reads raw CLI output from stdin and outputs parsed JSON to stdout.
 
 Options:
-  --agent   Agent type: claude, codex, or gemini (required)
+  --agent   Agent type: claude, codex, gemini, or forge (required)
   --help    Show this help message
 
 Examples:
@@ -56,7 +56,7 @@ async function main() {
     }
     const agent = args.agent;
     if (!agent || !AGENTS.includes(agent)) {
-        process.stderr.write(`Error: --agent is required (claude, codex, or gemini)\n\n`);
+        process.stderr.write(`Error: --agent is required (claude, codex, gemini, or forge)\n\n`);
         process.stderr.write(USAGE);
         process.exit(1);
     }
@@ -76,6 +76,9 @@ async function main() {
         case 'gemini':
             parsed = parseGeminiOutput(input);
             break;
+        case 'forge':
+            parsed = parseForgeOutput(input);
+            break;
     }
     process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');
 }

package/dist/cli-process-service.js

@@ -3,8 +3,8 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync,
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand } from './cli-builder.js';
-import { findClaudeCli, findCodexCli, findGeminiCli } from './cli-utils.js';
-import { parseClaudeOutput, parseCodexOutput, parseGeminiOutput } from './parsers.js';
+import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
 function resolveDefaultStateDir() {
     return process.env.AI_CLI_STATE_DIR || join(homedir(), '.local', 'state', 'ai-cli');
 }
@@ -35,6 +35,7 @@ export class CliProcessService {
             claude: findClaudeCli(),
             codex: findCodexCli(),
             gemini: findGeminiCli(),
+            forge: findForgeCli(),
         };
         mkdirSync(this.stateDir, { recursive: true });
     }
@@ -127,6 +128,9 @@ export class CliProcessService {
             else if (refreshed.toolType === 'gemini') {
                 agentOutput = parseGeminiOutput(stdout);
             }
+            else if (refreshed.toolType === 'forge') {
+                agentOutput = parseForgeOutput(stdout);
+            }
         }
         const response = {
             pid,

package/dist/cli-utils.js

@@ -128,6 +128,14 @@ function getCliBinaryConfig(name) {
             localInstallPath: join(homedir(), '.codex', 'local', 'codex'),
         };
     }
+    if (name === 'forge') {
+        return {
+            envVarName: 'FORGE_CLI_NAME',
+            customCliName: process.env.FORGE_CLI_NAME,
+            defaultCliName: 'forge',
+            localInstallPath: join(homedir(), '.forge', 'local', 'forge'),
+        };
+    }
     return {
         envVarName: 'GEMINI_CLI_NAME',
         customCliName: process.env.GEMINI_CLI_NAME,
@@ -143,6 +151,7 @@ export function getCliDoctorStatus() {
         claude: getCliBinaryStatus('claude'),
         codex: getCliBinaryStatus('codex'),
         gemini: getCliBinaryStatus('gemini'),
+        forge: getCliBinaryStatus('forge'),
     };
 }
 /**
@@ -163,6 +172,14 @@ export function findCodexCli() {
     const status = getCliBinaryStatus('codex');
     return getCliCommandOrThrow(status);
 }
+/**
+ * Determine the Forge CLI command/path.
+ */
+export function findForgeCli() {
+    debugLog('[Debug] Attempting to find Forge CLI...');
+    const status = getCliBinaryStatus('forge');
+    return getCliCommandOrThrow(status);
+}
 /**
  * Determine the Claude CLI command/path.
  * 1. Checks for CLAUDE_CLI_NAME environment variable:

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
 import { buildCliCommand } from './cli-builder.js';
-import { findClaudeCli, findCodexCli, findGeminiCli } from './cli-utils.js';
+import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
 /**
  * Minimal argv parser. No external dependencies.
  * Supports: --key value, --key=value
@@ -35,12 +35,12 @@ function parseArgs(argv) {
 const USAGE = `Usage: npm run -s cli.run -- --model <model> --workFolder <path> --prompt "..." [options]
 
 Options:
-  --model              Model name or alias (e.g. sonnet, opus, gpt-5.2-codex, gemini-2.5-pro)
+  --model              Model name or alias (e.g. sonnet, opus, gpt-5.2-codex, gemini-2.5-pro, forge)
   --workFolder         Working directory (absolute path)
   --prompt             Prompt string (mutually exclusive with --prompt_file)
   --prompt_file        Path to a file containing the prompt
   --session_id         Session ID to resume
-  --reasoning_effort   Claude/Codex: Claude=low|medium|high, Codex=low|medium|high|xhigh
+  --reasoning_effort   Claude/Codex only: Claude=low|medium|high, Codex=low|medium|high|xhigh
   --help               Show this help message
 
 Raw CLI output goes to stdout. Use cli.run.parse to parse the output:
@@ -68,6 +68,7 @@ async function main() {
         claude: findClaudeCli(),
         codex: findCodexCli(),
         gemini: findGeminiCli(),
+        forge: findForgeCli(),
     };
     // Build command
     let cmd;

package/dist/model-catalog.js

@@ -19,6 +19,7 @@ export const GEMINI_MODELS = [
     'gemini-3-pro-preview',
     'gemini-3-flash-preview',
 ];
+export const FORGE_MODELS = ['forge'];
 export const MODEL_ALIASES = {
     'claude-ultra': 'opus',
     'codex-ultra': 'gpt-5.4',
@@ -35,10 +36,11 @@ export function getSupportedModelsDescription() {
         ...CLAUDE_MODELS.map((model) => `"${model}"`),
         ...CODEX_MODELS.map((model) => `"${model}"`),
         ...GEMINI_MODELS.map((model) => `"${model}"`),
+        ...FORGE_MODELS.map((model) => `"${model}"`),
     ].join(', ');
 }
 export function getModelParameterDescription() {
-    return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS].map((model) => `"${model}"`).join(', ')}.`;
+    return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS, ...FORGE_MODELS].map((model) => `"${model}"`).join(', ')}. "forge" is a provider key, not a Forge model family selector.`;
 }
 export function getModelsPayload() {
     return {
@@ -46,5 +48,6 @@ export function getModelsPayload() {
         claude: CLAUDE_MODELS,
         codex: CODEX_MODELS,
         gemini: GEMINI_MODELS,
+        forge: FORGE_MODELS,
     };
 }

package/dist/parsers.js

@@ -163,3 +163,58 @@ export function parseGeminiOutput(stdout) {
         return null;
     }
 }
+/**
+ * Parse Forge output framed by Initialize/Continue/Finished markers.
+ */
+export function parseForgeOutput(stdout) {
+    if (!stdout)
+        return null;
+    const lines = stdout.split('\n');
+    const markerPattern = /^● \[[^\]]+\] (Initialize|Continue|Finished) (\S+)\s*$/;
+    let collecting = false;
+    let currentConversationId = null;
+    let currentBody = [];
+    let lastConversationId = null;
+    let lastMessage = null;
+    for (const line of lines) {
+        const match = line.match(markerPattern);
+        if (match) {
+            const [, action, conversationId] = match;
+            lastConversationId = conversationId;
+            if (action === 'Initialize' || action === 'Continue') {
+                collecting = true;
+                currentConversationId = conversationId;
+                currentBody = [];
+            }
+            else if (collecting && currentConversationId === conversationId) {
+                const message = currentBody.join('\n').trim();
+                if (message) {
+                    lastMessage = message;
+                }
+                collecting = false;
+                currentConversationId = null;
+                currentBody = [];
+            }
+            continue;
+        }
+        if (collecting) {
+            currentBody.push(line);
+        }
+    }
+    if (collecting) {
+        const message = currentBody.join('\n').trim();
+        if (message) {
+            lastMessage = message;
+        }
+        if (currentConversationId) {
+            lastConversationId = currentConversationId;
+        }
+    }
+    if (!lastMessage && !lastConversationId) {
+        return null;
+    }
+    return {
+        message: lastMessage,
+        session_id: lastConversationId,
+    };
+}

package/dist/process-service.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import { buildCliCommand } from './cli-builder.js';
-import { parseClaudeOutput, parseCodexOutput, parseGeminiOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
 export class ProcessService {
     processManager = new Map();
     cliPaths;
@@ -96,6 +96,9 @@ export class ProcessService {
             else if (process.toolType === 'gemini') {
                 agentOutput = parseGeminiOutput(process.stdout);
             }
+            else if (process.toolType === 'forge') {
+                agentOutput = parseForgeOutput(process.stdout);
+            }
         }
         const response = {
             pid,

package/dist/server.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-export { debugLog, findClaudeCli, findCodexCli, findGeminiCli } from './cli-utils.js';
+export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
 export { resolveModelAlias } from './cli-builder.js';
 export { ClaudeCodeServer, runMcpServer, spawnAsync } from './app/mcp.js';
 import { runMcpServer } from './app/mcp.js';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ai-cli-mcp",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "mcpName": "io.github.mkXultra/ai-cli-mcp",
-  "description": "MCP server for AI CLI tools (Claude, Codex, and Gemini) with background process management",
+  "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, and Forge) with background process management",
   "author": "mkXultra",
   "license": "MIT",
   "main": "dist/server.js",

package/server.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.mkXultra/ai-cli-mcp",
-  "description": "MCP server for AI CLI tools (Claude, Codex, and Gemini) with background process management",
+  "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, and Forge) with background process management",
   "repository": {
     "url": "https://github.com/mkXultra/ai-cli-mcp",
     "source": "github"

package/src/__tests__/app-cli.test.ts

@@ -222,6 +222,7 @@ describe('ai-cli app', () => {
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"aliases"'));
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"claude-ultra"'));
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"gpt-5.4"'));
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"forge"'));
     expect(stderr).not.toHaveBeenCalled();
   });
 
@@ -247,6 +248,12 @@ describe('ai-cli app', () => {
         available: true,
         lookup: 'path',
       },
+      forge: {
+        configuredCommand: 'forge',
+        resolvedPath: '/tmp/bin/forge',
+        available: true,
+        lookup: 'path',
+      },
     });
 
     const exitCode = await runCli(['doctor'], { stdout, stderr, getDoctorStatus });
@@ -280,6 +287,7 @@ describe('ai-cli app', () => {
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('claude-ultra'));
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('gpt-5.2-codex'));
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('gemini-2.5-pro'));
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('forge'));
     expect(stderr).not.toHaveBeenCalled();
   });
 

package/src/__tests__/cli-bin-smoke.test.ts

@@ -30,6 +30,7 @@ describe('ai-cli entrypoint smoke', () => {
     writeExecutable(fakeBinDir, 'claude');
     writeExecutable(fakeBinDir, 'codex');
     writeExecutable(fakeBinDir, 'gemini');
+    writeExecutable(fakeBinDir, 'forge');
 
     const output = execFileSync(
       'node',
@@ -43,6 +44,7 @@ describe('ai-cli entrypoint smoke', () => {
           CLAUDE_CLI_NAME: 'claude',
           CODEX_CLI_NAME: 'codex',
           GEMINI_CLI_NAME: 'gemini',
+          FORGE_CLI_NAME: 'forge',
         },
       }
     );
@@ -50,6 +52,7 @@ describe('ai-cli entrypoint smoke', () => {
     expect(output).toContain('"claude"');
     expect(output).toContain('"codex"');
     expect(output).toContain('"gemini"');
+    expect(output).toContain('"forge"');
     expect(output).toContain('"available": true');
   });
 
@@ -67,5 +70,6 @@ describe('ai-cli entrypoint smoke', () => {
     expect(output).toContain('Usage: ai-cli run --cwd <path> [options]');
     expect(output).toContain('--model <model>');
     expect(output).toContain('claude-ultra');
+    expect(output).toContain('forge');
   });
 });

package/src/__tests__/cli-builder.test.ts

@@ -22,6 +22,7 @@ const DEFAULT_CLI_PATHS = {
   claude: '/usr/bin/claude',
   codex: '/usr/bin/codex',
   gemini: '/usr/bin/gemini',
+  forge: '/usr/bin/forge',
 };
 
 describe('cli-builder', () => {
@@ -97,6 +98,12 @@ describe('cli-builder', () => {
         'reasoning_effort is only supported for Claude and Codex models.'
       );
     });
+
+    it('should reject reasoning_effort for forge explicitly', () => {
+      expect(() => getReasoningEffort('forge', 'high')).toThrow(
+        'reasoning_effort is not supported for forge.'
+      );
+    });
   });
 
   describe('buildCliCommand', () => {
@@ -401,5 +408,45 @@ describe('cli-builder', () => {
         expect(cmd.resolvedModel).toBe('gemini-3.1-pro-preview');
       });
     });
+
+    describe('forge agent', () => {
+      it('should build forge command without model flags', () => {
+        const cmd = buildCliCommand({
+          prompt: 'test',
+          workFolder: '/tmp',
+          model: 'forge',
+          cliPaths: DEFAULT_CLI_PATHS,
+        });
+
+        expect(cmd.agent).toBe('forge');
+        expect(cmd.cliPath).toBe('/usr/bin/forge');
+        expect(cmd.resolvedModel).toBe('forge');
+        expect(cmd.args).toEqual(['-C', '/tmp', '-p', 'test']);
+      });
+
+      it('should map session_id to --conversation-id for forge', () => {
+        const cmd = buildCliCommand({
+          prompt: 'test',
+          workFolder: '/tmp',
+          model: 'forge',
+          session_id: 'forge-conv-123',
+          cliPaths: DEFAULT_CLI_PATHS,
+        });
+
+        expect(cmd.args).toEqual(['-C', '/tmp', '--conversation-id', 'forge-conv-123', '-p', 'test']);
+      });
+
+      it('should reject reasoning_effort for forge in command building', () => {
+        expect(() =>
+          buildCliCommand({
+            prompt: 'test',
+            workFolder: '/tmp',
+            model: 'forge',
+            reasoning_effort: 'high',
+            cliPaths: DEFAULT_CLI_PATHS,
+          })
+        ).toThrow('reasoning_effort is not supported for forge.');
+      });
+    });
   });
 });

package/src/__tests__/cli-process-service.test.ts

@@ -65,6 +65,7 @@ describe('CliProcessService', () => {
         claude: scriptPath,
         codex: scriptPath,
         gemini: scriptPath,
+        forge: scriptPath,
       },
     });
 
@@ -114,6 +115,7 @@ describe('CliProcessService', () => {
         claude: scriptPath,
         codex: scriptPath,
         gemini: scriptPath,
+        forge: scriptPath,
       },
     });
 
@@ -152,6 +154,7 @@ describe('CliProcessService', () => {
         claude: '/bin/sh',
         codex: '/bin/sh',
         gemini: '/bin/sh',
+        forge: '/bin/sh',
       },
     });
 
@@ -254,6 +257,7 @@ describe('CliProcessService', () => {
         claude: '/bin/sh',
         codex: '/bin/sh',
         gemini: '/bin/sh',
+        forge: '/bin/sh',
       },
     });
 
@@ -275,4 +279,56 @@ describe('CliProcessService', () => {
     expect(existsSync(failedDir)).toBe(false);
     killSpy.mockRestore();
   });
+
+  it('parses forge output from detached process logs', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'forge-project');
+    mkdirSync(workFolder, { recursive: true });
+    const pid = 54321;
+    const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(pid));
+    mkdirSync(processDir, { recursive: true });
+
+    writeFileSync(
+      join(processDir, 'stdout.log'),
+      `● [21:09:01] Initialize forge-conv-1
+Forge assistant reply
+● [21:09:08] Finished forge-conv-1
+`
+    );
+    writeFileSync(join(processDir, 'stderr.log'), '');
+    writeFileSync(
+      join(processDir, 'meta.json'),
+      JSON.stringify({
+        pid,
+        prompt: 'hello forge',
+        workFolder,
+        model: 'forge',
+        toolType: 'forge',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(processDir, 'stdout.log'),
+        stderrPath: join(processDir, 'stderr.log'),
+        status: 'completed',
+      })
+    );
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: '/bin/sh',
+        codex: '/bin/sh',
+        gemini: '/bin/sh',
+        forge: '/bin/sh',
+      },
+    });
+
+    const result = await service.getProcessResult(pid, false);
+    expect(result.agent).toBe('forge');
+    expect(result.session_id).toBe('forge-conv-1');
+    expect(result.agentOutput).toEqual({
+      message: 'Forge assistant reply',
+      session_id: 'forge-conv-1',
+    });
+  });
 });