factory-factory 0.3.8 → 0.3.10

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

@@ -0,0 +1,644 @@
+import { createLogger } from '../../../../../backend/services/logger.service.js';
+import { chatConnectionService } from '../../../../../backend/services/session/service/chat/chat-connection.service.js';
+import { acpTraceLogger } from '../../../../../backend/services/session/service/logging/acp-trace-logger.service.js';
+import { userSettingsAccessor } from '../../../../../backend/services/settings/index.js';
+import { workspaceAccessor } from '../../../../../backend/services/workspace/index.js';
+import { SessionStatus } from '../../../../../shared/core/index.js';
+import { createInitialSessionRuntimeState, } from '../../../../../shared/session-runtime.js';
+import { closedSessionPersistenceService } from './closed-session-persistence.service.js';
+import { toErrorMessage } from './session.error-message.js';
+const logger = createLogger('session');
+const STALE_LOADING_RUNTIME_MAX_AGE_MS = 30_000;
+export class SessionLifecycleService {
+    repository;
+    promptBuilder;
+    runtimeManager;
+    sessionDomainService;
+    sessionPermissionService;
+    sessionConfigService;
+    acpEventProcessor;
+    promptTurnCompletionService;
+    retryService;
+    workspaceBridge = 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;
+    }
+    configure(bridges) {
+        this.workspaceBridge = bridges.workspace;
+    }
+    async startSession(sessionId, sendSessionMessage, options) {
+        const session = await this.repository.getSessionById(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        if (this.runtimeManager.isStopInProgress(sessionId)) {
+            throw new Error('Session is currently being stopped');
+        }
+        const existingClient = this.runtimeManager.getClient(sessionId);
+        if (existingClient) {
+            throw new Error('Session is already running');
+        }
+        const startupModePreset = options?.startupModePreset;
+        const { handle, resolvedPreset } = await this.getOrCreateAcpSessionClient(sessionId, {}, session);
+        await this.applyStartupModePreset(sessionId, handle, startupModePreset, session.workflow);
+        await this.applyConfiguredPermissionPreset(sessionId, session, handle, resolvedPreset);
+        const initialPrompt = options?.initialPrompt ?? 'Continue with the task.';
+        if (initialPrompt) {
+            await sendSessionMessage(sessionId, initialPrompt);
+        }
+        logger.info('Session started', { sessionId, provider: session.provider });
+    }
+    async restartSession(sessionId, sendSessionMessage) {
+        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, sendSessionMessage, {
+            initialPrompt: 'Continue with the task.',
+        });
+        logger.info('Session restarted', { sessionId });
+    }
+    async stopSession(sessionId, options) {
+        this.promptTurnCompletionService.clearSession(sessionId);
+        const session = await this.loadSessionForStop(sessionId);
+        const workspaceId = session?.workspaceId ?? this.acpEventProcessor.getWorkspaceId(sessionId);
+        if (this.runtimeManager.isStopInProgress(sessionId)) {
+            logger.debug('Session stop already in progress', { sessionId });
+            return;
+        }
+        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 {
+            if (!this.runtimeManager.isStopInProgress(sessionId)) {
+                await this.runtimeManager.stopClient(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.finalizeOrphanedToolCallsOnStop(sessionId);
+            await this.updateStoppedSessionState(sessionId);
+            this.sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: true });
+            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
+                phase: 'idle',
+                processState: 'stopped',
+                activity: 'IDLE',
+                updatedAt: new Date().toISOString(),
+            });
+            this.markWorkspaceSessionIdleOnStop(workspaceId, sessionId);
+            this.acpEventProcessor.clearSessionContext(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 stopWorkspaceSessions(workspaceId) {
+        const sessions = await this.repository.getSessionsByWorkspaceId(workspaceId);
+        for (const session of sessions) {
+            if (session.status === SessionStatus.RUNNING ||
+                this.runtimeManager.isSessionRunning(session.id)) {
+                try {
+                    await this.stopSession(session.id);
+                }
+                catch (error) {
+                    logger.error('Failed to stop workspace session', {
+                        sessionId: session.id,
+                        workspaceId,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+        logger.info('Stopped all workspace sessions', { workspaceId, count: sessions.length });
+    }
+    async getOrCreateSessionClient(sessionId, options) {
+        const session = await this.repository.getSessionById(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const hadClient = !!this.runtimeManager.getClient(sessionId);
+        const { handle, resolvedPreset } = await this.getOrCreateAcpSessionClient(sessionId, options ?? {}, session);
+        if (!hadClient) {
+            await this.applyConfiguredPermissionPreset(sessionId, session, handle, resolvedPreset);
+        }
+        return handle;
+    }
+    async getOrCreateSessionClientFromRecord(session, options) {
+        const hadClient = !!this.runtimeManager.getClient(session.id);
+        const { handle, resolvedPreset } = await this.getOrCreateAcpSessionClient(session.id, options ?? {}, session);
+        if (!hadClient) {
+            await this.applyConfiguredPermissionPreset(session.id, session, handle, resolvedPreset);
+        }
+        return handle;
+    }
+    getSessionClient(sessionId) {
+        return this.runtimeManager.getClient(sessionId);
+    }
+    getRuntimeSnapshot(sessionId) {
+        const fallback = createInitialSessionRuntimeState();
+        const persisted = this.sessionDomainService.getRuntimeSnapshot(sessionId);
+        const base = persisted ?? fallback;
+        const acpClient = this.runtimeManager.getClient(sessionId);
+        if (acpClient) {
+            const isWorking = this.runtimeManager.isSessionWorking(sessionId);
+            return {
+                phase: isWorking ? 'running' : 'idle',
+                processState: 'alive',
+                activity: isWorking ? 'WORKING' : 'IDLE',
+                updatedAt: base.updatedAt,
+            };
+        }
+        if (this.runtimeManager.isStopInProgress(sessionId)) {
+            return {
+                ...base,
+                phase: 'stopping',
+                updatedAt: base.updatedAt,
+            };
+        }
+        if (this.isStaleLoadingRuntime(base)) {
+            return {
+                ...base,
+                phase: 'idle',
+                processState: 'stopped',
+                activity: 'IDLE',
+                updatedAt: base.updatedAt,
+            };
+        }
+        return base;
+    }
+    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,
+        };
+    }
+    async stopAllClients(timeoutMs = 5000) {
+        this.promptTurnCompletionService.clearAll();
+        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;
+        }
+    }
+    isStaleLoadingRuntime(runtime) {
+        if (runtime.phase !== 'loading' || runtime.processState === 'alive') {
+            return false;
+        }
+        const updatedAtMs = Date.parse(runtime.updatedAt);
+        if (Number.isNaN(updatedAtMs)) {
+            return false;
+        }
+        return Date.now() - updatedAtMs > STALE_LOADING_RUNTIME_MAX_AGE_MS;
+    }
+    setupAcpEventHandler(sessionId) {
+        const runtimeEventHandler = this.acpEventProcessor.createRuntimeEventHandler(sessionId);
+        return {
+            ...runtimeEventHandler,
+            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),
+                    });
+                }
+            },
+            onExit: async (sid, exitCode) => {
+                this.promptTurnCompletionService.clearSession(sid);
+                this.acpEventProcessor.clearSessionState(sid);
+                this.sessionPermissionService.cancelPendingRequests(sid);
+                acpTraceLogger.log(sid, 'runtime_exit', { exitCode });
+                try {
+                    this.sessionDomainService.markProcessExit(sid, exitCode);
+                    const session = await this.repository.updateSession(sid, {
+                        status: SessionStatus.COMPLETED,
+                    });
+                    logger.debug('Updated ACP session status to COMPLETED on exit', { sessionId: sid });
+                    await this.clearRatchetActiveSessionIfMatching(session.workspaceId, sid);
+                    if (session.workflow === 'ratchet') {
+                        await this.persistRatchetTranscript(sid, session);
+                        await this.repository.deleteSession(sid);
+                        logger.debug('Deleted transient ratchet ACP session', { sessionId: sid });
+                    }
+                }
+                catch (error) {
+                    logger.warn('Failed to update ACP session status on exit', {
+                        sessionId: sid,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                finally {
+                    try {
+                        this.clearSessionStoreIfInactive(sid, 'runtime_exit');
+                    }
+                    finally {
+                        acpTraceLogger.closeSession(sid);
+                    }
+                }
+            },
+            onError: (sid, error) => {
+                acpTraceLogger.log(sid, 'runtime_error', {
+                    message: error.message,
+                    stack: error.stack,
+                });
+                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);
+            },
+        };
+    }
+    async createAcpClient(sessionId, options, session, permissionPreset) {
+        const sessionContext = await this.loadSessionContext(sessionId, session);
+        if (!sessionContext) {
+            throw new Error(`Session context not ready: ${sessionId}`);
+        }
+        await this.repository.markWorkspaceHasHadSessions(sessionContext.workspaceId);
+        this.acpEventProcessor.registerSessionContext(sessionId, {
+            workspaceId: sessionContext.workspaceId,
+            workingDir: sessionContext.workingDir,
+        });
+        const handlers = this.setupAcpEventHandler(sessionId);
+        const shouldSuppressReplay = this.shouldSuppressReplayDuringAcpResume(sessionId, session);
+        this.acpEventProcessor.setReplaySuppression(sessionId, shouldSuppressReplay);
+        const clientOptions = {
+            provider: session?.provider ?? 'CLAUDE',
+            workingDir: sessionContext.workingDir,
+            model: options?.model ?? sessionContext.model,
+            systemPrompt: sessionContext.systemPrompt,
+            permissionPreset,
+            sessionId,
+            resumeProviderSessionId: session?.providerSessionId ?? undefined,
+        };
+        let handle;
+        try {
+            handle = await this.runtimeManager.getOrCreateClient(sessionId, clientOptions, handlers, {
+                workspaceId: sessionContext.workspaceId,
+                workingDir: sessionContext.workingDir,
+            });
+        }
+        catch (error) {
+            this.acpEventProcessor.clearSessionState(sessionId);
+            throw error;
+        }
+        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),
+        });
+        return handle;
+    }
+    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);
+    }
+    finalizeOrphanedToolCallsOnStop(sessionId) {
+        try {
+            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.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.updateSession(sessionId, {
+                status: SessionStatus.IDLE,
+            }), {
+                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.clearRatchetActiveSessionIfMatching(session.workspaceId, sessionId);
+        }
+        catch (error) {
+            logger.warn('Failed clearing ratchet active session pointer during stop', {
+                sessionId,
+                workspaceId: session.workspaceId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        if (!shouldCleanupTransientRatchetSession) {
+            return;
+        }
+        try {
+            await this.repository.deleteSession(sessionId);
+            logger.debug('Deleted transient ratchet session after stop', { sessionId });
+        }
+        catch (error) {
+            logger.warn('Failed deleting transient ratchet session during stop', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async clearRatchetActiveSessionIfMatching(workspaceId, sessionId) {
+        if (!this.workspaceBridge) {
+            return;
+        }
+        await this.workspaceBridge.clearRatchetActiveSessionIfMatching(workspaceId, sessionId);
+    }
+    clearSessionStoreIfInactive(sessionId, reason) {
+        if (this.runtimeManager.isSessionRunning(sessionId) ||
+            chatConnectionService.countConnectionsViewingSession(sessionId) > 0) {
+            return;
+        }
+        this.sessionDomainService.clearSession(sessionId);
+        logger.debug('Cleared inactive in-memory session state', { sessionId, reason });
+    }
+    async persistRatchetTranscript(sessionId, session) {
+        if (!this.workspaceBridge) {
+            logger.warn('Cannot persist ratchet transcript: no workspace bridge', { sessionId });
+            return;
+        }
+        const transcript = this.sessionDomainService.getTranscriptSnapshot(sessionId);
+        const workspace = await workspaceAccessor.findById(session.workspaceId);
+        if (!workspace?.worktreePath) {
+            logger.warn('Cannot persist ratchet transcript: no worktree path', {
+                sessionId,
+                workspaceId: session.workspaceId,
+            });
+            return;
+        }
+        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 getOrCreateAcpSessionClient(sessionId, options, session) {
+        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 };
+        }
+        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
+            phase: 'starting',
+            processState: 'alive',
+            activity: 'IDLE',
+            updatedAt: new Date().toISOString(),
+        });
+        const resolvedPreset = await this.resolvePermissionPreset(session);
+        let handle;
+        try {
+            handle = await this.createAcpClient(sessionId, options, session, resolvedPreset);
+        }
+        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;
+        }
+        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 };
+    }
+    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 { 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,
+            },
+            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,
+        };
+    }
+    async resolvePermissionPreset(session) {
+        const fallback = session?.workflow === 'ratchet' ? 'YOLO' : 'STRICT';
+        try {
+            const settings = await userSettingsAccessor.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;
+        }
+    }
+}
+//# sourceMappingURL=session.lifecycle.service.js.map