ai-cli-mcp 2.10.0 → 2.12.0

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

@@ -0,0 +1,285 @@
+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';
+describe('ai-cli app', () => {
+    it('prints help and exits successfully when no subcommand is provided', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const startMcpServer = vi.fn();
+        const exitCode = await runCli([], {
+            stdout,
+            stderr,
+            startMcpServer,
+        });
+        expect(exitCode).toBe(0);
+        expect(stdout).toHaveBeenCalledWith(CLI_HELP_TEXT);
+        expect(stderr).not.toHaveBeenCalled();
+        expect(startMcpServer).not.toHaveBeenCalled();
+    });
+    it('starts MCP mode when the mcp subcommand is provided', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const startMcpServer = vi.fn().mockResolvedValue(undefined);
+        const exitCode = await runCli(['mcp'], {
+            stdout,
+            stderr,
+            startMcpServer,
+        });
+        expect(exitCode).toBe(0);
+        expect(startMcpServer).toHaveBeenCalledTimes(1);
+        expect(stdout).not.toHaveBeenCalled();
+        expect(stderr).not.toHaveBeenCalled();
+    });
+    it('dispatches run with parsed CLI options', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const startMcpServer = vi.fn();
+        const runProcess = vi.fn().mockResolvedValue({
+            pid: 123,
+            status: 'started',
+            agent: 'claude',
+            message: 'claude process started successfully',
+        });
+        const exitCode = await runCli(['run', '--cwd', '/tmp/project', '--prompt', 'hello', '--model', 'sonnet'], {
+            stdout,
+            stderr,
+            startMcpServer,
+            runProcess,
+        });
+        expect(exitCode).toBe(0);
+        expect(runProcess).toHaveBeenCalledWith({
+            cwd: '/tmp/project',
+            prompt: 'hello',
+            model: 'sonnet',
+        });
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"pid": 123'));
+        expect(stderr).not.toHaveBeenCalled();
+    });
+    it('accepts legacy run option aliases', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const runProcess = vi.fn().mockResolvedValue({
+            pid: 123,
+            status: 'started',
+            agent: 'claude',
+            message: 'claude process started successfully',
+        });
+        const exitCode = await runCli([
+            'run',
+            '--workFolder',
+            '/tmp/project',
+            '--prompt_file',
+            '/tmp/prompt.txt',
+            '--session_id',
+            'session-123',
+            '--reasoning_effort',
+            'high',
+        ], {
+            stdout,
+            stderr,
+            runProcess,
+        });
+        expect(exitCode).toBe(0);
+        expect(runProcess).toHaveBeenCalledWith({
+            cwd: '/tmp/project',
+            prompt_file: '/tmp/prompt.txt',
+            session_id: 'session-123',
+            reasoning_effort: 'high',
+        });
+        expect(stderr).not.toHaveBeenCalled();
+    });
+    it('requires a prompt or prompt file for run', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const exitCode = await runCli(['run', '--cwd', '/tmp/project'], {
+            stdout,
+            stderr,
+        });
+        expect(exitCode).toBe(1);
+        expect(stderr).toHaveBeenCalledWith('Missing required option: --prompt or --prompt-file\n');
+        expect(stdout).toHaveBeenCalledWith(CLI_HELP_TEXT);
+    });
+    it('dispatches wait with pid arguments and timeout', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const waitForProcesses = vi.fn().mockResolvedValue([{ pid: 123, status: 'completed' }]);
+        const exitCode = await runCli(['wait', '123', '456', '--timeout', '5'], {
+            stdout,
+            stderr,
+            waitForProcesses,
+        });
+        expect(exitCode).toBe(0);
+        expect(waitForProcesses).toHaveBeenCalledWith([123, 456], 5);
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"status": "completed"'));
+    });
+    it('rejects invalid wait timeout values', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const waitForProcesses = vi.fn();
+        const exitCode = await runCli(['wait', '123', '--timeout', 'abc'], {
+            stdout,
+            stderr,
+            waitForProcesses,
+        });
+        expect(exitCode).toBe(1);
+        expect(stderr).toHaveBeenCalledWith('Invalid --timeout value\n');
+        expect(stdout).toHaveBeenCalledWith(CLI_HELP_TEXT);
+        expect(waitForProcesses).not.toHaveBeenCalled();
+    });
+    it('rejects non-integer pid arguments for wait', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const waitForProcesses = vi.fn();
+        const exitCode = await runCli(['wait', '123', 'abc'], {
+            stdout,
+            stderr,
+            waitForProcesses,
+        });
+        expect(exitCode).toBe(1);
+        expect(stderr).toHaveBeenCalledWith('All pid arguments must be positive integers\n');
+        expect(stdout).toHaveBeenCalledWith(CLI_HELP_TEXT);
+        expect(waitForProcesses).not.toHaveBeenCalled();
+    });
+    it('dispatches ps, result, and kill', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const listProcesses = vi.fn().mockResolvedValue([{ pid: 123, agent: 'claude', status: 'running' }]);
+        const getProcessResult = vi.fn().mockResolvedValue({ pid: 123, status: 'completed' });
+        const killProcess = vi.fn().mockResolvedValue({ pid: 123, status: 'terminated' });
+        const psExitCode = await runCli(['ps'], { stdout, stderr, listProcesses });
+        expect(psExitCode).toBe(0);
+        expect(listProcesses).toHaveBeenCalledTimes(1);
+        const resultExitCode = await runCli(['result', '123'], { stdout, stderr, getProcessResult });
+        expect(resultExitCode).toBe(0);
+        expect(getProcessResult).toHaveBeenCalledWith(123, false);
+        const killExitCode = await runCli(['kill', '123'], { stdout, stderr, killProcess });
+        expect(killExitCode).toBe(0);
+        expect(killProcess).toHaveBeenCalledWith(123);
+    });
+    it('dispatches cleanup', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const cleanupProcesses = vi.fn().mockResolvedValue({ removed: 2, message: 'Removed 2 processes' });
+        const exitCode = await runCli(['cleanup'], { stdout, stderr, cleanupProcesses });
+        expect(exitCode).toBe(0);
+        expect(cleanupProcesses).toHaveBeenCalledTimes(1);
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"removed": 2'));
+    });
+    it('prints models as structured json', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const exitCode = await runCli(['models'], { stdout, stderr });
+        expect(exitCode).toBe(0);
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"aliases"'));
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"claude-ultra"'));
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"gpt-5.4"'));
+        expect(stderr).not.toHaveBeenCalled();
+    });
+    it('prints doctor status as structured json', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const getDoctorStatus = vi.fn().mockReturnValue({
+            claude: {
+                configuredCommand: 'claude',
+                resolvedPath: '/tmp/bin/claude',
+                available: true,
+                lookup: 'path',
+            },
+            codex: {
+                configuredCommand: 'codex',
+                resolvedPath: null,
+                available: false,
+                lookup: 'path',
+            },
+            gemini: {
+                configuredCommand: 'gemini',
+                resolvedPath: '/tmp/bin/gemini',
+                available: true,
+                lookup: 'path',
+            },
+        });
+        const exitCode = await runCli(['doctor'], { stdout, stderr, getDoctorStatus });
+        expect(exitCode).toBe(0);
+        expect(getDoctorStatus).toHaveBeenCalledTimes(1);
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"configuredCommand": "claude"'));
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"available": false'));
+        expect(stderr).not.toHaveBeenCalled();
+    });
+    it('passes verbose through to result', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const getProcessResult = vi.fn().mockResolvedValue({ pid: 123, status: 'completed' });
+        const exitCode = await runCli(['result', '123', '--verbose'], { stdout, stderr, getProcessResult });
+        expect(exitCode).toBe(0);
+        expect(getProcessResult).toHaveBeenCalledWith(123, true);
+    });
+    it('prints detailed help for run --help', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const exitCode = await runCli(['run', '--help'], { stdout, stderr });
+        expect(exitCode).toBe(0);
+        expect(stdout).toHaveBeenCalledWith(RUN_HELP_TEXT);
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('claude-ultra'));
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('gpt-5.2-codex'));
+        expect(stdout).toHaveBeenCalledWith(expect.stringContaining('gemini-2.5-pro'));
+        expect(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(stderr).not.toHaveBeenCalled();
+    });
+    it('prints detailed help for models --help', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const exitCode = await runCli(['models', '--help'], { stdout, stderr });
+        expect(exitCode).toBe(0);
+        expect(stdout).toHaveBeenCalledWith(MODELS_HELP_TEXT);
+        expect(stderr).not.toHaveBeenCalled();
+    });
+    it('prints detailed help for doctor --help', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const exitCode = await runCli(['doctor', '--help'], { stdout, stderr });
+        expect(exitCode).toBe(0);
+        expect(stdout).toHaveBeenCalledWith(DOCTOR_HELP_TEXT);
+        expect(stderr).not.toHaveBeenCalled();
+    });
+    it('prints detailed help for doctor -h', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const exitCode = await runCli(['doctor', '-h'], { stdout, stderr });
+        expect(exitCode).toBe(0);
+        expect(stdout).toHaveBeenCalledWith(DOCTOR_HELP_TEXT);
+        expect(stderr).not.toHaveBeenCalled();
+    });
+    it('prints help for --help', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const startMcpServer = vi.fn();
+        const exitCode = await runCli(['--help'], {
+            stdout,
+            stderr,
+            startMcpServer,
+        });
+        expect(exitCode).toBe(0);
+        expect(stdout).toHaveBeenCalledWith(CLI_HELP_TEXT);
+        expect(stderr).not.toHaveBeenCalled();
+    });
+    it('returns a non-zero exit code for unknown subcommands', async () => {
+        const stdout = vi.fn();
+        const stderr = vi.fn();
+        const startMcpServer = vi.fn();
+        const exitCode = await runCli(['unknown'], {
+            stdout,
+            stderr,
+            startMcpServer,
+        });
+        expect(exitCode).toBe(1);
+        expect(stderr).toHaveBeenCalledWith(expect.stringContaining('Unknown subcommand: unknown'));
+        expect(stdout).toHaveBeenCalledWith(CLI_HELP_TEXT);
+        expect(startMcpServer).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/cli-bin-smoke.test.js

@@ -0,0 +1,54 @@
+import { execFileSync } from 'node:child_process';
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { delimiter, join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+const tempDirs = [];
+function makeTempDir(prefix) {
+    const dir = mkdtempSync(join(tmpdir(), prefix));
+    tempDirs.push(dir);
+    return dir;
+}
+function writeExecutable(dir, name) {
+    const filePath = join(dir, name);
+    writeFileSync(filePath, '#!/bin/sh\nexit 0\n', 'utf8');
+    chmodSync(filePath, 0o755);
+}
+afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('ai-cli entrypoint smoke', () => {
+    it('prints doctor output for the ai-cli entrypoint', () => {
+        const fakeBinDir = makeTempDir('ai-cli-bin-');
+        writeExecutable(fakeBinDir, 'claude');
+        writeExecutable(fakeBinDir, 'codex');
+        writeExecutable(fakeBinDir, 'gemini');
+        const output = execFileSync('node', ['--import', 'tsx', 'src/bin/ai-cli.ts', 'doctor'], {
+            cwd: process.cwd(),
+            encoding: 'utf8',
+            env: {
+                ...process.env,
+                PATH: `${fakeBinDir}${delimiter}${process.env.PATH || ''}`,
+                CLAUDE_CLI_NAME: 'claude',
+                CODEX_CLI_NAME: 'codex',
+                GEMINI_CLI_NAME: 'gemini',
+            },
+        });
+        expect(output).toContain('"claude"');
+        expect(output).toContain('"codex"');
+        expect(output).toContain('"gemini"');
+        expect(output).toContain('"available": true');
+    });
+    it('prints run help for the ai-cli entrypoint', () => {
+        const output = execFileSync('node', ['--import', 'tsx', 'src/bin/ai-cli.ts', 'run', '--help'], {
+            cwd: process.cwd(),
+            encoding: 'utf8',
+            env: process.env,
+        });
+        expect(output).toContain('Usage: ai-cli run --cwd <path> [options]');
+        expect(output).toContain('--model <model>');
+        expect(output).toContain('claude-ultra');
+    });
+});

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

@@ -58,12 +58,17 @@ describe('cli-builder', () => {
             expect(getReasoningEffort('gpt-5.2', 'medium')).toBe('medium');
             expect(getReasoningEffort('gpt-5.2', 'high')).toBe('high');
             expect(getReasoningEffort('gpt-5.2', 'xhigh')).toBe('xhigh');
+            expect(getReasoningEffort('sonnet', 'high')).toBe('high');
+            expect(getReasoningEffort('', 'low')).toBe('low');
         });
         it('should throw for invalid reasoning effort value', () => {
             expect(() => getReasoningEffort('gpt-5.2', 'ultra')).toThrow('Invalid reasoning_effort: ultra. Allowed values: low, medium, high, xhigh.');
         });
-        it('should throw for non-codex models', () => {
-            expect(() => getReasoningEffort('sonnet', 'high')).toThrow('reasoning_effort is only supported for Codex models (gpt-*).');
+        it('should reject xhigh for claude models', () => {
+            expect(() => getReasoningEffort('sonnet', 'xhigh')).toThrow('Claude reasoning_effort supports only low, medium, high.');
+        });
+        it('should throw for unsupported model families', () => {
+            expect(() => getReasoningEffort('gemini-2.5-pro', 'high')).toThrow('reasoning_effort is only supported for Claude and Codex models.');
         });
     });
     describe('buildCliCommand', () => {
@@ -173,6 +178,48 @@ describe('cli-builder', () => {
                 expect(cmd.resolvedModel).toBe('opus');
                 expect(cmd.args).toContain('opus');
             });
+            it('should resolve claude-ultra and default to high effort', () => {
+                const cmd = buildCliCommand({
+                    prompt: 'test',
+                    workFolder: '/tmp',
+                    model: 'claude-ultra',
+                    cliPaths: DEFAULT_CLI_PATHS,
+                });
+                expect(cmd.args).toContain('--effort');
+                expect(cmd.args).toContain('high');
+            });
+            it('should build claude command with reasoning_effort using --effort', () => {
+                const cmd = buildCliCommand({
+                    prompt: 'test',
+                    workFolder: '/tmp',
+                    model: 'sonnet',
+                    reasoning_effort: 'medium',
+                    cliPaths: DEFAULT_CLI_PATHS,
+                });
+                expect(cmd.args).toContain('--effort');
+                expect(cmd.args).toContain('medium');
+            });
+            it('should reject xhigh reasoning_effort for claude', () => {
+                expect(() => buildCliCommand({
+                    prompt: 'test',
+                    workFolder: '/tmp',
+                    model: 'sonnet',
+                    reasoning_effort: 'xhigh',
+                    cliPaths: DEFAULT_CLI_PATHS,
+                })).toThrow('Claude reasoning_effort supports only low, medium, high.');
+            });
+            it('should allow overriding reasoning_effort for claude-ultra', () => {
+                const cmd = buildCliCommand({
+                    prompt: 'test',
+                    workFolder: '/tmp',
+                    model: 'claude-ultra',
+                    reasoning_effort: 'low',
+                    cliPaths: DEFAULT_CLI_PATHS,
+                });
+                expect(cmd.args).toContain('--effort');
+                expect(cmd.args).toContain('low');
+                expect(cmd.args).not.toContain('high');
+            });
         });
         describe('codex agent', () => {
             it('should build codex command', () => {

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

@@ -0,0 +1,233 @@
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { CliProcessService } from '../cli-process-service.js';
+function createMockCliScript(dir, name, options = {}) {
+    const scriptPath = join(dir, name);
+    writeFileSync(scriptPath, `#!/bin/bash
+prompt=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -p|--prompt)
+      prompt="$2"
+      shift 2
+      ;;
+    *)
+      shift
+      ;;
+  esac
+done
+
+${options.ignoreSigterm ? "trap '' TERM\n" : ''}
+
+if [[ "$prompt" == *"sleep"* ]]; then
+${options.ignoreSigterm ? '  while true; do sleep 1; done\n' : '  sleep 5\n'}
+fi
+
+echo "Command executed successfully"
+`);
+    chmodSync(scriptPath, 0o755);
+    return scriptPath;
+}
+function encodeCwd(cwd) {
+    return cwd
+        .split('')
+        .map((char) => (/^[A-Za-z0-9.-]$/.test(char) ? char : `_${char.charCodeAt(0).toString(16).padStart(2, '0')}`))
+        .join('');
+}
+describe('CliProcessService', () => {
+    const tempDirs = [];
+    afterEach(() => {
+        for (const dir of tempDirs.splice(0)) {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it('starts a detached process and persists state under a normalized cwd directory', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const scriptPath = createMockCliScript(root, 'mock-claude');
+        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,
+            },
+        });
+        const runResult = await service.startProcess({
+            prompt: 'hello',
+            cwd: workFolder,
+            model: 'sonnet',
+        });
+        const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(runResult.pid));
+        expect(runResult.pid).toBeGreaterThan(0);
+        expect(runResult.status).toBe('started');
+        expect(existsSync(join(processDir, 'meta.json'))).toBe(true);
+        expect(existsSync(join(processDir, 'stdout.log'))).toBe(true);
+        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');
+        const listed = await service.listProcesses();
+        expect(listed).toContainEqual({
+            pid: runResult.pid,
+            agent: 'claude',
+            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(readFileSync(join(processDir, 'meta.json'), 'utf-8')).toContain('"status": "completed"');
+    });
+    it('can terminate a tracked process', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const scriptPath = createMockCliScript(root, 'mock-claude');
+        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,
+            },
+        });
+        const runResult = await service.startProcess({
+            prompt: 'sleep please',
+            cwd: workFolder,
+            model: 'sonnet',
+        });
+        await new Promise((resolve) => setTimeout(resolve, 150));
+        const killResult = await service.killProcess(runResult.pid);
+        expect(killResult).toEqual({
+            pid: runResult.pid,
+            status: 'terminated',
+            message: 'Process terminated successfully',
+        });
+        const result = await service.getProcessResult(runResult.pid, false);
+        expect(result.status).toBe('failed');
+    });
+    it('does not report termination until the process actually exits', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'project');
+        mkdirSync(workFolder, { recursive: true });
+        const pid = 12345;
+        const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(pid));
+        mkdirSync(processDir, { recursive: true });
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: '/bin/sh',
+                codex: '/bin/sh',
+                gemini: '/bin/sh',
+            },
+        });
+        writeFileSync(join(processDir, 'meta.json'), JSON.stringify({
+            pid,
+            prompt: 'sleep please',
+            workFolder,
+            model: 'sonnet',
+            toolType: 'claude',
+            startTime: new Date().toISOString(),
+            stdoutPath: join(processDir, 'stdout.log'),
+            stderrPath: join(processDir, 'stderr.log'),
+            status: 'running',
+        }));
+        const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target, signal) => {
+            if (signal === 0) {
+                return true;
+            }
+            if (target === -pid && signal === 'SIGTERM') {
+                return true;
+            }
+            return true;
+        });
+        const killResult = await service.killProcess(pid);
+        expect(killResult).toEqual({
+            pid,
+            status: 'running',
+            message: 'Signal sent but process is still running',
+        });
+        const stored = JSON.parse(readFileSync(join(processDir, 'meta.json'), 'utf-8'));
+        expect(stored.status).toBe('running');
+        killSpy.mockRestore();
+    });
+    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);
+        const stateDir = join(root, 'state');
+        const runningCwd = join(root, 'running-project');
+        const finishedCwd = join(root, 'finished-project');
+        mkdirSync(runningCwd, { recursive: true });
+        mkdirSync(finishedCwd, { recursive: true });
+        const runningDir = join(stateDir, 'cwds', encodeCwd(realpathSync(runningCwd)), '111');
+        const completedDir = join(stateDir, 'cwds', encodeCwd(realpathSync(finishedCwd)), '222');
+        const failedDir = join(stateDir, 'cwds', encodeCwd(realpathSync(finishedCwd)), '333');
+        mkdirSync(runningDir, { recursive: true });
+        mkdirSync(completedDir, { recursive: true });
+        mkdirSync(failedDir, { recursive: true });
+        writeFileSync(join(runningDir, 'meta.json'), JSON.stringify({
+            pid: 111,
+            prompt: 'keep',
+            workFolder: runningCwd,
+            toolType: 'claude',
+            startTime: new Date().toISOString(),
+            stdoutPath: join(runningDir, 'stdout.log'),
+            stderrPath: join(runningDir, 'stderr.log'),
+            status: 'running',
+        }));
+        writeFileSync(join(completedDir, 'meta.json'), JSON.stringify({
+            pid: 222,
+            prompt: 'done',
+            workFolder: finishedCwd,
+            toolType: 'claude',
+            startTime: new Date().toISOString(),
+            stdoutPath: join(completedDir, 'stdout.log'),
+            stderrPath: join(completedDir, 'stderr.log'),
+            status: 'completed',
+        }));
+        writeFileSync(join(failedDir, 'meta.json'), JSON.stringify({
+            pid: 333,
+            prompt: 'failed',
+            workFolder: finishedCwd,
+            toolType: 'claude',
+            startTime: new Date().toISOString(),
+            stdoutPath: join(failedDir, 'stdout.log'),
+            stderrPath: join(failedDir, 'stderr.log'),
+            status: 'failed',
+        }));
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: '/bin/sh',
+                codex: '/bin/sh',
+                gemini: '/bin/sh',
+            },
+        });
+        const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target, signal) => {
+            if (signal === 0 && target === 111) {
+                return true;
+            }
+            throw Object.assign(new Error('not running'), { code: 'ESRCH' });
+        });
+        const result = await service.cleanupProcesses();
+        expect(result).toEqual({
+            removed: 2,
+            message: 'Removed 2 processes',
+        });
+        expect(existsSync(runningDir)).toBe(true);
+        expect(existsSync(completedDir)).toBe(false);
+        expect(existsSync(failedDir)).toBe(false);
+        killSpy.mockRestore();
+    });
+});