factory-factory 0.4.0 → 0.4.2

package/dist/src/backend/services/resources.integration.test.js

@@ -2,31 +2,42 @@ import { execFileSync } from 'node:child_process';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { CIStatus, KanbanColumn, PRState, RatchetState, RunScriptStatus, SessionStatus, WorkspaceStatus, } from '../../../prisma/generated/client.js';
+import { CIStatus, PRState, RunScriptStatus, SessionStatus, WorkspaceStatus, } from '../../../prisma/generated/client.js';
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
 import { clearIntegrationDatabase, createIntegrationDatabase, destroyIntegrationDatabase, } from '../../backend/testing/integration-db.js';
 let db;
 let prisma;
-let workspaceAccessor;
-let projectAccessor;
-let agentSessionAccessor;
-let terminalSessionAccessor;
-let userSettingsAccessor;
-let decisionLogAccessor;
-let GitClientFactory;
+let workspaceDataService;
+let workspaceAutoIterationService;
+let workspaceMaintenanceService;
+let workspacePrSnapshotService;
+let workspaceRatchetService;
+let workspaceRunScriptService;
+let workspaceStateMachine;
+let projectManagementService;
+let sessionDataService;
+let terminalSessionService;
+let userSettingsService;
+let decisionLogService;
 let counter = 0;
 const tempRepoDirs = new Set();
 beforeAll(async () => {
     db = await createIntegrationDatabase();
     prisma = db.prisma;
-    ({ workspaceAccessor } = await vi.importActual('@/backend/services/workspace'));
-    ({ projectAccessor } = await vi.importActual('@/backend/services/workspace'));
-    ({ agentSessionAccessor } = await vi.importActual('@/backend/services/session'));
-    ({ terminalSessionAccessor } = await vi.importActual('@/backend/services/terminal'));
-    ({ userSettingsAccessor } = await vi.importActual('@/backend/services/settings'));
-    ({ decisionLogAccessor } = await vi.importActual('@/backend/services/decision-log'));
-    const gitClientModule = await vi.importActual('@/backend/clients/git.client');
-    ({ GitClientFactory } = gitClientModule);
+    ({
+        projectManagementService,
+        workspaceAutoIterationService,
+        workspaceDataService,
+        workspaceMaintenanceService,
+        workspacePrSnapshotService,
+        workspaceRatchetService,
+        workspaceRunScriptService,
+        workspaceStateMachine,
+    } = await vi.importActual('@/backend/services/workspace'));
+    ({ sessionDataService } = await vi.importActual('@/backend/services/session'));
+    ({ terminalSessionService } = await vi.importActual('@/backend/services/terminal'));
+    ({ userSettingsService } = await vi.importActual('@/backend/services/settings'));
+    ({ decisionLogService } = await vi.importActual('@/backend/services/decision-log'));
 }, 30_000);
 afterEach(async () => {
     await clearIntegrationDatabase(prisma);
@@ -57,12 +68,17 @@ async function createProjectFixture(overrides = {}) {
     });
 }
 async function createWorkspaceFixture(projectId, overrides = {}) {
+    const { ratchet, pr, runScript, autoIteration, ...workspaceOverrides } = overrides;
     return await prisma.workspace.create({
         data: {
             projectId,
             name: nextId('workspace'),
             status: WorkspaceStatus.NEW,
-            ...overrides,
+            ...workspaceOverrides,
+            ratchet: { create: ratchet ?? {} },
+            pr: { create: pr ?? {} },
+            runScript: { create: runScript ?? {} },
+            autoIteration: { create: autoIteration ?? {} },
         },
     });
 }
@@ -86,34 +102,35 @@ function setOriginHead(repoPath, branch) {
         cwd: repoPath,
     });
 }
