github-issue-tower-defence-management 1.194.1 → 1.195.0

package/src/adapter/repositories/ProxyClaudeTokenUsageRepository.test.ts

@@ -76,6 +76,31 @@ describe('ProxyClaudeTokenUsageRepository', () => {
     const pastReset = Math.floor(Date.now() / 1000) - 3600;
     const observedAfterReset = Math.floor(Date.now() / 1000) - 60;
 
+    it('should leave out a token whose subscription the proxy has flagged as disabled', async () => {
+      mockLoadTokenEntries.mockReturnValue([
+        { name: 'alice', token: 'token-a' },
+        { name: 'disabled-one', token: 'token-disabled' },
+      ]);
+      mockReadRateLimit.mockImplementation((token: string) => ({
+        fiveHourUtilization: 0,
+        fiveHourReset: futureReset,
+        sevenDayUtilization: 0,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: false,
+        unifiedRejected: false,
+        fiveHourRejected: false,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {},
+        subscriptionDisabled: token === 'token-disabled',
+      }));
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result.map((usage) => usage.token)).toEqual(['token-a']);
+    });
+
     it('should map each token to its cached utilization and include name', async () => {
       mockLoadTokenEntries.mockReturnValue([
         { name: 'alice', token: 'token-a' },

package/src/adapter/repositories/ProxyClaudeTokenUsageRepository.ts

@@ -27,88 +27,97 @@ export class ProxyClaudeTokenUsageRepository implements ClaudeTokenUsageReposito
       return [];
     }
     const nowEpochSeconds = Date.now() / 1000;
-    return entries.map(({ name, token, selectionWeight }) => {
-      const snapshot = readRateLimit(token);
-      if (snapshot === null) {
+    const usages = entries.map(
+      ({ name, token, selectionWeight }): ClaudeTokenUsage | null => {
+        const snapshot = readRateLimit(token);
+        if (snapshot !== null && snapshot.subscriptionDisabled) {
+          console.error(
+            `Claude subscription access is disabled for token '${name}'; leaving it out of the preparation concurrency allocation.`,
+          );
+          return null;
+        }
+        if (snapshot === null) {
+          return {
+            name,
+            token,
+            fiveHourUtilization: 0,
+            sevenDayUtilization: 0,
+            blocked: false,
+            rejected: false,
+            fiveHourRejected: false,
+            modelWeeklyLimits: {},
+            blockedUntilEpoch: 0,
+            selectionWeight,
+          };
+        }
+        const fiveHourExpired =
+          nowEpochSeconds > snapshot.fiveHourReset &&
+          snapshot.lastUpdatedEpoch >= snapshot.fiveHourReset;
+        const sevenDayExpired =
+          nowEpochSeconds > snapshot.sevenDayReset &&
+          snapshot.lastUpdatedEpoch >= snapshot.sevenDayReset;
+        const fiveHourUtilization = fiveHourExpired
+          ? 0
+          : snapshot.fiveHourUtilization;
+        const sevenDayUtilization = sevenDayExpired
+          ? 0
+          : snapshot.sevenDayUtilization;
+        const fiveHourRejectionActive =
+          snapshot.fiveHourRejected && !fiveHourExpired;
+        const sevenDayRejectionActive =
+          snapshot.sevenDayRejected && !sevenDayExpired;
+        const unifiedRejectionActive =
+          snapshot.unifiedRejected && !fiveHourExpired;
+        const rejected =
+          unifiedRejectionActive ||
+          fiveHourRejectionActive ||
+          sevenDayRejectionActive;
+        const modelWeeklyLimits: Record<
+          string,
+          { rejected: boolean; resetsAt: number }
+        > = {};
+        for (const [limitType, limit] of Object.entries(
+          snapshot.modelWeeklyLimits,
+        )) {
+          const expired = nowEpochSeconds > limit.resetsAt;
+          modelWeeklyLimits[limitType] = {
+            rejected: limit.rejected && !expired,
+            resetsAt: limit.resetsAt,
+          };
+        }
+        const hasAnySevenDayWeeklyLimit =
+          modelWeeklyLimits['seven_day'] !== undefined ||
+          modelWeeklyLimits['seven_day_opus'] !== undefined ||
+          modelWeeklyLimits['seven_day_sonnet'] !== undefined;
+        const needsGenericSevenDayBridge =
+          modelWeeklyLimits['seven_day'] === undefined &&
+          (!hasAnySevenDayWeeklyLimit || sevenDayRejectionActive);
+        if (
+          snapshot.sevenDayReset > 0 &&
+          !sevenDayExpired &&
+          needsGenericSevenDayBridge
+        ) {
+          modelWeeklyLimits['seven_day'] = {
+            rejected: sevenDayRejectionActive,
+            resetsAt: snapshot.sevenDayReset,
+          };
+        }
+        const cooldownActive = snapshot.blockedUntilEpoch > nowEpochSeconds;
         return {
           name,
           token,
-          fiveHourUtilization: 0,
-          sevenDayUtilization: 0,
-          blocked: false,
-          rejected: false,
-          fiveHourRejected: false,
-          modelWeeklyLimits: {},
-          blockedUntilEpoch: 0,
+          fiveHourUtilization,
+          sevenDayUtilization,
+          blocked: snapshot.blocked,
+          rejected,
+          fiveHourRejected: fiveHourRejectionActive,
+          modelWeeklyLimits,
+          blockedUntilEpoch: cooldownActive ? snapshot.blockedUntilEpoch : 0,
           selectionWeight,
         };
-      }
-      const fiveHourExpired =
-        nowEpochSeconds > snapshot.fiveHourReset &&
-        snapshot.lastUpdatedEpoch >= snapshot.fiveHourReset;
-      const sevenDayExpired =
-        nowEpochSeconds > snapshot.sevenDayReset &&
-        snapshot.lastUpdatedEpoch >= snapshot.sevenDayReset;
-      const fiveHourUtilization = fiveHourExpired
-        ? 0
-        : snapshot.fiveHourUtilization;
-      const sevenDayUtilization = sevenDayExpired
-        ? 0
-        : snapshot.sevenDayUtilization;
-      const fiveHourRejectionActive =
-        snapshot.fiveHourRejected && !fiveHourExpired;
-      const sevenDayRejectionActive =
-        snapshot.sevenDayRejected && !sevenDayExpired;
-      const unifiedRejectionActive =
-        snapshot.unifiedRejected && !fiveHourExpired;
-      const rejected =
-        unifiedRejectionActive ||
-        fiveHourRejectionActive ||
-        sevenDayRejectionActive;
-      const modelWeeklyLimits: Record<
-        string,
-        { rejected: boolean; resetsAt: number }
-      > = {};
-      for (const [limitType, limit] of Object.entries(
-        snapshot.modelWeeklyLimits,
-      )) {
-        const expired = nowEpochSeconds > limit.resetsAt;
-        modelWeeklyLimits[limitType] = {
-          rejected: limit.rejected && !expired,
-          resetsAt: limit.resetsAt,
-        };
-      }
-      const hasAnySevenDayWeeklyLimit =
-        modelWeeklyLimits['seven_day'] !== undefined ||
-        modelWeeklyLimits['seven_day_opus'] !== undefined ||
-        modelWeeklyLimits['seven_day_sonnet'] !== undefined;
-      const needsGenericSevenDayBridge =
-        modelWeeklyLimits['seven_day'] === undefined &&
-        (!hasAnySevenDayWeeklyLimit || sevenDayRejectionActive);
-      if (
-        snapshot.sevenDayReset > 0 &&
-        !sevenDayExpired &&
-        needsGenericSevenDayBridge
-      ) {
-        modelWeeklyLimits['seven_day'] = {
-          rejected: sevenDayRejectionActive,
-          resetsAt: snapshot.sevenDayReset,
-        };
-      }
-      const cooldownActive = snapshot.blockedUntilEpoch > nowEpochSeconds;
-      return {
-        name,
-        token,
-        fiveHourUtilization,
-        sevenDayUtilization,
-        blocked: snapshot.blocked,
-        rejected,
-        fiveHourRejected: fiveHourRejectionActive,
-        modelWeeklyLimits,
-        blockedUntilEpoch: cooldownActive ? snapshot.blockedUntilEpoch : 0,
-        selectionWeight,
-      };
-    });
+      },
+    );
+    return usages.filter((usage): usage is ClaudeTokenUsage => usage !== null);
   };
 
   getTokenInFlightCounts = async (): Promise<Record<string, number>> => {

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

@@ -4825,4 +4825,350 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       );
     });
   });
