factory-factory 0.4.0 → 0.4.2

package/dist/src/backend/trpc/workspace.router.test.js

@@ -1,5 +1,8 @@
 import { PRState, RatchetState, WorkspaceStatus } from '../../../prisma/generated/client.js';
+import { TRPCError } from '@trpc/server';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ApplicationError } from '../../backend/lib/application-error.js';
+import { applicationGraphMocks, createFakeApplicationGraph } from '../../test-utils/application-graph.js';
 const mockWorkspaceDataService = vi.hoisted(() => ({
     findByProjectId: vi.fn(),
     findById: vi.fn(),
@@ -7,16 +10,15 @@ const mockWorkspaceDataService = vi.hoisted(() => ({
     delete: vi.fn(),
 }));
 const mockWorkspaceQueryService = vi.hoisted(() => ({
-    getProjectSummaryState: vi.fn(),
-    listWithKanbanState: vi.fn(),
-    listWithRuntimeState: vi.fn(),
+    listForProject: vi.fn(),
+    findWorkspaceIdsInKanbanColumn: vi.fn(),
     refreshFactoryConfigs: vi.fn(),
     getFactoryConfig: vi.fn(),
     syncPRStatus: vi.fn(),
     syncAllPRStatuses: vi.fn(),
     hasChanges: vi.fn(),
 }));
-const mockDeriveFlowState = vi.hoisted(() => vi.fn());
+const mockDeriveFlowState = applicationGraphMocks.deriveWorkspaceFlowStateFromWorkspace;
 const mockWorkspaceCreationCreate = vi.hoisted(() => vi.fn());
 const mockClearWorkspaceActivity = vi.hoisted(() => vi.fn());
 const mockArchiveWorkspace = vi.hoisted(() => vi.fn());
@@ -25,8 +27,8 @@ const mockInitializeWorkspaceWorktree = vi.hoisted(() => vi.fn());
 const mockBuildSessionSummaries = vi.hoisted(() => vi.fn());
 const mockHasWorkingSessionSummary = vi.hoisted(() => vi.fn());
 const mockDeriveWorkspaceSidebarStatus = vi.hoisted(() => vi.fn());
-const mockComputeKanbanColumn = vi.hoisted(() => vi.fn());
-const mockComputePendingRequestType = vi.hoisted(() => vi.fn());
+const mockComputeKanbanColumn = applicationGraphMocks.computeKanbanColumn;
+const mockComputePendingRequestType = applicationGraphMocks.computePendingRequestType;
 const mockSetWorkspaceRatcheting = vi.hoisted(() => vi.fn());
 const mockCheckWorkspaceById = vi.hoisted(() => vi.fn());
 const mockSessionRuntimeSnapshot = vi.hoisted(() => vi.fn());
@@ -41,52 +43,6 @@ const mockHasQueuedMessage = vi.hoisted(() => vi.fn());
 const mockTryDispatchNextMessage = vi.hoisted(() => vi.fn());
 const mockPersistChildNotification = vi.hoisted(() => vi.fn());
 const mockPersistParentNotification = vi.hoisted(() => vi.fn());
-vi.mock('@/backend/services/workspace', () => ({
-    workspaceDataService: mockWorkspaceDataService,
-    workspaceQueryService: mockWorkspaceQueryService,
-    workspaceAccessor: {
-        findByIdWithProject: (...args) => mockFindByIdWithProject(...args),
-    },
-    workspaceActivityService: {
-        clearWorkspace: (...args) => mockClearWorkspaceActivity(...args),
-    },
-    deriveWorkspaceFlowStateFromWorkspace: (...args) => mockDeriveFlowState(...args),
-    computeKanbanColumn: (...args) => mockComputeKanbanColumn(...args),
-    computePendingRequestType: (...args) => mockComputePendingRequestType(...args),
-    WorkspaceCreationService: class {
-        create = (...args) => mockWorkspaceCreationCreate(...args);
-    },
-}));
-vi.mock('@/backend/services/session', () => ({
-    sessionService: {
-        getRuntimeSnapshot: (...args) => mockSessionRuntimeSnapshot(...args),
-    },
-    sessionDomainService: {
-        getAllPendingRequests: () => new Map(),
-        appendClaudeEvent: (...args) => mockAppendClaudeEvent(...args),
-        emitDelta: (...args) => mockEmitDelta(...args),
-        enqueue: (...args) => mockEnqueue(...args),
-        hasQueuedMessage: (...args) => mockHasQueuedMessage(...args),
-    },
-    sessionDataService: {
-        createAgentSession: (...args) => mockCreateAgentSession(...args),
-    },
-    sessionProviderResolverService: {
-        resolveProviderForWorkspaceCreation: (explicitProvider) => mockResolveProviderForWorkspaceCreation(explicitProvider),
-    },
-    agentSessionAccessor: {
-        findByWorkspaceId: (...args) => mockFindSessionsByWorkspaceId(...args),
-    },
-    chatMessageHandlerService: {
-        tryDispatchNextMessage: (...args) => mockTryDispatchNextMessage(...args),
-    },
-}));
-vi.mock('@/backend/services/ratchet', () => ({
-    ratchetService: {
-        setWorkspaceRatcheting: (...args) => mockSetWorkspaceRatcheting(...args),
-        checkWorkspaceById: (...args) => mockCheckWorkspaceById(...args),
-    },
-}));
 vi.mock('@/backend/lib/session-summaries', () => ({
     buildWorkspaceSessionSummaries: (...args) => mockBuildSessionSummaries(...args),
     hasWorkingSessionSummary: (...args) => mockHasWorkingSessionSummary(...args),
@@ -94,44 +50,18 @@ vi.mock('@/backend/lib/session-summaries', () => ({
 vi.mock('@/shared/workspace-sidebar-status', () => ({
     deriveWorkspaceSidebarStatus: (...args) => mockDeriveWorkspaceSidebarStatus(...args),
 }));
-vi.mock('@/backend/orchestration/workspace-archive.orchestrator', () => ({
-    archiveWorkspace: (...args) => mockArchiveWorkspace(...args),
-    cleanupWorkspaceRuntimeResources: (...args) => mockCleanupWorkspaceRuntimeResources(...args),
-}));
-vi.mock('@/backend/orchestration/workspace-init.orchestrator', () => ({
-    initializeWorkspaceWorktree: (...args) => mockInitializeWorkspaceWorktree(...args),
-}));
-vi.mock('@/backend/orchestration/workspace-children.orchestrator', () => ({
-    createChildWorkspace: vi.fn(),
-    fireLifecycleNotification: vi.fn(),
-    persistChildNotification: (...args) => mockPersistChildNotification(...args),
-    persistParentNotification: (...args) => mockPersistParentNotification(...args),
-}));
 vi.mock('./workspace/workspace-helpers', () => ({
-    getWorkspaceWithProjectOrThrow: vi.fn(async (id) => ({
+    getWorkspaceWithProjectOrThrow: vi.fn(async (_service, id) => ({
         id,
         project: { slug: 'demo' },
     })),
 }));
-vi.mock('./workspace/files.trpc', () => ({
-    workspaceFilesRouter: { _def: { procedures: {} } },
-}));
-vi.mock('./workspace/git.trpc', () => ({
-    workspaceGitRouter: { _def: { procedures: {} } },
-}));
-vi.mock('./workspace/ide.trpc', () => ({
-    workspaceIdeRouter: { _def: { procedures: {} } },
-}));
-vi.mock('./workspace/init.trpc', () => ({
-    workspaceInitRouter: { _def: { procedures: {} } },
-}));
-vi.mock('./workspace/run-script.trpc', () => ({
-    workspaceRunScriptRouter: { _def: { procedures: {} } },
-}));
-import { workspaceRouter } from './workspace.trpc.js';
+import { workspaceCoreRouter } from './workspace.trpc.js';
 function createCaller(requestTrust) {
-    const sessionService = {
+    const fakeGraph = createFakeApplicationGraph('workspace-router');
+    const sessionLifecycleService = {
         stopWorkspaceSessions: vi.fn(async () => undefined),
+        getRuntimeSnapshot: (...args) => mockSessionRuntimeSnapshot(...args),
     };
     const runScriptService = {
         stopRunScript: vi.fn(async () => ({ success: true })),
@@ -148,33 +78,95 @@ function createCaller(requestTrust) {
             allHealthy: true,
         })),
     };
-    const caller = workspaceRouter.createCaller({
-        requestTrust,
-        appContext: {
-            services: {
-                configService: {
-                    getWorktreeBaseDir: () => '/tmp/worktrees',
-                    getMaxSessionsPerWorkspace: () => 2,
-                    getCorsConfig: () => ({
-                        allowedOrigins: ['http://localhost:3000', 'http://localhost:3001'],
-                    }),
-                },
-                cliHealthService,
-                createLogger: () => ({
-                    debug: vi.fn(),
-                    info: vi.fn(),
-                    warn: vi.fn(),
-                    error: vi.fn(),
-                }),
-                sessionService,
-                runScriptService,
-                terminalService,
-            },
-        },
+    const logger = Object.assign(fakeGraph.services.createLogger('workspace-router-test'), {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
     });
-    return { caller, sessionService, runScriptService, terminalService, cliHealthService };
+    const composedSessionLifecycleService = Object.assign({}, fakeGraph.services.sessionLifecycleService, sessionLifecycleService);
+    const composedRunScriptService = Object.assign({}, fakeGraph.services.runScriptService, runScriptService);
+    const composedTerminalService = Object.assign({}, fakeGraph.services.terminalService, terminalService);
+    const services = {
+        ...fakeGraph.services,
+        configService: Object.assign({}, fakeGraph.services.configService, {
+            getWorktreeBaseDir: () => '/tmp/worktrees',
+            getMaxSessionsPerWorkspace: () => 2,
+            getCorsConfig: () => ({
+                allowedOrigins: ['http://localhost:3000', 'http://localhost:3001'],
+            }),
+        }),
+        cliHealthService: Object.assign({}, fakeGraph.services.cliHealthService, cliHealthService),
+        createLogger: () => logger,
+        sessionLifecycleService: composedSessionLifecycleService,
+        sessionDataService: Object.assign({}, fakeGraph.services.sessionDataService, {
+            createAgentSession: (...args) => mockCreateAgentSession(...args),
+            findAgentSessionsByWorkspaceId: (...args) => mockFindSessionsByWorkspaceId(...args),
+        }),
+        sessionDomainService: Object.assign({}, fakeGraph.services.sessionDomainService, {
+            getAllPendingRequests: () => new Map(),
+            appendClaudeEvent: (...args) => mockAppendClaudeEvent(...args),
+            emitDelta: (...args) => mockEmitDelta(...args),
+            enqueue: (...args) => mockEnqueue(...args),
+            hasQueuedMessage: (...args) => mockHasQueuedMessage(...args),
+        }),
+        sessionProviderResolverService: Object.assign({}, fakeGraph.services.sessionProviderResolverService, {
+            resolveProviderForWorkspaceCreation: (explicitProvider) => mockResolveProviderForWorkspaceCreation(explicitProvider),
+        }),
+        chatMessageHandlerService: Object.assign({}, fakeGraph.services.chatMessageHandlerService, {
+            tryDispatchNextMessage: (...args) => mockTryDispatchNextMessage(...args),
+        }),
+        workspaceDataService: Object.assign({}, fakeGraph.services.workspaceDataService, mockWorkspaceDataService, { findByIdWithProject: (...args) => mockFindByIdWithProject(...args) }),
+        workspaceQueryService: Object.assign({}, fakeGraph.services.workspaceQueryService, mockWorkspaceQueryService),
+        runScriptConfigPersistenceService: Object.assign({}, fakeGraph.services.runScriptConfigPersistenceService, {
+            refreshFactoryConfigs: (...args) => mockWorkspaceQueryService.refreshFactoryConfigs(...args),
+            getFactoryConfig: (...args) => mockWorkspaceQueryService.getFactoryConfig(...args),
+        }),
+        workspaceRelationshipsService: Object.assign({}, fakeGraph.services.workspaceRelationshipsService, {
+            findChildrenWithStatus: vi.fn(async () => []),
+            findParent: vi.fn(async () => null),
+        }),
+        workspaceActivityService: Object.assign({}, fakeGraph.services.workspaceActivityService, {
+            clearWorkspace: (...args) => mockClearWorkspaceActivity(...args),
+        }),
+        workspaceNotificationService: Object.assign({}, fakeGraph.services.workspaceNotificationService, { countPending: vi.fn(async () => 0) }),
+        ratchetService: Object.assign({}, fakeGraph.services.ratchetService, {
+            setWorkspaceRatcheting: (...args) => mockSetWorkspaceRatcheting(...args),
+            checkWorkspaceById: (...args) => mockCheckWorkspaceById(...args),
+        }),
+        prSnapshotService: Object.assign({}, fakeGraph.services.prSnapshotService, {
+            attachAndRefreshPR: vi.fn(),
+        }),
+        archiveWorkspace: (...args) => mockArchiveWorkspace(...args),
+        cleanupWorkspaceRuntimeResources: (...args) => mockCleanupWorkspaceRuntimeResources(...args),
+        initializeWorkspaceWorktree: (...args) => mockInitializeWorkspaceWorktree(...args),
+        createWorkspaceCreationService: () => ({
+            create: (...args) => mockWorkspaceCreationCreate(...args),
+        }),
+        createChildWorkspace: vi.fn(),
+        deliverWorkspaceNotification: vi.fn(),
+        fireLifecycleNotification: vi.fn(),
+        persistChildNotification: (...args) => mockPersistChildNotification(...args),
+        persistParentNotification: (...args) => mockPersistParentNotification(...args),
+        runScriptService: composedRunScriptService,
+        terminalService: composedTerminalService,
+    };
+    const appContext = {
+        services,
+        lifecycle: fakeGraph.lifecycle,
+        config: fakeGraph.config,
+    };
+    const caller = workspaceCoreRouter.createCaller({ requestTrust, appContext });
+    return {
+        caller,
+        sessionLifecycleService: composedSessionLifecycleService,
+        runScriptService: composedRunScriptService,
+        terminalService: composedTerminalService,
+        cliHealthService,
+        eventCollector: fakeGraph.lifecycle.eventCollector,
+    };
 }
-describe('workspaceRouter', () => {
+describe('workspaceCoreRouter', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         mockResolveProviderForWorkspaceCreation.mockResolvedValue('CLAUDE');
@@ -194,7 +186,7 @@ describe('workspaceRouter', () => {
         mockCreateAgentSession.mockResolvedValue({ id: 'session-1' });
         mockCleanupWorkspaceRuntimeResources.mockImplementation(async (workspaceId, services, operation) => {
             const cleanupResults = await Promise.allSettled([
-                services.sessionService.stopWorkspaceSessions(workspaceId),
+                services.sessionLifecycleService.stopWorkspaceSessions(workspaceId),
                 (async () => {
                     const result = await services.runScriptService.stopRunScript(workspaceId);
                     if (!result.success) {
@@ -210,7 +202,7 @@ describe('workspaceRouter', () => {
             }
         });
     });
-    it('lists workspaces and returns enriched workspace details', async () => {
+    it('returns enriched workspace details', async () => {
         const workspace = {
             id: 'w1',
             projectId: 'p1',
@@ -223,10 +215,8 @@ describe('workspaceRouter', () => {
             hasHadSessions: true,
             agentSessions: [],
         };
-        mockWorkspaceDataService.findByProjectId.mockResolvedValue([workspace]);
         mockWorkspaceDataService.findById.mockResolvedValue(workspace);
         const { caller } = createCaller();
-        await expect(caller.list({ projectId: 'p1' })).resolves.toEqual([workspace]);
         await expect(caller.get({ id: 'w1' })).resolves.toEqual(expect.objectContaining({
             id: 'w1',
             sessionSummaries: [{ id: 's1', status: 'IDLE' }],
@@ -266,6 +256,40 @@ describe('workspaceRouter', () => {
         expect(mockCheckWorkspaceById).toHaveBeenCalledWith('w-created');
         await expect(caller.archive({ id: 'w-created' })).resolves.toEqual({ archived: true });
     });
+    it('includes error codes for individual bulk archive failures', async () => {
+        mockWorkspaceQueryService.findWorkspaceIdsInKanbanColumn.mockResolvedValue([
+            'w-success',
+            'w-blocked',
+            'w-missing',
+        ]);
+        mockArchiveWorkspace
+            .mockResolvedValueOnce({ archived: true })
+            .mockRejectedValueOnce(new ApplicationError('PRECONDITION_FAILED', 'Uncommitted changes'))
+            .mockRejectedValueOnce(new TRPCError({ code: 'NOT_FOUND', message: 'Workspace not found' }));
+        const { caller } = createCaller();
+        await expect(caller.bulkArchive({
+            projectId: 'p1',
+            kanbanColumn: 'WAITING',
+            commitUncommitted: false,
+        })).resolves.toEqual({
+            results: [
+                { id: 'w-success', success: true },
+                {
+                    id: 'w-blocked',
+                    success: false,
+                    error: 'Uncommitted changes',
+                    code: 'PRECONDITION_FAILED',
+                },
+                {
+                    id: 'w-missing',
+                    success: false,
+                    error: 'Workspace not found',
+                    code: 'NOT_FOUND',
+                },
+            ],
+            total: 3,
+        });
+    });
     it('rejects privileged workspace mutations from untrusted requests', async () => {
         const { caller } = createCaller({
             remoteAddress: '203.0.113.10',
@@ -277,11 +301,6 @@ describe('workspaceRouter', () => {
             projectId: 'p1',
             name: 'New Workspace',
         })).rejects.toThrow('trusted local Factory Factory client');
-        await expect(caller.createChild({
-            parentWorkspaceId: 'parent-1',
-            projectId: 'p1',
-            name: 'Child Workspace',
-        })).rejects.toThrow('trusted local Factory Factory client');
         expect(mockResolveProviderForWorkspaceCreation).not.toHaveBeenCalled();
         expect(mockWorkspaceCreationCreate).not.toHaveBeenCalled();
         expect(mockCreateAgentSession).not.toHaveBeenCalled();
@@ -468,14 +487,14 @@ describe('workspaceRouter', () => {
         mockWorkspaceQueryService.syncPRStatus.mockResolvedValue({ synced: true });
         mockWorkspaceQueryService.syncAllPRStatuses.mockResolvedValue({ synced: 10 });
         mockWorkspaceQueryService.hasChanges.mockResolvedValue({ hasChanges: true });
-        const { caller, sessionService, runScriptService, terminalService } = createCaller();
+        const { caller, sessionLifecycleService, runScriptService, terminalService, eventCollector } = createCaller();
         await expect(caller.delete({ id: 'w1' })).resolves.toEqual({ deleted: true });
         expect(mockCleanupWorkspaceRuntimeResources).toHaveBeenCalledWith('w1', expect.objectContaining({
-            sessionService,
+            sessionLifecycleService,
             runScriptService,
             terminalService,
         }), 'delete');
-        expect(sessionService.stopWorkspaceSessions).toHaveBeenCalledWith('w1');
+        expect(sessionLifecycleService.stopWorkspaceSessions).toHaveBeenCalledWith('w1');
         expect(runScriptService.stopRunScript).toHaveBeenCalledWith('w1');
         expect(runScriptService.evictWorkspaceBuffers).toHaveBeenCalledWith('w1');
         const evictionCallOrder = runScriptService.evictWorkspaceBuffers.mock.invocationCallOrder[0];
@@ -485,7 +504,7 @@ describe('workspaceRouter', () => {
         }
         expect(evictionCallOrder).toBeLessThan(deleteCallOrder);
         expect(terminalService.destroyWorkspaceTerminals).toHaveBeenCalledWith('w1');
-        expect(mockClearWorkspaceActivity).toHaveBeenCalledWith('w1');
+        expect(eventCollector.removeWorkspace).toHaveBeenCalledWith('w1');
         await expect(caller.refreshFactoryConfigs({ projectId: 'p1' })).resolves.toEqual({
             refreshed: 3,
         });
@@ -497,190 +516,42 @@ describe('workspaceRouter', () => {
         await expect(caller.hasChanges({ workspaceId: 'w1' })).resolves.toEqual({ hasChanges: true });
     });
     it('does not delete when run script cleanup reports failure', async () => {
-        const { caller, sessionService, runScriptService, terminalService } = createCaller();
+        const { caller, sessionLifecycleService, runScriptService, terminalService } = createCaller();
         runScriptService.stopRunScript.mockResolvedValue({ success: false, error: 'stop failed' });
         await expect(caller.delete({ id: 'w1' })).rejects.toThrow('Failed to cleanup workspace resources before delete');
-        expect(sessionService.stopWorkspaceSessions).toHaveBeenCalledWith('w1');
+        expect(sessionLifecycleService.stopWorkspaceSessions).toHaveBeenCalledWith('w1');
         expect(runScriptService.stopRunScript).toHaveBeenCalledWith('w1');
         expect(runScriptService.evictWorkspaceBuffers).not.toHaveBeenCalled();
         expect(terminalService.destroyWorkspaceTerminals).toHaveBeenCalledWith('w1');
         expect(mockWorkspaceDataService.delete).not.toHaveBeenCalled();
     });
+    it('does not clean workspace caches when database deletion fails', async () => {
+        mockWorkspaceDataService.delete.mockRejectedValue(new Error('database delete failed'));
+        const { caller, eventCollector } = createCaller();
+        await expect(caller.delete({ id: 'w1' })).rejects.toThrow('database delete failed');
+        expect(eventCollector.removeWorkspace).not.toHaveBeenCalled();
+    });
     it('does not delete when workspace session cleanup throws', async () => {
-        const { caller, sessionService, runScriptService, terminalService } = createCaller();
-        sessionService.stopWorkspaceSessions.mockRejectedValue(new Error('session cleanup failed'));
+        const { caller, sessionLifecycleService, runScriptService, terminalService } = createCaller();
+        sessionLifecycleService.stopWorkspaceSessions.mockRejectedValue(new Error('session cleanup failed'));
         await expect(caller.delete({ id: 'w1' })).rejects.toThrow('Failed to cleanup workspace resources before delete');
-        expect(sessionService.stopWorkspaceSessions).toHaveBeenCalledWith('w1');
+        expect(sessionLifecycleService.stopWorkspaceSessions).toHaveBeenCalledWith('w1');
         expect(runScriptService.stopRunScript).toHaveBeenCalledWith('w1');
         expect(runScriptService.evictWorkspaceBuffers).not.toHaveBeenCalled();
         expect(terminalService.destroyWorkspaceTerminals).toHaveBeenCalledWith('w1');
         expect(mockWorkspaceDataService.delete).not.toHaveBeenCalled();
     });
     it('does not delete when terminal cleanup throws', async () => {
-        const { caller, sessionService, runScriptService, terminalService } = createCaller();
+        const { caller, sessionLifecycleService, runScriptService, terminalService } = createCaller();
         terminalService.destroyWorkspaceTerminals.mockImplementation(() => {
             throw new Error('terminal cleanup failed');
         });
         await expect(caller.delete({ id: 'w1' })).rejects.toThrow('Failed to cleanup workspace resources before delete');
-        expect(sessionService.stopWorkspaceSessions).toHaveBeenCalledWith('w1');
+        expect(sessionLifecycleService.stopWorkspaceSessions).toHaveBeenCalledWith('w1');
         expect(runScriptService.stopRunScript).toHaveBeenCalledWith('w1');
         expect(runScriptService.evictWorkspaceBuffers).not.toHaveBeenCalled();
         expect(terminalService.destroyWorkspaceTerminals).toHaveBeenCalledWith('w1');
         expect(mockWorkspaceDataService.delete).not.toHaveBeenCalled();
     });
-    describe('sendMessageToParent', () => {
-        const child = {
-            id: 'child-1',
-            name: 'Child WS',
-            parentWorkspaceId: 'parent-1',
-            project: { name: 'Child Project' },
-        };
-        beforeEach(() => {
-            mockFindByIdWithProject.mockResolvedValue(child);
-            mockPersistChildNotification.mockResolvedValue({
-                id: 'notif-1',
-                direction: 'CHILD_TO_PARENT',
-                sourceWorkspaceName: 'Child WS',
-                message: 'hello',
-            });
-            mockAppendClaudeEvent.mockReturnValue(1);
-            mockEnqueue.mockReturnValue({ position: 0 });
-            mockHasQueuedMessage.mockReturnValue(false);
-            mockTryDispatchNextMessage.mockResolvedValue(undefined);
-        });
-        it('persists the notification before live delivery to an active session', async () => {
-            mockFindSessionsByWorkspaceId.mockResolvedValue([{ id: 'sess-1', status: 'RUNNING' }]);
-            const { caller } = createCaller();
-            await expect(caller.sendMessageToParent({ childWorkspaceId: 'child-1', message: 'hello' })).resolves.toEqual({ delivered: true });
-            expect(mockPersistChildNotification).toHaveBeenCalledWith({
-                parentWorkspaceId: 'parent-1',
-                sourceWorkspaceId: 'child-1',
-                message: 'hello',
-            });
-            expect(mockEnqueue).toHaveBeenCalledWith('sess-1', expect.objectContaining({
-                id: 'workspace-notification-notif-1',
-                text: `[Message from child workspace "Child WS"]: hello\n\n<!-- factory-factory-workspace-notification:notif-1 -->`,
-            }));
-            expect(mockTryDispatchNextMessage).toHaveBeenCalledWith('sess-1');
-            const persistOrder = mockPersistChildNotification.mock.invocationCallOrder[0];
-            const enqueueOrder = mockEnqueue.mock.invocationCallOrder[0];
-            if (persistOrder === undefined || enqueueOrder === undefined) {
-                throw new Error('Expected both persist and enqueue to be called');
-            }
-            expect(persistOrder).toBeLessThan(enqueueOrder);
-        });
-        it('persists the notification and skips live delivery when no active session', async () => {
-            mockFindSessionsByWorkspaceId.mockResolvedValue([{ id: 'sess-1', status: 'STOPPED' }]);
-            const { caller } = createCaller();
-            await expect(caller.sendMessageToParent({ childWorkspaceId: 'child-1', message: 'hello' })).resolves.toEqual({ delivered: false });
-            expect(mockPersistChildNotification).toHaveBeenCalledWith({
-                parentWorkspaceId: 'parent-1',
-                sourceWorkspaceId: 'child-1',
-                message: 'hello',
-            });
-            expect(mockEnqueue).not.toHaveBeenCalled();
-            expect(mockTryDispatchNextMessage).not.toHaveBeenCalled();
-        });
-        it('leaves the notification pending when live enqueue fails', async () => {
-            mockFindSessionsByWorkspaceId.mockResolvedValue([{ id: 'sess-1', status: 'RUNNING' }]);
-            mockEnqueue.mockReturnValue({ error: 'queue full' });
-            const { caller } = createCaller();
-            await expect(caller.sendMessageToParent({ childWorkspaceId: 'child-1', message: 'hello' })).resolves.toEqual({ delivered: false });
-            expect(mockPersistChildNotification).toHaveBeenCalled();
-            expect(mockTryDispatchNextMessage).not.toHaveBeenCalled();
-        });
-        it('skips enqueue when session startup already queued the notification', async () => {
-            mockFindSessionsByWorkspaceId.mockResolvedValue([{ id: 'sess-1', status: 'RUNNING' }]);
-            mockHasQueuedMessage.mockReturnValue(true);
-            const { caller } = createCaller();
-            await expect(caller.sendMessageToParent({ childWorkspaceId: 'child-1', message: 'hello' })).resolves.toEqual({ delivered: true });
-            expect(mockHasQueuedMessage).toHaveBeenCalledWith('sess-1', 'workspace-notification-notif-1');
-            expect(mockEnqueue).not.toHaveBeenCalled();
-            expect(mockAppendClaudeEvent).not.toHaveBeenCalled();
-            expect(mockEmitDelta).not.toHaveBeenCalled();
-        });
-    });
-    describe('sendMessageToChild', () => {
-        const child = {
-            id: 'child-1',
-            name: 'Child WS',
-            parentWorkspaceId: 'parent-1',
-            project: { name: 'Child Project' },
-        };
-        const parent = {
-            id: 'parent-1',
-            name: 'Parent WS',
-            parentWorkspaceId: null,
-            project: { name: 'Parent Project' },
-        };
-        beforeEach(() => {
-            mockFindByIdWithProject.mockImplementation(async (id) => id === 'child-1' ? child : parent);
-            mockPersistParentNotification.mockResolvedValue({
-                id: 'notif-2',
-                direction: 'PARENT_TO_CHILD',
-                sourceWorkspaceName: 'Parent WS',
-                message: 'do this',
-            });
-            mockAppendClaudeEvent.mockReturnValue(1);
-            mockEnqueue.mockReturnValue({ position: 0 });
-            mockHasQueuedMessage.mockReturnValue(false);
-            mockTryDispatchNextMessage.mockResolvedValue(undefined);
-        });
-        it('persists the notification before live delivery to an active session', async () => {
-            mockFindSessionsByWorkspaceId.mockResolvedValue([{ id: 'sess-2', status: 'IDLE' }]);
-            const { caller } = createCaller();
-            await expect(caller.sendMessageToChild({
-                parentWorkspaceId: 'parent-1',
-                childWorkspaceId: 'child-1',
-                message: 'do this',
-            })).resolves.toEqual({ delivered: true });
-            expect(mockPersistParentNotification).toHaveBeenCalledWith({
-                parentWorkspaceId: 'parent-1',
-                targetChildWorkspaceId: 'child-1',
-                message: 'do this',
-            });
-            expect(mockEnqueue).toHaveBeenCalledWith('sess-2', expect.objectContaining({
-                id: 'workspace-notification-notif-2',
-                text: `[Message from parent workspace "Parent WS"]: do this\n\n<!-- factory-factory-workspace-notification:notif-2 -->`,
-            }));
-            expect(mockTryDispatchNextMessage).toHaveBeenCalledWith('sess-2');
-            const persistOrder = mockPersistParentNotification.mock.invocationCallOrder[0];
-            const enqueueOrder = mockEnqueue.mock.invocationCallOrder[0];
-            if (persistOrder === undefined || enqueueOrder === undefined) {
-                throw new Error('Expected both persist and enqueue to be called');
-            }
-            expect(persistOrder).toBeLessThan(enqueueOrder);
-        });
-        it('persists the notification and skips live delivery when no active session', async () => {
-            mockFindSessionsByWorkspaceId.mockResolvedValue([]);
-            const { caller } = createCaller();
-            await expect(caller.sendMessageToChild({
-                parentWorkspaceId: 'parent-1',
-                childWorkspaceId: 'child-1',
-                message: 'do this',
-            })).resolves.toEqual({ delivered: false });
-            expect(mockPersistParentNotification).toHaveBeenCalledWith({
-                parentWorkspaceId: 'parent-1',
-                targetChildWorkspaceId: 'child-1',
-                message: 'do this',
-            });
-            expect(mockEnqueue).not.toHaveBeenCalled();
-            expect(mockTryDispatchNextMessage).not.toHaveBeenCalled();
-        });
-        it('skips enqueue when session startup already queued the notification', async () => {
-            mockFindSessionsByWorkspaceId.mockResolvedValue([{ id: 'sess-2', status: 'IDLE' }]);
-            mockHasQueuedMessage.mockReturnValue(true);
-            const { caller } = createCaller();
-            await expect(caller.sendMessageToChild({
-                parentWorkspaceId: 'parent-1',
-                childWorkspaceId: 'child-1',
-                message: 'do this',
-            })).resolves.toEqual({ delivered: true });
-            expect(mockHasQueuedMessage).toHaveBeenCalledWith('sess-2', 'workspace-notification-notif-2');
-            expect(mockEnqueue).not.toHaveBeenCalled();
-            expect(mockAppendClaudeEvent).not.toHaveBeenCalled();
-            expect(mockEmitDelta).not.toHaveBeenCalled();
-        });
-    });
 });
 //# sourceMappingURL=workspace.router.test.js.map