factory-factory 0.4.5 → 0.4.7

package/dist/src/backend/services/session/service/chat/chat-message-handlers.service.test.js

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { mockSessionDomainService, mockSessionService, mockSessionDataService, mockWorkspaceNotificationService, } = vi.hoisted(() => ({
+import { VOICE_MODE_BREVITY_INSTRUCTION } from '../../../../../backend/services/session/service/voice/voice-mode-instructions.js';
+const { mockSessionDomainService, mockSessionService, mockSessionDataService, mockNotificationDeliveryService, } = vi.hoisted(() => ({
     mockSessionDomainService: {
         peekNextMessage: vi.fn(),
         dequeueNext: vi.fn(),
@@ -9,6 +10,7 @@ const { mockSessionDomainService, mockSessionService, mockSessionDataService, mo
         markRunning: vi.fn(),
         allocateOrder: vi.fn(),
         emitDelta: vi.fn(),
+        emitSessionSnapshot: vi.fn(),
         failMessage: vi.fn(),
         commitSentUserMessageAtOrder: vi.fn(),
         removeTranscriptMessageById: vi.fn(),
@@ -19,9 +21,10 @@ const { mockSessionDomainService, mockSessionService, mockSessionDataService, mo
     mockSessionService: {
         getClient: vi.fn(),
         getSessionClient: vi.fn(),
+        getOrCreateSessionClient: vi.fn(),
         isSessionStopping: vi.fn(),
-        getStopGeneration: vi.fn(),
-        isStopGenerationCurrent: vi.fn(),
+        getGeneration: vi.fn(),
+        isGenerationCurrent: vi.fn(),
         isSessionRunning: vi.fn(),
         isSessionWorking: vi.fn(),
         setSessionModel: vi.fn(),
@@ -33,9 +36,13 @@ const { mockSessionDomainService, mockSessionService, mockSessionDataService, mo
     mockSessionDataService: {
         findAgentSessionById: vi.fn(),
     },
-    mockWorkspaceNotificationService: {
-        markDelivered: vi.fn(),
-        findForDelivery: vi.fn(),
+    mockNotificationDeliveryService: {
+        claimForDispatch: vi.fn(),
+        isAlreadyDelivered: vi.fn(),
+        acknowledgeSuccessfulDispatch: vi.fn(),
+        removeDuplicateFromQueue: vi.fn(),
+        resetSession: vi.fn(),
+        isNotificationMessage: vi.fn(),
     },
 }));
 vi.mock('@/backend/services/session/service/session-domain.service', () => ({
@@ -44,7 +51,7 @@ vi.mock('@/backend/services/session/service/session-domain.service', () => ({
 vi.mock('@/backend/services/session/service/acp', () => ({
     acpRuntimeManager: mockSessionService,
 }));
-vi.mock('@/backend/services/session/service/lifecycle/session-services', () => ({
+vi.mock('@/backend/services/session/service/lifecycle/session-core-services', () => ({
     sessionConfigService: mockSessionService,
     sessionLifecycleService: mockSessionService,
     sessionPermissionService: {},
@@ -53,14 +60,15 @@ vi.mock('@/backend/services/session/service/lifecycle/session-services', () => (
 vi.mock('@/backend/services/session/service/data/session-data.service', () => ({
     sessionDataService: mockSessionDataService,
 }));
-vi.mock('@/backend/services/workspace', () => ({
-    workspaceNotificationService: mockWorkspaceNotificationService,
-}));
 vi.mock('./chat-message-handlers/registry', () => ({
     createChatMessageHandlerRegistry: () => ({}),
 }));
-import { chatMessageHandlerService } from './chat-message-handlers.service.js';
+import { ChatMessageHandlerService } from './chat-message-handlers.service.js';
+const chatMessageHandlerService = new ChatMessageHandlerService();
 describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
+    it('fails fast when dispatch occurs before lifecycle configuration', async () => {
+        await expect(new ChatMessageHandlerService().tryDispatchNextMessage('s1')).rejects.toThrow('ChatMessageHandlerService not configured: lifecycle gate/startup missing');
+    });
     const queuedMessage = {
         id: 'm1',
         text: 'hello',
@@ -72,6 +80,20 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
             planModeEnabled: false,
         },
     };
+    const queuedMessageWithAttachment = {
+        ...queuedMessage,
+        text: 'preserve this draft',
+        attachments: [
+            {
+                id: 'attachment-1',
+                name: 'notes.txt',
+                type: 'text/plain',
+                size: 11,
+                data: 'draft notes',
+                contentType: 'text',
+            },
+        ],
+    };
     beforeEach(() => {
         vi.clearAllMocks();
         chatMessageHandlerService.resetDispatchState('s1');
@@ -80,6 +102,11 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
                 getWorkspaceInitPolicy: () => ({ dispatchPolicy: 'allowed' }),
             },
         });
+        chatMessageHandlerService.configureLifecycle({
+            gate: mockSessionService,
+            startup: mockSessionService,
+            notificationDelivery: mockNotificationDeliveryService,
+        });
         mockSessionDomainService.peekNextMessage.mockReturnValue(queuedMessage);
         mockSessionDomainService.dequeueNext.mockReturnValue(queuedMessage);
         mockSessionDomainService.allocateOrder.mockReturnValue(0);
@@ -88,15 +115,20 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
         mockSessionService.setSessionReasoningEffort.mockResolvedValue(undefined);
         mockSessionService.setSessionCollaborationMode.mockResolvedValue(undefined);
         mockSessionService.sendSessionMessage.mockResolvedValue(undefined);
-        mockWorkspaceNotificationService.markDelivered.mockResolvedValue(undefined);
-        mockWorkspaceNotificationService.findForDelivery.mockResolvedValue(null);
+        mockNotificationDeliveryService.claimForDispatch.mockReturnValue({
+            status: 'not_notification',
+        });
+        mockNotificationDeliveryService.isAlreadyDelivered.mockResolvedValue(false);
+        mockNotificationDeliveryService.acknowledgeSuccessfulDispatch.mockResolvedValue(undefined);
+        mockNotificationDeliveryService.removeDuplicateFromQueue.mockReturnValue(true);
+        mockNotificationDeliveryService.isNotificationMessage.mockReturnValue(false);
         mockSessionDomainService.getTranscriptSnapshot.mockReturnValue([]);
         mockSessionDomainService.removeQueuedMessage.mockReturnValue(true);
         mockSessionService.isSessionWorking.mockReturnValue(false);
         mockSessionService.isSessionRunning.mockReturnValue(true);
         mockSessionService.isSessionStopping.mockReturnValue(false);
-        mockSessionService.getStopGeneration.mockReturnValue(0);
-        mockSessionService.isStopGenerationCurrent.mockReturnValue(true);
+        mockSessionService.getGeneration.mockReturnValue(0);
+        mockSessionService.isGenerationCurrent.mockReturnValue(true);
         mockSessionDataService.findAgentSessionById.mockResolvedValue({
             workspace: {
                 status: 'READY',
@@ -160,11 +192,13 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
         expect(mockSessionDomainService.dequeueNext).not.toHaveBeenCalled();
         expect(mockSessionDomainService.emitDelta).not.toHaveBeenCalled();
     });
-    it('does not send or commit a dequeued message when stop begins during dispatch configuration', async () => {
+    it('fails a dequeued message for recovery when stop begins during dispatch configuration', async () => {
         let resolveModelUpdate;
         const modelUpdate = new Promise((resolve) => {
             resolveModelUpdate = resolve;
         });
+        mockSessionDomainService.peekNextMessage.mockReturnValue(queuedMessageWithAttachment);
+        mockSessionDomainService.dequeueNext.mockReturnValue(queuedMessageWithAttachment);
         mockSessionService.getSessionClient.mockReturnValue({});
         mockSessionService.setSessionModel.mockReturnValue(modelUpdate);
         const dispatchPromise = chatMessageHandlerService.tryDispatchNextMessage('s1');
@@ -178,15 +212,37 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
         expect(mockSessionDomainService.markRunning).not.toHaveBeenCalled();
         expect(mockSessionDomainService.commitSentUserMessageAtOrder).not.toHaveBeenCalled();
         expect(mockSessionDomainService.requeueFront).not.toHaveBeenCalled();
+        expect(mockSessionDomainService.failMessage).toHaveBeenCalledWith('s1', queuedMessageWithAttachment, 'Message was not sent because the session stopped during dispatch.');
+    });
+    it('fails a dequeued message for recovery when configuration rejects after stop begins', async () => {
+        let rejectModelUpdate;
+        const modelUpdate = new Promise((_resolve, reject) => {
+            rejectModelUpdate = reject;
+        });
+        mockSessionDomainService.peekNextMessage.mockReturnValue(queuedMessageWithAttachment);
+        mockSessionDomainService.dequeueNext.mockReturnValue(queuedMessageWithAttachment);
+        mockSessionService.getSessionClient.mockReturnValue({});
+        mockSessionService.setSessionModel.mockReturnValue(modelUpdate);
+        const dispatchPromise = chatMessageHandlerService.tryDispatchNextMessage('s1');
+        await vi.waitFor(() => {
+            expect(mockSessionService.setSessionModel).toHaveBeenCalledWith('s1', undefined);
+        });
+        mockSessionService.isSessionStopping.mockReturnValue(true);
+        rejectModelUpdate(new Error('session stopped'));
+        await dispatchPromise;
+        expect(mockSessionService.sendSessionMessage).not.toHaveBeenCalled();
+        expect(mockSessionDomainService.commitSentUserMessageAtOrder).not.toHaveBeenCalled();
+        expect(mockSessionDomainService.requeueFront).not.toHaveBeenCalled();
+        expect(mockSessionDomainService.failMessage).toHaveBeenCalledWith('s1', queuedMessageWithAttachment, 'Message was not sent because the session stopped during dispatch.');
     });
-    it('does not send or requeue a dequeued message when stop completes during configuration', async () => {
+    it('fails a dequeued message for recovery when stop completes during configuration', async () => {
         let resolveModelUpdate;
         const modelUpdate = new Promise((resolve) => {
             resolveModelUpdate = resolve;
         });
         let stopGeneration = 0;
-        mockSessionService.getStopGeneration.mockImplementation(() => stopGeneration);
-        mockSessionService.isStopGenerationCurrent.mockImplementation((_sessionId, generation) => generation === stopGeneration);
+        mockSessionService.getGeneration.mockImplementation(() => stopGeneration);
+        mockSessionService.isGenerationCurrent.mockImplementation((_sessionId, generation) => generation === stopGeneration);
         mockSessionService.getSessionClient.mockReturnValue({});
         mockSessionService.setSessionModel.mockReturnValue(modelUpdate);
         const dispatchPromise = chatMessageHandlerService.tryDispatchNextMessage('s1');
@@ -201,6 +257,33 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
         expect(mockSessionDomainService.markRunning).not.toHaveBeenCalled();
         expect(mockSessionDomainService.commitSentUserMessageAtOrder).not.toHaveBeenCalled();
         expect(mockSessionDomainService.requeueFront).not.toHaveBeenCalled();
+        expect(mockSessionDomainService.failMessage).toHaveBeenCalledWith('s1', queuedMessage, 'Message was not sent because the session stopped during dispatch.');
+    });
+    it('does not expose a stopped workspace notification as a recoverable user message', async () => {
+        const notificationMessage = {
+            ...queuedMessage,
+            id: 'workspace-notification-notif-parent',
+        };
+        let resolveModelUpdate;
+        const modelUpdate = new Promise((resolve) => {
+            resolveModelUpdate = resolve;
+        });
+        mockSessionDomainService.peekNextMessage.mockReturnValue(notificationMessage);
+        mockSessionDomainService.dequeueNext.mockReturnValue(notificationMessage);
+        mockSessionService.getSessionClient.mockReturnValue({});
+        mockSessionService.setSessionModel.mockReturnValue(modelUpdate);
+        mockNotificationDeliveryService.isNotificationMessage.mockReturnValue(true);
+        const dispatchPromise = chatMessageHandlerService.tryDispatchNextMessage('s1');
+        await vi.waitFor(() => {
+            expect(mockSessionService.setSessionModel).toHaveBeenCalledWith('s1', undefined);
+        });
+        mockSessionService.isSessionStopping.mockReturnValue(true);
+        resolveModelUpdate();
+        await dispatchPromise;
+        expect(mockSessionService.sendSessionMessage).not.toHaveBeenCalled();
+        expect(mockNotificationDeliveryService.acknowledgeSuccessfulDispatch).not.toHaveBeenCalled();
+        expect(mockSessionDomainService.failMessage).not.toHaveBeenCalled();
+        expect(mockSessionDomainService.emitSessionSnapshot).toHaveBeenCalledWith('s1');
     });
     it('fails a message once when ACP reports an internal error', async () => {
         const client = {
@@ -225,7 +308,7 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
         expect(mockSessionDomainService.markError).toHaveBeenCalledWith('s1', 'code -32603: Internal error');
         expect(mockSessionDomainService.failMessage).toHaveBeenCalledWith('s1', queuedMessage, 'code -32603: Internal error');
     });
-    it('marks a workspace notification delivered after its queued message commits', async () => {
+    it('acknowledges a workspace notification after its provider dispatch commits', async () => {
         const client = {
             isCompactingActive: vi.fn().mockReturnValue(false),
             startCompaction: vi.fn(),
@@ -241,7 +324,7 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
         mockSessionDomainService.dequeueNext.mockReturnValue(notificationMessage);
         await chatMessageHandlerService.tryDispatchNextMessage('s1');
         expect(mockSessionService.sendSessionMessage).toHaveBeenCalledWith('s1', 'hello');
-        expect(mockWorkspaceNotificationService.markDelivered).toHaveBeenCalledWith(['notif-parent']);
+        expect(mockNotificationDeliveryService.acknowledgeSuccessfulDispatch).toHaveBeenCalledWith('workspace-notification-notif-parent');
     });
     it('drops a duplicate notification and dispatches the next queued message', async () => {
         const client = {
@@ -258,177 +341,16 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
         mockSessionDomainService.peekNextMessage
             .mockReturnValueOnce(notificationMessage)
             .mockReturnValue(queuedMessage);
-        mockSessionDomainService.getTranscriptSnapshot.mockReturnValue([
-            { source: 'user', id: 'workspace-notification-notif-parent', text: 'hello' },
-        ]);
+        mockNotificationDeliveryService.claimForDispatch
+            .mockReturnValueOnce({ status: 'duplicate' })
+            .mockReturnValue({ status: 'not_notification' });
         await chatMessageHandlerService.tryDispatchNextMessage('s1');
-        expect(mockSessionDomainService.removeQueuedMessage).toHaveBeenCalledWith('s1', 'workspace-notification-notif-parent');
+        expect(mockNotificationDeliveryService.removeDuplicateFromQueue).toHaveBeenCalledWith('s1', 'workspace-notification-notif-parent');
         expect(mockSessionService.sendSessionMessage).toHaveBeenCalledTimes(1);
         expect(mockSessionService.sendSessionMessage).toHaveBeenCalledWith('s1', 'hello');
-        expect(mockWorkspaceNotificationService.markDelivered).not.toHaveBeenCalled();
-    });
-    it('drops a workspace notification whose row is already marked delivered', async () => {
-        const client = {
-            isCompactingActive: vi.fn().mockReturnValue(false),
-            startCompaction: vi.fn(),
-            endCompaction: vi.fn(),
-            setMaxThinkingTokens: vi.fn().mockResolvedValue(undefined),
-        };
-        const notificationMessage = {
-            ...queuedMessage,
-            id: 'workspace-notification-notif-parent',
-        };
-        mockSessionService.getSessionClient.mockReturnValue(client);
-        mockSessionDomainService.peekNextMessage
-            .mockReturnValueOnce(notificationMessage)
-            .mockReturnValue(undefined);
-        mockWorkspaceNotificationService.findForDelivery.mockResolvedValue({
-            id: 'notif-parent',
-            deliveredAt: new Date('2026-02-01T00:00:00.000Z'),
-        });
-        await chatMessageHandlerService.tryDispatchNextMessage('s1');
-        expect(mockWorkspaceNotificationService.findForDelivery).toHaveBeenCalledWith('notif-parent');
-        expect(mockSessionDomainService.removeQueuedMessage).toHaveBeenCalledWith('s1', 'workspace-notification-notif-parent');
-        expect(mockSessionService.sendSessionMessage).not.toHaveBeenCalled();
-        expect(mockSessionDomainService.markRunning).not.toHaveBeenCalled();
-    });
-    it('drops a duplicate while another session is delivering the same notification', async () => {
-        const client = {
-            isCompactingActive: vi.fn().mockReturnValue(false),
-            startCompaction: vi.fn(),
-            endCompaction: vi.fn(),
-            setMaxThinkingTokens: vi.fn().mockResolvedValue(undefined),
-        };
-        const notificationMessage = {
-            ...queuedMessage,
-            id: 'workspace-notification-notif-parent',
-        };
-        chatMessageHandlerService.resetDispatchState('s2');
-        mockSessionService.getSessionClient.mockReturnValue(client);
-        mockWorkspaceNotificationService.findForDelivery.mockResolvedValue({
-            id: 'notif-parent',
-            deliveredAt: null,
-        });
-        let resolveSend;
-        mockSessionService.sendSessionMessage.mockImplementation(() => new Promise((resolve) => {
-            resolveSend = () => resolve();
-        }));
-        const s2Queue = [notificationMessage];
-        mockSessionDomainService.peekNextMessage.mockImplementation((sessionId) => sessionId === 's2' ? s2Queue[0] : notificationMessage);
-        mockSessionDomainService.dequeueNext.mockReturnValue(notificationMessage);
-        mockSessionDomainService.removeQueuedMessage.mockImplementation((sessionId) => {
-            if (sessionId === 's2') {
-                s2Queue.shift();
-            }
-            return true;
-        });
-        const firstDispatch = chatMessageHandlerService.tryDispatchNextMessage('s1');
-        await vi.waitFor(() => {
-            expect(mockSessionService.sendSessionMessage).toHaveBeenCalledTimes(1);
-        });
-        await chatMessageHandlerService.tryDispatchNextMessage('s2');
-        expect(mockSessionService.sendSessionMessage).toHaveBeenCalledTimes(1);
-        expect(mockSessionDomainService.removeQueuedMessage).toHaveBeenCalledWith('s2', 'workspace-notification-notif-parent');
-        resolveSend();
-        await firstDispatch;
-        expect(mockWorkspaceNotificationService.markDelivered).toHaveBeenCalledWith(['notif-parent']);
-    });
-    it('retries a pending notification on another session after the claiming session is reset', async () => {
-        const client = {
-            isCompactingActive: vi.fn().mockReturnValue(false),
-            startCompaction: vi.fn(),
-            endCompaction: vi.fn(),
-            setMaxThinkingTokens: vi.fn().mockResolvedValue(undefined),
-        };
-        const notificationMessage = {
-            ...queuedMessage,
-            id: 'workspace-notification-notif-parent',
-        };
-        chatMessageHandlerService.resetDispatchState('s2');
-        mockSessionService.getSessionClient.mockReturnValue(client);
-        mockWorkspaceNotificationService.findForDelivery.mockResolvedValue({
-            id: 'notif-parent',
-            deliveredAt: null,
-        });
-        const sendResolvers = [];
-        mockSessionService.sendSessionMessage.mockImplementation(() => new Promise((resolve) => {
-            sendResolvers.push(() => resolve());
-        }));
-        const queues = {
-            s1: [notificationMessage],
-            s2: [notificationMessage],
-        };
-        mockSessionDomainService.peekNextMessage.mockImplementation((sessionId) => queues[sessionId]?.[0]);
-        mockSessionDomainService.dequeueNext.mockImplementation((sessionId) => queues[sessionId]?.shift());
-        mockSessionDomainService.removeQueuedMessage.mockImplementation((sessionId) => {
-            queues[sessionId]?.shift();
-            return true;
-        });
-        const hungDispatch = chatMessageHandlerService.tryDispatchNextMessage('s1');
-        await vi.waitFor(() => {
-            expect(mockSessionService.sendSessionMessage).toHaveBeenCalledTimes(1);
-        });
-        chatMessageHandlerService.resetDispatchState('s1');
-        const retryDispatch = chatMessageHandlerService.tryDispatchNextMessage('s2');
-        await vi.waitFor(() => {
-            expect(mockSessionService.sendSessionMessage).toHaveBeenCalledTimes(2);
-        });
-        for (const resolveSend of sendResolvers) {
-            resolveSend();
-        }
-        await Promise.all([hungDispatch, retryDispatch]);
-    });
-    it('does not release another session claim when a stale dispatch settles', async () => {
-        const client = {
-            isCompactingActive: vi.fn().mockReturnValue(false),
-            startCompaction: vi.fn(),
-            endCompaction: vi.fn(),
-            setMaxThinkingTokens: vi.fn().mockResolvedValue(undefined),
-        };
-        const notificationMessage = {
-            ...queuedMessage,
-            id: 'workspace-notification-notif-parent',
-        };
-        chatMessageHandlerService.resetDispatchState('s2');
-        chatMessageHandlerService.resetDispatchState('s3');
-        mockSessionService.getSessionClient.mockReturnValue(client);
-        mockWorkspaceNotificationService.findForDelivery.mockResolvedValue({
-            id: 'notif-parent',
-            deliveredAt: null,
-        });
-        const sendSettlers = [];
-        mockSessionService.sendSessionMessage.mockImplementation(() => new Promise((resolve, reject) => {
-            sendSettlers.push({ resolve: () => resolve(), reject });
-        }));
-        const queues = {
-            s1: [notificationMessage],
-            s2: [notificationMessage],
-            s3: [notificationMessage],
-        };
-        mockSessionDomainService.peekNextMessage.mockImplementation((sessionId) => queues[sessionId]?.[0]);
-        mockSessionDomainService.dequeueNext.mockImplementation((sessionId) => queues[sessionId]?.shift());
-        mockSessionDomainService.removeQueuedMessage.mockImplementation((sessionId) => {
-            queues[sessionId]?.shift();
-            return true;
-        });
-        const staleDispatch = chatMessageHandlerService.tryDispatchNextMessage('s1');
-        await vi.waitFor(() => {
-            expect(mockSessionService.sendSessionMessage).toHaveBeenCalledTimes(1);
-        });
-        chatMessageHandlerService.resetDispatchState('s1');
-        const retryDispatch = chatMessageHandlerService.tryDispatchNextMessage('s2');
-        await vi.waitFor(() => {
-            expect(mockSessionService.sendSessionMessage).toHaveBeenCalledTimes(2);
-        });
-        sendSettlers[0]?.reject(new Error('session stopped'));
-        await staleDispatch;
-        await chatMessageHandlerService.tryDispatchNextMessage('s3');
-        expect(mockSessionService.sendSessionMessage).toHaveBeenCalledTimes(2);
-        expect(mockSessionDomainService.removeQueuedMessage).toHaveBeenCalledWith('s3', 'workspace-notification-notif-parent');
-        sendSettlers[1]?.resolve();
-        await retryDispatch;
+        expect(mockNotificationDeliveryService.acknowledgeSuccessfulDispatch).toHaveBeenCalledWith('m1');
     });
-    it('dispatches a workspace notification whose row is still pending', async () => {
+    it('removes failed notification transcript evidence when the process has stopped', async () => {
         const client = {
             isCompactingActive: vi.fn().mockReturnValue(false),
             startCompaction: vi.fn(),
@@ -442,33 +364,16 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
         mockSessionService.getSessionClient.mockReturnValue(client);
         mockSessionDomainService.peekNextMessage.mockReturnValue(notificationMessage);
         mockSessionDomainService.dequeueNext.mockReturnValue(notificationMessage);
-        mockWorkspaceNotificationService.findForDelivery.mockResolvedValue({
-            id: 'notif-parent',
-            deliveredAt: null,
-        });
-        await chatMessageHandlerService.tryDispatchNextMessage('s1');
-        expect(mockSessionService.sendSessionMessage).toHaveBeenCalledWith('s1', 'hello');
-        expect(mockWorkspaceNotificationService.markDelivered).toHaveBeenCalledWith(['notif-parent']);
-    });
-    it('does not call markIdle when process has already stopped during dispatch failure', async () => {
-        const client = {
-            isCompactingActive: vi.fn().mockReturnValue(false),
-            startCompaction: vi.fn(),
-            endCompaction: vi.fn(),
-            setMaxThinkingTokens: vi.fn().mockResolvedValue(undefined),
-        };
-        mockSessionService.getSessionClient.mockReturnValue(client);
         mockSessionService.sendSessionMessage.mockRejectedValue(new Error('send failed'));
         mockSessionService.isSessionRunning.mockReturnValueOnce(true).mockReturnValue(false);
         await chatMessageHandlerService.tryDispatchNextMessage('s1');
         expect(mockSessionDomainService.markRunning).toHaveBeenCalledWith('s1');
-        expect(mockSessionDomainService.removeTranscriptMessageById).toHaveBeenCalledWith('s1', 'm1', {
-            emitSnapshot: false,
-        });
+        expect(mockSessionDomainService.removeTranscriptMessageById).toHaveBeenCalledWith('s1', 'workspace-notification-notif-parent', { emitSnapshot: false });
+        expect(mockNotificationDeliveryService.acknowledgeSuccessfulDispatch).not.toHaveBeenCalled();
         expect(mockSessionDomainService.markIdle).not.toHaveBeenCalled();
         expect(mockSessionDomainService.requeueFront).not.toHaveBeenCalled();
         expect(mockSessionDomainService.markError).not.toHaveBeenCalled();
-        expect(mockSessionDomainService.failMessage).toHaveBeenCalledWith('s1', queuedMessage, 'send failed');
+        expect(mockSessionDomainService.failMessage).toHaveBeenCalledWith('s1', notificationMessage, 'send failed');
     });
     it.each([
         {
@@ -629,13 +534,6 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
             vi.useRealTimers();
         }
     });
-    it('marks runtime as error when auto-start cannot run because client creator is missing', async () => {
-        mockSessionService.getSessionClient.mockReturnValue(undefined);
-        mockSessionService.isSessionRunning.mockReturnValue(false);
-        await chatMessageHandlerService.tryDispatchNextMessage('s1');
-        expect(mockSessionDomainService.markError).toHaveBeenCalledWith('s1', 'Failed to start agent: client creator not configured');
-        expect(mockSessionDomainService.dequeueNext).not.toHaveBeenCalled();
-    });
     it('skips thinking budget updates for non-Claude clients', async () => {
         const codexMessage = {
             ...queuedMessage,
@@ -683,6 +581,69 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
         await chatMessageHandlerService.tryDispatchNextMessage('s1');
         expect(mockSessionService.setSessionCollaborationMode).not.toHaveBeenCalled();
     });
+    it('appends the brevity instruction as a second content block for a voice-flagged message', async () => {
+        const voiceMessage = { ...queuedMessage, voiceMode: true };
+        mockSessionDomainService.peekNextMessage.mockReturnValue(voiceMessage);
+        mockSessionDomainService.dequeueNext.mockReturnValue(voiceMessage);
+        mockSessionService.getSessionClient.mockReturnValue({ sessionId: 's1', threadId: 't1' });
+        await chatMessageHandlerService.tryDispatchNextMessage('s1');
+        expect(mockSessionService.sendSessionMessage).toHaveBeenCalledWith('s1', [
+            { type: 'text', text: 'hello' },
+            { type: 'text', text: VOICE_MODE_BREVITY_INSTRUCTION },
+        ]);
+    });
+    it('appends the brevity instruction after attachment content for a voice-flagged message with attachments', async () => {
+        const voiceMessageWithImage = {
+            ...queuedMessage,
+            voiceMode: true,
+            attachments: [
+                {
+                    id: 'att-1',
+                    name: 'photo.png',
+                    type: 'image/png',
+                    size: 1024,
+                    contentType: 'image',
+                    data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+                },
+            ],
+        };
+        mockSessionDomainService.peekNextMessage.mockReturnValue(voiceMessageWithImage);
+        mockSessionDomainService.dequeueNext.mockReturnValue(voiceMessageWithImage);
+        mockSessionService.getSessionClient.mockReturnValue({ sessionId: 's1', threadId: 't1' });
+        await chatMessageHandlerService.tryDispatchNextMessage('s1');
+        const call = mockSessionService.sendSessionMessage.mock.calls[0];
+        if (!call) {
+            throw new Error('sendSessionMessage was not called');
+        }
+        const [, content] = call;
+        expect(Array.isArray(content)).toBe(true);
+        expect(content.at(-1)).toEqual({ type: 'text', text: VOICE_MODE_BREVITY_INSTRUCTION });
+        expect(content.some((block) => block.type === 'image')).toBe(true);
+    });
+    it('appends the brevity instruction after pasted text content for a voice-flagged message with a text attachment', async () => {
+        const voiceMessageWithText = {
+            ...queuedMessage,
+            voiceMode: true,
+            attachments: [
+                {
+                    id: 'text-1',
+                    name: 'notes.txt',
+                    type: 'text/plain',
+                    size: 11,
+                    contentType: 'text',
+                    data: 'pasted data',
+                },
+            ],
+        };
+        mockSessionDomainService.peekNextMessage.mockReturnValue(voiceMessageWithText);
+        mockSessionDomainService.dequeueNext.mockReturnValue(voiceMessageWithText);
+        mockSessionService.getSessionClient.mockReturnValue({ sessionId: 's1', threadId: 't1' });
+        await chatMessageHandlerService.tryDispatchNextMessage('s1');
+        expect(mockSessionService.sendSessionMessage).toHaveBeenCalledWith('s1', [
+            { type: 'text', text: 'hello\n\n[Pasted content: notes.txt]\npasted data' },
+            { type: 'text', text: VOICE_MODE_BREVITY_INSTRUCTION },
+        ]);
+    });
     it('persists dispatched user message before turn completion', async () => {
         const client = {
             isCompactingActive: vi.fn().mockReturnValue(false),
@@ -821,19 +782,18 @@ describe('chatMessageHandlerService.tryDispatchNextMessage', () => {
             },
         };
         const client = { sessionId: 's1', threadId: 't1' };
-        const getOrCreate = vi.fn(async () => client);
-        chatMessageHandlerService.setClientCreator({ getOrCreate });
+        mockSessionService.getOrCreateSessionClient.mockResolvedValue(client);
         mockSessionDomainService.peekNextMessage.mockReturnValue(planMessage);
         mockSessionDomainService.dequeueNext.mockReturnValue(planMessage);
         mockSessionService.getSessionClient.mockReturnValueOnce(undefined).mockReturnValue(client);
         await chatMessageHandlerService.tryDispatchNextMessage('s1');
-        expect(getOrCreate).toHaveBeenCalledWith('s1', {
+        expect(mockSessionService.getOrCreateSessionClient).toHaveBeenCalledWith('s1', {
             thinkingEnabled: false,
             planModeEnabled: true,
             model: undefined,
             reasoningEffort: undefined,
         });
-        expect(getOrCreate.mock.invocationCallOrder[0]).toBeLessThan(mockSessionService.setSessionCollaborationMode.mock.invocationCallOrder[0] ?? 0);
+        expect(mockSessionService.getOrCreateSessionClient.mock.invocationCallOrder[0]).toBeLessThan(mockSessionService.setSessionCollaborationMode.mock.invocationCallOrder[0] ?? 0);
         expect(mockSessionService.setSessionCollaborationMode.mock.invocationCallOrder[0]).toBeLessThan(mockSessionService.sendSessionMessage.mock.invocationCallOrder[0] ?? 0);
     });
 });