ai-cli-mcp 2.13.0 → 2.14.1

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

@@ -122,6 +122,7 @@ describe('MCP Contract Tests', () => {
     expect(Object.keys(waitTool.inputSchema.properties).sort()).toEqual([
       'pids',
       'timeout',
+      'verbose',
     ]);
   });
 
@@ -155,22 +156,32 @@ describe('MCP Contract Tests', () => {
       pid: runData.pid,
       agent: 'claude',
       status: expect.any(String),
-      startTime: expect.any(String),
-      workFolder: testDir,
-      prompt: 'create a file called contract.txt with content "hello"',
       model: 'haiku',
       stdout: expect.any(String),
       stderr: expect.any(String),
     });
+    expect(getResultData).toHaveProperty('exitCode');
+    expect(getResultData).not.toHaveProperty('startTime');
+    expect(getResultData).not.toHaveProperty('workFolder');
+    expect(getResultData).not.toHaveProperty('prompt');
 
     const waitResponse = await client.callTool('wait', { pids: [runData.pid], timeout: 5 });
     const waitData = parseToolJson(waitResponse);
 
     expect(Array.isArray(waitData)).toBe(true);
     expect(waitData).toHaveLength(1);
-    expect(waitData[0].pid).toBe(runData.pid);
-    expect(waitData[0].agent).toBe('claude');
-    expect(waitData[0].status).toBe('completed');
+    expect(waitData[0]).toMatchObject({
+      pid: runData.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: 0,
+      model: 'haiku',
+      stdout: expect.any(String),
+      stderr: expect.any(String),
+    });
+    expect(waitData[0]).not.toHaveProperty('startTime');
+    expect(waitData[0]).not.toHaveProperty('workFolder');
+    expect(waitData[0]).not.toHaveProperty('prompt');
 
     const cleanupResponse = await client.callTool('cleanup_processes', {});
     const cleanupData = parseToolJson(cleanupResponse);
@@ -183,13 +194,14 @@ describe('MCP Contract Tests', () => {
     expect(cleanupData.removedPids).toContain(runData.pid);
   });
 
