factory-factory 0.3.8 → 0.3.9

package/dist/src/backend/domains/session/lifecycle/session.service.js

@@ -1,11 +1,10 @@
-import { AcpEventTranslator, acpRuntimeManager, } from '../../../../backend/domains/session/acp/index.js';
+import { acpRuntimeManager } from '../../../../backend/domains/session/acp/index.js';
 import { acpTraceLogger } from '../../../../backend/domains/session/logging/acp-trace-logger.service.js';
-import { sessionFileLogger } from '../../../../backend/domains/session/logging/session-file-logger.service.js';
 import { sessionDomainService, } from '../../../../backend/domains/session/session-domain.service.js';
-import { interceptorRegistry } from '../../../../backend/interceptors/registry.js';
 import { createLogger } from '../../../../backend/services/logger.service.js';
 import { SessionStatus } from '../../../../shared/core/index.js';
 import { createInitialSessionRuntimeState, } from '../../../../shared/session-runtime.js';
+import { AcpEventProcessor } from './acp-event-processor.js';
 import { SessionConfigService, } from './session.config.service.js';
 import { SessionPermissionService } from './session.permission.service.js';
 import { sessionPromptBuilder } from './session.prompt-builder.js';
@@ -26,21 +25,20 @@ export class SessionService {
     promptBuilder;
     runtimeManager;
     sessionDomainService;
-    acpEventTranslator = new AcpEventTranslator(logger);
     sessionPermissionService;
     sessionConfigService;
-    acpStreamState = new Map();
-    pendingAcpToolCalls = new Map();
-    suppressAcpReplayForSession = new Set();
+    acpEventProcessor;
     workspaceBridge = null;
-    sessionToWorkspace = new Map();
-    sessionToWorkingDir = new Map();
     promptTurnCompleteHandler = null;
+    promptTurnCompleteTimeouts = new Map();
     configure(bridges) {
         this.workspaceBridge = bridges.workspace;
     }
     setPromptTurnCompleteHandler(handler) {
         this.promptTurnCompleteHandler = handler;
+        if (!handler) {
+            this.clearAllScheduledPromptTurnCompletions();
+        }
     }
     isStaleLoadingRuntime(runtime) {
         if (runtime.phase !== 'loading' || runtime.processState === 'alive') {
@@ -53,39 +51,9 @@ export class SessionService {
         return Date.now() - updatedAtMs > STALE_LOADING_RUNTIME_MAX_AGE_MS;
     }
     setupAcpEventHandler(sessionId) {
-        const permissionBridge = this.sessionPermissionService.createPermissionBridge(sessionId);
+        const runtimeEventHandler = this.acpEventProcessor.createRuntimeEventHandler(sessionId);
         return {
-            permissionBridge,
-            onAcpEvent: (sid, event) => {
-                const typed = event;
-                if (typed.type === 'acp_session_update') {
-                    const { update } = event;
-                    if (update.sessionUpdate === 'user_message_chunk' && update.content.type === 'text') {
-                        this.handleAcpUserMessageChunk(sid, update.content.text);
-                        return;
-                    }
-                    const deltas = this.acpEventTranslator.translateSessionUpdate(update);
-                    if (deltas.length === 0) {
-                        acpTraceLogger.log(sid, 'translated_delta', {
-                            sessionUpdate: update.sessionUpdate,
-                            deltaCount: 0,
-                        });
-                    }
-                    for (const [index, delta] of deltas.entries()) {
-                        acpTraceLogger.log(sid, 'translated_delta', {
-                            sessionUpdate: update.sessionUpdate,
-                            deltaIndex: index,
-                            delta,
-                        });
-                        this.handleAcpDelta(sid, delta);
-                    }
-                    return;
-                }
-                if (typed.type === 'acp_permission_request') {
-                    this.sessionPermissionService.handlePermissionRequest(sid, event);
-                    return;
-                }
-            },
+            ...runtimeEventHandler,
             onSessionId: async (sid, providerSessionId) => {
                 try {
                     await this.repository.updateSession(sid, { providerSessionId });
@@ -107,11 +75,8 @@ export class SessionService {
                 }
             },
             onExit: async (sid, exitCode) => {
-                this.acpStreamState.delete(sid);
-                this.pendingAcpToolCalls.delete(sid);
-                this.suppressAcpReplayForSession.delete(sid);
-                this.sessionToWorkspace.delete(sid);
-                this.sessionToWorkingDir.delete(sid);
+                this.clearScheduledPromptTurnCompletion(sid);
+                this.acpEventProcessor.clearSessionState(sid);
                 this.sessionPermissionService.cancelPendingRequests(sid);
                 acpTraceLogger.log(sid, 'runtime_exit', { exitCode });
                 try {
@@ -120,7 +85,7 @@ export class SessionService {
                         status: SessionStatus.COMPLETED,
                     });
                     logger.debug('Updated ACP session status to COMPLETED on exit', { sessionId: sid });
-                    await this.repository.clearRatchetActiveSession(session.workspaceId, sid);
+                    await this.clearRatchetActiveSessionIfMatching(session.workspaceId, sid);
                     if (session.workflow === 'ratchet') {
                         await this.repository.deleteSession(sid);
                         logger.debug('Deleted transient ratchet ACP session', { sessionId: sid });
@@ -149,319 +114,23 @@ export class SessionService {
                 });
             },
             onAcpLog: (sid, payload) => {
-                acpTraceLogger.log(sid, 'raw_acp_event', payload);
-                sessionFileLogger.log(sid, 'FROM_CLAUDE_CLI', payload);
+                this.acpEventProcessor.handleAcpLog(sid, payload);
             },
         };
     }
-    handleAcpDelta(sid, delta) {
-        this.maybeLiftReplaySuppression(sid);
-        if (this.suppressAcpReplayForSession.has(sid) &&
-            delta.type !== 'config_options_update' &&
-            delta.type !== 'slash_commands') {
-            return;
-        }
-        this.trackPendingAcpToolCalls(sid, delta);
-        if (delta.type === 'config_options_update') {
-            const acpHandle = this.runtimeManager.getClient(sid);
-            if (acpHandle) {
-                const { configOptions } = delta;
-                this.sessionConfigService.applyConfigOptionsUpdateDelta(sid, acpHandle, configOptions);
-                return;
-            }
-        }
-        if (delta.type !== 'agent_message') {
-            this.sessionDomainService.emitDelta(sid, delta);
-            return;
-        }
-        const data = delta.data;
-        if (data.type === 'assistant') {
-            this.accumulateAcpText(sid, data);
-            return;
-        }
-        this.acpStreamState.delete(sid);
-        const order = this.sessionDomainService.appendClaudeEvent(sid, data);
-        this.sessionDomainService.emitDelta(sid, { ...delta, order });
-    }
-    trackPendingAcpToolCalls(sid, delta) {
-        if (delta.type === 'agent_message') {
-            this.trackPendingFromAgentMessage(sid, delta.data);
-            return;
-        }
-        if (delta.type === 'tool_progress') {
-            this.trackPendingFromToolProgress(sid, delta);
-        }
-    }
-    trackPendingFromAgentMessage(sid, data) {
-        if (data.type === 'stream_event') {
-            this.trackPendingFromToolUseStreamEvent(sid, data);
-        }
-        if (data.type !== 'user') {
-            return;
-        }
-        this.clearPendingFromToolResultMessage(sid, data);
-    }
-    trackPendingFromToolUseStreamEvent(sid, data) {
-        const streamEvent = data.event;
-        const contentBlock = streamEvent?.content_block;
-        const isToolUse = streamEvent?.type === 'content_block_start' && contentBlock?.type === 'tool_use';
-        if (!isToolUse) {
-            return;
-        }
-        const toolUseId = typeof contentBlock?.id === 'string' ? contentBlock.id : null;
-        if (!toolUseId) {
-            return;
-        }
-        const toolName = typeof contentBlock?.name === 'string' ? contentBlock.name : 'ACP Tool';
-        const toolInput = this.normalizeToolInput(contentBlock?.input);
-        const existing = this.getPendingToolCall(sid, toolUseId);
-        this.upsertPendingToolCall(sid, toolUseId, { toolName, toolInput });
-        if (!existing) {
-            this.notifyInterceptorToolStart(sid, {
-                toolUseId,
-                toolName,
-                toolInput: toolInput ?? {},
-            });
-        }
-    }
-    clearPendingFromToolResultMessage(sid, data) {
-        if (data.type !== 'user') {
-            return;
-        }
-        const content = data.message?.content;
-        if (!Array.isArray(content)) {
-            return;
-        }
-        for (const item of content) {
-            if (item.type === 'tool_result') {
-                const pending = this.getPendingToolCall(sid, item.tool_use_id);
-                this.notifyInterceptorToolComplete(sid, item.tool_use_id, item.content, item.is_error === true, pending);
-                this.removePendingToolCall(sid, item.tool_use_id);
-            }
-        }
-    }
-    trackPendingFromToolProgress(sid, progress) {
-        if (!progress.tool_use_id) {
-            return;
-        }
-        const existing = this.getPendingToolCall(sid, progress.tool_use_id);
-        this.upsertPendingToolCall(sid, progress.tool_use_id, {
-            toolName: progress.tool_name ?? 'ACP Tool',
-            acpKind: progress.acpKind,
-            acpLocations: progress.acpLocations,
-        });
-        if (!existing) {
-            this.notifyInterceptorToolStart(sid, {
-                toolUseId: progress.tool_use_id,
-                toolName: progress.tool_name ?? 'ACP Tool',
-                toolInput: {},
-            });
-        }
-    }
-    upsertPendingToolCall(sid, toolUseId, update) {
-        const pendingById = this.pendingAcpToolCalls.get(sid) ?? new Map();
-        const existing = pendingById.get(toolUseId);
-        pendingById.set(toolUseId, {
-            toolUseId,
-            toolName: update.toolName || existing?.toolName || 'ACP Tool',
-            toolInput: update.toolInput ?? existing?.toolInput,
-            acpKind: update.acpKind ?? existing?.acpKind,
-            acpLocations: update.acpLocations ?? existing?.acpLocations,
-        });
-        this.pendingAcpToolCalls.set(sid, pendingById);
-    }
-    getPendingToolCall(sid, toolUseId) {
-        return this.pendingAcpToolCalls.get(sid)?.get(toolUseId);
-    }
-    removePendingToolCall(sid, toolUseId) {
-        const pendingById = this.pendingAcpToolCalls.get(sid);
-        if (!pendingById) {
-            return;
-        }
-        pendingById.delete(toolUseId);
-        if (pendingById.size === 0) {
-            this.pendingAcpToolCalls.delete(sid);
-        }
-    }
-    normalizeToolInput(input) {
-        if (typeof input !== 'object' || input === null || Array.isArray(input)) {
-            return undefined;
-        }
-        return input;
-    }
-    extractToolResultText(content) {
-        if (typeof content === 'string') {
-            return content;
-        }
-        if (Array.isArray(content)) {
-            return content
-                .flatMap((item) => {
-                if (typeof item === 'object' &&
-                    item !== null &&
-                    item.type === 'text' &&
-                    typeof item.text === 'string') {
-                    return [item.text];
-                }
-                return [];
-            })
-                .join('\n');
-        }
-        if (content === undefined || content === null) {
-            return '';
-        }
-        try {
-            return JSON.stringify(content);
-        }
-        catch {
-            return String(content);
-        }
-    }
-    getInterceptorContext(sessionId) {
-        const workspaceId = this.sessionToWorkspace.get(sessionId);
-        const workingDir = this.sessionToWorkingDir.get(sessionId);
-        if (!(workspaceId && workingDir)) {
-            return null;
-        }
-        return {
-            sessionId,
-            workspaceId,
-            workingDir,
-            timestamp: new Date(),
-        };
-    }
-    notifyInterceptorToolStart(sessionId, tool) {
-        const context = this.getInterceptorContext(sessionId);
-        if (!context) {
-            return;
-        }
-        const event = {
-            toolUseId: tool.toolUseId,
-            toolName: tool.toolName,
-            input: tool.toolInput,
-        };
-        interceptorRegistry.notifyToolStart(event, context);
-    }
-    notifyInterceptorToolComplete(sessionId, toolUseId, content, isError, pending) {
-        const context = this.getInterceptorContext(sessionId);
-        if (!context) {
-            return;
-        }
-        const event = {
-            toolUseId,
-            toolName: pending?.toolName ?? 'ACP Tool',
-            input: pending?.toolInput ?? {},
-            output: {
-                content: this.extractToolResultText(content),
-                isError,
-            },
-        };
-        interceptorRegistry.notifyToolComplete(event, context);
-    }
-    finalizeOrphanedToolCalls(sid, reason) {
-        const pendingById = this.pendingAcpToolCalls.get(sid);
-        if (!pendingById || pendingById.size === 0) {
-            this.pendingAcpToolCalls.delete(sid);
-            return;
-        }
-        const toolUseIds = [...pendingById.keys()];
-        logger.warn('Finalizing orphaned ACP tool calls without terminal status', {
-            sessionId: sid,
-            reason,
-            count: toolUseIds.length,
-            toolUseIds,
-        });
-        for (const pending of pendingById.values()) {
-            const syntheticProgress = {
-                type: 'tool_progress',
-                tool_use_id: pending.toolUseId,
-                tool_name: pending.toolName,
-                acpStatus: 'failed',
-                elapsed_time_seconds: 0,
-                ...(pending.acpKind ? { acpKind: pending.acpKind } : {}),
-                ...(pending.acpLocations ? { acpLocations: pending.acpLocations } : {}),
-            };
-            this.handleAcpDelta(sid, syntheticProgress);
-            const syntheticResult = {
-                type: 'agent_message',
-                data: {
-                    type: 'user',
-                    message: {
-                        role: 'user',
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: pending.toolUseId,
-                                content: `Tool call did not receive a terminal ACP update (${reason}). Marked as failed locally.`,
-                                is_error: true,
-                            },
-                        ],
-                    },
-                },
-            };
-            this.handleAcpDelta(sid, syntheticResult);
-            acpTraceLogger.log(sid, 'translated_delta', {
-                sessionUpdate: 'synthetic_orphan_tool_call',
-                delta: syntheticProgress,
-            });
-            acpTraceLogger.log(sid, 'translated_delta', {
-                sessionUpdate: 'synthetic_orphan_tool_call',
-                delta: syntheticResult,
-            });
-        }
-        this.pendingAcpToolCalls.delete(sid);
-    }
-    handleAcpUserMessageChunk(sid, text) {
-        this.maybeLiftReplaySuppression(sid);
-        if (this.suppressAcpReplayForSession.has(sid)) {
-            return;
-        }
-        if (this.runtimeManager.isSessionWorking(sid)) {
-            return;
-        }
-        const normalized = text.trim();
-        if (normalized.length === 0) {
-            return;
-        }
-        this.sessionDomainService.injectCommittedUserMessage(sid, normalized);
-    }
-    accumulateAcpText(sid, data) {
-        const content = data.message?.content;
-        const chunkText = Array.isArray(content) && content[0]?.type === 'text'
-            ? content[0].text
-            : '';
-        let ss = this.acpStreamState.get(sid);
-        if (!ss) {
-            ss = { textOrder: this.sessionDomainService.allocateOrder(sid), accText: '' };
-            this.acpStreamState.set(sid, ss);
-        }
-        ss.accText += chunkText;
-        const accMsg = {
-            type: 'assistant',
-            message: { role: 'assistant', content: [{ type: 'text', text: ss.accText }] },
-        };
-        this.sessionDomainService.upsertClaudeEvent(sid, accMsg, ss.textOrder);
-        this.sessionDomainService.emitDelta(sid, {
-            type: 'agent_message',
-            data: accMsg,
-            order: ss.textOrder,
-        });
-    }
     async createAcpClient(sessionId, options, session) {
         const sessionContext = await this.loadSessionContext(sessionId, session);
         if (!sessionContext) {
             throw new Error(`Session context not ready: ${sessionId}`);
         }
         await this.repository.markWorkspaceHasHadSessions(sessionContext.workspaceId);
-        this.sessionToWorkspace.set(sessionId, sessionContext.workspaceId);
-        this.sessionToWorkingDir.set(sessionId, sessionContext.workingDir);
+        this.acpEventProcessor.registerSessionContext(sessionId, {
+            workspaceId: sessionContext.workspaceId,
+            workingDir: sessionContext.workingDir,
+        });
         const handlers = this.setupAcpEventHandler(sessionId);
         const shouldSuppressReplay = this.shouldSuppressReplayDuringAcpResume(sessionId, session);
-        if (shouldSuppressReplay) {
-            this.suppressAcpReplayForSession.add(sessionId);
-        }
-        else {
-            this.suppressAcpReplayForSession.delete(sessionId);
-        }
+        this.acpEventProcessor.setReplaySuppression(sessionId, shouldSuppressReplay);
         const clientOptions = {
             provider: session?.provider ?? 'CLAUDE',
             workingDir: sessionContext.workingDir,
@@ -479,9 +148,7 @@ export class SessionService {
             });
         }
         catch (error) {
-            this.suppressAcpReplayForSession.delete(sessionId);
-            this.sessionToWorkspace.delete(sessionId);
-            this.sessionToWorkingDir.delete(sessionId);
+            this.acpEventProcessor.clearSessionState(sessionId);
             throw error;
         }
         await this.persistAcpConfigSnapshot(sessionId, {
@@ -511,15 +178,6 @@ export class SessionService {
         }
         return this.sessionDomainService.getTranscriptSnapshot(sessionId).length > 0;
     }
-    maybeLiftReplaySuppression(sessionId) {
-        if (!this.suppressAcpReplayForSession.has(sessionId)) {
-            return;
-        }
-        if (!this.runtimeManager.isSessionWorking(sessionId)) {
-            return;
-        }
-        this.suppressAcpReplayForSession.delete(sessionId);
-    }
     constructor(options) {
         this.repository = options?.repository ?? sessionRepository;
         this.promptBuilder = options?.promptBuilder ?? sessionPromptBuilder;
@@ -533,6 +191,12 @@ export class SessionService {
             runtimeManager: this.runtimeManager,
             sessionDomainService: this.sessionDomainService,
         });
+        this.acpEventProcessor = new AcpEventProcessor({
+            runtimeManager: this.runtimeManager,
+            sessionDomainService: this.sessionDomainService,
+            sessionPermissionService: this.sessionPermissionService,
+            sessionConfigService: this.sessionConfigService,
+        });
     }
     async startSession(sessionId, options) {
         const session = await this.repository.getSessionById(sessionId);
@@ -568,8 +232,9 @@ export class SessionService {
         await this.sessionConfigService.applyConfiguredPermissionPreset(sessionId, session, handle);
     }
     async stopSession(sessionId, options) {
+        this.clearScheduledPromptTurnCompletion(sessionId);
         const session = await this.loadSessionForStop(sessionId);
-        const workspaceId = session?.workspaceId ?? this.sessionToWorkspace.get(sessionId);
+        const workspaceId = session?.workspaceId ?? this.acpEventProcessor.getWorkspaceId(sessionId);
         if (this.runtimeManager.isStopInProgress(sessionId)) {
             logger.debug('Session stop already in progress', { sessionId });
             return;
@@ -581,8 +246,8 @@ export class SessionService {
             activity: 'IDLE',
             updatedAt: new Date().toISOString(),
         });
-        this.acpStreamState.delete(sessionId);
-        this.suppressAcpReplayForSession.delete(sessionId);
+        this.acpEventProcessor.clearStreamingState(sessionId);
+        this.acpEventProcessor.clearReplaySuppression(sessionId);
         this.sessionPermissionService.cancelPendingRequests(sessionId);
         let stopClientFailed = false;
         try {
@@ -608,8 +273,7 @@ export class SessionService {
                 updatedAt: new Date().toISOString(),
             });
             this.markWorkspaceSessionIdleOnStop(workspaceId, sessionId);
-            this.sessionToWorkspace.delete(sessionId);
-            this.sessionToWorkingDir.delete(sessionId);
+            this.acpEventProcessor.clearSessionContext(sessionId);
             if (!stopClientFailed) {
                 const shouldCleanupTransientRatchetSession = options?.cleanupTransientRatchetSession ?? true;
                 await this.cleanupTransientRatchetOnStop(session, sessionId, shouldCleanupTransientRatchetSession);
@@ -623,14 +287,14 @@ export class SessionService {
     }
     finalizeOrphanedToolCallsOnStop(sessionId) {
         try {
-            this.finalizeOrphanedToolCalls(sessionId, 'session_stop');
+            this.acpEventProcessor.finalizeOrphanedToolCalls(sessionId, 'session_stop');
         }
         catch (error) {
             logger.warn('Failed finalizing orphaned ACP tool calls during stop', {
                 sessionId,
                 error: error instanceof Error ? error.message : String(error),
             });
-            this.pendingAcpToolCalls.delete(sessionId);
+            this.acpEventProcessor.clearPendingToolCalls(sessionId);
         }
     }
     markWorkspaceSessionIdleOnStop(workspaceId, sessionId) {
@@ -678,7 +342,7 @@ export class SessionService {
             return;
         }
         try {
-            await this.repository.clearRatchetActiveSession(session.workspaceId, sessionId);
+            await this.clearRatchetActiveSessionIfMatching(session.workspaceId, sessionId);
         }
         catch (error) {
             logger.warn('Failed clearing ratchet active session pointer during stop', {
@@ -701,6 +365,12 @@ export class SessionService {
             });
         }
     }
+    async clearRatchetActiveSessionIfMatching(workspaceId, sessionId) {
+        if (!this.workspaceBridge) {
+            return;
+        }
+        await this.workspaceBridge.clearRatchetActiveSessionIfMatching(workspaceId, sessionId);
+    }
     async stopWorkspaceSessions(workspaceId) {
         const sessions = await this.repository.getSessionsByWorkspaceId(workspaceId);
         for (const session of sessions) {
@@ -804,8 +474,8 @@ export class SessionService {
         return chunks.join('\n\n');
     }
     async sendAcpMessage(sessionId, content) {
-        const workspaceId = this.sessionToWorkspace.get(sessionId);
-        this.pendingAcpToolCalls.set(sessionId, new Map());
+        const workspaceId = this.acpEventProcessor.getWorkspaceId(sessionId);
+        this.acpEventProcessor.beginPromptTurn(sessionId);
         this.sessionDomainService.setRuntimeSnapshot(sessionId, {
             phase: 'running',
             processState: 'alive',
@@ -817,7 +487,7 @@ export class SessionService {
         }
         try {
             const result = await this.runtimeManager.sendPrompt(sessionId, content);
-            this.finalizeOrphanedToolCalls(sessionId, `stop_reason:${result.stopReason}`);
+            this.acpEventProcessor.finalizeOrphanedToolCalls(sessionId, `stop_reason:${result.stopReason}`);
             this.sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'idle',
                 processState: 'alive',
@@ -827,7 +497,7 @@ export class SessionService {
             return result.stopReason;
         }
         catch (error) {
-            this.finalizeOrphanedToolCalls(sessionId, 'prompt_error');
+            this.acpEventProcessor.finalizeOrphanedToolCalls(sessionId, 'prompt_error');
             this.sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'error',
                 processState: 'alive',
@@ -848,9 +518,12 @@ export class SessionService {
         if (!this.promptTurnCompleteHandler) {
             return;
         }
-        setTimeout(() => {
+        this.clearScheduledPromptTurnCompletion(sessionId);
+        const timeout = setTimeout(() => {
+            this.promptTurnCompleteTimeouts.delete(sessionId);
             void this.notifyPromptTurnComplete(sessionId);
         }, 0);
+        this.promptTurnCompleteTimeouts.set(sessionId, timeout);
     }
     async notifyPromptTurnComplete(sessionId) {
         if (!this.promptTurnCompleteHandler) {
@@ -866,6 +539,20 @@ export class SessionService {
             });
         }
     }
+    clearScheduledPromptTurnCompletion(sessionId) {
+        const timeout = this.promptTurnCompleteTimeouts.get(sessionId);
+        if (!timeout) {
+            return;
+        }
+        clearTimeout(timeout);
+        this.promptTurnCompleteTimeouts.delete(sessionId);
+    }
+    clearAllScheduledPromptTurnCompletions() {
+        for (const timeout of this.promptTurnCompleteTimeouts.values()) {
+            clearTimeout(timeout);
+        }
+        this.promptTurnCompleteTimeouts.clear();
+    }
     async cancelAcpPrompt(sessionId) {
         await this.runtimeManager.cancelPrompt(sessionId);
     }
@@ -1019,9 +706,10 @@ export class SessionService {
     buildAcpChatBarCapabilities(handle) {
         return this.sessionConfigService.buildAcpChatBarCapabilities(handle);
     }
-    async stopAllClients(_timeoutMs = 5000) {
+    async stopAllClients(timeoutMs = 5000) {
+        this.clearAllScheduledPromptTurnCompletions();
         try {
-            await this.runtimeManager.stopAllClients();
+            await this.runtimeManager.stopAllClients(timeoutMs);
         }
         catch (error) {
             logger.error('Failed to stop ACP clients during shutdown', {