github-issue-tower-defence-management 2.9.0 → 2.10.1

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

@@ -214,7 +214,7 @@ describe('IssueRejectionEvaluator', () => {
           agent: 'my-developer',
         },
         [],
-        { developerAgentName: 'my-developer' },
+        { developerAgentNames: ['my-developer'] },
       );
 
       expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();
@@ -222,7 +222,7 @@ describe('IssueRejectionEvaluator', () => {
       expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
     });
 
-    it('should not require PR evaluation when issue agent does not match custom developer agent name', async () => {
+    it('should not require PR evaluation when issue agent does not match custom developer agent names', async () => {
       const result = await evaluator.evaluate(
         {
           url: 'https://github.com/user/repo/issues/1',
@@ -231,7 +231,7 @@ describe('IssueRejectionEvaluator', () => {
           agent: 'other-agent',
         },
         [],
-        { developerAgentName: 'my-developer' },
+        { developerAgentNames: ['my-developer'] },
       );
 
       expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
@@ -239,7 +239,7 @@ describe('IssueRejectionEvaluator', () => {
       expect(result.approvedPrUrl).toBeNull();
     });
 
-    it('should default to developer when developerAgentName is null', async () => {
+    it('should default to developer when developerAgentNames is null', async () => {
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
 
       const result = await evaluator.evaluate(
@@ -250,7 +250,7 @@ describe('IssueRejectionEvaluator', () => {
           agent: 'developer',
         },
         [],
-        { developerAgentName: null },
+        { developerAgentNames: null },
       );
 
       expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();
@@ -258,6 +258,42 @@ describe('IssueRejectionEvaluator', () => {
       expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
     });
 
+    it('should require PR evaluation when issue agent matches any of multiple developer agent names', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      const result = await evaluator.evaluate(
+        {
+          url: 'https://github.com/user/repo/issues/1',
+          labels: [],
+          isPr: false,
+          agent: 'second-developer',
+        },
+        [],
+        { developerAgentNames: ['first-developer', 'second-developer'] },
+      );
+
+      expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();
+      expect(result.rejections).toHaveLength(1);
+      expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
+    });
+
+    it('should not require PR evaluation when issue agent does not match any of multiple developer agent names', async () => {
+      const result = await evaluator.evaluate(
+        {
+          url: 'https://github.com/user/repo/issues/1',
+          labels: [],
+          isPr: false,
+          agent: 'chore',
+        },
+        [],
+        { developerAgentNames: ['first-developer', 'second-developer'] },
+      );
+
+      expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+      expect(result.rejections).toHaveLength(0);
+      expect(result.approvedPrUrl).toBeNull();
+    });
+
     it('should require PR evaluation and reject CI failure when issue agent is pr-reviewer', async () => {
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
         createReadyPr('https://github.com/user/repo/pull/10', {
@@ -316,7 +352,7 @@ describe('IssueRejectionEvaluator', () => {
       expect(result.approvedPrUrl).toBe('https://github.com/user/repo/pull/10');
     });
 
-    it('should still require PR evaluation for pr-reviewer when custom developerAgentName is set', async () => {
+    it('should still require PR evaluation for pr-reviewer when custom developerAgentNames is set', async () => {
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
         createReadyPr('https://github.com/user/repo/pull/10', {
           isPassedAllCiJob: false,
@@ -332,7 +368,7 @@ describe('IssueRejectionEvaluator', () => {
           agent: 'pr-reviewer',
         },
         [],
-        { developerAgentName: 'my-developer' },
+        { developerAgentNames: ['my-developer'] },
       );
 
       expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();

package/src/domain/usecases/IssueRejectionEvaluator.ts

@@ -33,9 +33,9 @@ export type EvaluateOptions = {
   // getOpenPullRequest call, which keeps the transient-failure handling that
   // distinguishes an unknown state from an absent pull request.
   resolvedOpenPrByUrl?: ReadonlyMap<string, RelatedPullRequest | null> | null;
-  // The agent name treated as the developer agent for PR/CI/conflict checks.
-  // When null or undefined, defaults to 'developer'.
-  developerAgentName?: string | null;
+  // The agent names treated as developer agents for PR/CI/conflict checks.
+  // When null, undefined, or empty, defaults to ['developer'].
+  developerAgentNames?: string[] | null;
   detectConflictEvenIfEvaluationSkipped?: boolean;
 };
 
@@ -68,7 +68,7 @@ export class IssueRejectionEvaluator {
       this.requiresPullRequestEvaluation(
         issue,
         labelsNotRequiringPullRequest,
-        options.developerAgentName,
+        options.developerAgentNames,
       )
     ) {
       let prsToCheck: RelatedPullRequest[];
@@ -226,15 +226,17 @@ export class IssueRejectionEvaluator {
   requiresPullRequestEvaluation = (
     issue: { labels: string[]; body?: string | null; agent?: string | null },
     labelsNotRequiringPullRequest: string[] = [],
-    developerAgentName?: string | null,
+    developerAgentNames?: string[] | null,
   ): boolean => {
     const categoryLabels = issue.labels.filter((label) =>
       label.startsWith('category:'),
     );
-    const effectiveDeveloperAgentName = developerAgentName ?? 'developer';
+    const effectiveDeveloperAgentNames = developerAgentNames?.length
+      ? developerAgentNames
+      : ['developer'];
     const isNonDeveloperAgent =
       issue.agent != null &&
-      issue.agent !== effectiveDeveloperAgentName &&
+      !effectiveDeveloperAgentNames.includes(issue.agent) &&
       issue.agent !== 'pr-reviewer';
     const hasLabelNotRequiringPullRequest = issue.labels.some((label) =>
       labelsNotRequiringPullRequest.includes(label),

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 = {
@@ -1757,7 +1763,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     );
   });
 
-  it('should reject a missing PR when the issue agent matches developerAgentName', async () => {
+  it('should reject a missing PR when the issue agent matches developerAgentNames', async () => {
     const issue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',
       status: 'Preparation',
@@ -1777,7 +1783,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       thresholdForAutoReject: 3,
       workflowBlockerResolvedWebhookUrl: null,
       allowedIssueAuthors: ['test-user'],
-      developerAgentName: 'my-agent',
+      developerAgentNames: ['my-agent'],
     });
 
     expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
@@ -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,
       );
     });
 
@@ -4888,7 +5112,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       );
     });
 
-    it('should reassign to the configured developerAgentName when chore agent has a failing CI PR', async () => {
+    it('should reassign to the first configured developerAgentNames when chore agent has a failing CI PR', async () => {
       const issue = createMockIssue({
         url: 'https://github.com/user/repo/issues/1',
         status: 'Preparation',
@@ -4921,7 +5145,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
         thresholdForAutoReject: 3,
         workflowBlockerResolvedWebhookUrl: null,
         allowedIssueAuthors: null,
-        developerAgentName: 'custom-developer',
+        developerAgentNames: ['custom-developer'],
       });
 
       expect(mockIssueRepository.setIssueAgentField).toHaveBeenCalledWith(

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -85,6 +85,9 @@ export class NotifyFinishedIssuePreparationUseCase {
       | 'searchIssue'
       | 'createNewIssue'
       | 'updateNextActionDate'
+      | 'updateStory'
+      | 'addIssueToProject'
+      | 'getIssueByUrl'
     >,
     private readonly issueCommentRepository: Pick<
       IssueCommentRepository,
@@ -116,7 +119,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     missingAgentName?: string | null;
     sessionErrorLine?: string | null;
     manager?: string | null;
-    developerAgentName?: string | null;
+    developerAgentNames?: string[] | null;
     deferPreparation?: boolean | null;
   }): Promise<void> => {
     const project = await this.projectRepository.getByUrl(params.projectUrl);
@@ -253,31 +256,26 @@ export class NotifyFinishedIssuePreparationUseCase {
       params.agents.length > 0 &&
       !params.agents.includes(nextStepAgent)
     ) {
-      issue.status = FAILED_PREPARATION_STATUS_NAME;
-      await this.issueRepository.update(issue, project);
-      await this.issueRepository.updateStatus(
-        project,
-        issue,
-        failedPreparationStatusOption.id,
-      );
-      await this.patchConsoleTab(issue);
-      await this.issueCommentRepository.createComment(
+      await this.handleUnregisteredNextStepAgent(
         issue,
-        `nextStepAgent '${nextStepAgent}' is not in the configured agents list. Update the configuration to include it.`,
+        project,
+        awaitingWorkspaceStatusOption,
+        nextStepAgent,
       );
       return;
     }
 
     const ciFailingPrUrl = await this.resolveLinkedPrWithCiFailure(
       issue,
-      params.developerAgentName ?? null,
+      params.developerAgentNames ?? null,
     );
     if (ciFailingPrUrl !== null) {
-      const effectiveDeveloperAgentName =
-        params.developerAgentName ?? 'developer';
+      const effectiveDeveloperAgentNames = params.developerAgentNames?.length
+        ? params.developerAgentNames
+        : ['developer'];
       const agentOptionId = await this.ensureAgentOptionAndGetId(
         project,
-        effectiveDeveloperAgentName,
+        effectiveDeveloperAgentNames[0],
       );
       if (agentOptionId !== null) {
         await this.issueRepository.setIssueAgentField(
@@ -312,7 +310,7 @@ export class NotifyFinishedIssuePreparationUseCase {
       isTrustedAuthor,
       resolveLabelsNotRequiringPullRequest(params),
       nextStepAgent,
-      params.developerAgentName,
+      params.developerAgentNames,
     );
 
     const rejectionStatusMessage =
@@ -579,6 +577,88 @@ export class NotifyFinishedIssuePreparationUseCase {
     );
   };
 
+  private handleUnregisteredNextStepAgent = async (
+    issue: Issue,
+    project: Project,
+    awaitingWorkspaceStatusOption: { id: string },
+    nextStepAgent: string,
+  ): Promise<void> => {
+    const blockerIssueTitle = `Unregistered agent in workflow configuration: ${nextStepAgent}`;
+
+    const searchResults = await this.issueRepository.searchIssue({
+      owner: issue.org,
+      repositoryName: issue.repo,
+      type: 'issue',
+      state: 'open',
+      title: blockerIssueTitle,
+    });
+    const exactMatch = searchResults.find((i) => i.title === blockerIssueTitle);
+
+    let blockerIssueUrl: string;
+    if (exactMatch) {
+      blockerIssueUrl = exactMatch.url;
+    } else {
+      const body = [
+        `The last agent report on ${issue.url} designated \`nextStepAgent\` as \`${nextStepAgent}\`, which is absent from the configured agents list.`,
+        '',
+        `- Missing agent name: \`${nextStepAgent}\``,
+        `- Declaring task: ${issue.url}`,
+      ].join('\n');
+      const issueNumber = await this.issueRepository.createNewIssue(
+        issue.org,
+        issue.repo,
+        blockerIssueTitle,
+        body,
+        [],
+        [],
+      );
+      blockerIssueUrl = `https://github.com/${issue.org}/${issue.repo}/issues/${issueNumber}`;
+    }
+
+    if (project.story) {
+      const workflowBlockerStory = project.story.stories.find((s) =>
+        s.name.toLowerCase().includes('workflow blocker'),
+      );
+      if (workflowBlockerStory) {
+        await this.issueRepository.addIssueToProject(project, blockerIssueUrl);
+        const blockerIssue =
+          await this.issueRepository.getIssueByUrl(blockerIssueUrl);
+        if (blockerIssue) {
+          await this.issueRepository.updateStory(
+            { ...project, story: project.story },
+            blockerIssue,
+            workflowBlockerStory.id,
+          );
+        }
+      }
+    }
+
+    if (project.dependedIssueUrlSeparatedByComma) {
+      await this.issueRepository.setDependedIssueUrl(
+        issue.url,
+        project,
+        blockerIssueUrl,
+      );
+    } else {
+      console.warn(
+        `dependedIssueUrlSeparatedByComma not configured; cannot block ${issue.url} via ${blockerIssueUrl}`,
+      );
+    }
+
+    issue.status = AWAITING_WORKSPACE_STATUS_NAME;
+    await this.issueRepository.update(issue, project);
+    await this.issueRepository.updateStatus(
+      project,
+      issue,
+      awaitingWorkspaceStatusOption.id,
+    );
+    await this.patchConsoleTab(issue);
+    await this.issueCommentRepository.createComment(
+      issue,
+      `nextStepAgent \`${nextStepAgent}\` is not in the configured agents list. Created workflow blocker task:\n${blockerIssueUrl}`,
+    );
+  };
+
   private collectRejections = async (
     issue: {
       url: string;
@@ -590,7 +670,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     isTrustedAuthor: (author: string) => boolean,
     labelsNotRequiringPullRequest: string[],
     nextStepAgent: string | null,
-    developerAgentName?: string | null,
+    developerAgentNames?: string[] | null,
   ): Promise<{
     rejections: { type: RejectedReasonType; detail: string }[];
     approvedPrUrl: string | null;
@@ -618,7 +698,7 @@ export class NotifyFinishedIssuePreparationUseCase {
       await this.issueRejectionEvaluator.evaluate(
         issue,
         labelsNotRequiringPullRequest,
-        { developerAgentName },
+        { developerAgentNames },
       );
     const requiredPrRejections = isTriagerAgentName(nextStepAgent)
       ? prRejections.filter(
@@ -682,12 +762,14 @@ export class NotifyFinishedIssuePreparationUseCase {
 
   private resolveLinkedPrWithCiFailure = async (
     issue: { url: string; agent: string | null; isPr: boolean },
-    developerAgentName: string | null,
+    developerAgentNames: string[] | null,
   ): Promise<string | null> => {
-    const effectiveDeveloperName = developerAgentName ?? 'developer';
+    const effectiveDeveloperAgentNames = developerAgentNames?.length
+      ? developerAgentNames
+      : ['developer'];
     if (
       issue.agent === null ||
-      issue.agent === effectiveDeveloperName ||
+      effectiveDeveloperAgentNames.includes(issue.agent) ||
       issue.agent === 'pr-reviewer'
     ) {
       return null;