factory-factory 0.4.0 → 0.4.2

package/dist/src/backend/services/workspace/service/query/workspace-query.service.test.js

@@ -1,29 +1,31 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { WorkspaceSnapshotStore } from '../../../../../backend/services/workspace/service/snapshot/workspace-snapshot-store.service.js';
 import { deriveWorkspaceFlowState } from '../../../../../backend/services/workspace/service/state/flow-state.js';
 import { computeKanbanColumn } from '../../../../../backend/services/workspace/service/state/kanban-state.js';
-import { WorkspaceSnapshotStore } from '../../../../../backend/services/workspace-snapshot-store.service.js';
-import { CIStatus, PRState, RatchetState, RunScriptStatus, WorkspaceStatus } from '../../../../../shared/core/index.js';
+import { CIStatus, KanbanColumn, PRState, RatchetState, RunScriptStatus, WorkspaceStatus, } from '../../../../../shared/core/index.js';
 import { deriveWorkspaceSidebarStatus } from '../../../../../shared/workspace-sidebar-status.js';
 import { workspaceQueryService } from './workspace-query.service.js';
 const mockFindByProjectIdWithSessions = vi.fn();
-const mockFindByProjectId = vi.fn();
 const mockFindById = vi.fn();
 const mockFindByIdWithProject = vi.fn();
 const mockWorkspaceUpdate = vi.fn();
+const mockResetPRDiscoveryBackoff = vi.fn();
 const mockProjectFindById = vi.fn();
 const mockDeriveWorkspaceRuntimeState = vi.fn();
-const mockReadConfig = vi.fn();
 const mockGetWorkspaceGitStats = vi.fn();
-const mockSyncWorkspaceCommandsFromWorktreeConfig = vi.fn();
 vi.mock('@/backend/services/workspace/resources/workspace.accessor', () => ({
     workspaceAccessor: {
         findByProjectIdWithSessions: (...args) => mockFindByProjectIdWithSessions(...args),
-        findByProjectId: (...args) => mockFindByProjectId(...args),
         findById: (...args) => mockFindById(...args),
         findByIdWithProject: (...args) => mockFindByIdWithProject(...args),
         update: (...args) => mockWorkspaceUpdate(...args),
     },
 }));
