github-issue-tower-defence-management 2.6.1 → 2.8.0

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

@@ -4,7 +4,7 @@
     <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-CaxYBHiT.js"></script>
+    <script type="module" crossorigin src="/assets/index-DkMqSpkk.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CLHvrafO.css">
   </head>
   <body>

package/src/adapter/entry-points/console/webServer.test.ts

@@ -1187,6 +1187,91 @@ describe('webServer new routes integration', () => {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
+
+  it('routes POST /api/reorderstory to handleReorderStory and calls resolveProjectRepository.updateStoryList', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const updateStoryList = jest.fn().mockResolvedValue([]);
+    const projectWithTwoStories: Project = {
+      ...mock<Project>(),
+      id: 'PVT_1',
+      url: 'https://github.com/orgs/acme-labs/projects/1',
+      status: {
+        name: 'Status',
+        fieldId: 'statusField',
+        statuses: [
+          {
+            id: 'status_aw',
+            name: 'Awaiting workspace',
+            color: 'GRAY',
+            description: '',
+          },
+        ],
+      },
+      story: {
+        name: 'Story',
+        fieldId: 'storyField',
+        databaseId: 1,
+        stories: [
+          {
+            id: 'opt_first',
+            name: 'First story',
+            color: 'BLUE',
+            description: '',
+          },
+          {
+            id: 'opt_second',
+            name: 'Second story',
+            color: 'GREEN',
+            description: '',
+          },
+        ],
+        workflowManagementStory: { id: 'wms', name: 'workflow' },
+      },
+    };
+    const issueRepository = mock<IssueRepository>();
+    const server = await startWebServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'ui-dist'),
+      consoleDataOutputDir: null,
+      inTmuxDataDir: null,
+      dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectNames: [],
+      issueRepository,
+      resolveProject: async (pjcode) =>
+        pjcode === 'acme' ? { pjcode, project: projectWithTwoStories } : null,
+      isPjcodeConfigured: (pjcode) => pjcode === 'acme',
+      resolveProjectRepository: () => ({ updateStoryList }),
+      port: 0,
+    });
+    try {
+      const response = await request(
+        server,
+        'POST',
+        `/api/reorderstory?k=${testToken}`,
+        { pjcode: 'acme', storyOptionId: 'opt_first', direction: 'down' },
+      );
+      expect(response.statusCode).toBe(200);
+      expect(JSON.parse(response.body)).toEqual({ ok: true });
+      expect(updateStoryList).toHaveBeenCalledWith(projectWithTwoStories, [
+        {
+          id: 'opt_second',
+          name: 'Second story',
+          color: 'GREEN',
+          description: '',
+        },
+        {
+          id: 'opt_first',
+          name: 'First story',
+          color: 'BLUE',
+          description: '',
+        },
+      ]);
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
 });
 
 describe('resolveFlatInTmuxFilePath', () => {
@@ -2720,4 +2805,108 @@ describe('webServer GET /api/projects', () => {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
+
+  it('GET /api/features returns { airplaneMode: false } when enableAirplaneMode is absent', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const server = await startWebServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'ui-dist'),
+      consoleDataOutputDir: null,
+      inTmuxDataDir: null,
+      dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectNames: [],
+      port: 0,
+    });
+    try {
+      const response = await request(
+        server,
+        'GET',
+        `/api/features?k=${testToken}`,
+      );
+      expect(response.statusCode).toBe(200);
+      expect(JSON.parse(response.body)).toEqual({ airplaneMode: false });
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('GET /api/features returns { airplaneMode: true } when enableAirplaneMode is true', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const server = await startWebServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'ui-dist'),
+      consoleDataOutputDir: null,
+      inTmuxDataDir: null,
+      dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectNames: [],
+      enableAirplaneMode: true,
+      port: 0,
+    });
+    try {
+      const response = await request(
+        server,
+        'GET',
+        `/api/features?k=${testToken}`,
+      );
+      expect(response.statusCode).toBe(200);
+      expect(JSON.parse(response.body)).toEqual({ airplaneMode: true });
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('GET /api/airplanesync returns 404 when enableAirplaneMode is absent', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const server = await startWebServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'ui-dist'),
+      consoleDataOutputDir: null,
+      inTmuxDataDir: null,
+      dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectNames: [],
+      port: 0,
+    });
+    try {
+      const response = await request(
+        server,
+        'GET',
+        `/api/airplanesync?k=${testToken}`,
+      );
+      expect(response.statusCode).toBe(404);
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('GET /api/airplanesync returns 404 when enableAirplaneMode is false', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const server = await startWebServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'ui-dist'),
+      consoleDataOutputDir: null,
+      inTmuxDataDir: null,
+      dashboardDir: null,
+      dashboardDataDir: null,
+      dashboardProjectNames: [],
+      enableAirplaneMode: false,
+      port: 0,
+    });
+    try {
+      const response = await request(
+        server,
+        'GET',
+        `/api/airplanesync?k=${testToken}`,
+      );
+      expect(response.statusCode).toBe(404);
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
 });

