factory-factory 0.3.20 → 0.4.0

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

@@ -1,15 +1,21 @@
+import { configService } from '../../../../../backend/services/config.service.js';
 import { createLogger } from '../../../../../backend/services/logger.service.js';
-import { chatConnectionService } from '../../../../../backend/services/session/service/chat/chat-connection.service.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 { userSettingsAccessor } from '../../../../../backend/services/settings/index.js';
-import { workspaceAccessor } from '../../../../../backend/services/workspace/index.js';
+import { workspaceAccessor, workspaceNotificationAccessor } from '../../../../../backend/services/workspace/index.js';
 import { 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');
+function getPersistedStatusForExitCode(exitCode) {
+    return exitCode === 0 ? SessionStatus.COMPLETED : SessionStatus.FAILED;
+}
 export class SessionLifecycleService {
     repository;
     promptBuilder;
@@ -22,7 +28,11 @@ export class SessionLifecycleService {
     retryService;
     onBeforeStopSession;
     onSessionExit;
+    stoppingSessions = new Set();
+    stopGenerations = new Map();
+    clientCreationOperations = new Map();
     workspaceBridge = null;
+    messageQueueBridge = null;
     autoIterationExitBridge = null;
     constructor(options) {
         this.repository = options.repository;
@@ -39,33 +49,38 @@ export class SessionLifecycleService {
     }
     configure(bridges) {
         this.workspaceBridge = bridges.workspace;
+        this.messageQueueBridge = bridges.messageQueue ?? null;
         this.autoIterationExitBridge = bridges.autoIterationExit ?? null;
     }
     async startSession(sessionId, sendSessionMessage, options) {
+        const stopGeneration = this.getStopGeneration(sessionId);
         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');
-        }
+        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 } = await this.getOrCreateAcpSessionClient(sessionId, {}, session);
+        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);
-        const initialPrompt = typeof options?.initialPrompt === 'string'
-            ? options.initialPrompt
-            : 'Continue with the task.';
-        if (initialPrompt) {
+        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 sendSessionMessage(sessionId, initialPrompt);
         }
         logger.info('Session started', { sessionId, provider: session.provider });
     }
-    async restartSession(sessionId, sendSessionMessage) {
+    async restartSession(sessionId, sendSessionMessage, options) {
         const isRunning = this.runtimeManager.isSessionRunning(sessionId);
         const isStopInProgress = this.runtimeManager.isStopInProgress(sessionId);
         if (isStopInProgress) {
@@ -82,14 +97,30 @@ export class SessionLifecycleService {
                 });
             }
         }
-        await this.startSession(sessionId, sendSessionMessage, {
+        await this.startSession(sessionId, sendSessionMessage, options ?? {
             initialPrompt: 'Continue with the task.',
+            initialPromptIsDefault: true,
         });
         logger.info('Session restarted', { sessionId });
     }
     async stopSession(sessionId, options) {
+        if (this.stoppingSessions.has(sessionId)) {
+            logger.debug('Session stop already in progress', { sessionId });
+            return;
+        }
+        this.stopGenerations.set(sessionId, this.getStopGeneration(sessionId) + 1);
+        this.stoppingSessions.add(sessionId);
+        try {
+            await this.stopSessionWithBarrier(sessionId, options);
+        }
+        finally {
+            this.stoppingSessions.delete(sessionId);
+        }
+    }
+    async stopSessionWithBarrier(sessionId, 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);
         if (this.runtimeManager.isStopInProgress(sessionId)) {
@@ -108,9 +139,7 @@ export class SessionLifecycleService {
         this.sessionPermissionService.cancelPendingRequests(sessionId);
         let stopClientFailed = false;
         try {
-            if (!this.runtimeManager.isStopInProgress(sessionId)) {
-                await this.runtimeManager.stopClient(sessionId);
-            }
+            await this.stopRuntimeAndPendingCreation(sessionId);
         }
         catch (error) {
             stopClientFailed = true;
@@ -122,7 +151,6 @@ export class SessionLifecycleService {
         finally {
             this.finalizeOrphanedToolCalls(sessionId, 'session_stop');
             await this.updateStoppedSessionState(sessionId);
-            this.sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: true });
             this.sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'idle',
                 processState: 'stopped',
@@ -147,8 +175,22 @@ export class SessionLifecycleService {
             }
         }
     }
+    async stopRuntimeAndPendingCreation(sessionId) {
+        if (!this.runtimeManager.isStopInProgress(sessionId)) {
+            await this.runtimeManager.stopClient(sessionId);
+        }
+        const pendingCreations = this.clientCreationOperations.get(sessionId);
+        if (!pendingCreations || pendingCreations.size === 0) {
+            return;
+        }
+        await Promise.allSettled([...pendingCreations]);
+        if (!this.runtimeManager.isStopInProgress(sessionId)) {
+            await this.runtimeManager.stopClient(sessionId);
+        }
+    }
     async stopWorkspaceSessions(workspaceId) {
         const sessions = await this.repository.getSessionsByWorkspaceId(workspaceId);
+        const stopErrors = [];
         for (const session of sessions) {
             if (session.status === SessionStatus.RUNNING ||
                 this.runtimeManager.isSessionRunning(session.id)) {
@@ -161,28 +203,44 @@ export class SessionLifecycleService {
                         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 });
     }
     async getOrCreateSessionClient(sessionId, options) {
+        const stopGeneration = this.getStopGeneration(sessionId);
         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 } = await this.getOrCreateAcpSessionClient(sessionId, options ?? {}, session);
+        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;
     }
     async getOrCreateSessionClientFromRecord(session, options) {
+        const stopGeneration = this.getStopGeneration(session.id);
+        this.assertStartupAllowed(session.id, stopGeneration);
         const hadClient = !!this.runtimeManager.getClient(session.id);
-        const { handle, resolvedPreset } = await this.getOrCreateAcpSessionClient(session.id, options ?? {}, session);
+        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;
     }
@@ -221,6 +279,17 @@ export class SessionLifecycleService {
         }
         return base;
     }
+    isSessionStopping(sessionId) {
+        return this.stoppingSessions.has(sessionId) || this.runtimeManager.isStopInProgress(sessionId);
+    }
+    getStopGeneration(sessionId) {
+        return this.stopGenerations.get(sessionId) ?? 0;
+    }
+    assertStartupAllowed(sessionId, stopGeneration) {
+        if (this.isSessionStopping(sessionId) || this.getStopGeneration(sessionId) !== stopGeneration) {
+            throw new Error('Session is currently being stopped');
+        }
+    }
     async getSessionOptions(sessionId) {
         const sessionContext = await this.loadSessionContext(sessionId);
         if (!sessionContext) {
@@ -231,6 +300,7 @@ export class SessionLifecycleService {
             resumeProviderSessionId: sessionContext.resumeProviderSessionId,
             systemPrompt: sessionContext.systemPrompt,
             model: sessionContext.model,
+            workspaceStatus: sessionContext.workspaceStatus,
         };
     }
     async stopAllClients(timeoutMs = 5000) {
@@ -278,11 +348,16 @@ export class SessionLifecycleService {
                 acpTraceLogger.log(sid, 'runtime_exit', { exitCode });
                 try {
                     this.sessionDomainService.markProcessExit(sid, exitCode);
+                    const persistedStatus = getPersistedStatusForExitCode(exitCode);
                     const session = await this.repository.updateSession(sid, {
-                        status: SessionStatus.COMPLETED,
+                        status: persistedStatus,
+                    });
+                    logger.debug('Updated ACP session status on exit', {
+                        sessionId: sid,
+                        exitCode,
+                        status: persistedStatus,
                     });
-                    logger.debug('Updated ACP session status to COMPLETED on exit', { sessionId: sid });
-                    await this.clearRatchetActiveSessionIfMatching(session.workspaceId, sid);
+                    await this.recordRatchetSessionEndOnExit(session.workspaceId, sid, exitCode);
                     void this.maybeDiscoverPROnSessionEnd(session.workspaceId);
                     if (session.workflow === 'ratchet') {
                         await this.persistRatchetTranscript(sid, session);
@@ -327,19 +402,28 @@ export class SessionLifecycleService {
             },
         };
     }
-    async createAcpClient(sessionId, options, session, permissionPreset) {
+    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);
         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);
         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',
             workingDir: sessionContext.workingDir,
@@ -348,18 +432,36 @@ export class SessionLifecycleService {
             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 this.runtimeManager.getOrCreateClient(sessionId, clientOptions, handlers, {
-                workspaceId: sessionContext.workspaceId,
-                workingDir: sessionContext.workingDir,
+            handle = await creationPromise;
+            this.assertStartupAllowed(sessionId, stopGeneration);
+            await this.sessionConfigService.applyConfiguredReasoningEffort(sessionId, handle, {
+                persistSnapshot: false,
+                emitUpdates: false,
             });
         }
         catch (error) {
             this.acpEventProcessor.clearSessionState(sessionId);
             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,
@@ -376,7 +478,9 @@ export class SessionLifecycleService {
             type: 'chat_capabilities',
             capabilities: this.buildAcpChatBarCapabilities(handle),
         });
-        return handle;
+        this.assertStartupAllowed(sessionId, stopGeneration);
+        const dispatchableNotificationCount = await this.deliverPendingChildNotifications(sessionId, sessionContext.workspaceId, stopGeneration);
+        return { handle, dispatchableNotificationCount };
     }
     shouldSuppressReplayDuringAcpResume(sessionId, session) {
         if (!session?.providerSessionId) {
@@ -461,10 +565,10 @@ export class SessionLifecycleService {
             return;
         }
         try {
-            await this.clearRatchetActiveSessionIfMatching(session.workspaceId, sessionId);
+            await this.recordRatchetSessionEnd(session.workspaceId, sessionId, 'COMPLETED');
         }
         catch (error) {
-            logger.warn('Failed clearing ratchet active session pointer during stop', {
+            logger.warn('Failed settling ratchet dispatch record during stop', {
                 sessionId,
                 workspaceId: session.workspaceId,
                 error: error instanceof Error ? error.message : String(error),
@@ -485,18 +589,22 @@ export class SessionLifecycleService {
             });
         }
     }
-    async clearRatchetActiveSessionIfMatching(workspaceId, sessionId) {
+    async recordRatchetSessionEnd(workspaceId, sessionId, outcome) {
         if (!this.workspaceBridge) {
             return;
         }
-        await this.workspaceBridge.clearRatchetActiveSessionIfMatching(workspaceId, sessionId);
+        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) {
         await maybeDiscoverPROnSessionEndHelper(workspaceId, logger);
     }
     clearSessionStoreIfInactive(sessionId, reason) {
         if (this.runtimeManager.isSessionRunning(sessionId) ||
-            chatConnectionService.countConnectionsViewingSession(sessionId) > 0) {
+            sessionEventBus.countViewers(sessionId) > 0) {
             return;
         }
         this.sessionDomainService.clearSession(sessionId);
@@ -528,7 +636,8 @@ export class SessionLifecycleService {
             messages: transcript,
         });
     }
-    async getOrCreateAcpSessionClient(sessionId, options, session) {
+    async getOrCreateAcpSessionClient(sessionId, options, session, stopGeneration) {
+        this.assertStartupAllowed(sessionId, stopGeneration);
         const existingAcp = this.runtimeManager.getClient(sessionId);
         if (existingAcp) {
             this.sessionDomainService.setRuntimeSnapshot(sessionId, {
@@ -537,7 +646,7 @@ export class SessionLifecycleService {
                 activity: existingAcp.isPromptInFlight ? 'WORKING' : 'IDLE',
                 updatedAt: new Date().toISOString(),
             });
-            return { handle: existingAcp };
+            return { handle: existingAcp, dispatchableNotificationCount: 0 };
         }
         this.sessionDomainService.setRuntimeSnapshot(sessionId, {
             phase: 'starting',
@@ -546,9 +655,13 @@ export class SessionLifecycleService {
             updatedAt: new Date().toISOString(),
         });
         const resolvedPreset = await this.resolvePermissionPreset(session);
+        this.assertStartupAllowed(sessionId, stopGeneration);
         let handle;
+        let dispatchableNotificationCount = 0;
         try {
-            handle = await this.createAcpClient(sessionId, options, session, resolvedPreset);
+            const created = await this.createAcpClient(sessionId, options, session, resolvedPreset, stopGeneration);
+            handle = created.handle;
+            dispatchableNotificationCount = created.dispatchableNotificationCount;
         }
         catch (error) {
             this.sessionDomainService.setRuntimeSnapshot(sessionId, {
@@ -560,6 +673,7 @@ export class SessionLifecycleService {
             });
             throw error;
         }
+        this.assertStartupAllowed(sessionId, stopGeneration);
         await this.repository.updateSession(sessionId, {
             status: SessionStatus.RUNNING,
         });
@@ -569,7 +683,21 @@ export class SessionLifecycleService {
             activity: handle.isPromptInFlight ? 'WORKING' : 'IDLE',
             updatedAt: new Date().toISOString(),
         });
-        return { handle, resolvedPreset };
+        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);
@@ -605,6 +733,7 @@ export class SessionLifecycleService {
                 projectId: workspace.projectId,
             });
         }
+        const parentCtx = await this.resolveParentWorkspaceContext(workspace);
         const { workflowPrompt, systemPrompt, injectedBranchRename } = this.promptBuilder.buildSystemPrompt({
             workflow: session.workflow,
             workspace: {
@@ -613,6 +742,11 @@ export class SessionLifecycleService {
                 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,
         });
@@ -635,8 +769,168 @@ export class SessionLifecycleService {
             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 workspaceNotificationAccessor.findPending(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;
+                }
+                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 workspaceNotificationAccessor.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 {