ai-cli-mcp 2.12.0 → 2.13.0

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

@@ -19,6 +19,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';
   });
 
@@ -44,6 +45,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 () => {
@@ -60,6 +67,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 () => {
@@ -129,4 +142,25 @@ 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/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;
@@ -154,6 +201,131 @@ describe('MCP Contract Tests', () => {
     });
   });
 
+  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/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/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:

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'],

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'];

package/src/cli-parse.ts

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { parseClaudeOutput, parseCodexOutput, parseGeminiOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
 
-const AGENTS = ['claude', 'codex', 'gemini'] as const;
+const AGENTS = ['claude', 'codex', 'gemini', 'forge'] as const;
 type Agent = typeof AGENTS[number];
 
-const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini>
+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:
@@ -62,7 +62,7 @@ async function main(): Promise<void> {
 
   const agent = args.agent as 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);
   }
@@ -85,6 +85,9 @@ async function main(): Promise<void> {
     case 'gemini':
       parsed = parseGeminiOutput(input);
       break;
+    case 'forge':
+      parsed = parseForgeOutput(input);
+      break;
   }
 
   process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');

package/src/cli-process-service.ts

@@ -15,8 +15,8 @@ import {
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand, type BuildCliCommandOptions } 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';
 import type { AgentType, ProcessListItem } from './process-service.js';
 
 interface StoredProcess {
@@ -78,6 +78,7 @@ export class CliProcessService {
       claude: findClaudeCli(),
       codex: findCodexCli(),
       gemini: findGeminiCli(),
+      forge: findForgeCli(),
     };
     mkdirSync(this.stateDir, { recursive: true });
   }
@@ -177,6 +178,8 @@ export class CliProcessService {
         agentOutput = parseClaudeOutput(stdout);
       } else if (refreshed.toolType === 'gemini') {
         agentOutput = parseGeminiOutput(stdout);
+      } else if (refreshed.toolType === 'forge') {
+        agentOutput = parseForgeOutput(stdout);
       }
     }
 

package/src/cli-utils.ts

@@ -148,7 +148,7 @@ function isExecutableFile(filePath: string): boolean {
   }
 }
 
-type CliBinaryName = 'claude' | 'codex' | 'gemini';
+type CliBinaryName = 'claude' | 'codex' | 'gemini' | 'forge';
 
 function getCliBinaryConfig(name: CliBinaryName): {
   envVarName: string;
@@ -174,6 +174,15 @@ function getCliBinaryConfig(name: CliBinaryName): {
     };
   }
 
+  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,
@@ -190,11 +199,13 @@ export function getCliDoctorStatus(): {
   claude: CliBinaryStatus;
   codex: CliBinaryStatus;
   gemini: CliBinaryStatus;
+  forge: CliBinaryStatus;
 } {
   return {
     claude: getCliBinaryStatus('claude'),
     codex: getCliBinaryStatus('codex'),
     gemini: getCliBinaryStatus('gemini'),
+    forge: getCliBinaryStatus('forge'),
   };
 }
 
@@ -218,6 +229,15 @@ export function findCodexCli(): string {
   return getCliCommandOrThrow(status);
 }
 
+/**
+ * Determine the Forge CLI command/path.
+ */
+export function findForgeCli(): string {
+  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/src/cli.ts

@@ -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.
@@ -35,12 +35,12 @@ function parseArgs(argv: string[]): Record<string, string> {
 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:
@@ -73,6 +73,7 @@ async function main(): Promise<void> {
     claude: findClaudeCli(),
     codex: findCodexCli(),
     gemini: findGeminiCli(),
+    forge: findForgeCli(),
   };
 
   // Build command

package/src/model-catalog.ts

@@ -19,6 +19,7 @@ export const GEMINI_MODELS = [
   'gemini-3-pro-preview',
   'gemini-3-flash-preview',
 ] as const;
+export const FORGE_MODELS = ['forge'] as const;
 
 export const MODEL_ALIASES: Record<string, string> = {
   'claude-ultra': 'opus',
@@ -38,11 +39,12 @@ export function getSupportedModelsDescription(): string {
     ...CLAUDE_MODELS.map((model) => `"${model}"`),
     ...CODEX_MODELS.map((model) => `"${model}"`),
     ...GEMINI_MODELS.map((model) => `"${model}"`),
+    ...FORGE_MODELS.map((model) => `"${model}"`),
   ].join(', ');
 }
 
 export function getModelParameterDescription(): string {
-  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(): {
@@ -50,11 +52,13 @@ export function getModelsPayload(): {
   claude: ReadonlyArray<string>;
   codex: ReadonlyArray<string>;
   gemini: ReadonlyArray<string>;
+  forge: ReadonlyArray<string>;
 } {
   return {
     aliases: MODEL_ALIAS_DETAILS,
     claude: CLAUDE_MODELS,
     codex: CODEX_MODELS,
     gemini: GEMINI_MODELS,
+    forge: FORGE_MODELS,
   };
 }

package/src/parsers.ts

@@ -167,3 +167,64 @@ export function parseGeminiOutput(stdout: string): any {
     return null;
   }
 }
+
+/**
+ * Parse Forge output framed by Initialize/Continue/Finished markers.
+ */
+export function parseForgeOutput(stdout: string): any {
+  if (!stdout) return null;
+
+  const lines = stdout.split('\n');
+  const markerPattern = /^● \[[^\]]+\] (Initialize|Continue|Finished) (\S+)\s*$/;
+  let collecting = false;
+  let currentConversationId: string | null = null;
+  let currentBody: string[] = [];
+  let lastConversationId: string | null = null;
+  let lastMessage: string | null = 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,
+  };
+}