github-issue-tower-defence-management 1.32.0 → 1.34.0

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

@@ -1,12 +1,8 @@
 import { NotifyFinishedIssuePreparationUseCase } from './NotifyFinishedIssuePreparationUseCase';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
-import { IssueCommentRepository } from './adapter-interfaces/IssueCommentRepository';
 import { Issue } from '../entities/Issue';
 import { Project } from '../entities/Project';
 import { Comment } from '../entities/Comment';
-
-type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+import { StoryObjectMap } from '../entities/StoryObjectMap';
 
 const createMockProject = (overrides: Partial<Project> = {}): Project => ({
   id: 'project-1',
@@ -62,13 +58,23 @@ const createMockComment = (overrides: Partial<Comment> = {}): Comment => ({
 
 describe('NotifyFinishedIssuePreparationUseCase', () => {
   let useCase: NotifyFinishedIssuePreparationUseCase;
-  let mockProjectRepository: Mocked<Pick<ProjectRepository, 'getByUrl'>>;
-  let mockIssueRepository: Mocked<
-    Pick<IssueRepository, 'get' | 'update' | 'findRelatedOpenPRs'>
-  >;
-  let mockIssueCommentRepository: Mocked<
-    Pick<IssueCommentRepository, 'getCommentsFromIssue' | 'createComment'>
-  >;
+  let mockProjectRepository: {
+    getByUrl: jest.Mock;
+    prepareStatus: jest.Mock;
+  };
+  let mockIssueRepository: {
+    get: jest.Mock;
+    update: jest.Mock;
+    findRelatedOpenPRs: jest.Mock;
+    getStoryObjectMap: jest.Mock;
+  };
+  let mockIssueCommentRepository: {
+    getCommentsFromIssue: jest.Mock;
+    createComment: jest.Mock;
+  };
+  let mockWebhookRepository: {
+    sendGetRequest: jest.Mock;
+  };
   let mockProject: Project;
 
   beforeEach(() => {
@@ -78,9 +84,15 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
 
     mockProjectRepository = {
       getByUrl: jest.fn(),
+      prepareStatus: jest
+        .fn()
+        .mockImplementation((_name: string, project: Project) =>
+          Promise.resolve(project),
+        ),
     };
 
     mockIssueRepository = {
+      getStoryObjectMap: jest.fn(),
       get: jest.fn(),
       update: jest.fn(),
       findRelatedOpenPRs: jest.fn(),
@@ -91,10 +103,73 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       createComment: jest.fn(),
     };
 
+    mockWebhookRepository = {
+      sendGetRequest: jest.fn(),
+    };
+
     useCase = new NotifyFinishedIssuePreparationUseCase(
       mockProjectRepository,
       mockIssueRepository,
       mockIssueCommentRepository,
+      mockWebhookRepository,
+    );
+  });
+
+  it('should call prepareStatus for preparationStatus, awaitingWorkspaceStatus, and awaitingQualityCheckStatus with chained project objects', async () => {
+    const projectAfterFirstPrepare = createMockProject();
+    const projectAfterSecondPrepare = createMockProject();
+    const projectAfterThirdPrepare = createMockProject();
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockProjectRepository.prepareStatus
+      .mockResolvedValueOnce(projectAfterFirstPrepare)
+      .mockResolvedValueOnce(projectAfterSecondPrepare)
+      .mockResolvedValueOnce(projectAfterThirdPrepare);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({ content: 'From: Test report' }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isConflicted: false,
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      preparationStatus: 'Preparation',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      awaitingQualityCheckStatus: 'Awaiting Quality Check',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+    });
+
+    expect(mockProjectRepository.prepareStatus).toHaveBeenCalledTimes(3);
+    expect(mockProjectRepository.prepareStatus).toHaveBeenNthCalledWith(
+      1,
+      'Preparation',
+      mockProject,
+    );
+    expect(mockProjectRepository.prepareStatus).toHaveBeenNthCalledWith(
+      2,
+      'Awaiting Workspace',
+      projectAfterFirstPrepare,
+    );
+    expect(mockProjectRepository.prepareStatus).toHaveBeenNthCalledWith(
+      3,
+      'Awaiting Quality Check',
+      projectAfterSecondPrepare,
     );
   });
 
@@ -114,8 +189,10 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         url: 'https://github.com/user/repo/pull/1',
         isConflicted: false,
         isPassedAllCiJob: true,
+        isCiStateSuccess: true,
         isResolvedAllReviewComments: true,
         isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
       },
     ]);
 
@@ -126,6 +203,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledTimes(1);
@@ -150,6 +228,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         awaitingWorkspaceStatus: 'Awaiting Workspace',
         awaitingQualityCheckStatus: 'Awaiting Quality Check',
         thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
       }),
     ).rejects.toThrow(
       'Issue not found: https://github.com/user/repo/issues/999',
@@ -173,6 +252,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         awaitingWorkspaceStatus: 'Awaiting Workspace',
         awaitingQualityCheckStatus: 'Awaiting Quality Check',
         thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
       }),
     ).rejects.toThrow(
       'Illegal issue status for https://github.com/user/repo/issues/1: expected Preparation, but got Done',
@@ -197,8 +277,10 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         url: 'https://github.com/user/repo/pull/1',
         isConflicted: false,
         isPassedAllCiJob: true,
+        isCiStateSuccess: true,
         isResolvedAllReviewComments: true,
         isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
       },
     ]);
 
