github-issue-tower-defence-management 1.77.3 → 1.79.0

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts

@@ -40,7 +40,7 @@ import { ProxyClaudeTokenUsageRepository } from '../../repositories/ProxyClaudeT
 import { ProxyRateLimitCacheRepository } from '../../repositories/ProxyRateLimitCacheRepository';
 import { UpdateRateLimitCacheUseCase } from '../../../domain/usecases/UpdateRateLimitCacheUseCase';
 import { RevertOrphanedPreparationUseCase } from '../../../domain/usecases/RevertOrphanedPreparationUseCase';
-import { RevertNotReadyAwaitingQualityCheckUseCase } from '../../../domain/usecases/RevertNotReadyAwaitingQualityCheckUseCase';
+import { RevertNotReadyReviewQueueIssueUseCase } from '../../../domain/usecases/RevertNotReadyReviewQueueIssueUseCase';
 import { GitHubIssueCommentRepository } from '../../repositories/GitHubIssueCommentRepository';
 import { SetupTowerDefenceProjectUseCase } from '../../../domain/usecases/SetupTowerDefenceProjectUseCase';
 import { DailySecurityScanUseCase } from '../../../domain/usecases/DailySecurityScanUseCase';
@@ -296,8 +296,8 @@ export class HandleScheduledEventUseCaseHandler {
         issueCommentRepository,
         nodeLocalCommandRunner,
       );