package/src/adapter/entry-points/console/webServer.ts

@@ -20,6 +20,7 @@ import {
   handlePullRequestStatus,
   handleRelatedPrs,
 } from './consoleReadApi';
+import { handleAirplaneSync } from './consoleAirplaneSnapshotApi';
 import {
   ConsoleIssueRepositoryResolver,
   ConsoleOperationContext,
@@ -243,6 +244,7 @@ export type WebServerOptions = {
     ((pjcode: string, updatedProject: Project) => void) | null;
   issueTitleStateCache?: IssueTitleStateCache | null;
   pullRequestStatusCache?: PullRequestStatusCache | null;
+  enableAirplaneMode?: boolean;
 };
 
 const FLAT_IN_TMUX_PREFIX = '/in-tmux-by-human/';
@@ -662,6 +664,42 @@ const handleTokenedRequest = async (
         await handleImageProxy(options, response, searchParams);
         return;
       }
+      if (requestPath === '/api/features') {
+        sendJson(response, 200, {
+          airplaneMode: options.enableAirplaneMode === true,
+        });
+        return;
+      }
+      if (requestPath === '/api/airplanesync') {
+        if (options.enableAirplaneMode !== true) {
+          sendNotFound(response);
+          return;
+        }
+        const issueRepository = options.issueRepository ?? null;
+        const consoleDataOutputDir = options.consoleDataOutputDir ?? null;
+        const issueTitleStateCache = options.issueTitleStateCache ?? null;
+        const pullRequestStatusCache = options.pullRequestStatusCache ?? null;
+        if (
+          issueRepository === null ||
+          consoleDataOutputDir === null ||
+          issueTitleStateCache === null ||
+          pullRequestStatusCache === null
+        ) {
+          sendNotFound(response);
+          return;
+        }
+        await handleAirplaneSync(
+          response,
+          consoleDataOutputDir,
+          issueRepository,
+          issueTitleStateCache,
+          pullRequestStatusCache,
+          options.resolveGithubToken != null
+            ? options.resolveGithubToken('')
+            : null,
+        );
+        return;
+      }
       const readResult = await handleReadApi(
         options,
         requestPath,

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

@@ -74,7 +74,6 @@ import { ProxyRateLimitCacheRepository } from '../../repositories/ProxyRateLimit
 import { UpdateRateLimitCacheUseCase } from '../../../domain/usecases/UpdateRateLimitCacheUseCase';
 import { RevertOrphanedPreparationUseCase } from '../../../domain/usecases/RevertOrphanedPreparationUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from '../../../domain/usecases/RevertNotReadyReviewQueueIssueUseCase';
-import { TriagerApprovalDispatchUseCase } from '../../../domain/usecases/TriagerApprovalDispatchUseCase';
 import { AgentDesignationLabelAdoptUseCase } from '../../../domain/usecases/AgentDesignationLabelAdoptUseCase';
 import { GitHubIssueCommentRepository } from '../../repositories/GitHubIssueCommentRepository';
 import { ProjectRequiredFieldCreateUseCase } from '../../../domain/usecases/ProjectRequiredFieldCreateUseCase';
@@ -528,11 +527,6 @@ export class HandleScheduledEventUseCaseHandler {
         issueRepository,
         issueCommentRepository,
       );
-    const triagerApprovalDispatchUseCase = new TriagerApprovalDispatchUseCase(
-      projectRepository,
-      issueRepository,
-      issueCommentRepository,
-    );
     const agentDesignationLabelAdoptUseCase =
       new AgentDesignationLabelAdoptUseCase(projectRepository, issueRepository);
 
@@ -575,7 +569,6 @@ export class HandleScheduledEventUseCaseHandler {
       revertOrphanedPreparationUseCase,
       conflictedIssueRevertUseCase,
       revertNotReadyReviewQueueIssueUseCase,
-      triagerApprovalDispatchUseCase,
       agentDesignationLabelAdoptUseCase,
       updateRateLimitCacheUseCase,
       dailySecurityScanUseCase,

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

@@ -212,13 +212,13 @@ describe('CheckIssueReviewReadinessUseCase', () => {
       });
     });
 
-    it('should return reviewReady=true when the last report declares pullRequestRequired as false and no related PR exists', async () => {
+    it('should return reviewReady=true when the last report designates the triager and no related PR exists', async () => {
       const issue = createMockIssue();
       mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
       mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
         createMockComment({
           content:
-            'From: :robot: Agent report\n```json\n{"pullRequestRequired": false}\n```',
+            'From: :robot: Agent report\n```json\n{"nextStepAgent": "triager"}\n```',
         }),
       ]);
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
@@ -232,13 +232,35 @@ describe('CheckIssueReviewReadinessUseCase', () => {
       expect(result.reviewReady).toBe(true);
     });
 
-    it('should keep every rejection other than PULL_REQUEST_NOT_FOUND when the last report declares pullRequestRequired as false', async () => {
+    it('should keep rejecting a missing PR when the last report designates an agent other than the triager', async () => {
       const issue = createMockIssue();
       mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
       mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
         createMockComment({
           content:
-            'From: :robot: Agent report\n```json\n{"pullRequestRequired": false}\n```',
+            'From: :robot: Agent report\n```json\n{"nextStepAgent": "developer"}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      const result = await useCase.run({
+        issueUrl: 'https://github.com/user/repo/issues/1',
+      });
+
+      expect(result.reviewReady).toBe(false);
+      expect(result.rejections).toContainEqual({
+        type: 'PULL_REQUEST_NOT_FOUND',
+        detail: 'PULL_REQUEST_NOT_FOUND',
+      });
+    });
+
+    it('should keep every rejection other than PULL_REQUEST_NOT_FOUND when the last report designates the triager', async () => {
+      const issue = createMockIssue();
+      mockIssueRepository.getIssueByUrl.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: Agent report\n```json\n{"nextStepAgent": "triager"}\n```',
         }),
       ]);
       mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([

package/src/domain/usecases/CheckIssueReviewReadinessUseCase.ts

@@ -5,10 +5,11 @@ import {
   PrRejectedReasonType,
 } from './IssueRejectionEvaluator';
 import { resolveLabelsNotRequiringPullRequest } from './resolveLabelsNotRequiringPullRequest';
-import { isPullRequestDeclaredUnnecessary } from './isPullRequestDeclaredUnnecessary';
 import { normalizeReportBody } from './normalizeReportBody';
 import { isAgentReportBody } from './isAgentReportBody';
 import { isAuthorAuthorizedForAutoStatusCheck } from './isAuthorAuthorizedForAutoStatusCheck';
+import { extractNextStepAgentFromComments } from './extractNextStepAgentFromComments';
+import { isTriagerAgentName } from './triagerAgentName';
 
 type RejectedReasonType =
   | 'ISSUE_NOT_FOUND'
@@ -94,10 +95,11 @@ export class CheckIssueReviewReadinessUseCase {
         { developerAgentName: params.developerAgentName },
       );
 
-    const requiredPrRejections = isPullRequestDeclaredUnnecessary(
+    const nextStepAgent = extractNextStepAgentFromComments(
       comments,
       isTrustedAuthor,
-    )
+    );
+    const requiredPrRejections = isTriagerAgentName(nextStepAgent)
       ? prRejections.filter(
           (rejection) => rejection.type !== 'PULL_REQUEST_NOT_FOUND',
         )

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

@@ -25,7 +25,6 @@ import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { ConflictedIssueRevertUseCase } from './ConflictedIssueRevertUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
-import { TriagerApprovalDispatchUseCase } from './TriagerApprovalDispatchUseCase';
 import { AgentDesignationLabelAdoptUseCase } from './AgentDesignationLabelAdoptUseCase';
 import { ProjectRequiredFieldCreateUseCase } from './ProjectRequiredFieldCreateUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
@@ -129,8 +128,6 @@ describe('HandleScheduledEventUseCase', () => {
       mock<ConflictedIssueRevertUseCase>();
     const mockRevertNotReadyReviewQueueIssueUseCase =
       mock<RevertNotReadyReviewQueueIssueUseCase>();
-    const mockTriagerApprovalDispatchUseCase =
-      mock<TriagerApprovalDispatchUseCase>();
     const mockAgentDesignationLabelAdoptUseCase =
       mock<AgentDesignationLabelAdoptUseCase>();
     const mockUpdateRateLimitCacheUseCase = mock<UpdateRateLimitCacheUseCase>();
@@ -165,7 +162,6 @@ describe('HandleScheduledEventUseCase', () => {
       mockRevertOrphanedPreparationUseCase,
       mockConflictedIssueRevertUseCase,
       mockRevertNotReadyReviewQueueIssueUseCase,
-      mockTriagerApprovalDispatchUseCase,
       mockAgentDesignationLabelAdoptUseCase,
       mockUpdateRateLimitCacheUseCase,
       mockDailySecurityScanUseCase,
@@ -282,29 +278,6 @@ describe('HandleScheduledEventUseCase', () => {
       });
     });
 
-    it('should call TriagerApprovalDispatchUseCase with project URL', async () => {
-      const input = {
-        projectName: 'test-project',
-        org: 'test-org',
-        projectUrl: 'https://github.com/test-org/test-project',
-        manager: 'test-manager',
-        workingReport: {
-          repo: 'test-repo',
-          members: ['member1'],
-          spreadsheetUrl: 'https://docs.google.com/spreadsheets/test',
-        },
-        urlOfStoryView: 'https://github.com/test-org/test-project/issues',
-        disabled: false,
-      };
-
-      await useCase.run(input);
-      expect(mockTriagerApprovalDispatchUseCase.run).toHaveBeenCalledWith(
-        expect.objectContaining({
-          projectUrl: 'https://github.com/test-org/test-project',
-        }),
-      );
-    });
-
     it('should return null and skip all processing when disabled is true', async () => {
       const input = {
         projectName: 'test-project',
@@ -1827,7 +1800,6 @@ describe('HandleScheduledEventUseCase', () => {
       mock<RevertOrphanedPreparationUseCase>(),
       mock<ConflictedIssueRevertUseCase>(),
       mock<RevertNotReadyReviewQueueIssueUseCase>(),
-      mock<TriagerApprovalDispatchUseCase>(),
       mock<AgentDesignationLabelAdoptUseCase>(),
       null,
       null,

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -28,7 +28,6 @@ import {
 import { AgentDesignationLabelAdoptUseCase } from './AgentDesignationLabelAdoptUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
-import { TriagerApprovalDispatchUseCase } from './TriagerApprovalDispatchUseCase';
 import { isRecord } from './isRecord';
 import { resolveLabelsAsLlmAgentName } from './resolveLabelsAsLlmAgentName';
 import { resolveAllowedIssueAuthors } from './resolveAllowedIssueAuthors';
@@ -139,7 +138,6 @@ export class HandleScheduledEventUseCase {
     readonly revertOrphanedPreparationUseCase: RevertOrphanedPreparationUseCase,
     readonly conflictedIssueRevertUseCase: ConflictedIssueRevertUseCase,
     readonly revertNotReadyReviewQueueIssueUseCase: RevertNotReadyReviewQueueIssueUseCase,
-    readonly triagerApprovalDispatchUseCase: TriagerApprovalDispatchUseCase,
     readonly agentDesignationLabelAdoptUseCase: AgentDesignationLabelAdoptUseCase,
     readonly updateRateLimitCacheUseCase: UpdateRateLimitCacheUseCase | null,
     readonly dailySecurityScanUseCase: DailySecurityScanUseCase | null,
@@ -452,10 +450,6 @@ ${JSON.stringify(e)}
       allowedIssueAuthors,
       developerAgentName: input.developerAgentName,
     });
-    await this.triagerApprovalDispatchUseCase.run({
-      projectUrl: input.projectUrl,
-      allowedIssueAuthors,
-    });
     if (this.dailySecurityScanUseCase !== null && input.dailySecurityScan) {
       await this.dailySecurityScanUseCase.run({
         targetDates: targetDateTimes,

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

@@ -739,125 +739,6 @@ describe('IssueRejectionEvaluator', () => {
       });
     });
 
-    describe('pullRequestRequired: false in issue body', () => {
-      it('should not reject and not call findRelatedOpenPRs when body ends with JSON block containing pullRequestRequired: false', async () => {
-        const body = '```json\n{"pullRequestRequired": false}\n```';
-
-        const result = await evaluator.evaluate({
-          url: 'https://github.com/user/repo/issues/1',
-          labels: [],
-          isPr: false,
-          body,
-        });
-
-        expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
-        expect(result.rejections).toHaveLength(0);
-        expect(result.approvedPrUrl).toBeNull();
-      });
-
-      it('should not reject even with trailing whitespace after the closing JSON block', async () => {
-        const body = '```json\n{"pullRequestRequired": false}\n```\n  ';
-
-        const result = await evaluator.evaluate({
-          url: 'https://github.com/user/repo/issues/1',
-          labels: [],
-          isPr: false,
-          body,
-        });
-
-        expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
-        expect(result.rejections).toHaveLength(0);
-      });
-
-      it('should still require PR when body has pullRequestRequired: true', async () => {
-        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
-        const body = '```json\n{"pullRequestRequired": true}\n```';
-
-        const result = await evaluator.evaluate({
-          url: 'https://github.com/user/repo/issues/1',
-          labels: [],
-          isPr: false,
-          body,
-        });
-
-        expect(result.rejections).toHaveLength(1);
-        expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
-      });
-
-      it('should still require PR when body is null', async () => {
-        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
-
-        const result = await evaluator.evaluate({
-          url: 'https://github.com/user/repo/issues/1',
-          labels: [],
-          isPr: false,
-          body: null,
-        });
-
-        expect(result.rejections).toHaveLength(1);
-        expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
-      });
-
-      it('should still require PR when body is undefined', async () => {
-        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
-
-        const result = await evaluator.evaluate({
-          url: 'https://github.com/user/repo/issues/1',
-          labels: [],
-          isPr: false,
-        });
-
-        expect(result.rejections).toHaveLength(1);
-        expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
-      });
-
-      it('should still require PR when JSON block with pullRequestRequired: false is not at end of body', async () => {
-        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
-        const body =
-          '```json\n{"pullRequestRequired": false}\n```\n\nsome text after';
-
-        const result = await evaluator.evaluate({
-          url: 'https://github.com/user/repo/issues/1',
-          labels: [],
-          isPr: false,
-          body,
-        });
-
-        expect(result.rejections).toHaveLength(1);
-        expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
-      });
-
-      it('should still require PR when body has invalid JSON in code block', async () => {
-        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
-        const body = '```json\n{invalid json}\n```';
-
-        const result = await evaluator.evaluate({
-          url: 'https://github.com/user/repo/issues/1',
-          labels: [],
-          isPr: false,
-          body,
-        });
-
-        expect(result.rejections).toHaveLength(1);
-        expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
-      });
-
-      it('should still require PR when body has pullRequestRequired not set to false', async () => {
-        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
-        const body = '```json\n{"someOtherField": true}\n```';
-
-        const result = await evaluator.evaluate({
-          url: 'https://github.com/user/repo/issues/1',
-          labels: [],
-          isPr: false,
-          body,
-        });
-
-        expect(result.rejections).toHaveLength(1);
-        expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
-      });
-    });
-
     describe('detectConflictEvenIfEvaluationSkipped option', () => {
       it('should call findRelatedOpenPRs and return PULL_REQUEST_CONFLICTED when relatedOpenPrUrls is null and PR is conflicted', async () => {
         mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([

package/src/domain/usecases/IssueRejectionEvaluator.ts

@@ -2,7 +2,6 @@ import {
   IssueRepository,
   RelatedPullRequest,
 } from './adapter-interfaces/IssueRepository';
-import { normalizeReportBody } from './normalizeReportBody';
 
 export type PrRejectedReasonType =
   | 'PULL_REQUEST_NOT_FOUND'
@@ -243,7 +242,6 @@ export class IssueRejectionEvaluator {
     return (
       !isNonDeveloperAgent &&
       !hasLabelNotRequiringPullRequest &&
-      this.isPullRequestRequiredByBody(issue.body) &&
       (categoryLabels.length <= 0 || categoryLabels.includes('category:e2e'))
     );
   };
@@ -337,23 +335,4 @@ export class IssueRejectionEvaluator {
     targetPath: string,
   ): boolean =>
     filePath === targetPath || filePath.startsWith(`${targetPath}/`);
-
-  private isPullRequestRequiredByBody = (
-    body: string | null | undefined,
-  ): boolean => {
-    if (!body) return true;
-    const match = normalizeReportBody(body)
-      .trimEnd()
-      .match(/```json\n([\s\S]*?)\n```\s*$/);
-    if (!match || !match[1]) return true;
-    let config: unknown;
-    try {
-      config = JSON.parse(match[1]);
-    } catch {
-      return true;
-    }
-    if (typeof config !== 'object' || config === null) return true;
-    if (!('pullRequestRequired' in config)) return true;
-    return Reflect.get(config, 'pullRequestRequired') !== false;
-  };
 }