@@ -209,6 +291,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledWith(
@@ -225,7 +308,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     );
   });
 
-  it('should pass when last comment does not start with Auto Status Check or From:', async () => {
+  it('should reject when last comment does not start with From:', async () => {
     const issue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',
       status: 'Preparation',
@@ -241,8 +324,10 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         url: 'https://github.com/user/repo/pull/1',
         isConflicted: false,
         isPassedAllCiJob: true,
+        isCiStateSuccess: true,
         isResolvedAllReviewComments: true,
         isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
       },
     ]);
 
@@ -253,14 +338,21 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledWith(
       expect.objectContaining({
-        status: 'Awaiting Quality Check',
+        status: 'Awaiting Workspace',
       }),
       mockProject,
     );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://github.com/user/repo/issues/1',
+      }),
+      expect.stringContaining('NO_REPORT_FROM_AGENT_BOT'),
+    );
   });
 
   it('should reject and set status to Awaiting Workspace when no comments exist', async () => {
@@ -277,8 +369,10 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         url: 'https://github.com/user/repo/pull/1',
         isConflicted: false,
         isPassedAllCiJob: true,
+        isCiStateSuccess: true,
         isResolvedAllReviewComments: true,
         isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
       },
     ]);
 
@@ -289,6 +383,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledWith(
@@ -321,6 +416,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledWith(
@@ -356,8 +452,10 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         url: 'https://github.com/user/repo/pull/1',
         isConflicted: false,
         isPassedAllCiJob: true,
+        isCiStateSuccess: true,
         isResolvedAllReviewComments: true,
         isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
       },
     ]);
 
@@ -368,6 +466,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledWith(
@@ -378,6 +477,94 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     );
   });
 
+  it('should not auto-escalate when retry comment exists even if threshold met', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({ content: 'Auto Status Check: REJECTED - first' }),
+      createMockComment({ content: 'Auto Status Check: REJECTED - second' }),
+      createMockComment({ content: 'Auto Status Check: REJECTED - third' }),
+      createMockComment({ content: 'retry' }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isConflicted: false,
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      preparationStatus: 'Preparation',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      awaitingQualityCheckStatus: 'Awaiting Quality Check',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+    });
+
+    expect(mockIssueRepository.update).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 'Awaiting Quality Check',
+      }),
+      mockProject,
+    );
+  });
+
+  it('should handle case-insensitive retry comment', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({ content: 'Auto Status Check: REJECTED - first' }),
+      createMockComment({ content: 'Auto Status Check: REJECTED - second' }),
+      createMockComment({ content: 'Auto Status Check: REJECTED - third' }),
+      createMockComment({ content: 'Retry please' }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isConflicted: false,
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      preparationStatus: 'Preparation',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      awaitingQualityCheckStatus: 'Awaiting Quality Check',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+    });
+
+    expect(mockIssueRepository.update).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 'Awaiting Quality Check',
+      }),
+      mockProject,
+    );
+  });
+
   it('should reject when PR is not found', async () => {
     const issue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',
@@ -398,6 +585,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledWith(
@@ -430,15 +618,19 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         url: 'https://github.com/user/repo/pull/1',
         isConflicted: false,
         isPassedAllCiJob: true,
+        isCiStateSuccess: true,
         isResolvedAllReviewComments: true,
         isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
       },
       {
         url: 'https://github.com/user/repo/pull/2',
         isConflicted: false,
         isPassedAllCiJob: true,
+        isCiStateSuccess: true,
         isResolvedAllReviewComments: true,
         isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
       },
     ]);
 
@@ -449,6 +641,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledWith(
@@ -481,8 +674,10 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         url: 'https://github.com/user/repo/pull/1',
         isConflicted: true,
         isPassedAllCiJob: true,
+        isCiStateSuccess: true,
         isResolvedAllReviewComments: true,
         isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
       },
     ]);
 
