factory-factory 0.4.6 → 0.4.8

package/dist/src/backend/services/session/service/acp/acp-runtime-manager.test.js

@@ -1,1736 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { tmpdir } from 'node:os';
-import { PassThrough } from 'node:stream';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { mockSpawn, mockInitialize, mockLoadSession, mockNewSession, mockPrompt, mockCancel, mockSetSessionConfigOption, mockSetSessionMode, mockSetSessionModel, mockExtMethod, mockNdJsonStream, } = vi.hoisted(() => ({
-    mockSpawn: vi.fn(),
-    mockInitialize: vi.fn(),
-    mockLoadSession: vi.fn(),
-    mockNewSession: vi.fn(),
-    mockPrompt: vi.fn(),
-    mockCancel: vi.fn(),
-    mockSetSessionConfigOption: vi.fn(),
-    mockSetSessionMode: vi.fn(),
-    mockSetSessionModel: vi.fn(),
-    mockExtMethod: vi.fn(),
-    mockNdJsonStream: vi
-        .fn()
-        .mockReturnValue({ writable: {}, readable: { pipeThrough: () => ({}) } }),
-}));
-vi.mock('node:child_process', () => ({
-    spawn: (...args) => mockSpawn(...args),
-}));
-vi.mock('@agentclientprotocol/sdk', () => {
-    class MockCSC {
-        toClient;
-        initialize = mockInitialize;
-        loadSession = mockLoadSession;
-        newSession = mockNewSession;
-        prompt = mockPrompt;
-        cancel = mockCancel;
-        setSessionConfigOption = mockSetSessionConfigOption;
-        setSessionMode = mockSetSessionMode;
-        unstable_setSessionModel = mockSetSessionModel;
-        extMethod = mockExtMethod;
-        constructor(toClient, _stream) {
-            this.toClient = toClient;
-        }
-    }
-    return {
-        ClientSideConnection: MockCSC,
-        ndJsonStream: (...args) => mockNdJsonStream(...args),
-        PROTOCOL_VERSION: 1,
-    };
-});
-vi.mock('@/backend/services/logger.service', () => ({
-    createLogger: () => ({
-        info: vi.fn(),
-        debug: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-    }),
-    getCurrentProcessEnv: () => ({ ...process.env }),
-}));
-import { SUBAGENTS_CAPABILITY_META_KEY, SUBAGENTS_LIST_METHOD, SUBAGENTS_READ_METHOD, } from '../../../../../shared/acp-protocol/subagents.js';
-import { AcpClientHandler } from './acp-client-handler.js';
-import { AcpRuntimeManager, PromptTimeoutError } from './acp-runtime-manager.js';
-describe('PromptTimeoutError', () => {
-    it('retains the caller-specified timeout for durable classification', () => {
-        const error = new PromptTimeoutError('session-1', 300_000);
-        expect(error.timeoutMs).toBe(300_000);
-    });
-});
-function createMockChildProcess() {
-    const child = new EventEmitter();
-    child.pid = 12_345;
-    child.exitCode = null;
-    child.signalCode = null;
-    child.killed = false;
-    child.kill = vi.fn((signal) => {
-        if (signal) {
-            child.killed = true;
-        }
-        if (signal === 'SIGKILL') {
-            child.exitCode = 137;
-            child.emit('exit', 137, 'SIGKILL');
-        }
-        return true;
-    });
-    child.stdout = new PassThrough();
-    child.stderr = new PassThrough();
-    child.stdin = new PassThrough();
-    return child;
-}
-function exitChildAfterSigterm(child) {
-    child.kill = vi.fn((signal) => {
-        if (signal === 'SIGTERM') {
-            queueMicrotask(() => {
-                child.signalCode = 'SIGTERM';
-                child.emit('exit', null, 'SIGTERM');
-            });
-        }
-        return true;
-    });
-}
-function defaultOptions() {
-    return {
-        provider: 'CLAUDE',
-        workingDir: '/tmp/workspace',
-        sessionId: 'test-session-1',
-    };
-}
-function codexOptions() {
-    return {
-        provider: 'CODEX',
-        workingDir: '/tmp/workspace',
-        sessionId: 'test-session-1',
-    };
-}
-function defaultHandlers() {
-    return {
-        onSessionId: vi.fn().mockResolvedValue(undefined),
-        onExit: vi.fn().mockResolvedValue(undefined),
-        onError: vi.fn(),
-        onAcpEvent: vi.fn(),
-    };
-}
-function defaultContext() {
-    return { workspaceId: 'w1', workingDir: '/tmp/workspace' };
-}
-function defaultConfigOptions() {
-    return [
-        {
-            id: 'model',
-            name: 'Model',
-            type: 'select',
-            category: 'model',
-            currentValue: 'sonnet',
-            options: [
-                { value: 'sonnet', name: 'Sonnet' },
-                { value: 'opus', name: 'Opus' },
-            ],
-        },
-        {
-            id: 'mode',
-            name: 'Mode',
-            type: 'select',
-            category: 'mode',
-            currentValue: 'default',
-            options: [
-                { value: 'default', name: 'Default' },
-                { value: 'plan', name: 'Plan' },
-            ],
-        },
-    ];
-}
-function setupSuccessfulSpawn(agentCapabilities = { loadSession: {} }) {
-    const child = createMockChildProcess();
-    mockSpawn.mockReturnValue(child);
-    mockInitialize.mockResolvedValue({
-        protocolVersion: 1,
-        agentCapabilities,
-        agentInfo: { name: 'claude-agent-acp' },
-    });
-    mockNewSession.mockResolvedValue({
-        sessionId: 'provider-session-123',
-        configOptions: defaultConfigOptions(),
-    });
-    mockLoadSession.mockResolvedValue({
-        configOptions: defaultConfigOptions(),
-    });
-    mockSetSessionConfigOption.mockResolvedValue({
-        configOptions: defaultConfigOptions(),
-    });
-    mockSetSessionMode.mockResolvedValue({});
-    mockSetSessionModel.mockResolvedValue({});
-    return child;
-}
-function subagentBrowseCapabilities() {
-    return {
-        loadSession: {},
-        _meta: {
-            [SUBAGENTS_CAPABILITY_META_KEY]: {
-                version: 1,
-                list: true,
-                read: true,
-                notifications: true,
-            },
-        },
-    };
-}
-function createDeferred() {
-    let resolvePromise;
-    let rejectPromise;
-    const promise = new Promise((resolve, reject) => {
-        resolvePromise = resolve;
-        rejectPromise = reject;
-    });
-    return { promise, resolve: resolvePromise, reject: rejectPromise };
-}
-describe('AcpRuntimeManager', () => {
-    let manager;
-    beforeEach(() => {
-        manager = new AcpRuntimeManager();
-    });
-    describe('getOrCreateClient', () => {
-        it('rejects before spawn when workingDir is empty', async () => {
-            await expect(manager.getOrCreateClient('session-empty-cwd', { ...defaultOptions(), workingDir: '' }, defaultHandlers(), defaultContext())).rejects.toThrow('ACP working directory is required before spawning adapter process');
-            expect(mockSpawn).not.toHaveBeenCalled();
-        });
-        it('rejects before spawn when workingDir is whitespace only', async () => {
-            await expect(manager.getOrCreateClient('session-whitespace-cwd', { ...defaultOptions(), workingDir: '   ' }, defaultHandlers(), defaultContext())).rejects.toThrow('ACP working directory is required before spawning adapter process');
-            expect(mockSpawn).not.toHaveBeenCalled();
-        });
-        it('spawns subprocess with detached:false, wires streams, initializes, creates session, returns handle', async () => {
-            setupSuccessfulSpawn();
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            expect(mockSpawn).toHaveBeenCalledTimes(1);
-            const spawnArgs = mockSpawn.mock.calls[0];
-            expect(spawnArgs[1]).toEqual([]);
-            expect(spawnArgs[2]).toMatchObject({
-                cwd: '/tmp/workspace',
-                stdio: ['pipe', 'pipe', 'pipe'],
-                detached: false,
-            });
-            expect(mockInitialize).toHaveBeenCalledTimes(1);
-            expect(mockInitialize).toHaveBeenCalledWith(expect.objectContaining({
-                protocolVersion: 1,
-                clientCapabilities: {},
-                clientInfo: expect.objectContaining({
-                    name: 'factory-factory',
-                }),
-            }));
-            expect(mockNewSession).toHaveBeenCalledTimes(1);
-            expect(mockNewSession).toHaveBeenCalledWith(expect.objectContaining({
-                cwd: '/tmp/workspace',
-                mcpServers: [],
-            }));
-            expect(handle.providerSessionId).toBe('provider-session-123');
-            expect(handle.agentCapabilities).toEqual({ loadSession: {} });
-            expect(handle.isPromptInFlight).toBe(false);
-            expect(handle.isRunning()).toBe(true);
-            expect(handle.getPid()).toBe(12_345);
-        });
-        it('spawns CODEX provider using internal CLI adapter command', async () => {
-            setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', codexOptions(), defaultHandlers(), defaultContext());
-            expect(mockSpawn).toHaveBeenCalledTimes(1);
-            const spawnArgs = mockSpawn.mock.calls[0];
-            expect(spawnArgs[1]).toContain('internal');
-            expect(spawnArgs[1]).toContain('codex-app-server-acp');
-            expect(spawnArgs[1].some((arg) => arg.endsWith('src/cli/index.ts') || arg.endsWith('dist/src/cli/index.js'))).toBe(true);
-            expect(typeof spawnArgs[0]).toBe('string');
-            expect(spawnArgs[0].length).toBeGreaterThan(0);
-            expect(spawnArgs[2].env?.DOTENV_CONFIG_QUIET).toBe('true');
-            if (spawnArgs[0].endsWith('tsx') ||
-                spawnArgs[0].endsWith('tsx.cmd')) {
-                expect(spawnArgs[1]).toContain('--tsconfig');
-                expect(spawnArgs[1].some((arg) => arg.endsWith('tsconfig.json'))).toBe(true);
-            }
-            expect(spawnArgs[2]).toMatchObject({
-                cwd: '/tmp/workspace',
-                stdio: ['pipe', 'pipe', 'pipe'],
-                detached: false,
-            });
-        });
-        it('resolves CODEX internal adapter from module location when cwd is outside repo', async () => {
-            setupSuccessfulSpawn();
-            const originalCwd = process.cwd();
-            process.chdir(tmpdir());
-            try {
-                await manager.getOrCreateClient('session-1', codexOptions(), defaultHandlers(), defaultContext());
-            }
-            finally {
-                process.chdir(originalCwd);
-            }
-            expect(mockSpawn).toHaveBeenCalledTimes(1);
-            const spawnArgs = mockSpawn.mock.calls[0];
-            const command = spawnArgs[0];
-            const args = spawnArgs[1];
-            expect(command.length).toBeGreaterThan(0);
-            expect(args).toContain('internal');
-            expect(args).toContain('codex-app-server-acp');
-            if (command.endsWith('tsx') || command.endsWith('tsx.cmd')) {
-                expect(args).toContain('--tsconfig');
-                expect(args.some((arg) => arg.endsWith('tsconfig.json'))).toBe(true);
-            }
-            expect(args.some((arg) => arg.endsWith('src/cli/index.ts') || arg.endsWith('dist/src/cli/index.js'))).toBe(true);
-        });
-        it('rejects cleanly when ACP binary spawn fails (ENOENT)', async () => {
-            const child = createMockChildProcess();
-            mockSpawn.mockReturnValue(child);
-            mockInitialize.mockImplementation(() => new Promise(() => {
-            }));
-            vi.useFakeTimers();
-            try {
-                const handlers = defaultHandlers();
-                const createResult = manager
-                    .getOrCreateClient('session-1', defaultOptions(), handlers, defaultContext())
-                    .then((handle) => ({ handle }), (error) => ({ error }));
-                let creationSettled = false;
-                void createResult.then(() => {
-                    creationSettled = true;
-                });
-                await vi.advanceTimersByTimeAsync(0);
-                expect(mockSpawn).toHaveBeenCalledTimes(1);
-                const spawnError = Object.assign(new Error('spawn claude-agent-acp ENOENT'), {
-                    code: 'ENOENT',
-                });
-                child.emit('error', spawnError);
-                await vi.advanceTimersByTimeAsync(0);
-                expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-                child.emit('close', -2, null);
-                await vi.advanceTimersByTimeAsync(0);
-                expect(creationSettled).toBe(true);
-                await expect(createResult).resolves.toMatchObject({
-                    error: {
-                        message: expect.stringMatching(/Failed to spawn ACP adapter ".*": spawn claude-agent-acp ENOENT/),
-                    },
-                });
-                expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
-                expect(handlers.onError).toHaveBeenCalledWith('session-1', expect.any(Error));
-            }
-            finally {
-                await vi.advanceTimersByTimeAsync(5000);
-                vi.useRealTimers();
-            }
-        });
-        it('allows the subprocess to exit during the SIGTERM grace period after initialization fails', async () => {
-            const child = createMockChildProcess();
-            exitChildAfterSigterm(child);
-            mockSpawn.mockReturnValue(child);
-            mockInitialize.mockRejectedValue(new Error('handshake failed'));
-            await expect(manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('handshake failed');
-            expect(child.kill).toHaveBeenCalledTimes(1);
-            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
-            expect(mockNewSession).not.toHaveBeenCalled();
-        });
-        it('does not signal a subprocess that already terminated from a signal', async () => {
-            const child = createMockChildProcess();
-            child.signalCode = 'SIGTERM';
-            mockSpawn.mockReturnValue(child);
-            mockInitialize.mockRejectedValue(new Error('handshake failed'));
-            vi.useFakeTimers();
-            try {
-                const creationPromise = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-                const creationRejection = creationPromise.catch((error) => error);
-                await vi.advanceTimersByTimeAsync(5000);
-                await expect(creationRejection).resolves.toMatchObject({ message: 'handshake failed' });
-                expect(child.kill).not.toHaveBeenCalled();
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
-        it('escalates failed initialization cleanup to SIGKILL after the grace period', async () => {
-            const child = createMockChildProcess();
-            mockSpawn.mockReturnValue(child);
-            mockInitialize.mockRejectedValue(new Error('handshake failed'));
-            vi.useFakeTimers();
-            try {
-                const creationPromise = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-                const creationRejection = creationPromise.catch((error) => error);
-                await vi.advanceTimersByTimeAsync(0);
-                expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-                expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
-                await vi.advanceTimersByTimeAsync(4999);
-                expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
-                await vi.advanceTimersByTimeAsync(1);
-                await expect(creationRejection).resolves.toMatchObject({ message: 'handshake failed' });
-                expect(child.kill).toHaveBeenCalledWith('SIGKILL');
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
-        it('times out when ACP initialize handshake never resolves', async () => {
-            manager.setAcpStartupTimeoutMs(20);
-            const child = createMockChildProcess();
-            exitChildAfterSigterm(child);
-            mockSpawn.mockReturnValue(child);
-            mockInitialize.mockImplementation(() => new Promise(() => {
-            }));
-            await expect(manager.getOrCreateClient('session-timeout-init', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('ACP initialize handshake timed out');
-            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
-        });
-        it('times out when ACP session creation never resolves', async () => {
-            manager.setAcpStartupTimeoutMs(20);
-            const child = createMockChildProcess();
-            exitChildAfterSigterm(child);
-            mockSpawn.mockReturnValue(child);
-            mockInitialize.mockResolvedValue({
-                protocolVersion: 1,
-                agentCapabilities: { loadSession: {} },
-                agentInfo: { name: 'claude-agent-acp' },
-            });
-            mockNewSession.mockImplementation(() => new Promise(() => {
-            }));
-            await expect(manager.getOrCreateClient('session-timeout-new-session', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('ACP session creation timed out');
-            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
-        });
-        it('returns existing handle if session already exists and is running', async () => {
-            setupSuccessfulSpawn();
-            const handle1 = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const handle2 = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            expect(handle1).toBe(handle2);
-            expect(mockSpawn).toHaveBeenCalledTimes(1);
-        });
-        it('deduplicates concurrent creation for same sessionId', async () => {
-            const child = createMockChildProcess();
-            mockSpawn.mockReturnValue(child);
-            let resolveInit;
-            mockInitialize.mockReturnValue(new Promise((resolve) => {
-                resolveInit = resolve;
-            }));
-            mockNewSession.mockResolvedValue({
-                sessionId: 'provider-session-123',
-                configOptions: defaultConfigOptions(),
-            });
-            const first = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const second = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await new Promise((r) => setTimeout(r, 10));
-            resolveInit({
-                protocolVersion: 1,
-                agentCapabilities: {},
-                agentInfo: { name: 'test' },
-            });
-            const [h1, h2] = await Promise.all([first, second]);
-            expect(h1).toBe(h2);
-            expect(mockSpawn).toHaveBeenCalledTimes(1);
-        });
-        it('calls onSessionId handler with provider session ID', async () => {
-            setupSuccessfulSpawn();
-            const handlers = defaultHandlers();
-            await manager.getOrCreateClient('session-1', defaultOptions(), handlers, defaultContext());
-            expect(handlers.onSessionId).toHaveBeenCalledWith('session-1', 'provider-session-123');
-        });
-        it('calls onClientCreated callback when set', async () => {
-            setupSuccessfulSpawn();
-            const callback = vi.fn();
-            manager.setOnClientCreated(callback);
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            expect(callback).toHaveBeenCalledWith('session-1', handle, defaultContext());
-        });
-        it('stores config options returned by ACP newSession', async () => {
-            setupSuccessfulSpawn();
-            const expectedConfigOptions = [
-                {
-                    id: 'model',
-                    name: 'Model',
-                    type: 'select',
-                    category: 'model',
-                    currentValue: 'sonnet',
-                    options: [
-                        { value: 'sonnet', name: 'Sonnet' },
-                        { value: 'opus', name: 'Opus' },
-                    ],
-                },
-                {
-                    id: 'mode',
-                    name: 'Mode',
-                    type: 'select',
-                    category: 'mode',
-                    currentValue: 'default',
-                    options: [
-                        { value: 'default', name: 'Default' },
-                        { value: 'plan', name: 'Plan' },
-                    ],
-                },
-            ];
-            mockNewSession.mockResolvedValueOnce({
-                sessionId: 'provider-session-123',
-                configOptions: expectedConfigOptions,
-            });
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            expect(handle.configOptions).toEqual(expectedConfigOptions);
-        });
-        it('fails fast when ACP newSession omits configOptions', async () => {
-            const child = setupSuccessfulSpawn();
-            exitChildAfterSigterm(child);
-            mockNewSession.mockResolvedValueOnce({
-                sessionId: 'provider-session-123',
-            });
-            await expect(manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('did not include required configOptions');
-        });
-        it('derives required config options from models/modes when newSession omits configOptions', async () => {
-            setupSuccessfulSpawn();
-            mockNewSession.mockResolvedValueOnce({
-                sessionId: 'provider-session-123',
-                models: {
-                    availableModels: [
-                        { modelId: 'claude-opus-4-6', name: 'Claude Opus 4.6' },
-                        { modelId: 'claude-sonnet-4-5', name: 'Claude Sonnet 4.5' },
-                    ],
-                    currentModelId: 'claude-opus-4-6',
-                },
-                modes: {
-                    availableModes: [
-                        { id: 'default', name: 'Default' },
-                        { id: 'plan', name: 'Plan' },
-                    ],
-                    currentModeId: 'default',
-                },
-            });
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const modelOption = handle.configOptions.find((option) => option.category === 'model');
-            const modeOption = handle.configOptions.find((option) => option.category === 'mode');
-            expect(modelOption).toMatchObject({
-                id: 'model',
-                currentValue: 'claude-opus-4-6',
-            });
-            expect(modelOption?.options).toEqual(expect.arrayContaining([
-                expect.objectContaining({ value: 'claude-opus-4-6', name: 'Claude Opus 4.6' }),
-                expect.objectContaining({ value: 'claude-sonnet-4-5', name: 'Claude Sonnet 4.5' }),
-            ]));
-            expect(modeOption).toMatchObject({
-                id: 'mode',
-                currentValue: 'default',
-            });
-            expect(modeOption?.options).toEqual(expect.arrayContaining([
-                expect.objectContaining({ value: 'default', name: 'Default' }),
-                expect.objectContaining({ value: 'plan', name: 'Plan' }),
-            ]));
-        });
-        it('fails fast when ACP newSession omits required model/mode categories', async () => {
-            const child = setupSuccessfulSpawn();
-            exitChildAfterSigterm(child);
-            mockNewSession.mockResolvedValueOnce({
-                sessionId: 'provider-session-123',
-                configOptions: [
-                    {
-                        id: 'reasoning_effort',
-                        name: 'Reasoning Effort',
-                        type: 'select',
-                        category: 'thought_level',
-                        currentValue: 'medium',
-                        options: [{ value: 'medium', name: 'Medium' }],
-                    },
-                ],
-            });
-            await expect(manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('missing required config option categories: model, mode');
-        });
-        it('uses model family name for Claude default model labels in configOptions', async () => {
-            setupSuccessfulSpawn();
-            mockNewSession.mockResolvedValueOnce({
-                sessionId: 'provider-session-123',
-                configOptions: [
-                    {
-                        id: 'model',
-                        name: 'Model',
-                        type: 'select',
-                        category: 'model',
-                        currentValue: 'default',
-                        options: [
-                            {
-                                value: 'default',
-                                name: 'Default (recommended)',
-                                description: 'Opus 4.6 · best for complex tasks',
-                            },
-                            { value: 'sonnet', name: 'Sonnet 4.5' },
-                        ],
-                    },
-                    {
-                        id: 'mode',
-                        name: 'Mode',
-                        type: 'select',
-                        category: 'mode',
-                        currentValue: 'default',
-                        options: [
-                            { value: 'default', name: 'Default' },
-                            { value: 'plan', name: 'Plan' },
-                        ],
-                    },
-                ],
-            });
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const modelOption = handle.configOptions.find((option) => option.id === 'model');
-            const defaultEntry = modelOption?.options.find((option) => 'value' in option && option.value === 'default');
-            expect(defaultEntry).toMatchObject({ value: 'default', name: 'Default — Opus 4.6' });
-        });
-    });
-    describe('sub-agent browsing extensions', () => {
-        it('classifies a browse-only client before provider restoration completes', async () => {
-            const child = setupSuccessfulSpawn({ ...subagentBrowseCapabilities(), loadSession: true });
-            const initialization = createDeferred();
-            mockInitialize.mockReturnValueOnce(initialization.promise);
-            const creation = manager.getOrCreateClient('db-session-1', {
-                ...codexOptions(),
-                purpose: 'browse',
-                resumeProviderSessionId: 'provider-session-existing',
-            }, defaultHandlers(), defaultContext());
-            await vi.waitFor(() => {
-                expect(mockSpawn).toHaveBeenCalled();
-            });
-            expect(manager.isBrowseOnlySession('db-session-1')).toBe(true);
-            initialization.resolve({
-                protocolVersion: 1,
-                agentCapabilities: { ...subagentBrowseCapabilities(), loadSession: true },
-                agentInfo: { name: 'codex-app-server-acp' },
-            });
-            await creation;
-            expect(manager.isBrowseOnlySession('db-session-1')).toBe(true);
-            exitChildAfterSigterm(child);
-            await manager.stopClient('db-session-1');
-        });
-        it('keeps a browse-only restored client stopped until active startup promotes it', async () => {
-            setupSuccessfulSpawn({ ...subagentBrowseCapabilities(), loadSession: true });
-            mockExtMethod.mockResolvedValueOnce({ subagents: [], nextCursor: null });
-            const browseHandle = await manager.getOrCreateClient('db-session-1', {
-                ...codexOptions(),
-                purpose: 'browse',
-                resumeProviderSessionId: 'provider-session-existing',
-            }, defaultHandlers(), defaultContext());
-            await expect(manager.listSubagents('db-session-1', { cursor: null, limit: 50 })).resolves.toEqual({ subagents: [], nextCursor: null });
-            expect(manager.getClient('db-session-1')).toBeUndefined();
-            expect(manager.isSessionRunning('db-session-1')).toBe(false);
-            const activeHandle = await manager.getOrCreateClient('db-session-1', { ...codexOptions(), purpose: 'active' }, defaultHandlers(), defaultContext());
-            expect(activeHandle).toBe(browseHandle);
-            expect(manager.getClient('db-session-1')).toBe(browseHandle);
-            expect(manager.isSessionRunning('db-session-1')).toBe(true);
-            expect(mockSpawn).toHaveBeenCalledTimes(1);
-        });
-        it('does not replace a missing browse-only provider session with a new session', async () => {
-            const child = setupSuccessfulSpawn({ ...subagentBrowseCapabilities(), loadSession: true });
-            exitChildAfterSigterm(child);
-            mockLoadSession.mockRejectedValueOnce(new Error('stored provider session missing'));
-            await expect(manager.getOrCreateClient('db-session-1', {
-                ...codexOptions(),
-                purpose: 'browse',
-                resumeProviderSessionId: 'provider-session-missing',
-            }, defaultHandlers(), defaultContext())).rejects.toMatchObject({
-                name: 'AcpBrowseSessionUnavailableError',
-                cause: { message: 'stored provider session missing' },
-            });
-            expect(mockNewSession).not.toHaveBeenCalled();
-        });
-        it('preserves browse-only state when an older process finishes exit handling', async () => {
-            const firstChild = setupSuccessfulSpawn();
-            const exitHandling = createDeferred();
-            const firstHandlers = {
-                ...defaultHandlers(),
-                onExit: vi.fn(() => exitHandling.promise),
-            };
-            await manager.getOrCreateClient('db-session-1', defaultOptions(), firstHandlers, defaultContext());
-            firstChild.exitCode = 1;
-            firstChild.emit('exit', 1, null);
-            await vi.waitFor(() => {
-                expect(firstHandlers.onExit).toHaveBeenCalledWith('db-session-1', 1);
-            });
-            const replacementChild = setupSuccessfulSpawn({
-                ...subagentBrowseCapabilities(),
-                loadSession: true,
-            });
-            const replacementHandle = await manager.getOrCreateClient('db-session-1', {
-                ...codexOptions(),
-                purpose: 'browse',
-                resumeProviderSessionId: 'provider-session-existing',
-            }, defaultHandlers(), defaultContext());
-            exitHandling.resolve();
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            expect(manager.getBrowseClient('db-session-1')).toBe(replacementHandle);
-            expect(manager.isBrowseOnlySession('db-session-1')).toBe(true);
-            expect(manager.getClient('db-session-1')).toBeUndefined();
-            exitChildAfterSigterm(replacementChild);
-            await manager.stopClient('db-session-1');
-        });
-        it('classifies a provider without loadSession as unsupported for browse restoration', async () => {
-            const child = setupSuccessfulSpawn(subagentBrowseCapabilities());
-            exitChildAfterSigterm(child);
-            await expect(manager.getOrCreateClient('db-session-1', {
-                ...codexOptions(),
-                purpose: 'browse',
-                resumeProviderSessionId: 'provider-session-existing',
-            }, defaultHandlers(), defaultContext())).rejects.toMatchObject({ name: 'AcpBrowseSessionUnavailableError' });
-            expect(mockNewSession).not.toHaveBeenCalled();
-        });
-        it('returns the negotiated capability only for a live handle', async () => {
-            expect(manager.getSubagentBrowseCapability('session-1')).toBeNull();
-            const child = setupSuccessfulSpawn(subagentBrowseCapabilities());
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            expect(manager.getSubagentBrowseCapability('session-1')).toEqual({
-                version: 1,
-                list: true,
-                read: true,
-                notifications: true,
-            });
-            child.killed = true;
-            expect(manager.getSubagentBrowseCapability('session-1')).toBeNull();
-        });
-        it('lists sub-agents with the provider session ID and unchanged cursor', async () => {
-            setupSuccessfulSpawn(subagentBrowseCapabilities());
-            mockExtMethod.mockResolvedValueOnce({ subagents: [], nextCursor: null });
-            await manager.getOrCreateClient('db-session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const result = await manager.listSubagents('db-session-1', {
-                cursor: 'list-cursor-7',
-                limit: 50,
-            });
-            expect(result).toEqual({ subagents: [], nextCursor: null });
-            expect(mockExtMethod).toHaveBeenCalledWith(SUBAGENTS_LIST_METHOD, {
-                sessionId: 'provider-session-123',
-                cursor: 'list-cursor-7',
-                limit: 50,
-            });
-        });
-        it('reads a transcript with the provider session ID and unchanged cursor', async () => {
-            setupSuccessfulSpawn(subagentBrowseCapabilities());
-            mockExtMethod.mockResolvedValueOnce({
-                projectionBoundary: 'turn',
-                updates: [],
-                nextCursor: 'read-cursor-9',
-            });
-            await manager.getOrCreateClient('db-session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const result = await manager.readSubagentTranscript('db-session-1', {
-                subagentId: 'child-1',
-                cursor: 'read-cursor-8',
-                limit: 10,
-            });
-            expect(result).toEqual({
-                projectionBoundary: 'turn',
-                updates: [],
-                nextCursor: 'read-cursor-9',
-            });
-            expect(mockExtMethod).toHaveBeenCalledWith(SUBAGENTS_READ_METHOD, {
-                sessionId: 'provider-session-123',
-                subagentId: 'child-1',
-                cursor: 'read-cursor-8',
-                limit: 10,
-            });
-        });
-        it('rejects malformed extension inputs before calling the provider', async () => {
-            setupSuccessfulSpawn(subagentBrowseCapabilities());
-            await manager.getOrCreateClient('db-session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await expect(manager.listSubagents('db-session-1', { cursor: null, limit: 101 })).rejects.toThrow();
-            expect(mockExtMethod).not.toHaveBeenCalled();
-        });
-        it('normalizes malformed list and transcript responses as provider precondition errors', async () => {
-            setupSuccessfulSpawn(subagentBrowseCapabilities());
-            await manager.getOrCreateClient('db-session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            mockExtMethod.mockResolvedValueOnce({ subagents: 'invalid', nextCursor: null });
-            await expect(manager.listSubagents('db-session-1', { cursor: null, limit: 50 })).rejects.toMatchObject({
-                name: 'AcpSubagentBrowseError',
-                code: 'PRECONDITION_FAILED',
-                message: 'Sub-agent list is unavailable because the provider returned an invalid response.',
-            });
-            mockExtMethod.mockResolvedValueOnce({
-                projectionBoundary: 'turn',
-                updates: [{ sessionUpdate: 'unknown' }],
-                nextCursor: null,
-            });
-            await expect(manager.readSubagentTranscript('db-session-1', {
-                subagentId: 'child-1',
-                cursor: null,
-                limit: 10,
-            })).rejects.toMatchObject({
-                name: 'AcpSubagentBrowseError',
-                code: 'PRECONDITION_FAILED',
-                message: 'Sub-agent transcript is unavailable because the provider returned an invalid response.',
-            });
-        });
-        it('normalizes provider extension errors into safe application errors', async () => {
-            setupSuccessfulSpawn(subagentBrowseCapabilities());
-            await manager.getOrCreateClient('db-session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            mockExtMethod.mockRejectedValueOnce({
-                code: -32_602,
-                message: 'Invalid params: secret provider detail',
-                data: { cursor: 'invalid' },
-            });
-            await expect(manager.readSubagentTranscript('db-session-1', {
-                subagentId: 'child-1',
-                cursor: 'invalid',
-                limit: 10,
-            })).rejects.toMatchObject({
-                name: 'AcpSubagentBrowseError',
-                code: 'INVALID_INPUT',
-                message: 'Invalid sub-agent transcript request.',
-            });
-            mockExtMethod.mockRejectedValueOnce({
-                code: -32_002,
-                message: 'Resource not found: secret provider thread',
-            });
-            await expect(manager.readSubagentTranscript('db-session-1', {
-                subagentId: 'foreign-child',
-                cursor: null,
-                limit: 10,
-            })).rejects.toMatchObject({
-                name: 'AcpSubagentBrowseError',
-                code: 'NOT_FOUND',
-                message: 'Sub-agent transcript not found for this session.',
-            });
-            mockExtMethod.mockRejectedValueOnce({
-                code: -32_603,
-                message: 'Internal error: mismatched provider thread IDs',
-            });
-            await expect(manager.readSubagentTranscript('db-session-1', {
-                subagentId: 'child-1',
-                cursor: null,
-                limit: 10,
-            })).rejects.toMatchObject({
-                name: 'AcpSubagentBrowseError',
-                code: 'PRECONDITION_FAILED',
-                message: 'Sub-agent transcript is unavailable because the provider returned an invalid response.',
-            });
-        });
-        it('preserves JSON-RPC codes carried by Error subclasses', async () => {
-            setupSuccessfulSpawn(subagentBrowseCapabilities());
-            await manager.getOrCreateClient('db-session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const providerError = Object.assign(new Error('Resource not found: provider thread'), {
-                code: -32_002,
-                data: { threadId: 'missing-child' },
-            });
-            mockExtMethod.mockRejectedValueOnce(providerError);
-            await expect(manager.readSubagentTranscript('db-session-1', {
-                subagentId: 'missing-child',
-                cursor: null,
-                limit: 10,
-            })).rejects.toMatchObject({
-                name: 'AcpSubagentBrowseError',
-                code: 'NOT_FOUND',
-                message: 'Sub-agent transcript not found for this session.',
-            });
-        });
-        it('rejects extension requests without a live handle or negotiated capability', async () => {
-            await expect(manager.listSubagents('missing-session', { cursor: null, limit: 50 })).rejects.toMatchObject({
-                name: 'AcpSubagentBrowseError',
-                code: 'PRECONDITION_FAILED',
-                message: 'Sub-agent browsing requires a running parent session.',
-            });
-            setupSuccessfulSpawn();
-            await manager.getOrCreateClient('db-session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await expect(manager.readSubagentTranscript('db-session-1', {
-                subagentId: 'child-1',
-                cursor: null,
-                limit: 10,
-            })).rejects.toMatchObject({
-                name: 'AcpSubagentBrowseError',
-                code: 'PRECONDITION_FAILED',
-                message: 'Sub-agent browsing is unavailable for this session.',
-            });
-            expect(mockExtMethod).not.toHaveBeenCalled();
-        });
-    });
-    describe('stopClient', () => {
-        it('keeps creation lock bookkeeping when stop is already in progress', async () => {
-            const child = setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const internalManager = manager;
-            internalManager.creationLocks.set('session-1', vi.fn());
-            internalManager.lockRefCounts.set('session-1', 3);
-            child.kill = vi.fn(() => {
-                setTimeout(() => {
-                    child.exitCode = 0;
-                    child.emit('exit', 0, null);
-                }, 10);
-                return true;
-            });
-            const stopPromise = manager.stopClient('session-1');
-            await vi.waitFor(() => {
-                expect(manager.isStopInProgress('session-1')).toBe(true);
-            });
-            await manager.stopClient('session-1');
-            expect(internalManager.creationLocks.has('session-1')).toBe(true);
-            expect(internalManager.lockRefCounts.has('session-1')).toBe(true);
-            await stopPromise;
-        });
-        it('sends SIGTERM, waits grace period, cleans up references', async () => {
-            const child = setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            child.kill = vi.fn(() => {
-                child.exitCode = 0;
-                child.emit('exit', 0, null);
-                return true;
-            });
-            await manager.stopClient('session-1');
-            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(manager.getClient('session-1')).toBeUndefined();
-        });
-        it('clears the SIGTERM grace-period timeout when the child exits quickly', async () => {
-            const child = setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            child.kill = vi.fn(() => {
-                child.exitCode = 0;
-                child.emit('exit', 0, null);
-                return true;
-            });
-            vi.useFakeTimers();
-            try {
-                await manager.stopClient('session-1');
-                expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-                expect(vi.getTimerCount()).toBe(0);
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
-        it('escalates to SIGKILL after timeout', async () => {
-            const child = setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const killCalls = [];
-            child.kill = vi.fn((signal) => {
-                killCalls.push(signal ?? 'default');
-                if (signal === 'SIGKILL') {
-                    child.killed = true;
-                    child.exitCode = 137;
-                    child.emit('exit', 137, 'SIGKILL');
-                }
-                return true;
-            });
-            vi.useFakeTimers();
-            const stopPromise = manager.stopClient('session-1');
-            await vi.advanceTimersByTimeAsync(5100);
-            await stopPromise;
-            expect(killCalls).toContain('SIGTERM');
-            expect(killCalls).toContain('SIGKILL');
-            expect(manager.getClient('session-1')).toBeUndefined();
-            vi.useRealTimers();
-        });
-        it('cancels prompt if isPromptInFlight before SIGTERM', async () => {
-            const child = setupSuccessfulSpawn();
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            handle.isPromptInFlight = true;
-            mockCancel.mockResolvedValue(undefined);
-            child.kill = vi.fn(() => {
-                child.exitCode = 0;
-                child.emit('exit', 0, null);
-                return true;
-            });
-            await manager.stopClient('session-1');
-            expect(mockCancel).toHaveBeenCalledWith({
-                sessionId: 'provider-session-123',
-            });
-            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-        });
-        it('waits for an existing stop when called concurrently', async () => {
-            const child = setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            child.kill = vi.fn(() => true);
-            const firstStop = manager.stopClient('session-1');
-            await vi.waitFor(() => {
-                expect(manager.isStopInProgress('session-1')).toBe(true);
-            });
-            let secondStopSettled = false;
-            const secondStop = manager.stopClient('session-1').then(() => {
-                secondStopSettled = true;
-            });
-            await Promise.resolve();
-            expect(secondStopSettled).toBe(false);
-            child.exitCode = 0;
-            child.emit('exit', 0, null);
-            await Promise.all([firstStop, secondStop]);
-            expect(secondStopSettled).toBe(true);
-            expect(child.kill).toHaveBeenCalledTimes(1);
-            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-        });
-        it('aborts in-flight client creation and cleans up the spawned subprocess', async () => {
-            const child = createMockChildProcess();
-            exitChildAfterSigterm(child);
-            mockSpawn.mockReturnValue(child);
-            mockInitialize.mockImplementation(() => new Promise(() => {
-            }));
-            const createPromise = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const createRejection = createPromise.catch((error) => error);
-            await vi.waitFor(() => {
-                expect(mockSpawn).toHaveBeenCalledTimes(1);
-                expect(manager.getPendingClient('session-1')).toBeDefined();
-            });
-            await manager.stopClient('session-1');
-            await expect(createRejection).resolves.toMatchObject({
-                message: expect.stringContaining('ACP session stop requested'),
-            });
-            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
-            expect(manager.isStopInProgress('session-1')).toBe(false);
-            expect(manager.getClient('session-1')).toBeUndefined();
-            expect(manager.getPendingClient('session-1')).toBeUndefined();
-        });
-        it('skips exit handler when stop is in progress', async () => {
-            const child = setupSuccessfulSpawn();
-            const handlers = defaultHandlers();
-            await manager.getOrCreateClient('session-1', defaultOptions(), handlers, defaultContext());
-            handlers.onExit.mockClear();
-            child.kill = vi.fn(() => {
-                child.exitCode = 0;
-                child.emit('exit', 0, null);
-                return true;
-            });
-            await manager.stopClient('session-1');
-            expect(handlers.onExit).not.toHaveBeenCalled();
-        });
-        it('skips exit handler when a stopped process exits after stop timeout', async () => {
-            const child = setupSuccessfulSpawn();
-            const handlers = defaultHandlers();
-            await manager.getOrCreateClient('session-1', defaultOptions(), handlers, defaultContext());
-            child.kill = vi.fn((signal) => {
-                if (signal) {
-                    child.killed = true;
-                }
-                return true;
-            });
-            vi.useFakeTimers();
-            const stopPromise = manager.stopClient('session-1');
-            await vi.advanceTimersByTimeAsync(5100);
-            await stopPromise;
-            vi.useRealTimers();
-            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(child.kill).toHaveBeenCalledWith('SIGKILL');
-            expect(manager.isStopInProgress('session-1')).toBe(false);
-            handlers.onExit.mockClear();
-            child.exitCode = 137;
-            child.emit('exit', 137, 'SIGKILL');
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            expect(handlers.onExit).not.toHaveBeenCalled();
-        });
-        it('does not let a late stopped-process exit affect a replacement client', async () => {
-            const firstChild = setupSuccessfulSpawn();
-            const firstHandlers = defaultHandlers();
-            await manager.getOrCreateClient('session-1', defaultOptions(), firstHandlers, defaultContext());
-            firstChild.kill = vi.fn((signal) => {
-                if (signal) {
-                    firstChild.killed = true;
-                }
-                return true;
-            });
-            vi.useFakeTimers();
-            const stopPromise = manager.stopClient('session-1');
-            await vi.advanceTimersByTimeAsync(5100);
-            await stopPromise;
-            vi.useRealTimers();
-            const secondChild = createMockChildProcess();
-            const secondHandlers = defaultHandlers();
-            mockSpawn.mockReturnValueOnce(secondChild);
-            const restartedHandle = await manager.getOrCreateClient('session-1', defaultOptions(), secondHandlers, defaultContext());
-            firstHandlers.onExit.mockClear();
-            firstChild.exitCode = 137;
-            firstChild.emit('exit', 137, 'SIGKILL');
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            expect(firstHandlers.onExit).not.toHaveBeenCalled();
-            expect(manager.getClient('session-1')).toBe(restartedHandle);
-        });
-        it('does not call onExit for stale SIGKILL exit after stop completes and session restarts', async () => {
-            const firstChild = setupSuccessfulSpawn();
-            const handlers = defaultHandlers();
-            await manager.getOrCreateClient('session-1', defaultOptions(), handlers, defaultContext());
-            firstChild.kill = vi.fn((signal) => {
-                if (signal) {
-                    firstChild.killed = true;
-                }
-                if (signal === 'SIGKILL') {
-                    firstChild.exitCode = 137;
-                }
-                return true;
-            });
-            vi.useFakeTimers();
-            const stopPromise = manager.stopClient('session-1');
-            await vi.advanceTimersByTimeAsync(5100);
-            await stopPromise;
-            vi.useRealTimers();
-            const secondChild = createMockChildProcess();
-            mockSpawn.mockReturnValueOnce(secondChild);
-            const newHandle = await manager.getOrCreateClient('session-1', defaultOptions(), handlers, defaultContext());
-            expect(newHandle.child).toBe(secondChild);
-            handlers.onExit.mockClear();
-            firstChild.emit('exit', 137, 'SIGKILL');
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            expect(handlers.onExit).not.toHaveBeenCalled();
-            expect(manager.getClient('session-1')).toBe(newHandle);
-        });
-        it('rejects client creation while a stop is in progress', async () => {
-            const firstChild = setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            firstChild.kill = vi.fn((signal) => {
-                if (signal) {
-                    firstChild.killed = true;
-                }
-                return true;
-            });
-            const stopPromise = manager.stopClient('session-1');
-            await vi.waitFor(() => {
-                expect(firstChild.kill).toHaveBeenCalledWith('SIGTERM');
-            });
-            const secondChild = createMockChildProcess();
-            exitChildAfterSigterm(secondChild);
-            mockSpawn.mockReturnValueOnce(secondChild);
-            await expect(manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('ACP session stop requested');
-            expect(secondChild.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(secondChild.kill).not.toHaveBeenCalledWith('SIGKILL');
-            firstChild.exitCode = 0;
-            firstChild.emit('exit', 0, null);
-            await stopPromise;
-            expect(manager.getClient('session-1')).toBeUndefined();
-        });
-        it('wires child error handlers before aborting creation during stop', async () => {
-            const firstChild = setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            firstChild.kill = vi.fn((signal) => {
-                if (signal) {
-                    firstChild.killed = true;
-                }
-                return true;
-            });
-            const stopPromise = manager.stopClient('session-1');
-            await vi.waitFor(() => {
-                expect(firstChild.kill).toHaveBeenCalledWith('SIGTERM');
-            });
-            const secondChild = createMockChildProcess();
-            secondChild.kill = vi.fn((signal) => {
-                if (signal === 'SIGTERM') {
-                    secondChild.emit('error', new Error('cleanup child error'));
-                    queueMicrotask(() => {
-                        secondChild.exitCode = 0;
-                        secondChild.emit('exit', 0, null);
-                    });
-                }
-                return true;
-            });
-            mockSpawn.mockReturnValueOnce(secondChild);
-            const handlers = defaultHandlers();
-            await expect(manager.getOrCreateClient('session-1', defaultOptions(), handlers, defaultContext())).rejects.toThrow('ACP session stop requested');
-            expect(secondChild.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(secondChild.kill).not.toHaveBeenCalledWith('SIGKILL');
-            await vi.waitFor(() => {
-                expect(handlers.onError).toHaveBeenCalledWith('session-1', expect.any(Error));
-            });
-            firstChild.exitCode = 0;
-            firstChild.emit('exit', 0, null);
-            await stopPromise;
-        });
-        it('clears creation lock bookkeeping when stop rejects a concurrent create', async () => {
-            const firstChild = setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            firstChild.kill = vi.fn((signal) => {
-                if (signal) {
-                    firstChild.killed = true;
-                }
-                return true;
-            });
-            const stopPromise = manager.stopClient('session-1');
-            await vi.waitFor(() => {
-                expect(firstChild.kill).toHaveBeenCalledWith('SIGTERM');
-            });
-            const secondChild = createMockChildProcess();
-            exitChildAfterSigterm(secondChild);
-            mockSpawn.mockReturnValueOnce(secondChild);
-            await expect(manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('ACP session stop requested');
-            const internalManager = manager;
-            expect(internalManager.creationLocks.has('session-1')).toBe(false);
-            expect(internalManager.lockRefCounts.has('session-1')).toBe(false);
-            firstChild.exitCode = 0;
-            firstChild.emit('exit', 0, null);
-            await stopPromise;
-        });
-    });
-    describe('stopAllClients', () => {
-        it('atomically closes admission and reports active and pending session ids', async () => {
-            const activeChild = setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-active', defaultOptions(), defaultHandlers(), defaultContext());
-            const pendingChild = createMockChildProcess();
-            exitChildAfterSigterm(pendingChild);
-            mockSpawn.mockReturnValueOnce(pendingChild);
-            mockInitialize.mockImplementationOnce(() => new Promise(() => {
-            }));
-            const pendingCreation = manager
-                .getOrCreateClient('session-pending', { ...defaultOptions(), sessionId: 'session-pending' }, defaultHandlers(), defaultContext())
-                .catch((error) => error);
-            await vi.waitFor(() => {
-                expect(manager.getPendingClient('session-pending')).toBeDefined();
-            });
-            const shutdownSessionIds = manager.beginShutdown();
-            expect(new Set(shutdownSessionIds)).toEqual(new Set(['session-active', 'session-pending']));
-            await expect(manager.getOrCreateClient('session-too-late', { ...defaultOptions(), sessionId: 'session-too-late' }, defaultHandlers(), defaultContext())).rejects.toThrow('ACP runtime manager is shutting down');
-            activeChild.kill = vi.fn(() => {
-                activeChild.exitCode = 0;
-                activeChild.emit('exit', 0, null);
-                return true;
-            });
-            await manager.stopAllClients(50);
-            await expect(pendingCreation).resolves.toMatchObject({
-                message: expect.stringContaining('ACP runtime manager is shutting down'),
-            });
-        });
-        it('clears per-client shutdown timeouts when clients stop quickly', async () => {
-            const firstChild = setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const secondChild = createMockChildProcess();
-            mockSpawn.mockReturnValueOnce(secondChild);
-            await manager.getOrCreateClient('session-2', { ...defaultOptions(), sessionId: 'session-2' }, defaultHandlers(), defaultContext());
-            firstChild.kill = vi.fn(() => {
-                firstChild.exitCode = 0;
-                firstChild.emit('exit', 0, null);
-                return true;
-            });
-            secondChild.kill = vi.fn(() => {
-                secondChild.exitCode = 0;
-                secondChild.emit('exit', 0, null);
-                return true;
-            });
-            vi.useFakeTimers();
-            try {
-                await manager.stopAllClients(10_000);
-                expect(firstChild.kill).toHaveBeenCalledWith('SIGTERM');
-                expect(secondChild.kill).toHaveBeenCalledWith('SIGTERM');
-                expect(vi.getTimerCount()).toBe(0);
-                expect([...manager.getAllClients()]).toEqual([]);
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
-        it('rejects new client creation after shutdown begins', async () => {
-            await manager.stopAllClients();
-            await expect(manager.getOrCreateClient('session-after-shutdown', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('ACP runtime manager is shutting down');
-            expect(mockSpawn).not.toHaveBeenCalled();
-        });
-        it('aborts in-flight client creation and cleans up the spawned subprocess', async () => {
-            const child = createMockChildProcess();
-            exitChildAfterSigterm(child);
-            mockSpawn.mockReturnValue(child);
-            mockInitialize.mockImplementation(() => new Promise(() => {
-            }));
-            const createPromise = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const createRejection = createPromise.catch((error) => error);
-            await vi.waitFor(() => {
-                expect(mockSpawn).toHaveBeenCalledTimes(1);
-            });
-            await manager.stopAllClients(50);
-            await expect(createRejection).resolves.toMatchObject({
-                message: expect.stringContaining('ACP runtime manager is shutting down'),
-            });
-            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
-            expect(manager.getClient('session-1')).toBeUndefined();
-            expect(manager.getPendingClient('session-1')).toBeUndefined();
-        });
-        it('rejects queued creation requests after an in-flight creation is aborted', async () => {
-            const child = createMockChildProcess();
-            exitChildAfterSigterm(child);
-            mockSpawn.mockReturnValue(child);
-            mockInitialize.mockImplementation(() => new Promise(() => {
-            }));
-            const firstCreate = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const firstRejection = firstCreate.catch((error) => error);
-            await vi.waitFor(() => {
-                expect(mockSpawn).toHaveBeenCalledTimes(1);
-            });
-            const secondCreate = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const secondRejection = secondCreate.catch((error) => error);
-            await manager.stopAllClients(50);
-            await expect(firstRejection).resolves.toMatchObject({
-                message: expect.stringContaining('ACP runtime manager is shutting down'),
-            });
-            await expect(secondRejection).resolves.toMatchObject({
-                message: expect.stringContaining('ACP runtime manager is shutting down'),
-            });
-            expect(mockSpawn).toHaveBeenCalledTimes(1);
-            expect(manager.getClient('session-1')).toBeUndefined();
-        });
-    });
-    describe('sendPrompt', () => {
-        it('sets isPromptInFlight, calls connection.prompt, clears flag on resolve', async () => {
-            setupSuccessfulSpawn();
-            mockPrompt.mockResolvedValue({ stopReason: 'end_turn' });
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            expect(handle.isPromptInFlight).toBe(false);
-            const result = await manager.sendPrompt('session-1', [{ type: 'text', text: 'Hello world' }]);
-            expect(mockPrompt).toHaveBeenCalledWith({
-                sessionId: 'provider-session-123',
-                prompt: [{ type: 'text', text: 'Hello world' }],
-            });
-            expect(result.stopReason).toBe('end_turn');
-            expect(handle.isPromptInFlight).toBe(false);
-        });
-        it('clears isPromptInFlight on error', async () => {
-            setupSuccessfulSpawn();
-            mockPrompt.mockRejectedValue(new Error('prompt failed'));
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await expect(manager.sendPrompt('session-1', [{ type: 'text', text: 'Hello' }])).rejects.toThrow('prompt failed');
-            expect(handle.isPromptInFlight).toBe(false);
-        });
-        it('keeps prompt marked in flight while cancelling after prompt timeout', async () => {
-            setupSuccessfulSpawn();
-            mockPrompt.mockReturnValue(new Promise(() => undefined));
-            mockCancel.mockResolvedValue(undefined);
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            vi.useFakeTimers();
-            try {
-                const promptPromise = manager.sendPrompt('session-1', [{ type: 'text', text: 'Hello' }], 100);
-                const promptRejection = promptPromise.catch((error) => error);
-                await vi.advanceTimersByTimeAsync(100);
-                await expect(promptRejection).resolves.toBeInstanceOf(PromptTimeoutError);
-                expect(mockCancel).toHaveBeenCalledWith({
-                    sessionId: 'provider-session-123',
-                });
-                expect(handle.isPromptInFlight).toBe(false);
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
-        it('stops the client when prompt timeout cancellation hangs', async () => {
-            const child = setupSuccessfulSpawn();
-            mockPrompt.mockReturnValue(new Promise(() => undefined));
-            mockCancel.mockReturnValue(new Promise(() => undefined));
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            child.kill = vi.fn((signal) => {
-                if (signal === 'SIGTERM') {
-                    child.killed = true;
-                    child.exitCode = 0;
-                    child.emit('exit', 0, null);
-                }
-                return true;
-            });
-            vi.useFakeTimers();
-            try {
-                const promptPromise = manager.sendPrompt('session-1', [{ type: 'text', text: 'Hello' }], 100);
-                const promptRejection = promptPromise.catch((error) => error);
-                await vi.advanceTimersByTimeAsync(100);
-                expect(mockCancel).toHaveBeenCalledTimes(1);
-                await vi.advanceTimersByTimeAsync(5000);
-                await expect(promptRejection).resolves.toBeInstanceOf(PromptTimeoutError);
-                expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-                expect(manager.getClient('session-1')).toBeUndefined();
-                expect(handle.isPromptInFlight).toBe(false);
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
-        it('does not clear or stop a replacement session when timeout cancel hangs', async () => {
-            setupSuccessfulSpawn();
-            mockPrompt.mockReturnValue(new Promise(() => undefined));
-            mockCancel.mockReturnValue(new Promise(() => undefined));
-            const firstHandle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            vi.useFakeTimers();
-            try {
-                const stalePrompt = manager.sendPrompt('session-1', [{ type: 'text', text: 'old prompt' }], 100);
-                const staleRejection = stalePrompt.catch((error) => error);
-                await vi.advanceTimersByTimeAsync(100);
-                expect(mockCancel).toHaveBeenCalledTimes(1);
-                const internalManager = manager;
-                internalManager.sessions.delete('session-1');
-                const replacementChild = setupSuccessfulSpawn();
-                const replacementHandle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-                replacementHandle.isPromptInFlight = true;
-                await vi.advanceTimersByTimeAsync(5000);
-                await expect(staleRejection).resolves.toBeInstanceOf(PromptTimeoutError);
-                expect(replacementHandle.isPromptInFlight).toBe(true);
-                expect(replacementChild.kill).not.toHaveBeenCalled();
-                expect(manager.getClient('session-1')).toBe(replacementHandle);
-                expect(firstHandle.isPromptInFlight).toBe(false);
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
-        it('does not cancel a replacement session when an old prompt timeout fires', async () => {
-            const firstChild = setupSuccessfulSpawn();
-            mockPrompt.mockReturnValueOnce(new Promise(() => undefined));
-            mockCancel.mockResolvedValue(undefined);
-            const firstHandle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            firstChild.kill = vi.fn((signal) => {
-                if (signal === 'SIGTERM') {
-                    firstChild.killed = true;
-                    firstChild.exitCode = 0;
-                    firstChild.emit('exit', 0, null);
-                }
-                return true;
-            });
-            vi.useFakeTimers();
-            try {
-                const stalePrompt = manager.sendPrompt('session-1', [{ type: 'text', text: 'old prompt' }], 100);
-                const staleRejection = stalePrompt.catch((error) => error);
-                await manager.stopClient('session-1');
-                expect(manager.getClient('session-1')).toBeUndefined();
-                const replacementPrompt = createDeferred();
-                setupSuccessfulSpawn();
-                mockPrompt.mockReturnValueOnce(replacementPrompt.promise);
-                const replacementHandle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-                const replacementSend = manager.sendPrompt('session-1', [
-                    { type: 'text', text: 'new prompt' },
-                ]);
-                await Promise.resolve();
-                expect(replacementHandle.isPromptInFlight).toBe(true);
-                const cancelCallsBeforeStaleTimeout = mockCancel.mock.calls.length;
-                await vi.advanceTimersByTimeAsync(100);
-                await expect(staleRejection).resolves.toBeInstanceOf(PromptTimeoutError);
-                expect(mockCancel).toHaveBeenCalledTimes(cancelCallsBeforeStaleTimeout);
-                expect(replacementHandle.isPromptInFlight).toBe(true);
-                expect(firstHandle.isPromptInFlight).toBe(false);
-                replacementPrompt.resolve({ stopReason: 'end_turn' });
-                await expect(replacementSend).resolves.toEqual({ stopReason: 'end_turn' });
-                expect(replacementHandle.isPromptInFlight).toBe(false);
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
-        it('throws if no session found', async () => {
-            await expect(manager.sendPrompt('nonexistent', [{ type: 'text', text: 'Hello' }])).rejects.toThrow('No ACP session found');
-        });
-    });
-    describe('cancelPrompt', () => {
-        it('calls connection.cancel when prompt is in flight', async () => {
-            setupSuccessfulSpawn();
-            mockCancel.mockResolvedValue(undefined);
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            handle.isPromptInFlight = true;
-            const cancelled = await manager.cancelPrompt('session-1');
-            expect(mockCancel).toHaveBeenCalledWith({
-                sessionId: 'provider-session-123',
-            });
-            expect(cancelled).toBe(true);
-        });
-        it('does nothing when no prompt is in flight', async () => {
-            setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            const cancelled = await manager.cancelPrompt('session-1');
-            expect(mockCancel).not.toHaveBeenCalled();
-            expect(cancelled).toBe(false);
-        });
-        it('does nothing for nonexistent session', async () => {
-            const cancelled = await manager.cancelPrompt('nonexistent');
-            expect(mockCancel).not.toHaveBeenCalled();
-            expect(cancelled).toBe(false);
-        });
-    });
-    describe('setConfigOption', () => {
-        it('updates cached config options from setSessionConfigOption response', async () => {
-            setupSuccessfulSpawn();
-            mockSetSessionConfigOption.mockResolvedValueOnce({
-                configOptions: [
-                    {
-                        id: 'model',
-                        name: 'Model',
-                        type: 'select',
-                        category: 'model',
-                        currentValue: 'opus',
-                        options: [
-                            { value: 'default', name: 'Default (recommended)', description: 'Opus 4.6 · best' },
-                            { value: 'opus', name: 'Opus' },
-                        ],
-                    },
-                    {
-                        id: 'mode',
-                        name: 'Mode',
-                        type: 'select',
-                        category: 'mode',
-                        currentValue: 'plan',
-                        options: [
-                            { value: 'default', name: 'Default' },
-                            { value: 'plan', name: 'Plan' },
-                        ],
-                    },
-                ],
-            });
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await manager.setConfigOption('session-1', 'mode', 'plan');
-            const defaultModelOption = handle.configOptions
-                .find((option) => option.id === 'model')
-                ?.options.find((option) => 'value' in option && option.value === 'default');
-            expect(defaultModelOption).toMatchObject({
-                value: 'default',
-                name: 'Default — Opus 4.6',
-            });
-            expect(handle.configOptions.find((option) => option.id === 'mode')?.currentValue).toBe('plan');
-        });
-        it('throws when setSessionConfigOption call fails', async () => {
-            setupSuccessfulSpawn();
-            mockSetSessionConfigOption.mockRejectedValueOnce(new Error('Method not found'));
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await expect(manager.setConfigOption('session-1', 'model', 'opus')).rejects.toThrow('Method not found');
-        });
-        it('fails fast when setSessionConfigOption response omits required categories', async () => {
-            setupSuccessfulSpawn();
-            mockSetSessionConfigOption.mockResolvedValueOnce({
-                configOptions: [
-                    {
-                        id: 'reasoning_effort',
-                        name: 'Reasoning Effort',
-                        type: 'select',
-                        category: 'thought_level',
-                        currentValue: 'medium',
-                        options: [{ value: 'medium', name: 'Medium' }],
-                    },
-                ],
-            });
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await expect(manager.setConfigOption('session-1', 'mode', 'plan')).rejects.toThrow('missing required config option categories: model, mode');
-        });
-    });
-    describe('setSessionMode', () => {
-        it('calls ACP setSessionMode and updates cached mode currentValue', async () => {
-            setupSuccessfulSpawn();
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await manager.setSessionMode('session-1', 'plan');
-            expect(mockSetSessionMode).toHaveBeenCalledWith({
-                sessionId: 'provider-session-123',
-                modeId: 'plan',
-            });
-            expect(handle.configOptions.find((option) => option.id === 'mode')?.currentValue).toBe('plan');
-        });
-        it('throws when setSessionMode call fails', async () => {
-            setupSuccessfulSpawn();
-            mockSetSessionMode.mockRejectedValueOnce(new Error('Invalid mode'));
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await expect(manager.setSessionMode('session-1', 'acceptEdits')).rejects.toThrow('Invalid mode');
-        });
-    });
-    describe('setSessionModel', () => {
-        it('uses unstable_setSessionModel for CLAUDE and updates cached model currentValue', async () => {
-            setupSuccessfulSpawn();
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await manager.setSessionModel('session-1', 'opus');
-            expect(mockSetSessionModel).toHaveBeenCalledWith({
-                sessionId: 'provider-session-123',
-                modelId: 'opus',
-            });
-            expect(mockSetSessionConfigOption).not.toHaveBeenCalled();
-            expect(handle.configOptions.find((option) => option.id === 'model')?.currentValue).toBe('opus');
-        });
-        it('falls back to setSessionConfigOption when unstable_setSessionModel is unavailable', async () => {
-            setupSuccessfulSpawn();
-            mockSetSessionModel.mockRejectedValueOnce({ code: -32_601, message: 'Method not found' });
-            mockSetSessionConfigOption.mockResolvedValueOnce({
-                configOptions: [
-                    {
-                        id: 'model',
-                        name: 'Model',
-                        type: 'select',
-                        category: 'model',
-                        currentValue: 'opus',
-                        options: [
-                            { value: 'sonnet', name: 'Sonnet' },
-                            { value: 'opus', name: 'Opus' },
-                        ],
-                    },
-                    {
-                        id: 'mode',
-                        name: 'Mode',
-                        type: 'select',
-                        category: 'mode',
-                        currentValue: 'default',
-                        options: [{ value: 'default', name: 'Default' }],
-                    },
-                ],
-            });
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            await manager.setSessionModel('session-1', 'opus');
-            expect(mockSetSessionModel).toHaveBeenCalledWith({
-                sessionId: 'provider-session-123',
-                modelId: 'opus',
-            });
-            expect(mockSetSessionConfigOption).toHaveBeenCalledWith({
-                sessionId: 'provider-session-123',
-                configId: 'model',
-                value: 'opus',
-            });
-            expect(handle.configOptions.find((option) => option.id === 'model')?.currentValue).toBe('opus');
-        });
-        it('uses setSessionConfigOption path for CODEX model updates', async () => {
-            setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', { ...defaultOptions(), provider: 'CODEX' }, defaultHandlers(), defaultContext());
-            await manager.setSessionModel('session-1', 'gpt-5.2-codex');
-            expect(mockSetSessionModel).not.toHaveBeenCalled();
-            expect(mockSetSessionConfigOption).toHaveBeenCalledWith({
-                sessionId: 'provider-session-123',
-                configId: 'model',
-                value: 'gpt-5.2-codex',
-            });
-        });
-    });
-    describe('session status methods', () => {
-        it('isSessionRunning returns true for active session', async () => {
-            setupSuccessfulSpawn();
-            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            expect(manager.isSessionRunning('session-1')).toBe(true);
-            expect(manager.isSessionRunning('nonexistent')).toBe(false);
-        });
-        it('isSessionWorking returns true when prompt is in flight', async () => {
-            setupSuccessfulSpawn();
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            expect(manager.isSessionWorking('session-1')).toBe(false);
-            handle.isPromptInFlight = true;
-            expect(manager.isSessionWorking('session-1')).toBe(true);
-        });
-        it('isAnySessionWorking checks multiple sessions', async () => {
-            setupSuccessfulSpawn();
-            const handle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            expect(manager.isAnySessionWorking(['session-1', 'session-2'])).toBe(false);
-            handle.isPromptInFlight = true;
-            expect(manager.isAnySessionWorking(['session-1', 'session-2'])).toBe(true);
-        });
-    });
-});
-describe('AcpClientHandler', () => {
-    it('AcpEventCallback is a discriminated ACP runtime event union', () => {
-        const onEvent = (_sessionId, event) => {
-            if (event.type === 'acp_session_update') {
-                expect(event.update.sessionUpdate).toBe('agent_message_chunk');
-                return;
-            }
-            if (event.type === 'acp_permission_request') {
-                expect(event.params.toolCall.toolCallId).toBe('tc-1');
-                return;
-            }
-            expect(event.subagentId).toBe('child-1');
-            expect(event.change).toBe('updated');
-        };
-        onEvent('test-session', {
-            type: 'acp_session_update',
-            update: {
-                sessionUpdate: 'agent_message_chunk',
-                content: { type: 'text', text: 'Hello' },
-            },
-        });
-        onEvent('test-session', {
-            type: 'acp_permission_request',
-            requestId: 'req-1',
-            params: {
-                sessionId: 'provider-session-1',
-                toolCall: { toolCallId: 'tc-1', title: 'Write file' },
-                options: [{ optionId: 'allow-1', kind: 'allow_once', name: 'Allow once' }],
-            },
-        });
-        onEvent('test-session', {
-            type: 'acp_subagents_changed',
-            subagentId: 'child-1',
-            change: 'updated',
-        });
-    });
-    it('sessionUpdate emits logs through onLog callback', async () => {
-        const onEvent = vi.fn();
-        const onLog = vi.fn();
-        const handler = new AcpClientHandler('test-session', onEvent, undefined, onLog);
-        await handler.sessionUpdate({
-            sessionId: 'provider-session-1',
-            update: {
-                sessionUpdate: 'agent_message_chunk',
-                content: { type: 'text', text: 'Hello' },
-            },
-        });
-        expect(onLog).toHaveBeenCalledWith('test-session', {
-            eventType: 'acp_session_update',
-            sessionUpdate: 'agent_message_chunk',
-            data: expect.objectContaining({ sessionUpdate: 'agent_message_chunk' }),
-        });
-    });
-    it('sessionUpdate forwards all events as acp_session_update wrapper', async () => {
-        const onEvent = vi.fn();
-        const handler = new AcpClientHandler('test-session', onEvent);
-        await handler.sessionUpdate({
-            sessionId: 'provider-session-1',
-            update: {
-                sessionUpdate: 'agent_message_chunk',
-                content: { type: 'text', text: 'Hello' },
-            },
-        });
-        expect(onEvent).toHaveBeenCalledWith('test-session', {
-            type: 'acp_session_update',
-            update: {
-                sessionUpdate: 'agent_message_chunk',
-                content: { type: 'text', text: 'Hello' },
-            },
-        });
-    });
-    it('sessionUpdate forwards tool_call events as acp_session_update wrapper', async () => {
-        const onEvent = vi.fn();
-        const handler = new AcpClientHandler('test-session', onEvent);
-        await handler.sessionUpdate({
-            sessionId: 'provider-session-1',
-            update: {
-                sessionUpdate: 'tool_call',
-                toolCallId: 'tc-1',
-                title: 'Read file',
-                kind: 'read',
-                status: 'in_progress',
-            },
-        });
-        expect(onEvent).toHaveBeenCalledWith('test-session', {
-            type: 'acp_session_update',
-            update: {
-                sessionUpdate: 'tool_call',
-                toolCallId: 'tc-1',
-                title: 'Read file',
-                kind: 'read',
-                status: 'in_progress',
-            },
-        });
-    });
-    it('sessionUpdate forwards all event types including previously deferred ones', async () => {
-        const onEvent = vi.fn();
-        const handler = new AcpClientHandler('test-session', onEvent);
-        await handler.sessionUpdate({
-            sessionId: 'provider-session-1',
-            update: {
-                sessionUpdate: 'agent_thought_chunk',
-                content: { type: 'text', text: 'thinking...' },
-            },
-        });
-        expect(onEvent).toHaveBeenCalledWith('test-session', {
-            type: 'acp_session_update',
-            update: {
-                sessionUpdate: 'agent_thought_chunk',
-                content: { type: 'text', text: 'thinking...' },
-            },
-        });
-    });
-    it('requestPermission fails closed by default when no bridge exists', async () => {
-        const onEvent = vi.fn();
-        const handler = new AcpClientHandler('test-session', onEvent);
-        const result = await handler.requestPermission({
-            sessionId: 'provider-session-1',
-            toolCall: { toolCallId: 'tc-1', title: 'Write file' },
-            options: [
-                { optionId: 'reject-1', kind: 'reject_once', name: 'Deny' },
-                { optionId: 'allow-1', kind: 'allow_always', name: 'Allow Always' },
-                { optionId: 'allow-2', kind: 'allow_once', name: 'Allow Once' },
-            ],
-        });
-        expect(result).toEqual({
-            outcome: {
-                outcome: 'selected',
-                optionId: 'reject-1',
-            },
-        });
-    });
-    it('requestPermission selects a reject option when no bridge exists', async () => {
-        const onEvent = vi.fn();
-        const handler = new AcpClientHandler('test-session', onEvent);
-        const result = await handler.requestPermission({
-            sessionId: 'provider-session-1',
-            toolCall: { toolCallId: 'tc-1', title: 'Write file' },
-            options: [
-                { optionId: 'reject-1', kind: 'reject_once', name: 'Deny' },
-                { optionId: 'reject-2', kind: 'reject_always', name: 'Deny Always' },
-            ],
-        });
-        expect(result).toEqual({
-            outcome: {
-                outcome: 'selected',
-                optionId: 'reject-1',
-            },
-        });
-    });
-});
-//# sourceMappingURL=acp-runtime-manager.test.js.map