github-issue-tower-defence-management 1.194.2 → 1.196.0

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 }[]> => {

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

@@ -1,4 +1,5 @@
 import {
+  CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
   OauthTokenCandidate,
   OauthTokenSelectUseCase,
   OauthTokenWindowSnapshot,
@@ -550,3 +551,101 @@ describe('sevenDayUrgencyFactor', () => {
     expect(almostReset).toBe(SEVEN_DAY_WINDOW_HOURS);
   });
 });
+
+describe('OauthTokenSelectUseCase with CL script thresholds', () => {
+  const useCase = new OauthTokenSelectUseCase();
+
+  it('excludes a token whose 5h window is less than 60% free when using CL script thresholds', () => {
+    const result = useCase.run(
+      [
+        candidate('busy5h', snapshot({ fiveHourUtilization: 0.41 })),
+        candidate('ok', snapshot({ fiveHourUtilization: 0.4 })),
+      ],
+      NOW,
+      Math.random,
+      CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
+    );
+
+    expect(result.selected?.name).toBe('ok');
+    const busy = result.metrics.find((m) => m.name === 'busy5h');
+    expect(busy?.eligible).toBe(false);
+    expect(busy?.exclusionReason).toContain('5h window');
+  });
+
+  it('treats exactly 40% used 5h utilization as eligible under CL script thresholds (boundary)', () => {
+    const result = useCase.run(
+      [candidate('boundary', snapshot({ fiveHourUtilization: 0.4 }))],
+      NOW,
+      Math.random,
+      CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
+    );
+
+    expect(result.selected?.name).toBe('boundary');
+    const boundary = result.metrics.find((m) => m.name === 'boundary');
+    expect(boundary?.fiveHourFreeRatio).toBeCloseTo(0.6, 9);
+  });
+
+  it('excludes a token whose 7d window is less than 14% free when using CL script thresholds', () => {
+    const result = useCase.run(
+      [
+        candidate('busy7d', snapshot({ sevenDayUtilization: 0.87 })),
+        candidate('ok', snapshot({ sevenDayUtilization: 0.86 })),
+      ],
+      NOW,
+      Math.random,
+      CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
+    );
+
+    expect(result.selected?.name).toBe('ok');
+    const busy = result.metrics.find((m) => m.name === 'busy7d');
+    expect(busy?.eligible).toBe(false);
+    expect(busy?.exclusionReason).toContain('7d window');
+  });
+
+  it('treats exactly 86% used 7d utilization as eligible under CL script thresholds (boundary)', () => {
+    const result = useCase.run(
+      [candidate('boundary', snapshot({ sevenDayUtilization: 0.86 }))],
+      NOW,
+      Math.random,
+      CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
+    );
+
+    expect(result.selected?.name).toBe('boundary');
+    const boundary = result.metrics.find((m) => m.name === 'boundary');
+    expect(boundary?.sevenDayFreeRatio).toBeCloseTo(0.14, 9);
+  });
+
+  it('returns null when only a token with 59% 5h free is available under CL script thresholds', () => {
+    const result = useCase.run(
+      [candidate('marginal', snapshot({ fiveHourUtilization: 0.41 }))],
+      NOW,
+      Math.random,
+      CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
+    );
+
+    expect(result.selected).toBeNull();
+  });
+
+  it('returns null when only a token with 13% 7d free is available under CL script thresholds', () => {
+    const result = useCase.run(
+      [candidate('marginal', snapshot({ sevenDayUtilization: 0.87 }))],
+      NOW,
+      Math.random,
+      CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
+    );
+
+    expect(result.selected).toBeNull();
+  });
+
+  it('includes the correct threshold percentages in the exclusion reason message', () => {
+    const result = useCase.run(
+      [candidate('low5h', snapshot({ fiveHourUtilization: 0.5 }))],
+      NOW,
+      Math.random,
+      CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
+    );
+
+    const low5h = result.metrics.find((m) => m.name === 'low5h');
+    expect(low5h?.exclusionReason).toContain('60%');
+  });
+});

package/src/domain/usecases/OauthTokenSelectUseCase.ts

@@ -39,12 +39,29 @@ export type OauthTokenSelectResult = {
   metrics: OauthTokenCandidateMetrics[];
 };
 
