github-issue-tower-defence-management 1.174.2 → 1.175.0

package/src/domain/usecases/RevertNotReadyReviewQueueIssueUseCase.test.ts

@@ -24,12 +24,6 @@ const createMockProject = (overrides: Partial<Project> = {}): Project => ({
         color: 'BLUE',
         description: '',
       },
-      {
-        id: 'unread-id',
-        name: 'Unread',
-        color: 'ORANGE',
-        description: '',
-      },
     ],
   },
   nextActionDate: null,
@@ -90,7 +84,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
 const createMockPullRequest = (overrides: Partial<Issue> = {}): Issue =>
   createMockIssue({
     title: 'Test PR',
-    status: 'Unread',
+    status: 'Awaiting Workspace',
     url: 'https://github.com/user/repo/pull/1',
     isPr: true,
     ...overrides,
@@ -1142,39 +1136,43 @@ describe('RevertNotReadyReviewQueueIssueUseCase', () => {
     });
   });
 
-  describe('Unread pull request processing', () => {
-    it('should do nothing when there are no Unread pull requests', async () => {
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [
-          createMockPullRequest({ status: 'Awaiting Workspace' }),
-          createMockPullRequest({ status: 'Preparation' }),
-        ],
-        cacheUsed: false,
-      });
+  describe('archived project item containment', () => {
+    let warnSpy: jest.SpyInstance;
 
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
+    beforeEach(() => {
+      warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    });
 
-      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-      expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+    afterEach(() => {
+      warnSpy.mockRestore();
     });
 
-    it('should skip Unread issue that is not a pull request', async () => {
-      const issue = createMockIssue({
-        status: 'Unread',
-        isPr: false,
+    it('should skip an archived issue on updateStatus failure and continue with remaining issues', async () => {
+      const archivedIssue = createMockIssue({
+        number: 1,
         url: 'https://github.com/user/repo/issues/1',
+        itemId: 'archived-item',
+        status: 'Awaiting Quality Check',
+      });
+      const normalIssue = createMockIssue({
+        number: 2,
+        url: 'https://github.com/user/repo/issues/2',
+        itemId: 'normal-item',
+        status: 'Awaiting Quality Check',
       });
       mockIssueRepository.getAllIssues.mockResolvedValue({
         project: mockProject,
-        issues: [issue],
+        issues: [archivedIssue, normalIssue],
         cacheUsed: false,
       });
+      mockIssueRepository.updateStatus.mockImplementation(
+        (_project: Project, issue: Issue) =>
+          issue.url === archivedIssue.url
+            ? Promise.reject(
+                new Error('The item is archived and cannot be updated'),
+              )
+            : Promise.resolve(undefined),
+      );
 
       await useCase.run({
         manager: 'manager-user',
@@ -1182,49 +1180,86 @@ describe('RevertNotReadyReviewQueueIssueUseCase', () => {
         allowedIssueAuthors: ['owner'],
       });
 
-      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-      expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        archivedIssue,
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        normalIssue,
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalledWith(
+        archivedIssue,
+        expect.anything(),
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        normalIssue,
+        expect.stringContaining('Auto Status Check: REJECTED'),
+      );
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining(archivedIssue.url),
+      );
     });
 
-    it('should skip Unread pull request with non-developer agent field', async () => {
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
-        labels: [],
-        agent: 'chore',
+    it('should propagate a non-archived updateStatus error for issues unchanged', async () => {
+      const issue = createMockIssue({
+        status: 'Awaiting Quality Check',
       });
       mockIssueRepository.getAllIssues.mockResolvedValue({
         project: mockProject,
-        issues: [pullRequest],
+        issues: [issue],
         cacheUsed: false,
       });
+      mockIssueRepository.updateStatus.mockRejectedValue(
+        new Error('Something went wrong'),
+      );
 
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
+      await expect(
+        useCase.run({
+          manager: 'manager-user',
+          projectUrl: 'https://github.com/users/user/projects/1',
+          allowedIssueAuthors: ['owner'],
+        }),
+      ).rejects.toThrow('Something went wrong');
 
-      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-      expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
       expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
     });
 
-    it('should revert Unread pull request with developer agent field when it is in draft state', async () => {
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
-        labels: ['llm-agent:developer'],
-        agent: 'developer',
+    it('should skip an archived Awaiting Quality Check pull request on updateStatus failure and continue with remaining pull requests', async () => {
+      const archivedPullRequest = createMockPullRequest({
+        number: 1,
+        url: 'https://github.com/user/repo/pull/1',
+        itemId: 'archived-pr-item',
+        status: 'Awaiting Quality Check',
+      });
+      const normalPullRequest = createMockPullRequest({
+        number: 2,
+        url: 'https://github.com/user/repo/pull/2',
+        itemId: 'normal-pr-item',
+        status: 'Awaiting Quality Check',
       });
       mockIssueRepository.getAllIssues.mockResolvedValue({
         project: mockProject,
-        issues: [pullRequest],
+        issues: [archivedPullRequest, normalPullRequest],
         cacheUsed: false,
       });
-      mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-        ...createReadyPr(),
-        isDraft: true,
-      });
+      mockIssueRepository.getOpenPullRequest.mockImplementation(
+        (prUrl: string) =>
+          Promise.resolve({
+            ...createReadyPr(prUrl),
+            isConflicted: true,
+          }),
+      );
+      mockIssueRepository.updateStatus.mockImplementation(
+        (_project: Project, issue: Issue) =>
+          issue.url === archivedPullRequest.url
+            ? Promise.reject(
+                new Error('The item is archived and cannot be updated'),
+              )
+            : Promise.resolve(undefined),
+      );
 
       await useCase.run({
         manager: 'manager-user',
@@ -1234,50 +1269,105 @@ describe('RevertNotReadyReviewQueueIssueUseCase', () => {
 
       expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
         mockProject,
-        pullRequest,
+        archivedPullRequest,
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueRepository.updateStory).not.toHaveBeenCalledWith(
+        expect.anything(),
+        archivedPullRequest,
+        expect.anything(),
+      );
+      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalledWith(
+        archivedPullRequest,
+        expect.anything(),
+      );
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        normalPullRequest,
         'awaiting-workspace-id',
       );
       expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        pullRequest,
-        expect.stringContaining('PULL_REQUEST_IS_DRAFT'),
+        normalPullRequest,
+        expect.stringContaining('Auto Status Check: REJECTED'),
+      );
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining(archivedPullRequest.url),
       );
     });
 
-    it('should not move Unread pull request when it is review-ready', async () => {
+    it('should propagate a non-archived updateStatus error for Awaiting Quality Check pull requests unchanged', async () => {
       const pullRequest = createMockPullRequest({
-        status: 'Unread',
+        status: 'Awaiting Quality Check',
       });
       mockIssueRepository.getAllIssues.mockResolvedValue({
         project: mockProject,
         issues: [pullRequest],
         cacheUsed: false,
       });
-      mockIssueRepository.getOpenPullRequest.mockResolvedValue(createReadyPr());
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
+      mockIssueRepository.getOpenPullRequest.mockResolvedValue({
+        ...createReadyPr(),
+        isConflicted: true,
       });
+      mockIssueRepository.updateStatus.mockRejectedValue(
+        new Error('Something went wrong'),
+      );
+
+      await expect(
+        useCase.run({
+          manager: 'manager-user',
+          projectUrl: 'https://github.com/users/user/projects/1',
+          allowedIssueAuthors: ['owner'],
+        }),
+      ).rejects.toThrow('Something went wrong');
 
-      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
       expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
       expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
     });
+  });
 
-    it('should move Unread pull request to Awaiting Workspace and set Story to workflow management when PR is conflicted', async () => {
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
+  describe('ky TimeoutError containment', () => {
+    let warnSpy: jest.SpyInstance;
+
+    const createKyTimeoutError = (): Error => {
+      const error = new Error(
+        'Request timed out: POST https://api.github.com/graphql',
+      );
+      error.name = 'TimeoutError';
+      return error;
+    };
+
+    beforeEach(() => {
+      warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+      warnSpy.mockRestore();
+    });
+
+    it('should skip an issue whose updateStatus times out and continue with remaining issues', async () => {
+      const timedOutIssue = createMockIssue({
+        number: 1,
+        url: 'https://github.com/user/repo/issues/1',
+        itemId: 'timed-out-item',
+        status: 'Awaiting Quality Check',
+      });
+      const normalIssue = createMockIssue({
+        number: 2,
+        url: 'https://github.com/user/repo/issues/2',
+        itemId: 'normal-item',
+        status: 'Awaiting Quality Check',
       });
       mockIssueRepository.getAllIssues.mockResolvedValue({
         project: mockProject,
-        issues: [pullRequest],
+        issues: [timedOutIssue, normalIssue],
         cacheUsed: false,
       });
-      mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-        ...createReadyPr(),
-        isConflicted: true,
-      });
+      mockIssueRepository.updateStatus.mockImplementation(
+        (_project: Project, issue: Issue) =>
+          issue.url === timedOutIssue.url
+            ? Promise.reject(createKyTimeoutError())
+            : Promise.resolve(undefined),
+      );
 
       await useCase.run({
         manager: 'manager-user',
@@ -1287,762 +1377,43 @@ describe('RevertNotReadyReviewQueueIssueUseCase', () => {
 
       expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
         mockProject,
-        pullRequest,
+        timedOutIssue,
         'awaiting-workspace-id',
       );
-      expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'project-1' }),
-        pullRequest,
-        'workflow-management-story-id',
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        normalIssue,
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalledWith(
+        timedOutIssue,
+        expect.anything(),
       );
       expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        pullRequest,
+        normalIssue,
         expect.stringContaining('Auto Status Check: REJECTED'),
       );
-      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        pullRequest,
-        expect.stringContaining('PULL_REQUEST_CONFLICTED'),
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining(timedOutIssue.url),
       );
     });
 
-    it('should move Unread pull request when CI is failing', async () => {
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
+    it('should skip an issue whose createComment times out and continue with remaining issues', async () => {
+      const timedOutIssue = createMockIssue({
+        number: 1,
+        url: 'https://github.com/user/repo/issues/1',
+        itemId: 'timed-out-item',
+        status: 'Awaiting Quality Check',
+      });
+      const normalIssue = createMockIssue({
+        number: 2,
+        url: 'https://github.com/user/repo/issues/2',
+        itemId: 'normal-item',
+        status: 'Awaiting Quality Check',
       });
       mockIssueRepository.getAllIssues.mockResolvedValue({
         project: mockProject,
-        issues: [pullRequest],
-        cacheUsed: false,
-      });
-      mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-        ...createReadyPr(),
-        isPassedAllCiJob: false,
-        isCiStateSuccess: false,
-      });
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        pullRequest,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'project-1' }),
-        pullRequest,
-        'workflow-management-story-id',
-      );
-      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        pullRequest,
-        expect.stringContaining('ANY_CI_JOB_FAILED_OR_IN_PROGRESS'),
-      );
-    });
-
-    it('should move Unread pull request when it is in draft state', async () => {
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [pullRequest],
-        cacheUsed: false,
-      });
-      mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-        ...createReadyPr(),
-        isDraft: true,
-      });
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        pullRequest,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'project-1' }),
-        pullRequest,
-        'workflow-management-story-id',
-      );
-      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        pullRequest,
-        expect.stringContaining('PULL_REQUEST_IS_DRAFT'),
-      );
-    });
-
-    it('should move Unread pull request when CI is SUCCESS but required check never started', async () => {
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [pullRequest],
-        cacheUsed: false,
-      });
-      mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-        ...createReadyPr(),
-        isPassedAllCiJob: false,
-        isCiStateSuccess: true,
-        missingRequiredCheckNames: ['E2E Tests'],
-      });
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        pullRequest,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'project-1' }),
-        pullRequest,
-        'workflow-management-story-id',
-      );
-      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        pullRequest,
-        expect.stringContaining('REQUIRED_CI_JOB_NEVER_STARTED'),
-      );
-    });
-
-    it('should move Unread pull request when review comments are not resolved', async () => {
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [pullRequest],
-        cacheUsed: false,
-      });
-      mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-        ...createReadyPr(),
-        isResolvedAllReviewComments: false,
-      });
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        pullRequest,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'project-1' }),
-        pullRequest,
-        'workflow-management-story-id',
-      );
-      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        pullRequest,
-        expect.stringContaining('ANY_REVIEW_COMMENT_NOT_RESOLVED'),
-      );
-    });
-
-    it('should move Unread pull request when no open PR is found at the PR URL', async () => {
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [pullRequest],
-        cacheUsed: false,
-      });
-      mockIssueRepository.getOpenPullRequest.mockResolvedValue(null);
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        pullRequest,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'project-1' }),
-        pullRequest,
-        'workflow-management-story-id',
-      );
-      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        pullRequest,
-        expect.stringContaining('PULL_REQUEST_NOT_FOUND'),
-      );
-    });
-
-    it('should skip updateStory when project has no story field configured', async () => {
-      const projectWithoutStory = createMockProject({ story: null });
-      mockProjectRepository.getProject.mockResolvedValue(projectWithoutStory);
-
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [pullRequest],
-        cacheUsed: false,
-      });
-      mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-        ...createReadyPr(),
-        isConflicted: true,
-      });
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        projectWithoutStory,
-        pullRequest,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        pullRequest,
-        expect.stringContaining('Auto Status Check: REJECTED'),
-      );
-    });
-
-    it('should return early when Awaiting Workspace status option does not exist', async () => {
-      const projectWithoutAwaitingWorkspace = createMockProject({
-        status: {
-          name: 'Status',
-          fieldId: 'field-1',
-          statuses: [
-            {
-              id: 'unread-id',
-              name: 'Unread',
-              color: 'ORANGE',
-              description: '',
-            },
-          ],
-        },
-      });
-      mockProjectRepository.getProject.mockResolvedValue(
-        projectWithoutAwaitingWorkspace,
-      );
-
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [pullRequest],
-        cacheUsed: false,
-      });
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-      expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
-    });
-
-    describe('author authorization guard', () => {
-      it('should skip an Unread pull request authored by a non-owner human not in allowedIssueAuthors', async () => {
-        const pullRequest = createMockPullRequest({
-          status: 'Unread',
-          author: 'outside-contributor',
-        });
-        mockIssueRepository.getAllIssues.mockResolvedValue({
-          project: mockProject,
-          issues: [pullRequest],
-          cacheUsed: false,
-        });
-        mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-          ...createReadyPr(),
-          isConflicted: true,
-        });
-
-        await useCase.run({
-          manager: 'manager-user',
-          projectUrl: 'https://github.com/users/user/projects/1',
-          allowedIssueAuthors: ['owner'],
-        });
-
-        expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-        expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-        expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
-      });
-
-      it('should act on an Unread pull request authored by an allowed owner', async () => {
-        const pullRequest = createMockPullRequest({
-          status: 'Unread',
-          author: 'owner',
-        });
-        mockIssueRepository.getAllIssues.mockResolvedValue({
-          project: mockProject,
-          issues: [pullRequest],
-          cacheUsed: false,
-        });
-        mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-          ...createReadyPr(),
-          isConflicted: true,
-        });
-
-        await useCase.run({
-          manager: 'manager-user',
-          projectUrl: 'https://github.com/users/user/projects/1',
-          allowedIssueAuthors: ['owner'],
-        });
-
-        expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-          mockProject,
-          pullRequest,
-          'awaiting-workspace-id',
-        );
-        expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
-          expect.objectContaining({ id: 'project-1' }),
-          pullRequest,
-          'workflow-management-story-id',
-        );
-        expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-          pullRequest,
-          expect.stringContaining('Auto Status Check: REJECTED'),
-        );
-      });
-
-      it('should skip an Unread pull request authored by a dependency-update bot not in allowedIssueAuthors', async () => {
-        const pullRequest = createMockPullRequest({
-          status: 'Unread',
-          author: 'dependabot[bot]',
-        });
-        mockIssueRepository.getAllIssues.mockResolvedValue({
-          project: mockProject,
-          issues: [pullRequest],
-          cacheUsed: false,
-        });
-        mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-          ...createReadyPr(),
-          isConflicted: true,
-        });
-
-        await useCase.run({
-          manager: 'manager-user',
-          projectUrl: 'https://github.com/users/user/projects/1',
-          allowedIssueAuthors: ['owner'],
-        });
-
-        expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-        expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-        expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
-      });
-
-      it('should act on a dependency-update bot only when it is explicitly listed in allowedIssueAuthors', async () => {
-        const pullRequest = createMockPullRequest({
-          status: 'Unread',
-          author: 'dependabot[bot]',
-        });
-        mockIssueRepository.getAllIssues.mockResolvedValue({
-          project: mockProject,
-          issues: [pullRequest],
-          cacheUsed: false,
-        });
-        mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-          ...createReadyPr(),
-          isConflicted: true,
-        });
-
-        await useCase.run({
-          manager: 'manager-user',
-          projectUrl: 'https://github.com/users/user/projects/1',
-          allowedIssueAuthors: ['owner', 'dependabot[bot]'],
-        });
-
-        expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-          mockProject,
-          pullRequest,
-          'awaiting-workspace-id',
-        );
-        expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-          pullRequest,
-          expect.stringContaining('Auto Status Check: REJECTED'),
-        );
-      });
-
-      it('should process no author when allowedIssueAuthors is null', async () => {
-        const pullRequest = createMockPullRequest({
-          status: 'Unread',
-          author: 'outside-contributor',
-        });
-        mockIssueRepository.getAllIssues.mockResolvedValue({
-          project: mockProject,
-          issues: [pullRequest],
-          cacheUsed: false,
-        });
-        mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-          ...createReadyPr(),
-          isConflicted: true,
-        });
-
-        await useCase.run({
-          manager: 'manager-user',
-          projectUrl: 'https://github.com/users/user/projects/1',
-          allowedIssueAuthors: null,
-        });
-
-        expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-        expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-        expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
-      });
-
-      it('should process no author when allowedIssueAuthors is undefined', async () => {
-        const pullRequest = createMockPullRequest({
-          status: 'Unread',
-          author: 'owner',
-        });
-        mockIssueRepository.getAllIssues.mockResolvedValue({
-          project: mockProject,
-          issues: [pullRequest],
-          cacheUsed: false,
-        });
-        mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-          ...createReadyPr(),
-          isConflicted: true,
-        });
-
-        await useCase.run({
-          manager: 'manager-user',
-          projectUrl: 'https://github.com/users/user/projects/1',
-        });
-
-        expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-        expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-        expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
-      });
-
-      it('should process no author when allowedIssueAuthors is an empty list', async () => {
-        const pullRequest = createMockPullRequest({
-          status: 'Unread',
-          author: 'owner',
-        });
-        mockIssueRepository.getAllIssues.mockResolvedValue({
-          project: mockProject,
-          issues: [pullRequest],
-          cacheUsed: false,
-        });
-        mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-          ...createReadyPr(),
-          isConflicted: true,
-        });
-
-        await useCase.run({
-          manager: 'manager-user',
-          projectUrl: 'https://github.com/users/user/projects/1',
-          allowedIssueAuthors: [],
-        });
-
-        expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-        expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-        expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
-      });
-    });
-  });
-
-  describe('archived project item containment', () => {
-    let warnSpy: jest.SpyInstance;
-
-    beforeEach(() => {
-      warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-    });
-
-    afterEach(() => {
-      warnSpy.mockRestore();
-    });
-
-    it('should skip an archived issue on updateStatus failure and continue with remaining issues', async () => {
-      const archivedIssue = createMockIssue({
-        number: 1,
-        url: 'https://github.com/user/repo/issues/1',
-        itemId: 'archived-item',
-        status: 'Awaiting Quality Check',
-      });
-      const normalIssue = createMockIssue({
-        number: 2,
-        url: 'https://github.com/user/repo/issues/2',
-        itemId: 'normal-item',
-        status: 'Awaiting Quality Check',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [archivedIssue, normalIssue],
-        cacheUsed: false,
-      });
-      mockIssueRepository.updateStatus.mockImplementation(
-        (_project: Project, issue: Issue) =>
-          issue.url === archivedIssue.url
-            ? Promise.reject(
-                new Error('The item is archived and cannot be updated'),
-              )
-            : Promise.resolve(undefined),
-      );
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        archivedIssue,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        normalIssue,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalledWith(
-        archivedIssue,
-        expect.anything(),
-      );
-      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        normalIssue,
-        expect.stringContaining('Auto Status Check: REJECTED'),
-      );
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining(archivedIssue.url),
-      );
-    });
-
-    it('should propagate a non-archived updateStatus error for issues unchanged', async () => {
-      const issue = createMockIssue({
-        status: 'Awaiting Quality Check',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [issue],
-        cacheUsed: false,
-      });
-      mockIssueRepository.updateStatus.mockRejectedValue(
-        new Error('Something went wrong'),
-      );
-
-      await expect(
-        useCase.run({
-          manager: 'manager-user',
-          projectUrl: 'https://github.com/users/user/projects/1',
-          allowedIssueAuthors: ['owner'],
-        }),
-      ).rejects.toThrow('Something went wrong');
-
-      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
-    });
-
-    it('should skip an archived Unread pull request on updateStatus failure and continue with remaining pull requests', async () => {
-      const archivedPullRequest = createMockPullRequest({
-        number: 1,
-        url: 'https://github.com/user/repo/pull/1',
-        itemId: 'archived-pr-item',
-        status: 'Unread',
-      });
-      const normalPullRequest = createMockPullRequest({
-        number: 2,
-        url: 'https://github.com/user/repo/pull/2',
-        itemId: 'normal-pr-item',
-        status: 'Unread',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [archivedPullRequest, normalPullRequest],
-        cacheUsed: false,
-      });
-      mockIssueRepository.getOpenPullRequest.mockImplementation(
-        (prUrl: string) =>
-          Promise.resolve({
-            ...createReadyPr(prUrl),
-            isConflicted: true,
-          }),
-      );
-      mockIssueRepository.updateStatus.mockImplementation(
-        (_project: Project, issue: Issue) =>
-          issue.url === archivedPullRequest.url
-            ? Promise.reject(
-                new Error('The item is archived and cannot be updated'),
-              )
-            : Promise.resolve(undefined),
-      );
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        archivedPullRequest,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueRepository.updateStory).not.toHaveBeenCalledWith(
-        expect.anything(),
-        archivedPullRequest,
-        expect.anything(),
-      );
-      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalledWith(
-        archivedPullRequest,
-        expect.anything(),
-      );
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        normalPullRequest,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'project-1' }),
-        normalPullRequest,
-        'workflow-management-story-id',
-      );
-      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        normalPullRequest,
-        expect.stringContaining('Auto Status Check: REJECTED'),
-      );
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining(archivedPullRequest.url),
-      );
-    });
-
-    it('should propagate a non-archived updateStatus error for Unread pull requests unchanged', async () => {
-      const pullRequest = createMockPullRequest({
-        status: 'Unread',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [pullRequest],
-        cacheUsed: false,
-      });
-      mockIssueRepository.getOpenPullRequest.mockResolvedValue({
-        ...createReadyPr(),
-        isConflicted: true,
-      });
-      mockIssueRepository.updateStatus.mockRejectedValue(
-        new Error('Something went wrong'),
-      );
-
-      await expect(
-        useCase.run({
-          manager: 'manager-user',
-          projectUrl: 'https://github.com/users/user/projects/1',
-          allowedIssueAuthors: ['owner'],
-        }),
-      ).rejects.toThrow('Something went wrong');
-
-      expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
-      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('ky TimeoutError containment', () => {
-    let warnSpy: jest.SpyInstance;
-
-    const createKyTimeoutError = (): Error => {
-      const error = new Error(
-        'Request timed out: POST https://api.github.com/graphql',
-      );
-      error.name = 'TimeoutError';
-      return error;
-    };
-
-    beforeEach(() => {
-      warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-    });
-
-    afterEach(() => {
-      warnSpy.mockRestore();
-    });
-
-    it('should skip an issue whose updateStatus times out and continue with remaining issues', async () => {
-      const timedOutIssue = createMockIssue({
-        number: 1,
-        url: 'https://github.com/user/repo/issues/1',
-        itemId: 'timed-out-item',
-        status: 'Awaiting Quality Check',
-      });
-      const normalIssue = createMockIssue({
-        number: 2,
-        url: 'https://github.com/user/repo/issues/2',
-        itemId: 'normal-item',
-        status: 'Awaiting Quality Check',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [timedOutIssue, normalIssue],
-        cacheUsed: false,
-      });
-      mockIssueRepository.updateStatus.mockImplementation(
-        (_project: Project, issue: Issue) =>
-          issue.url === timedOutIssue.url
-            ? Promise.reject(createKyTimeoutError())
-            : Promise.resolve(undefined),
-      );
-
-      await useCase.run({
-        manager: 'manager-user',
-        projectUrl: 'https://github.com/users/user/projects/1',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        timedOutIssue,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        mockProject,
-        normalIssue,
-        'awaiting-workspace-id',
-      );
-      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalledWith(
-        timedOutIssue,
-        expect.anything(),
-      );
-      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        normalIssue,
-        expect.stringContaining('Auto Status Check: REJECTED'),
-      );
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining(timedOutIssue.url),
-      );
-    });
-
-    it('should skip an issue whose createComment times out and continue with remaining issues', async () => {
-      const timedOutIssue = createMockIssue({
-        number: 1,
-        url: 'https://github.com/user/repo/issues/1',
-        itemId: 'timed-out-item',
-        status: 'Awaiting Quality Check',
-      });
-      const normalIssue = createMockIssue({
-        number: 2,
-        url: 'https://github.com/user/repo/issues/2',
-        itemId: 'normal-item',
-        status: 'Awaiting Quality Check',
-      });
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [timedOutIssue, normalIssue],
+        issues: [timedOutIssue, normalIssue],
         cacheUsed: false,
       });
       mockIssueCommentRepository.createComment.mockImplementation(
@@ -2067,18 +1438,18 @@ describe('RevertNotReadyReviewQueueIssueUseCase', () => {
       );
     });
 
-    it('should skip an Unread pull request whose updateStatus times out and continue with remaining pull requests', async () => {
+    it('should skip an Awaiting Quality Check pull request whose updateStatus times out and continue with remaining pull requests', async () => {
       const timedOutPullRequest = createMockPullRequest({
         number: 1,
         url: 'https://github.com/user/repo/pull/1',
         itemId: 'timed-out-pr-item',
-        status: 'Unread',
+        status: 'Awaiting Quality Check',
       });
       const normalPullRequest = createMockPullRequest({
         number: 2,
         url: 'https://github.com/user/repo/pull/2',
         itemId: 'normal-pr-item',
-        status: 'Unread',
+        status: 'Awaiting Quality Check',
       });
       mockIssueRepository.getAllIssues.mockResolvedValue({
         project: mockProject,
@@ -2124,11 +1495,6 @@ describe('RevertNotReadyReviewQueueIssueUseCase', () => {
         normalPullRequest,
         'awaiting-workspace-id',
       );
-      expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'project-1' }),
-        normalPullRequest,
-        'workflow-management-story-id',
-      );
       expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
         normalPullRequest,
         expect.stringContaining('Auto Status Check: REJECTED'),
@@ -2211,9 +1577,9 @@ describe('RevertNotReadyReviewQueueIssueUseCase', () => {
       );
     });
 
-    it('should not revert a rejected Unread pull request that is not assigned to the manager', async () => {
+    it('should not revert a rejected Awaiting Quality Check pull request that is not assigned to the manager', async () => {
       const pullRequest = createMockPullRequest({
-        status: 'Unread',
+        status: 'Awaiting Quality Check',
         assignees: ['other-user'],
       });
       mockIssueRepository.getAllIssues.mockResolvedValue({
@@ -2237,9 +1603,9 @@ describe('RevertNotReadyReviewQueueIssueUseCase', () => {
       expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
     });
 
-    it('should revert a rejected Unread pull request that is assigned to the manager', async () => {
+    it('should revert a rejected Awaiting Quality Check pull request that is assigned to the manager', async () => {
       const pullRequest = createMockPullRequest({
-        status: 'Unread',
+        status: 'Awaiting Quality Check',
         assignees: ['manager-user'],
       });
       mockIssueRepository.getAllIssues.mockResolvedValue({
@@ -2335,37 +1701,6 @@ describe('RevertNotReadyReviewQueueIssueUseCase', () => {
       expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
     });
 
-    it('includes the unread pull requests in the same batched call', async () => {
-      const unreadPrUrl = 'https://github.com/user/repo/pull/400';
-      const { boardIssues, relatedPrs } = buildAwaitingQualityCheckBoard(1);
-      mockIssueRepository.getAllIssues.mockResolvedValue({
-        project: mockProject,
-        issues: [
-          ...boardIssues,
-          createMockPullRequest({
-            url: unreadPrUrl,
-            number: 400,
-            itemId: 'item-pr-unread',
-          }),
-        ],
-        cacheUsed: false,
-      });
-      resolveBatchFrom([...relatedPrs, createReadyPr(unreadPrUrl)]);
-
-      await useCase.run({
-        projectUrl,
-        manager: 'manager-user',
-        allowedIssueAuthors: ['owner'],
-      });
-
-      expect(mockIssueRepository.getOpenPullRequests).toHaveBeenCalledTimes(1);
-      expect(mockIssueRepository.getOpenPullRequests).toHaveBeenCalledWith([
-        relatedPrs[0].url,
-        unreadPrUrl,
-      ]);
-      expect(mockIssueRepository.getOpenPullRequest).not.toHaveBeenCalled();
-    });
-
     it('falls back to the single pull request query only for a url the batch left unresolved', async () => {
       const { boardIssues, relatedPrs } = buildAwaitingQualityCheckBoard(2);
       const resolvedPr = relatedPrs[0];