factory-factory 0.4.6 → 0.4.7

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

@@ -1,1046 +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 { z } from 'zod';
-import { createLogger, getCurrentProcessEnv } from '../../../../../backend/services/logger.service.js';
-import { SUBAGENTS_LIST_METHOD, SUBAGENTS_READ_METHOD, subagentListParamsSchema, subagentListResultSchema, subagentReadParamsSchema, subagentReadResultSchema, } from '../../../../../shared/acp-protocol/subagents.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';
-    }
-}
-export class AcpBrowseSessionUnavailableError extends Error {
-    constructor(message, options) {
-        super(message, options);
-        this.name = 'AcpBrowseSessionUnavailableError';
-    }
-}
-class AcpSubagentBrowseError extends Error {
-    code;
-    constructor(code, message, options) {
-        super(message, options);
-        this.code = code;
-        this.name = 'AcpSubagentBrowseError';
-    }
-}
-function resolveAutoApprovePolicy(preset) {
-    if (preset === 'YOLO' || preset === 'RELAXED') {
-        return 'all';
-    }
-    return 'none';
-}
-const DEFAULT_ACP_STARTUP_TIMEOUT_MS = 30_000;
-function getAcpErrorMetadata(error) {
-    const code = typeof error.code === 'number' || typeof error.code === 'string' ? error.code : undefined;
-    return {
-        ...(code !== undefined ? { code } : {}),
-        ...(typeof error.data !== 'undefined' ? { data: error.data } : {}),
-    };
-}
-function getAcpErrorLogDetails(error) {
-    if (error instanceof Error) {
-        const maybe = error;
-        return {
-            message: error.message,
-            ...getAcpErrorMetadata(maybe),
-        };
-    }
-    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);
-                }
-            })();
-        return {
-            message,
-            ...getAcpErrorMetadata(maybe),
-        };
-    }
-    return { message: String(error) };
-}
-function isMethodNotFoundError(error) {
-    const details = getAcpErrorLogDetails(error);
-    return details.code === -32_601 || details.message.includes('Method not found');
-}
-function subagentBrowseMessage(operation, kind) {
-    const subject = operation === 'list' ? 'Sub-agent list' : 'Sub-agent transcript';
-    if (kind === 'invalid') {
-        return `Invalid ${subject.toLowerCase()} request.`;
-    }
-    if (kind === 'not_found') {
-        return `${subject} not found for this session.`;
-    }
-    if (kind === 'protocol') {
-        return `${subject} is unavailable because the provider returned an invalid response.`;
-    }
-    return `${subject} request failed.`;
-}
-function normalizeSubagentBrowseError(error, operation) {
-    if (error instanceof AcpSubagentBrowseError) {
-        return error;
-    }
-    if (error instanceof z.ZodError) {
-        return new AcpSubagentBrowseError('PRECONDITION_FAILED', subagentBrowseMessage(operation, 'protocol'), { cause: error });
-    }
-    const details = getAcpErrorLogDetails(error);
-    if (details.code === -32_602) {
-        return new AcpSubagentBrowseError('INVALID_INPUT', subagentBrowseMessage(operation, 'invalid'), { cause: error });
-    }
-    if (details.code === -32_002) {
-        return new AcpSubagentBrowseError('NOT_FOUND', subagentBrowseMessage(operation, 'not_found'), {
-            cause: error,
-        });
-    }
-    if (details.code === -32_601) {
-        return new AcpSubagentBrowseError('PRECONDITION_FAILED', 'Sub-agent browsing is unavailable for this session.', { cause: error });
-    }
-    if (details.code === -32_000) {
-        return new AcpSubagentBrowseError('PRECONDITION_FAILED', 'Provider authentication is required for sub-agent browsing.', { cause: error });
-    }
-    if (details.code === -32_603 || details.code === -32_600 || details.code === -32_700) {
-        return new AcpSubagentBrowseError('PRECONDITION_FAILED', subagentBrowseMessage(operation, 'protocol'), { cause: error });
-    }
-    return new AcpSubagentBrowseError('INTERNAL_ERROR', subagentBrowseMessage(operation, 'failed'), {
-        cause: error,
-    });
-}
-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();
-    browseOnlySessions = new Set();
-    pendingCreation = new Map();
-    stoppingInProgress = new Set();
-    stopOperations = new Map();
-    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) {
-        if (this.browseOnlySessions.has(sessionId)) {
-            return undefined;
-        }
-        return this.getBrowseClient(sessionId);
+        return this.supervisor.getClient(sessionId);
     }
     getBrowseClient(sessionId) {
-        const handle = this.sessions.get(sessionId);
-        return handle?.isRunning() ? handle : undefined;
+        return this.supervisor.getBrowseClient(sessionId);
     }
     isBrowseOnlySession(sessionId) {
-        return this.browseOnlySessions.has(sessionId);
-    }
-    getPendingClient(sessionId) {
-        return this.pendingCreation.get(sessionId);
+        return this.supervisor.isBrowseOnlySession(sessionId);
     }
