factory-factory 0.3.21 → 0.4.0

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

@@ -1,11 +1,11 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { chatConnectionService } from '../../../../../backend/services/session/service/chat/chat-connection.service.js';
 import { sessionDomainService } from '../../../../../backend/services/session/service/session-domain.service.js';
+import { sessionEventBus } from '../../../../../backend/services/session/service/session-event-bus.js';
 import { SessionStatus } from '../../../../../shared/core/index.js';
 import { unsafeCoerce } from '../../../../../test-utils/unsafe-coerce.js';
 const mockNotifyToolStart = vi.fn();
 const mockNotifyToolComplete = vi.fn();
-const mockClearRatchetActiveSessionIfMatching = vi.fn();
+const mockRecordRatchetSessionEnd = vi.fn();
 const mockAcpTraceLoggerCloseSession = vi.fn();
 vi.mock('@/backend/services/logger.service', () => ({
     createLogger: () => ({
@@ -110,7 +110,7 @@ describe('SessionService', () => {
         vi.clearAllMocks();
         mockNotifyToolStart.mockReset();
         mockNotifyToolComplete.mockReset();
-        mockClearRatchetActiveSessionIfMatching.mockReset();
+        mockRecordRatchetSessionEnd.mockReset();
         mockAcpTraceLoggerCloseSession.mockReset();
         const acpProcessor = getAcpProcessorState();
         acpProcessor.pendingAcpToolCalls.clear();
@@ -121,7 +121,7 @@ describe('SessionService', () => {
             workspace: {
                 markSessionRunning: vi.fn(),
                 markSessionIdle: vi.fn(),
-                clearRatchetActiveSessionIfMatching: mockClearRatchetActiveSessionIfMatching,
+                recordRatchetSessionEnd: mockRecordRatchetSessionEnd,
             },
         });
         vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
@@ -669,11 +669,71 @@ describe('SessionService', () => {
             status: SessionStatus.IDLE,
         }, [SessionStatus.RUNNING]);
     });
-    it('skips stop when already stopping', async () => {
+    it('still clears lifecycle state when only the runtime is already stopping', async () => {
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(true);
+        const clearQueuedWorkSpy = vi.spyOn(sessionDomainService, 'clearQueuedWork');
         await sessionService.stopSession('session-1');
         expect(acpRuntimeManager.stopClient).not.toHaveBeenCalled();
         expect(sessionRepository.updateSessionIfStatus).not.toHaveBeenCalled();
+        expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: true });
+    });
+    it('rejects startup and client acquisition after lifecycle stop is reserved', async () => {
+        const session = unsafeCoerce({
+            id: 'session-1',
+            workspaceId: 'workspace-1',
+            status: SessionStatus.IDLE,
+            workflow: 'default',
+            model: 'sonnet',
+            provider: 'CLAUDE',
+            providerSessionId: null,
+        });
+        const workspace = unsafeCoerce({
+            id: 'workspace-1',
+            worktreePath: '/tmp/work',
+            branchName: 'feature-branch',
+            isAutoGeneratedBranch: false,
+            hasHadSessions: true,
+            name: 'Workspace A',
+            description: null,
+            projectId: 'project-1',
+        });
+        const acpHandle = unsafeCoerce({
+            getPid: vi.fn().mockReturnValue(456),
+            isPromptInFlight: false,
+            configOptions: [],
+        });
+        const stopLoad = createDeferred();
+        vi.mocked(sessionRepository.getSessionById)
+            .mockReturnValueOnce(stopLoad.promise)
+            .mockResolvedValue(session);
+        vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
+        vi.mocked(sessionRepository.markWorkspaceHasHadSessions).mockResolvedValue();
+        vi.mocked(sessionRepository.updateSession).mockResolvedValue(session);
+        vi.mocked(sessionPromptBuilder.shouldInjectBranchRename).mockReturnValue(false);
+        vi.mocked(sessionPromptBuilder.buildSystemPrompt).mockReturnValue({
+            workflowPrompt: undefined,
+            systemPrompt: undefined,
+            injectedBranchRename: false,
+        });
+        vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
+        mockCreatedAcpClient(acpHandle);
+        const stopPromise = sessionService.stopSession('session-1');
+        await vi.waitFor(() => {
+            expect(sessionRepository.getSessionById).toHaveBeenCalledTimes(1);
+        });
+        const startError = await sessionService
+            .startSession('session-1', { initialPrompt: '' })
+            .then(() => null)
+            .catch((error) => error);
+        const acquisitionError = await sessionService
+            .getOrCreateSessionClientFromRecord(session)
+            .then(() => null)
+            .catch((error) => error);
+        stopLoad.resolve(session);
+        await stopPromise;
+        expect(startError).toEqual(expect.objectContaining({ message: 'Session is currently being stopped' }));
+        expect(acquisitionError).toEqual(expect.objectContaining({ message: 'Session is currently being stopped' }));
+        expect(acpRuntimeManager.getOrCreateClient).not.toHaveBeenCalled();
     });
     it('clears queued work during manual stop', async () => {
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
@@ -683,6 +743,21 @@ describe('SessionService', () => {
         await sessionService.stopSession('session-1');
         expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: true });
     });
+    it('clears queued work before waiting for the runtime to stop', async () => {
+        const runtimeStop = createDeferred();
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.stopClient).mockReturnValue(runtimeStop.promise);
+        vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
+        const clearQueuedWorkSpy = vi.spyOn(sessionDomainService, 'clearQueuedWork');
+        const stopPromise = sessionService.stopSession('session-1');
+        await vi.waitFor(() => {
+            expect(acpRuntimeManager.stopClient).toHaveBeenCalledWith('session-1');
+        });
+        const clearedBeforeRuntimeStopped = clearQueuedWorkSpy.mock.calls.length > 0;
+        runtimeStop.resolve();
+        await stopPromise;
+        expect(clearedBeforeRuntimeStopped).toBe(true);
+    });
     it('rejects queued ACP prompts during manual stop', async () => {
         const firstPrompt = createDeferred();
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
@@ -730,6 +805,32 @@ describe('SessionService', () => {
         firstPrompt.resolve({ stopReason: 'end_turn' });
         await expect(firstSend).resolves.toBe('end_turn');
     });
+    it('marks prompt turns idle with the activity generation that started them', async () => {
+        const markSessionRunning = vi.fn().mockReturnValueOnce(101).mockReturnValueOnce(102);
+        const markSessionIdle = vi.fn();
+        sessionService.configure({
+            workspace: {
+                markSessionRunning,
+                markSessionIdle,
+                recordRatchetSessionEnd: mockRecordRatchetSessionEnd,
+            },
+        });
+        const acpProcessor = getAcpProcessorState();
+        acpProcessor.sessionToWorkspace.set('session-activity-generation', 'workspace-1');
+        vi.mocked(acpRuntimeManager.sendPrompt)
+            .mockResolvedValueOnce({ stopReason: 'end_turn' })
+            .mockResolvedValueOnce({ stopReason: 'end_turn' });
+        await sessionService.sendAcpMessage('session-activity-generation', [
+            { type: 'text', text: 'first' },
+        ]);
+        await sessionService.sendAcpMessage('session-activity-generation', [
+            { type: 'text', text: 'second' },
+        ]);
+        expect(markSessionRunning).toHaveBeenNthCalledWith(1, 'workspace-1', 'session-activity-generation');
+        expect(markSessionRunning).toHaveBeenNthCalledWith(2, 'workspace-1', 'session-activity-generation');
+        expect(markSessionIdle).toHaveBeenNthCalledWith(1, 'workspace-1', 'session-activity-generation', 101);
+        expect(markSessionIdle).toHaveBeenNthCalledWith(2, 'workspace-1', 'session-activity-generation', 102);
+    });
     it('rejects queued ACP prompts during unexpected runtime exit', async () => {
         const session = unsafeCoerce({
             id: 'session-runtime-exit',
@@ -905,17 +1006,12 @@ describe('SessionService', () => {
         vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
         const clearSessionSpy = vi.spyOn(sessionDomainService, 'clearSession');
-        const connectionId = 'conn-active-session';
-        chatConnectionService.register(connectionId, {
-            ws: {},
-            dbSessionId: 'session-active',
-            workingDir: null,
-        });
+        sessionEventBus.registerViewerCountProvider((sessionId) => sessionId === 'session-active' ? 1 : 0);
         try {
             await sessionService.stopSession('session-active');
         }
         finally {
-            chatConnectionService.unregister(connectionId);
+            sessionEventBus.registerViewerCountProvider(null);
         }
         expect(clearSessionSpy).not.toHaveBeenCalled();
     });
@@ -925,7 +1021,7 @@ describe('SessionService', () => {
             workspace: {
                 markSessionRunning: vi.fn(),
                 markSessionIdle,
-                clearRatchetActiveSessionIfMatching: mockClearRatchetActiveSessionIfMatching,
+                recordRatchetSessionEnd: mockRecordRatchetSessionEnd,
             },
         });
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
@@ -953,7 +1049,7 @@ describe('SessionService', () => {
             status: SessionStatus.IDLE,
         }, [SessionStatus.RUNNING]);
         expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: true });
-        expect(mockClearRatchetActiveSessionIfMatching).not.toHaveBeenCalled();
+        expect(mockRecordRatchetSessionEnd).not.toHaveBeenCalled();
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
     it('finalizes orphaned ACP tool calls during manual stop', async () => {
@@ -1007,7 +1103,7 @@ describe('SessionService', () => {
             workspace: {
                 markSessionRunning: vi.fn(),
                 markSessionIdle,
-                clearRatchetActiveSessionIfMatching: mockClearRatchetActiveSessionIfMatching,
+                recordRatchetSessionEnd: mockRecordRatchetSessionEnd,
             },
         });
         const pendingToolCalls = getAcpProcessorState().pendingAcpToolCalls;
@@ -1067,7 +1163,7 @@ describe('SessionService', () => {
         vi.mocked(sessionRepository.deleteSession).mockResolvedValue({});
         try {
             await sessionService.stopSession('session-1');
-            expect(mockClearRatchetActiveSessionIfMatching).toHaveBeenCalledWith('workspace-1', 'session-1');
+            expect(mockRecordRatchetSessionEnd).toHaveBeenCalledWith('workspace-1', 'session-1', 'COMPLETED');
             expect(closedSessionPersistenceService.persistClosedSession).toHaveBeenCalledWith({
                 sessionId: 'session-1',
                 workspaceId: 'workspace-1',
@@ -1128,7 +1224,7 @@ describe('SessionService', () => {
         await sessionService.stopSession('session-3', {
             cleanupTransientRatchetSession: false,
         });
-        expect(mockClearRatchetActiveSessionIfMatching).toHaveBeenCalledWith('workspace-1', 'session-3');
+        expect(mockRecordRatchetSessionEnd).toHaveBeenCalledWith('workspace-1', 'session-3', 'COMPLETED');
         expect(closedSessionPersistenceService.persistClosedSession).not.toHaveBeenCalled();
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
@@ -1242,7 +1338,7 @@ describe('SessionService', () => {
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
             status: SessionStatus.COMPLETED,
         });
-        expect(mockClearRatchetActiveSessionIfMatching).toHaveBeenCalledWith('workspace-1', 'session-1');
+        expect(mockRecordRatchetSessionEnd).toHaveBeenCalledWith('workspace-1', 'session-1', 'COMPLETED');
         expect(sessionRepository.deleteSession).toHaveBeenCalledWith('session-1');
     });
     it('does not delete ratchet session when closed-session persistence fails', async () => {
@@ -1341,6 +1437,52 @@ describe('SessionService', () => {
         });
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
+    it.each([
+        { exitCode: 1, expectedStatus: SessionStatus.FAILED },
+        { exitCode: null, expectedStatus: SessionStatus.FAILED },
+    ])('persists $expectedStatus on ACP exit code $exitCode', async ({ exitCode, expectedStatus, }) => {
+        const session = unsafeCoerce({
+            id: 'session-2',
+            workspaceId: 'workspace-1',
+            status: SessionStatus.IDLE,
+            workflow: 'default',
+            model: 'sonnet',
+            provider: 'CLAUDE',
+            providerSessionId: null,
+        });
+        const workspace = unsafeCoerce({
+            id: 'workspace-1',
+            worktreePath: '/tmp/work',
+            branchName: 'fix-branch',
+            isAutoGeneratedBranch: false,
+            name: 'Workspace A',
+            description: null,
+            projectId: 'project-1',
+        });
+        const acpHandle = unsafeCoerce({
+            getPid: vi.fn().mockReturnValue(789),
+            isPromptInFlight: false,
+            configOptions: [],
+        });
+        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
+        vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
+        vi.mocked(sessionRepository.markWorkspaceHasHadSessions).mockResolvedValue();
+        vi.mocked(sessionRepository.updateSession).mockResolvedValue(session);
+        vi.mocked(sessionPromptBuilder.shouldInjectBranchRename).mockReturnValue(false);
+        vi.mocked(sessionPromptBuilder.buildSystemPrompt).mockReturnValue({
+            workflowPrompt: undefined,
+            systemPrompt: undefined,
+            injectedBranchRename: false,
+        });
+        mockCreatedAcpClient(acpHandle);
+        vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
+        await sessionService.startSession('session-2');
+        const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
+        await acpHandlers.onExit('session-2', exitCode);
+        expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-2', {
+            status: expectedStatus,
+        });
+    });
     it('closes ACP trace session even when stop cleanup throws', async () => {
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
         vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
@@ -1597,6 +1739,35 @@ describe('SessionService', () => {
             vi.useRealTimers();
         }
     });
+    it('does not dispatch prompt-turn completion when a prompt settles during stop', async () => {
+        vi.useFakeTimers();
+        try {
+            const prompt = createDeferred();
+            const runtimeStop = createDeferred();
+            const onPromptTurnComplete = vi.fn().mockResolvedValue(undefined);
+            sessionService.setPromptTurnCompleteHandler(onPromptTurnComplete);
+            vi.mocked(acpRuntimeManager.sendPrompt).mockReturnValue(prompt.promise);
+            vi.mocked(acpRuntimeManager.stopClient).mockReturnValue(runtimeStop.promise);
+            const sendPromise = sessionService.sendAcpMessage('session-1', [
+                { type: 'text', text: 'hello' },
+            ]);
+            await Promise.resolve();
+            const stopPromise = sessionService.stopSession('session-1');
+            await vi.waitFor(() => {
+                expect(acpRuntimeManager.stopClient).toHaveBeenCalledWith('session-1');
+            });
+            prompt.resolve({ stopReason: 'end_turn' });
+            await expect(sendPromise).resolves.toBe('end_turn');
+            await vi.runOnlyPendingTimersAsync();
+            const completionDispatchedDuringStop = onPromptTurnComplete.mock.calls.length > 0;
+            runtimeStop.resolve();
+            await stopPromise;
+            expect(completionDispatchedDuringStop).toBe(false);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
     it('swallows prompt-turn completion callback failures', async () => {
         vi.useFakeTimers();
         try {