+export type OauthTokenSelectionThresholds = {
+  fiveHourMinFreeRatio: number;
+  sevenDayMinFreeRatio: number;
+};
+
 const SECONDS_PER_DAY = 86400;
 const SEVEN_DAYS_IN_SECONDS = 7 * SECONDS_PER_DAY;
 
 export const FIVE_HOUR_MIN_FREE_RATIO = 0.25;
 export const SEVEN_DAY_MIN_FREE_RATIO = 0.03;
 
+export const DEFAULT_OAUTH_TOKEN_SELECTION_THRESHOLDS: OauthTokenSelectionThresholds =
+  {
+    fiveHourMinFreeRatio: FIVE_HOUR_MIN_FREE_RATIO,
+    sevenDayMinFreeRatio: SEVEN_DAY_MIN_FREE_RATIO,
+  };
+
+export const CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS: OauthTokenSelectionThresholds =
+  {
+    fiveHourMinFreeRatio: 0.6,
+    sevenDayMinFreeRatio: 0.14,
+  };
+
 export const SEVEN_DAY_WINDOW_HOURS = 168;
 export const MIN_HOURS_TO_RESET = 1;
 const SECONDS_PER_HOUR = 3600;
@@ -91,9 +108,14 @@ export class OauthTokenSelectUseCase {
     candidates: OauthTokenCandidate[],
     nowEpochSeconds: number,
     random: SelectionRandom = Math.random,
+    thresholds: OauthTokenSelectionThresholds = DEFAULT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
   ): OauthTokenSelectResult => {
     const evaluated = candidates.map((candidate) => {
-      const evaluatedMetric = this.evaluate(candidate, nowEpochSeconds);
+      const evaluatedMetric = this.evaluate(
+        candidate,
+        nowEpochSeconds,
+        thresholds,
+      );
       return {
         candidate,
         metric: {
@@ -136,6 +158,7 @@ export class OauthTokenSelectUseCase {
   private evaluate = (
     candidate: OauthTokenCandidate,
     nowEpochSeconds: number,
+    thresholds: OauthTokenSelectionThresholds,
   ): Omit<OauthTokenCandidateMetrics, 'drawWeight'> => {
     const fiveHourFreeRatio = this.fiveHourFreeRatio(
       candidate.snapshot,
@@ -156,6 +179,7 @@ export class OauthTokenSelectUseCase {
       candidate.fableRejected,
       fiveHourFreeRatio,
       sevenDayFreeRatio,
+      thresholds,
     );
 
     return {
@@ -174,6 +198,7 @@ export class OauthTokenSelectUseCase {
     fableRejected: boolean,
     fiveHourFreeRatio: number,
     sevenDayFreeRatio: number,
+    thresholds: OauthTokenSelectionThresholds,
   ): string | null => {
     if (subscriptionDisabled) {
       return 'organization has disabled Claude subscription access for Claude Code';
@@ -184,11 +209,11 @@ export class OauthTokenSelectUseCase {
     if (fableRejected) {
       return 'fable weekly limit exhausted (a fable request was rejected with HTTP 429)';
     }
-    if (fiveHourFreeRatio < FIVE_HOUR_MIN_FREE_RATIO) {
-      return `5h window only ${this.toPercent(fiveHourFreeRatio)}% free (requires >= ${this.toPercent(FIVE_HOUR_MIN_FREE_RATIO)}%)`;
+    if (fiveHourFreeRatio < thresholds.fiveHourMinFreeRatio) {
+      return `5h window only ${this.toPercent(fiveHourFreeRatio)}% free (requires >= ${this.toPercent(thresholds.fiveHourMinFreeRatio)}%)`;
     }
-    if (sevenDayFreeRatio < SEVEN_DAY_MIN_FREE_RATIO) {
-      return `7d window only ${this.toPercent(sevenDayFreeRatio)}% free (requires >= ${this.toPercent(SEVEN_DAY_MIN_FREE_RATIO)}%)`;
+    if (sevenDayFreeRatio < thresholds.sevenDayMinFreeRatio) {
+      return `7d window only ${this.toPercent(sevenDayFreeRatio)}% free (requires >= ${this.toPercent(thresholds.sevenDayMinFreeRatio)}%)`;
     }
     return null;
   };