github-issue-tower-defence-management 2.10.0 → 2.10.2

package/src/adapter/entry-points/console/ui/e2e/consoleTestHarness.ts

@@ -625,6 +625,7 @@ const createStubIssueRepository = (
         }
       : null,
   setIssueAgentField: async (): Promise<void> => undefined,
+  updateBranch: async (): Promise<boolean> => false,
   updateStoryOptionColor: async (
     _project,
     storyOptionId: string,

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.ts

@@ -2786,6 +2786,30 @@ export class ApiV3CheerioRestIssueRepository
     return `${status} ${reason}`;
   };
 
+  updateBranch = async (prUrl: string): Promise<boolean> => {
+    const { owner, repo, issueNumber: prNumber } = this.parseIssueUrl(prUrl);
+    const response = await this.fetchWithRateLimitRetry(() =>
+      fetch(
+        `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${prNumber}/update-branch`,
+        {
+          method: 'PUT',
+          headers: {
+            Authorization: `Bearer ${this.ghToken}`,
+            Accept: 'application/vnd.github+json',
+          },
+        },
+      ),
+    );
+    if (response.ok) {
+      return true;
+    }
+    if (response.status === 422) {
+      return false;
+    }
+    const reason = await this.formatGitHubErrorWithStatus(response);
+    throw new Error(`Failed to update branch for PR ${prUrl}: ${reason}`);
+  };
+
   deletePullRequestBranch = async (
     prUrl: string,
     branchName: string,

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

@@ -97,6 +97,7 @@ describe('ConflictedIssueRevertUseCase', () => {
     getAllIssues: jest.Mock;
     getOpenPullRequests: jest.Mock;
     updateStatus: jest.Mock;
+    updateBranch: jest.Mock;
   };
   let mockIssueCommentRepository: {
     createComment: jest.Mock;
@@ -122,6 +123,7 @@ describe('ConflictedIssueRevertUseCase', () => {
       }),
       getOpenPullRequests: jest.fn().mockResolvedValue(new Map()),
       updateStatus: jest.fn().mockResolvedValue(undefined),
+      updateBranch: jest.fn().mockResolvedValue(false),
     };
 
     mockIssueCommentRepository = {
@@ -144,7 +146,6 @@ describe('ConflictedIssueRevertUseCase', () => {
     });
 
     const excludedStatuses = [
-      'Awaiting Workspace',
       'Done',
       'Icebox',
       'Failed Preparation',
@@ -170,6 +171,40 @@ describe('ConflictedIssueRevertUseCase', () => {
       });
     });
 
+    it('should process Awaiting Workspace issues when their linked PR is conflicted and update-branch fails', async () => {
+      const issue = createMockIssue({ status: 'Awaiting Workspace' });
+      const prItem = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/1',
+        closingIssueReferenceUrls: [issue.url],
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue, prItem],
+        cacheUsed: false,
+      });
+      const conflictedPr = createMockRelatedPullRequest({
+        url: prItem.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      mockIssueRepository.getOpenPullRequests.mockResolvedValue(
+        new Map([[conflictedPr.url, conflictedPr]]),
+      );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
+
+      await useCase.run({ projectUrl });
+
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        issue,
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        issue,
+        'conflict',
+      );
+    });
+
     it('should skip PR items when scanning for target task issues', async () => {
       const prIssue = createMockIssue({
         url: 'https://github.com/user/repo/issues/1',
@@ -195,6 +230,7 @@ describe('ConflictedIssueRevertUseCase', () => {
       mockIssueRepository.getOpenPullRequests.mockResolvedValue(
         new Map([[conflictedPr.url, conflictedPr]]),
       );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
 
       await useCase.run({ projectUrl });
 
@@ -255,7 +291,44 @@ describe('ConflictedIssueRevertUseCase', () => {
       expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
     });
 
-    it('should update status and post conflict comment when linked PR is conflicted', async () => {
+    it('should update status and post conflict comment when linked PR is conflicted and update-branch fails', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      const prItem = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/1',
+        closingIssueReferenceUrls: [issue.url],
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue, prItem],
+        cacheUsed: false,
+      });
+      const conflictedPr = createMockRelatedPullRequest({
+        url: prItem.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      mockIssueRepository.getOpenPullRequests.mockResolvedValue(
+        new Map([[conflictedPr.url, conflictedPr]]),
+      );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
+
+      await useCase.run({ projectUrl });
+
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        issue,
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        issue,
+        'conflict',
+      );
+    });
+
+    it('should not update status or post comment when update-branch succeeds for the conflicted PR', async () => {
       const issue = createMockIssue({
         url: 'https://github.com/user/repo/issues/1',
         status: 'Preparation',
@@ -277,6 +350,105 @@ describe('ConflictedIssueRevertUseCase', () => {
       mockIssueRepository.getOpenPullRequests.mockResolvedValue(
         new Map([[conflictedPr.url, conflictedPr]]),
       );
+      mockIssueRepository.updateBranch.mockResolvedValue(true);
+
+      await useCase.run({ projectUrl });
+
+      expect(mockIssueRepository.updateBranch).toHaveBeenCalledWith(
+        conflictedPr.url,
+      );
+      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+    });
+
+    it('should call update-branch only for conflicted PRs, not for all linked PRs', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      const prItem1 = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/1',
+        number: 1,
+        closingIssueReferenceUrls: [issue.url],
+      });
+      const prItem2 = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/2',
+        number: 2,
+        closingIssueReferenceUrls: [issue.url],
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue, prItem1, prItem2],
+        cacheUsed: false,
+      });
+      const conflictedPr = createMockRelatedPullRequest({
+        url: prItem1.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      const mergeablePr = createMockRelatedPullRequest({
+        url: prItem2.url,
+        isConflicted: false,
+        mergeable: 'MERGEABLE',
+      });
+      mockIssueRepository.getOpenPullRequests.mockResolvedValue(
+        new Map([
+          [conflictedPr.url, conflictedPr],
+          [mergeablePr.url, mergeablePr],
+        ]),
+      );
+      mockIssueRepository.updateBranch.mockResolvedValue(true);
+
+      await useCase.run({ projectUrl });
+
+      expect(mockIssueRepository.updateBranch).toHaveBeenCalledTimes(1);
+      expect(mockIssueRepository.updateBranch).toHaveBeenCalledWith(
+        conflictedPr.url,
+      );
+      expect(mockIssueRepository.updateBranch).not.toHaveBeenCalledWith(
+        mergeablePr.url,
+      );
+    });
+
+    it('should fall back to status update when any conflicted PR update-branch fails', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      const prItem1 = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/1',
+        number: 1,
+        closingIssueReferenceUrls: [issue.url],
+      });
+      const prItem2 = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/2',
+        number: 2,
+        closingIssueReferenceUrls: [issue.url],
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue, prItem1, prItem2],
+        cacheUsed: false,
+      });
+      const conflictedPr1 = createMockRelatedPullRequest({
+        url: prItem1.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      const conflictedPr2 = createMockRelatedPullRequest({
+        url: prItem2.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      mockIssueRepository.getOpenPullRequests.mockResolvedValue(
+        new Map([
+          [conflictedPr1.url, conflictedPr1],
+          [conflictedPr2.url, conflictedPr2],
+        ]),
+      );
+      mockIssueRepository.updateBranch
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce(false);
 
       await useCase.run({ projectUrl });
 
@@ -313,6 +485,7 @@ describe('ConflictedIssueRevertUseCase', () => {
       mockIssueRepository.getOpenPullRequests.mockResolvedValue(
         new Map([[conflictedPr.url, conflictedPr]]),
       );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
 
       await useCase.run({ projectUrl });
 
@@ -430,6 +603,7 @@ describe('ConflictedIssueRevertUseCase', () => {
           [mergeablePr.url, mergeablePr],
         ]),
       );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
 
       await useCase.run({ projectUrl });
 
@@ -491,7 +665,7 @@ describe('ConflictedIssueRevertUseCase', () => {
       expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
     });
 
-    it('should perform status update before comment posting', async () => {
+    it('should call update-branch before status update and comment when update-branch fails', async () => {
       const callOrder: string[] = [];
       const issue = createMockIssue({
         url: 'https://github.com/user/repo/issues/1',
@@ -514,6 +688,10 @@ describe('ConflictedIssueRevertUseCase', () => {
       mockIssueRepository.getOpenPullRequests.mockResolvedValue(
         new Map([[conflictedPr.url, conflictedPr]]),
       );
+      mockIssueRepository.updateBranch.mockImplementation(() => {
+        callOrder.push('updateBranch');
+        return Promise.resolve(false);
+      });
       mockIssueRepository.updateStatus.mockImplementation(() => {
         callOrder.push('updateStatus');
         return Promise.resolve();
@@ -525,7 +703,11 @@ describe('ConflictedIssueRevertUseCase', () => {
 
       await useCase.run({ projectUrl });
 
-      expect(callOrder).toEqual(['updateStatus', 'createComment']);
+      expect(callOrder).toEqual([
+        'updateBranch',
+        'updateStatus',
+        'createComment',
+      ]);
     });
 
     it('should fetch all PR URLs in a single batched call', async () => {
@@ -567,7 +749,7 @@ describe('ConflictedIssueRevertUseCase', () => {
       );
     });
 
-    it('should process multiple conflicted issues in one run', async () => {
+    it('should process multiple conflicted issues in one run when update-branch fails for both', async () => {
       const issue1 = createMockIssue({
         url: 'https://github.com/user/repo/issues/1',
         number: 1,
@@ -609,6 +791,7 @@ describe('ConflictedIssueRevertUseCase', () => {
           [conflictedPr2.url, conflictedPr2],
         ]),
       );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
 
       await useCase.run({ projectUrl });
 

package/src/domain/usecases/ConflictedIssueRevertUseCase.ts

@@ -11,7 +11,6 @@ import {
 } from '../entities/WorkflowStatus';
 
 const EXCLUDED_STATUSES = new Set([
-  AWAITING_WORKSPACE_STATUS_NAME,
   DONE_STATUS_NAME,
   ICEBOX_STATUS_NAME,
   FAILED_PREPARATION_STATUS_NAME,
@@ -26,7 +25,7 @@ export class ConflictedIssueRevertUseCase {
     >,
     private readonly issueRepository: Pick<
       IssueRepository,
-      'getAllIssues' | 'getOpenPullRequests' | 'updateStatus'
+      'getAllIssues' | 'getOpenPullRequests' | 'updateStatus' | 'updateBranch'
     >,
     private readonly issueCommentRepository: Pick<
       IssueCommentRepository,
@@ -98,8 +97,17 @@ export class ConflictedIssueRevertUseCase {
         continue;
       }
 
-      const hasConflict = relatedPrs.some((pr) => pr.isConflicted);
-      if (!hasConflict) {
+      const conflictedPrs = relatedPrs.filter((pr) => pr.isConflicted);
+      if (conflictedPrs.length === 0) {
+        continue;
+      }
+
+      const allBranchesUpdated = (
+        await Promise.all(
+          conflictedPrs.map((pr) => this.issueRepository.updateBranch(pr.url)),
+        )
+      ).every(Boolean);
+      if (allBranchesUpdated) {
         continue;
       }
 

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

@@ -117,6 +117,9 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     searchIssue: jest.Mock;
     createNewIssue: jest.Mock;
     updateNextActionDate: jest.Mock;
+    updateStory: jest.Mock;
+    addIssueToProject: jest.Mock;
+    getIssueByUrl: jest.Mock;
   };
   let mockIssueCommentRepository: {
     getCommentsFromIssue: jest.Mock;
@@ -174,6 +177,9 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       searchIssue: jest.fn().mockResolvedValue([]),
       createNewIssue: jest.fn().mockResolvedValue(42),
       updateNextActionDate: jest.fn().mockResolvedValue(undefined),
+      updateStory: jest.fn().mockResolvedValue(undefined),
+      addIssueToProject: jest.fn().mockResolvedValue(undefined),
+      getIssueByUrl: jest.fn().mockResolvedValue(null),
     };
 
     mockIssueCommentRepository = {
@@ -4477,11 +4483,10 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
   });
 
   describe('nextStepAgent validation against agents list', () => {
-    it('should transition to Failed Preparation when nextStepAgent is not in configured agents list', async () => {
-      const issue = createMockIssue({
-        url: 'https://github.com/user/repo/issues/1',
-        status: 'Preparation',
-      });
+    it('creates a workflow blocker issue and returns original task to Awaiting Workspace when nextStepAgent is not in configured agents list', async () => {
+      const issueUrl = 'https://github.com/user/repo/issues/1';
+      const blockerIssueUrl = 'https://github.com/user/repo/issues/42';
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
 
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
       mockIssueRepository.get.mockResolvedValue(issue);
@@ -4491,37 +4496,256 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
             'From: :robot: test-agent (model)\n```json\n{"nextStepAgent": "unknown-agent"}\n```',
         }),
       ]);
-      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+      mockIssueRepository.searchIssue.mockResolvedValue([]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(42);
 
       await useCase.run({
         projectUrl: 'https://github.com/users/user/projects/1',
-        issueUrl: 'https://github.com/user/repo/issues/1',
+        issueUrl,
         thresholdForAutoReject: 3,
         workflowBlockerResolvedWebhookUrl: null,
         allowedIssueAuthors: ['test-user'],
         agents: ['developer', 'triager'],
       });
 
+      expect(mockIssueRepository.createNewIssue).toHaveBeenCalledWith(
+        'user',
+        'repo',
+        expect.stringContaining('unknown-agent'),
+        expect.stringContaining(issueUrl),
+        [],
+        [],
+      );
+      expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+        issueUrl,
+        mockProject,
+        blockerIssueUrl,
+      );
       expect(mockIssueRepository.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        mockProject,
+      );
+      expect(mockIssueRepository.update).not.toHaveBeenCalledWith(
         expect.objectContaining({ status: 'Failed Preparation' }),
         mockProject,
       );
       expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
         mockProject,
-        expect.objectContaining({ status: 'Failed Preparation' }),
-        'failed-preparation-id',
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        'awaiting-workspace-id',
       );
       expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        expect.objectContaining({
-          url: 'https://github.com/user/repo/issues/1',
+        expect.objectContaining({ url: issueUrl }),
+        expect.stringContaining(blockerIssueUrl),
+      );
+    });
+
+    it('sets workflow blocker story on the created blocker issue when project has a matching story', async () => {
+      const issueUrl = 'https://github.com/user/repo/issues/1';
+      const blockerIssueUrl = 'https://github.com/user/repo/issues/42';
+      const blockerStoryId = 'blocker-story-id';
+      const projectWithStory = createMockProject({
+        dependedIssueUrlSeparatedByComma: {
+          name: 'Depended Issue URL',
+          fieldId: 'depended-field-id',
+        },
+        story: {
+          name: 'Story',
+          fieldId: 'story-field-id',
+          databaseId: 1,
+          stories: [
+            {
+              id: blockerStoryId,
+              name: 'workflow blocker',
+              color: 'RED',
+              description: '',
+            },
+            {
+              id: 'regular-story-id',
+              name: 'regular / workflow improvement',
+              color: 'BLUE',
+              description: '',
+            },
+          ],
+          workflowManagementStory: {
+            id: 'wms-id',
+            name: 'workflow management',
+          },
+        },
+      });
+      const blockerIssueObject = createMockIssue({
+        url: blockerIssueUrl,
+        itemId: 'blocker-item-id',
+      });
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithStory);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: test-agent (model)\n```json\n{"nextStepAgent": "unknown-agent"}\n```',
         }),
-        expect.stringContaining('unknown-agent'),
+      ]);
+      mockIssueRepository.searchIssue.mockResolvedValue([]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(42);
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(blockerIssueObject);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: ['test-user'],
+        agents: ['developer', 'triager'],
+      });
+
+      expect(mockIssueRepository.addIssueToProject).toHaveBeenCalledWith(
+        projectWithStory,
+        blockerIssueUrl,
+      );
+      expect(mockIssueRepository.updateStory).toHaveBeenCalledWith(
+        expect.objectContaining({ story: projectWithStory.story }),
+        blockerIssueObject,
+        blockerStoryId,
+      );
+    });
+
+    it('reuses an existing open blocker issue instead of creating a new one', async () => {
+      const issueUrl = 'https://github.com/user/repo/issues/1';
+      const existingBlockerUrl = 'https://github.com/user/repo/issues/99';
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: test-agent (model)\n```json\n{"nextStepAgent": "unknown-agent"}\n```',
+        }),
+      ]);
+      mockIssueRepository.searchIssue.mockResolvedValue([
+        {
+          url: existingBlockerUrl,
+          title: 'Unregistered agent in workflow configuration: unknown-agent',
+          number: '99',
+        },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: ['test-user'],
+        agents: ['developer', 'triager'],
+      });
+
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+      expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+        issueUrl,
+        mockProject,
+        existingBlockerUrl,
       );
       expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
-        expect.objectContaining({
-          url: 'https://github.com/user/repo/issues/1',
+        expect.objectContaining({ url: issueUrl }),
+        expect.stringContaining(existingBlockerUrl),
+      );
+    });
+
+    it('skips story assignment when project has no story field', async () => {
+      const issueUrl = 'https://github.com/user/repo/issues/1';
+      const projectWithoutStory = createMockProject({
+        dependedIssueUrlSeparatedByComma: {
+          name: 'Depended Issue URL',
+          fieldId: 'depended-field-id',
+        },
+        story: null,
+      });
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithoutStory);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: test-agent (model)\n```json\n{"nextStepAgent": "unknown-agent"}\n```',
+        }),
+      ]);
+      mockIssueRepository.searchIssue.mockResolvedValue([]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(42);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: ['test-user'],
+        agents: ['developer', 'triager'],
+      });
+
+      expect(mockIssueRepository.addIssueToProject).not.toHaveBeenCalled();
+      expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
+      expect(mockIssueRepository.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        projectWithoutStory,
+      );
+    });
+
+    it('skips story assignment when no workflow blocker story option exists in project', async () => {
+      const issueUrl = 'https://github.com/user/repo/issues/1';
+      const projectWithNoBlockerStory = createMockProject({
+        dependedIssueUrlSeparatedByComma: {
+          name: 'Depended Issue URL',
+          fieldId: 'depended-field-id',
+        },
+        story: {
+          name: 'Story',
+          fieldId: 'story-field-id',
+          databaseId: 1,
+          stories: [
+            {
+              id: 'regular-story-id',
+              name: 'regular / workflow improvement',
+              color: 'BLUE',
+              description: '',
+            },
+          ],
+          workflowManagementStory: {
+            id: 'wms-id',
+            name: 'workflow management',
+          },
+        },
+      });
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(
+        projectWithNoBlockerStory,
+      );
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: test-agent (model)\n```json\n{"nextStepAgent": "unknown-agent"}\n```',
         }),
-        expect.stringContaining('not in the configured agents list'),
+      ]);
+      mockIssueRepository.searchIssue.mockResolvedValue([]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(42);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: ['test-user'],
+        agents: ['developer', 'triager'],
+      });
+
+      expect(mockIssueRepository.addIssueToProject).not.toHaveBeenCalled();
+      expect(mockIssueRepository.updateStory).not.toHaveBeenCalled();
+      expect(mockIssueRepository.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        projectWithNoBlockerStory,
       );
     });