github-issue-tower-defence-management 1.177.0 → 1.178.1

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

@@ -947,6 +947,85 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
   });
 
+  it('should comment the repeated dispatch when the declared nextStepAgent is already the agent field value', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      agent: 'accounting',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({
+        content:
+          'From: :robot: triager\n```json\n{"nextStepAgent": "accounting", "nextStep": null}\n```',
+      }),
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      expect.anything(),
+      'awaiting-workspace-id',
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining('Next step agent dispatch repeated: accounting'),
+    );
+  });
+
+  it('should escalate to Failed Preparation when the declared nextStepAgent was already dispatched up to the threshold without a report', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      agent: 'accounting',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({
+        content:
+          'From: :robot: triager\n```json\n{"nextStepAgent": "accounting", "nextStep": null}\n```',
+      }),
+      createMockComment({
+        content: 'Next step agent dispatch repeated: accounting',
+      }),
+      createMockComment({
+        content: 'Next step agent dispatch repeated: accounting',
+      }),
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      expect.anything(),
+      'failed-preparation-id',
+    );
+    expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining(
+        'Failed to receive a report from the dispatched agent for 3 times',
+      ),
+    );
+  });
+
   it('should not modify labels when nextStepAgent is specified', async () => {
     const issue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -31,6 +31,7 @@ import { extractNextStepAgent } from './extractNextStepAgent';
 import { findLastAgentReport } from './findLastAgentReport';
 import { issueReactivationTriggerIsPending } from './issueReactivationTriggerIsPending';
 import { normalizeReportBody } from './normalizeReportBody';
+import { resolveNextStepAgentDispatchRepetition } from './resolveNextStepAgentDispatchRepetition';
 
 export class IssueNotFoundError extends Error {
   constructor(issueUrl: string) {
@@ -229,7 +230,37 @@ export class NotifyFinishedIssuePreparationUseCase {
     const nextStepAgent = lastAgentReport
       ? extractNextStepAgent(lastAgentReport.content)
       : null;
+    const commentsAfterLastAgentReport = lastAgentReport
+      ? comments.slice(comments.indexOf(lastAgentReport) + 1)
+      : [];
     if (nextStepAgent !== null) {
+      const repetition = resolveNextStepAgentDispatchRepetition({
+        agentFieldValue: issue.agent,
+        nextStepAgent,
+        commentsAfterLastAgentReport,
+        isTrustedAuthor,
+        thresholdForAutoReject: params.thresholdForAutoReject,
+      });
+      if (repetition.type === 'escalateToFailedPreparation') {
+        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(
+          issue,
+          repetition.comment,
+        );
+        await this.sendWorkflowBlockerNotification(
+          params.issueUrl,
+          params.workflowBlockerResolvedWebhookUrl,
+          project,
+        );
+        return;
+      }
       const agentOptionId = await this.ensureAgentOptionAndGetId(
         project,
         nextStepAgent,
@@ -249,6 +280,12 @@ export class NotifyFinishedIssuePreparationUseCase {
         awaitingWorkspaceStatusOption.id,
       );
       await this.patchConsoleTab(issue);
+      if (repetition.type === 'dispatchAgain') {
+        await this.issueCommentRepository.createComment(
+          issue,
+          repetition.comment,
+        );
+      }
       return;
     }
 

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

@@ -260,6 +260,134 @@ describe('RevertOrphanedPreparationUseCase', () => {
     expect(mockIssueRepository.updateStatus.mock.calls[0][2]).toBe('1');
   });
 
+  it('should transition to Failed Preparation when the declared next step agent is already assigned and the repetition threshold is met', async () => {
+    mockProject.agent = {
+      name: 'agent',
+      fieldId: 'agent-field-id',
+      options: [
+        {
+          id: 'agent-option-developer',
+          name: 'developer',
+          color: 'GRAY',
+          description: '',
+        },
+      ],
+    };
+    const stuckIssue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/10',
+      status: 'Preparation',
+      agent: 'developer',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      project: mockProject,
+      issues: [stuckIssue],
+      cacheUsed: false,
+    });
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 1,
+    });
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      {
+        author: 'bot',
+        content:
+          'From: :robot: triager\n\n```json\n{"nextStep":null,"nextStepAgent":"developer"}\n```',
+        createdAt: new Date('2024-01-02T00:00:00Z'),
+      },
+      {
+        author: 'bot',
+        content: 'Next step agent dispatch repeated: developer',
+        createdAt: new Date('2024-01-02T01:00:00Z'),
+      },
+      {
+        author: 'bot',
+        content: 'Next step agent dispatch repeated: developer',
+        createdAt: new Date('2024-01-02T02:00:00Z'),
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      preparationProcessCheckCommand: 'pgrep -fa "claude-agent.*{URL}"',
+      thresholdForAutoReject: 3,
+      allowedIssueAuthors: ['bot'],
+    });
+
+    expect(mockIssueRepository.setIssueAgentField.mock.calls).toEqual([]);
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.updateStatus.mock.calls[0][2]).toBe('5');
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      stuckIssue,
+      expect.stringContaining(
+        'Failed to receive a report from the dispatched agent for 3 times',
+      ),
+    );
+  });
+
+  it('should record the repeated dispatch even when the project has no Failed Preparation status', async () => {
+    mockProject.status.statuses = mockProject.status.statuses.filter(
+      (status) => status.name !== 'Failed Preparation',
+    );
+    mockProject.agent = {
+      name: 'agent',
+      fieldId: 'agent-field-id',
+      options: [
+        {
+          id: 'agent-option-developer',
+          name: 'developer',
+          color: 'GRAY',
+          description: '',
+        },
+      ],
+    };
+    const stuckIssue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/10',
+      status: 'Preparation',
+      agent: 'developer',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      project: mockProject,
+      issues: [stuckIssue],
+      cacheUsed: false,
+    });
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 1,
+    });
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      {
+        author: 'bot',
+        content:
+          'From: :robot: triager\n\n```json\n{"nextStep":null,"nextStepAgent":"developer"}\n```',
+        createdAt: new Date('2024-01-02T00:00:00Z'),
+      },
+      {
+        author: 'bot',
+        content: 'Next step agent dispatch repeated: developer',
+        createdAt: new Date('2024-01-02T01:00:00Z'),
+      },
+      {
+        author: 'bot',
+        content: 'Next step agent dispatch repeated: developer',
+        createdAt: new Date('2024-01-02T02:00:00Z'),
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      preparationProcessCheckCommand: 'pgrep -fa "claude-agent.*{URL}"',
+      thresholdForAutoReject: 3,
+      allowedIssueAuthors: ['bot'],
+    });
+
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      stuckIssue,
+      expect.stringContaining('Next step agent dispatch repeated: developer'),
+    );
+  });
+
   it('should ignore a next step agent designated by an author outside the allowed issue authors', async () => {
     mockProject.agent = {
       name: 'agent',

package/src/domain/usecases/RevertOrphanedPreparationUseCase.ts

@@ -26,6 +26,7 @@ import { extractNextStepAgent } from './extractNextStepAgent';
 import { findLastAgentReport } from './findLastAgentReport';
 import { ensureAgentOptionAndGetId } from './ensureAgentOptionAndGetId';
 import { normalizeReportBody } from './normalizeReportBody';
+import { resolveNextStepAgentDispatchRepetition } from './resolveNextStepAgentDispatchRepetition';
 
 const ORPHANED_PREPARATION_REJECTION_DETAIL = 'ORPHANED_PREPARATION';
 
@@ -121,11 +122,44 @@ export class RevertOrphanedPreparationUseCase {
       if (!isStillInPreparation) {
         continue;
       }
-      const nextStepAgent = this.resolveNextStepAgent(
-        comments,
-        params.allowedIssueAuthors,
+      const lastAgentReport = findLastAgentReport(comments, (author) =>
+        isAuthorAuthorizedForAutoStatusCheck(
+          author,
+          params.allowedIssueAuthors,
+        ),
       );
+      const nextStepAgent = lastAgentReport
+        ? extractNextStepAgent(lastAgentReport.content)
+        : null;
       if (nextStepAgent !== null) {
+        const repetition = resolveNextStepAgentDispatchRepetition({
+          agentFieldValue: issue.agent,
+          nextStepAgent,
+          commentsAfterLastAgentReport: lastAgentReport
+            ? comments.slice(comments.indexOf(lastAgentReport) + 1)
+            : [],
+          isTrustedAuthor: (author) =>
+            isAuthorAuthorizedForAutoStatusCheck(
+              author,
+              params.allowedIssueAuthors,
+            ),
+          thresholdForAutoReject: params.thresholdForAutoReject,
+        });
+        if (
+          repetition.type === 'escalateToFailedPreparation' &&
+          failedPreparationStatusOption
+        ) {
+          await this.issueRepository.updateStatus(
+            project,
+            issue,
+            failedPreparationStatusOption.id,
+          );
+          await this.issueCommentRepository.createComment(
+            issue,
+            repetition.comment,
+          );
+          continue;
+        }
         const agentOptionId = await ensureAgentOptionAndGetId(
           this.projectRepository,
           project,
@@ -143,6 +177,12 @@ export class RevertOrphanedPreparationUseCase {
           issue,
           awaitingWorkspaceStatusOption.id,
         );
+        if (repetition.type !== 'notRepeated') {
+          await this.issueCommentRepository.createComment(
+            issue,
+            repetition.comment,
+          );
+        }
         continue;
       }
       if (outcome === 'returnToLabelSelectedAgent') {
@@ -346,18 +386,6 @@ export class RevertOrphanedPreparationUseCase {
     return [pr];
   };
 
-  private resolveNextStepAgent = (
-    comments: Comment[],
-    allowedIssueAuthors: string[] | null | undefined,
-  ): string | null => {
-    const lastAgentReport = findLastAgentReport(comments, (author) =>
-      isAuthorAuthorizedForAutoStatusCheck(author, allowedIssueAuthors),
-    );
-    return lastAgentReport
-      ? extractNextStepAgent(lastAgentReport.content)
-      : null;
-  };
-
   private reportBodyHasNextStep = (body: string): boolean => {
     const reportMatch = normalizeReportBody(body).match(
       /```json\n([\s\S]*?)\n```/,

package/src/domain/usecases/console/GenerateConsoleListsUseCase.test.ts

@@ -217,31 +217,27 @@ describe('GenerateConsoleListsUseCase', () => {
       expect(result['todo-by-agent'].items).toHaveLength(0);
     });
 
-    it('selects no-story items case-insensitively for triage', () => {
+    it('selects all actionable items for triage regardless of story', () => {
       const result = run([
         makeIssue({ story: 'regular / NO STORY; SET STORY FIELD' }),
         makeIssue({ story: 'no story please' }),
         makeIssue({ story: 'Story Alpha' }),
         makeIssue({ story: null }),
       ]);
-      expect(result.triage.items).toHaveLength(3);
+      expect(result.triage.items).toHaveLength(4);
     });
 
-    it('keeps no-story items whose status is In Tmux by agent', () => {
+    it('excludes In Tmux by agent items from triage regardless of story', () => {
       const result = run([
         makeIssue({ story: 'no story', status: 'In Tmux by agent' }),
         makeIssue({ story: 'no story', status: 'in tmux by agent' }),
         makeIssue({ story: 'no story', status: 'Unread' }),
       ]);
       const statuses = result.triage.items.map((item) => item.status);
-      expect(statuses).toEqual([
-        'In Tmux by agent',
-        'in tmux by agent',
-        'Unread',
-      ]);
+      expect(statuses).toEqual(['Unread']);
     });
 
-    it('keeps a no-story item that is blocked or scheduled to resume later', () => {
+    it('excludes items with reactivation triggers from triage', () => {
       const result = run([
         makeIssue({
           story: 'no story',
@@ -253,42 +249,42 @@ describe('GenerateConsoleListsUseCase', () => {
         }),
         makeIssue({ story: 'no story', nextActionHour: 9 }),
       ]);
-      expect(result.triage.items).toHaveLength(3);
+      expect(result.triage.items).toHaveLength(0);
     });
 
-    it('keeps a pull request and another person’s item off the triage tab', () => {
+    it('includes pull requests in triage when assigned, excludes unassigned and closed', () => {
       const result = run([
         makeIssue({ story: 'no story', isPr: true }),
         makeIssue({ story: 'no story', assignees: ['someone-else'] }),
         makeIssue({ story: 'no story', isClosed: true }),
       ]);
-      expect(result.triage.items).toHaveLength(0);
+      expect(result.triage.items).toHaveLength(1);
     });
 
-    it('keeps an item whose story field is empty on the triage tab', () => {
+    it('includes all actionable items in triage including those with a real story or null story', () => {
       const result = run([
         makeIssue({ story: null, status: 'Awaiting Workspace' }),
         makeIssue({ story: null, status: null }),
         makeIssue({ story: 'regular / NO STORY' }),
         makeIssue({ story: 'Story Alpha' }),
       ]);
-      expect(result.triage.items).toHaveLength(3);
+      expect(result.triage.items).toHaveLength(4);
     });
 
-    it('keeps a pull request, another person’s item and a closed item off the triage tab when the story field is empty', () => {
+    it('includes pull requests in triage, excludes unassigned and closed items with null story', () => {
       const result = run([
         makeIssue({ story: null, isPr: true }),
         makeIssue({ story: null, assignees: ['someone-else'] }),
         makeIssue({ story: null, isClosed: true }),
       ]);
-      expect(result.triage.items).toHaveLength(0);
+      expect(result.triage.items).toHaveLength(1);
     });
 
-    it('keeps every no-story item whatever status it carries', () => {
+    it('shows all actionable items in triage whatever status they carry, excluding In Tmux by agent', () => {
       const result = run([
         makeIssue({ story: 'no story', status: 'Unread' }),
         makeIssue({ story: 'no story', status: 'Awaiting Workspace' }),
-        makeIssue({ story: 'no story', status: null }),
+        makeIssue({ story: 'no story', status: 'In Tmux by agent' }),
         makeIssue({ story: 'no story', status: 'Preparation' }),
         makeIssue({ story: 'no story', status: 'Failed Preparation' }),
         makeIssue({ story: 'no story', status: 'Awaiting Quality Check' }),
@@ -301,7 +297,6 @@ describe('GenerateConsoleListsUseCase', () => {
       expect(result.triage.items.map((item) => item.status)).toEqual([
         'Unread',
         'Awaiting Workspace',
-        null,
         'Preparation',
         'Failed Preparation',
         'Awaiting Quality Check',
@@ -313,11 +308,11 @@ describe('GenerateConsoleListsUseCase', () => {
       ]);
     });
 
-    it('keeps an item whose story is not a no-story name off the triage tab at every status', () => {
+    it('shows items with any story in triage at every status except In Tmux by agent', () => {
       const result = run([
         makeIssue({ story: 'Story Alpha', status: 'Unread' }),
         makeIssue({ story: 'Story Alpha', status: 'Awaiting Workspace' }),
-        makeIssue({ story: 'Story Alpha', status: null }),
+        makeIssue({ story: 'Story Alpha', status: 'In Tmux by agent' }),
         makeIssue({ story: 'Story Alpha', status: 'Preparation' }),
         makeIssue({ story: 'Story Alpha', status: 'Failed Preparation' }),
         makeIssue({ story: 'Story Alpha', status: 'Awaiting Quality Check' }),
@@ -327,7 +322,7 @@ describe('GenerateConsoleListsUseCase', () => {
         makeIssue({ story: 'Story Alpha', status: 'Done' }),
         makeIssue({ story: 'Story Alpha', status: 'Icebox' }),
       ]);
-      expect(result.triage.items).toHaveLength(0);
+      expect(result.triage.items).toHaveLength(10);
     });
 
     it('keeps a no-story item whose status is written in a different case', () => {
@@ -440,15 +435,15 @@ describe('GenerateConsoleListsUseCase', () => {
       expect(allTabItems(result)).toHaveLength(1);
     });
 
-    it('shows a no-story In Tmux by agent issue on the triage tab and nowhere else', () => {
+    it('hides a no-story In Tmux by agent issue from triage and all other tabs', () => {
       const result = run([
         makeIssue({
           story: 'no story',
           status: 'In Tmux by agent',
         }),
       ]);
-      expect(result.triage.items).toHaveLength(1);
-      expect(allTabItems(result)).toHaveLength(1);
+      expect(result.triage.items).toHaveLength(0);
+      expect(allTabItems(result)).toHaveLength(0);
     });
 
     it('hides In Tmux by agent case-insensitively from every tab other than the workflow blocker tab', () => {
@@ -477,7 +472,7 @@ describe('GenerateConsoleListsUseCase', () => {
       expect(
         result['workflow-blocker'].items.map((item) => item.status).sort(),
       ).toEqual(['In Tmux by agent', 'In Tmux by human']);
-      expect(result.triage.items.map((item) => item.number)).toEqual([3]);
+      expect(result.triage.items.map((item) => item.number)).toEqual([3, 2]);
       expect(
         result.prs.items
           .concat(result.triage.items)

package/src/domain/usecases/console/GenerateConsoleListsUseCase.ts

@@ -219,14 +219,12 @@ export class GenerateConsoleListsUseCase {
         storyOrder,
         storyColors: this.buildStoryColorsString(storyOptions),
         items: this.sortByStoryOrder(
-          issues
-            .filter((issue) => this.needsStory(issue, assigneeLogin))
-            .map((issue) =>
-              this.projectItem(
-                issue,
-                relatedOpenPullRequestUrlsByIssueUrl.get(issue.url) ?? [],
-              ),
+          actionableIssues.map((issue) =>
+            this.projectItem(
+              issue,
+              relatedOpenPullRequestUrlsByIssueUrl.get(issue.url) ?? [],
             ),
+          ),
           storyOrder,
         ),
       },
@@ -241,12 +239,6 @@ export class GenerateConsoleListsUseCase {
     };
   };
 
-  private needsStory = (issue: Issue, assigneeLogin: string): boolean =>
-    issue.isClosed === false &&
-    issue.isPr === false &&
-    issue.assignees.includes(assigneeLogin) &&
-    (issue.story === null || issue.story.toLowerCase().includes('no story'));
-
   private isActionable = (issue: Issue, assigneeLogin: string): boolean =>
     issue.isClosed === false &&
     issue.assignees.includes(assigneeLogin) &&

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

@@ -0,0 +1,97 @@
+import {
+  NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD,
+  resolveNextStepAgentDispatchRepetition,
+} from './resolveNextStepAgentDispatchRepetition';
+
+const trustAll = (): boolean => true;
+
+describe('resolveNextStepAgentDispatchRepetition', () => {
+  it('returns notRepeated when the agent field holds no value', () => {
+    expect(
+      resolveNextStepAgentDispatchRepetition({
+        agentFieldValue: null,
+        nextStepAgent: 'accounting',
+        commentsAfterLastAgentReport: [],
+        isTrustedAuthor: trustAll,
+        thresholdForAutoReject: 3,
+      }),
+    ).toEqual({ type: 'notRepeated' });
+  });
+
+  it('returns notRepeated when the agent field holds another agent', () => {
+    expect(
+      resolveNextStepAgentDispatchRepetition({
+        agentFieldValue: 'triager',
+        nextStepAgent: 'accounting',
+        commentsAfterLastAgentReport: [],
+        isTrustedAuthor: trustAll,
+        thresholdForAutoReject: 3,
+      }),
+    ).toEqual({ type: 'notRepeated' });
+  });
+
+  it('returns dispatchAgain with the attempt count when the declared agent is already assigned', () => {
+    const result = resolveNextStepAgentDispatchRepetition({
+      agentFieldValue: 'accounting',
+      nextStepAgent: 'accounting',
+      commentsAfterLastAgentReport: [],
+      isTrustedAuthor: trustAll,
+      thresholdForAutoReject: 3,
+    });
+
+    expect(result.type).toBe('dispatchAgain');
+    expect(result.type === 'dispatchAgain' ? result.comment : '').toContain(
+      '(1/3)',
+    );
+  });
+
+  it('matches the agent field and the declared agent ignoring case, spaces and hyphens', () => {
+    expect(
+      resolveNextStepAgentDispatchRepetition({
+        agentFieldValue: 'PR Reviewer',
+        nextStepAgent: 'pr-reviewer',
+        commentsAfterLastAgentReport: [],
+        isTrustedAuthor: trustAll,
+        thresholdForAutoReject: 3,
+      }).type,
+    ).toBe('dispatchAgain');
+  });
+
+  it('counts only repetition comments written by a trusted author', () => {
+    const result = resolveNextStepAgentDispatchRepetition({
+      agentFieldValue: 'accounting',
+      nextStepAgent: 'accounting',
+      commentsAfterLastAgentReport: [
+        {
+          author: 'stranger',
+          content: `${NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD} accounting`,
+        },
+        {
+          author: 'stranger',
+          content: `${NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD} accounting`,
+        },
+      ],
+      isTrustedAuthor: (author: string): boolean => author === 'bot',
+      thresholdForAutoReject: 3,
+    });
+
+    expect(result.type).toBe('dispatchAgain');
+  });
+
+  it('escalates once the repetition count reaches the auto reject threshold', () => {
+    const repeated = {
+      author: 'bot',
+      content: `${NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD} accounting`,
+    };
+
+    const result = resolveNextStepAgentDispatchRepetition({
+      agentFieldValue: 'accounting',
+      nextStepAgent: 'accounting',
+      commentsAfterLastAgentReport: [repeated, repeated],
+      isTrustedAuthor: trustAll,
+      thresholdForAutoReject: 3,
+    });
+
+    expect(result.type).toBe('escalateToFailedPreparation');
+  });
+});