factory-factory 0.3.9 → 0.3.10

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

@@ -1,789 +0,0 @@
-import { acpRuntimeManager } from '../../../../backend/domains/session/acp/index.js';
-import { acpTraceLogger } from '../../../../backend/domains/session/logging/acp-trace-logger.service.js';
-import { sessionDomainService, } from '../../../../backend/domains/session/session-domain.service.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';
-import { sessionRepository } from './session.repository.js';
-const logger = createLogger('session');
-const STALE_LOADING_RUNTIME_MAX_AGE_MS = 30_000;
-function toErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    if (typeof error === 'object') {
-        return JSON.stringify(error);
-    }
-    return String(error);
-}
-export class SessionService {
-    repository;
-    promptBuilder;
-    runtimeManager;
-    sessionDomainService;
-    sessionPermissionService;
-    sessionConfigService;
-    acpEventProcessor;
-    workspaceBridge = null;
-    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') {
-            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.clearScheduledPromptTurnCompletion(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.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 {
-                    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) {
-        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,
-            permissionMode: options?.permissionMode ?? 'bypassPermissions',
-            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;
-    }
-    constructor(options) {
-        this.repository = options?.repository ?? sessionRepository;
-        this.promptBuilder = options?.promptBuilder ?? sessionPromptBuilder;
-        this.runtimeManager = options?.runtimeManager ?? acpRuntimeManager;
-        this.sessionDomainService = options?.sessionDomainService ?? sessionDomainService;
-        this.sessionPermissionService = new SessionPermissionService({
-            sessionDomainService: this.sessionDomainService,
-        });
-        this.sessionConfigService = new SessionConfigService({
-            repository: this.repository,
-            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);
-        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 startupPermissionMode = startupModePreset === 'plan' ? 'plan' : 'bypassPermissions';
-        const handle = await this.getOrCreateAcpSessionClient(sessionId, { permissionMode: startupPermissionMode }, session);
-        await this.applyStartupModePreset(sessionId, handle, startupModePreset, session.workflow);
-        if (!session.providerSessionId) {
-            await this.applyConfiguredPermissionPreset(sessionId, session, handle);
-        }
-        const initialPrompt = options?.initialPrompt ?? 'Continue with the task.';
-        if (initialPrompt) {
-            await this.sendSessionMessage(sessionId, initialPrompt);
-        }
-        logger.info('Session started', { sessionId, provider: session.provider });
-    }
-    async applyStartupModePreset(sessionId, handle, startupModePreset, workflow) {
-        await this.sessionConfigService.applyStartupModePreset(sessionId, handle, startupModePreset, workflow, {
-            persistSnapshot: this.persistAcpConfigSnapshot.bind(this),
-        });
-    }
-    async applyConfiguredPermissionPreset(sessionId, session, handle) {
-        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.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);
-            }
-            logger.info('ACP session stopped', {
-                sessionId,
-                ...(stopClientFailed ? { runtimeStopFailed: true } : {}),
-            });
-            acpTraceLogger.closeSession(sessionId);
-        }
-    }
-    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.repository.getSessionById(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.repository.updateSession(sessionId, {
-                status: SessionStatus.IDLE,
-            });
-        }
-        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);
-    }
-    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 = await this.getOrCreateAcpSessionClient(sessionId, options ?? {}, session);
-        if (!(hadClient || session.providerSessionId)) {
-            await this.applyConfiguredPermissionPreset(sessionId, session, handle);
-        }
-        return handle;
-    }
-    async getOrCreateSessionClientFromRecord(session, options) {
-        const hadClient = !!this.runtimeManager.getClient(session.id);
-        const handle = await this.getOrCreateAcpSessionClient(session.id, options ?? {}, session);
-        if (!(hadClient || session.providerSessionId)) {
-            await this.applyConfiguredPermissionPreset(session.id, session, handle);
-        }
-        return handle;
-    }
-    getSessionClient(sessionId) {
-        return this.runtimeManager.getClient(sessionId);
-    }
-    getSessionConfigOptions(sessionId) {
-        return this.sessionConfigService.getSessionConfigOptions(sessionId);
-    }
-    getSessionConfigOptionsWithFallback(sessionId) {
-        return this.sessionConfigService.getSessionConfigOptionsWithFallback(sessionId);
-    }
-    async setSessionModel(sessionId, model) {
-        await this.sessionConfigService.setSessionModel(sessionId, model);
-    }
-    setSessionReasoningEffort(sessionId, _effort) {
-        logger.debug('setSessionReasoningEffort is a no-op for ACP sessions', { sessionId });
-    }
-    async setSessionThinkingBudget(sessionId, maxTokens) {
-        await this.sessionConfigService.setSessionThinkingBudget(sessionId, maxTokens);
-    }
-    async setSessionConfigOption(sessionId, configId, value) {
-        await this.sessionConfigService.setSessionConfigOption(sessionId, configId, value);
-    }
-    sendSessionMessage(sessionId, content) {
-        const acpClient = this.runtimeManager.getClient(sessionId);
-        if (acpClient) {
-            const normalizedText = typeof content === 'string' ? content : this.normalizeContentToText(content);
-            return this.sendAcpMessage(sessionId, normalizedText).then(() => {
-            }, (error) => {
-                logger.error('ACP prompt failed', {
-                    sessionId,
-                    error: toErrorMessage(error),
-                });
-            });
-        }
-        logger.warn('No ACP client found for sendSessionMessage', { sessionId });
-        return Promise.resolve();
-    }
-    normalizeContentToText(content) {
-        const chunks = [];
-        for (const item of content) {
-            switch (item.type) {
-                case 'text':
-                    chunks.push(item.text);
-                    break;
-                case 'thinking':
-                    chunks.push(item.thinking);
-                    break;
-                case 'image':
-                    chunks.push('[Image attachment omitted for this provider]');
-                    break;
-                case 'tool_result':
-                    if (typeof item.content === 'string') {
-                        chunks.push(item.content);
-                    }
-                    else {
-                        chunks.push(JSON.stringify(item.content));
-                    }
-                    break;
-                default:
-                    break;
-            }
-        }
-        return chunks.join('\n\n');
-    }
-    async sendAcpMessage(sessionId, content) {
-        const workspaceId = this.acpEventProcessor.getWorkspaceId(sessionId);
-        this.acpEventProcessor.beginPromptTurn(sessionId);
-        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
-            phase: 'running',
-            processState: 'alive',
-            activity: 'WORKING',
-            updatedAt: new Date().toISOString(),
-        });
-        if (workspaceId && this.workspaceBridge) {
-            this.workspaceBridge.markSessionRunning(workspaceId, sessionId);
-        }
-        try {
-            const result = await this.runtimeManager.sendPrompt(sessionId, content);
-            this.acpEventProcessor.finalizeOrphanedToolCalls(sessionId, `stop_reason:${result.stopReason}`);
-            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
-                phase: 'idle',
-                processState: 'alive',
-                activity: 'IDLE',
-                updatedAt: new Date().toISOString(),
-            });
-            return result.stopReason;
-        }
-        catch (error) {
-            this.acpEventProcessor.finalizeOrphanedToolCalls(sessionId, 'prompt_error');
-            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
-                phase: 'error',
-                processState: 'alive',
-                activity: 'IDLE',
-                errorMessage: toErrorMessage(error),
-                updatedAt: new Date().toISOString(),
-            });
-            throw error;
-        }
-        finally {
-            if (workspaceId && this.workspaceBridge) {
-                this.workspaceBridge.markSessionIdle(workspaceId, sessionId);
-            }
-            this.schedulePromptTurnComplete(sessionId);
-        }
-    }
-    schedulePromptTurnComplete(sessionId) {
-        if (!this.promptTurnCompleteHandler) {
-            return;
-        }
-        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) {
-            return;
-        }
-        try {
-            await this.promptTurnCompleteHandler(sessionId);
-        }
-        catch (error) {
-            logger.warn('Prompt turn completion handler failed', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    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);
-    }
-    getSessionConversationHistory(sessionId, _workingDir) {
-        const transcript = this.sessionDomainService.getTranscriptSnapshot(sessionId);
-        return transcript.flatMap((entry) => this.mapTranscriptEntryToHistory(entry));
-    }
-    mapTranscriptEntryToHistory(entry) {
-        if (entry.source === 'user') {
-            return entry.text
-                ? [
-                    {
-                        type: 'user',
-                        content: entry.text,
-                        timestamp: entry.timestamp,
-                    },
-                ]
-                : [];
-        }
-        const message = entry.message;
-        if (!message || (message.type !== 'assistant' && message.type !== 'user')) {
-            return [];
-        }
-        const content = this.extractMessageText(message);
-        if (!content) {
-            return [];
-        }
-        return [
-            {
-                type: message.type,
-                content,
-                timestamp: entry.timestamp,
-            },
-        ];
-    }
-    extractMessageText(message) {
-        const content = message.message?.content;
-        if (typeof content === 'string') {
-            return content;
-        }
-        if (!Array.isArray(content)) {
-            return '';
-        }
-        return content
-            .filter((item) => item.type === 'text')
-            .map((item) => item.text)
-            .join('\n')
-            .trim();
-    }
-    respondToAcpPermission(sessionId, requestId, optionId, answers) {
-        return this.sessionPermissionService.respondToPermission(sessionId, requestId, optionId, answers);
-    }
-    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 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 existingAcp;
-        }
-        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
-            phase: 'starting',
-            processState: 'alive',
-            activity: 'IDLE',
-            updatedAt: new Date().toISOString(),
-        });
-        let handle;
-        try {
-            handle = await this.createAcpClient(sessionId, options, session);
-        }
-        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;
-    }
-    isSessionRunning(sessionId) {
-        return this.runtimeManager.isSessionRunning(sessionId);
-    }
-    isSessionWorking(sessionId) {
-        return this.runtimeManager.isSessionWorking(sessionId);
-    }
-    isAnySessionWorking(sessionIds) {
-        return this.runtimeManager.isAnySessionWorking(sessionIds);
-    }
-    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,
-        };
-    }
-    getChatBarCapabilities(sessionId) {
-        return this.sessionConfigService.getChatBarCapabilities(sessionId);
-    }
-    buildAcpChatBarCapabilities(handle) {
-        return this.sessionConfigService.buildAcpChatBarCapabilities(handle);
-    }
-    async stopAllClients(timeoutMs = 5000) {
-        this.clearAllScheduledPromptTurnCompletions();
-        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;
-        }
-    }
-    async persistAcpConfigSnapshot(sessionId, params) {
-        await this.sessionConfigService.persistAcpConfigSnapshot(sessionId, params);
-    }
-    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,
-        };
-    }
-}
-export function createSessionService(options) {
-    return new SessionService(options);
-}
-export const sessionService = createSessionService();
-//# sourceMappingURL=session.service.js.map