+
+  describe('non-developer agent CI failure reassignment', () => {
+    const makeProjectWithDeveloper = (developerName = 'developer') =>
+      createMockProject({
+        dependedIssueUrlSeparatedByComma: {
+          name: 'Depended Issue URL',
+          fieldId: 'depended-field-id',
+        },
+        agent: {
+          name: 'Agent',
+          fieldId: 'agent-field-id',
+          options: [
+            {
+              id: 'opt-developer',
+              name: developerName,
+              color: 'GRAY',
+              description: '',
+            },
+          ],
+        },
+      });
+
+    it('should return issue to Awaiting Workspace and reassign to developer when chore agent has exactly one linked PR with failing CI', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+        agent: 'chore',
+      });
+      const projectWithDeveloper = makeProjectWithDeveloper();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithDeveloper);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/99',
+          isConflicted: false,
+          isPassedAllCiJob: false,
+          isCiStateSuccess: false,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      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.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        projectWithDeveloper,
+      );
+      expect(mockIssueRepository.setIssueAgentField).toHaveBeenCalledWith(
+        'https://github.com/user/repo/issues/1',
+        projectWithDeveloper,
+        'opt-developer',
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        expect.objectContaining({
+          url: 'https://github.com/user/repo/issues/1',
+        }),
+        expect.stringContaining('ANY_CI_JOB_FAILED_OR_IN_PROGRESS'),
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        expect.objectContaining({
+          url: 'https://github.com/user/repo/issues/1',
+        }),
+        expect.stringContaining('https://github.com/user/repo/pull/99'),
+      );
+    });
+
+    it('should advance to Awaiting Quality Check when chore agent has exactly one linked PR where all CI passes', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+        agent: 'chore',
+      });
+      const projectWithDeveloper = makeProjectWithDeveloper();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithDeveloper);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/99',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      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.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Quality Check' }),
+        projectWithDeveloper,
+      );
+      expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
+    });
+
+    it('should not trigger reassignment when chore agent has no linked PRs', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+        agent: 'chore',
+      });
+      const projectWithDeveloper = makeProjectWithDeveloper();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithDeveloper);
+      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: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
+      expect(mockIssueRepository.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Quality Check' }),
+        projectWithDeveloper,
+      );
+    });
+
+    it('should not trigger the new path when developer agent has a failing CI PR', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+        agent: 'developer',
+      });
+      const projectWithDeveloper = makeProjectWithDeveloper();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithDeveloper);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/99',
+          isConflicted: false,
+          isPassedAllCiJob: false,
+          isCiStateSuccess: false,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      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.update).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'Awaiting Workspace' }),
+        projectWithDeveloper,
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        expect.objectContaining({
+          url: 'https://github.com/user/repo/issues/1',
+        }),
+        expect.stringContaining('ANY_CI_JOB_FAILED_OR_IN_PROGRESS'),
+      );
+    });
+
+    it('should reassign to the configured developerAgentName when chore agent has a failing CI PR', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+        agent: 'chore',
+      });
+      const projectWithCustomDeveloper =
+        makeProjectWithDeveloper('custom-developer');
+      mockProjectRepository.getByUrl.mockResolvedValue(
+        projectWithCustomDeveloper,
+      );
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/99',
+          isConflicted: false,
+          isPassedAllCiJob: false,
+          isCiStateSuccess: false,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      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,
+        developerAgentName: 'custom-developer',
+      });
+
+      expect(mockIssueRepository.setIssueAgentField).toHaveBeenCalledWith(
+        'https://github.com/user/repo/issues/1',
+        projectWithCustomDeveloper,
+        'opt-developer',
+      );
+    });
+
+    it('should not trigger the new path when agent is null', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+        agent: null,
+      });
+      const projectWithDeveloper = makeProjectWithDeveloper();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithDeveloper);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/99',
+          isConflicted: false,
+          isPassedAllCiJob: false,
+          isCiStateSuccess: false,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      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.setIssueAgentField).not.toHaveBeenCalled();
+    });
+
+    it('should not trigger the new path when agent is pr-reviewer', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+        agent: 'pr-reviewer',
+      });
+      const projectWithDeveloper = makeProjectWithDeveloper();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithDeveloper);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/99',
+          isConflicted: false,
+          isPassedAllCiJob: false,
+          isCiStateSuccess: false,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      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.setIssueAgentField).not.toHaveBeenCalled();
+    });
+
+    it('should not trigger the new path when chore agent has two failing CI linked PRs', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+        agent: 'chore',
+      });
+      const projectWithDeveloper = makeProjectWithDeveloper();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithDeveloper);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: Test report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/99',
+          isConflicted: false,
+          isPassedAllCiJob: false,
+          isCiStateSuccess: false,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+        {
+          url: 'https://github.com/user/repo/pull/100',
+          isConflicted: false,
+          isPassedAllCiJob: false,
+          isCiStateSuccess: false,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      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.setIssueAgentField).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -373,6 +373,44 @@ export class NotifyFinishedIssuePreparationUseCase {
       return;
     }
 
