factory-factory 0.2.1 → 0.2.3

package/dist/src/backend/services/ci-fixer.service.test.js

@@ -1,30 +1,15 @@
 import { SessionStatus } from '../../../prisma/generated/client.js';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-vi.mock('../db', () => ({
-    prisma: {
-        $transaction: vi.fn(),
-    },
-}));
-vi.mock('../resource_accessors/workspace.accessor', () => ({
-    workspaceAccessor: {
-        findById: vi.fn(),
-    },
-}));
-vi.mock('../resource_accessors/claude-session.accessor', () => ({
-    claudeSessionAccessor: {
-        findByWorkspaceId: vi.fn(),
-    },
-}));
-vi.mock('./config.service', () => ({
-    configService: {
-        getMaxSessionsPerWorkspace: vi.fn(),
+vi.mock('./fixer-session.service', () => ({
+    fixerSessionService: {
+        acquireAndDispatch: vi.fn(),
+        getActiveSession: vi.fn(),
     },
 }));
 vi.mock('./session.service', () => ({
     sessionService: {
         isSessionWorking: vi.fn(),
         getClient: vi.fn(),
-        startClaudeSession: vi.fn(),
     },
 }));
 vi.mock('./logger.service', () => ({
@@ -35,527 +20,82 @@ vi.mock('./logger.service', () => ({
         error: vi.fn(),
     }),
 }));
-import { prisma } from '../db.js';
-import { claudeSessionAccessor } from '../resource_accessors/claude-session.accessor.js';
-import { workspaceAccessor } from '../resource_accessors/workspace.accessor.js';
 import { ciFixerService } from './ci-fixer.service.js';
-import { configService } from './config.service.js';
+import { fixerSessionService } from './fixer-session.service.js';
 import { sessionService } from './session.service.js';
-function createMockWorkspace(overrides = {}) {
-    return {
-        id: 'workspace-1',
-        worktreePath: '/path/to/worktree',
-        ...overrides,
-    };
-}
-function createMockSession(overrides = {}) {
-    return {
-        id: 'session-1',
-        workspaceId: 'workspace-1',
-        workflow: 'ci-fix',
-        status: SessionStatus.IDLE,
-        model: 'sonnet',
-        name: null,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        claudeSessionId: null,
-        claudeProcessPid: null,
-        ...overrides,
-    };
-}
-function createMockTransactionContext() {
-    return {
-        claudeSession: {
-            findFirst: vi.fn(),
-            findMany: vi.fn(),
-            create: vi.fn(),
-        },
-    };
-}
-function mockTransaction(txContext) {
-    vi.mocked(prisma.$transaction).mockImplementation((callback) => Promise.resolve(callback(txContext)));
-}
-function mockSlowTransaction(txContext, delayMs) {
-    vi.mocked(prisma.$transaction).mockImplementation(async (callback) => {
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
-        return callback(txContext);
-    });
-}
 describe('CIFixerService', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
-    describe('triggerCIFix - workspace validation', () => {
-        it('should skip if workspace does not exist', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(null);
-            const result = await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(result).toEqual({
-                status: 'skipped',
-                reason: 'Workspace not ready (no worktree path)',
-            });
-        });
-        it('should skip if workspace has no worktree path', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace({ worktreePath: null }));
-            const result = await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(result).toEqual({
-                status: 'skipped',
-                reason: 'Workspace not ready (no worktree path)',
-            });
-        });
-    });
-    describe('triggerCIFix - session creation', () => {
-        it('should create new session when none exists', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(null);
-            txContext.claudeSession.findMany.mockResolvedValue([]);
-            txContext.claudeSession.create.mockResolvedValue(createMockSession({ id: 'new-session-id' }));
-            mockTransaction(txContext);
-            vi.mocked(configService.getMaxSessionsPerWorkspace).mockReturnValue(10);
-            vi.mocked(sessionService.startClaudeSession).mockResolvedValue(undefined);
-            const result = await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(result).toEqual({
-                status: 'started',
-                sessionId: 'new-session-id',
-            });
-            expect(txContext.claudeSession.create).toHaveBeenCalledWith({
-                data: expect.objectContaining({
-                    workspaceId: 'workspace-1',
-                    workflow: 'ci-fix',
-                    name: 'CI Fixing',
-                    status: SessionStatus.IDLE,
-                }),
-            });
-            expect(sessionService.startClaudeSession).toHaveBeenCalledWith('new-session-id', {
-                initialPrompt: expect.stringContaining('CI Failure Alert'),
-            });
+    it('returns started when shared fixer service starts a session', async () => {
+        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+            status: 'started',
+            sessionId: 's1',
         });
-        it('should inherit model from most recent workspace session', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst
-                .mockResolvedValueOnce(null)
-                .mockResolvedValueOnce({ model: 'opus' });
-            txContext.claudeSession.findMany.mockResolvedValue([]);
-            txContext.claudeSession.create.mockResolvedValue(createMockSession({ model: 'opus' }));
-            mockTransaction(txContext);
-            vi.mocked(configService.getMaxSessionsPerWorkspace).mockReturnValue(10);
-            vi.mocked(sessionService.startClaudeSession).mockResolvedValue(undefined);
-            await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(txContext.claudeSession.create).toHaveBeenCalledWith({
-                data: expect.objectContaining({
-                    model: 'opus',
-                }),
-            });
-        });
-        it('should use sonnet as default model when no recent session exists', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(null);
-            txContext.claudeSession.findMany.mockResolvedValue([]);
-            txContext.claudeSession.create.mockResolvedValue(createMockSession());
-            mockTransaction(txContext);
-            vi.mocked(configService.getMaxSessionsPerWorkspace).mockReturnValue(10);
-            vi.mocked(sessionService.startClaudeSession).mockResolvedValue(undefined);
-            await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(txContext.claudeSession.create).toHaveBeenCalledWith({
-                data: expect.objectContaining({
-                    model: 'sonnet',
-                }),
-            });
+        const result = await ciFixerService.triggerCIFix({
+            workspaceId: 'w1',
+            prUrl: 'https://github.com/org/repo/pull/1',
+            prNumber: 1,
         });
+        expect(result).toEqual({ status: 'started', sessionId: 's1' });
     });
-    describe('triggerCIFix - session limit enforcement', () => {
-        it('should skip if workspace session limit is reached', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(null);
-            txContext.claudeSession.findMany.mockResolvedValue([
-                { id: 'session-1' },
-                { id: 'session-2' },
-                { id: 'session-3' },
-            ]);
-            mockTransaction(txContext);
-            vi.mocked(configService.getMaxSessionsPerWorkspace).mockReturnValue(3);
-            const result = await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(result).toEqual({
-                status: 'skipped',
-                reason: 'Workspace session limit reached',
-            });
-            expect(txContext.claudeSession.create).not.toHaveBeenCalled();
-        });
-        it('should allow session creation when under limit', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(null);
-            txContext.claudeSession.findMany.mockResolvedValue([{ id: 'session-1' }]);
-            txContext.claudeSession.create.mockResolvedValue(createMockSession({ id: 'new-session' }));
-            mockTransaction(txContext);
-            vi.mocked(configService.getMaxSessionsPerWorkspace).mockReturnValue(3);
-            vi.mocked(sessionService.startClaudeSession).mockResolvedValue(undefined);
-            const result = await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(result.status).toBe('started');
-            expect(txContext.claudeSession.create).toHaveBeenCalled();
-        });
+    it('returns already_fixing when shared fixer service returns already_active', async () => {
+        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+            status: 'already_active',
+            sessionId: 's1',
+            reason: 'working',
+        });
+        const result = await ciFixerService.triggerCIFix({
+            workspaceId: 'w1',
+            prUrl: 'https://github.com/org/repo/pull/1',
+            prNumber: 1,
+        });
+        expect(result).toEqual({ status: 'already_fixing', sessionId: 's1' });
     });
-    describe('triggerCIFix - existing session handling', () => {
-        it('should return already_fixing when session is actively working', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const existingSession = createMockSession({
-                id: 'existing-session',
-                status: SessionStatus.RUNNING,
-            });
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(existingSession);
-            mockTransaction(txContext);
-            vi.mocked(sessionService.isSessionWorking).mockReturnValue(true);
-            const result = await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(result).toEqual({
-                status: 'already_fixing',
-                sessionId: 'existing-session',
-            });
-            expect(sessionService.startClaudeSession).not.toHaveBeenCalled();
-        });
-        it('should send message to running but idle session', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const existingSession = createMockSession({
-                id: 'existing-session',
-                status: SessionStatus.RUNNING,
-            });
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(existingSession);
-            mockTransaction(txContext);
-            vi.mocked(sessionService.isSessionWorking).mockReturnValue(false);
-            const mockClient = {
-                sendMessage: vi.fn().mockResolvedValue(undefined),
-            };
-            vi.mocked(sessionService.getClient).mockReturnValue(mockClient);
-            const result = await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(result).toEqual({
-                status: 'already_fixing',
-                sessionId: 'existing-session',
-            });
-            expect(mockClient.sendMessage).toHaveBeenCalledWith(expect.stringContaining('CI Failure'));
+    it('returns skipped when shared fixer service cannot acquire session', async () => {
+        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+            status: 'skipped',
+            reason: 'Workspace session limit reached',
         });
-        it('should restart IDLE session', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const existingSession = createMockSession({
-                id: 'idle-session',
-                status: SessionStatus.IDLE,
-            });
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(existingSession);
-            mockTransaction(txContext);
-            vi.mocked(sessionService.isSessionWorking).mockReturnValue(false);
-            vi.mocked(sessionService.startClaudeSession).mockResolvedValue(undefined);
-            const result = await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(result).toEqual({
-                status: 'started',
-                sessionId: 'idle-session',
-            });
-            expect(sessionService.startClaudeSession).toHaveBeenCalledWith('idle-session', {
-                initialPrompt: expect.stringContaining('CI Failure'),
-            });
+        const result = await ciFixerService.triggerCIFix({
+            workspaceId: 'w1',
+            prUrl: 'https://github.com/org/repo/pull/1',
+            prNumber: 1,
         });
+        expect(result).toEqual({ status: 'skipped', reason: 'Workspace session limit reached' });
     });
-    describe('triggerCIFix - race condition prevention', () => {
-        it('should return pending promise for concurrent triggers on same workspace', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(null);
-            txContext.claudeSession.findMany.mockResolvedValue([]);
-            txContext.claudeSession.create.mockResolvedValue(createMockSession({ id: 'new-session' }));
-            mockSlowTransaction(txContext, 50);
-            vi.mocked(configService.getMaxSessionsPerWorkspace).mockReturnValue(10);
-            vi.mocked(sessionService.startClaudeSession).mockResolvedValue(undefined);
-            const [result1, result2] = await Promise.all([
-                ciFixerService.triggerCIFix({
-                    workspaceId: 'workspace-1',
-                    prUrl: 'https://github.com/org/repo/pull/123',
-                    prNumber: 123,
-                }),
-                ciFixerService.triggerCIFix({
-                    workspaceId: 'workspace-1',
-                    prUrl: 'https://github.com/org/repo/pull/123',
-                    prNumber: 123,
-                }),
-            ]);
-            expect(result1).toEqual(result2);
-            expect(result1.status).toBe('started');
-            expect(txContext.claudeSession.create).toHaveBeenCalledTimes(1);
+    it('returns error when shared fixer service errors', async () => {
+        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+            status: 'error',
+            error: 'boom',
         });
-        it('should allow concurrent triggers on different workspaces', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(null);
-            txContext.claudeSession.findMany.mockResolvedValue([]);
-            let createCallCount = 0;
-            txContext.claudeSession.create.mockImplementation(() => {
-                createCallCount++;
-                return Promise.resolve(createMockSession({ id: `session-${createCallCount}` }));
-            });
-            mockTransaction(txContext);
-            vi.mocked(configService.getMaxSessionsPerWorkspace).mockReturnValue(10);
-            vi.mocked(sessionService.startClaudeSession).mockResolvedValue(undefined);
-            const [result1, result2] = await Promise.all([
-                ciFixerService.triggerCIFix({
-                    workspaceId: 'workspace-1',
-                    prUrl: 'https://github.com/org/repo/pull/123',
-                    prNumber: 123,
-                }),
-                ciFixerService.triggerCIFix({
-                    workspaceId: 'workspace-2',
-                    prUrl: 'https://github.com/org/repo/pull/456',
-                    prNumber: 456,
-                }),
-            ]);
-            expect(result1.status).toBe('started');
-            expect(result2.status).toBe('started');
-            expect(txContext.claudeSession.create).toHaveBeenCalledTimes(2);
+        const result = await ciFixerService.triggerCIFix({
+            workspaceId: 'w1',
+            prUrl: 'https://github.com/org/repo/pull/1',
+            prNumber: 1,
         });
+        expect(result).toEqual({ status: 'error', error: 'boom' });
     });
-    describe('triggerCIFix - initial prompt building', () => {
-        it('should include PR number and URL in prompt', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(null);
-            txContext.claudeSession.findMany.mockResolvedValue([]);
-            txContext.claudeSession.create.mockResolvedValue(createMockSession());
-            mockTransaction(txContext);
-            vi.mocked(configService.getMaxSessionsPerWorkspace).mockReturnValue(10);
-            vi.mocked(sessionService.startClaudeSession).mockResolvedValue(undefined);
-            await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(sessionService.startClaudeSession).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-                initialPrompt: expect.stringMatching(/PR #123/),
-            }));
-            expect(sessionService.startClaudeSession).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-                initialPrompt: expect.stringContaining('https://github.com/org/repo/pull/123'),
-            }));
-        });
-        it('should include failure details in prompt when provided', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(null);
-            txContext.claudeSession.findMany.mockResolvedValue([]);
-            txContext.claudeSession.create.mockResolvedValue(createMockSession());
-            mockTransaction(txContext);
-            vi.mocked(configService.getMaxSessionsPerWorkspace).mockReturnValue(10);
-            vi.mocked(sessionService.startClaudeSession).mockResolvedValue(undefined);
-            await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-                failureDetails: {
-                    failedChecks: [
-                        { name: 'typecheck', conclusion: 'failure', detailsUrl: 'https://example.com/logs' },
-                        { name: 'lint', conclusion: 'failure' },
-                    ],
-                },
-            });
-            const call = vi.mocked(sessionService.startClaudeSession).mock.calls[0];
-            const prompt = call?.[1]?.initialPrompt ?? '';
-            expect(call).toBeDefined();
-            expect(prompt).toContain('typecheck');
-            expect(prompt).toContain('lint');
-            expect(prompt).toContain('https://example.com/logs');
+    it('checks active session working status', async () => {
+        vi.mocked(fixerSessionService.getActiveSession).mockResolvedValue({
+            id: 's1',
+            status: SessionStatus.RUNNING,
         });
+        vi.mocked(sessionService.isSessionWorking).mockReturnValue(true);
+        await expect(ciFixerService.isFixingInProgress('w1')).resolves.toBe(true);
     });