-    const revertNotReadyAwaitingQualityCheckUseCase =
-      new RevertNotReadyAwaitingQualityCheckUseCase(
+    const revertNotReadyReviewQueueIssueUseCase =
+      new RevertNotReadyReviewQueueIssueUseCase(
         projectRepository,
         issueRepository,
         issueCommentRepository,
@@ -329,7 +329,7 @@ export class HandleScheduledEventUseCaseHandler {
       updateIssueStatusByLabelUseCase,
       startPreparationUseCase,
       revertOrphanedPreparationUseCase,
-      revertNotReadyAwaitingQualityCheckUseCase,
+      revertNotReadyReviewQueueIssueUseCase,
       updateRateLimitCacheUseCase,
       dailySecurityScanUseCase,
       systemDateRepository,

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

@@ -1,34 +1,8 @@
 import { CheckIssueReviewReadinessUseCase } from './CheckIssueReviewReadinessUseCase';
 import { Issue } from '../entities/Issue';
-import { Project } from '../entities/Project';
+import { Comment } from '../entities/Comment';
 import { RelatedPullRequest } from './adapter-interfaces/IssueRepository';
 
-const createMockProject = (overrides: Partial<Project> = {}): Project => ({
-  id: 'project-1',
-  url: 'https://github.com/users/user/projects/1',
-  databaseId: 1,
-  name: 'Test Project',
-  status: {
-    name: 'Status',
-    fieldId: 'field-1',
-    statuses: [
-      {
-        id: 'preparation-id',
-        name: 'Preparation',
-        color: 'YELLOW',
-        description: '',
-      },
-    ],
-  },
-  nextActionDate: null,
-  nextActionHour: null,
-  story: null,
-  remainingEstimationMinutes: null,
-  dependedIssueUrlSeparatedByComma: null,
-  completionDate50PercentConfidence: null,
-  ...overrides,
-});
-
 const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   nameWithOwner: 'user/repo',
   number: 1,
@@ -56,6 +30,13 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   ...overrides,
 });
 
+const createMockComment = (overrides: Partial<Comment> = {}): Comment => ({
+  author: 'agent-bot',
+  content: 'From: :robot: Agent report',
+  createdAt: new Date('2000-01-01T00:00:00Z'),
+  ...overrides,
+});
+
 const createReadyPr = (
   overrides: Partial<RelatedPullRequest> = {},
 ): RelatedPullRequest => ({
@@ -73,51 +54,151 @@ const createReadyPr = (
 });
 
 describe('CheckIssueReviewReadinessUseCase', () => {
-  let mockProjectRepository: { getByUrl: jest.Mock };
   let mockIssueRepository: {
-    get: jest.Mock;
+    getIssueByUrl: jest.Mock;
     findRelatedOpenPRs: jest.Mock;
     getOpenPullRequest: jest.Mock;
     getPullRequestChangedFilePaths: jest.Mock;
     requestChangesWithInlineComment: jest.Mock;
   };
+  let mockIssueCommentRepository: {
+    getCommentsFromIssue: jest.Mock;
+  };
   let useCase: CheckIssueReviewReadinessUseCase;
-  let mockProject: Project;
 
   beforeEach(() => {
     jest.resetAllMocks();
 
-    mockProject = createMockProject();
-
-    mockProjectRepository = {
-      getByUrl: jest.fn(),
-    };
-
     mockIssueRepository = {
-      get: jest.fn(),
+      getIssueByUrl: jest.fn(),
       findRelatedOpenPRs: jest.fn(),
       getOpenPullRequest: jest.fn(),
       getPullRequestChangedFilePaths: jest.fn().mockResolvedValue([]),
       requestChangesWithInlineComment: jest.fn().mockResolvedValue(undefined),
     };
 
+    mockIssueCommentRepository = {
+      getCommentsFromIssue: jest.fn(),
+    };
+
     useCase = new CheckIssueReviewReadinessUseCase(
-      mockProjectRepository,
       mockIssueRepository,
+      mockIssueCommentRepository,
     );
   });
 
   describe('run', () => {
-    it('should return reviewReady=true with empty rejections when the linked PR is ready', async () => {
+    it('should return reviewReady=false with ISSUE_NOT_FOUND when issue does not exist', async () => {
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(null);
+
+      const result = await useCase.run({
+        issueUrl: 'https://github.com/user/repo/issues/999',
+      });
+
+      expect(result.reviewReady).toBe(false);
+      expect(result.rejections).toEqual([
+        {
+          type: 'ISSUE_NOT_FOUND',
+          detail: 'Issue not found: https://github.com/user/repo/issues/999',
+        },
+      ]);
+    });
+
+    it('should return reviewReady=false with NO_REPORT_FROM_AGENT_BOT when no comments exist', async () => {
       const issue = createMockIssue();
-      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr(),
+      ]);
+
+      const result = await useCase.run({
+        issueUrl: 'https://github.com/user/repo/issues/1',
+      });
+
+      expect(result.reviewReady).toBe(false);
+      expect(result.rejections).toContainEqual({
+        type: 'NO_REPORT_FROM_AGENT_BOT',
+        detail: 'NO_REPORT_FROM_AGENT_BOT',
+      });
+    });
+
+    it('should return reviewReady=false with NO_REPORT_FROM_AGENT_BOT when last comment does not start with From: :robot:', async () => {
+      const issue = createMockIssue();
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'Some regular comment' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr(),
+      ]);
+
+      const result = await useCase.run({
+        issueUrl: 'https://github.com/user/repo/issues/1',
+      });
+
+      expect(result.reviewReady).toBe(false);
+      expect(result.rejections).toContainEqual({
+        type: 'NO_REPORT_FROM_AGENT_BOT',
+        detail: 'NO_REPORT_FROM_AGENT_BOT',
+      });
+    });
+
+    it('should return reviewReady=false with REPORT_HAS_NEXT_STEP when last comment has nextStep in JSON', async () => {
+      const issue = createMockIssue();
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
+      const commentWithNextStep = createMockComment({
+        content:
+          'From: :robot: Agent report\n```json\n{"nextStep": "fix the bug"}\n```',
+      });
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        commentWithNextStep,
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr(),
+      ]);
+
+      const result = await useCase.run({
+        issueUrl: 'https://github.com/user/repo/issues/1',
+      });
+
+      expect(result.reviewReady).toBe(false);
+      expect(result.rejections).toContainEqual({
+        type: 'REPORT_HAS_NEXT_STEP',
+        detail: 'REPORT_HAS_NEXT_STEP',
+      });
+    });
+
+    it('should return reviewReady=false with PULL_REQUEST_NOT_FOUND when no related PR exists', async () => {
+      const issue = createMockIssue();
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment(),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      const result = await useCase.run({
+        issueUrl: 'https://github.com/user/repo/issues/1',
+      });
+
+      expect(result.reviewReady).toBe(false);
+      expect(result.rejections).toContainEqual({
+        type: 'PULL_REQUEST_NOT_FOUND',
+        detail: 'PULL_REQUEST_NOT_FOUND',
+      });
+    });
+
+    it('should return reviewReady=true with empty rejections when all checks pass', async () => {
+      const issue = createMockIssue();
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment(),
+      ]);
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
         createReadyPr(),
       ]);
 
       const result = await useCase.run({
-        projectUrl: 'https://github.com/users/user/projects/1',
         issueUrl: 'https://github.com/user/repo/issues/1',
       });
 
@@ -125,10 +206,12 @@ describe('CheckIssueReviewReadinessUseCase', () => {
       expect(result.rejections).toEqual([]);
     });
 
