ai-cli-mcp 2.13.0 → 2.14.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [2.14.1](https://github.com/mkXultra/ai-cli-mcp/compare/v2.14.0...v2.14.1) (2026-04-07)
+
+
+### Bug Fixes
+
+* 削除済み作業フォルダでのプロセス操作クラッシュを修正 ([02d765f](https://github.com/mkXultra/ai-cli-mcp/commit/02d765ff76ebd295118e16a112ea3e7ac6fab111))
+
+# [2.14.0](https://github.com/mkXultra/ai-cli-mcp/compare/v2.13.0...v2.14.0) (2026-04-07)
+
+
+### Features
+
+* get_result・waitにcompact/verbose出力形式を追加 ([21fdff3](https://github.com/mkXultra/ai-cli-mcp/commit/21fdff3813f28327a2da94f4b5bed94b54abcd74))
+
 # [2.13.0](https://github.com/mkXultra/ai-cli-mcp/compare/v2.12.0...v2.13.0) (2026-04-07)
 
 

package/README.ja.md

@@ -118,7 +118,9 @@ ai-cli models
 ai-cli run --cwd "$PWD" --model sonnet --prompt "summarize this repository"
 ai-cli ps
 ai-cli result 12345
+ai-cli result 12345 --verbose
 ai-cli wait 12345 --timeout 300
+ai-cli wait 12345 --verbose
 ai-cli kill 12345
 ai-cli cleanup
 ai-cli-mcp
@@ -185,7 +187,9 @@ ai-cli models
 ai-cli run --cwd "$PWD" --model codex-ultra --prompt "fix failing tests"
 ai-cli ps
 ai-cli wait 12345
+ai-cli wait 12345 --verbose
 ai-cli result 12345
+ai-cli result 12345 --verbose
 ai-cli cleanup
 ```
 
@@ -244,9 +248,12 @@ Claude CLI、Codex CLI、Gemini CLI、または Forge CLI を使用してプロ
 
 複数のAIエージェントプロセスの完了を待機し、結果をまとめて返します。指定されたすべてのPIDが終了するか、タイムアウトになるまでブロックします。
 
+デフォルトでは、返される各結果項目は `get_result(verbose: false)` と同じ compact 形を使います。`pid`、`agent`、`status`、`exitCode`、`model` などの運用上必要な項目に加え、利用可能であれば `agentOutput` やトップレベルの `session_id` を含みます。`verbose: true` を指定すると、`startTime`、`workFolder`、`prompt` などの完全なメタデータや、`agentOutput.tools` のような詳細な解析結果を含む full 形を返します。
+
 **引数:**
 - `pids` (array of numbers, 必須): 待機するプロセスIDのリスト（`run` ツールから返されたもの）。
 - `timeout` (number, 任意): 最大待機時間（秒）。デフォルトは180秒（3分）です。
+- `verbose` (boolean, 任意): `true` の場合、各結果項目を full 形で返します。デフォルトは `false` です。
 
 ### `list_processes`
 
@@ -256,8 +263,11 @@ Claude CLI、Codex CLI、Gemini CLI、または Forge CLI を使用してプロ
 
 PIDを指定して、AIエージェントプロセスの現在の出力とステータスを取得します。
 
+デフォルトでは compact 形を返します。これには `pid`、`agent`、`status`、`exitCode`、`model` などの運用上必要な項目に加え、利用可能であれば `agentOutput` やトップレベルの `session_id` を含みます。`startTime`、`workFolder`、`prompt` は含みません。`verbose: true` を指定すると、これらのメタデータや `agentOutput.tools` のような詳細な解析結果を含む full 形を返します。解析結果が得られない場合や不完全な場合は、従来どおり `stdout` / `stderr` のフォールバックを維持します。
+
 **引数:**
 - `pid` (number, 必須): `run` ツールによって返されたプロセスID。
+- `verbose` (boolean, 任意): `true` の場合、full 形で返します。デフォルトは `false` です。
 
 ### `kill_process`
 

package/README.md

@@ -116,7 +116,9 @@ ai-cli models
 ai-cli run --cwd "$PWD" --model sonnet --prompt "summarize this repository"
 ai-cli ps
 ai-cli result 12345
+ai-cli result 12345 --verbose
 ai-cli wait 12345 --timeout 300
+ai-cli wait 12345 --verbose
 ai-cli kill 12345
 ai-cli cleanup
 ai-cli-mcp
@@ -183,7 +185,9 @@ ai-cli models
 ai-cli run --cwd "$PWD" --model codex-ultra --prompt "fix failing tests"
 ai-cli ps
 ai-cli wait 12345
+ai-cli wait 12345 --verbose
 ai-cli result 12345
+ai-cli result 12345 --verbose
 ai-cli cleanup
 ```
 
@@ -242,9 +246,12 @@ Executes a prompt using Claude CLI, Codex CLI, Gemini CLI, or Forge CLI. The app
 
 Waits for multiple AI agent processes to complete and returns their combined results. Blocks until all specified PIDs finish or a timeout occurs.
 
+By default, each returned result item uses the compact shape shared with `get_result(verbose: false)`: operational fields such as `pid`, `agent`, `status`, `exitCode`, `model`, parsed output such as `agentOutput`, and top-level `session_id` when available. Set `verbose: true` to include full metadata like `startTime`, `workFolder`, `prompt`, and detailed parsed output such as `agentOutput.tools`.
+
 **Arguments:**
 - `pids` (array of numbers, required): List of process IDs to wait for (returned by the `run` tool).
 - `timeout` (number, optional): Maximum wait time in seconds. Defaults to 180 (3 minutes).
+- `verbose` (boolean, optional): If `true`, each result item uses the full result shape. Defaults to `false`.
 
 ### `list_processes`
 
@@ -254,8 +261,11 @@ Lists all running and completed AI agent processes with their status, PID, and b
 
 Gets the current output and status of an AI agent process by PID.
 
+By default, this returns the compact result shape: operational fields such as `pid`, `agent`, `status`, `exitCode`, `model`, parsed output such as `agentOutput`, and top-level `session_id` when available. It omits metadata fields like `startTime`, `workFolder`, and `prompt`. Set `verbose: true` to return the full result shape including those metadata fields and detailed parsed output such as `agentOutput.tools`. If parsed output is unavailable or incomplete, the raw `stdout`/`stderr` fallback is preserved.
+
 **Arguments:**
 - `pid` (number, required): The process ID returned by the `run` tool.
+- `verbose` (boolean, optional): If `true`, returns the full result shape. Defaults to `false`.
 
 ### `kill_process`
 

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

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { CLI_HELP_TEXT, DOCTOR_HELP_TEXT, MODELS_HELP_TEXT, RUN_HELP_TEXT, WAIT_HELP_TEXT, runCli, } from '../app/cli.js';
+import { CLI_HELP_TEXT, DOCTOR_HELP_TEXT, MODELS_HELP_TEXT, RESULT_HELP_TEXT, RUN_HELP_TEXT, WAIT_HELP_TEXT, runCli, } from '../app/cli.js';
 describe('ai-cli app', () => {
     it('prints help and exits successfully when no subcommand is provided', async () => {
         const stdout = vi.fn();
@@ -108,9 +108,21 @@ describe('ai-cli app', () => {
             waitForProcesses,
         });
         expect(exitCode).toBe(0);
-        expect(waitForProcesses).toHaveBeenCalledWith([123, 456], 5);
+        expect(waitForProcesses).toHaveBeenCalledWith([123, 456], 5, false);
         expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"status": "completed"'));
     });
+    it('passes verbose through to wait', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const waitForProcesses = vi.fn().mockResolvedValue([{ pid: 123, status: 'completed' }]);
+        const exitCode = await runCli(['wait', '123', '--verbose'], {
+            stdout,
+            stderr,
+            waitForProcesses,
+        });
+        expect(exitCode).toBe(0);
+        expect(waitForProcesses).toHaveBeenCalledWith([123], undefined, true);
+    });
     it('rejects invalid wait timeout values', async () => {
         const stdout = vi.fn();
         const stderr = vi.fn();
@@ -231,12 +243,24 @@ describe('ai-cli app', () => {
         expect(stdout).toHaveBeenCalledWith(expect.stringContaining('forge'));
         expect(stderr).not.toHaveBeenCalled();
     });
+    it('prints detailed help for result --help', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const exitCode = await runCli(['result', '--help'], { stdout, stderr });
+        expect(exitCode).toBe(0);
+        expect(stdout).toHaveBeenCalledWith(RESULT_HELP_TEXT);
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('compact result shape'));
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('--verbose'));
+        expect(stderr).not.toHaveBeenCalled();
+    });
     it('prints detailed help for wait --help', async () => {
         const stdout = vi.fn();
         const stderr = vi.fn();
         const exitCode = await runCli(['wait', '--help'], { stdout, stderr });
         expect(exitCode).toBe(0);
         expect(stdout).toHaveBeenCalledWith(WAIT_HELP_TEXT);
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('compact shape'));
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('--verbose'));
         expect(stderr).not.toHaveBeenCalled();
     });
     it('prints detailed help for models --help', async () => {

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

@@ -72,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,
@@ -81,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);
@@ -165,6 +294,90 @@ describe('CliProcessService', () => {
         expect(stored.status).toBe('running');
         killSpy.mockRestore();
     });
+    it('lists processes without crashing when a tracked work folder has been deleted', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'deleted-project');
+        mkdirSync(workFolder, { recursive: true });
+        const pid = 45678;
+        const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(pid));
+        mkdirSync(processDir, { recursive: true });
+        writeFileSync(join(processDir, 'meta.json'), JSON.stringify({
+            pid,
+            prompt: 'deleted cwd',
+            workFolder,
+            toolType: 'claude',
+            startTime: new Date().toISOString(),
+            stdoutPath: join(processDir, 'stdout.log'),
+            stderrPath: join(processDir, 'stderr.log'),
+            status: 'running',
+        }));
+        rmSync(workFolder, { recursive: true, force: true });
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: '/bin/sh',
+                codex: '/bin/sh',
+                gemini: '/bin/sh',
+                forge: '/bin/sh',
+            },
+        });
+        const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target, signal) => {
+            if (signal === 0 && target === pid) {
+                throw Object.assign(new Error('not running'), { code: 'ESRCH' });
+            }
+            return true;
+        });
+        const listed = await service.listProcesses();
+        expect(listed).toEqual([
+            {
+                pid,
+                agent: 'claude',
+                status: 'completed',
+            },
+        ]);
+        expect(JSON.parse(readFileSync(join(processDir, 'meta.json'), 'utf-8')).status).toBe('completed');
+        killSpy.mockRestore();
+    });
+    it('cleans up finished process directories even when their work folder has been deleted', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'deleted-finished-project');
+        mkdirSync(workFolder, { recursive: true });
+        const pid = 56789;
+        const cwdDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)));
+        const processDir = join(cwdDir, String(pid));
+        mkdirSync(processDir, { recursive: true });
+        writeFileSync(join(processDir, 'meta.json'), JSON.stringify({
+            pid,
+            prompt: 'done',
+            workFolder,
+            toolType: 'claude',
+            startTime: new Date().toISOString(),
+            stdoutPath: join(processDir, 'stdout.log'),
+            stderrPath: join(processDir, 'stderr.log'),
+            status: 'completed',
+        }));
+        rmSync(workFolder, { recursive: true, force: true });
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: '/bin/sh',
+                codex: '/bin/sh',
+                gemini: '/bin/sh',
+                forge: '/bin/sh',
+            },
+        });
+        const result = await service.cleanupProcesses();
+        expect(result).toEqual({
+            removed: 1,
+            message: 'Removed 1 processes',
+        });
+        expect(existsSync(processDir)).toBe(false);
+        expect(existsSync(cwdDir)).toBe(false);
+    });
     it('cleans up completed and failed process directories but preserves running ones', async () => {
         const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
         tempDirs.push(root);

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

@@ -107,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 () => {
@@ -134,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({
@@ -157,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({
@@ -171,6 +183,124 @@ 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();

package/dist/__tests__/process-management.test.js

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

package/dist/app/cli.js

@@ -38,17 +38,19 @@ 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
 `;
 export const KILL_HELP_TEXT = `Usage: ai-cli kill <pid>
@@ -104,7 +106,7 @@ const defaultDeps = {
     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(),
@@ -253,7 +255,7 @@ export async function runCli(argv, deps = {}) {
             stdout(CLI_HELP_TEXT);
             return 1;
         }
-        writeJson(stdout, await waitForProcesses(pids, timeout));
+        writeJson(stdout, await waitForProcesses(pids, timeout, 'verbose' in flags));
         return 0;
     }
     if (command === 'kill') {