+vi.mock('@/backend/services/workspace/resources/workspace-pr.accessor', () => ({
+    workspacePrAccessor: {
+        resetDiscoveryBackoff: (...args) => mockResetPRDiscoveryBackoff(...args),
+    },
+}));
 vi.mock('@/backend/services/workspace/resources/project.accessor', () => ({
     projectAccessor: {
         findById: (...args) => mockProjectFindById(...args),
@@ -32,17 +34,7 @@ vi.mock('@/backend/services/workspace/resources/project.accessor', () => ({
 vi.mock('@/backend/services/workspace/service/state/workspace-runtime-state', () => ({
     deriveWorkspaceRuntimeState: (...args) => mockDeriveWorkspaceRuntimeState(...args),
 }));
-vi.mock('@/backend/services/factory-config.service', () => ({
-    FactoryConfigService: {
-        readConfig: (...args) => mockReadConfig(...args),
-    },
-}));
-vi.mock('@/backend/services/run-script-config-persistence.service', () => ({
-    runScriptConfigPersistenceService: {
-        syncWorkspaceCommandsFromWorktreeConfig: (...args) => mockSyncWorkspaceCommandsFromWorktreeConfig(...args),
-    },
-}));
-vi.mock('@/backend/services/git-ops.service', () => ({
+vi.mock('@/backend/services/workspace/service/worktree/git-ops.service', () => ({
     gitOpsService: {
         getWorkspaceGitStats: (...args) => mockGetWorkspaceGitStats(...args),
     },
@@ -56,11 +48,9 @@ vi.mock('@/backend/services/logger.service', () => ({
     }),
 }));
 describe('WorkspaceQueryService', () => {
-    const mockIsAnySessionWorking = vi.fn();
     const mockGetAllPendingRequests = vi.fn();
     const mockGetRuntimeSnapshot = vi.fn();
     const mockSessionBridge = {
-        isAnySessionWorking: mockIsAnySessionWorking,
         getAllPendingRequests: mockGetAllPendingRequests,
         getRuntimeSnapshot: mockGetRuntimeSnapshot,
     };
@@ -88,44 +78,7 @@ describe('WorkspaceQueryService', () => {
             prSnapshot: mockPrSnapshotBridge,
         });
     });
-    it('listWithRuntimeState maps working state and pending request types', async () => {
-        mockFindByProjectIdWithSessions.mockResolvedValue([
-            { id: 'ws-1', name: 'Workspace 1' },
-            { id: 'ws-2', name: 'Workspace 2' },
-            { id: 'ws-3', name: 'Workspace 3' },
-        ]);
-        mockDeriveWorkspaceRuntimeState.mockImplementation((workspace) => {
-            if (workspace.id === 'ws-1') {
-                return { sessionIds: ['s-1'], isSessionWorking: false, isWorking: false };
-            }
-            if (workspace.id === 'ws-2') {
-                return { sessionIds: ['s-2'], isSessionWorking: true, isWorking: true };
-            }
-            return { sessionIds: ['s-3'], isSessionWorking: false, isWorking: false };
-        });
-        mockGetAllPendingRequests.mockReturnValue(new Map([
-            ['s-1', { toolName: 'ExitPlanMode' }],
-            ['s-2', { toolName: 'SomeOtherPermissionTool' }],
-        ]));
-        const result = await workspaceQueryService.listWithRuntimeState({ projectId: 'proj-1' });
-        expect(result).toHaveLength(3);
-        expect(result[0]).toMatchObject({
-            id: 'ws-1',
-            isWorking: false,
-            pendingRequestType: 'plan_approval',
-        });
-        expect(result[1]).toMatchObject({
-            id: 'ws-2',
-            isWorking: true,
-            pendingRequestType: 'permission_request',
-        });
-        expect(result[2]).toMatchObject({
-            id: 'ws-3',
-            isWorking: false,
-            pendingRequestType: null,
-        });
-    });
-    it('listWithKanbanState shows empty workspaces and applies runtime-derived reasons', async () => {
+    it('listForProject applies runtime-derived reasons, newest first', async () => {
         mockFindByProjectIdWithSessions.mockResolvedValue([
             {
                 id: 'w1',
@@ -165,7 +118,7 @@ describe('WorkspaceQueryService', () => {
             },
         }));
         mockGetAllPendingRequests.mockReturnValue(new Map([['w2', { toolName: 'AskUserQuestion' }]]));
-        const result = await workspaceQueryService.listWithKanbanState({ projectId: 'proj-1' });
+        const { workspaces: result } = await workspaceQueryService.listForProject('proj-1');
         expect(result).toHaveLength(2);
         expect(result[0]).toMatchObject({
             id: 'w2',
@@ -187,7 +140,52 @@ describe('WorkspaceQueryService', () => {
             },
         });
     });
-    it('listWithKanbanState returns only workspaces matching the requested live kanbanColumn', async () => {
+    it('keeps pending CI automation-owned without marking the session working', async () => {
+        mockProjectFindById.mockResolvedValue({ id: 'p1', defaultBranch: 'main' });
+        mockFindByProjectIdWithSessions.mockResolvedValue([
+            {
+                id: 'w-ci',
+                name: 'Pending CI',
+                status: WorkspaceStatus.READY,
+                createdAt: new Date('2026-01-01T00:00:00.000Z'),
+                worktreePath: null,
+                branchName: 'feature/pending-ci',
+                prUrl: 'https://github.com/org/repo/pull/1',
+                prNumber: 1,
+                prState: PRState.OPEN,
+                prCiStatus: CIStatus.PENDING,
+                prUpdatedAt: new Date('2026-01-01T00:00:00.000Z'),
+                ratchetEnabled: true,
+                ratchetState: RatchetState.CI_RUNNING,
+                ratchetDispatchOutcome: null,
+                ratchetDispatchRetryCount: 0,
+                runScriptStatus: RunScriptStatus.IDLE,
+                hasHadSessions: true,
+                agentSessions: [],
+                terminalSessions: [],
+            },
+        ]);
+        mockDeriveWorkspaceRuntimeState.mockReturnValue({
+            sessionIds: [],
+            isSessionWorking: false,
+            isWorking: true,
+            flowState: {
+                hasActivePr: true,
+                isWorking: true,
+                shouldAnimateRatchetButton: true,
+                phase: 'CI_WAIT',
+                ciObservation: 'CHECKS_PENDING',
+            },
+        });
+        mockGetAllPendingRequests.mockReturnValue(new Map());
+        mockGithubCheckHealth.mockResolvedValue({ isInstalled: false, isAuthenticated: false });
+        const result = await workspaceQueryService.listForProject('p1');
+        expect(result.workspaces[0]).toMatchObject({
+            id: 'w-ci',
+            isWorking: false,
+        });
+    });
+    it('findWorkspaceIdsInKanbanColumn returns only ids matching the live column', async () => {
         mockFindByProjectIdWithSessions.mockResolvedValue([
             {
                 id: 'w1',
@@ -198,7 +196,6 @@ describe('WorkspaceQueryService', () => {
                 ratchetState: RatchetState.IDLE,
                 runScriptStatus: RunScriptStatus.IDLE,
                 hasHadSessions: true,
-                cachedKanbanColumn: 'WAITING',
                 createdAt: new Date('2026-01-01T00:00:00.000Z'),
             },
         ]);
@@ -215,17 +212,88 @@ describe('WorkspaceQueryService', () => {
             },
         });
         mockGetAllPendingRequests.mockReturnValue(new Map());
-        const result = await workspaceQueryService.listWithKanbanState({
-            projectId: 'proj-1',
-            kanbanColumn: 'WAITING',
+        const result = await workspaceQueryService.findWorkspaceIdsInKanbanColumn('proj-1', KanbanColumn.WAITING);
+        expect(result).toEqual([]);
+        expect(mockFindByProjectIdWithSessions).toHaveBeenCalledWith('proj-1', {
+            excludeStatuses: [WorkspaceStatus.ARCHIVING, WorkspaceStatus.ARCHIVED],
+        });
+    });
+    it('treats an alive-but-idle session as working, matching the snapshot store', async () => {
+        mockFindByProjectIdWithSessions.mockResolvedValue([
+            {
+                id: 'w-alive',
+                status: WorkspaceStatus.READY,
+                prUrl: null,
+                prState: PRState.NONE,
+                prCiStatus: CIStatus.UNKNOWN,
+                ratchetState: RatchetState.IDLE,
+                runScriptStatus: RunScriptStatus.IDLE,
+                hasHadSessions: true,
+                createdAt: new Date('2026-01-01T00:00:00.000Z'),
+                agentSessions: [
+                    { id: 's-alive', name: null, workflow: null, model: null, status: 'ACTIVE' },
+                ],
+            },
+        ]);
+        mockGetRuntimeSnapshot.mockReturnValue({
+            phase: 'running',
+            processState: 'alive',
+            activity: 'IDLE',
+            updatedAt: '2026-01-01T00:00:00.000Z',
         });
-        expect(result).toHaveLength(0);
+        mockDeriveWorkspaceRuntimeState.mockImplementation((workspace, resolveSessionWorking) => {
+            const isSessionWorking = resolveSessionWorking(['s-alive'], workspace.id);
+            return {
+                sessionIds: ['s-alive'],
+                isSessionWorking,
+                isWorking: isSessionWorking,
+                flowState: {
+                    hasActivePr: false,
+                    isWorking: false,
+                    shouldAnimateRatchetButton: false,
+                    phase: 'NO_PR',
+                    ciObservation: 'CHECKS_UNKNOWN',
+                },
+            };
+        });
+        mockGetAllPendingRequests.mockReturnValue(new Map());
+        const { workspaces: result } = await workspaceQueryService.listForProject('proj-1');
+        expect(result[0]).toMatchObject({ id: 'w-alive', kanbanColumn: 'WORKING', isWorking: true });
+    });
+    it('findWorkspaceIdsInKanbanColumn matches a column only live session state produces', async () => {
+        mockFindByProjectIdWithSessions.mockResolvedValue([
+            {
+                id: 'w-live',
+                status: WorkspaceStatus.READY,
+                prUrl: null,
+                prState: PRState.NONE,
+                prCiStatus: CIStatus.UNKNOWN,
+                ratchetState: RatchetState.IDLE,
+                runScriptStatus: RunScriptStatus.IDLE,
+                hasHadSessions: true,
+                createdAt: new Date('2026-01-01T00:00:00.000Z'),
+            },
+        ]);
+        mockDeriveWorkspaceRuntimeState.mockReturnValue({
+            sessionIds: ['s-1'],
+            isSessionWorking: true,
+            isWorking: true,
+            flowState: {
+                hasActivePr: false,
+                isWorking: false,
+                shouldAnimateRatchetButton: false,
+                phase: 'NO_PR',
+                ciObservation: 'CHECKS_UNKNOWN',
+            },
+        });
+        mockGetAllPendingRequests.mockReturnValue(new Map());
+        const result = await workspaceQueryService.findWorkspaceIdsInKanbanColumn('proj-1', KanbanColumn.WORKING);
+        expect(result).toEqual(['w-live']);
         expect(mockFindByProjectIdWithSessions).toHaveBeenCalledWith('proj-1', {
-            kanbanColumn: 'WAITING',
             excludeStatuses: [WorkspaceStatus.ARCHIVING, WorkspaceStatus.ARCHIVED],
         });
     });
-    it('listWithKanbanState returns FAILED workspaces from the WORKING cache bucket', async () => {
+    it('findWorkspaceIdsInKanbanColumn returns FAILED workspaces for WAITING', async () => {
         mockFindByProjectIdWithSessions.mockResolvedValue([
             {
                 id: 'w1',
@@ -236,7 +304,6 @@ describe('WorkspaceQueryService', () => {
                 ratchetState: RatchetState.IDLE,
                 runScriptStatus: RunScriptStatus.IDLE,
                 hasHadSessions: true,
-                cachedKanbanColumn: 'WORKING',
                 createdAt: new Date('2026-01-01T00:00:00.000Z'),
             },
         ]);
@@ -253,22 +320,13 @@ describe('WorkspaceQueryService', () => {
             },
         });
         mockGetAllPendingRequests.mockReturnValue(new Map());
-        const result = await workspaceQueryService.listWithKanbanState({
-            projectId: 'proj-1',
-            kanbanColumn: 'WORKING',
-        });
-        expect(result).toHaveLength(1);
-        expect(result[0]).toMatchObject({
-            id: 'w1',
-            status: WorkspaceStatus.FAILED,
-            kanbanColumn: 'WORKING',
-        });
+        const result = await workspaceQueryService.findWorkspaceIdsInKanbanColumn('proj-1', KanbanColumn.WAITING);
+        expect(result).toEqual(['w1']);
         expect(mockFindByProjectIdWithSessions).toHaveBeenCalledWith('proj-1', {
-            kanbanColumn: 'WORKING',
             excludeStatuses: [WorkspaceStatus.ARCHIVING, WorkspaceStatus.ARCHIVED],
         });
     });
-    it('surfaces session runtime errors in initial workspace query paths', async () => {
+    it('surfaces session runtime errors in the initial workspace query', async () => {
         const erroredWorkspace = {
             id: 'w1',
             name: 'W1',
@@ -283,8 +341,6 @@ describe('WorkspaceQueryService', () => {
             ratchetState: RatchetState.IDLE,
             runScriptStatus: RunScriptStatus.IDLE,
             hasHadSessions: true,
-            cachedKanbanColumn: 'WAITING',
-            stateComputedAt: null,
             agentSessions: [
                 {
                     id: 's1',
@@ -320,18 +376,13 @@ describe('WorkspaceQueryService', () => {
         });
         mockGetAllPendingRequests.mockReturnValue(new Map());
         mockGithubCheckHealth.mockResolvedValue({ isInstalled: false, isAuthenticated: false });
-        const summary = await workspaceQueryService.getProjectSummaryState('p1');
-        const kanban = await workspaceQueryService.listWithKanbanState({ projectId: 'p1' });
-        expect(summary.workspaces[0]?.statusReason).toMatchObject({
-            code: 'SESSION_ERROR',
-            label: 'Session error',
-        });
-        expect(kanban[0]?.statusReason).toMatchObject({
+        const { workspaces } = await workspaceQueryService.listForProject('p1');
+        expect(workspaces[0]?.statusReason).toMatchObject({
             code: 'SESSION_ERROR',
             label: 'Session error',
         });
     });
-    it('getProjectSummaryState computes git stats and caches review count', async () => {
+    it('listForProject computes git stats and caches review count', async () => {
         mockProjectFindById.mockResolvedValue({ id: 'p1', defaultBranch: 'main' });
         mockFindByProjectIdWithSessions.mockResolvedValue([
             {
@@ -348,8 +399,6 @@ describe('WorkspaceQueryService', () => {
                 ratchetState: 'IDLE',
                 runScriptStatus: 'IDLE',
                 hasHadSessions: true,
-                cachedKanbanColumn: 'WAITING',
-                stateComputedAt: null,
                 agentSessions: [{ updatedAt: new Date('2026-01-03T00:00:00.000Z') }],
                 terminalSessions: [],
             },
@@ -366,8 +415,6 @@ describe('WorkspaceQueryService', () => {
                 ratchetEnabled: true,
                 ratchetState: 'REVIEW_PENDING',
                 runScriptStatus: 'RUNNING',
-                cachedKanbanColumn: 'WORKING',
-                stateComputedAt: new Date('2026-01-02T10:00:00.000Z'),
                 agentSessions: [],
                 terminalSessions: [{ updatedAt: new Date('2026-01-04T00:00:00.000Z') }],
             },
@@ -396,17 +443,24 @@ describe('WorkspaceQueryService', () => {
             { reviewDecision: 'APPROVED' },
             { reviewDecision: 'CHANGES_REQUESTED' },
         ]);
-        const first = await workspaceQueryService.getProjectSummaryState('p1');
+        const first = await workspaceQueryService.listForProject('p1');
         expect(first.reviewCount).toBe(0);
-        expect(first.workspaces).toHaveLength(2);
-        expect(first.workspaces[0]).toMatchObject({
+        expect(first.workspaces.map((workspace) => workspace.id)).toEqual(['w2', 'w1']);
+        expect(first.workspaces[1]).toMatchObject({
             id: 'w1',
             isWorking: false,
             gitStats: expect.objectContaining({ total: 3 }),
+            lastActivityAt: '2026-01-03T00:00:00.000Z',
+        });
+        expect(first.workspaces[0]).toMatchObject({
+            id: 'w2',
+            gitStats: null,
+            lastActivityAt: '2026-01-04T00:00:00.000Z',
         });
+        expect(mockGetWorkspaceGitStats).toHaveBeenCalledWith('/tmp/w1', 'main');
         await new Promise((resolve) => setImmediate(resolve));
         mockGithubListReviewRequests.mockClear();
-        const second = await workspaceQueryService.getProjectSummaryState('p1');
+        const second = await workspaceQueryService.listForProject('p1');
         expect(second.reviewCount).toBe(1);
         expect(mockGithubListReviewRequests).not.toHaveBeenCalled();
     });
@@ -428,7 +482,6 @@ describe('WorkspaceQueryService', () => {
             ratchetState: RatchetState.REVIEW_PENDING,
             runScriptStatus: RunScriptStatus.IDLE,
             hasHadSessions: true,
-            stateComputedAt: null,
             githubIssueNumber: null,
             linearIssueId: null,
             agentSessions: [{ updatedAt: new Date('2026-01-01T00:20:00.000Z') }],
@@ -452,9 +505,8 @@ describe('WorkspaceQueryService', () => {
             isWorking: false,
             flowState,
         });
-        const summary = await workspaceQueryService.getProjectSummaryState('p1');
-        const kanban = await workspaceQueryService.listWithKanbanState({ projectId: 'p1' });
-        const summaryWorkspace = summary.workspaces[0];
+        const listed = await workspaceQueryService.listForProject('p1');
+        const listedWorkspace = listed.workspaces[0];
         const snapshotStore = new WorkspaceSnapshotStore();
         snapshotStore.configure({
             deriveFlowState: (input) => deriveWorkspaceFlowState({
@@ -483,60 +535,12 @@ describe('WorkspaceQueryService', () => {
         }, 'test:equivalence', Date.now());
         const snapshotEntry = snapshotStore.getByWorkspaceId(workspace.id);
         expect(snapshotEntry).toBeDefined();
-        expect(summaryWorkspace).toBeDefined();
-        expect(kanban[0]).toBeDefined();
-        expect(summaryWorkspace?.flowPhase).toBe(snapshotEntry?.flowPhase);
-        expect(summaryWorkspace?.ciObservation).toBe(snapshotEntry?.ciObservation);
-        expect(summaryWorkspace?.sidebarStatus).toEqual(snapshotEntry?.sidebarStatus);
-        expect(summaryWorkspace?.cachedKanbanColumn).toBe(snapshotEntry?.kanbanColumn);
-        expect(summaryWorkspace?.statusReason).toEqual(snapshotEntry?.statusReason);
-        expect(kanban[0]?.flowPhase).toBe(snapshotEntry?.flowPhase);
-        expect(kanban[0]?.ciObservation).toBe(snapshotEntry?.ciObservation);
-        expect(kanban[0]?.kanbanColumn).toBe(snapshotEntry?.kanbanColumn);
-        expect(kanban[0]?.statusReason).toEqual(snapshotEntry?.statusReason);
-    });
-    it('refreshFactoryConfigs updates script commands and reports per-workspace errors', async () => {
-        mockFindByProjectId.mockResolvedValue([
-            { id: 'w1', worktreePath: '/tmp/w1' },
-            { id: 'w2', worktreePath: '/tmp/w2' },
-            { id: 'w3', worktreePath: null },
-        ]);
-        mockSyncWorkspaceCommandsFromWorktreeConfig
-            .mockResolvedValueOnce({
-            runScriptCommand: 'pnpm dev',
-            runScriptPostRunCommand: null,
-            runScriptCleanupCommand: 'pkill node',
-        })
-            .mockRejectedValueOnce(new Error('bad config'));
-        const result = await workspaceQueryService.refreshFactoryConfigs('p1');
-        expect(result).toEqual({
-            updatedCount: 1,
-            totalWorkspaces: 3,
-            errors: [{ workspaceId: 'w2', error: 'bad config' }],
-        });
-        expect(mockSyncWorkspaceCommandsFromWorktreeConfig).toHaveBeenCalledWith({
-            workspaceId: 'w1',
-            worktreePath: '/tmp/w1',
-            persistWorkspaceCommands: expect.any(Function),
-        });
-        expect(mockSyncWorkspaceCommandsFromWorktreeConfig).toHaveBeenCalledWith({
-            workspaceId: 'w2',
-            worktreePath: '/tmp/w2',
-            persistWorkspaceCommands: expect.any(Function),
-        });
-        expect(mockSyncWorkspaceCommandsFromWorktreeConfig).toHaveBeenCalledTimes(2);
-    });
-    it('getFactoryConfig validates project and handles read errors', async () => {
-        mockProjectFindById.mockResolvedValueOnce(null);
-        await expect(workspaceQueryService.getFactoryConfig('missing')).rejects.toThrow('Project not found');
-        mockProjectFindById.mockResolvedValueOnce({ id: 'p1', repoPath: '/repo' });
-        mockReadConfig.mockResolvedValueOnce({ scripts: { run: 'pnpm dev' } });
-        await expect(workspaceQueryService.getFactoryConfig('p1')).resolves.toEqual({
-            scripts: { run: 'pnpm dev' },
-        });
-        mockProjectFindById.mockResolvedValueOnce({ id: 'p1', repoPath: '/repo' });
-        mockReadConfig.mockRejectedValueOnce(new Error('boom'));
-        await expect(workspaceQueryService.getFactoryConfig('p1')).resolves.toBeNull();
+        expect(listedWorkspace).toBeDefined();
+        expect(listedWorkspace?.flowPhase).toBe(snapshotEntry?.flowPhase);
+        expect(listedWorkspace?.ciObservation).toBe(snapshotEntry?.ciObservation);
+        expect(listedWorkspace?.sidebarStatus).toEqual(snapshotEntry?.sidebarStatus);
+        expect(listedWorkspace?.kanbanColumn).toBe(snapshotEntry?.kanbanColumn);
+        expect(listedWorkspace?.statusReason).toEqual(snapshotEntry?.statusReason);
     });
     it('syncPRStatus and syncAllPRStatuses handle success and failure paths', async () => {
         mockFindById.mockResolvedValueOnce(null);
@@ -579,6 +583,25 @@ describe('WorkspaceQueryService', () => {
             queued: 2,
         });
     });
+    it('syncPRStatus resets discovery backoff before returning no_pr_url', async () => {
+        mockFindById.mockResolvedValue({ id: 'w1', prUrl: null });
+        mockResetPRDiscoveryBackoff.mockResolvedValue(true);
+        await expect(workspaceQueryService.syncPRStatus('w1')).resolves.toEqual({
+            success: false,
+            reason: 'no_pr_url',
+        });
+        expect(mockResetPRDiscoveryBackoff).toHaveBeenCalledOnce();
+        expect(mockResetPRDiscoveryBackoff).toHaveBeenCalledWith('w1');
+        expect(mockRefreshWorkspace).not.toHaveBeenCalled();
+    });
+    it('syncAllPRStatuses does not reset discovery backoff for workspaces without PRs', async () => {
+        mockFindByProjectIdWithSessions.mockResolvedValue([
+            { id: 'w1', prUrl: null },
+            { id: 'w2', prUrl: null },
+        ]);
+        await expect(workspaceQueryService.syncAllPRStatuses('p1')).resolves.toEqual({ queued: 0 });
+        expect(mockResetPRDiscoveryBackoff).not.toHaveBeenCalled();
+    });
     it('skips concurrent syncAllPRStatuses calls while the workspace lookup is pending', async () => {
         let resolveLookup;
         const lookupPromise = new Promise((resolve) => {
@@ -596,9 +619,41 @@ describe('WorkspaceQueryService', () => {
             expect(mockRefreshWorkspace).toHaveBeenCalledTimes(1);
         });
     });
+    it('runs syncAllPRStatuses independently for different projects', async () => {
+        let resolveFirstRefresh;
+        const firstRefresh = new Promise((resolve) => {
+            resolveFirstRefresh = resolve;
+        });
+        mockFindByProjectIdWithSessions.mockImplementation(async (projectId) => [
+            {
+                id: projectId === 'p1' ? 'w1' : 'w2',
+                prUrl: `https://github.com/o/r/pull/${projectId === 'p1' ? '1' : '2'}`,
+            },
+        ]);
+        mockRefreshWorkspace.mockImplementation((workspaceId) => workspaceId === 'w1' ? firstRefresh : Promise.resolve({ success: true }));
+        try {
+            await expect(workspaceQueryService.syncAllPRStatuses('p1')).resolves.toEqual({ queued: 1 });
+            await vi.waitFor(() => {
+                expect(mockRefreshWorkspace).toHaveBeenCalledWith('w1', 'https://github.com/o/r/pull/1');
+            });
+            await expect(workspaceQueryService.syncAllPRStatuses('p2')).resolves.toEqual({ queued: 1 });
+            expect(mockFindByProjectIdWithSessions).toHaveBeenCalledWith('p2', {
+                excludeStatuses: [WorkspaceStatus.ARCHIVING, WorkspaceStatus.ARCHIVED],
+            });
+            await vi.waitFor(() => {
+                expect(mockRefreshWorkspace).toHaveBeenCalledWith('w2', 'https://github.com/o/r/pull/2');
+            });
+        }
+        finally {
+            resolveFirstRefresh?.({ success: true });
+            await firstRefresh;
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+    });
     it('hasChanges checks workspace metadata and git stats safely', async () => {
         mockFindByIdWithProject.mockResolvedValueOnce(null);
         await expect(workspaceQueryService.hasChanges('w1')).resolves.toBe(false);
+        expect(mockGetWorkspaceGitStats).not.toHaveBeenCalled();
         mockFindByIdWithProject.mockResolvedValueOnce({
             id: 'w1',
             worktreePath: '/tmp/w1',
@@ -611,6 +666,7 @@ describe('WorkspaceQueryService', () => {
             hasUncommitted: false,
         });
         await expect(workspaceQueryService.hasChanges('w1')).resolves.toBe(false);
+        expect(mockGetWorkspaceGitStats).toHaveBeenLastCalledWith('/tmp/w1', 'main');
         mockFindByIdWithProject.mockResolvedValueOnce({
             id: 'w1',
             worktreePath: '/tmp/w1',
@@ -623,6 +679,7 @@ describe('WorkspaceQueryService', () => {
             hasUncommitted: false,
         });
         await expect(workspaceQueryService.hasChanges('w1')).resolves.toBe(true);
+        expect(mockGetWorkspaceGitStats).toHaveBeenLastCalledWith('/tmp/w1', 'main');
         mockFindByIdWithProject.mockResolvedValueOnce({
             id: 'w1',
             worktreePath: '/tmp/w1',
@@ -636,8 +693,8 @@ describe('WorkspaceQueryService', () => {
         mockProjectFindById.mockResolvedValue({ id: 'p1', defaultBranch: 'main' });
         mockGetAllPendingRequests.mockReturnValue(new Map());
         mockGithubCheckHealth.mockResolvedValue({ isInstalled: false, isAuthenticated: false });
-        await workspaceQueryService.getProjectSummaryState('p1');
-        await workspaceQueryService.listWithKanbanState({ projectId: 'p1' });
+        await workspaceQueryService.listForProject('p1');
+        await workspaceQueryService.findWorkspaceIdsInKanbanColumn('p1', KanbanColumn.WORKING);
         await workspaceQueryService.syncAllPRStatuses('p1');
         expect(mockFindByProjectIdWithSessions).toHaveBeenNthCalledWith(1, 'p1', {
             excludeStatuses: [WorkspaceStatus.ARCHIVING, WorkspaceStatus.ARCHIVED],