-    getSubagentBrowseCapability(sessionId) {
-        return this.getBrowseClient(sessionId)?.getSubagentBrowseCapability() ?? null;
+    hasClientCreationOperation(sessionId) {
+        return this.supervisor.hasClientCreationOperation(sessionId);
     }
-    async listSubagents(sessionId, input) {
-        const handle = this.requireSubagentBrowseHandle(sessionId);
-        const parsedParams = subagentListParamsSchema.safeParse({
-            ...input,
-            sessionId: handle.providerSessionId,
-        });
-        if (!parsedParams.success) {
-            throw new AcpSubagentBrowseError('INVALID_INPUT', subagentBrowseMessage('list', 'invalid'), {
-                cause: parsedParams.error,
-            });
-        }
-        try {
-            const response = await handle.connection.extMethod(SUBAGENTS_LIST_METHOD, parsedParams.data);
-            return subagentListResultSchema.parse(response);
-        }
-        catch (error) {
-            throw normalizeSubagentBrowseError(error, 'list');
-        }
-    }
-    async readSubagentTranscript(sessionId, input) {
-        const handle = this.requireSubagentBrowseHandle(sessionId);
-        const parsedParams = subagentReadParamsSchema.safeParse({
-            ...input,
-            sessionId: handle.providerSessionId,
-        });
-        if (!parsedParams.success) {
-            throw new AcpSubagentBrowseError('INVALID_INPUT', subagentBrowseMessage('transcript', 'invalid'), { cause: parsedParams.error });
-        }
-        try {
-            const response = await handle.connection.extMethod(SUBAGENTS_READ_METHOD, parsedParams.data);
-            return subagentReadResultSchema.parse(response);
-        }
-        catch (error) {
-            throw normalizeSubagentBrowseError(error, 'transcript');
-        }
-    }
-    requireSubagentBrowseHandle(sessionId) {
-        const handle = this.getBrowseClient(sessionId);
-        if (!handle) {
-            throw new AcpSubagentBrowseError('PRECONDITION_FAILED', 'Sub-agent browsing requires a running parent session.');
-        }
-        if (!handle.getSubagentBrowseCapability()) {
-            throw new AcpSubagentBrowseError('PRECONDITION_FAILED', 'Sub-agent browsing is unavailable for this session.');
-        }
-        return handle;
-    }
-    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.getBrowseClient(sessionId);
-                if (existing?.isRunning()) {
-                    this.promoteForActiveUse(sessionId, options);
-                    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 });
-                    const handle = await pending;
-                    this.promoteForActiveUse(sessionId, options);
-                    return handle;
-                }
-                logger.info('Creating new ACP client', { sessionId, provider: options.provider });
-                this.recordClientPurpose(sessionId, options);
-                const createPromise = this.createClient(sessionId, options, handlers, context);
-                this.pendingCreation.set(sessionId, createPromise);
-                try {
-                    return await createPromise;
-                }
-                finally {
-                    this.pendingCreation.delete(sessionId);
-                    this.clearBrowseOnlyPurposeIfUnused(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);
-                }
-            }
-        });
-    }
-    promoteForActiveUse(sessionId, options) {
-        if (options.purpose !== 'browse') {
-            this.browseOnlySessions.delete(sessionId);
-        }
-    }
-    recordClientPurpose(sessionId, options) {
-        if (options.purpose === 'browse') {
-            this.browseOnlySessions.add(sessionId);
-            return;
-        }
-        this.browseOnlySessions.delete(sessionId);
+    getPendingClient(sessionId) {
+        return this.supervisor.getPendingClient(sessionId);
     }
-    clearBrowseOnlyPurposeIfUnused(sessionId) {
-        if (!(this.sessions.has(sessionId) || this.pendingCreation.has(sessionId))) {
-            this.browseOnlySessions.delete(sessionId);
-        }
+    runClientCreationOperation(sessionId, purpose, operation) {
+        return this.supervisor.runClientCreationOperation(sessionId, purpose, operation);
     }
-    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.recordClientPurpose(sessionId, options);
-        this.wireChildExitHandler(sessionId, child, handlers);
-        await this.notifyClientCreated(sessionId, handle, context, handlers);
-        return handle;
+    stopAndQuiesce(sessionId) {
+        return this.supervisor.stopAndQuiesce(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,
-        });
+    getSubagentBrowseCapability(sessionId) {
+        return this.subagentBrowser.getCapability(this.supervisor.getBrowseClient(sessionId));
     }
-    async abortClientCreationIfStopping(child, sessionId) {
-        if (!this.stoppingInProgress.has(sessionId)) {
-            return;
-        }
-        await this.cleanupFailedClientCreation(child, sessionId);
-        throw this.createStopRequestedError(sessionId);
+    listSubagents(sessionId, input) {
+        return this.subagentBrowser.listSubagents(this.supervisor.getBrowseClient(sessionId), input);
     }
-    createShutdownError(sessionId) {
-        return new Error(`ACP runtime manager is shutting down; cannot create client ${sessionId}`);
+    readSubagentTranscript(sessionId, input) {
+        return this.subagentBrowser.readSubagentTranscript(this.supervisor.getBrowseClient(sessionId), input);
     }
-    createStopRequestedError(sessionId) {
-        return new Error(`ACP session stop requested; cannot create client ${sessionId}`);
+    getOrCreateClient(sessionId, options, handlers, context) {
+        return this.supervisor.getOrCreateClient(sessionId, options, handlers, context);
     }
     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];
-    }
-    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);
-                }
-            },
-        };
-    }
-    wireChildExitHandler(sessionId, child, handlers) {
-        child.on('exit', async (code) => {
-            if (this.shouldSkipChildExitHandler(sessionId, child, code)) {
-                this.clearBrowseOnlyPurposeIfUnused(sessionId);
-                return;
-            }
-            this.pendingCreation.delete(sessionId);
-            try {
-                if (handlers.onExit) {
-                    await handlers.onExit(sessionId, code);
-                }
-            }
-            catch (error) {
-                logger.warn('Failed to handle ACP exit event', {
-                    sessionId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-            finally {
-                this.clearBrowseOnlyPurposeIfUnused(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;
-    }
-    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),
-                });
-            }
-        }
-    }
-    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,
-                });
-            }
-        });
-    }
-    async createOrResumeSession(connection, sessionId, options, agentCapabilities) {
-        const storedId = options.resumeProviderSessionId;
-        const browseOnly = options.purpose === 'browse';
-        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 })),
-        }));
-        const resumed = await this.tryLoadStoredSession(connection, sessionId, options, agentCapabilities, mcpServers);
-        if (resumed) {
-            return resumed;
-        }
-        if (browseOnly) {
-            throw new AcpBrowseSessionUnavailableError(storedId
-                ? 'Provider does not support restoring this session for sub-agent browsing.'
-                : 'Stored provider session is required for sub-agent browsing.');
-        }
-        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),
-        };
-    }
-    async tryLoadStoredSession(connection, sessionId, options, agentCapabilities, mcpServers) {
-        const storedId = options.resumeProviderSessionId;
-        if (!(agentCapabilities.loadSession === true && storedId)) {
-            return null;
-        }
-        let loadResult;
-        try {
-            loadResult = await connection.loadSession({
-                sessionId: storedId,
-                cwd: options.workingDir,
-                mcpServers,
-            });
-        }
-        catch (error) {
-            this.logLoadSessionFailure(sessionId, storedId, error, options.purpose === 'browse');
-            if (options.purpose === 'browse') {
-                throw new AcpBrowseSessionUnavailableError('Provider failed to restore this session for sub-agent browsing.', { cause: error });
-            }
-            return null;
-        }
-        logger.info('ACP session resumed via loadSession', {
-            sessionId,
-            providerSessionId: storedId,
-        });
-        return {
-            providerSessionId: storedId,
-            configOptions: requireSessionConfigOptions(options.provider, 'loadSession', loadResult),
-        };
-    }
-    logLoadSessionFailure(sessionId, storedProviderSessionId, error, browseOnly) {
-        const details = getAcpErrorLogDetails(error);
-        logger.warn(browseOnly ? 'Browse-only loadSession failed' : 'loadSession failed', {
-            sessionId,
-            storedProviderSessionId,
-            error: details.message,
-            ...(details.code !== undefined ? { errorCode: details.code } : {}),
-            ...(typeof details.data !== 'undefined' ? { errorData: details.data } : {}),
-            ...(!browseOnly ? { fallback: 'newSession' } : {}),
-        });
+        return this.supervisor.beginShutdown();
     }
     stopClient(sessionId) {
-        const existingStop = this.stopOperations.get(sessionId);
-        if (existingStop) {
-            logger.debug('ACP session stop already in progress', { sessionId });
-            return existingStop;
-        }
-        let trackedStop;
-        trackedStop = this.stopClientOnce(sessionId).finally(() => {
-            if (this.stopOperations.get(sessionId) === trackedStop) {
-                this.stopOperations.delete(sessionId);
-            }
-        });
-        this.stopOperations.set(sessionId, trackedStop);
-        return trackedStop;
-    }
-    async stopClientOnce(sessionId) {
-        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);
-                this.browseOnlySessions.delete(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 false;
-        }
-        if (!handle.isPromptInFlight) {
-            return false;
-        }
-        await handle.connection.cancel({
-            sessionId: handle.providerSessionId,
-        });
-        return true;
+        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');
-    }
-    async stopCurrentClients(timeoutMs) {
-        const sessionIds = [...this.sessions.keys()];
-        const stopPromises = sessionIds.map((sessionId) => raceWithSoftTimeout(this.stopClient(sessionId), timeoutMs));
-        await Promise.all(stopPromises);
+        return await this.configController.setSessionModel(this.requireInstalledHandle(sessionId), modelId, sessionId);
     }
-    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) {
-        return this.getClient(sessionId) !== undefined;
+        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() {