-    it('should return reviewReady=false with rejections when the linked PR has failing CI', async () => {
+    it('should return reviewReady=false with ANY_CI_JOB_FAILED_OR_IN_PROGRESS when PR CI is failing', async () => {
       const issue = createMockIssue();
-      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment(),
+      ]);
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
         createReadyPr({
           isPassedAllCiJob: false,
@@ -137,62 +220,71 @@ describe('CheckIssueReviewReadinessUseCase', () => {
       ]);
 
       const result = await useCase.run({
-        projectUrl: 'https://github.com/users/user/projects/1',
         issueUrl: 'https://github.com/user/repo/issues/1',
       });
 
       expect(result.reviewReady).toBe(false);
-      expect(result.rejections).toHaveLength(1);
       expect(result.rejections[0].type).toBe(
         'ANY_CI_JOB_FAILED_OR_IN_PROGRESS',
       );
-      expect(result.rejections[0].detail).toContain(
-        'https://github.com/user/repo/pull/1',
-      );
     });
 
-    it('should return reviewReady=false with PULL_REQUEST_NOT_FOUND when no related PR exists', async () => {
+    it('should treat all authors as trusted when allowedIssueAuthors is null', async () => {
       const issue = createMockIssue();
-      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.get.mockResolvedValue(issue);
-      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ author: 'any-unknown-author' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr(),
+      ]);
 
       const result = await useCase.run({
-        projectUrl: 'https://github.com/users/user/projects/1',
         issueUrl: 'https://github.com/user/repo/issues/1',
+        allowedIssueAuthors: null,
       });
 
-      expect(result.reviewReady).toBe(false);
-      expect(result.rejections).toEqual([
-        { type: 'PULL_REQUEST_NOT_FOUND', detail: 'PULL_REQUEST_NOT_FOUND' },
-      ]);
+      expect(result.reviewReady).toBe(true);
+      expect(result.rejections).toEqual([]);
     });
 
-    it('should throw IssueNotFoundError when the issue does not exist', async () => {
-      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.get.mockResolvedValue(null);
+    it('should reject when last comment author is not in allowedIssueAuthors list', async () => {
+      const issue = createMockIssue();
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ author: 'untrusted-author' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr(),
+      ]);
+
+      const result = await useCase.run({
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        allowedIssueAuthors: ['trusted-author'],
+      });
 
-      await expect(
-        useCase.run({
-          projectUrl: 'https://github.com/users/user/projects/1',
-          issueUrl: 'https://github.com/user/repo/issues/999',
-        }),
-      ).rejects.toThrow(
-        'Issue not found: https://github.com/user/repo/issues/999',
-      );
+      expect(result.reviewReady).toBe(false);
+      expect(result.rejections).toContainEqual({
+        type: 'NO_REPORT_FROM_AGENT_BOT',
+        detail: 'NO_REPORT_FROM_AGENT_BOT',
+      });
     });
 
-    it('should not call findRelatedOpenPRs nor mutate state when issue has a category label other than e2e', async () => {
-      const issue = createMockIssue({ labels: ['category:frontend'] });
-      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.get.mockResolvedValue(issue);
+    it('should accept when last comment author is in allowedIssueAuthors list', async () => {
+      const issue = createMockIssue();
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ author: 'trusted-author' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr(),
+      ]);
 
       const result = await useCase.run({
-        projectUrl: 'https://github.com/users/user/projects/1',
         issueUrl: 'https://github.com/user/repo/issues/1',
+        allowedIssueAuthors: ['trusted-author'],
       });
 
-      expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
       expect(result.reviewReady).toBe(true);
       expect(result.rejections).toEqual([]);
     });

package/src/domain/usecases/CheckIssueReviewReadinessUseCase.ts

@@ -1,53 +1,127 @@
 import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { IssueCommentRepository } from './adapter-interfaces/IssueCommentRepository';
 import {
   IssueRejectionEvaluator,
   PrRejectedReasonType,
 } from './IssueRejectionEvaluator';
-import { IssueNotFoundError } from './NotifyFinishedIssuePreparationUseCase';
+
+type RejectedReasonType =
+  | 'ISSUE_NOT_FOUND'
+  | 'NO_REPORT_FROM_AGENT_BOT'
+  | 'REPORT_HAS_NEXT_STEP'
+  | PrRejectedReasonType;
 
 export type IssueReviewReadinessResult = {
   reviewReady: boolean;
-  rejections: { type: PrRejectedReasonType; detail: string }[];
+  rejections: { type: RejectedReasonType; detail: string }[];
 };
 
 export class CheckIssueReviewReadinessUseCase {
   private readonly issueRejectionEvaluator: IssueRejectionEvaluator;
 
   constructor(
-    private readonly projectRepository: Pick<ProjectRepository, 'getByUrl'>,
     private readonly issueRepository: Pick<
       IssueRepository,
-      | 'get'
+      | 'getIssueByUrl'
       | 'findRelatedOpenPRs'
       | 'getOpenPullRequest'
       | 'getPullRequestChangedFilePaths'
       | 'requestChangesWithInlineComment'
     >,
+    private readonly issueCommentRepository: Pick<
+      IssueCommentRepository,
+      'getCommentsFromIssue'
+    >,
   ) {
     this.issueRejectionEvaluator = new IssueRejectionEvaluator(issueRepository);
   }
 
   run = async (params: {
-    projectUrl: string;
     issueUrl: string;
+    allowedIssueAuthors?: string[] | null;
     labelsAsLlmAgentName?: string[] | null;
   }): Promise<IssueReviewReadinessResult> => {
-    const project = await this.projectRepository.getByUrl(params.projectUrl);
-    const issue = await this.issueRepository.get(params.issueUrl, project);
+    const issue = await this.issueRepository.getIssueByUrl(params.issueUrl);
 
     if (!issue) {
-      throw new IssueNotFoundError(params.issueUrl);
+      return {
+        reviewReady: false,
+        rejections: [
+          {
+            type: 'ISSUE_NOT_FOUND',
+            detail: `Issue not found: ${params.issueUrl}`,
+          },
+        ],
+      };
+    }
+
+    const rejections: { type: RejectedReasonType; detail: string }[] = [];
+
+    const comments =
+      await this.issueCommentRepository.getCommentsFromIssue(issue);
+
+    const isTrustedAuthor = (author: string): boolean =>
+      this.isAuthorTrusted(author, params.allowedIssueAuthors ?? null);
+
+    const lastComment = comments[comments.length - 1];
+    if (
+      !lastComment ||
+      !isTrustedAuthor(lastComment.author) ||
+      !lastComment.content.startsWith('From: :robot:')
+    ) {
+      rejections.push({
+        type: 'NO_REPORT_FROM_AGENT_BOT',
+        detail: 'NO_REPORT_FROM_AGENT_BOT',
+      });
+    } else if (this.reportBodyHasNextStep(lastComment.content)) {
+      rejections.push({
+        type: 'REPORT_HAS_NEXT_STEP',
+        detail: 'REPORT_HAS_NEXT_STEP',
+      });
     }
 
-    const { rejections } = await this.issueRejectionEvaluator.evaluate(
-      issue,
-      params.labelsAsLlmAgentName ?? [],
-    );
+    const { rejections: prRejections } =
+      await this.issueRejectionEvaluator.evaluate(
+        issue,
+        params.labelsAsLlmAgentName ?? [],
+      );
+
+    const allRejections = [...rejections, ...prRejections];
 
     return {
-      reviewReady: rejections.length === 0,
-      rejections,
+      reviewReady: allRejections.length === 0,
+      rejections: allRejections,
     };
   };
+
+  private isAuthorTrusted = (
+    author: string,
+    allowedIssueAuthors: string[] | null,
+  ): boolean =>
+    allowedIssueAuthors === null || allowedIssueAuthors.includes(author);
+
+  private reportBodyHasNextStep = (body: string): boolean => {
+    const reportMatch = body.match(/```json\n([\s\S]*?)\n```/);
+    if (!reportMatch || reportMatch.length < 2) {
+      return false;
+    }
+    let reportJson: unknown;
+    try {
+      reportJson = JSON.parse(reportMatch[1]);
+    } catch (error) {
+      console.warn(
+        'Invalid JSON in report body while checking nextStep:',
+        error,
+      );
+      return false;
+    }
+    if (typeof reportJson !== 'object' || reportJson === null) {
+      return false;
+    }
+    if (!('nextStep' in reportJson)) {
+      return false;
+    }
+    const nextStepValue = Reflect.get(reportJson, 'nextStep');
+    return nextStepValue !== null && nextStepValue !== undefined;
+  };
 }

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

@@ -22,7 +22,7 @@ import { AssignNoAssigneeIssueToManagerUseCase } from './AssignNoAssigneeIssueTo
 import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCase';
 import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
-import { RevertNotReadyAwaitingQualityCheckUseCase } from './RevertNotReadyAwaitingQualityCheckUseCase';
+import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
 import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
 import { DailySecurityScanUseCase } from './DailySecurityScanUseCase';
@@ -115,8 +115,8 @@ describe('HandleScheduledEventUseCase', () => {
     const mockStartPreparationUseCase = mock<StartPreparationUseCase>();
     const mockRevertOrphanedPreparationUseCase =
       mock<RevertOrphanedPreparationUseCase>();
-    const mockRevertNotReadyAwaitingQualityCheckUseCase =
-      mock<RevertNotReadyAwaitingQualityCheckUseCase>();
+    const mockRevertNotReadyReviewQueueIssueUseCase =
+      mock<RevertNotReadyReviewQueueIssueUseCase>();
     const mockUpdateRateLimitCacheUseCase = mock<UpdateRateLimitCacheUseCase>();
     const mockDailySecurityScanUseCase = mock<DailySecurityScanUseCase>();
     const mockDateRepository = mock<DateRepository>();
@@ -142,7 +142,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockUpdateIssueStatusByLabelUseCase,
       mockStartPreparationUseCase,
       mockRevertOrphanedPreparationUseCase,
-      mockRevertNotReadyAwaitingQualityCheckUseCase,
+      mockRevertNotReadyReviewQueueIssueUseCase,
       mockUpdateRateLimitCacheUseCase,
       mockDailySecurityScanUseCase,
       mockDateRepository,
@@ -326,7 +326,7 @@ describe('HandleScheduledEventUseCase', () => {
       );
     });
 
-    it('should invoke revertNotReadyAwaitingQualityCheckUseCase on every scheduled run', async () => {
+    it('should invoke revertNotReadyReviewQueueIssueUseCase on every scheduled run', async () => {
       const input = {
         projectName: 'test-project',
         org: 'test-org',
@@ -346,7 +346,7 @@ describe('HandleScheduledEventUseCase', () => {
       await useCase.run(input);
 
       expect(
-        mockRevertNotReadyAwaitingQualityCheckUseCase.run,
+        mockRevertNotReadyReviewQueueIssueUseCase.run,
       ).toHaveBeenCalledWith(
         expect.objectContaining({
           projectUrl: 'https://github.com/test-org/test-project',
@@ -355,7 +355,7 @@ describe('HandleScheduledEventUseCase', () => {
       );
     });
 
-    it('should invoke revertNotReadyAwaitingQualityCheckUseCase even when startPreparation is absent', async () => {
+    it('should invoke revertNotReadyReviewQueueIssueUseCase even when startPreparation is absent', async () => {
       const input = {
         projectName: 'test-project',
         org: 'test-org',
@@ -375,7 +375,7 @@ describe('HandleScheduledEventUseCase', () => {
       await useCase.run(input);
 
       expect(
-        mockRevertNotReadyAwaitingQualityCheckUseCase.run,
+        mockRevertNotReadyReviewQueueIssueUseCase.run,
       ).toHaveBeenCalledTimes(1);
     });
 

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -25,7 +25,7 @@ import {
   StartPreparationUseCase,
 } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
-import { RevertNotReadyAwaitingQualityCheckUseCase } from './RevertNotReadyAwaitingQualityCheckUseCase';
+import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
 import { resolveLabelsAsLlmAgentName } from './resolveLabelsAsLlmAgentName';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
 import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
@@ -62,7 +62,7 @@ export class HandleScheduledEventUseCase {
     readonly updateIssueStatusByLabelUseCase: UpdateIssueStatusByLabelUseCase,
     readonly startPreparationUseCase: StartPreparationUseCase,
     readonly revertOrphanedPreparationUseCase: RevertOrphanedPreparationUseCase,
-    readonly revertNotReadyAwaitingQualityCheckUseCase: RevertNotReadyAwaitingQualityCheckUseCase,
+    readonly revertNotReadyReviewQueueIssueUseCase: RevertNotReadyReviewQueueIssueUseCase,
     readonly updateRateLimitCacheUseCase: UpdateRateLimitCacheUseCase | null,
     readonly dailySecurityScanUseCase: DailySecurityScanUseCase | null,
     readonly dateRepository: DateRepository,
@@ -292,7 +292,7 @@ ${JSON.stringify(e)}
       topLevel: input.labelsAsLlmAgentName,
       startPreparation: input.startPreparation?.labelsAsLlmAgentName,
     });
-    await this.revertNotReadyAwaitingQualityCheckUseCase.run({
+    await this.revertNotReadyReviewQueueIssueUseCase.run({
       projectUrl: input.projectUrl,
       allowIssueCacheMinutes: input.allowIssueCacheMinutes,
       labelsAsLlmAgentName,