factory-factory 0.4.5 → 0.4.7

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

@@ -1,860 +1,118 @@
-import { spawn } from 'node:child_process';
-import { Readable, Writable } from 'node:stream';
-import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
-import pLimit from 'p-limit';
-import { createLogger, getCurrentProcessEnv } from '../../../../../backend/services/logger.service.js';
-import { AcpClientHandler } from './acp-client-handler.js';
-import { AcpProcessHandle } from './acp-process-handle.js';
-import { createAcpSpawnError, hasUsableWorkingDir, resolveAcpBinary, resolveInternalCodexAcpSpawnCommand, withTimeout, } from './acp-runtime-spawn.js';
-import { requireSessionConfigOptions } from './acp-session-config-options.js';
-import { createNormalizedAcpReadableStream, normalizeUnknownError } from './acp-stream-normalizer.js';
-const logger = createLogger('acp-runtime-manager');
-export class PromptTimeoutError extends Error {
-    timeoutMs;
-    constructor(sessionId, timeoutMs) {
-        super(`ACP prompt timed out after ${timeoutMs}ms for session ${sessionId}`);
-        this.timeoutMs = timeoutMs;
-        this.name = 'PromptTimeoutError';
-    }
-}
-function resolveAutoApprovePolicy(preset) {
-    if (preset === 'YOLO' || preset === 'RELAXED') {
-        return 'all';
-    }
-    return 'none';
-}
-const DEFAULT_ACP_STARTUP_TIMEOUT_MS = 30_000;
-function getAcpErrorLogDetails(error) {
-    if (error instanceof Error) {
-        return { message: error.message };
-    }
-    if (typeof error === 'object' && error !== null) {
-        const maybe = error;
-        const message = typeof maybe.message === 'string'
-            ? maybe.message
-            : (() => {
-                try {
-                    return JSON.stringify(error);
-                }
-                catch {
-                    return String(error);
-                }
-            })();
-        const code = typeof maybe.code === 'number' || typeof maybe.code === 'string' ? maybe.code : undefined;
-        return {
-            message,
-            ...(code !== undefined ? { code } : {}),
-            ...(typeof maybe.data !== 'undefined' ? { data: maybe.data } : {}),
-        };
-    }
-    return { message: String(error) };
-}
-function isMethodNotFoundError(error) {
-    const details = getAcpErrorLogDetails(error);
-    return details.code === -32_601 || details.message.includes('Method not found');
-}
-async function raceWithSoftTimeout(promise, timeoutMs) {
-    let timeout;
-    const timeoutPromise = new Promise((resolve) => {
-        timeout = setTimeout(() => resolve(undefined), timeoutMs);
-        timeout.unref?.();
-    });
-    try {
-        return await Promise.race([promise, timeoutPromise]);
-    }
-    finally {
-        if (timeout !== undefined) {
-            clearTimeout(timeout);
-        }
-    }
-}
+import { AcpClientFactory } from './acp-client-factory.js';
+import { AcpPromptController } from './acp-prompt-controller.js';
+import { AcpRuntimeConfigController } from './acp-runtime-config-controller.js';
+import { AcpRuntimeSupervisor } from './acp-runtime-supervisor.js';
+import { AcpSubagentBrowser } from './acp-subagent-browser.js';
+export { AcpBrowseSessionUnavailableError, PromptTimeoutError } from './acp-runtime-errors.js';
 export class AcpRuntimeManager {
-    sessions = new Map();
-    pendingCreation = new Map();
-    stoppingInProgress = new Set();
-    managedStopChildren = new WeakSet();
-    creationLocks = new Map();
-    lockRefCounts = new Map();
-    shutdownWaiters = new Set();
-    sessionStopWaiters = new Map();
-    isShuttingDown = false;
-    onClientCreatedCallback = null;
-    acpStartupTimeoutMs = DEFAULT_ACP_STARTUP_TIMEOUT_MS;
-    preferSourceEntrypoint = true;
-    childProcessEnvProvider = getCurrentProcessEnv;
+    clientFactory;
+    promptController;
+    configController = new AcpRuntimeConfigController();
+    subagentBrowser = new AcpSubagentBrowser();
+    supervisor;
     constructor(options) {
-        this.setAcpStartupTimeoutMs(options?.acpStartupTimeoutMs ?? DEFAULT_ACP_STARTUP_TIMEOUT_MS);
+        this.clientFactory = new AcpClientFactory(options);
+        let supervisor;
+        this.promptController = new AcpPromptController({
+            isCurrentHandle: (sessionId, handle) => supervisor.isCurrentHandle(sessionId, handle),
+            stopClient: (sessionId) => supervisor.stopClient(sessionId),
+        });
+        supervisor = new AcpRuntimeSupervisor({
+            clientFactory: this.clientFactory,
+            cancelPrompt: (sessionId, handle) => this.promptController.cancelPrompt(sessionId, handle),
+        });
+        this.supervisor = supervisor;
     }
     setAcpStartupTimeoutMs(timeoutMs) {
-        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-            this.acpStartupTimeoutMs = DEFAULT_ACP_STARTUP_TIMEOUT_MS;
-            return;
-        }
-        this.acpStartupTimeoutMs = Math.floor(timeoutMs);
+        this.clientFactory.setAcpStartupTimeoutMs(timeoutMs);
     }
     configureEnvironment(options) {
-        this.preferSourceEntrypoint = options.preferSourceEntrypoint;
-        this.childProcessEnvProvider = options.childProcessEnvProvider;
+        this.clientFactory.configureEnvironment(options);
     }
     setOnClientCreated(callback) {
-        this.onClientCreatedCallback = callback;
+        this.supervisor.setOnClientCreated(callback);
     }
     isStopInProgress(sessionId) {
-        return this.stoppingInProgress.has(sessionId);
+        return this.supervisor.isStopInProgress(sessionId);
     }
     getClient(sessionId) {
-        const handle = this.sessions.get(sessionId);
-        return handle?.isRunning() ? handle : undefined;
-    }
-    getPendingClient(sessionId) {
-        return this.pendingCreation.get(sessionId);
-    }
-    getOrCreateClient(sessionId, options, handlers, context) {
-        if (this.isShuttingDown) {
-            return Promise.reject(this.createShutdownError(sessionId));
-        }
-        let lock = this.creationLocks.get(sessionId);
-        if (!lock) {
-            lock = pLimit(1);
-            this.creationLocks.set(sessionId, lock);
-            this.lockRefCounts.set(sessionId, 0);
-        }
-        const currentCount = this.lockRefCounts.get(sessionId) ?? 0;
-        this.lockRefCounts.set(sessionId, currentCount + 1);
-        return lock(async () => {
-            try {
-                if (this.isShuttingDown) {
-                    throw this.createShutdownError(sessionId);
-                }
-                const existing = this.sessions.get(sessionId);
-                if (existing?.isRunning()) {
-                    logger.debug('Returning existing running ACP client', { sessionId });
-                    return existing;
-                }
-                const pending = this.pendingCreation.get(sessionId);
-                if (pending) {
-                    logger.debug('Waiting for pending ACP client creation', { sessionId });
-                    return await pending;
-                }
-                logger.info('Creating new ACP client', { sessionId, provider: options.provider });
-                const createPromise = this.createClient(sessionId, options, handlers, context);
-                this.pendingCreation.set(sessionId, createPromise);
-                try {
-                    return await createPromise;
-                }
-                finally {
-                    this.pendingCreation.delete(sessionId);
-                }
-            }
-            finally {
-                const refCount = this.lockRefCounts.get(sessionId) ?? 1;
-                const newCount = refCount - 1;
-                if (newCount <= 0) {
-                    this.creationLocks.delete(sessionId);
-                    this.lockRefCounts.delete(sessionId);
-                }
-                else {
-                    this.lockRefCounts.set(sessionId, newCount);
-                }
-            }
-        });
-    }
-    async createClient(sessionId, options, handlers, context) {
-        if (this.isShuttingDown) {
-            throw this.createShutdownError(sessionId);
-        }
-        if (!hasUsableWorkingDir(options.workingDir)) {
-            throw new Error('ACP working directory is required before spawning adapter process');
-        }
-        const isCodex = options.provider === 'CODEX';
-        const spawnCommand = options.adapterBinaryPath
-            ? {
-                command: options.adapterBinaryPath,
-                args: [],
-                commandLabel: options.adapterBinaryPath,
-            }
-            : isCodex
-                ? resolveInternalCodexAcpSpawnCommand(this.preferSourceEntrypoint)
-                : (() => {
-                    const binaryName = 'claude-agent-acp';
-                    const packageName = '@agentclientprotocol/claude-agent-acp';
-                    const binaryPath = resolveAcpBinary(packageName, binaryName);
-                    return {
-                        command: binaryPath,
-                        args: [],
-                        commandLabel: binaryPath,
-                    };
-                })();
-        logger.info('Spawning ACP subprocess', {
-            sessionId,
-            command: spawnCommand.command,
-            args: spawnCommand.args,
-            provider: options.provider,
-            workingDir: options.workingDir,
-        });
-        const spawnEnv = {
-            ...this.childProcessEnvProvider(),
-            BROWSER: 'none',
-            ...(isCodex ? { DOTENV_CONFIG_QUIET: 'true' } : {}),
-        };
-        const child = spawn(spawnCommand.command, spawnCommand.args, {
-            cwd: options.workingDir,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            env: spawnEnv,
-            detached: false,
-        });
-        let startupErrorListener = null;
-        const startupError = new Promise((_, reject) => {
-            startupErrorListener = (error) => reject(createAcpSpawnError(spawnCommand.commandLabel, error));
-            child.once('error', startupErrorListener);
-        });
-        const startupErrorSettled = startupError.catch(() => undefined);
-        this.wireChildErrorHandler(child, sessionId, handlers);
-        await this.abortClientCreationIfStopping(child, sessionId);
-        child.stderr?.on('data', (chunk) => {
-            handlers.onAcpLog?.(options.sessionId, {
-                eventType: 'acp_stderr',
-                data: chunk.toString(),
-            });
-        });
-        if (!(child.stdout && child.stdin)) {
-            throw new Error('ACP subprocess stdio streams not available');
-        }
-        const input = Readable.toWeb(child.stdout);
-        const output = Writable.toWeb(child.stdin);
-        const stream = ndJsonStream(output, input);
-        const normalizedStream = {
-            writable: stream.writable,
-            readable: createNormalizedAcpReadableStream(stream.readable),
-        };
-        const acpEventHandler = handlers.onAcpEvent;
-        const onEvent = acpEventHandler
-            ? (sid, event) => acpEventHandler(sid, event)
-            : (_sid, _event) => {
-                logger.debug('ACP event received but no handler registered', { sessionId });
-            };
-        const autoApprovePolicy = resolveAutoApprovePolicy(options.permissionPreset);
-        const connection = new ClientSideConnection((_agent) => new AcpClientHandler(sessionId, onEvent, handlers.permissionBridge, handlers.onAcpLog, autoApprovePolicy), normalizedStream);
-        let initResult;
-        let sessionInfo;
-        const startupTimeoutMs = this.acpStartupTimeoutMs;
-        const shutdownSignal = this.createShutdownSignal(sessionId);
-        const stopSignal = this.createSessionStopSignal(sessionId);
-        const startupCancelOn = Promise.race([
-            startupErrorSettled,
-            shutdownSignal.promise.catch(() => undefined),
-            stopSignal.promise.catch(() => undefined),
-        ]);
-        try {
-            initResult = await Promise.race([
-                withTimeout({
-                    promise: connection.initialize({
-                        protocolVersion: PROTOCOL_VERSION,
-                        clientCapabilities: {},
-                        clientInfo: {
-                            name: 'factory-factory',
-                            title: 'Factory Factory',
-                            version: '1.2.0',
-                        },
-                    }),
-                    timeoutMs: startupTimeoutMs,
-                    description: 'initialize handshake',
-                    cancelOn: startupCancelOn,
-                }),
-                startupError,
-                shutdownSignal.promise,
-                stopSignal.promise,
-            ]);
-            logger.info('ACP connection initialized', {
-                sessionId,
-                agentCapabilities: initResult.agentCapabilities,
-            });
-            const agentCapabilities = initResult.agentCapabilities ?? {};
-            sessionInfo = await Promise.race([
-                withTimeout({
-                    promise: this.createOrResumeSession(connection, sessionId, options, agentCapabilities),
-                    timeoutMs: startupTimeoutMs,
-                    description: 'session creation',
-                    cancelOn: startupCancelOn,
-                }),
-                startupError,
-                shutdownSignal.promise,
-                stopSignal.promise,
-            ]);
-        }
-        catch (error) {
-            await this.cleanupFailedClientCreation(child, sessionId);
-            throw error;
-        }
-        finally {
-            shutdownSignal.dispose();
-            stopSignal.dispose();
-            if (startupErrorListener) {
-                child.removeListener('error', startupErrorListener);
-                startupErrorListener = null;
-            }
-        }
-        if (this.isShuttingDown) {
-            await this.cleanupFailedClientCreation(child, sessionId);
-            throw this.createShutdownError(sessionId);
-        }
-        await this.abortClientCreationIfStopping(child, sessionId);
-        const agentCapabilities = initResult.agentCapabilities ?? {};
-        const handle = new AcpProcessHandle({
-            connection,
-            child,
-            provider: options.provider,
-            providerSessionId: sessionInfo.providerSessionId,
-            agentCapabilities,
-        });
-        handle.configOptions = sessionInfo.configOptions;
-        this.sessions.set(sessionId, handle);
-        this.wireChildExitHandler(sessionId, child, handlers);
-        await this.notifyClientCreated(sessionId, handle, context, handlers);
-        return handle;
+        return this.supervisor.getClient(sessionId);
     }