+async function findWorkspaceOrThrow(workspaceId) {
+    const workspace = await workspaceDataService.findById(workspaceId);
+    if (!workspace) {
+        throw new Error(`Workspace not found: ${workspaceId}`);
+    }
+    return workspace;
+}
 describe('resource accessors integration', () => {
-    describe('workspaceAccessor', () => {
-        it('enforces compare-and-swap status transitions', async () => {
+    describe('workspace services', () => {
+        it('persists validated status transitions through the state machine', async () => {
             const project = await createProjectFixture();
             const workspace = await createWorkspaceFixture(project.id, { status: WorkspaceStatus.NEW });
-            const changed = await workspaceAccessor.transitionWithCas(workspace.id, WorkspaceStatus.NEW, {
-                status: WorkspaceStatus.PROVISIONING,
-            });
-            const unchanged = await workspaceAccessor.transitionWithCas(workspace.id, WorkspaceStatus.NEW, {
-                status: WorkspaceStatus.READY,
-            });
-            const reloaded = await workspaceAccessor.findRawByIdOrThrow(workspace.id);
-            expect(changed.count).toBe(1);
-            expect(unchanged.count).toBe(0);
-            expect(reloaded.status).toBe(WorkspaceStatus.PROVISIONING);
+            await workspaceStateMachine.transition(workspace.id, WorkspaceStatus.PROVISIONING);
+            await workspaceStateMachine.transition(workspace.id, WorkspaceStatus.READY);
+            const reloaded = await findWorkspaceOrThrow(workspace.id);
+            expect(reloaded.status).toBe(WorkspaceStatus.READY);
         });
         it('enforces compare-and-swap run script transitions', async () => {
             const project = await createProjectFixture();
             const workspace = await createWorkspaceFixture(project.id, {
-                runScriptStatus: RunScriptStatus.IDLE,
+                runScript: { status: RunScriptStatus.IDLE },
             });
-            const started = await workspaceAccessor.casRunScriptStatusUpdate(workspace.id, RunScriptStatus.IDLE, {
+            const started = await workspaceRunScriptService.transitionStatusIfCurrent(workspace.id, RunScriptStatus.IDLE, {
                 runScriptStatus: RunScriptStatus.STARTING,
             });
-            const duplicate = await workspaceAccessor.casRunScriptStatusUpdate(workspace.id, RunScriptStatus.IDLE, {
+            const duplicate = await workspaceRunScriptService.transitionStatusIfCurrent(workspace.id, RunScriptStatus.IDLE, {
                 runScriptStatus: RunScriptStatus.RUNNING,
             });
-            const reloaded = await workspaceAccessor.findRawByIdOrThrow(workspace.id);
+            const reloaded = await findWorkspaceOrThrow(workspace.id);
             expect(started.count).toBe(1);
             expect(duplicate.count).toBe(0);
             expect(reloaded.runScriptStatus).toBe(RunScriptStatus.STARTING);
@@ -122,21 +139,23 @@ describe('resource accessors integration', () => {
             const project = await createProjectFixture();
             const eligible = await createWorkspaceFixture(project.id, {
                 status: WorkspaceStatus.FAILED,
-                cachedKanbanColumn: KanbanColumn.WAITING,
                 initRetryCount: 1,
             });
             const maxed = await createWorkspaceFixture(project.id, {
                 status: WorkspaceStatus.FAILED,
                 initRetryCount: 3,
             });
-            const eligibleResult = await workspaceAccessor.startProvisioningRetryIfAllowed(eligible.id, 3);
-            const maxedResult = await workspaceAccessor.startProvisioningRetryIfAllowed(maxed.id, 3);
-            const eligibleReloaded = await workspaceAccessor.findRawByIdOrThrow(eligible.id);
-            const maxedReloaded = await workspaceAccessor.findRawByIdOrThrow(maxed.id);
-            expect(eligibleResult.count).toBe(1);
-            expect(maxedResult.count).toBe(0);
+            const eligibleResult = await workspaceStateMachine.startProvisioning(eligible.id, {
+                maxRetries: 3,
+            });
+            const maxedResult = await workspaceStateMachine.startProvisioning(maxed.id, {
+                maxRetries: 3,
+            });
+            const eligibleReloaded = await findWorkspaceOrThrow(eligible.id);
+            const maxedReloaded = await findWorkspaceOrThrow(maxed.id);
+            expect(eligibleResult).not.toBeNull();
+            expect(maxedResult).toBeNull();
             expect(eligibleReloaded.status).toBe(WorkspaceStatus.PROVISIONING);
-            expect(eligibleReloaded.cachedKanbanColumn).toBe(KanbanColumn.WORKING);
             expect(eligibleReloaded.initRetryCount).toBe(2);
             expect(maxedReloaded.status).toBe(WorkspaceStatus.FAILED);
         });
@@ -154,42 +173,70 @@ describe('resource accessors integration', () => {
                 status: WorkspaceStatus.PROVISIONING,
                 initStartedAt: new Date(),
             });
-            const needingWorktree = await workspaceAccessor.findNeedingWorktree();
+            const needingWorktree = await workspaceMaintenanceService.findNeedingWorktree();
             const ids = new Set(needingWorktree.map((workspace) => workspace.id));
             expect(ids.has(newWorkspace.id)).toBe(true);
             expect(ids.has(staleProvisioning.id)).toBe(true);
             expect(needingWorktree.some((workspace) => workspace.status === WorkspaceStatus.PROVISIONING)).toBe(true);
         });
-        it('filters ratchet workspaces by READY + PR + ratchet state', async () => {
+        it('filters ratchet workspaces by READY + open PR + ratchet enabled', async () => {
             const project = await createProjectFixture();
             const included = await createWorkspaceFixture(project.id, {
                 status: WorkspaceStatus.READY,
-                prUrl: 'https://github.com/acme/repo/pull/1',
-                prNumber: 1,
-                prState: PRState.OPEN,
-                prCiStatus: CIStatus.PENDING,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_RUNNING,
+                pr: {
+                    url: 'https://github.com/acme/repo/pull/1',
+                    number: 1,
+                    state: PRState.OPEN,
+                    ciStatus: CIStatus.PENDING,
+                },
+                ratchet: { enabled: true },
             });
             await createWorkspaceFixture(project.id, {
                 status: WorkspaceStatus.READY,
-                prUrl: 'https://github.com/acme/repo/pull/2',
-                ratchetEnabled: false,
+                pr: { url: 'https://github.com/acme/repo/pull/2' },
+                ratchet: { enabled: false },
             });
             await createWorkspaceFixture(project.id, {
                 status: WorkspaceStatus.READY,
-                prUrl: 'https://github.com/acme/repo/pull/3',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.MERGED,
+                pr: { url: 'https://github.com/acme/repo/pull/3', state: PRState.MERGED },
+                ratchet: { enabled: true },
             });
-            const ratchetCandidates = await workspaceAccessor.findWithPRsForRatchet();
+            const ratchetCandidates = await workspaceRatchetService.findCandidates();
             expect(ratchetCandidates.map((workspace) => workspace.id)).toEqual([included.id]);
         });
+        it('projects ratchetState from the PR row on every read, with no state column', async () => {
+            const project = await createProjectFixture();
+            const conflicted = await createWorkspaceFixture(project.id, {
+                status: WorkspaceStatus.READY,
+                pr: {
+                    url: 'https://github.com/acme/repo/pull/10',
+                    number: 10,
+                    state: PRState.OPEN,
+                    ciStatus: CIStatus.SUCCESS,
+                    hasMergeConflict: true,
+                },
+                ratchet: { enabled: true },
+            });
+            await expect(workspaceDataService.findById(conflicted.id)).resolves.toMatchObject({
+                prHasMergeConflict: true,
+                ratchetState: 'MERGE_CONFLICT',
+            });
+            await workspaceRatchetService.disable(conflicted.id);
+            await expect(workspaceDataService.findById(conflicted.id)).resolves.toMatchObject({
+                ratchetEnabled: false,
+                ratchetState: 'IDLE',
+            });
+            await workspaceRatchetService.enable(conflicted.id);
+            await expect(workspaceDataService.findById(conflicted.id)).resolves.toMatchObject({
+                ratchetEnabled: true,
+                ratchetState: 'MERGE_CONFLICT',
+            });
+        });
         it('truncates init output when max size is exceeded', async () => {
             const project = await createProjectFixture();
             const workspace = await createWorkspaceFixture(project.id);
-            await workspaceAccessor.appendInitOutput(workspace.id, 'a'.repeat(80), 50);
-            const reloaded = await workspaceAccessor.findRawByIdOrThrow(workspace.id);
+            await workspaceRunScriptService.appendInitOutput(workspace.id, 'a'.repeat(80), 50);
+            const reloaded = await findWorkspaceOrThrow(workspace.id);
             expect(reloaded.initOutput).toBeTruthy();
             expect((reloaded.initOutput || '').length).toBeLessThanOrEqual(50);
             expect(reloaded.initOutput?.startsWith('[...truncated...]\n')).toBe(true);
@@ -198,8 +245,8 @@ describe('resource accessors integration', () => {
             const project = await createProjectFixture();
             const workspace = await createWorkspaceFixture(project.id);
             const chunks = Array.from({ length: 40 }, (_, index) => `chunk-${index}\n`);
-            await Promise.all(chunks.map((chunk) => workspaceAccessor.appendInitOutput(workspace.id, chunk, 10 * 1024)));
-            const reloaded = await workspaceAccessor.findRawByIdOrThrow(workspace.id);
+            await Promise.all(chunks.map((chunk) => workspaceRunScriptService.appendInitOutput(workspace.id, chunk, 10 * 1024)));
+            const reloaded = await findWorkspaceOrThrow(workspace.id);
             const output = reloaded.initOutput ?? '';
             expect(output.length).toBeGreaterThan(0);
             expect(output.startsWith('[...truncated...]\n')).toBe(false);
@@ -216,38 +263,117 @@ describe('resource accessors integration', () => {
         SET "updatedAt" = ${staleUpdatedAt}
         WHERE "id" = ${workspace.id}
       `;
-            await workspaceAccessor.appendInitOutput(workspace.id, 'hello\n');
-            const reloaded = await workspaceAccessor.findRawByIdOrThrow(workspace.id);
+            await workspaceRunScriptService.appendInitOutput(workspace.id, 'hello\n');
+            const reloaded = await findWorkspaceOrThrow(workspace.id);
             expect(reloaded.updatedAt.getTime()).toBeGreaterThan(staleUpdatedAt.getTime());
         });
         it('settles ratchet session end only when session id matches', async () => {
             const project = await createProjectFixture();
             const workspace = await createWorkspaceFixture(project.id, {
-                ratchetActiveSessionId: 'session-1',
+                ratchet: { activeSessionId: 'session-1' },
             });
-            const mismatch = await workspaceAccessor.recordRatchetSessionEnd(workspace.id, 'different-session', 'DIED');
+            const mismatch = await workspaceRatchetService.recordSessionEnd(workspace.id, 'different-session', 'DIED');
             expect(mismatch).toBe(false);
-            const unchanged = await workspaceAccessor.findRawByIdOrThrow(workspace.id);
+            const unchanged = await findWorkspaceOrThrow(workspace.id);
             expect(unchanged.ratchetActiveSessionId).toBe('session-1');
             expect(unchanged.ratchetDispatchOutcome).toBeNull();
-            const settled = await workspaceAccessor.recordRatchetSessionEnd(workspace.id, 'session-1', 'DIED');
+            const settled = await workspaceRatchetService.recordSessionEnd(workspace.id, 'session-1', 'DIED');
             expect(settled).toBe(true);
-            const cleared = await workspaceAccessor.findRawByIdOrThrow(workspace.id);
+            const cleared = await findWorkspaceOrThrow(workspace.id);
             expect(cleared.ratchetActiveSessionId).toBeNull();
             expect(cleared.ratchetDispatchOutcome).toBe('DIED');
         });
-        it('throws when mutually exclusive status filters are passed', async () => {
+        it('resets settled Ratchet ownership only for changed PR aggregates', async () => {
             const project = await createProjectFixture();
-            expect(() => workspaceAccessor.findByProjectIdWithSessions(project.id, {
-                status: WorkspaceStatus.READY,
-                excludeStatuses: [WorkspaceStatus.NEW],
-            })).toThrow('Cannot specify both status and excludeStatuses filters');
+            const workspace = await createWorkspaceFixture(project.id, {
+                pr: {
+                    number: 42,
+                    state: PRState.CHANGES_REQUESTED,
+                    reviewState: 'CHANGES_REQUESTED',
+                    ciStatus: CIStatus.FAILURE,
+                },
+                ratchet: {
+                    dispatchSnapshotKey: 'rich-dispatch-snapshot',
+                    dispatchOutcome: 'DIED',
+                    dispatchRetryCount: 3,
+                },
+            });
+            const identical = await workspacePrSnapshotService.applyPrSnapshotWithDispatchReset(workspace.id, {
+                prNumber: 42,
+                prState: PRState.CHANGES_REQUESTED,
+                prReviewState: 'CHANGES_REQUESTED',
+                prCiStatus: CIStatus.FAILURE,
+                prUpdatedAt: new Date('2026-07-17T12:00:00.000Z'),
+            });
+            expect(identical).toEqual({ applied: true, dispatchReset: false });
+            expect((await findWorkspaceOrThrow(workspace.id)).ratchetDispatchOutcome).toBe('DIED');
+            const changed = await workspacePrSnapshotService.applyPrSnapshotWithDispatchReset(workspace.id, {
+                prNumber: 42,
+                prState: PRState.OPEN,
+                prReviewState: null,
+                prCiStatus: CIStatus.PENDING,
+                prUpdatedAt: new Date('2026-07-17T12:01:00.000Z'),
+            });
+            expect(changed).toEqual({ applied: true, dispatchReset: true });
+            const reset = await findWorkspaceOrThrow(workspace.id);
+            expect(reset.ratchetDispatchOutcome).toBeNull();
+            expect(reset.ratchetDispatchRetryCount).toBe(0);
+            expect(reset.ratchetDispatchSnapshotKey).toBe('rich-dispatch-snapshot');
+            const ciChangedWorkspace = await createWorkspaceFixture(project.id, {
+                pr: { number: 42, state: PRState.OPEN, reviewState: null, ciStatus: CIStatus.PENDING },
+                ratchet: { dispatchOutcome: 'DIED', dispatchRetryCount: 3 },
+            });
+            await expect(workspacePrSnapshotService.applyPrSnapshotWithDispatchReset(ciChangedWorkspace.id, {
+                prNumber: 42,
+                prState: PRState.OPEN,
+                prReviewState: null,
+                prCiStatus: CIStatus.FAILURE,
+                prUpdatedAt: new Date('2026-07-17T12:02:00.000Z'),
+            })).resolves.toEqual({ applied: true, dispatchReset: true });
+            const reviewChangedWorkspace = await createWorkspaceFixture(project.id, {
+                pr: { number: 42, state: PRState.OPEN, reviewState: null, ciStatus: CIStatus.FAILURE },
+                ratchet: { dispatchOutcome: 'DIED', dispatchRetryCount: 3 },
+            });
+            await expect(workspacePrSnapshotService.applyPrSnapshotWithDispatchReset(reviewChangedWorkspace.id, {
+                prNumber: 42,
+                prState: PRState.CHANGES_REQUESTED,
+                prReviewState: 'CHANGES_REQUESTED',
+                prCiStatus: CIStatus.FAILURE,
+                prUpdatedAt: new Date('2026-07-17T12:03:00.000Z'),
+            })).resolves.toEqual({ applied: true, dispatchReset: true });
+            const runningWorkspace = await createWorkspaceFixture(project.id, {
+                pr: {
+                    number: 42,
+                    state: PRState.CHANGES_REQUESTED,
+                    reviewState: 'CHANGES_REQUESTED',
+                    ciStatus: CIStatus.FAILURE,
+                },
+                ratchet: { dispatchOutcome: 'RUNNING', dispatchRetryCount: 1 },
+            });
+            await expect(workspacePrSnapshotService.applyPrSnapshotWithDispatchReset(runningWorkspace.id, {
+                prNumber: 43,
+                prState: PRState.OPEN,
+                prReviewState: null,
+                prCiStatus: CIStatus.SUCCESS,
+                prUpdatedAt: new Date('2026-07-17T12:04:00.000Z'),
+            })).resolves.toEqual({ applied: true, dispatchReset: false });
+            expect((await findWorkspaceOrThrow(runningWorkspace.id)).ratchetDispatchOutcome).toBe('RUNNING');
+        });
+        it('clears auto-iteration session only when the expected pointer still matches', async () => {
+            const project = await createProjectFixture();
+            const workspace = await createWorkspaceFixture(project.id, {
+                autoIteration: { sessionId: 'session-1' },
+            });
+            await expect(workspaceAutoIterationService.clearSessionIfMatching(workspace.id, 'different-session')).resolves.toBe(false);
+            expect((await findWorkspaceOrThrow(workspace.id)).autoIterationSessionId).toBe('session-1');
+            await expect(workspaceAutoIterationService.clearSessionIfMatching(workspace.id, 'session-1')).resolves.toBe(true);
+            expect((await findWorkspaceOrThrow(workspace.id)).autoIterationSessionId).toBeNull();
         });
     });
-    describe('projectAccessor', () => {
+    describe('projectManagementService', () => {
         it('auto-detects GitHub owner/repo from git remote during create', async () => {
             const repoPath = createGitRepository('git@github.com:purplefish-ai/factory-factory.git');
-            const project = await projectAccessor.create({
+            const project = await projectManagementService.create({
                 repoPath,
             }, {
                 worktreeBaseDir: '/tmp/worktrees',
@@ -259,7 +385,7 @@ describe('resource accessors integration', () => {
             const repoPath = createGitRepository('git@github.com:purplefish-ai/factory-factory.git');
             createGitCommit(repoPath);
             setOriginHead(repoPath, 'unstable');
-            const project = await projectAccessor.create({
+            const project = await projectManagementService.create({
                 repoPath,
             }, {
                 worktreeBaseDir: '/tmp/worktrees',
@@ -269,7 +395,7 @@ describe('resource accessors integration', () => {
         it('falls back to local HEAD when origin HEAD is unavailable during create', async () => {
             const repoPath = createGitRepository();
             execFileSync('git', ['checkout', '-b', 'develop'], { cwd: repoPath });
-            const project = await projectAccessor.create({
+            const project = await projectManagementService.create({
                 repoPath,
             }, {
                 worktreeBaseDir: '/tmp/worktrees',
@@ -279,7 +405,7 @@ describe('resource accessors integration', () => {
         it('falls back to main when default branch cannot be detected during create', async () => {
             const repoPath = mkdtempSync(join(tmpdir(), 'ff-nongit-'));
             tempRepoDirs.add(repoPath);
-            const project = await projectAccessor.create({
+            const project = await projectManagementService.create({
                 repoPath,
             }, {
                 worktreeBaseDir: '/tmp/worktrees',
@@ -288,12 +414,12 @@ describe('resource accessors integration', () => {
         });
         it('retries slug creation when a slug collision occurs', async () => {
             const repoPath = createGitRepository();
-            const first = await projectAccessor.create({
+            const first = await projectManagementService.create({
                 repoPath,
             }, {
                 worktreeBaseDir: '/tmp/worktrees',
             });
-            const second = await projectAccessor.create({
+            const second = await projectManagementService.create({
                 repoPath,
             }, {
                 worktreeBaseDir: '/tmp/worktrees',
@@ -305,26 +431,17 @@ describe('resource accessors integration', () => {
             const gitRepo = createGitRepository();
             const nonGitDir = mkdtempSync(join(tmpdir(), 'ff-nongit-'));
             tempRepoDirs.add(nonGitDir);
-            const valid = await projectAccessor.validateRepoPath(gitRepo);
-            const invalid = await projectAccessor.validateRepoPath(nonGitDir);
-            const missing = await projectAccessor.validateRepoPath('/path/that/does/not/exist');
+            const valid = await projectManagementService.validateRepoPath(gitRepo);
+            const invalid = await projectManagementService.validateRepoPath(nonGitDir);
+            const missing = await projectManagementService.validateRepoPath('/path/that/does/not/exist');
             expect(valid.valid).toBe(true);
             expect(invalid.valid).toBe(false);
             expect(invalid.error).toContain('not a git repository');
             expect(missing.valid).toBe(false);
             expect(missing.error).toContain('does not exist');
         });
-        it('evicts git client cache on project delete', async () => {
-            const project = await createProjectFixture();
-            const removeSpy = vi.spyOn(GitClientFactory, 'removeProject').mockImplementation(() => false);
-            await projectAccessor.delete(project.id);
-            expect(removeSpy).toHaveBeenCalledWith({
-                repoPath: project.repoPath,
-                worktreeBasePath: project.worktreeBasePath,
-            });
-        });
     });
-    describe('agentSessionAccessor', () => {
+    describe('sessionDataService', () => {
         it('returns existing RUNNING fixer session instead of creating a new one', async () => {
             const project = await createProjectFixture();
             const workspace = await createWorkspaceFixture(project.id);
@@ -337,11 +454,12 @@ describe('resource accessors integration', () => {
                     provider: 'CLAUDE',
                 },
             });
-            const acquired = await agentSessionAccessor.acquireFixerSession({
+            const acquired = await sessionDataService.acquireFixerSession({
                 workspaceId: workspace.id,
                 workflow: 'ci-fix',
                 sessionName: 'CI Fixer',
                 maxSessions: 3,
+                provider: 'CLAUDE',
                 providerProjectPath: '/tmp/worktree',
             });
             expect(acquired).toEqual({
@@ -371,11 +489,12 @@ describe('resource accessors integration', () => {
                     },
                 ],
             });
-            const acquired = await agentSessionAccessor.acquireFixerSession({
+            const acquired = await sessionDataService.acquireFixerSession({
                 workspaceId: workspace.id,
                 workflow: 'ci-fix',
                 sessionName: 'CI Fixer',
                 maxSessions: 2,
+                provider: 'CLAUDE',
                 providerProjectPath: null,
             });
             expect(acquired).toEqual({ outcome: 'limit_reached' });
@@ -401,11 +520,12 @@ describe('resource accessors integration', () => {
                     },
                 ],
             });
-            const acquired = await agentSessionAccessor.acquireFixerSession({
+            const acquired = await sessionDataService.acquireFixerSession({
                 workspaceId: workspace.id,
                 workflow: 'ci-fix',
                 sessionName: 'CI Fixer',
                 maxSessions: 2,
+                provider: 'CLAUDE',
                 providerProjectPath: null,
             });
             expect(acquired.outcome).toBe('created');
@@ -422,11 +542,12 @@ describe('resource accessors integration', () => {
                     provider: 'CLAUDE',
                 },
             });
-            const acquired = await agentSessionAccessor.acquireFixerSession({
+            const acquired = await sessionDataService.acquireFixerSession({
                 workspaceId: workspace.id,
                 workflow: 'ci-fix',
                 sessionName: 'CI Fixer',
                 maxSessions: 5,
+                provider: 'CLAUDE',
                 providerProjectPath: '/tmp/worktree',
             });
             expect(acquired.outcome).toBe('created');
@@ -440,7 +561,7 @@ describe('resource accessors integration', () => {
             expect(created.status).toBe(SessionStatus.IDLE);
         });
     });
-    describe('terminalSessionAccessor', () => {
+    describe('terminalSessionService', () => {
         it('clears pid only for matching terminal names in the requested workspace', async () => {
             const project = await createProjectFixture();
             const workspace = await createWorkspaceFixture(project.id);
@@ -453,7 +574,7 @@ describe('resource accessors integration', () => {
                     { workspaceId: otherWorkspace.id, name: 'terminal-a', pid: 4004 },
                 ],
             });
-            await terminalSessionAccessor.clearPid(workspace.id, 'terminal-a');
+            await terminalSessionService.releaseSessionPid(workspace.id, 'terminal-a');
             const all = await prisma.terminalSession.findMany({ orderBy: { name: 'asc' } });
             const target = all.filter((session) => session.workspaceId === workspace.id && session.name === 'terminal-a');
             const untouchedName = all.find((session) => session.name === 'terminal-b');
@@ -471,13 +592,13 @@ describe('resource accessors integration', () => {
             await prisma.terminalSession.create({
                 data: { workspaceId: workspace.id, name: 'idle', pid: null },
             });
-            const withPid = await terminalSessionAccessor.findWithPid();
+            const withPid = await terminalSessionService.listPidBackedSessions();
             expect(withPid.map((session) => session.id)).toEqual([live.id]);
         });
     });
-    describe('userSettingsAccessor', () => {
+    describe('userSettingsService', () => {
         it('creates defaults on first read', async () => {
-            const settings = await userSettingsAccessor.get();
+            const settings = await userSettingsService.get();
             expect(settings.userId).toBe('default');
             expect(settings.preferredIde).toBe('cursor');
             expect(settings.playSoundOnComplete).toBe(true);
@@ -485,24 +606,24 @@ describe('resource accessors integration', () => {
             expect(settings.defaultCodexModel).toBe('default');
         });
         it('returns one default row for concurrent first reads', async () => {
-            const settings = await Promise.all(Array.from({ length: 10 }, () => userSettingsAccessor.get()));
+            const settings = await Promise.all(Array.from({ length: 10 }, () => userSettingsService.get()));
             expect(new Set(settings.map((row) => row.id)).size).toBe(1);
             expect(await prisma.userSettings.count({ where: { userId: 'default' } })).toBe(1);
         });
         it('persists workspace order by project id', async () => {
             const projectA = await createProjectFixture();
             const projectB = await createProjectFixture();
-            await userSettingsAccessor.updateWorkspaceOrder(projectA.id, ['ws-3', 'ws-1']);
-            await userSettingsAccessor.updateWorkspaceOrder(projectB.id, ['ws-9']);
-            const orderA = await userSettingsAccessor.getWorkspaceOrder(projectA.id);
-            const orderB = await userSettingsAccessor.getWorkspaceOrder(projectB.id);
+            await userSettingsService.updateWorkspaceOrder(projectA.id, ['ws-3', 'ws-1']);
+            await userSettingsService.updateWorkspaceOrder(projectB.id, ['ws-9']);
+            const orderA = await userSettingsService.getWorkspaceOrder(projectA.id);
+            const orderB = await userSettingsService.getWorkspaceOrder(projectB.id);
             expect(orderA).toEqual(['ws-3', 'ws-1']);
             expect(orderB).toEqual(['ws-9']);
         });
         it('retries stale workspace order writes and preserves concurrent project entries', async () => {
             const projectA = await createProjectFixture();
             const projectB = await createProjectFixture();
-            await userSettingsAccessor.get();
+            await userSettingsService.get();
             const originalUpdateMany = prisma.userSettings.updateMany.bind(prisma.userSettings);
             let injectedConcurrentUpdate = false;
             const updateManySpy = vi
@@ -525,7 +646,7 @@ describe('resource accessors integration', () => {
                 }
                 return originalUpdateMany(args);
             });
-            await userSettingsAccessor.updateWorkspaceOrder(projectA.id, ['ws-3', 'ws-1']);
+            await userSettingsService.updateWorkspaceOrder(projectA.id, ['ws-3', 'ws-1']);
             const settings = await prisma.userSettings.findUniqueOrThrow({
                 where: { userId: 'default' },
             });
@@ -536,9 +657,9 @@ describe('resource accessors integration', () => {
             });
         });
     });
-    describe('decisionLogAccessor', () => {
+    describe('decisionLogService', () => {
         it('formats automatic error logs with structured context', async () => {
-            const entry = await decisionLogAccessor.createAutomatic('agent-1', 'OpenFile', 'error', {
+            const entry = await decisionLogService.createAutomatic('agent-1', 'OpenFile', 'error', {
                 message: 'permission denied',
                 code: 'EACCES',
             });
@@ -549,11 +670,11 @@ describe('resource accessors integration', () => {
             expect(entry.context).toContain('EACCES');
         });
         it('lists recent logs scoped by agent id', async () => {
-            await decisionLogAccessor.createManual('agent-1', 'Decision A', 'Reason A');
-            await decisionLogAccessor.createManual('agent-2', 'Decision B', 'Reason B');
-            await decisionLogAccessor.createManual('agent-1', 'Decision C', 'Reason C');
-            const agentOne = await decisionLogAccessor.list({ agentId: 'agent-1', limit: 10 });
-            const all = await decisionLogAccessor.list({ limit: 10 });
+            await decisionLogService.createManual('agent-1', 'Decision A', 'Reason A');
+            await decisionLogService.createManual('agent-2', 'Decision B', 'Reason B');
+            await decisionLogService.createManual('agent-1', 'Decision C', 'Reason C');
+            const agentOne = await decisionLogService.list({ agentId: 'agent-1', limit: 10 });
+            const all = await decisionLogService.list({ limit: 10 });
             expect(agentOne).toHaveLength(2);
             expect(agentOne.every((entry) => entry.agentId === 'agent-1')).toBe(true);
             expect(all).toHaveLength(3);