github-issue-tower-defence-management 1.188.0 → 1.189.0

package/src/adapter/entry-points/console/ui-dist/index.html

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-CA6c7Pfz.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-D1xvwesF.css">
+    <script type="module" crossorigin src="/assets/index-CZ1NNzIm.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CLHvrafO.css">
   </head>
   <body>
     <div id="root"></div>

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts

@@ -301,6 +301,8 @@ export class HandleScheduledEventUseCaseHandler {
         input.claudeCodeOauthTokenListJsonPath,
       thresholdForAutoReject:
         readmeConfig.thresholdForAutoReject ?? input.thresholdForAutoReject,
+      thresholdForDispatchLoop:
+        readmeConfig.thresholdForDispatchLoop ?? input.thresholdForDispatchLoop,
       developerAgentName:
         readmeConfig.developerAgentName ?? input.developerAgentName ?? null,
       startPreparation: input.startPreparation

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -188,6 +188,7 @@ export class HandleScheduledEventUseCase {
       labelsAsLlmAgentName?: string[] | null;
     } | null;
     thresholdForAutoReject?: number;
+    thresholdForDispatchLoop?: number;
     createTaskFromStoryBodyCheckboxEnabled?: boolean;
     queryToAddProjectEnabled?: boolean;
     queryToAddProject?: string | null;
@@ -468,6 +469,7 @@ ${JSON.stringify(e)}
           preparationProcessCheckCommand:
             input.startPreparation.preparationProcessCheckCommand,
           thresholdForAutoReject: input.thresholdForAutoReject ?? 3,
+          thresholdForDispatchLoop: input.thresholdForDispatchLoop,
           awLogDirectoryPath: input.startPreparation.awLogDirectoryPath,
           awLogStaleThresholdMinutes:
             input.startPreparation.awLogStaleThresholdMinutes,

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

@@ -1079,6 +1079,104 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     );
   });
 
+  it('should escalate to Failed Preparation when two agents keep naming each other and each one reports every round', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      agent: 'systems-analyst',
+    });
+    const namesReviewer = createMockComment({
+      content:
+        'From: :robot: systems-analyst\n```json\n{"nextStepAgent": "system-design-reviewer"}\n```',
+    });
+    const namesAnalyst = createMockComment({
+      content:
+        'From: :robot: system-design-reviewer\n```json\n{"nextStepAgent": "systems-analyst"}\n```',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      namesReviewer,
+      namesAnalyst,
+      namesReviewer,
+      namesAnalyst,
+      namesReviewer,
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      thresholdForDispatchLoop: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      expect.anything(),
+      'failed-preparation-id',
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining(
+        'dispatched 3 times since the last human comment',
+      ),
+    );
+  });
+
+  it('should keep dispatching when a human comment separates the repeated dispatches', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      agent: 'systems-analyst',
+    });
+    const namesReviewer = createMockComment({
+      content:
+        'From: :robot: systems-analyst\n```json\n{"nextStepAgent": "system-design-reviewer"}\n```',
+    });
+    const namesAnalyst = createMockComment({
+      content:
+        'From: :robot: system-design-reviewer\n```json\n{"nextStepAgent": "systems-analyst"}\n```',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      namesReviewer,
+      namesAnalyst,
+      createMockComment({ content: 'Please take the second option.' }),
+      namesReviewer,
+      namesAnalyst,
+      namesReviewer,
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      thresholdForDispatchLoop: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalledWith(
+      mockProject,
+      expect.anything(),
+      'failed-preparation-id',
+    );
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      expect.anything(),
+      'awaiting-workspace-id',
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining('(2/3)'),
+    );
+  });
+
   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

@@ -35,7 +35,10 @@ import {
   issueReactivationTriggerStartOfTomorrow,
 } from './issueReactivationTriggerIsPending';
 import { normalizeReportBody } from './normalizeReportBody';