-    async cleanupFailedClientCreation(child, sessionId) {
-        const hasExited = () => child.exitCode !== null || child.signalCode !== null;
-        if (hasExited()) {
-            return;
-        }
-        try {
-            let terminationObserved = false;
-            const exitPromise = new Promise((resolve) => {
-                const resolveOnTermination = () => {
-                    terminationObserved = true;
-                    child.removeListener('exit', resolveOnTermination);
-                    child.removeListener('close', resolveOnTermination);
-                    resolve();
-                };
-                child.once('exit', resolveOnTermination);
-                child.once('close', resolveOnTermination);
-                if (hasExited()) {
-                    resolveOnTermination();
-                }
-            });
-            child.kill('SIGTERM');
-            await raceWithSoftTimeout(exitPromise, 5000);
-            if (!(terminationObserved || hasExited())) {
-                child.kill('SIGKILL');
-            }
-        }
-        catch {
-        }
-        logger.warn('Cleaned up ACP subprocess after initialization failure', {
-            sessionId,
-            pid: child.pid,
-        });
+    getBrowseClient(sessionId) {
+        return this.supervisor.getBrowseClient(sessionId);
     }
-    async abortClientCreationIfStopping(child, sessionId) {
-        if (!this.stoppingInProgress.has(sessionId)) {
-            return;
-        }
-        await this.cleanupFailedClientCreation(child, sessionId);
-        throw this.createStopRequestedError(sessionId);
+    isBrowseOnlySession(sessionId) {
+        return this.supervisor.isBrowseOnlySession(sessionId);
     }
-    createShutdownError(sessionId) {
-        return new Error(`ACP runtime manager is shutting down; cannot create client ${sessionId}`);
+    hasClientCreationOperation(sessionId) {
+        return this.supervisor.hasClientCreationOperation(sessionId);
     }
-    createStopRequestedError(sessionId) {
-        return new Error(`ACP session stop requested; cannot create client ${sessionId}`);
+    getPendingClient(sessionId) {
+        return this.supervisor.getPendingClient(sessionId);
     }
-    beginShutdown() {
-        const sessionIds = new Set([
-            ...this.sessions.keys(),
-            ...this.pendingCreation.keys(),
-            ...this.creationLocks.keys(),
-        ]);
-        if (!this.isShuttingDown) {
-            this.isShuttingDown = true;
-            for (const rejectShutdown of this.shutdownWaiters) {
-                rejectShutdown();
-            }
-            this.shutdownWaiters.clear();
-        }
-        return [...sessionIds];
+    runClientCreationOperation(sessionId, purpose, operation) {
+        return this.supervisor.runClientCreationOperation(sessionId, purpose, operation);
     }
-    beginSessionStop(sessionId) {
-        this.stoppingInProgress.add(sessionId);
-        const stopWaiters = this.sessionStopWaiters.get(sessionId);
-        if (!stopWaiters) {
-            return;
-        }
-        for (const rejectStop of stopWaiters) {
-            rejectStop();
-        }
-        this.sessionStopWaiters.delete(sessionId);
-    }
-    createShutdownSignal(sessionId) {
-        let rejectShutdown;
-        const promise = new Promise((_resolve, reject) => {
-            rejectShutdown = () => reject(this.createShutdownError(sessionId));
-        });
-        if (this.isShuttingDown) {
-            rejectShutdown();
-        }
-        else {
-            this.shutdownWaiters.add(rejectShutdown);
-        }
-        return {
-            promise,
-            dispose: () => {
-                this.shutdownWaiters.delete(rejectShutdown);
-            },
-        };
-    }
-    createSessionStopSignal(sessionId) {
-        let rejectStop;
-        const promise = new Promise((_resolve, reject) => {
-            rejectStop = () => reject(this.createStopRequestedError(sessionId));
-        });
-        if (this.stoppingInProgress.has(sessionId)) {
-            rejectStop();
-        }
-        else {
-            const waiters = this.sessionStopWaiters.get(sessionId) ?? new Set();
-            waiters.add(rejectStop);
-            this.sessionStopWaiters.set(sessionId, waiters);
-        }
-        return {
-            promise,
-            dispose: () => {
-                const waiters = this.sessionStopWaiters.get(sessionId);
-                if (!waiters) {
-                    return;
-                }
-                waiters.delete(rejectStop);
-                if (waiters.size === 0) {
-                    this.sessionStopWaiters.delete(sessionId);
-                }
-            },
-        };
+    stopAndQuiesce(sessionId) {
+        return this.supervisor.stopAndQuiesce(sessionId);
     }
-    wireChildExitHandler(sessionId, child, handlers) {
-        child.on('exit', async (code) => {
-            if (this.shouldSkipChildExitHandler(sessionId, child, code)) {
-                return;
-            }
-            this.pendingCreation.delete(sessionId);
-            if (handlers.onExit) {
-                try {
-                    await handlers.onExit(sessionId, code);
-                }
-                catch (error) {
-                    logger.warn('Failed to handle ACP exit event', {
-                        sessionId,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
-        });
+    getSubagentBrowseCapability(sessionId) {
+        return this.subagentBrowser.getCapability(this.supervisor.getBrowseClient(sessionId));
     }
-    shouldSkipChildExitHandler(sessionId, child, code) {
-        const current = this.sessions.get(sessionId);
-        const isCurrentProcess = current?.child === child;
-        const isManagedStopProcess = this.managedStopChildren.delete(child);
-        if (isCurrentProcess) {
-            this.sessions.delete(sessionId);
-        }
-        if (current && !isCurrentProcess) {
-            logger.debug('Skipping exit handler - stale ACP process exited', {
-                sessionId,
-                code,
-                pid: child.pid,
-                currentPid: current.getPid(),
-            });
-            return true;
-        }
-        if (isManagedStopProcess || this.stoppingInProgress.has(sessionId)) {
-            logger.debug('Skipping exit handler - managed stop process exited', { sessionId, code });
-            return true;
-        }
-        return false;
+    listSubagents(sessionId, input) {
+        return this.subagentBrowser.listSubagents(this.supervisor.getBrowseClient(sessionId), input);
     }
-    async notifyClientCreated(sessionId, handle, context, handlers) {
-        if (this.onClientCreatedCallback) {
-            this.onClientCreatedCallback(sessionId, handle, context);
-        }
-        if (handlers.onSessionId) {
-            try {
-                await handlers.onSessionId(sessionId, handle.providerSessionId);
-            }
-            catch (error) {
-                logger.warn('Failed to handle ACP session ID event', {
-                    sessionId,
-                    providerSessionId: handle.providerSessionId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
+    readSubagentTranscript(sessionId, input) {
+        return this.subagentBrowser.readSubagentTranscript(this.supervisor.getBrowseClient(sessionId), input);
     }
-    wireChildErrorHandler(child, sessionId, handlers) {
-        child.on('error', async (error) => {
-            const normalizedError = normalizeUnknownError(error);
-            if (handlers.onError) {
-                try {
-                    await handlers.onError(sessionId, normalizedError);
-                }
-                catch (handlerError) {
-                    logger.warn('Failed to handle ACP error event', {
-                        sessionId,
-                        originalError: normalizedError.message,
-                        handlerError: handlerError instanceof Error ? handlerError.message : String(handlerError),
-                    });
-                }
-            }
-            else {
-                logger.warn('ACP child process error (no handler provided)', {
-                    sessionId,
-                    error: normalizedError.message,
-                });
-            }
-        });
+    getOrCreateClient(sessionId, options, handlers, context) {
+        return this.supervisor.getOrCreateClient(sessionId, options, handlers, context);
     }
-    async createOrResumeSession(connection, sessionId, options, agentCapabilities) {
-        const storedId = options.resumeProviderSessionId;
-        const canResume = agentCapabilities.loadSession === true && !!storedId;
-        const mcpServers = (options.mcpServers ?? []).map((s) => ({
-            name: s.name,
-            command: s.command,
-            args: s.args,
-            env: Object.entries(s.env).map(([name, value]) => ({ name, value })),
-        }));
-        if (canResume && storedId) {
-            let loadResult = null;
-            try {
-                loadResult = await connection.loadSession({
-                    sessionId: storedId,
-                    cwd: options.workingDir,
-                    mcpServers,
-                });
-            }
-            catch (error) {
-                const details = getAcpErrorLogDetails(error);
-                logger.warn('loadSession failed, falling back to newSession', {
-                    sessionId,
-                    storedProviderSessionId: storedId,
-                    error: details.message,
-                    ...(details.code !== undefined ? { errorCode: details.code } : {}),
-                    ...(typeof details.data !== 'undefined' ? { errorData: details.data } : {}),
-                });
-            }
-            if (loadResult !== null) {
-                logger.info('ACP session resumed via loadSession', {
-                    sessionId,
-                    providerSessionId: storedId,
-                });
-                return {
-                    providerSessionId: storedId,
-                    configOptions: requireSessionConfigOptions(options.provider, 'loadSession', loadResult),
-                };
-            }
-        }
-        const sessionResult = await connection.newSession({
-            cwd: options.workingDir,
-            mcpServers,
-        });
-        logger.info('ACP session created', {
-            sessionId,
-            providerSessionId: sessionResult.sessionId,
-        });
-        return {
-            providerSessionId: sessionResult.sessionId,
-            configOptions: requireSessionConfigOptions(options.provider, 'newSession', sessionResult),
-        };
+    beginShutdown() {
+        return this.supervisor.beginShutdown();
     }
-    async stopClient(sessionId) {
-        if (this.stoppingInProgress.has(sessionId)) {
-            logger.debug('ACP session stop already in progress', { sessionId });
-            return;
-        }
-        const pendingCreation = this.pendingCreation.get(sessionId);
-        const initialHandle = this.sessions.get(sessionId);
-        if (!(initialHandle || pendingCreation)) {
-            return;
-        }
-        this.beginSessionStop(sessionId);
-        let stoppedHandle;
-        try {
-            if (pendingCreation) {
-                await raceWithSoftTimeout(pendingCreation.catch(() => undefined), 5000);
-            }
-            const handle = this.sessions.get(sessionId) ?? initialHandle;
-            if (!handle) {
-                return;
-            }
-            stoppedHandle = handle;
-            this.managedStopChildren.add(handle.child);
-            if (handle.isPromptInFlight) {
-                try {
-                    await handle.connection.cancel({
-                        sessionId: handle.providerSessionId,
-                    });
-                }
-                catch (error) {
-                    logger.debug('Failed to cancel prompt during stop (expected)', {
-                        sessionId,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
-            const exitPromise = new Promise((resolve) => {
-                handle.child.on('exit', () => resolve());
-                if (handle.child.exitCode !== null) {
-                    resolve();
-                }
-            });
-            handle.child.kill('SIGTERM');
-            await raceWithSoftTimeout(exitPromise, 5000);
-            if (handle.child.exitCode === null) {
-                logger.warn('ACP process did not exit after SIGTERM, escalating to SIGKILL', {
-                    sessionId,
-                    pid: handle.getPid(),
-                });
-                handle.child.kill('SIGKILL');
-            }
-        }
-        finally {
-            this.stoppingInProgress.delete(sessionId);
-            const current = this.sessions.get(sessionId);
-            if (current === stoppedHandle) {
-                this.sessions.delete(sessionId);
-            }
-        }
+    stopClient(sessionId) {
+        return this.supervisor.stopClient(sessionId);
     }
     async sendPrompt(sessionId, prompt, timeoutMs) {
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            throw new Error(`No ACP session found for sessionId: ${sessionId}`);
-        }
-        handle.isPromptInFlight = true;
-        try {
-            const promptPromise = handle.connection.prompt({
-                sessionId: handle.providerSessionId,
-                prompt,
-            });
-            let result;
-            if (timeoutMs != null && timeoutMs > 0) {
-                result = await new Promise((resolve, reject) => {
-                    const timer = setTimeout(() => reject(new PromptTimeoutError(sessionId, timeoutMs)), timeoutMs);
-                    promptPromise.then((r) => {
-                        clearTimeout(timer);
-                        resolve(r);
-                    }, (e) => {
-                        clearTimeout(timer);
-                        reject(e);
-                    });
-                });
-            }
-            else {
-                result = await promptPromise;
-            }
-            handle.isPromptInFlight = false;
-            return { stopReason: result.stopReason };
-        }
-        catch (error) {
-            if (error instanceof PromptTimeoutError) {
-                await this.escalatePromptTimeout(sessionId, handle, timeoutMs);
-            }
-            handle.isPromptInFlight = false;
-            throw error;
-        }
-    }
-    async escalatePromptTimeout(sessionId, timedOutHandle, timeoutMs) {
-        if (!this.isCurrentPromptTimeoutHandle(sessionId, timedOutHandle, timeoutMs)) {
-            return;
-        }
-        logger.warn('Prompt timed out, attempting cancel', { sessionId, timeoutMs });
-        try {
-            const cancelled = await Promise.race([
-                this.cancelPrompt(sessionId).then(() => true),
-                new Promise((resolve) => setTimeout(() => resolve(false), 5000)),
-            ]);
-            if (!this.isCurrentPromptTimeoutHandle(sessionId, timedOutHandle, timeoutMs)) {
-                return;
-            }
-            if (!cancelled) {
-                logger.warn('Cancel timed out after prompt timeout, stopping client', { sessionId });
-                this.clearPromptInFlight(sessionId);
-                await this.stopClient(sessionId).catch(() => {
-                });
-            }
-        }
-        catch {
-            if (!this.isCurrentPromptTimeoutHandle(sessionId, timedOutHandle, timeoutMs)) {
-                return;
-            }
-            logger.warn('Cancel failed after timeout, stopping client', { sessionId });
-            this.clearPromptInFlight(sessionId);
-            await this.stopClient(sessionId).catch(() => {
-            });
-        }
-    }
-    isCurrentPromptTimeoutHandle(sessionId, timedOutHandle, timeoutMs) {
-        if (this.sessions.get(sessionId) === timedOutHandle) {
-            return true;
-        }
-        logger.info('Ignoring stale prompt timeout for replaced ACP session', {
-            sessionId,
-            timeoutMs,
-        });
-        return false;
-    }
-    clearPromptInFlight(sessionId) {
-        const handle = this.sessions.get(sessionId);
-        if (handle) {
-            handle.isPromptInFlight = false;
-        }
+        return await this.promptController.sendPrompt(sessionId, this.requireInstalledHandle(sessionId), prompt, timeoutMs);
     }
     async cancelPrompt(sessionId) {
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            return;
-        }
-        if (handle.isPromptInFlight) {
-            await handle.connection.cancel({
-                sessionId: handle.providerSessionId,
-            });
-        }
+        return await this.promptController.cancelPrompt(sessionId, this.supervisor.getInstalledHandle(sessionId));
     }
     async setConfigOption(sessionId, configId, value) {
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            throw new Error(`No ACP session found for sessionId: ${sessionId}`);
-        }
-        try {
-            const response = await handle.connection.setSessionConfigOption({
-                sessionId: handle.providerSessionId,
-                configId,
-                value,
-            });
-            const configOptions = requireSessionConfigOptions(handle.provider, 'setSessionConfigOption', {
-                configOptions: response.configOptions,
-            });
-            handle.configOptions = configOptions;
-            return configOptions;
-        }
-        catch (error) {
-            logger.warn('setSessionConfigOption failed', {
-                sessionId,
-                configId,
-                provider: handle.provider,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
-        }
+        return await this.configController.setConfigOption(this.requireInstalledHandle(sessionId), configId, value, sessionId);
     }
     async setSessionMode(sessionId, modeId) {
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            throw new Error(`No ACP session found for sessionId: ${sessionId}`);
-        }
-        try {
-            await handle.connection.setSessionMode({
-                sessionId: handle.providerSessionId,
-                modeId,
-            });
-            handle.configOptions = handle.configOptions.map((option) => option.category === 'mode' ? { ...option, currentValue: modeId } : option);
-            return [...handle.configOptions];
-        }
-        catch (error) {
-            logger.warn('setSessionMode failed', {
-                sessionId,
-                modeId,
-                provider: handle.provider,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
-        }
+        return await this.configController.setSessionMode(this.requireInstalledHandle(sessionId), modeId, sessionId);
     }
     async setSessionModel(sessionId, modelId) {
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            throw new Error(`No ACP session found for sessionId: ${sessionId}`);
-        }
-        const applyModelToCache = () => {
-            handle.configOptions = handle.configOptions.map((option) => option.category === 'model' ? { ...option, currentValue: modelId } : option);
-            return [...handle.configOptions];
-        };
-        if (handle.provider === 'CLAUDE') {
-            try {
-                await handle.connection.unstable_setSessionModel({
-                    sessionId: handle.providerSessionId,
-                    modelId,
-                });
-                return applyModelToCache();
-            }
-            catch (error) {
-                if (!isMethodNotFoundError(error)) {
-                    logger.warn('setSessionModel failed', {
-                        sessionId,
-                        modelId,
-                        provider: handle.provider,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    throw error;
-                }
-                logger.warn('unstable_setSessionModel unavailable, falling back to setSessionConfigOption', {
-                    sessionId,
-                    modelId,
-                    provider: handle.provider,
-                });
-            }
-        }
-        return await this.setConfigOption(sessionId, 'model', modelId);
-    }
-    async stopAllClients(timeoutMs = 5000) {
-        this.beginShutdown();
-        await this.stopCurrentClients(timeoutMs);
-        await this.waitForPendingCreations(timeoutMs);
-        await this.stopCurrentClients(timeoutMs);
-        this.sessions.clear();
-        this.pendingCreation.clear();
-        this.creationLocks.clear();
-        this.lockRefCounts.clear();
-        this.shutdownWaiters.clear();
-        this.sessionStopWaiters.clear();
-        logger.info('All ACP clients stopped and cleaned up');
+        return await this.configController.setSessionModel(this.requireInstalledHandle(sessionId), modelId, sessionId);
     }
-    async stopCurrentClients(timeoutMs) {
-        const sessionIds = [...this.sessions.keys()];
-        const stopPromises = sessionIds.map((sessionId) => raceWithSoftTimeout(this.stopClient(sessionId), timeoutMs));
-        await Promise.all(stopPromises);
-    }
-    async waitForPendingCreations(timeoutMs) {
-        const pendingCreations = [...this.pendingCreation.values()];
-        if (pendingCreations.length === 0) {
-            return;
-        }
-        await raceWithSoftTimeout(Promise.allSettled(pendingCreations).then(() => undefined), timeoutMs);
+    stopAllClients(timeoutMs = 5000) {
+        return this.supervisor.stopAllClients(timeoutMs);
     }
     getAllClients() {
-        return this.sessions.entries();
+        return this.supervisor.getAllClients();
     }
     isSessionRunning(sessionId) {
-        const handle = this.sessions.get(sessionId);
-        return handle?.isRunning() ?? false;
+        return this.supervisor.isSessionRunning(sessionId);
     }
     isSessionWorking(sessionId) {
-        const handle = this.sessions.get(sessionId);
-        return handle?.isPromptInFlight ?? false;
+        return this.supervisor.isSessionWorking(sessionId);
     }
     isAnySessionWorking(sessionIds) {
-        return sessionIds.some((id) => this.isSessionWorking(id));
+        return this.supervisor.isAnySessionWorking(sessionIds);
     }
     getAllActiveProcesses() {
-        const processes = [];
-        for (const [sessionId, handle] of this.sessions) {
-            processes.push({
-                sessionId,
-                pid: handle.getPid(),
-                status: handle.isRunning() ? 'running' : 'stopped',
-                isRunning: handle.isRunning(),
-                isPromptInFlight: handle.isPromptInFlight,
-                provider: handle.provider,
-            });
+        return this.supervisor.getAllActiveProcesses();
+    }
+    requireInstalledHandle(sessionId) {
+        const handle = this.supervisor.getInstalledHandle(sessionId);
+        if (!handle) {
+            throw new Error(`No ACP session found for sessionId: ${sessionId}`);
         }
-        return processes;
+        return handle;
     }
 }
 function createAcpRuntimeManager() {