-  it('accepts prompt_file and keeps the run response shape stable', async () => {
+  it('preserves successful prompt_file execution through the MCP process path', async () => {
     const promptFile = join(testDir, 'prompt.txt');
-    writeFileSync(promptFile, 'create a file called from-file.txt');
+    writeFileSync(promptFile, 'Create a file from prompt_file');
 
     const runResponse = await client.callTool('run', {
       prompt_file: promptFile,
       workFolder: testDir,
+      model: 'haiku',
     });
     const runData = parseToolJson(runResponse);
 
@@ -199,6 +211,138 @@ 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 () => {

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

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

package/src/app/cli.ts

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

package/src/app/mcp.ts

@@ -187,7 +187,7 @@ ${getSupportedModelsDescription()}
         },
         {
           name: 'get_result',
-          description: 'Get the current output and status of an AI agent process by PID. Returns the output from the agent including session_id (if applicable), along with process metadata.',
+          description: 'Get the current output and status of an AI agent process by PID. Defaults to a compact result shape; set verbose to true for full metadata and detailed parsed output.',
           inputSchema: {
             type: 'object',
             properties: {
@@ -197,7 +197,7 @@ ${getSupportedModelsDescription()}
               },
               verbose: {
                 type: 'boolean',
-                description: 'Optional: If true, returns detailed execution information including tool usage history. Defaults to false.',
+                description: 'Optional: If true, returns the full result shape including metadata fields and detailed parsed output such as tool usage history. Defaults to false.',
               }
             },
             required: ['pid'],
@@ -205,7 +205,7 @@ ${getSupportedModelsDescription()}
         },
         {
           name: 'wait',
-          description: 'Wait for multiple AI agent processes to complete and return their results. Blocks until all specified PIDs finish or timeout occurs.',
+          description: 'Wait for multiple AI agent processes to complete and return their results. Defaults to compact result items; set verbose to true for full metadata and detailed parsed output.',
           inputSchema: {
             type: 'object',
             properties: {
@@ -218,6 +218,10 @@ ${getSupportedModelsDescription()}
                 type: 'number',
                 description: 'Optional: Maximum time to wait in seconds. Defaults to 180 (3 minutes).',
               },
+              verbose: {
+                type: 'boolean',
+                description: 'Optional: If true, each result item uses the full result shape including metadata fields and detailed parsed output. Defaults to false.',
+              },
             },
             required: ['pids'],
           },
@@ -336,7 +340,8 @@ ${getSupportedModelsDescription()}
     try {
       const results = await this.processService.waitForProcesses(
         toolArguments.pids,
-        typeof toolArguments.timeout === 'number' ? toolArguments.timeout : 180
+        typeof toolArguments.timeout === 'number' ? toolArguments.timeout : 180,
+        !!toolArguments.verbose
       );
       return {
         content: [{

package/src/cli-process-service.ts

@@ -12,17 +12,19 @@ import {
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
-import { join } from 'node:path';
+import { join, basename, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand, type BuildCliCommandOptions } from './cli-builder.js';
 import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
 import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { buildProcessResult } from './process-result.js';
 import type { AgentType, ProcessListItem } from './process-service.js';
 
 interface StoredProcess {
   pid: number;
   prompt: string;
   workFolder: string;
+  cwdKey?: string;
   model?: string;
   toolType: AgentType;
   startTime: string;
@@ -127,6 +129,7 @@ export class CliProcessService {
         pid,
         prompt: cmd.prompt,
         workFolder: cmd.cwd,
+        cwdKey: this.resolveCwdKey(cmd.cwd),
         model: options.model,
         toolType: cmd.agent,
         startTime: new Date().toISOString(),
@@ -183,7 +186,7 @@ export class CliProcessService {
       }
     }
 
-    const response: any = {
+    return buildProcessResult({
       pid,
       agent: refreshed.toolType,
       status: refreshed.status,
@@ -192,27 +195,12 @@ export class CliProcessService {
       workFolder: refreshed.workFolder,
       prompt: refreshed.prompt,
       model: refreshed.model,
-    };
-
-    if (agentOutput) {
-      if (!verbose && agentOutput.tools) {
-        const { tools, ...rest } = agentOutput;
-        response.agentOutput = rest;
-      } else {
-        response.agentOutput = agentOutput;
-      }
-      if (agentOutput.session_id) {
-        response.session_id = agentOutput.session_id;
-      }
-    } else {
-      response.stdout = stdout;
-      response.stderr = stderr;
-    }
-
-    return response;
+      stdout,
+      stderr,
+    }, agentOutput, verbose);
   }
 
-  async waitForProcesses(pids: number[], timeoutSeconds = 180): Promise<any[]> {
+  async waitForProcesses(pids: number[], timeoutSeconds = 180, verbose = false): Promise<any[]> {
     const start = Date.now();
     for (const pid of pids) {
       this.readProcess(pid);
@@ -221,7 +209,7 @@ export class CliProcessService {
     while (true) {
       const statuses = pids.map((pid) => this.refreshStatus(this.readProcess(pid)).status);
       if (statuses.every((status) => status !== 'running')) {
-        return Promise.all(pids.map((pid) => this.getProcessResult(pid, false)));
+        return Promise.all(pids.map((pid) => this.getProcessResult(pid, verbose)));
       }
 
       if (Date.now() - start >= timeoutSeconds * 1000) {
@@ -274,7 +262,7 @@ export class CliProcessService {
         continue;
       }
 
-      const processDir = this.resolveProcessDir(refreshed.workFolder, refreshed.pid);
+      const processDir = this.resolveStoredProcessDir(refreshed);
       if (existsSync(processDir)) {
         rmSync(processDir, { recursive: true, force: true });
         removed++;
@@ -318,11 +306,15 @@ export class CliProcessService {
   }
 
   private parseProcessFile(metaPath: string): StoredProcess {
-    return JSON.parse(readFileSync(metaPath, 'utf-8')) as StoredProcess;
+    const process = JSON.parse(readFileSync(metaPath, 'utf-8')) as StoredProcess;
+    if (!process.cwdKey) {
+      process.cwdKey = basename(dirname(dirname(metaPath)));
+    }
+    return process;
   }
 
   private writeProcess(process: StoredProcess): void {
-    const processDir = this.resolveProcessDir(process.workFolder, process.pid);
+    const processDir = this.resolveStoredProcessDir(process);
     mkdirSync(processDir, { recursive: true });
     writeFileSync(this.resolveMetaPath(processDir), JSON.stringify(process, null, 2));
   }
@@ -347,7 +339,18 @@ export class CliProcessService {
   }
 
   private resolveProcessDir(cwd: string, pid: number): string {
-    return join(this.resolveCwdsDir(), normalizeCwdForStorage(realpathSync(cwd)), String(pid));
+    return join(this.resolveCwdsDir(), this.resolveCwdKey(cwd), String(pid));
+  }
+
+  private resolveStoredProcessDir(process: StoredProcess): string {
+    if (!process.cwdKey) {
+      process.cwdKey = this.resolveCwdKey(process.workFolder);
+    }
+    return join(this.resolveCwdsDir(), process.cwdKey, String(process.pid));
+  }
+
+  private resolveCwdKey(cwd: string): string {
+    return normalizeCwdForStorage(realpathSync(cwd));
   }
 
   private resolveMetaPath(processDir: string): string {

package/src/process-result.ts

@@ -0,0 +1,79 @@
+import type { AgentType, ProcessStatus } from './process-service.js';
+
+interface ProcessResultContext {
+  pid: number;
+  agent: AgentType;
+  status: ProcessStatus;
+  exitCode?: number;
+  startTime: string;
+  workFolder: string;
+  prompt: string;
+  model?: string;
+  stdout: string;
+  stderr: string;
+}
+
+function compactAgentOutput(agentOutput: any): any | null {
+  if (!agentOutput || typeof agentOutput !== 'object') {
+    return null;
+  }
+
+  const { tools: _tools, ...rest } = agentOutput;
+  const compact = Object.fromEntries(Object.entries(rest).filter(([, value]) => value !== undefined && value !== null));
+  return Object.keys(compact).length > 0 ? compact : null;
+}
+
+function hasMeaningfulParsedOutput(agentOutput: any): boolean {
+  if (!agentOutput || typeof agentOutput !== 'object') {
+    return false;
+  }
+
+  return Object.entries(agentOutput).some(([key, value]) => {
+    if (value === undefined || value === null) {
+      return false;
+    }
+
+    if (key === 'session_id') {
+      return false;
+    }
+
+    if (key === 'tools') {
+      return Array.isArray(value) ? value.length > 0 : true;
+    }
+
+    return true;
+  });
+}
+
+export function buildProcessResult(context: ProcessResultContext, agentOutput: any, verbose = false): any {
+  const response: any = {
+    pid: context.pid,
+    agent: context.agent,
+    status: context.status,
+    exitCode: context.exitCode ?? null,
+    model: context.model ?? null,
+  };
+
+  if (verbose) {
+    response.startTime = context.startTime;
+    response.workFolder = context.workFolder;
+    response.prompt = context.prompt;
+  }
+
+  if (agentOutput?.session_id) {
+    response.session_id = agentOutput.session_id;
+  }
+
+  const shapedAgentOutput = verbose ? agentOutput : compactAgentOutput(agentOutput);
+
+  if (hasMeaningfulParsedOutput(shapedAgentOutput)) {
+    response.agentOutput = shapedAgentOutput;
+  }
+
+  if (!response.agentOutput) {
+    response.stdout = context.stdout;
+    response.stderr = context.stderr;
+  }
+
+  return response;
+}

package/src/process-service.ts

@@ -1,6 +1,7 @@
 import { spawn, type ChildProcess } from 'node:child_process';
 import { buildCliCommand, type BuildCliCommandOptions } from './cli-builder.js';
 import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { buildProcessResult } from './process-result.js';
 
 export type AgentType = 'claude' | 'codex' | 'gemini' | 'forge';
 export type ProcessStatus = 'running' | 'completed' | 'failed';
@@ -149,7 +150,7 @@ export class ProcessService {
       }
     }
 
-    const response: any = {
+    return buildProcessResult({
       pid,
       agent: process.toolType,
       status: process.status,
@@ -158,28 +159,12 @@ export class ProcessService {
       workFolder: process.workFolder,
       prompt: process.prompt,
       model: process.model,
-    };
-
-    if (agentOutput) {
-      if (!verbose && agentOutput.tools) {
-        const { tools, ...rest } = agentOutput;
-        response.agentOutput = rest;
-      } else {
-        response.agentOutput = agentOutput;
-      }
-
-      if (agentOutput.session_id) {
-        response.session_id = agentOutput.session_id;
-      }
-    } else {
-      response.stdout = process.stdout;
-      response.stderr = process.stderr;
-    }
-
-    return response;
+      stdout: process.stdout,
+      stderr: process.stderr,
+    }, agentOutput, verbose);
   }
 
-  async waitForProcesses(pids: number[], timeoutSeconds = 180): Promise<any[]> {
+  async waitForProcesses(pids: number[], timeoutSeconds = 180, verbose = false): Promise<any[]> {
     for (const pid of pids) {
       if (!this.processManager.has(pid)) {
         throw new Error(`Process with PID ${pid} not found`);
@@ -211,7 +196,7 @@ export class ProcessService {
 
     try {
       await Promise.race([Promise.all(waitPromises), timeoutPromise]);
-      return pids.map((pid) => this.getProcessResult(pid, false));
+      return pids.map((pid) => this.getProcessResult(pid, verbose));
     } finally {
       if (timeoutHandle) {
         clearTimeout(timeoutHandle);