factory-factory 0.3.21 → 0.4.1

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

@@ -2,32 +2,43 @@ import { execFileSync } from 'node:child_process';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { CIStatus, PRState, RatchetState, RunScriptStatus, SessionStatus, WorkspaceStatus, } from '../../../prisma/generated/client.js';
+import { CIStatus, KanbanColumn, PRState, RatchetState, 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);
     for (const repoDir of tempRepoDirs) {
@@ -77,34 +88,44 @@ function createGitRepository(remoteUrl) {
     }
     return repoDir;
 }
+function createGitCommit(repoPath) {
+    execFileSync('git', ['commit', '--allow-empty', '-m', 'Initial commit'], { cwd: repoPath });
+}
+function setOriginHead(repoPath, branch) {
+    execFileSync('git', ['update-ref', `refs/remotes/origin/${branch}`, 'HEAD'], { cwd: repoPath });
+    execFileSync('git', ['symbolic-ref', 'refs/remotes/origin/HEAD', `refs/remotes/origin/${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,
             });
-            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);
@@ -113,19 +134,25 @@ 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);
         });
@@ -143,7 +170,7 @@ 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);
@@ -171,14 +198,14 @@ describe('resource accessors integration', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.MERGED,
             });
-            const ratchetCandidates = await workspaceAccessor.findWithPRsForRatchet();
+            const ratchetCandidates = await workspaceRatchetService.findCandidates();
             expect(ratchetCandidates.map((workspace) => workspace.id)).toEqual([included.id]);
         });
         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);
@@ -187,8 +214,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);
@@ -205,34 +232,120 @@ 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('clears ratchet active session only when session id matches', async () => {
+        it('settles ratchet session end only when session id matches', async () => {
             const project = await createProjectFixture();
             const workspace = await createWorkspaceFixture(project.id, {
                 ratchetActiveSessionId: 'session-1',
             });
-            await workspaceAccessor.clearRatchetActiveSession(workspace.id, 'different-session');
-            const unchanged = await workspaceAccessor.findRawByIdOrThrow(workspace.id);
+            const mismatch = await workspaceRatchetService.recordSessionEnd(workspace.id, 'different-session', 'DIED');
+            expect(mismatch).toBe(false);
+            const unchanged = await findWorkspaceOrThrow(workspace.id);
             expect(unchanged.ratchetActiveSessionId).toBe('session-1');
-            await workspaceAccessor.clearRatchetActiveSession(workspace.id, 'session-1');
-            const cleared = await workspaceAccessor.findRawByIdOrThrow(workspace.id);
+            expect(unchanged.ratchetDispatchOutcome).toBeNull();
+            const settled = await workspaceRatchetService.recordSessionEnd(workspace.id, 'session-1', 'DIED');
+            expect(settled).toBe(true);
+            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, {
+                prNumber: 42,
+                prState: PRState.CHANGES_REQUESTED,
+                prReviewState: 'CHANGES_REQUESTED',
+                prCiStatus: CIStatus.FAILURE,
+                ratchetLastCiRunId: 'rich-dispatch-snapshot',
+                ratchetDispatchOutcome: 'DIED',
+                ratchetDispatchRetryCount: 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.ratchetLastCiRunId).toBe('rich-dispatch-snapshot');
+            const ciChangedWorkspace = await createWorkspaceFixture(project.id, {
+                prNumber: 42,
+                prState: PRState.OPEN,
+                prReviewState: null,
+                prCiStatus: CIStatus.PENDING,
+                ratchetDispatchOutcome: 'DIED',
+                ratchetDispatchRetryCount: 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, {
+                prNumber: 42,
+                prState: PRState.OPEN,
+                prReviewState: null,
+                prCiStatus: CIStatus.FAILURE,
+                ratchetDispatchOutcome: 'DIED',
+                ratchetDispatchRetryCount: 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, {
+                prNumber: 42,
+                prState: PRState.CHANGES_REQUESTED,
+                prReviewState: 'CHANGES_REQUESTED',
+                prCiStatus: CIStatus.FAILURE,
+                ratchetDispatchOutcome: 'RUNNING',
+                ratchetDispatchRetryCount: 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, {
+                autoIterationSessionId: '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',
@@ -240,14 +353,45 @@ describe('resource accessors integration', () => {
             expect(project.githubOwner).toBe('purplefish-ai');
             expect(project.githubRepo).toBe('factory-factory');
         });
+        it('auto-detects default branch from origin HEAD during create', async () => {
+            const repoPath = createGitRepository('git@github.com:purplefish-ai/factory-factory.git');
+            createGitCommit(repoPath);
+            setOriginHead(repoPath, 'unstable');
+            const project = await projectManagementService.create({
+                repoPath,
+            }, {
+                worktreeBaseDir: '/tmp/worktrees',
+            });
+            expect(project.defaultBranch).toBe('unstable');
+        });
+        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 projectManagementService.create({
+                repoPath,
+            }, {
+                worktreeBaseDir: '/tmp/worktrees',
+            });
+            expect(project.defaultBranch).toBe('develop');
+        });
+        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 projectManagementService.create({
+                repoPath,
+            }, {
+                worktreeBaseDir: '/tmp/worktrees',
+            });
+            expect(project.defaultBranch).toBe('main');
+        });
         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',
@@ -259,26 +403,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);
@@ -291,11 +426,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({
@@ -325,11 +461,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' });
@@ -355,11 +492,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');
@@ -376,11 +514,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');
@@ -394,23 +533,27 @@ describe('resource accessors integration', () => {
             expect(created.status).toBe(SessionStatus.IDLE);
         });
     });
-    describe('terminalSessionAccessor', () => {
-        it('clears pid for all matching terminal names', async () => {
+    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);
+            const otherWorkspace = await createWorkspaceFixture(project.id);
             await prisma.terminalSession.createMany({
                 data: [
                     { workspaceId: workspace.id, name: 'terminal-a', pid: 1001 },
                     { workspaceId: workspace.id, name: 'terminal-a', pid: 2002 },
                     { workspaceId: workspace.id, name: 'terminal-b', pid: 3003 },
+                    { workspaceId: otherWorkspace.id, name: 'terminal-a', pid: 4004 },
                 ],
             });
-            await terminalSessionAccessor.clearPid('terminal-a');
+            await terminalSessionService.releaseSessionPid(workspace.id, 'terminal-a');
             const all = await prisma.terminalSession.findMany({ orderBy: { name: 'asc' } });
-            const target = all.filter((session) => session.name === 'terminal-a');
-            const untouched = all.find((session) => session.name === 'terminal-b');
+            const target = all.filter((session) => session.workspaceId === workspace.id && session.name === 'terminal-a');
+            const untouchedName = all.find((session) => session.name === 'terminal-b');
+            const untouchedWorkspace = all.find((session) => session.workspaceId === otherWorkspace.id && session.name === 'terminal-a');
             expect(target.every((session) => session.pid === null)).toBe(true);
-            expect(untouched?.pid).toBe(3003);
+            expect(untouchedName?.pid).toBe(3003);
+            expect(untouchedWorkspace?.pid).toBe(4004);
         });
         it('finds only terminal sessions with a live pid', async () => {
             const project = await createProjectFixture();
@@ -421,33 +564,74 @@ 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);
             expect(settings.defaultClaudeModel).toBe('sonnet');
             expect(settings.defaultCodexModel).toBe('default');
         });
+        it('returns one default row for concurrent first reads', async () => {
+            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 userSettingsService.get();
+            const originalUpdateMany = prisma.userSettings.updateMany.bind(prisma.userSettings);
+            let injectedConcurrentUpdate = false;
+            const updateManySpy = vi
+                .spyOn(prisma.userSettings, 'updateMany')
+                .mockImplementation((args) => {
+                if (!injectedConcurrentUpdate) {
+                    injectedConcurrentUpdate = true;
+                    return prisma.userSettings
+                        .findUniqueOrThrow({
+                        where: { userId: 'default' },
+                    })
+                        .then((currentSettings) => prisma.userSettings.update({
+                        where: { userId: 'default' },
+                        data: {
+                            workspaceOrder: { [projectB.id]: ['ws-9'] },
+                            updatedAt: new Date(currentSettings.updatedAt.getTime() + 1000),
+                        },
+                    }))
+                        .then(() => originalUpdateMany(args));
+                }
+                return originalUpdateMany(args);
+            });
+            await userSettingsService.updateWorkspaceOrder(projectA.id, ['ws-3', 'ws-1']);
+            const settings = await prisma.userSettings.findUniqueOrThrow({
+                where: { userId: 'default' },
+            });
+            expect(updateManySpy).toHaveBeenCalledTimes(2);
+            expect(settings.workspaceOrder).toEqual({
+                [projectB.id]: ['ws-9'],
+                [projectA.id]: ['ws-3', 'ws-1'],
+            });
+        });
     });
-    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',
             });
@@ -458,11 +642,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);