factory-factory 0.4.6 → 0.4.8

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

@@ -1,368 +1,59 @@
-import { randomUUID } from 'node:crypto';
-import { configService } from '../../../../../backend/services/config.service.js';
-import { createLogger } from '../../../../../backend/services/logger.service.js';
-import { AcpBrowseSessionUnavailableError } from '../../../../../backend/services/session/service/acp/acp-runtime-manager.js';
-import { getChildWorkspaceMcpServerConfig } from '../../../../../backend/services/session/service/acp/child-workspace-mcp-server.js';
-import { acpTraceLogger } from '../../../../../backend/services/session/service/logging/acp-trace-logger.service.js';
-import { sessionEventBus } from '../../../../../backend/services/session/service/session-event-bus.js';
-import { userSettingsService } from '../../../../../backend/services/settings/index.js';
-import { workspaceDataService, workspaceNotificationService } from '../../../../../backend/services/workspace/index.js';
-import { SessionLifecycleEventKind, SessionLifecycleEventReason, SessionStatus, } from '../../../../../shared/core/index.js';
 import { createInitialSessionRuntimeState, } from '../../../../../shared/session-runtime.js';
-import { buildWorkspaceNotificationMessageText, WORKSPACE_NOTIFICATION_MESSAGE_ID_PREFIX, workspaceNotificationMessageId, } from '../../../../../shared/workspace-notifications.js';
-import { closedSessionPersistenceService } from './closed-session-persistence.service.js';
-import { toErrorMessage } from './session.error-message.js';
-import { maybeDiscoverPROnSessionEnd as maybeDiscoverPROnSessionEndHelper } from './session-pr-discovery.service.js';
 import { isStaleLoadingRuntime } from './session-runtime-state.helpers.js';