+    const ciFailingPrUrl = await this.resolveLinkedPrWithCiFailure(
+      issue,
+      params.developerAgentName ?? null,
+    );
+    if (ciFailingPrUrl !== null) {
+      const effectiveDeveloperAgentName =
+        params.developerAgentName ?? 'developer';
+      const agentOptionId = await this.ensureAgentOptionAndGetId(
+        project,
+        effectiveDeveloperAgentName,
+      );
+      if (agentOptionId !== null) {
+        await this.issueRepository.setIssueAgentField(
+          params.issueUrl,
+          project,
+          agentOptionId,
+        );
+      }
+      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.setDependedIssueUrlForAllOpenPRs(
+        issue,
+        params.issueUrl,
+        project,
+      );
+      await this.issueCommentRepository.createComment(
+        issue,
+        `Auto Status Check: REJECTED\n- ANY_CI_JOB_FAILED_OR_IN_PROGRESS: ${ciFailingPrUrl}`,
+      );
+      return;
+    }
+
     const { rejections, approvedPrUrl } = await this.collectRejections(
       issue,
       comments,
@@ -710,6 +748,32 @@ export class NotifyFinishedIssuePreparationUseCase {
     }
   };
 
+  private resolveLinkedPrWithCiFailure = async (
+    issue: { url: string; agent: string | null; isPr: boolean },
+    developerAgentName: string | null,
+  ): Promise<string | null> => {
+    const effectiveDeveloperName = developerAgentName ?? 'developer';
+    if (
+      issue.agent === null ||
+      issue.agent === effectiveDeveloperName ||
+      issue.agent === 'pr-reviewer'
+    ) {
+      return null;
+    }
+    let openPrs: { url: string; isPassedAllCiJob: boolean }[];
+    if (issue.isPr) {
+      const pr = await this.issueRepository.getOpenPullRequest(issue.url);
+      openPrs = pr === null ? [] : [pr];
+    } else {
+      openPrs = await this.issueRepository.findRelatedOpenPRs(issue.url);
+    }
+    if (openPrs.length !== 1) {
+      return null;
+    }
+    const pr = openPrs[0];
+    return !pr.isPassedAllCiJob ? pr.url : null;
+  };
+
   private resolveOpenPrsForPrItem = async (
     prUrl: string,
   ): Promise<{ url: string }[]> => {