@@ -493,6 +688,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledWith(
@@ -525,8 +721,110 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         url: 'https://github.com/user/repo/pull/1',
         isConflicted: false,
         isPassedAllCiJob: false,
+        isCiStateSuccess: false,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      preparationStatus: 'Preparation',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      awaitingQualityCheckStatus: 'Awaiting Quality Check',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+    });
+
+    expect(mockIssueRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 'Awaiting Workspace',
+      }),
+      mockProject,
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://github.com/user/repo/issues/1',
+      }),
+      expect.stringContaining('ANY_CI_JOB_FAILED_OR_IN_PROGRESS'),
+    );
+  });
+
+  it('should reject with REQUIRED_CI_JOB_NEVER_STARTED when required checks are missing', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({ content: 'From: Test report' }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isConflicted: false,
+        isPassedAllCiJob: false,
+        isCiStateSuccess: true,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: ['E2E Tests', 'deploy-preview'],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      preparationStatus: 'Preparation',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      awaitingQualityCheckStatus: 'Awaiting Quality Check',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+    });
+
+    expect(mockIssueRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 'Awaiting Workspace',
+      }),
+      mockProject,
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://github.com/user/repo/issues/1',
+      }),
+      expect.stringContaining('REQUIRED_CI_JOB_NEVER_STARTED'),
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://github.com/user/repo/issues/1',
+      }),
+      expect.stringContaining('E2E Tests'),
+    );
+  });
+
+  it('should reject with ANY_CI_JOB_FAILED_OR_IN_PROGRESS when CI has failures and required checks are also missing', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({ content: 'From: Test report' }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isConflicted: false,
+        isPassedAllCiJob: false,
+        isCiStateSuccess: false,
         isResolvedAllReviewComments: true,
         isBranchOutOfDate: false,
+        missingRequiredCheckNames: ['deploy-preview'],
       },
     ]);
 
@@ -537,6 +835,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledWith(
@@ -549,7 +848,54 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       expect.objectContaining({
         url: 'https://github.com/user/repo/issues/1',
       }),
-      expect.stringContaining('ANY_CI_JOB_FAILED'),
+      expect.stringContaining('ANY_CI_JOB_FAILED_OR_IN_PROGRESS'),
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://github.com/user/repo/issues/1',
+      }),
+      expect.stringContaining('deploy-preview'),
+    );
+  });
+
+  it('should include PR URL in rejection comment details', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({ content: 'From: Test report' }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isConflicted: false,
+        isPassedAllCiJob: false,
+        isCiStateSuccess: false,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      preparationStatus: 'Preparation',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      awaitingQualityCheckStatus: 'Awaiting Quality Check',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+    });
+
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://github.com/user/repo/issues/1',
+      }),
+      expect.stringContaining('https://github.com/user/repo/pull/1'),
     );
   });
 
@@ -569,8 +915,10 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         url: 'https://github.com/user/repo/pull/1',
         isConflicted: false,
         isPassedAllCiJob: true,
+        isCiStateSuccess: true,
         isResolvedAllReviewComments: false,
         isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
       },
     ]);
 
@@ -581,6 +929,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.update).toHaveBeenCalledWith(
@@ -617,6 +966,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
@@ -628,6 +978,49 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     );
   });
 
+  it('should check PRs when issue has category:e2e label', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      labels: ['category:e2e'],
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({ content: 'From: Test report' }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isConflicted: false,
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      preparationStatus: 'Preparation',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      awaitingQualityCheckStatus: 'Awaiting Quality Check',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+    });
+
+    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();
+    expect(mockIssueRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 'Awaiting Quality Check',
+      }),
+      mockProject,
+    );
+  });
+
   it('should still check for report comment even when issue has category label', async () => {
     const issue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',
@@ -650,6 +1043,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       awaitingQualityCheckStatus: 'Awaiting Quality Check',
       thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
     });
 
     expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
@@ -663,7 +1057,319 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       expect.objectContaining({
         url: 'https://github.com/user/repo/issues/1',
       }),
-      expect.stringContaining('NO_REPORT'),
+      expect.stringContaining('NO_REPORT_FROM_AGENT_BOT'),
     );
   });