-const logger = createLogger('session');
-class SessionStartupCancelledError extends Error {
-    constructor() {
-        super('Session is currently being stopped');
-        this.name = 'SessionStartupCancelledError';
-    }
-}
-function getPersistedStatusForExitCode(exitCode) {
-    return exitCode === 0 ? SessionStatus.COMPLETED : SessionStatus.FAILED;
-}
-const SESSION_STOP_MESSAGES = {
-    USER_STOP: 'Session stopped by you.',
-    SESSION_CLOSED: 'Session closed by you.',
-    WORKSPACE_ARCHIVED: 'Session stopped because the workspace was archived.',
-    SYSTEM_STOP: 'Session stopped by the system.',
-};
-const SHUTDOWN_LIFECYCLE_RECORD_TIMEOUT_MS = 1000;
 export class SessionLifecycleService {
-    repository;
-    promptBuilder;
-    runtimeManager;
-    sessionDomainService;
-    sessionPermissionService;
-    sessionConfigService;
-    acpEventProcessor;
-    promptTurnCompletionService;
-    retryService;
-    lifecycleEventService;
-    hydrateProviderHistory;
-    sendSessionMessage;
-    onBeforeStopSession;
-    onSessionExit;
-    stoppingSessions = new Set();
-    shutdownSessions = new Set();
-    stopGenerationCounter = 0;
-    stopGenerations = new Map();
-    startupGenerationReferences = new Map();
-    clientCreationOperations = new Map();
-    workspaceBridge = null;
-    messageQueueBridge = null;
-    autoIterationExitBridge = null;
-    constructor(options) {
-        this.repository = options.repository;
-        this.promptBuilder = options.promptBuilder;
-        this.runtimeManager = options.runtimeManager;
-        this.sessionDomainService = options.sessionDomainService;
-        this.sessionPermissionService = options.sessionPermissionService;
-        this.sessionConfigService = options.sessionConfigService;
-        this.acpEventProcessor = options.acpEventProcessor;
-        this.promptTurnCompletionService = options.promptTurnCompletionService;
-        this.retryService = options.retryService;
-        this.lifecycleEventService = options.lifecycleEventService;
-        this.hydrateProviderHistory =
-            options.hydrateProviderHistory ?? (async () => undefined);
-        this.sendSessionMessage = options.sendSessionMessage;
-        this.onBeforeStopSession = options.onBeforeStopSession;
-        this.onSessionExit = options.onSessionExit;
+    dependencies;
+    configured = false;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
     }
     configure(bridges) {
-        this.workspaceBridge = bridges.workspace;
-        this.messageQueueBridge = bridges.messageQueue ?? null;
-        this.autoIterationExitBridge = bridges.autoIterationExit ?? null;
+        this.configured = false;
+        this.dependencies.workflowFinalizer.configure({
+            workspace: bridges.workspace,
+            autoIterationExit: bridges.autoIterationExit,
+        });
+        this.dependencies.terminationCoordinator.configure({ workspace: bridges.workspace });
+        this.dependencies.startupCoordinator.configure({ messageQueue: bridges.messageQueue });
+        this.configured = true;
     }
     async startSession(sessionId, options) {
-        await this.runStartupOperation(sessionId, async (stopGeneration) => {
-            const session = await this.repository.getSessionById(sessionId);
-            if (!session) {
-                throw new Error(`Session not found: ${sessionId}`);
-            }
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            const existingClient = this.runtimeManager.getClient(sessionId);
-            if (existingClient) {
-                throw new Error('Session is already running');
-            }
-            const startupModePreset = options?.startupModePreset;
-            const { handle, resolvedPreset, dispatchableNotificationCount } = await this.getOrCreateAcpSessionClient(sessionId, {}, session, stopGeneration);
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            await this.applyStartupModePreset(sessionId, handle, startupModePreset, session.workflow);
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            await this.applyConfiguredPermissionPreset(sessionId, session, handle, resolvedPreset);
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            await this.dispatchQueuedNotificationsIfNeeded(sessionId, dispatchableNotificationCount);
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            const initialPrompt = options?.initialPrompt ?? 'Continue with the task.';
-            const shouldSendInitialPrompt = dispatchableNotificationCount === 0 ||
-                (typeof options?.initialPrompt === 'string' && !options.initialPromptIsDefault);
-            if (shouldSendInitialPrompt && initialPrompt) {
-                await this.sendSessionMessage(sessionId, initialPrompt);
-            }
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            logger.info('Session started', { sessionId, provider: session.provider });
-        });
+        this.assertConfigured();
+        await this.dependencies.startupCoordinator.startSession(sessionId, options);
     }
     async restartSession(sessionId, options) {
-        const isRunning = this.runtimeManager.isSessionRunning(sessionId);
-        const isStopInProgress = this.runtimeManager.isStopInProgress(sessionId);
-        if (isStopInProgress) {
-            throw new Error('Cannot restart: session is currently being stopped. Please try again shortly.');
-        }
-        if (isRunning) {
-            try {
-                await this.stopSession(sessionId, { cleanupTransientRatchetSession: false });
-            }
-            catch (error) {
-                logger.warn('Error stopping session during restart; continuing with start', {
-                    sessionId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        await this.startSession(sessionId, options ?? {
-            initialPrompt: 'Continue with the task.',
-            initialPromptIsDefault: true,
-        });
-        logger.info('Session restarted', { sessionId });
+        this.assertConfigured();
+        await this.dependencies.startupCoordinator.restartSession(sessionId, options);
     }
     async stopSession(sessionId, options) {
-        if (this.stoppingSessions.has(sessionId)) {
-            logger.debug('Session stop already in progress', { sessionId });
-            return;
-        }
-        this.advanceStopGeneration(sessionId);
-        this.stoppingSessions.add(sessionId);
-        const stopInvocationId = randomUUID();
-        try {
-            await this.stopSessionWithBarrier(sessionId, stopInvocationId, options);
-        }
-        finally {
-            this.stoppingSessions.delete(sessionId);
-            this.stopGenerations.delete(sessionId);
-        }
-    }
-    async stopSessionWithBarrier(sessionId, stopInvocationId, options) {
-        this.promptTurnCompletionService.clearSession(sessionId);
-        this.onBeforeStopSession?.(sessionId);
-        this.sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: true });
-        const session = await this.loadSessionForStop(sessionId);
-        const workspaceId = session?.workspaceId ?? this.acpEventProcessor.getWorkspaceId(sessionId);
-        const reason = options?.reason ?? 'SYSTEM_STOP';
-        if (workspaceId && options?.recordLifecycleEvent !== false) {
-            await this.lifecycleEventService.record({
-                workspaceId,
-                sessionId,
-                kind: SessionLifecycleEventKind.SESSION_STOPPED,
-                reason,
-                message: SESSION_STOP_MESSAGES[reason],
-                dedupeKey: `session-stop:${stopInvocationId}`,
-            });
-        }
-        const current = this.getRuntimeSnapshot(sessionId);
-        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
-            ...current,
-            phase: 'stopping',
-            activity: 'IDLE',
-            updatedAt: new Date().toISOString(),
-        });
-        this.acpEventProcessor.clearStreamingState(sessionId);
-        this.acpEventProcessor.clearReplaySuppression(sessionId);
-        this.sessionPermissionService.cancelPendingRequests(sessionId);
-        let stopClientFailed = false;
-        try {
-            await this.stopRuntimeAndPendingCreation(sessionId);
-        }
-        catch (error) {
-            stopClientFailed = true;
-            logger.warn('Error stopping ACP session runtime; continuing cleanup', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        finally {
-            this.finalizeOrphanedToolCalls(sessionId, 'session_stop');
-            await this.updateStoppedSessionState(sessionId);
-            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
-                phase: 'idle',
-                processState: 'stopped',
-                activity: 'IDLE',
-                updatedAt: new Date().toISOString(),
-            });
-            this.markWorkspaceSessionIdleOnStop(workspaceId, sessionId);
-            this.acpEventProcessor.clearSessionState(sessionId);
-            if (!stopClientFailed) {
-                const shouldCleanupTransientRatchetSession = options?.cleanupTransientRatchetSession ?? true;
-                await this.cleanupTransientRatchetOnStop(session, sessionId, shouldCleanupTransientRatchetSession);
-            }
-            try {
-                this.clearSessionStoreIfInactive(sessionId, 'manual_stop');
-                logger.info('ACP session stopped', {
-                    sessionId,
-                    ...(stopClientFailed ? { runtimeStopFailed: true } : {}),
-                });
-            }
-            finally {
-                acpTraceLogger.closeSession(sessionId);
-            }
-        }
-    }
-    async stopRuntimeAndPendingCreation(sessionId) {
-        await this.runtimeManager.stopClient(sessionId);
-        const pendingCreations = this.clientCreationOperations.get(sessionId);
-        if (!pendingCreations || pendingCreations.size === 0) {
-            return;
-        }
-        await Promise.allSettled([...pendingCreations]);
-        await this.runtimeManager.stopClient(sessionId);
+        this.assertConfigured();
+        await this.dependencies.terminationCoordinator.stopSession(sessionId, options);
     }
     async stopWorkspaceSessions(workspaceId, options) {
-        const sessions = await this.repository.getSessionsByWorkspaceId(workspaceId);
-        const stopErrors = [];
-        for (const session of sessions) {
-            const stopOptions = this.getWorkspaceSessionStopOptions(session, options?.reason ?? 'SYSTEM_STOP');
-            if (!stopOptions) {
-                continue;
-            }
-            try {
-                await this.stopSession(session.id, stopOptions);
-            }
-            catch (error) {
-                logger.error('Failed to stop workspace session', {
-                    sessionId: session.id,
-                    workspaceId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                stopErrors.push(error);
-            }
-        }
-        if (stopErrors.length > 0) {
-            throw new Error(`Failed to stop ${stopErrors.length} workspace session${stopErrors.length === 1 ? '' : 's'}`);
-        }
-        logger.info('Stopped all workspace sessions', { workspaceId, count: sessions.length });
-    }
-    getWorkspaceSessionStopOptions(session, reason) {
-        const browseOnlyClient = this.runtimeManager.isBrowseOnlySession(session.id);
-        const activeClient = this.runtimeManager.isSessionRunning(session.id);
-        if (!(session.status === SessionStatus.RUNNING || activeClient || browseOnlyClient)) {
-            return null;
-        }
-        return {
-            reason,
-            ...(browseOnlyClient && !activeClient ? { recordLifecycleEvent: false } : {}),
-        };
+        this.assertConfigured();
+        await this.dependencies.terminationCoordinator.stopWorkspaceSessions(workspaceId, options);
     }
     async getOrCreateSessionClient(sessionId, options) {
-        return await this.runStartupOperation(sessionId, async (stopGeneration) => {
-            const session = await this.repository.getSessionById(sessionId);
-            if (!session) {
-                throw new Error(`Session not found: ${sessionId}`);
-            }
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            const hadClient = !!this.runtimeManager.getClient(sessionId);
-            const { handle, resolvedPreset, dispatchableNotificationCount } = await this.getOrCreateAcpSessionClient(sessionId, options ?? {}, session, stopGeneration);
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            if (!hadClient) {
-                await this.applyConfiguredPermissionPreset(sessionId, session, handle, resolvedPreset);
-                this.assertStartupAllowed(sessionId, stopGeneration);
-                await this.dispatchQueuedNotificationsIfNeeded(sessionId, dispatchableNotificationCount);
-                this.assertStartupAllowed(sessionId, stopGeneration);
-            }
-            return handle;
-        });
+        this.assertConfigured();
+        return await this.dependencies.startupCoordinator.getOrCreateSessionClient(sessionId, options);
     }
     async getOrCreateSessionClientFromRecord(session, options) {
-        return await this.runStartupOperation(session.id, async (stopGeneration) => {
-            this.assertStartupAllowed(session.id, stopGeneration);
-            const hadClient = !!this.runtimeManager.getClient(session.id);
-            const { handle, resolvedPreset, dispatchableNotificationCount } = await this.getOrCreateAcpSessionClient(session.id, options ?? {}, session, stopGeneration);
-            this.assertStartupAllowed(session.id, stopGeneration);
-            if (!hadClient) {
-                await this.applyConfiguredPermissionPreset(session.id, session, handle, resolvedPreset);
-                this.assertStartupAllowed(session.id, stopGeneration);
-                await this.dispatchQueuedNotificationsIfNeeded(session.id, dispatchableNotificationCount);
-                this.assertStartupAllowed(session.id, stopGeneration);
-            }
-            return handle;
-        });
+        this.assertConfigured();
+        return await this.dependencies.startupCoordinator.getOrCreateSessionClientFromRecord(session, options);
     }
     async ensureSubagentBrowseSession(sessionId) {
-        if (this.runtimeManager.getSubagentBrowseCapability(sessionId)) {
-            return true;
-        }
-        const pendingClient = this.runtimeManager.getPendingClient(sessionId);
-        if (pendingClient) {
-            try {
-                await pendingClient;
-            }
-            catch (error) {
-                if (error instanceof AcpBrowseSessionUnavailableError) {
-                    return false;
-                }
-                throw error;
-            }
-            return await this.resolveSubagentBrowseSupport(sessionId);
-        }
-        return await this.runStartupOperation(sessionId, async (stopGeneration) => {
-            const session = await this.repository.getSessionById(sessionId);
-            if (!(session?.provider === 'CODEX' && session.providerSessionId)) {
-                return false;
-            }
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            const workspace = await this.repository.getWorkspaceById(session.workspaceId);
-            if (!workspace?.worktreePath ||
-                workspace.status === 'ARCHIVING' ||
-                workspace.status === 'ARCHIVED') {
-                return false;
-            }
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            try {
-                await this.createAcpClient(sessionId, { purpose: 'browse' }, session, undefined, stopGeneration);
-            }
-            catch (error) {
-                if (error instanceof AcpBrowseSessionUnavailableError) {
-                    return false;
-                }
-                throw error;
-            }
-            return await this.resolveSubagentBrowseSupport(sessionId);
-        }).catch((error) => {
-            if (error instanceof SessionStartupCancelledError) {
-                return false;
-            }
-            throw error;
-        });
-    }
-    async resolveSubagentBrowseSupport(sessionId) {
-        if (this.runtimeManager.getSubagentBrowseCapability(sessionId) !== null) {
-            return true;
-        }
-        if (!this.runtimeManager.isBrowseOnlySession(sessionId)) {
-            return false;
-        }
-        this.advanceStopGeneration(sessionId);
-        try {
-            await this.runtimeManager.stopClient(sessionId);
-        }
-        finally {
-            this.acpEventProcessor.clearSessionState(sessionId);
-        }
-        return false;
+        this.assertConfigured();
+        return await this.dependencies.startupCoordinator.ensureSubagentBrowseSession(sessionId);
     }
     getSessionClient(sessionId) {
-        return this.runtimeManager.getClient(sessionId);
+        return this.dependencies.runtimeManager.getClient(sessionId);
     }
     getRuntimeSnapshot(sessionId) {
         const fallback = createInitialSessionRuntimeState();
-        const persisted = this.sessionDomainService.getRuntimeSnapshot(sessionId);
+        const persisted = this.dependencies.sessionDomainService.getRuntimeSnapshot(sessionId);
         const base = persisted ?? fallback;
-        const acpClient = this.runtimeManager.getClient(sessionId);
+        const acpClient = this.dependencies.runtimeManager.getClient(sessionId);
         if (acpClient) {
-            const isWorking = this.runtimeManager.isSessionWorking(sessionId);
+            const isWorking = this.dependencies.runtimeManager.isSessionWorking(sessionId);
             return {
                 phase: isWorking ? 'running' : 'idle',
                 processState: 'alive',
@@ -370,7 +61,7 @@ export class SessionLifecycleService {
                 updatedAt: base.updatedAt,
             };
         }
-        if (this.runtimeManager.isStopInProgress(sessionId)) {
+        if (this.dependencies.runtimeManager.isStopInProgress(sessionId)) {
             return {
                 ...base,
                 phase: 'stopping',
@@ -389,844 +80,32 @@ export class SessionLifecycleService {
         return base;
     }
     isSessionStopping(sessionId) {
-        return this.stoppingSessions.has(sessionId) || this.runtimeManager.isStopInProgress(sessionId);
+        return this.dependencies.lifecycleGate.isSessionStopping(sessionId);
     }
     getStopGeneration(sessionId) {
-        return this.stopGenerations.get(sessionId) ?? this.advanceStopGeneration(sessionId);
-    }
-    async runStartupOperation(sessionId, operation) {
-        const stopGeneration = this.getStopGeneration(sessionId);
-        this.startupGenerationReferences.set(stopGeneration, (this.startupGenerationReferences.get(stopGeneration) ?? 0) + 1);
-        let succeeded = false;
-        try {
-            const result = await operation(stopGeneration);
-            succeeded = true;
-            return result;
-        }
-        finally {
-            this.releaseStartupGeneration(sessionId, stopGeneration, succeeded);
-        }
-    }
-    releaseStartupGeneration(sessionId, stopGeneration, succeeded) {
-        const referenceCount = this.startupGenerationReferences.get(stopGeneration);
-        if (referenceCount === undefined) {
-            return;
-        }
-        if (referenceCount > 1) {
-            this.startupGenerationReferences.set(stopGeneration, referenceCount - 1);
-            return;
-        }
-        this.startupGenerationReferences.delete(stopGeneration);
-        if (!(succeeded ||
-            this.isSessionStopping(sessionId) ||
-            this.runtimeManager.getClient(sessionId)) &&
-            this.isStopGenerationCurrent(sessionId, stopGeneration)) {
-            this.stopGenerations.delete(sessionId);
-        }
+        return this.dependencies.lifecycleGate.getGeneration(sessionId);
     }
     isStopGenerationCurrent(sessionId, stopGeneration) {
-        return this.stopGenerations.get(sessionId) === stopGeneration;
-    }
-    advanceStopGeneration(sessionId) {
-        this.stopGenerationCounter += 1;
-        this.stopGenerations.set(sessionId, this.stopGenerationCounter);
-        return this.stopGenerationCounter;
+        return this.dependencies.lifecycleGate.isGenerationCurrent(sessionId, stopGeneration);
     }
-    assertStartupAllowed(sessionId, stopGeneration) {
-        if (this.isSessionStopping(sessionId) ||
-            !this.isStopGenerationCurrent(sessionId, stopGeneration)) {
-            throw new SessionStartupCancelledError();
-        }
-    }
-    async getSessionOptions(sessionId) {
-        const sessionContext = await this.loadSessionContext(sessionId);
-        if (!sessionContext) {
-            return null;
-        }
-        return {
-            workingDir: sessionContext.workingDir,
-            resumeProviderSessionId: sessionContext.resumeProviderSessionId,
-            systemPrompt: sessionContext.systemPrompt,
-            model: sessionContext.model,
-            workspaceStatus: sessionContext.workspaceStatus,
-        };
+    getSessionOptions(sessionId) {
+        return this.dependencies.contextService.getOptions(sessionId);
     }
     async stopAllClients(timeoutMs = 5000) {
-        this.promptTurnCompletionService.clearAll();
-        const shutdownSessionIds = this.runtimeManager.beginShutdown();
-        const activeShutdownSessionIds = shutdownSessionIds.filter((sessionId) => !this.runtimeManager.isBrowseOnlySession(sessionId));
-        for (const sessionId of activeShutdownSessionIds) {
-            this.shutdownSessions.add(sessionId);
-        }
-        await this.recordShutdownLifecycleEvents(activeShutdownSessionIds);
-        try {
-            await this.runtimeManager.stopAllClients(timeoutMs);
-        }
-        catch (error) {
-            logger.error('Failed to stop ACP clients during shutdown', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
-        }
+        this.assertConfigured();
+        await this.dependencies.terminationCoordinator.stopAllClients(timeoutMs);
     }
-    async recordShutdownLifecycleEvent(sessionId) {
-        const session = await this.loadSessionForStop(sessionId);
-        const workspaceId = session?.workspaceId ?? this.acpEventProcessor.getWorkspaceId(sessionId);
-        if (!workspaceId) {
-            logger.warn('Skipped shutdown lifecycle event without workspace owner', { sessionId });
-            return;
-        }
-        await this.lifecycleEventService.record({
-            workspaceId,
-            sessionId,
-            kind: SessionLifecycleEventKind.SESSION_STOPPED,
-            reason: SessionLifecycleEventReason.SYSTEM_STOP,
-            message: SESSION_STOP_MESSAGES.SYSTEM_STOP,
-            dedupeKey: `session-stop:${randomUUID()}`,
-        });
+    persistClosedSession(sessionId) {
+        this.assertConfigured();
+        return this.dependencies.workflowFinalizer.persistClosedSession(sessionId);
     }
-    async recordShutdownLifecycleEvents(sessionIds) {
-        const resultsPromise = Promise.allSettled(sessionIds.map((sessionId) => this.recordShutdownLifecycleEvent(sessionId)));
-        let timeout;
-        const results = await Promise.race([
-            resultsPromise,
-            new Promise((resolve) => {
-                timeout = setTimeout(() => resolve(null), SHUTDOWN_LIFECYCLE_RECORD_TIMEOUT_MS);
-            }),
-        ]);
-        if (timeout) {
-            clearTimeout(timeout);
-        }
-        if (results === null) {
-            logger.warn('Timed out recording shutdown lifecycle events; continuing shutdown', {
-                timeoutMs: SHUTDOWN_LIFECYCLE_RECORD_TIMEOUT_MS,
-            });
-            return;
-        }
-        for (const [index, result] of results.entries()) {
-            if (result.status === 'rejected') {
-                logger.warn('Failed recording shutdown lifecycle event; continuing shutdown', {
-                    sessionId: sessionIds[index],
-                    error: result.reason instanceof Error ? result.reason.message : String(result.reason),
-                });
-            }
-        }
-    }
-    setupAcpEventHandler(sessionId, options) {
-        const runtimeEventHandler = this.acpEventProcessor.createRuntimeEventHandler(sessionId);
-        const runtimeIncarnationId = randomUUID();
-        const providerSessionIdHandler = options?.persistProviderSessionId === false
-            ? {}
-            : {
-                onSessionId: async (sid, providerSessionId) => {
-                    try {
-                        await this.repository.updateSession(sid, { providerSessionId });
-                        acpTraceLogger.log(sid, 'runtime_metadata', {
-                            type: 'provider_session_id',
-                            providerSessionId,
-                        });
-                        logger.debug('Updated session with ACP providerSessionId', {
-                            sessionId: sid,
-                            providerSessionId,
-                        });
-                    }
-                    catch (error) {
-                        logger.warn('Failed to update session with ACP providerSessionId', {
-                            sessionId: sid,
-                            providerSessionId,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    }
-                },
-            };
-        return {
-            ...runtimeEventHandler,
-            ...providerSessionIdHandler,
-            onExit: async (sid, exitCode) => {
-                this.stopGenerations.delete(sid);
-                if (this.runtimeManager.isBrowseOnlySession(sid)) {
-                    this.acpEventProcessor.clearSessionState(sid);
-                    acpTraceLogger.closeSession(sid);
-                    return;
-                }
-                const wasDeliberateStop = this.stoppingSessions.has(sid) ||
-                    this.shutdownSessions.has(sid) ||
-                    this.runtimeManager.isStopInProgress(sid);
-                this.prepareAcpRuntimeExit(sid, exitCode);
-                await this.handleAcpRuntimeExit(sid, exitCode, wasDeliberateStop, runtimeIncarnationId);
-            },
-            onError: (sid, error) => {
-                acpTraceLogger.log(sid, 'runtime_error', {
-                    message: error.message,
-                    stack: error.stack,
-                });
-                if (!this.runtimeManager.isBrowseOnlySession(sid)) {
-                    this.sessionDomainService.markError(sid, error.message);
-                }
-                logger.error('ACP client error', {
-                    sessionId: sid,
-                    error: error.message,
-                    stack: error.stack,
-                });
-            },
-            onAcpLog: (sid, payload) => {
-                this.acpEventProcessor.handleAcpLog(sid, payload);
-            },
-        };
-    }
-    prepareAcpRuntimeExit(sessionId, exitCode) {
-        this.promptTurnCompletionService.clearSession(sessionId);
-        this.onSessionExit?.(sessionId);
-        this.finalizeOrphanedToolCalls(sessionId, 'runtime_exit');
-        this.acpEventProcessor.clearSessionState(sessionId);
-        this.sessionPermissionService.cancelPendingRequests(sessionId);
-        acpTraceLogger.log(sessionId, 'runtime_exit', { exitCode });
-    }
-    async handleAcpRuntimeExit(sessionId, exitCode, wasDeliberateStop, runtimeIncarnationId) {
-        try {
-            this.sessionDomainService.markProcessExit(sessionId, exitCode);
-            const session = await this.repository.getSessionById(sessionId);
-            if (!session) {
-                logger.warn('Failed to find ACP session on exit', { sessionId });
-                return;
-            }
-            const persistedStatus = getPersistedStatusForExitCode(exitCode);
-            try {
-                await this.repository.updateSession(sessionId, { status: persistedStatus });
-                logger.debug('Updated ACP session status on exit', {
-                    sessionId,
-                    exitCode,
-                    status: persistedStatus,
-                });
-            }
-            catch (error) {
-                logger.warn('Failed to update ACP session status on exit', {
-                    sessionId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-            await this.recordUnexpectedExitIfNeeded(session, sessionId, exitCode, wasDeliberateStop, runtimeIncarnationId);
-            await this.recordRatchetSessionEndOnExit(session.workspaceId, sessionId, exitCode);
-            void this.maybeDiscoverPROnSessionEnd(session.workspaceId);
-            await this.cleanupExitedWorkflow(session, sessionId, wasDeliberateStop);
-        }
-        catch (error) {
-            logger.warn('Failed to process ACP session exit', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        finally {
-            try {
-                this.clearSessionStoreIfInactive(sessionId, 'runtime_exit');
-            }
-            finally {
-                acpTraceLogger.closeSession(sessionId);
-            }
-        }
+    recoverStaleRunningSessions() {
+        this.assertConfigured();
+        return this.dependencies.workflowFinalizer.recoverStaleRunningSessions();
     }
-    async recordUnexpectedExitIfNeeded(session, sessionId, exitCode, wasDeliberateStop, runtimeIncarnationId) {
-        if (wasDeliberateStop) {
-            return;
-        }
-        await this.lifecycleEventService.record({
-            workspaceId: session.workspaceId,
-            sessionId,
-            kind: SessionLifecycleEventKind.SESSION_STOPPED,
-            reason: SessionLifecycleEventReason.UNEXPECTED_EXIT,
-            message: exitCode === null
-                ? 'Session stopped: agent process exited unexpectedly.'
-                : `Session stopped: agent process exited unexpectedly (code ${exitCode}).`,
-            dedupeKey: `process-exit:${runtimeIncarnationId}:${exitCode ?? 'signal'}`,
-        });
-    }
-    async cleanupExitedWorkflow(session, sessionId, wasDeliberateStop) {
-        if (session.workflow === 'ratchet') {
-            await this.persistRatchetTranscript(sessionId);
-            await this.repository.deleteSession(sessionId);
-            this.sessionDomainService.clearSession(sessionId);
-            logger.debug('Deleted transient ratchet ACP session', { sessionId });
-        }
-        if (session.workflow === 'auto-iteration' &&
-            this.autoIterationExitBridge &&
-            !wasDeliberateStop) {
-            this.autoIterationExitBridge.onAutoIterationSessionExit(session.workspaceId, sessionId);
-        }
-    }
-    async createAcpClient(sessionId, options, session, permissionPreset, stopGeneration = this.getStopGeneration(sessionId)) {
-        const sessionContext = await this.loadSessionContext(sessionId, session);
-        if (!sessionContext) {
-            throw new Error(`Session context not ready: ${sessionId}`);
-        }
-        this.assertStartupAllowed(sessionId, stopGeneration);
-        const browseOnly = options?.purpose === 'browse';
-        if (!browseOnly) {
-            await this.repository.markWorkspaceHasHadSessions(sessionContext.workspaceId);
-            this.assertStartupAllowed(sessionId, stopGeneration);
-        }
-        this.acpEventProcessor.registerSessionContext(sessionId, {
-            workspaceId: sessionContext.workspaceId,
-            workingDir: sessionContext.workingDir,
-            provider: session?.provider ?? 'CLAUDE',
-        });
-        const handlers = this.setupAcpEventHandler(sessionId, {
-            persistProviderSessionId: !browseOnly,
-        });
-        const shouldSuppressReplay = this.shouldSuppressReplayDuringAcpResume(sessionId, session);
-        this.acpEventProcessor.setReplaySuppression(sessionId, shouldSuppressReplay);
-        const apiPort = String(configService.getBackendPort());
-        const mcpServerConfig = getChildWorkspaceMcpServerConfig({
-            workspaceId: sessionContext.workspaceId,
-            parentWorkspaceId: sessionContext.parentWorkspaceId ?? null,
-            apiBaseUrl: `http://localhost:${apiPort}`,
-        });
-        const clientOptions = {
-            provider: session?.provider ?? 'CLAUDE',
-            purpose: options?.purpose,
-            workingDir: sessionContext.workingDir,
-            model: options?.model ?? sessionContext.model,
-            systemPrompt: sessionContext.systemPrompt,
-            permissionPreset,
-            sessionId,
-            resumeProviderSessionId: session?.providerSessionId ?? undefined,
-            mcpServers: [mcpServerConfig],
-        };
-        let handle;
-        this.assertStartupAllowed(sessionId, stopGeneration);
-        const creationPromise = this.runtimeManager.getOrCreateClient(sessionId, clientOptions, handlers, {
-            workspaceId: sessionContext.workspaceId,
-            workingDir: sessionContext.workingDir,
-        });
-        const sessionCreations = this.clientCreationOperations.get(sessionId) ?? new Set();
-        sessionCreations.add(creationPromise);
-        this.clientCreationOperations.set(sessionId, sessionCreations);
-        try {
-            handle = await creationPromise;
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            if (browseOnly) {
-                return { handle, dispatchableNotificationCount: 0 };
-            }
-            await this.sessionConfigService.applyConfiguredReasoningEffort(sessionId, handle, {
-                persistSnapshot: false,
-                emitUpdates: false,
-            });
-        }
-        catch (error) {
-            this.clearAcpSessionStateAfterFailedCreation(sessionId, sessionCreations);
-            throw error;
-        }
-        finally {
-            sessionCreations.delete(creationPromise);
-            if (sessionCreations.size === 0) {
-                this.clientCreationOperations.delete(sessionId);
-            }
-        }
-        this.assertStartupAllowed(sessionId, stopGeneration);
-        await this.persistAcpConfigSnapshot(sessionId, {
-            provider: handle.provider,
-            providerSessionId: handle.providerSessionId,
-            configOptions: handle.configOptions,
-            existingMetadata: session?.providerMetadata ?? undefined,
-        });
-        if (handle.configOptions.length > 0) {
-            this.sessionDomainService.emitDelta(sessionId, {
-                type: 'config_options_update',
-                configOptions: handle.configOptions,
-            });
-        }
-        this.sessionDomainService.emitDelta(sessionId, {
-            type: 'chat_capabilities',
-            capabilities: this.buildAcpChatBarCapabilities(handle),
-        });
-        this.assertStartupAllowed(sessionId, stopGeneration);
-        const dispatchableNotificationCount = await this.deliverPendingChildNotifications(sessionId, sessionContext.workspaceId, stopGeneration);
-        return { handle, dispatchableNotificationCount };
-    }
-    clearAcpSessionStateAfterFailedCreation(sessionId, sessionCreations) {
-        if (sessionCreations.size === 1) {
-            this.acpEventProcessor.clearSessionState(sessionId);
-        }
-    }
-    shouldSuppressReplayDuringAcpResume(sessionId, session) {
-        if (!session?.providerSessionId) {
-            return false;
-        }
-        if (!this.sessionDomainService.isHistoryHydrated(sessionId)) {
-            return false;
-        }
-        return this.sessionDomainService.getTranscriptSnapshot(sessionId).length > 0;
-    }
-    async applyStartupModePreset(sessionId, handle, startupModePreset, workflow) {
-        await this.sessionConfigService.applyStartupModePreset(sessionId, handle, startupModePreset, workflow, {
-            persistSnapshot: this.persistAcpConfigSnapshot.bind(this),
-        });
-    }
-    async applyConfiguredPermissionPreset(sessionId, session, handle, permissionPreset) {
-        await this.sessionConfigService.applyConfiguredPermissionPreset(sessionId, session, handle, permissionPreset);
-    }
-    finalizeOrphanedToolCalls(sessionId, reason) {
-        try {
-            this.acpEventProcessor.finalizeOrphanedToolCalls(sessionId, reason);
-        }
-        catch (error) {
-            logger.warn('Failed finalizing orphaned ACP tool calls', {
-                sessionId,
-                reason,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            this.acpEventProcessor.clearPendingToolCalls(sessionId);
-        }
-    }
-    markWorkspaceSessionIdleOnStop(workspaceId, sessionId) {
-        if (!(workspaceId && this.workspaceBridge)) {
-            return;
-        }
-        try {
-            this.workspaceBridge.markSessionIdle(workspaceId, sessionId);
-        }
-        catch (error) {
-            logger.warn('Failed to mark workspace session idle during stop', {
-                sessionId,
-                workspaceId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async loadSessionForStop(sessionId) {
-        try {
-            return await this.retryService.run(() => this.repository.getSessionById(sessionId), {
-                attempts: 2,
-                operationName: 'loadSessionForStop',
-                context: { sessionId },
-            });
-        }
-        catch (error) {
-            logger.warn('Failed to load session before stop; continuing with process shutdown', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return null;
-        }
-    }
-    async updateStoppedSessionState(sessionId) {
-        try {
-            await this.retryService.run(() => this.repository.updateSessionIfStatus(sessionId, {
-                status: SessionStatus.IDLE,
-            }, [SessionStatus.RUNNING]), {
-                attempts: 2,
-                operationName: 'updateStoppedSessionState',
-                context: { sessionId },
-            });
-        }
-        catch (error) {
-            logger.warn('Failed to update session state during stop; continuing cleanup', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async cleanupTransientRatchetOnStop(session, sessionId, shouldCleanupTransientRatchetSession) {
-        if (session?.workflow !== 'ratchet') {
-            return;
-        }
-        try {
-            await this.recordRatchetSessionEnd(session.workspaceId, sessionId, 'COMPLETED');
-        }
-        catch (error) {
-            logger.warn('Failed settling ratchet dispatch record during stop', {
-                sessionId,
-                workspaceId: session.workspaceId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        if (!shouldCleanupTransientRatchetSession) {
-            return;
-        }
-        try {
-            await this.persistRatchetTranscript(sessionId);
-            await this.repository.deleteSession(sessionId);
-            this.sessionDomainService.clearSession(sessionId);
-            logger.debug('Deleted transient ratchet session after stop', { sessionId });
-        }
-        catch (error) {
-            logger.warn('Failed persisting or deleting transient ratchet session during stop', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async recordRatchetSessionEnd(workspaceId, sessionId, outcome) {
-        if (!this.workspaceBridge) {
-            return;
-        }
-        await this.workspaceBridge.recordRatchetSessionEnd(workspaceId, sessionId, outcome);
-    }
-    async recordRatchetSessionEndOnExit(workspaceId, sessionId, exitCode) {
-        const outcome = exitCode === 0 || this.runtimeManager.isStopInProgress(sessionId) ? 'COMPLETED' : 'DIED';
-        await this.recordRatchetSessionEnd(workspaceId, sessionId, outcome);
-    }
-    async maybeDiscoverPROnSessionEnd(workspaceId) {
-        if (!this.workspaceBridge) {
-            return;
-        }
-        await maybeDiscoverPROnSessionEndHelper(workspaceId, logger, this.workspaceBridge);
-    }
-    clearSessionStoreIfInactive(sessionId, reason) {
-        if (this.runtimeManager.isSessionRunning(sessionId) ||
-            sessionEventBus.countViewers(sessionId) > 0) {
-            return;
-        }
-        this.sessionDomainService.clearSession(sessionId, { preserveRejections: true });
-        logger.debug('Cleared inactive in-memory session state', { sessionId, reason });
-    }
-    async persistClosedSession(sessionId) {
-        const session = await this.repository.getSessionById(sessionId);
-        if (!session) {
-            logger.warn('Cannot persist closed session: session not found', { sessionId });
-            return;
-        }
-        const workspace = await workspaceDataService.findById(session.workspaceId);
-        if (!workspace?.worktreePath) {
-            logger.warn('Cannot persist closed session: no worktree path', {
-                sessionId,
-                workspaceId: session.workspaceId,
-            });
-            return;
-        }
-        await this.hydrateProviderHistory(sessionId, {
-            ...session,
-            workspace: { worktreePath: workspace.worktreePath },
-        });
-        await this.lifecycleEventService.hydrate(sessionId);
-        const transcript = this.sessionDomainService.getTranscriptSnapshot(sessionId);
-        await closedSessionPersistenceService.persistClosedSession({
-            sessionId,
-            workspaceId: session.workspaceId,
-            worktreePath: workspace.worktreePath,
-            name: session.name,
-            workflow: session.workflow,
-            provider: session.provider,
-            model: session.model,
-            startedAt: session.createdAt,
-            messages: transcript,
-        });
-    }
-    async persistRatchetTranscript(sessionId) {
-        await this.persistClosedSession(sessionId);
-    }
-    async getOrCreateAcpSessionClient(sessionId, options, session, stopGeneration) {
-        this.assertStartupAllowed(sessionId, stopGeneration);
-        const existingAcp = this.runtimeManager.getClient(sessionId);
-        if (existingAcp) {
-            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
-                phase: existingAcp.isPromptInFlight ? 'running' : 'idle',
-                processState: 'alive',
-                activity: existingAcp.isPromptInFlight ? 'WORKING' : 'IDLE',
-                updatedAt: new Date().toISOString(),
-            });
-            return { handle: existingAcp, dispatchableNotificationCount: 0 };
-        }
-        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
-            phase: 'starting',
-            processState: 'alive',
-            activity: 'IDLE',
-            updatedAt: new Date().toISOString(),
-        });
-        const resolvedPreset = await this.resolvePermissionPreset(session);
-        this.assertStartupAllowed(sessionId, stopGeneration);
-        let handle;
-        let dispatchableNotificationCount = 0;
-        try {
-            const created = await this.createAcpClient(sessionId, options, session, resolvedPreset, stopGeneration);
-            handle = created.handle;
-            dispatchableNotificationCount = created.dispatchableNotificationCount;
-        }
-        catch (error) {
-            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
-                phase: 'error',
-                processState: 'stopped',
-                activity: 'IDLE',
-                errorMessage: `Failed to start agent: ${toErrorMessage(error)}`,
-                updatedAt: new Date().toISOString(),
-            });
-            throw error;
-        }
-        this.assertStartupAllowed(sessionId, stopGeneration);
-        await this.repository.updateSession(sessionId, {
-            status: SessionStatus.RUNNING,
-        });
-        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
-            phase: handle.isPromptInFlight ? 'running' : 'idle',
-            processState: 'alive',
-            activity: handle.isPromptInFlight ? 'WORKING' : 'IDLE',
-            updatedAt: new Date().toISOString(),
-        });
-        return { handle, resolvedPreset, dispatchableNotificationCount };
-    }
-    async dispatchQueuedNotificationsIfNeeded(sessionId, dispatchableNotificationCount) {
-        if (dispatchableNotificationCount === 0 || !this.messageQueueBridge) {
-            return;
-        }
-        try {
-            await this.messageQueueBridge.tryDispatchNextMessage(sessionId);
-        }
-        catch (error) {
-            logger.warn('Failed to dispatch queued workspace notifications', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async persistAcpConfigSnapshot(sessionId, params) {
-        await this.sessionConfigService.persistAcpConfigSnapshot(sessionId, params);
-    }
-    buildAcpChatBarCapabilities(handle) {
-        return this.sessionConfigService.buildAcpChatBarCapabilities(handle);
-    }
-    async loadSessionContext(sessionId, preloadedSession) {
-        const session = preloadedSession ?? (await this.repository.getSessionById(sessionId));
-        if (!session) {
-            logger.warn('Session not found when getting options', { sessionId });
-            return null;
-        }
-        const workspace = await this.repository.getWorkspaceById(session.workspaceId);
-        if (!workspace?.worktreePath) {
-            logger.warn('Workspace or worktree not found', {
-                sessionId,
-                workspaceId: session.workspaceId,
-            });
-            return null;
-        }
-        const shouldInjectBranchRename = this.promptBuilder.shouldInjectBranchRename({
-            branchName: workspace.branchName,
-            isAutoGeneratedBranch: workspace.isAutoGeneratedBranch,
-            hasHadSessions: workspace.hasHadSessions,
-        });
-        const project = shouldInjectBranchRename
-            ? await this.repository.getProjectById(workspace.projectId)
-            : null;
-        if (shouldInjectBranchRename && !project) {
-            logger.warn('Project not found when building branch rename instruction', {
-                sessionId,
-                projectId: workspace.projectId,
-            });
-        }
-        const parentCtx = await this.resolveParentWorkspaceContext(workspace);
-        const { workflowPrompt, systemPrompt, injectedBranchRename } = this.promptBuilder.buildSystemPrompt({
-            workflow: session.workflow,
-            workspace: {
-                branchName: workspace.branchName,
-                isAutoGeneratedBranch: workspace.isAutoGeneratedBranch,
-                hasHadSessions: workspace.hasHadSessions,
-                name: workspace.name,
-                description: workspace.description ?? undefined,
-                runScriptPort: workspace.runScriptPort,
-                parentWorkspaceId: workspace.parentWorkspaceId,
-                parentWorkspaceName: parentCtx.parentWorkspaceName,
-                parentProjectName: parentCtx.parentProjectName,
-                reportBackOn: parentCtx.reportBackOn,
-            },
-            project,
-        });
-        logger.info('Loaded workflow prompt for session options', {
-            sessionId,
-            workflow: session.workflow,
-            hasPrompt: !!workflowPrompt,
-            promptLength: workflowPrompt?.length ?? 0,
-        });
-        if (injectedBranchRename) {
-            logger.info('Injected branch rename instruction', {
-                sessionId,
-                branchName: workspace.branchName,
-                branchPrefix: project?.githubOwner,
-            });
-        }
-        return {
-            workingDir: workspace.worktreePath,
-            resumeProviderSessionId: session.providerSessionId ?? undefined,
-            systemPrompt,
-            model: session.model,
-            workspaceId: workspace.id,
-            workspaceStatus: workspace.status,
-            parentWorkspaceId: workspace.parentWorkspaceId,
-        };
-    }
-    async deliverPendingChildNotifications(sessionId, workspaceId, stopGeneration = this.getStopGeneration(sessionId)) {
-        try {
-            const pending = await workspaceNotificationService.listPendingForDelivery(workspaceId);
-            this.assertStartupAllowed(sessionId, stopGeneration);
-            if (pending.length === 0) {
-                return 0;
-            }
-            if (!this.messageQueueBridge) {
-                logger.warn('Cannot deliver pending workspace notifications: message queue bridge missing', {
-                    sessionId,
-                    workspaceId,
-                    count: pending.length,
-                });
-                return 0;
-            }
-            let enqueuedCount = 0;
-            let dispatchableCount = 0;
-            const consumedContentMatchIds = new Set();
-            for (const notification of pending) {
-                this.assertStartupAllowed(sessionId, stopGeneration);
-                const timestamp = notification.createdAt.toISOString();
-                const messageId = workspaceNotificationMessageId(notification.id);
-                if (this.sessionDomainService.hasQueuedMessage(sessionId, messageId)) {
-                    dispatchableCount += 1;
-                    continue;
-                }
-                let claudeMessage;
-                if (notification.direction === 'PARENT_TO_CHILD') {
-                    claudeMessage = {
-                        type: 'parent_workspace_update',
-                        parentWorkspaceId: notification.sourceWorkspaceId,
-                        parentWorkspaceName: notification.sourceWorkspaceName,
-                        parentProjectName: notification.sourceProjectName,
-                        text: notification.message,
-                        timestamp,
-                    };
-                }
-                else {
-                    claudeMessage = {
-                        type: 'child_workspace_update',
-                        childWorkspaceId: notification.sourceWorkspaceId,
-                        childWorkspaceName: notification.sourceWorkspaceName,
-                        childProjectName: notification.sourceProjectName,
-                        text: notification.message,
-                        timestamp,
-                    };
-                }
-                const enqueueText = buildWorkspaceNotificationMessageText(notification);
-                const alreadyDelivered = await this.markDeliveredIfTranscriptMatch(sessionId, workspaceId, notification.id, messageId, enqueueText, consumedContentMatchIds);
-                this.assertStartupAllowed(sessionId, stopGeneration);
-                if (alreadyDelivered) {
-                    continue;
-                }
-                if (this.sessionDomainService.hasQueuedMessage(sessionId, messageId)) {
-                    dispatchableCount += 1;
-                    continue;
-                }
-                const enqueueResult = this.sessionDomainService.enqueue(sessionId, {
-                    id: messageId,
-                    text: enqueueText,
-                    timestamp,
-                    settings: {
-                        selectedModel: null,
-                        reasoningEffort: null,
-                        thinkingEnabled: false,
-                        planModeEnabled: false,
-                    },
-                });
-                if ('error' in enqueueResult) {
-                    logger.warn('Failed to enqueue pending workspace notification', {
-                        sessionId,
-                        workspaceId,
-                        notificationId: notification.id,
-                        error: enqueueResult.error,
-                    });
-                    continue;
-                }
-                enqueuedCount += 1;
-                dispatchableCount += 1;
-                const order = this.sessionDomainService.appendClaudeEvent(sessionId, claudeMessage);
-                this.sessionDomainService.emitDelta(sessionId, {
-                    type: 'agent_message',
-                    data: claudeMessage,
-                    order,
-                });
-            }
-            logger.info('Queued pending workspace notifications', {
-                sessionId,
-                workspaceId,
-                count: enqueuedCount,
-                dispatchableCount,
-            });
-            return dispatchableCount;
-        }
-        catch (error) {
-            logger.warn('Failed to deliver pending workspace notifications', {
-                sessionId,
-                workspaceId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return 0;
-        }
-    }
-    findCommittedQueuedWorkspaceNotificationMessage(sessionId, messageId, messageText, consumedContentMatchIds) {
-        const userEntries = this.sessionDomainService
-            .getTranscriptSnapshot(sessionId)
-            .filter((entry) => entry.source === 'user');
-        const exactIdMatch = userEntries.find((entry) => entry.id === messageId);
-        if (exactIdMatch) {
-            return { id: exactIdMatch.id, matchedByContent: false };
-        }
-        if (this.sessionDomainService.getHistoryHydrationSource(sessionId) !== 'jsonl') {
-            return undefined;
-        }
-        const contentMatch = userEntries.find((entry) => !entry.id.startsWith(WORKSPACE_NOTIFICATION_MESSAGE_ID_PREFIX) &&
-            entry.text === messageText &&
-            !consumedContentMatchIds.has(entry.id));
-        if (contentMatch) {
-            return { id: contentMatch.id, matchedByContent: true };
-        }
-        return undefined;
-    }
-    async markDeliveredIfTranscriptMatch(sessionId, workspaceId, notificationId, messageId, messageText, consumedContentMatchIds) {
-        const committedMessage = this.findCommittedQueuedWorkspaceNotificationMessage(sessionId, messageId, messageText, consumedContentMatchIds);
-        if (!committedMessage) {
-            return false;
-        }
-        if (committedMessage.matchedByContent) {
-            consumedContentMatchIds.add(committedMessage.id);
-        }
-        await this.markDeliveredAfterTranscriptMatch(sessionId, workspaceId, notificationId);
-        return true;
-    }
-    async markDeliveredAfterTranscriptMatch(sessionId, workspaceId, notificationId) {
-        try {
-            await workspaceNotificationService.markDelivered([notificationId]);
-        }
-        catch (error) {
-            logger.warn('Failed to mark already-transcripted workspace notification delivered', {
-                sessionId,
-                workspaceId,
-                notificationId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async resolveParentWorkspaceContext(workspace) {
-        if (!workspace.parentWorkspaceId) {
-            return {};
-        }
-        let parentWorkspaceName;
-        let parentProjectName;
-        const parentWorkspace = await this.repository.getWorkspaceById(workspace.parentWorkspaceId);
-        if (parentWorkspace) {
-            parentWorkspaceName = parentWorkspace.name;
-            const parentProject = await this.repository.getProjectById(parentWorkspace.projectId);
-            parentProjectName = parentProject?.name;
-        }
-        const metadata = workspace.creationMetadata;
-        const reportBackOn = typeof metadata?.reportBackOn === 'string' ? metadata.reportBackOn : undefined;
-        return { parentWorkspaceName, parentProjectName, reportBackOn };
-    }
-    async resolvePermissionPreset(session) {
-        const fallback = session?.workflow === 'ratchet' ? 'YOLO' : 'STRICT';
-        try {
-            const settings = await userSettingsService.get();
-            return session?.workflow === 'ratchet'
-                ? settings.ratchetPermissions
-                : settings.defaultWorkspacePermissions;
-        }
-        catch (error) {
-            logger.warn('Failed loading user permission preset; using default', {
-                workflow: session?.workflow,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return fallback;
+    assertConfigured() {
+        if (!this.configured) {
+            throw new Error('SessionLifecycleService not configured: lifecycle bridges missing');
         }
     }
 }