factory-factory 0.4.0 → 0.4.2

package/dist/src/backend/orchestration/workspace-init.orchestrator.test.js

@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { SessionStatus } from '../../shared/core/index.js';
 import { unsafeCoerce } from '../../test-utils/unsafe-coerce.js';
+const mockWorkspaceUpdate = vi.hoisted(() => vi.fn());
 vi.mock('@/backend/services/github', () => ({
     githubCLIService: {
         getAuthenticatedUsername: vi.fn(),
@@ -12,26 +13,29 @@ vi.mock('@/backend/services/run-script', () => ({
         hasStartupScript: vi.fn(),
         runStartupScript: vi.fn(),
     },
+    FactoryConfigService: {
+        readConfig: vi.fn(),
+    },
+    runScriptConfigPersistenceService: {
+        syncWorkspaceCommandsFromFactoryConfig: vi.fn(),
+    },
 }));
 vi.mock('@/backend/services/session', () => ({
+    buildChildWorkspaceContext: vi.fn((input) => `## Child Workspace Context\nUse send_message_to_parent.${input.reportBackOn ? `\nReport back when: ${input.reportBackOn}` : ''}\n`),
     chatMessageHandlerService: {
         tryDispatchNextMessage: vi.fn(),
     },
     sessionDataService: {
-        createTerminalSession: vi.fn(),
-        clearTerminalPid: vi.fn(),
+        findAgentSessionsByWorkspaceId: vi.fn(),
     },
     sessionDomainService: {
         enqueue: vi.fn(),
         emitDelta: vi.fn(),
     },
-    sessionService: {
+    sessionLifecycleService: {
         startSession: vi.fn(),
         stopWorkspaceSessions: vi.fn(),
     },
-    agentSessionAccessor: {
-        findByWorkspaceId: vi.fn(),
-    },
 }));
 vi.mock('@/backend/services/terminal', () => ({
     terminalService: {
@@ -40,6 +44,10 @@ vi.mock('@/backend/services/terminal', () => ({
         getTerminalsForWorkspace: vi.fn(),
         onExit: vi.fn(),
     },
+    terminalSessionService: {
+        registerSession: vi.fn(),
+        releaseSessionPid: vi.fn(),
+    },
 }));
 vi.mock('@/backend/services/workspace', () => ({
     assertWorktreePathSafe: vi.fn(),
@@ -53,18 +61,17 @@ vi.mock('@/backend/services/workspace', () => ({
         getInitMode: vi.fn(),
         clearInitMode: vi.fn(),
     },
-    workspaceAccessor: {
+    workspaceDataService: {
         findById: vi.fn(),
         findByIdWithProject: vi.fn(),
-        update: vi.fn(),
     },
-}));
-vi.mock('@/backend/services/factory-config.service', () => ({
-    FactoryConfigService: {
-        readConfig: vi.fn(),
+    workspaceRelationshipsService: {
+        findParent: vi.fn(),
+    },
+    workspaceRunScriptService: {
+        registerInitializedWorktree: (...args) => mockWorkspaceUpdate(...args),
+        setCommands: (...args) => mockWorkspaceUpdate(...args),
     },
-}));
-vi.mock('@/backend/services/git-ops.service', () => ({
     gitOpsService: {
         ensureBaseBranchExists: vi.fn(),
         createWorktree: vi.fn(),
@@ -72,11 +79,6 @@ vi.mock('@/backend/services/git-ops.service', () => ({
         removeWorktree: vi.fn(),
     },
 }));
-vi.mock('@/backend/services/run-script-config-persistence.service', () => ({
-    runScriptConfigPersistenceService: {
-        syncWorkspaceCommandsFromFactoryConfig: vi.fn(),
-    },
-}));
 vi.mock('@/backend/services/logger.service', () => ({
     createLogger: () => ({
         debug: vi.fn(),
@@ -89,14 +91,11 @@ vi.mock('@/shared/acp-protocol', () => ({
     MessageState: { ACCEPTED: 'ACCEPTED' },
     resolveSelectedModel: vi.fn((m) => m ?? 'claude-sonnet'),
 }));
-import { FactoryConfigService } from '../../backend/services/factory-config.service.js';
-import { gitOpsService } from '../../backend/services/git-ops.service.js';
 import { githubCLIService } from '../../backend/services/github/index.js';
-import { startupScriptService } from '../../backend/services/run-script/index.js';
-import { runScriptConfigPersistenceService } from '../../backend/services/run-script-config-persistence.service.js';
-import { agentSessionAccessor, chatMessageHandlerService, sessionDataService, sessionDomainService, sessionService, } from '../../backend/services/session/index.js';
-import { terminalService } from '../../backend/services/terminal/index.js';
-import { workspaceAccessor, workspaceStateMachine, worktreeLifecycleService, } from '../../backend/services/workspace/index.js';
+import { FactoryConfigService, runScriptConfigPersistenceService, startupScriptService, } from '../../backend/services/run-script/index.js';
+import { buildChildWorkspaceContext, chatMessageHandlerService, sessionDataService, sessionDomainService, sessionLifecycleService, } from '../../backend/services/session/index.js';
+import { terminalService, terminalSessionService } from '../../backend/services/terminal/index.js';
+import { gitOpsService, workspaceDataService, workspaceRelationshipsService, workspaceStateMachine, worktreeLifecycleService, } from '../../backend/services/workspace/index.js';
 import { clearWorkspaceInitOrchestratorStateForTests, initializeWorkspaceWorktree, } from './workspace-init.orchestrator.js';
 const WORKSPACE_ID = 'ws-1';
 function createDeferredPromise() {
@@ -131,9 +130,9 @@ function makeWorkspaceWithProject(overrides = {}) {
 function setupHappyPath(overrides = {}) {
     const workspace = makeWorkspaceWithProject(overrides);
     vi.mocked(workspaceStateMachine.startProvisioning).mockResolvedValue(unsafeCoerce(workspace));
-    vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-    vi.mocked(workspaceAccessor.findById).mockResolvedValue(workspace);
-    vi.mocked(workspaceAccessor.update).mockResolvedValue(workspace);
+    vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+    vi.mocked(workspaceDataService.findById).mockResolvedValue(workspace);
+    vi.mocked(mockWorkspaceUpdate).mockResolvedValue(workspace);
     vi.mocked(gitOpsService.ensureBaseBranchExists).mockResolvedValue(undefined);
     vi.mocked(gitOpsService.removeWorktree).mockResolvedValue(undefined);
     vi.mocked(gitOpsService.createWorktree).mockResolvedValue({
@@ -161,12 +160,12 @@ function setupHappyPath(overrides = {}) {
     vi.mocked(workspaceStateMachine.markReadyWithWarning).mockResolvedValue(unsafeCoerce(workspace));
     vi.mocked(workspaceStateMachine.markFailed).mockResolvedValue(unsafeCoerce(workspace));
     vi.mocked(githubCLIService.getAuthenticatedUsername).mockResolvedValue('testuser');
-    vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
-    vi.mocked(sessionService.stopWorkspaceSessions).mockResolvedValue(undefined);
-    vi.mocked(sessionService.startSession).mockResolvedValue(undefined);
+    vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([]);
+    vi.mocked(sessionLifecycleService.stopWorkspaceSessions).mockResolvedValue(undefined);
+    vi.mocked(sessionLifecycleService.startSession).mockResolvedValue(undefined);
     vi.mocked(chatMessageHandlerService.tryDispatchNextMessage).mockResolvedValue(undefined);
-    vi.mocked(sessionDataService.createTerminalSession).mockResolvedValue(unsafeCoerce({}));
-    vi.mocked(sessionDataService.clearTerminalPid).mockResolvedValue(undefined);
+    vi.mocked(terminalSessionService.registerSession).mockResolvedValue(unsafeCoerce({}));
+    vi.mocked(terminalSessionService.releaseSessionPid).mockResolvedValue(undefined);
     vi.mocked(terminalService.createTerminal).mockResolvedValue({
         terminalId: 'term-default',
         pid: 12_345,
@@ -185,32 +184,32 @@ describe('initializeWorkspaceWorktree', () => {
         it('returns early without doing work when provisioning fails', async () => {
             vi.mocked(workspaceStateMachine.startProvisioning).mockRejectedValue(new Error('invalid transition'));
             await initializeWorkspaceWorktree(WORKSPACE_ID);
-            expect(workspaceAccessor.findByIdWithProject).not.toHaveBeenCalled();
+            expect(workspaceDataService.findByIdWithProject).not.toHaveBeenCalled();
             expect(gitOpsService.createWorktree).not.toHaveBeenCalled();
         });
         it('continues without starting provisioning when already started by caller', async () => {
             setupHappyPath();
             await initializeWorkspaceWorktree(WORKSPACE_ID, { provisioningAlreadyStarted: true });
             expect(workspaceStateMachine.startProvisioning).not.toHaveBeenCalled();
-            expect(workspaceAccessor.findByIdWithProject).toHaveBeenCalledWith(WORKSPACE_ID);
+            expect(workspaceDataService.findByIdWithProject).toHaveBeenCalledWith(WORKSPACE_ID);
             expect(workspaceStateMachine.markReady).toHaveBeenCalledWith(WORKSPACE_ID);
         });
     });
     describe('workspace lookup', () => {
         it('marks failed when workspace has no project', async () => {
             vi.mocked(workspaceStateMachine.startProvisioning).mockResolvedValue(unsafeCoerce({}));
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(null);
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(null);
             vi.mocked(workspaceStateMachine.markFailed).mockResolvedValue(unsafeCoerce({}));
-            vi.mocked(sessionService.stopWorkspaceSessions).mockResolvedValue(undefined);
+            vi.mocked(sessionLifecycleService.stopWorkspaceSessions).mockResolvedValue(undefined);
             vi.mocked(worktreeLifecycleService.clearInitMode).mockResolvedValue(undefined);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(workspaceStateMachine.markFailed).toHaveBeenCalledWith(WORKSPACE_ID, 'Workspace project not found');
         });
         it('marks failed when workspace lookup returns workspace without project', async () => {
             vi.mocked(workspaceStateMachine.startProvisioning).mockResolvedValue(unsafeCoerce({}));
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(unsafeCoerce({ id: WORKSPACE_ID, project: null }));
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(unsafeCoerce({ id: WORKSPACE_ID, project: null }));
             vi.mocked(workspaceStateMachine.markFailed).mockResolvedValue(unsafeCoerce({}));
-            vi.mocked(sessionService.stopWorkspaceSessions).mockResolvedValue(undefined);
+            vi.mocked(sessionLifecycleService.stopWorkspaceSessions).mockResolvedValue(undefined);
             vi.mocked(worktreeLifecycleService.clearInitMode).mockResolvedValue(undefined);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(workspaceStateMachine.markFailed).toHaveBeenCalledWith(WORKSPACE_ID, 'Workspace project not found');
@@ -226,7 +225,7 @@ describe('initializeWorkspaceWorktree', () => {
         it('updates workspace with worktree path and branch name', async () => {
             setupHappyPath();
             await initializeWorkspaceWorktree(WORKSPACE_ID);
-            expect(workspaceAccessor.update).toHaveBeenCalledWith(WORKSPACE_ID, expect.objectContaining({
+            expect(mockWorkspaceUpdate).toHaveBeenCalledWith(WORKSPACE_ID, expect.objectContaining({
                 worktreePath: '/worktrees/workspace-ws-1',
                 branchName: 'user/test-workspace',
                 isAutoGeneratedBranch: true,
@@ -235,8 +234,8 @@ describe('initializeWorkspaceWorktree', () => {
         it('persists worktree and run-script fields in a single update call', async () => {
             setupHappyPath();
             await initializeWorkspaceWorktree(WORKSPACE_ID);
-            expect(workspaceAccessor.update).toHaveBeenCalledTimes(1);
-            expect(workspaceAccessor.update).toHaveBeenCalledWith(WORKSPACE_ID, expect.objectContaining({
+            expect(mockWorkspaceUpdate).toHaveBeenCalledTimes(1);
+            expect(mockWorkspaceUpdate).toHaveBeenCalledWith(WORKSPACE_ID, expect.objectContaining({
                 worktreePath: '/worktrees/workspace-ws-1',
                 branchName: 'user/test-workspace',
                 isAutoGeneratedBranch: true,
@@ -257,7 +256,7 @@ describe('initializeWorkspaceWorktree', () => {
                 workspaceId: WORKSPACE_ID,
                 workingDir: '/worktrees/workspace-ws-1',
             });
-            expect(sessionDataService.createTerminalSession).toHaveBeenCalledWith({
+            expect(terminalSessionService.registerSession).toHaveBeenCalledWith({
                 workspaceId: WORKSPACE_ID,
                 name: 'term-default',
                 pid: 12_345,
@@ -273,7 +272,7 @@ describe('initializeWorkspaceWorktree', () => {
             vi.mocked(startupScriptService.runStartupScript).mockResolvedValue({
                 success: true,
             });
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
@@ -286,11 +285,11 @@ describe('initializeWorkspaceWorktree', () => {
                 workspaceId: WORKSPACE_ID,
                 workingDir: '/worktrees/existing-ws-1',
             });
-            expect(sessionService.startSession).toHaveBeenCalledWith('session-1', {
+            expect(sessionLifecycleService.startSession).toHaveBeenCalledWith('session-1', {
                 initialPrompt: '',
                 startupModePreset: 'non_interactive',
             });
-            const updateData = vi.mocked(workspaceAccessor.update).mock.calls[0]?.[1];
+            const updateData = vi.mocked(mockWorkspaceUpdate).mock.calls[0]?.[1];
             expect(updateData).not.toHaveProperty('worktreePath');
             expect(updateData).not.toHaveProperty('branchName');
             expect(worktreeLifecycleService.clearInitMode).not.toHaveBeenCalled();
@@ -302,11 +301,11 @@ describe('initializeWorkspaceWorktree', () => {
             ]);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(terminalService.createTerminal).not.toHaveBeenCalled();
-            expect(sessionDataService.createTerminalSession).not.toHaveBeenCalled();
+            expect(terminalSessionService.registerSession).not.toHaveBeenCalled();
         });
         it('destroys the spawned terminal when session persistence fails', async () => {
             setupHappyPath();
-            vi.mocked(sessionDataService.createTerminalSession).mockRejectedValue(new Error('db unavailable'));
+            vi.mocked(terminalSessionService.registerSession).mockRejectedValue(new Error('db unavailable'));
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(terminalService.createTerminal).toHaveBeenCalledWith({
                 workspaceId: WORKSPACE_ID,
@@ -320,7 +319,7 @@ describe('initializeWorkspaceWorktree', () => {
             setupHappyPath();
             const createTerminalSessionDeferred = createDeferredPromise();
             let exitListener;
-            vi.mocked(sessionDataService.createTerminalSession).mockImplementation(() => createTerminalSessionDeferred.promise);
+            vi.mocked(terminalSessionService.registerSession).mockImplementation(() => createTerminalSessionDeferred.promise);
             vi.mocked(terminalService.onExit).mockImplementation((_, listener) => {
                 exitListener = listener;
                 return vi.fn();
@@ -331,10 +330,10 @@ describe('initializeWorkspaceWorktree', () => {
             });
             expect(exitListener).toBeDefined();
             exitListener?.(0);
-            expect(sessionDataService.clearTerminalPid).not.toHaveBeenCalled();
+            expect(terminalSessionService.releaseSessionPid).not.toHaveBeenCalled();
             createTerminalSessionDeferred.resolve(unsafeCoerce({}));
             await initializationPromise;
-            expect(sessionDataService.clearTerminalPid).toHaveBeenCalledWith(WORKSPACE_ID, 'term-default');
+            expect(terminalSessionService.releaseSessionPid).toHaveBeenCalledWith(WORKSPACE_ID, 'term-default');
         });
     });
     describe('branch options', () => {
@@ -363,7 +362,7 @@ describe('initializeWorkspaceWorktree', () => {
                 branchName: 'existing-branch',
                 useExistingBranch: true,
             });
-            expect(workspaceAccessor.update).toHaveBeenCalledWith(WORKSPACE_ID, expect.objectContaining({
+            expect(mockWorkspaceUpdate).toHaveBeenCalledWith(WORKSPACE_ID, expect.objectContaining({
                 isAutoGeneratedBranch: false,
             }));
         });
@@ -491,7 +490,7 @@ describe('initializeWorkspaceWorktree', () => {
                 errorMessage: 'setup failed',
             });
             await initializeWorkspaceWorktree(WORKSPACE_ID);
-            expect(sessionService.stopWorkspaceSessions).not.toHaveBeenCalled();
+            expect(sessionLifecycleService.stopWorkspaceSessions).not.toHaveBeenCalled();
             expect(workspaceStateMachine.markReadyWithWarning).toHaveBeenCalledWith(WORKSPACE_ID, expect.any(String));
         });
         it('reaches READY state even when factory setup script fails', async () => {
@@ -532,7 +531,7 @@ describe('initializeWorkspaceWorktree', () => {
                 errorMessage: 'startup failed',
             });
             await initializeWorkspaceWorktree(WORKSPACE_ID);
-            expect(sessionService.stopWorkspaceSessions).not.toHaveBeenCalled();
+            expect(sessionLifecycleService.stopWorkspaceSessions).not.toHaveBeenCalled();
             expect(workspaceStateMachine.markReadyWithWarning).toHaveBeenCalledWith(WORKSPACE_ID, expect.any(String));
         });
         it('reaches READY state even when project startup script fails', async () => {
@@ -549,41 +548,41 @@ describe('initializeWorkspaceWorktree', () => {
     describe('default Claude session auto-start', () => {
         it('starts default Claude session when idle session exists', async () => {
             setupHappyPath();
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
-            expect(sessionService.startSession).toHaveBeenCalledWith('session-1', {
+            expect(sessionLifecycleService.startSession).toHaveBeenCalledWith('session-1', {
                 initialPrompt: '',
                 startupModePreset: 'non_interactive',
             });
         });
         it('starts default session in plan mode when requested in creation metadata', async () => {
             setupHappyPath();
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(unsafeCoerce({
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(unsafeCoerce({
                 id: WORKSPACE_ID,
                 creationMetadata: {
                     startupModePreset: 'plan',
                 },
             }));
             await initializeWorkspaceWorktree(WORKSPACE_ID);
-            expect(sessionService.startSession).toHaveBeenCalledWith('session-1', {
+            expect(sessionLifecycleService.startSession).toHaveBeenCalledWith('session-1', {
                 initialPrompt: '',
                 startupModePreset: 'plan',
             });
         });
         it('does not start session when no idle session exists', async () => {
             setupHappyPath();
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([]);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
-            expect(sessionService.startSession).not.toHaveBeenCalled();
+            expect(sessionLifecycleService.startSession).not.toHaveBeenCalled();
         });
         it('dispatches queued messages after session start', async () => {
             setupHappyPath();
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
@@ -592,16 +591,193 @@ describe('initializeWorkspaceWorktree', () => {
         });
         it('does not throw when session auto-start fails', async () => {
             setupHappyPath();
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockRejectedValue(new Error('accessor error'));
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockRejectedValue(new Error('accessor error'));
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(workspaceStateMachine.markReady).toHaveBeenCalled();
         });
+        it('prepends child workspace context to the initial prompt', async () => {
+            setupHappyPath({
+                parentWorkspaceId: 'parent-1',
+                creationMetadata: {
+                    initialPrompt: 'Implement the fix',
+                    reportBackOn: 'a PR is opened',
+                },
+            });
+            vi.mocked(workspaceRelationshipsService.findParent).mockResolvedValue(unsafeCoerce({
+                id: 'parent-1',
+                name: 'parent-workspace',
+                project: { id: 'parent-project-1', name: 'parent-project' },
+            }));
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
+                unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
+            ]);
+            vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
+            await initializeWorkspaceWorktree(WORKSPACE_ID);
+            const queued = vi.mocked(sessionDomainService.enqueue).mock.calls[0]?.[1];
+            if (!queued) {
+                throw new Error('Expected an initial message to be queued');
+            }
+            expect(queued.text).toContain('## Child Workspace Context');
+            expect(queued.text).toContain('Report back when: a PR is opened');
+            expect(queued.text.indexOf('## Child Workspace Context')).toBeLessThan(queued.text.indexOf('Implement the fix'));
+            expect(workspaceRelationshipsService.findParent).toHaveBeenCalledWith(WORKSPACE_ID);
+            expect(buildChildWorkspaceContext).toHaveBeenCalledWith({
+                parentWorkspaceName: 'parent-workspace',
+                parentProjectName: 'parent-project',
+                reportBackOn: 'a PR is opened',
+            });
+        });
+        it('enqueues child workspace context when no initial prompt is provided', async () => {
+            setupHappyPath({
+                parentWorkspaceId: 'parent-1',
+                creationMetadata: {},
+            });
+            vi.mocked(workspaceRelationshipsService.findParent).mockResolvedValue(unsafeCoerce({
+                id: 'parent-1',
+                name: 'parent-workspace',
+                project: { id: 'parent-project-1', name: 'parent-project' },
+            }));
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
+                unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
+            ]);
+            vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
+            await initializeWorkspaceWorktree(WORKSPACE_ID);
+            expect(sessionDomainService.enqueue).toHaveBeenCalledWith('session-1', expect.objectContaining({ text: expect.stringContaining('send_message_to_parent') }));
+        });
+        it('preserves initial attachments when composing child workspace context', async () => {
+            setupHappyPath({
+                parentWorkspaceId: 'parent-1',
+                creationMetadata: {
+                    initialPrompt: 'Review the evidence',
+                    initialAttachments: [
+                        {
+                            id: 'att-child-1',
+                            name: 'child-evidence.png',
+                            type: 'image/png',
+                            size: 120,
+                            data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB',
+                            contentType: 'image',
+                        },
+                    ],
+                },
+            });
+            vi.mocked(workspaceRelationshipsService.findParent).mockResolvedValue(unsafeCoerce({
+                id: 'parent-1',
+                name: 'parent-workspace',
+                project: { id: 'parent-project-1', name: 'parent-project' },
+            }));
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
+                unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
+            ]);
+            vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
+            await initializeWorkspaceWorktree(WORKSPACE_ID);
+            expect(sessionDomainService.enqueue).toHaveBeenCalledWith('session-1', expect.objectContaining({
+                text: expect.stringContaining('Review the evidence'),
+                attachments: [
+                    expect.objectContaining({
+                        id: 'att-child-1',
+                        name: 'child-evidence.png',
+                    }),
+                ],
+            }));
+        });
+        it('queues child workspace context with attachments when no initial prompt is provided', async () => {
+            setupHappyPath({
+                parentWorkspaceId: 'parent-1',
+                creationMetadata: {
+                    initialAttachments: [
+                        {
+                            id: 'att-child-only-1',
+                            name: 'child-only-evidence.png',
+                            type: 'image/png',
+                            size: 120,
+                            data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB',
+                            contentType: 'image',
+                        },
+                    ],
+                },
+            });
+            vi.mocked(workspaceRelationshipsService.findParent).mockResolvedValue(unsafeCoerce({
+                id: 'parent-1',
+                name: 'parent-workspace',
+                project: { id: 'parent-project-1', name: 'parent-project' },
+            }));
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
+                unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
+            ]);
+            vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
+            await initializeWorkspaceWorktree(WORKSPACE_ID);
+            expect(sessionDomainService.enqueue).toHaveBeenCalledWith('session-1', expect.objectContaining({
+                text: '## Child Workspace Context\nUse send_message_to_parent.',
+                attachments: [
+                    expect.objectContaining({
+                        id: 'att-child-only-1',
+                        name: 'child-only-evidence.png',
+                    }),
+                ],
+            }));
+        });
+        it('queues child workspace context for a whitespace-only initial prompt', async () => {
+            setupHappyPath({
+                parentWorkspaceId: 'parent-1',
+                creationMetadata: { initialPrompt: '  \n\t' },
+            });
+            vi.mocked(workspaceRelationshipsService.findParent).mockResolvedValue(unsafeCoerce({
+                id: 'parent-1',
+                name: 'parent-workspace',
+                project: { id: 'parent-project-1', name: 'parent-project' },
+            }));
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
+                unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
+            ]);
+            vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
+            await initializeWorkspaceWorktree(WORKSPACE_ID);
+            expect(sessionDomainService.enqueue).toHaveBeenCalledWith('session-1', expect.objectContaining({
+                text: '## Child Workspace Context\nUse send_message_to_parent.',
+            }));
+        });
+        it('ignores non-string child report-back metadata', async () => {
+            setupHappyPath({
+                parentWorkspaceId: 'parent-1',
+                creationMetadata: {
+                    initialPrompt: 'Implement the fix',
+                    reportBackOn: { event: 'pull-request' },
+                },
+            });
+            vi.mocked(workspaceRelationshipsService.findParent).mockResolvedValue(unsafeCoerce({
+                id: 'parent-1',
+                name: 'parent-workspace',
+                project: { id: 'parent-project-1', name: 'parent-project' },
+            }));
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
+                unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
+            ]);
+            vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
+            await initializeWorkspaceWorktree(WORKSPACE_ID);
+            expect(buildChildWorkspaceContext).toHaveBeenCalledWith({
+                parentWorkspaceName: 'parent-workspace',
+                parentProjectName: 'parent-project',
+                reportBackOn: undefined,
+            });
+        });
+        it('does not resolve a parent workspace for non-child initialization', async () => {
+            setupHappyPath({
+                creationMetadata: { initialPrompt: 'Implement the fix' },
+            });
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
+                unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
+            ]);
+            vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
+            await initializeWorkspaceWorktree(WORKSPACE_ID);
+            expect(workspaceRelationshipsService.findParent).not.toHaveBeenCalled();
+            expect(buildChildWorkspaceContext).not.toHaveBeenCalled();
+        });
         it('enqueues initial attachments from workspace creation metadata', async () => {
             setupHappyPath();
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(unsafeCoerce({
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(unsafeCoerce({
                 id: WORKSPACE_ID,
                 creationMetadata: {
                     initialAttachments: [
@@ -637,7 +813,7 @@ describe('initializeWorkspaceWorktree', () => {
                     ],
                 }),
             }));
-            expect(workspaceAccessor.findById).toHaveBeenCalledTimes(1);
+            expect(workspaceDataService.findById).toHaveBeenCalledTimes(1);
         });
     });
     describe('GitHub issue prompt', () => {
@@ -651,9 +827,9 @@ describe('initializeWorkspaceWorktree', () => {
                 },
             });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
@@ -673,9 +849,9 @@ describe('initializeWorkspaceWorktree', () => {
                 },
             });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
@@ -695,9 +871,9 @@ describe('initializeWorkspaceWorktree', () => {
                 },
             });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
@@ -715,9 +891,9 @@ describe('initializeWorkspaceWorktree', () => {
                 },
             });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
@@ -745,9 +921,9 @@ describe('initializeWorkspaceWorktree', () => {
                 },
             });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(sessionDomainService.enqueue).mockReturnValue({ position: 0 });
@@ -765,8 +941,8 @@ describe('initializeWorkspaceWorktree', () => {
         it('enqueues GitHub issue prompt when workspace has linked issue', async () => {
             const workspace = makeWorkspaceWithProject({ githubIssueNumber: 42 });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(githubCLIService.getIssue).mockResolvedValue(unsafeCoerce({
@@ -784,8 +960,8 @@ describe('initializeWorkspaceWorktree', () => {
         it('emits delta when enqueue succeeds', async () => {
             const workspace = makeWorkspaceWithProject({ githubIssueNumber: 42 });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(githubCLIService.getIssue).mockResolvedValue(unsafeCoerce({
@@ -804,8 +980,8 @@ describe('initializeWorkspaceWorktree', () => {
         it('logs warning when enqueue returns error', async () => {
             const workspace = makeWorkspaceWithProject({ githubIssueNumber: 42 });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(githubCLIService.getIssue).mockResolvedValue(unsafeCoerce({
@@ -820,7 +996,7 @@ describe('initializeWorkspaceWorktree', () => {
         });
         it('returns empty prompt when workspace has no GitHub issue', async () => {
             setupHappyPath();
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
@@ -838,8 +1014,8 @@ describe('initializeWorkspaceWorktree', () => {
                 }),
             });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
@@ -849,8 +1025,8 @@ describe('initializeWorkspaceWorktree', () => {
         it('returns empty prompt when issue fetch fails', async () => {
             const workspace = makeWorkspaceWithProject({ githubIssueNumber: 42 });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(githubCLIService.getIssue).mockResolvedValue(null);
@@ -860,8 +1036,8 @@ describe('initializeWorkspaceWorktree', () => {
         it('returns empty prompt when issue fetch throws', async () => {
             const workspace = makeWorkspaceWithProject({ githubIssueNumber: 42 });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(githubCLIService.getIssue).mockRejectedValue(new Error('GitHub API error'));
@@ -871,8 +1047,8 @@ describe('initializeWorkspaceWorktree', () => {
         it('includes issue body of "(No description provided)" when body is empty', async () => {
             const workspace = makeWorkspaceWithProject({ githubIssueNumber: 42 });
             setupHappyPath();
-            vi.mocked(workspaceAccessor.findByIdWithProject).mockResolvedValue(workspace);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(workspaceDataService.findByIdWithProject).mockResolvedValue(workspace);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(githubCLIService.getIssue).mockResolvedValue(unsafeCoerce({
@@ -899,12 +1075,12 @@ describe('initializeWorkspaceWorktree', () => {
             setupHappyPath();
             vi.mocked(gitOpsService.createWorktree).mockRejectedValue(new Error('git worktree add failed'));
             await initializeWorkspaceWorktree(WORKSPACE_ID);
-            expect(sessionService.stopWorkspaceSessions).toHaveBeenCalledWith(WORKSPACE_ID);
+            expect(sessionLifecycleService.stopWorkspaceSessions).toHaveBeenCalledWith(WORKSPACE_ID);
         });
         it('does not throw when stopping sessions fails after init failure', async () => {
             setupHappyPath();
             vi.mocked(gitOpsService.createWorktree).mockRejectedValue(new Error('git worktree add failed'));
-            vi.mocked(sessionService.stopWorkspaceSessions).mockRejectedValue(new Error('stop failed'));
+            vi.mocked(sessionLifecycleService.stopWorkspaceSessions).mockRejectedValue(new Error('stop failed'));
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(workspaceStateMachine.markFailed).toHaveBeenCalled();
         });
@@ -916,15 +1092,15 @@ describe('initializeWorkspaceWorktree', () => {
         });
         it('clears init mode even when error occurs after worktree creation', async () => {
             setupHappyPath();
-            vi.mocked(workspaceAccessor.update).mockRejectedValue(new Error('db error'));
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(unsafeCoerce({ id: WORKSPACE_ID, worktreePath: null }));
+            vi.mocked(mockWorkspaceUpdate).mockRejectedValue(new Error('db error'));
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(unsafeCoerce({ id: WORKSPACE_ID, worktreePath: null }));
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(worktreeLifecycleService.clearInitMode).toHaveBeenCalledWith(WORKSPACE_ID);
         });
         it('removes unregistered worktree when persistence fails after creation', async () => {
             const workspace = setupHappyPath();
-            vi.mocked(workspaceAccessor.update).mockRejectedValue(new Error('db update error'));
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(unsafeCoerce({ id: WORKSPACE_ID, worktreePath: null }));
+            vi.mocked(mockWorkspaceUpdate).mockRejectedValue(new Error('db update error'));
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(unsafeCoerce({ id: WORKSPACE_ID, worktreePath: null }));
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(gitOpsService.removeWorktree).toHaveBeenCalledWith('/worktrees/workspace-ws-1', workspace.project);
         });
@@ -936,17 +1112,17 @@ describe('initializeWorkspaceWorktree', () => {
         });
         it('does not throw when unregistered worktree cleanup fails', async () => {
             setupHappyPath();
-            vi.mocked(workspaceAccessor.update).mockRejectedValue(new Error('db update error'));
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(unsafeCoerce({ id: WORKSPACE_ID, worktreePath: null }));
+            vi.mocked(mockWorkspaceUpdate).mockRejectedValue(new Error('db update error'));
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(unsafeCoerce({ id: WORKSPACE_ID, worktreePath: null }));
             vi.mocked(gitOpsService.removeWorktree).mockRejectedValue(new Error('remove failed'));
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(workspaceStateMachine.markFailed).toHaveBeenCalledWith(WORKSPACE_ID, 'db update error');
-            expect(sessionService.stopWorkspaceSessions).toHaveBeenCalledWith(WORKSPACE_ID);
+            expect(sessionLifecycleService.stopWorkspaceSessions).toHaveBeenCalledWith(WORKSPACE_ID);
         });
         it('marks workspace failed when workspace update throws', async () => {
             setupHappyPath();
-            vi.mocked(workspaceAccessor.update).mockRejectedValue(new Error('db update error'));
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(unsafeCoerce({ id: WORKSPACE_ID, worktreePath: null }));
+            vi.mocked(mockWorkspaceUpdate).mockRejectedValue(new Error('db update error'));
+            vi.mocked(workspaceDataService.findById).mockResolvedValue(unsafeCoerce({ id: WORKSPACE_ID, worktreePath: null }));
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(workspaceStateMachine.markFailed).toHaveBeenCalledWith(WORKSPACE_ID, 'db update error');
         });
@@ -954,20 +1130,20 @@ describe('initializeWorkspaceWorktree', () => {
             setupHappyPath();
             vi.mocked(FactoryConfigService.readConfig).mockResolvedValue(unsafeCoerce({ scripts: { setup: './setup.sh', run: null, cleanup: null } }));
             const startSessionDeferred = createDeferredPromise();
-            vi.mocked(sessionService.startSession).mockReturnValue(startSessionDeferred.promise);
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(sessionLifecycleService.startSession).mockReturnValue(startSessionDeferred.promise);
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             vi.mocked(startupScriptService.runStartupScript).mockRejectedValue(new Error('script boom'));
             const initializationPromise = initializeWorkspaceWorktree(WORKSPACE_ID);
             await Promise.resolve();
             await Promise.resolve();
-            expect(sessionService.stopWorkspaceSessions).not.toHaveBeenCalled();
+            expect(sessionLifecycleService.stopWorkspaceSessions).not.toHaveBeenCalled();
             startSessionDeferred.resolve(undefined);
             await initializationPromise;
-            expect(sessionService.stopWorkspaceSessions).toHaveBeenCalledWith(WORKSPACE_ID);
+            expect(sessionLifecycleService.stopWorkspaceSessions).toHaveBeenCalledWith(WORKSPACE_ID);
             expect(terminalService.destroyTerminal).toHaveBeenCalledWith(WORKSPACE_ID, 'term-default');
-            expect(sessionDataService.clearTerminalPid).toHaveBeenCalledWith(WORKSPACE_ID, 'term-default');
+            expect(terminalSessionService.releaseSessionPid).toHaveBeenCalledWith(WORKSPACE_ID, 'term-default');
             expect(workspaceStateMachine.markFailed).toHaveBeenCalledWith(WORKSPACE_ID, 'script boom');
         });
         it('does not destroy an existing terminal after init failure', async () => {
@@ -980,7 +1156,7 @@ describe('initializeWorkspaceWorktree', () => {
             await initializeWorkspaceWorktree(WORKSPACE_ID);
             expect(terminalService.createTerminal).not.toHaveBeenCalled();
             expect(terminalService.destroyTerminal).not.toHaveBeenCalled();
-            expect(sessionDataService.clearTerminalPid).not.toHaveBeenCalled();
+            expect(terminalSessionService.releaseSessionPid).not.toHaveBeenCalled();
             expect(workspaceStateMachine.markFailed).toHaveBeenCalledWith(WORKSPACE_ID, 'script boom');
         });
     });
@@ -1004,7 +1180,7 @@ describe('initializeWorkspaceWorktree', () => {
             vi.mocked(startupScriptService.runStartupScript).mockResolvedValue({
                 success: true,
             });
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
@@ -1018,7 +1194,7 @@ describe('initializeWorkspaceWorktree', () => {
                 success: false,
                 errorMessage: 'setup failed',
             });
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({ id: 'session-1', status: SessionStatus.IDLE, model: 'claude-sonnet' }),
             ]);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
@@ -1027,7 +1203,7 @@ describe('initializeWorkspaceWorktree', () => {
         });
         it('retries dispatch using the started session id without re-querying session status', async () => {
             setupHappyPath();
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 unsafeCoerce({
                     id: 'session-idle',
                     status: SessionStatus.IDLE,
@@ -1035,8 +1211,8 @@ describe('initializeWorkspaceWorktree', () => {
                 }),
             ]);
             await initializeWorkspaceWorktree(WORKSPACE_ID);
-            expect(agentSessionAccessor.findByWorkspaceId).toHaveBeenCalledTimes(1);
-            expect(agentSessionAccessor.findByWorkspaceId).toHaveBeenCalledWith(WORKSPACE_ID, {
+            expect(sessionDataService.findAgentSessionsByWorkspaceId).toHaveBeenCalledTimes(1);
+            expect(sessionDataService.findAgentSessionsByWorkspaceId).toHaveBeenCalledWith(WORKSPACE_ID, {
                 status: SessionStatus.IDLE,
                 limit: 1,
             });