+
+  describe('workflow blocker webhook notification', () => {
+    const createWorkflowBlockerStoryObjectMap = (
+      issueUrl: string,
+    ): StoryObjectMap => {
+      const map: StoryObjectMap = new Map();
+      map.set('Workflow Blocker Story', {
+        story: {
+          id: 'story-1',
+          name: 'Workflow Blocker Story',
+          color: 'GRAY',
+          description: '',
+        },
+        storyIssue: null,
+        issues: [createMockIssue({ url: issueUrl })],
+      });
+      return map;
+    };
+
+    const createNonBlockerStoryObjectMap = (): StoryObjectMap => {
+      const map: StoryObjectMap = new Map();
+      map.set('Regular Story', {
+        story: {
+          id: 'story-2',
+          name: 'Regular Story',
+          color: 'GRAY',
+          description: '',
+        },
+        storyIssue: null,
+        issues: [
+          createMockIssue({
+            url: 'https://github.com/user/repo/issues/99',
+          }),
+        ],
+      });
+      return map;
+    };
+
+    it('should send webhook when workflow blocker issue status changes to awaitingQualityCheckStatus on checks pass', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/1',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createWorkflowBlockerStoryObjectMap(
+          'https://github.com/user/repo/issues/1',
+        ),
+      );
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        preparationStatus: 'Preparation',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        awaitingQualityCheckStatus: 'Awaiting Quality Check',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl:
+          'https://example.com/webhook?url={URL}&msg={MESSAGE}',
+      });
+
+      expect(mockWebhookRepository.sendGetRequest).toHaveBeenCalledWith(
+        `https://example.com/webhook?url=${encodeURIComponent('https://github.com/user/repo/issues/1')}&msg=${encodeURIComponent('Workflow blocker resolved: https://github.com/user/repo/issues/1')}`,
+      );
+    });
+
+    it('should send webhook when workflow blocker issue auto-escalates', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content: 'Auto Status Check: REJECTED - first',
+        }),
+        createMockComment({
+          content: 'Auto Status Check: REJECTED - second',
+        }),
+        createMockComment({
+          content: 'Auto Status Check: REJECTED - third',
+        }),
+      ]);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createWorkflowBlockerStoryObjectMap(
+          'https://github.com/user/repo/issues/1',
+        ),
+      );
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        preparationStatus: 'Preparation',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        awaitingQualityCheckStatus: 'Awaiting Quality Check',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl:
+          'https://example.com/notify={MESSAGE}',
+      });
+
+      expect(mockWebhookRepository.sendGetRequest).toHaveBeenCalledTimes(1);
+      expect(mockWebhookRepository.sendGetRequest).toHaveBeenCalledWith(
+        expect.stringContaining('https://example.com/notify='),
+      );
+    });
+
+    it('should not send webhook for non-blocker issues', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/1',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createNonBlockerStoryObjectMap(),
+      );
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        preparationStatus: 'Preparation',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        awaitingQualityCheckStatus: 'Awaiting Quality Check',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl:
+          'https://example.com/webhook?msg={MESSAGE}',
+      });
+
+      expect(mockWebhookRepository.sendGetRequest).not.toHaveBeenCalled();
+    });
+
+    it('should not send webhook when URL is null', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/1',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        preparationStatus: 'Preparation',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        awaitingQualityCheckStatus: 'Awaiting Quality Check',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+      });
+
+      expect(mockIssueRepository.getStoryObjectMap).not.toHaveBeenCalled();
+      expect(mockWebhookRepository.sendGetRequest).not.toHaveBeenCalled();
+    });
+
+    it('should log warning and not block workflow when webhook fails', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/1',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createWorkflowBlockerStoryObjectMap(
+          'https://github.com/user/repo/issues/1',
+        ),
+      );
+      mockWebhookRepository.sendGetRequest.mockRejectedValue(
+        new Error('Network error'),
+      );
+
+      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        preparationStatus: 'Preparation',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        awaitingQualityCheckStatus: 'Awaiting Quality Check',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl:
+          'https://example.com/webhook?msg={MESSAGE}',
+      });
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Failed to send workflow blocker notification:',
+        expect.any(Error),
+      );
+      expect(mockIssueRepository.update).toHaveBeenCalledWith(
+        expect.objectContaining({
+          status: 'Awaiting Quality Check',
+        }),
+        mockProject,
+      );
+
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('should URL-encode placeholders in webhook URL', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/1',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createWorkflowBlockerStoryObjectMap(
+          'https://github.com/user/repo/issues/1',
+        ),
+      );
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        preparationStatus: 'Preparation',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        awaitingQualityCheckStatus: 'Awaiting Quality Check',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl:
+          'https://example.com/runTasker/notify=:={MESSAGE}',
+      });
+
+      expect(mockWebhookRepository.sendGetRequest).toHaveBeenCalledTimes(1);
+      expect(mockWebhookRepository.sendGetRequest).not.toHaveBeenCalledWith(
+        expect.stringContaining('{MESSAGE}'),
+      );
+      expect(mockWebhookRepository.sendGetRequest).not.toHaveBeenCalledWith(
+        expect.stringContaining('{URL}'),
+      );
+      expect(mockWebhookRepository.sendGetRequest).toHaveBeenCalledWith(
+        expect.stringContaining(
+          encodeURIComponent('Workflow blocker resolved:'),
+        ),
+      );
+    });
+  });
 });