-    describe('triggerCIFix - error handling', () => {
-        it('should return error status when transaction fails', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            vi.mocked(prisma.$transaction).mockRejectedValue(new Error('Database connection lost'));
-            const result = await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(result).toEqual({
-                status: 'error',
-                error: 'Database connection lost',
-            });
-        });
-        it('should return error status when session start fails', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(createMockWorkspace());
-            const txContext = createMockTransactionContext();
-            txContext.claudeSession.findFirst.mockResolvedValue(null);
-            txContext.claudeSession.findMany.mockResolvedValue([]);
-            txContext.claudeSession.create.mockResolvedValue(createMockSession());
-            mockTransaction(txContext);
-            vi.mocked(configService.getMaxSessionsPerWorkspace).mockReturnValue(10);
-            vi.mocked(sessionService.startClaudeSession).mockRejectedValue(new Error('Failed to spawn Claude CLI'));
-            const result = await ciFixerService.triggerCIFix({
-                workspaceId: 'workspace-1',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prNumber: 123,
-            });
-            expect(result).toEqual({
-                status: 'error',
-                error: 'Failed to spawn Claude CLI',
-            });
-        });
-    });
-    describe('isFixingInProgress', () => {
-        it('should return false when no CI fix session exists', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
-            const result = await ciFixerService.isFixingInProgress('workspace-1');
-            expect(result).toBe(false);
-        });
-        it('should return false when CI fix session exists but is not working', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([
-                createMockSession({ id: 'ci-fix-session', workflow: 'ci-fix', status: SessionStatus.IDLE }),
-            ]);
-            vi.mocked(sessionService.isSessionWorking).mockReturnValue(false);
-            const result = await ciFixerService.isFixingInProgress('workspace-1');
-            expect(result).toBe(false);
-        });
-        it('should return true when CI fix session is actively working', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([
-                createMockSession({
-                    id: 'ci-fix-session',
-                    workflow: 'ci-fix',
-                    status: SessionStatus.RUNNING,
-                }),
-            ]);
-            vi.mocked(sessionService.isSessionWorking).mockReturnValue(true);
-            const result = await ciFixerService.isFixingInProgress('workspace-1');
-            expect(result).toBe(true);
-        });
-    });
-    describe('getActiveCIFixSession', () => {
-        it('should return null when no CI fix session exists', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
-            const result = await ciFixerService.getActiveCIFixSession('workspace-1');
-            expect(result).toBeNull();
-        });
-        it('should return null when only non-CI-fix sessions exist', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([
-                createMockSession({ workflow: 'default', status: SessionStatus.RUNNING }),
-            ]);
-            const result = await ciFixerService.getActiveCIFixSession('workspace-1');
-            expect(result).toBeNull();
-        });
-        it('should return CI fix session when one exists', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([
-                createMockSession({
-                    id: 'ci-fix-session',
-                    workflow: 'ci-fix',
-                    status: SessionStatus.RUNNING,
-                }),
-            ]);
-            const result = await ciFixerService.getActiveCIFixSession('workspace-1');
-            expect(result).toEqual({
-                id: 'ci-fix-session',
-                status: SessionStatus.RUNNING,
-            });
-        });
-        it('should ignore completed CI fix sessions', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([
-                createMockSession({
-                    id: 'old-session',
-                    workflow: 'ci-fix',
-                    status: SessionStatus.COMPLETED,
-                }),
-            ]);
-            const result = await ciFixerService.getActiveCIFixSession('workspace-1');
-            expect(result).toBeNull();
-        });
-    });
-    describe('notifyCIPassed', () => {
-        it('should return false when no CI fix session exists', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
-            const result = await ciFixerService.notifyCIPassed('workspace-1');
-            expect(result).toBe(false);
-        });
-        it('should return false when session has no client', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([
-                createMockSession({
-                    id: 'ci-fix-session',
-                    workflow: 'ci-fix',
-                    status: SessionStatus.RUNNING,
-                }),
-            ]);
-            vi.mocked(sessionService.getClient).mockReturnValue(undefined);
-            const result = await ciFixerService.notifyCIPassed('workspace-1');
-            expect(result).toBe(false);
-        });
-        it('should return false when client is not running', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([
-                createMockSession({
-                    id: 'ci-fix-session',
-                    workflow: 'ci-fix',
-                    status: SessionStatus.RUNNING,
-                }),
-            ]);
-            const mockClient = {
-                isRunning: vi.fn().mockReturnValue(false),
-                sendMessage: vi.fn().mockResolvedValue(undefined),
-            };
-            vi.mocked(sessionService.getClient).mockReturnValue(mockClient);
-            const result = await ciFixerService.notifyCIPassed('workspace-1');
-            expect(result).toBe(false);
-            expect(mockClient.sendMessage).not.toHaveBeenCalled();
-        });
-        it('should send CI passed message and return true when session is running', async () => {
-            vi.mocked(claudeSessionAccessor.findByWorkspaceId).mockResolvedValue([
-                createMockSession({
-                    id: 'ci-fix-session',
-                    workflow: 'ci-fix',
-                    status: SessionStatus.RUNNING,
-                }),
-            ]);
-            const mockClient = {
-                isRunning: vi.fn().mockReturnValue(true),
-                sendMessage: vi.fn().mockResolvedValue(undefined),
-            };
-            vi.mocked(sessionService.getClient).mockReturnValue(mockClient);
-            const result = await ciFixerService.notifyCIPassed('workspace-1');
-            expect(result).toBe(true);
-            expect(mockClient.sendMessage).toHaveBeenCalledWith(expect.stringContaining('CI Passed'));
-        });
+    it('notifies CI passed when running client exists', async () => {
+        vi.mocked(fixerSessionService.getActiveSession).mockResolvedValue({
+            id: 's1',
+            status: SessionStatus.RUNNING,
+        });
+        const client = {
+            isRunning: vi.fn().mockReturnValue(true),
+            sendMessage: vi.fn().mockResolvedValue(undefined),
+        };
+        vi.mocked(sessionService.getClient).mockReturnValue(client);
+        await expect(ciFixerService.notifyCIPassed('w1')).resolves.toBe(true);
+        expect(client.sendMessage).toHaveBeenCalled();
     });
 });
 //# sourceMappingURL=ci-fixer.service.test.js.map