-import { resolveNextStepAgentDispatchRepetition } from './resolveNextStepAgentDispatchRepetition';
+import {
+  DEFAULT_THRESHOLD_FOR_DISPATCH_LOOP,
+  resolveNextStepAgentDispatchRepetition,
+} from './resolveNextStepAgentDispatchRepetition';
 
 export class IssueNotFoundError extends Error {
   constructor(issueUrl: string) {
@@ -106,6 +109,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     projectUrl: string;
     issueUrl: string;
     thresholdForAutoReject: number;
+    thresholdForDispatchLoop?: number;
     workflowBlockerResolvedWebhookUrl: string | null;
     allowedIssueAuthors?: string[] | null;
     labelsAsLlmAgentName?: string[] | null;
@@ -246,16 +250,16 @@ 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,
+        comments,
         isTrustedAuthor,
         thresholdForAutoReject: params.thresholdForAutoReject,
+        thresholdForDispatchLoop:
+          params.thresholdForDispatchLoop ??
+          DEFAULT_THRESHOLD_FOR_DISPATCH_LOOP,
       });
       if (repetition.type === 'escalateToFailedPreparation') {
         issue.status = FAILED_PREPARATION_STATUS_NAME;

package/src/domain/usecases/RevertOrphanedPreparationUseCase.ts

@@ -27,7 +27,10 @@ import { findLastAgentReport } from './findLastAgentReport';
 import { isAgentReportBody } from './isAgentReportBody';
 import { ensureAgentOptionAndGetId } from './ensureAgentOptionAndGetId';
 import { normalizeReportBody } from './normalizeReportBody';
-import { resolveNextStepAgentDispatchRepetition } from './resolveNextStepAgentDispatchRepetition';
+import {
+  DEFAULT_THRESHOLD_FOR_DISPATCH_LOOP,
+  resolveNextStepAgentDispatchRepetition,
+} from './resolveNextStepAgentDispatchRepetition';
 
 const ORPHANED_PREPARATION_REJECTION_DETAIL = 'ORPHANED_PREPARATION';
 
@@ -64,6 +67,7 @@ export class RevertOrphanedPreparationUseCase {
     projectUrl: string;
     preparationProcessCheckCommand: string;
     thresholdForAutoReject: number;
+    thresholdForDispatchLoop?: number;
     awLogDirectoryPath?: string;
     awLogStaleThresholdMinutes?: number;
     awaitingQualityCheckStatus?: string | null;
@@ -136,15 +140,16 @@ export class RevertOrphanedPreparationUseCase {
         const repetition = resolveNextStepAgentDispatchRepetition({
           agentFieldValue: issue.agent,
           nextStepAgent,
-          commentsAfterLastAgentReport: lastAgentReport
-            ? comments.slice(comments.indexOf(lastAgentReport) + 1)
-            : [],
+          comments,
           isTrustedAuthor: (author) =>
             isAuthorAuthorizedForAutoStatusCheck(
               author,
               params.allowedIssueAuthors,
             ),
           thresholdForAutoReject: params.thresholdForAutoReject,
+          thresholdForDispatchLoop:
+            params.thresholdForDispatchLoop ??
+            DEFAULT_THRESHOLD_FOR_DISPATCH_LOOP,
         });
         if (
           repetition.type === 'escalateToFailedPreparation' &&

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

@@ -838,6 +838,94 @@ describe('TriagerApprovalDispatchUseCase', () => {
       );
     });
 
+    it('should skip a candidate issue when getCommentsFromIssue throws and continue processing the remaining issues', async () => {
+      const failingIssue = createMockIssue({
+        number: 1,
+        url: 'https://github.com/owner/repo/issues/1',
+        itemId: 'item-1',
+        status: 'Awaiting Quality Check',
+        author: 'owner-user',
+        createdAt: new Date('2000-01-01T00:00:00Z'),
+      });
+      const successIssue = createMockIssue({
+        number: 2,
+        url: 'https://github.com/owner/repo/issues/2',
+        itemId: 'item-2',
+        status: 'Awaiting Quality Check',
+        author: 'owner-user',
+        createdAt: new Date('2000-01-02T00:00:00Z'),
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [failingIssue, successIssue],
+        cacheUsed: false,
+      });
+      mockIssueCommentRepository.getCommentsFromIssue.mockImplementation(
+        async (issue) => {
+          if (issue.number === 1) {
+            throw new Error(
+              'Failed to fetch comments from GitHub REST API: 404 ',
+            );
+          }
+          return [
+            createComment(
+              'bot',
+              TRIAGER_PROPOSAL_COMMENT(
+                'developer',
+                'regular / workflow improvement',
+                false,
+              ),
+            ),
+            createComment('owner-user', 'ok'),
+          ];
+        },
+      );
+
+      await useCase.run({
+        projectUrl: 'https://github.com/orgs/owner/projects/1',
+        allowedIssueAuthors: ['owner-user'],
+      });
+
+      expect(
+        mockIssueCommentRepository.getCommentsFromIssue,
+      ).toHaveBeenCalledTimes(2);
+      expect(mockIssueRepository.setIssueAgentField).toHaveBeenCalledTimes(1);
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        successIssue,
+        'awaiting-workspace-id',
+      );
+    });
+
+    it('should propagate non-404 errors from getCommentsFromIssue', async () => {
+      const issue = createMockIssue({
+        number: 1,
+        url: 'https://github.com/owner/repo/issues/1',
+        itemId: 'item-1',
+        status: 'Awaiting Quality Check',
+        author: 'owner-user',
+        createdAt: new Date('2000-01-01T00:00:00Z'),
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue],
+        cacheUsed: false,
+      });
+      const authError = new Error(
+        'Failed to fetch comments from GitHub REST API: 401 Unauthorized',
+      );
+      mockIssueCommentRepository.getCommentsFromIssue.mockRejectedValue(
+        authError,
+      );
+
+      await expect(
+        useCase.run({
+          projectUrl: 'https://github.com/orgs/owner/projects/1',
+          allowedIssueAuthors: ['owner-user'],
+        }),
+      ).rejects.toThrow(authError);
+    });
+
     it('should use the last triager proposal when multiple proposals exist', async () => {
       const issue = createMockIssue({
         status: 'Awaiting Quality Check',

package/src/domain/usecases/TriagerApprovalDispatchUseCase.ts

@@ -1,6 +1,7 @@
 import { IssueCommentRepository } from './adapter-interfaces/IssueCommentRepository';
 import { IssueRepository } from './adapter-interfaces/IssueRepository';
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { Comment } from '../entities/Comment';
 import {
   isAgentReportBody,
   isAgentReportBodyFromAgent,
@@ -68,6 +69,9 @@ const parseTriagerProposalBlock = (
   return null;
 };
 
+const isNotFoundError = (error: unknown): boolean =>
+  (error instanceof Error ? error.message : String(error)).includes('404');
+
 const isApprovalComment = (
   content: string,
   author: string,
@@ -160,8 +164,19 @@ export class TriagerApprovalDispatchUseCase {
       const issue =
         candidateIssues[(windowStart + slot) % candidateIssues.length];
 
-      const comments =
-        await this.issueCommentRepository.getCommentsFromIssue(issue);
+      let comments: Comment[];
+      try {
+        comments =
+          await this.issueCommentRepository.getCommentsFromIssue(issue);
+      } catch (error) {
+        if (!isNotFoundError(error)) {
+          throw error;
+        }
+        console.warn(
+          `[TriagerApprovalDispatch] Failed to fetch comments, skipping issue for this cycle. issueUrl: ${issue.url} error: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        continue;
+      }
 
       let firstProposalIndex = -1;
       let proposal: TriagerProposal | null = null;

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

@@ -0,0 +1,90 @@
+import { AUTO_STATUS_CHECK_MESSAGE_HEAD } from './autoStatusCheckComments';
+import { isHumanComment } from './isHumanComment';
+import { NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD } from './nextStepAgentDispatchRepeatedMessage';
+import { RETURNED_TO_AWAITING_WORKSPACE_MESSAGE_HEAD } from './returnedToAwaitingWorkspaceMessage';
+
+const trustAll = (): boolean => true;
+
+describe('isHumanComment', () => {
+  it('treats a plain comment from a trusted author as human input', () => {
+    expect(
+      isHumanComment(
+        { author: 'bot', content: 'Please use the second option.' },
+        trustAll,
+      ),
+    ).toBe(true);
+  });
+
+  it('treats an agent report as machine generated', () => {
+    expect(
+      isHumanComment(
+        {
+          author: 'bot',
+          content: 'From: :robot: agent (model)\n\nReport body.',
+        },
+        trustAll,
+      ),
+    ).toBe(false);
+  });
+
+  it('treats an agent report whose leading fenced block precedes the prefix as machine generated', () => {
+    expect(
+      isHumanComment(
+        {
+          author: 'bot',
+          content:
+            '```json\n{ "nextStepAgent": "developer" }\n```\n\nFrom: :robot: agent (model)\n\nReport body.',
+        },
+        trustAll,
+      ),
+    ).toBe(false);
+  });
+
+  it('treats the dispatch repetition comment as machine generated', () => {
+    expect(
+      isHumanComment(
+        {
+          author: 'bot',
+          content: `${NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD} developer\n\nDispatching it again.`,
+        },
+        trustAll,
+      ),
+    ).toBe(false);
+  });
+
+  it('treats an auto status check comment as machine generated', () => {
+    expect(
+      isHumanComment(
+        {
+          author: 'bot',
+          content: `${AUTO_STATUS_CHECK_MESSAGE_HEAD} PULL_REQUEST_NOT_FOUND`,
+        },
+        trustAll,
+      ),
+    ).toBe(false);
+  });
+
+  it('treats the returned to awaiting workspace comment as machine generated', () => {
+    expect(
+      isHumanComment(
+        {
+          author: 'bot',
+          content: `${RETURNED_TO_AWAITING_WORKSPACE_MESSAGE_HEAD}\nThe last report declared that this task needs no pull request.`,
+        },
+        trustAll,
+      ),
+    ).toBe(false);
+  });
+
+  it('treats any comment from an untrusted author as human input', () => {
+    expect(
+      isHumanComment(
+        {
+          author: 'stranger',
+          content: 'From: :robot: agent (model)\n\nImpersonated report.',
+        },
+        (author: string): boolean => author === 'bot',
+      ),
+    ).toBe(true);
+  });
+});

package/src/domain/usecases/isHumanComment.ts

@@ -0,0 +1,23 @@
+import { AUTO_STATUS_CHECK_MESSAGE_HEAD } from './autoStatusCheckComments';
+import { isAgentReportBody } from './isAgentReportBody';
+import { NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD } from './nextStepAgentDispatchRepeatedMessage';
+
+const MACHINE_GENERATED_COMMENT_HEADS = [
+  AUTO_STATUS_CHECK_MESSAGE_HEAD,
+  NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD,
+];
+
+export const isHumanComment = (
+  comment: { author: string; content: string },
+  isTrustedAuthor: (author: string) => boolean,
+): boolean => {
+  if (!isTrustedAuthor(comment.author)) {
+    return true;
+  }
+  if (isAgentReportBody(comment.content)) {
+    return false;
+  }
+  return !MACHINE_GENERATED_COMMENT_HEADS.some((head) =>
+    comment.content.startsWith(head),
+  );
+};

package/src/domain/usecases/nextStepAgentDispatchRepeatedMessage.ts

@@ -0,0 +1,2 @@
+export const NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD =
+  'Next step agent dispatch repeated:';