github-issue-tower-defence-management 1.178.0 → 1.179.0

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

@@ -109,6 +109,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     setIssueAgentField: jest.Mock;
     searchIssue: jest.Mock;
     createNewIssue: jest.Mock;
+    updateNextActionDate: jest.Mock;
   };
   let mockIssueCommentRepository: {
     getCommentsFromIssue: jest.Mock;
@@ -155,6 +156,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       setIssueAgentField: jest.fn().mockResolvedValue(undefined),
       searchIssue: jest.fn().mockResolvedValue([]),
       createNewIssue: jest.fn().mockResolvedValue(42),
+      updateNextActionDate: jest.fn().mockResolvedValue(undefined),
     };
 
     mockIssueCommentRepository = {
@@ -947,6 +949,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',
@@ -4301,4 +4382,138 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
     });
   });
+
+  describe('when deferPreparation is true', () => {
+    const issueUrl = 'https://github.com/user/repo/issues/1';
+
+    it('sets nextActionDate to start of tomorrow and returns item to Awaiting Workspace without creating any issue', async () => {
+      const now = new Date('2026-08-24T10:00:00Z');
+      jest.useFakeTimers();
+      jest.setSystemTime(now);
+
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+        deferPreparation: true,
+      });
+
+      expect(mockIssueRepository.updateNextActionDate).toHaveBeenCalledTimes(1);
+      expect(mockIssueRepository.updateNextActionDate).toHaveBeenCalledWith(
+        issueUrl,
+        mockProject,
+        new Date('2026-08-25T00:00:00'),
+      );
+
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        'awaiting-workspace-id',
+      );
+
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledTimes(1);
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        expect.objectContaining({ url: issueUrl }),
+        expect.stringContaining('2026-08-25'),
+      );
+
+      expect(mockIssueRepository.searchIssue).not.toHaveBeenCalled();
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+      expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
+    });
+
+    it('takes precedence over missingAgentName and defers without creating any issue', async () => {
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+        deferPreparation: true,
+        missingAgentName: 'some-agent',
+        manager: 'alice',
+      });
+
+      expect(mockIssueRepository.updateNextActionDate).toHaveBeenCalledTimes(1);
+      expect(mockIssueRepository.searchIssue).not.toHaveBeenCalled();
+      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+      expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
+    });
+
+    it('does not defer when deferPreparation is false', async () => {
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+        deferPreparation: false,
+      });
+
+      expect(mockIssueRepository.updateNextActionDate).not.toHaveBeenCalled();
+    });
+
+    it('states the session stop reason in the deferral comment', async () => {
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+        deferPreparation: true,
+        sessionErrorLine:
+          'Task failed 3 consecutive times with terminal_reason=api_error',
+      });
+
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledTimes(1);
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        expect.objectContaining({ url: issueUrl }),
+        expect.stringContaining(
+          'Task failed 3 consecutive times with terminal_reason=api_error',
+        ),
+      );
+    });
+
+    it('states that no stop reason was captured when sessionErrorLine is absent', async () => {
+      const issue = createMockIssue({ url: issueUrl, status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl,
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+        deferPreparation: true,
+      });
+
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        expect.objectContaining({ url: issueUrl }),
+        expect.stringContaining('(not captured)'),
+      );
+    });
+  });
 });

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -29,8 +29,12 @@ import { Project } from '../entities/Project';
 import { ensureAgentOptionAndGetId } from './ensureAgentOptionAndGetId';
 import { extractNextStepAgent } from './extractNextStepAgent';
 import { findLastAgentReport } from './findLastAgentReport';
-import { issueReactivationTriggerIsPending } from './issueReactivationTriggerIsPending';
+import {
+  issueReactivationTriggerIsPending,
+  issueReactivationTriggerStartOfTomorrow,
+} from './issueReactivationTriggerIsPending';
 import { normalizeReportBody } from './normalizeReportBody';
+import { resolveNextStepAgentDispatchRepetition } from './resolveNextStepAgentDispatchRepetition';
 
 export class IssueNotFoundError extends Error {
   constructor(issueUrl: string) {
@@ -79,6 +83,7 @@ export class NotifyFinishedIssuePreparationUseCase {
       | 'setIssueAgentField'
       | 'searchIssue'
       | 'createNewIssue'
+      | 'updateNextActionDate'
     >,
     private readonly issueCommentRepository: Pick<
       IssueCommentRepository,
@@ -110,6 +115,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     sessionErrorLine?: string | null;
     manager?: string | null;
     developerAgentName?: string | null;
+    deferPreparation?: boolean | null;
   }): Promise<void> => {
     const project = await this.projectRepository.getByUrl(params.projectUrl);
 
@@ -153,6 +159,16 @@ export class NotifyFinishedIssuePreparationUseCase {
       );
     }
 
+    if (params.deferPreparation) {
+      await this.handleTransientFailureDeferral(
+        issue,
+        project,
+        awaitingWorkspaceStatusOption,
+        params.sessionErrorLine ?? null,
+      );
+      return;
+    }
+
     if (params.missingAgentName) {
       await this.handleMissingAgentDefinition(
         issue,
@@ -229,7 +245,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 +295,12 @@ export class NotifyFinishedIssuePreparationUseCase {
         awaitingWorkspaceStatusOption.id,
       );
       await this.patchConsoleTab(issue);
+      if (repetition.type === 'dispatchAgain') {
+        await this.issueCommentRepository.createComment(
+          issue,
+          repetition.comment,
+        );
+      }
       return;
     }
 
@@ -382,6 +434,32 @@ export class NotifyFinishedIssuePreparationUseCase {
     );
   };
 
+  private handleTransientFailureDeferral = async (
+    issue: Issue,
+    project: Project,
+    awaitingWorkspaceStatusOption: { id: string },
+    sessionErrorLine: string | null,
+  ): Promise<void> => {
+    const tomorrow = issueReactivationTriggerStartOfTomorrow(new Date());
+    await this.issueRepository.updateNextActionDate(
+      issue.url,
+      project,
+      tomorrow,
+    );
+    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,
+      `Preparation deferred due to transient failure; item reactivates from ${tomorrow.toISOString().split('T')[0]}\nSession stop reason: ${sessionErrorLine ?? '(not captured)'}`,
+    );
+  };
+
   private handleMissingAgentDefinition = async (
     issue: Issue,
     project: Project,

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```/,