ai-cli-mcp 2.12.0 → 2.14.0

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

@@ -56,6 +56,7 @@ describe('CliProcessService', () => {
                 claude: scriptPath,
                 codex: scriptPath,
                 gemini: scriptPath,
+                forge: scriptPath,
             },
         });
         const runResult = await service.startProcess({
@@ -71,8 +72,18 @@ describe('CliProcessService', () => {
         expect(existsSync(join(processDir, 'stderr.log'))).toBe(true);
         const waitResult = await service.waitForProcesses([runResult.pid], 5);
         expect(waitResult).toHaveLength(1);
-        expect(waitResult[0].pid).toBe(runResult.pid);
-        expect(waitResult[0].status).toBe('completed');
+        expect(waitResult[0]).toMatchObject({
+            pid: runResult.pid,
+            agent: 'claude',
+            status: 'completed',
+            exitCode: null,
+            model: 'sonnet',
+            stdout: expect.any(String),
+            stderr: expect.any(String),
+        });
+        expect(waitResult[0]).not.toHaveProperty('startTime');
+        expect(waitResult[0]).not.toHaveProperty('workFolder');
+        expect(waitResult[0]).not.toHaveProperty('prompt');
         const listed = await service.listProcesses();
         expect(listed).toContainEqual({
             pid: runResult.pid,
@@ -80,11 +91,130 @@ describe('CliProcessService', () => {
             status: 'completed',
         });
         const result = await service.getProcessResult(runResult.pid, false);
-        expect(result.pid).toBe(runResult.pid);
-        expect(result.status).toBe('completed');
-        expect(result.stdout).toContain('Command executed successfully');
+        expect(result).toMatchObject({
+            pid: runResult.pid,
+            agent: 'claude',
+            status: 'completed',
+            exitCode: null,
+            model: 'sonnet',
+            stdout: expect.stringContaining('Command executed successfully'),
+            stderr: expect.any(String),
+        });
+        expect(result).not.toHaveProperty('startTime');
+        expect(result).not.toHaveProperty('workFolder');
+        expect(result).not.toHaveProperty('prompt');
         expect(readFileSync(join(processDir, 'meta.json'), 'utf-8')).toContain('"status": "completed"');
     });
+    it('returns compact results by default and full results when verbose is true', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const scriptPath = join(root, 'mock-claude-json');
+        writeFileSync(scriptPath, `#!/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 cli-process-service test"}'
+printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
+`);
+        chmodSync(scriptPath, 0o755);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'work');
+        mkdirSync(workFolder, { recursive: true });
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: scriptPath,
+                codex: scriptPath,
+                gemini: scriptPath,
+                forge: scriptPath,
+            },
+        });
+        const runResult = await service.startProcess({
+            prompt: 'hello structured output',
+            cwd: workFolder,
+        });
+        const compactWait = await service.waitForProcesses([runResult.pid], 5);
+        expect(compactWait).toHaveLength(1);
+        expect(compactWait[0]).toMatchObject({
+            pid: runResult.pid,
+            agent: 'claude',
+            status: 'completed',
+            exitCode: null,
+            model: null,
+            session_id: 'session-cli-1',
+            agentOutput: {
+                message: 'Completed cli-process-service test',
+                session_id: 'session-cli-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 compactResult = await service.getProcessResult(runResult.pid, false);
+        expect(compactResult).toMatchObject({
+            pid: runResult.pid,
+            agent: 'claude',
+            status: 'completed',
+            exitCode: null,
+            model: null,
+            session_id: 'session-cli-1',
+            agentOutput: {
+                message: 'Completed cli-process-service test',
+                session_id: 'session-cli-1',
+            },
+        });
+        expect(compactResult).not.toHaveProperty('startTime');
+        expect(compactResult).not.toHaveProperty('workFolder');
+        expect(compactResult).not.toHaveProperty('prompt');
+        expect(compactResult.agentOutput).not.toHaveProperty('tools');
+        const verboseWait = await service.waitForProcesses([runResult.pid], 5, true);
+        expect(verboseWait).toHaveLength(1);
+        expect(verboseWait[0]).toMatchObject({
+            pid: runResult.pid,
+            agent: 'claude',
+            status: 'completed',
+            exitCode: null,
+            model: null,
+            startTime: expect.any(String),
+            workFolder,
+            prompt: 'hello structured output',
+            session_id: 'session-cli-1',
+            agentOutput: {
+                message: 'Completed cli-process-service test',
+                session_id: 'session-cli-1',
+                tools: [
+                    {
+                        tool: 'Read',
+                        input: { file_path: '/tmp/demo.txt' },
+                        output: 'demo output',
+                    },
+                ],
+            },
+        });
+        const verboseResult = await service.getProcessResult(runResult.pid, true);
+        expect(verboseResult).toMatchObject({
+            pid: runResult.pid,
+            agent: 'claude',
+            status: 'completed',
+            exitCode: null,
+            model: null,
+            startTime: expect.any(String),
+            workFolder,
+            prompt: 'hello structured output',
+            session_id: 'session-cli-1',
+            agentOutput: {
+                message: 'Completed cli-process-service test',
+                session_id: 'session-cli-1',
+                tools: [
+                    {
+                        tool: 'Read',
+                        input: { file_path: '/tmp/demo.txt' },
+                        output: 'demo output',
+                    },
+                ],
+            },
+        });
+    });
     it('can terminate a tracked process', async () => {
         const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
         tempDirs.push(root);
@@ -98,6 +228,7 @@ describe('CliProcessService', () => {
                 claude: scriptPath,
                 codex: scriptPath,
                 gemini: scriptPath,
+                forge: scriptPath,
             },
         });
         const runResult = await service.startProcess({
@@ -130,6 +261,7 @@ describe('CliProcessService', () => {
                 claude: '/bin/sh',
                 codex: '/bin/sh',
                 gemini: '/bin/sh',
+                forge: '/bin/sh',
             },
         });
         writeFileSync(join(processDir, 'meta.json'), JSON.stringify({
@@ -212,6 +344,7 @@ describe('CliProcessService', () => {
                 claude: '/bin/sh',
                 codex: '/bin/sh',
                 gemini: '/bin/sh',
+                forge: '/bin/sh',
             },
         });
         const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target, signal) => {
@@ -230,4 +363,46 @@ 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',
+        });
+    });
 });

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

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

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

@@ -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';
@@ -16,6 +16,49 @@ function expectProcessSummaryShape(processInfo) {
         status: expect.any(String),
     });
 }
+function createForgeMockScript(dir, argsLogPath) {
+    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;
     let testDir;
@@ -64,6 +107,7 @@ describe('MCP Contract Tests', () => {
         expect(Object.keys(waitTool.inputSchema.properties).sort()).toEqual([
             'pids',
             'timeout',
+            'verbose',
         ]);
     });
     it('preserves the stdio MCP smoke flow and response shapes', async () => {
@@ -91,20 +135,30 @@ 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);
         expect(cleanupData).toEqual({
@@ -114,12 +168,13 @@ 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);
         expect(runData).toEqual({
@@ -128,6 +183,229 @@ 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 () => {
         await expect(client.callTool('run', {

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();
+    });
+});