github-issue-tower-defence-management 1.65.0 → 1.67.0

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

@@ -1221,6 +1221,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-a',
         token: 'token-a',
         fiveHourUtilization: 0,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -1229,6 +1230,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-b',
         token: 'token-b',
         fiveHourUtilization: 0,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -1241,7 +1243,7 @@ describe('StartPreparationUseCase', () => {
       defaultLlmModelName: 'claude-sonnet-4-6',
       defaultLlmAgentName: null,
       configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
+      maximumPreparingIssuesCount: 12,
       utilizationPercentageThreshold: 90,
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
@@ -1284,6 +1286,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-a',
         token: 'token-a',
         fiveHourUtilization: 0,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -1292,6 +1295,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-b',
         token: 'token-b',
         fiveHourUtilization: 0,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -1712,9 +1716,6 @@ describe('StartPreparationUseCase', () => {
       stderr: '',
       exitCode: 0,
     });
-    const consoleWarnSpy = jest
-      .spyOn(console, 'warn')
-      .mockImplementation(() => {});
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
@@ -1735,10 +1736,6 @@ describe('StartPreparationUseCase', () => {
       status: 'Preparation',
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      `Skipping issue https://github.com/user/repo/issues/2: author 'user3' is not in the allowedIssueAuthors list.`,
-    );
-    consoleWarnSpy.mockRestore();
   });
 
   it('should process all issues when allowedIssueAuthors is null', async () => {
@@ -1811,9 +1808,6 @@ describe('StartPreparationUseCase', () => {
       stderr: '',
       exitCode: 0,
     });
-    const consoleWarnSpy = jest
-      .spyOn(console, 'warn')
-      .mockImplementation(() => {});
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
@@ -1833,10 +1827,6 @@ describe('StartPreparationUseCase', () => {
       url: 'https://github.com/user/repo/issues/2',
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      'Skipping issue https://github.com/user/repo/issues/1: author is unknown (empty string); deny-by-default when allowedIssueAuthors is configured.',
-    );
-    consoleWarnSpy.mockRestore();
   });
 
   it('should skip issue with empty author when allowedIssueAuthors is set', async () => {
@@ -1857,9 +1847,6 @@ describe('StartPreparationUseCase', () => {
       stderr: '',
       exitCode: 0,
     });
-    const consoleWarnSpy = jest
-      .spyOn(console, 'warn')
-      .mockImplementation(() => {});
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
@@ -1876,10 +1863,6 @@ describe('StartPreparationUseCase', () => {
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      'Skipping issue https://github.com/user/repo/issues/1: author is unknown (empty string); deny-by-default when allowedIssueAuthors is configured.',
-    );
-    consoleWarnSpy.mockRestore();
   });
 
   it('should not pass --codexHome when codexHomeCandidates is null', async () => {
@@ -2299,6 +2282,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-a',
         token: 'token-a',
         fiveHourUtilization: 0,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2374,6 +2358,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-a',
         token: 'token-a',
         fiveHourUtilization: 0,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2382,6 +2367,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-b',
         token: 'token-b',
         fiveHourUtilization: 0,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2464,7 +2450,7 @@ describe('StartPreparationUseCase', () => {
     ).toHaveLength(0);
   });
 
-  it('should pick the least-utilized token first', async () => {
+  it('should pick the token with the lowest 7-day utilization first', async () => {
     const awaitingIssue = createMockIssue({
       url: 'url1',
       title: 'Issue 1',
@@ -2484,17 +2470,19 @@ describe('StartPreparationUseCase', () => {
     });
     mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
       {
-        name: 'token-high',
-        token: 'token-high',
-        fiveHourUtilization: 0.8,
+        name: 'token-high-7d',
+        token: 'token-high-7d',
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.7,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
       },
       {
-        name: 'token-low',
-        token: 'token-low',
-        fiveHourUtilization: 0.1,
+        name: 'token-low-7d',
+        token: 'token-low-7d',
+        fiveHourUtilization: 0.5,
+        sevenDayUtilization: 0.2,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2517,7 +2505,7 @@ describe('StartPreparationUseCase', () => {
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
       env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-low',
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-low-7d',
         ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
       },
     });
@@ -2546,6 +2534,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-blocked',
         token: 'token-blocked',
         fiveHourUtilization: 0.05,
+        sevenDayUtilization: 0,
         blocked: true,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2554,6 +2543,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-ok',
         token: 'token-ok',
         fiveHourUtilization: 0.5,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2605,6 +2595,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-a',
         token: 'token-a',
         fiveHourUtilization: 0.05,
+        sevenDayUtilization: 0,
         blocked: true,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2613,6 +2604,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-b',
         token: 'token-b',
         fiveHourUtilization: 0.08,
+        sevenDayUtilization: 0,
         blocked: true,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2670,6 +2662,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-a',
         token: 'token-a',
         fiveHourUtilization: 0.95,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2678,6 +2671,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-b',
         token: 'token-b',
         fiveHourUtilization: 0.97,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2707,12 +2701,12 @@ describe('StartPreparationUseCase', () => {
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
     expect(consoleWarnSpy).toHaveBeenCalledWith(
-      expect.stringContaining('5h utilization >= 95%'),
+      expect.stringContaining('5h utilization >= 90%'),
     );
     consoleWarnSpy.mockRestore();
   });
 
-  it('should return all tokens sorted ascending when all have full process capacity', async () => {
+  it('should sort tokens by 7-day utilization ascending when all have full process capacity', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
         url: 'url1',
@@ -2750,25 +2744,28 @@ describe('StartPreparationUseCase', () => {
     });
     mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
       {
-        name: 'token-mid',
-        token: 'token-mid',
-        fiveHourUtilization: 0.5,
+        name: 'token-7d-mid',
+        token: 'token-7d-mid',
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.5,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
       },
       {
-        name: 'token-low',
-        token: 'token-low',
-        fiveHourUtilization: 0.1,
+        name: 'token-7d-low',
+        token: 'token-7d-low',
+        fiveHourUtilization: 0.5,
+        sevenDayUtilization: 0.1,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
       },
       {
-        name: 'token-high',
-        token: 'token-high',
-        fiveHourUtilization: 0.8,
+        name: 'token-7d-high',
+        token: 'token-7d-high',
+        fiveHourUtilization: 0.3,
+        sevenDayUtilization: 0.7,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2790,17 +2787,17 @@ describe('StartPreparationUseCase', () => {
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toMatchObject({
-      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-low' },
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-7d-low' },
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls[1][2]).toMatchObject({
-      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-mid' },
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-7d-mid' },
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls[2][2]).toMatchObject({
-      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-high' },
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-7d-high' },
     });
   });
 
-  it('should reduce token process capacity exponentially above 80 percent 5h utilization', async () => {
+  it('should cap total tasks to the sum of per-token 7-day adaptive concurrent limits', async () => {
     const awaitingIssues: Issue[] = Array.from({ length: 10 }, (_, i) =>
       createMockIssue({
         url: `url${i + 1}`,
@@ -2822,33 +2819,10 @@ describe('StartPreparationUseCase', () => {
     });
     mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
       {
-        name: 'token-full-capacity',
-        token: 'token-full-capacity',
-        fiveHourUtilization: 0.8,
-        blocked: false,
-        rejected: false,
-        modelWeeklyLimits: {},
-      },
-      {
-        name: 'token-two-slots',
-        token: 'token-two-slots',
-        fiveHourUtilization: 0.85,
-        blocked: false,
-        rejected: false,
-        modelWeeklyLimits: {},
-      },
-      {
-        name: 'token-one-slot',
-        token: 'token-one-slot',
-        fiveHourUtilization: 0.9,
-        blocked: false,
-        rejected: false,
-        modelWeeklyLimits: {},
-      },
-      {
-        name: 'token-zero-slots',
-        token: 'token-zero-slots',
-        fiveHourUtilization: 0.95,
+        name: 'token-at-90-percent-7d',
+        token: 'token-at-90-percent-7d',
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.9,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2868,20 +2842,13 @@ describe('StartPreparationUseCase', () => {
       allowIssueCacheMinutes: 0,
     });
 
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(9);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
     const spawnedTokens = mockLocalCommandRunner.runCommand.mock.calls.map(
       (call) => call[2]?.env?.CLAUDE_CODE_OAUTH_TOKEN,
     );
     expect(
-      spawnedTokens.filter((token) => token === 'token-full-capacity'),
-    ).toHaveLength(6);
-    expect(
-      spawnedTokens.filter((token) => token === 'token-two-slots'),
-    ).toHaveLength(2);
-    expect(
-      spawnedTokens.filter((token) => token === 'token-one-slot'),
-    ).toHaveLength(1);
-    expect(spawnedTokens).not.toContain('token-zero-slots');
+      spawnedTokens.filter((token) => token === 'token-at-90-percent-7d'),
+    ).toHaveLength(3);
   });
 
   it('should exclude a rejected token from rotation', async () => {
@@ -2907,6 +2874,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-rejected',
         token: 'token-rejected',
         fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: true,
         modelWeeklyLimits: {},
@@ -2915,6 +2883,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-ok',
         token: 'token-ok',
         fiveHourUtilization: 0.5,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2966,6 +2935,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-reset',
         token: 'token-reset',
         fiveHourUtilization: 0,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -2974,6 +2944,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-busy',
         token: 'token-busy',
         fiveHourUtilization: 0.5,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3025,6 +2996,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-saturated',
         token: 'token-saturated',
         fiveHourUtilization: 0.95,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: true,
         modelWeeklyLimits: {},
@@ -3033,6 +3005,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-ok',
         token: 'token-ok',
         fiveHourUtilization: 0.2,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3084,6 +3057,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-a',
         token: 'token-a',
         fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: true,
         modelWeeklyLimits: {},
@@ -3092,6 +3066,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-b',
         token: 'token-b',
         fiveHourUtilization: 0.2,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: true,
         modelWeeklyLimits: {},
@@ -3169,7 +3144,7 @@ describe('StartPreparationUseCase', () => {
     expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toBeUndefined();
   });
 
-  it('should keep a token in rotation with opus model when seven_day_sonnet is rejected and seven_day_opus is available', async () => {
+  it('should exclude a token whose seven_day_sonnet weekly limit is rejected when the model is sonnet', async () => {
     const awaitingIssue = createMockIssue({
       url: 'url1',
       title: 'Issue 1',
@@ -3193,6 +3168,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-sonnet-exhausted',
         token: 'token-sonnet-exhausted',
         fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {
@@ -3203,6 +3179,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-ok',
         token: 'token-ok',
         fiveHourUtilization: 0.5,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3225,13 +3202,10 @@ describe('StartPreparationUseCase', () => {
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
       env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-sonnet-exhausted',
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-ok',
         ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
       },
     });
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][1][2]).toBe(
-      'claude-opus-4-6',
-    );
   });
 
   it('should re-admit a token whose seven_day_sonnet rejection has been cleared by stale-reset expiry', async () => {
@@ -3258,6 +3232,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-recovered',
         token: 'token-recovered',
         fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {
@@ -3268,6 +3243,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-busy',
         token: 'token-busy',
         fiveHourUtilization: 0.5,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3320,6 +3296,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-sonnet-exhausted',
         token: 'token-sonnet-exhausted',
         fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {
@@ -3330,6 +3307,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-higher-util',
         token: 'token-higher-util',
         fiveHourUtilization: 0.5,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3382,6 +3360,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-weekly-exhausted',
         token: 'token-weekly-exhausted',
         fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {
@@ -3392,6 +3371,7 @@ describe('StartPreparationUseCase', () => {
         name: 'token-ok',
         token: 'token-ok',
         fiveHourUtilization: 0.5,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3419,211 +3399,6 @@ describe('StartPreparationUseCase', () => {
       },
     });
   });
-
-  it('should include a token in rotation with opus model when seven_day_sonnet is rejected but seven_day_opus is available', async () => {
-    const awaitingIssue = createMockIssue({
-      url: 'url1',
-      title: 'Issue 1',
-      labels: ['category:impl'],
-      status: 'Awaiting Workspace',
-      number: 1,
-      itemId: 'item-1',
-    });
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([awaitingIssue]),
-    );
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: '',
-      stderr: '',
-      exitCode: 0,
-    });
-    const futureReset = Math.floor(Date.now() / 1000) + 3600;
-    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
-      {
-        token: 'token-sonnet-exhausted',
-        fiveHourUtilization: 0.1,
-        blocked: false,
-        rejected: false,
-        modelWeeklyLimits: {
-          seven_day_sonnet: { rejected: true, resetsAt: futureReset },
-        },
-      },
-    ]);
-
-    await useCase.run({
-      projectUrl: 'https://github.com/user/repo',
-      defaultAgentName: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
-    });
-
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][1][2]).toBe(
-      'claude-opus-4-6',
-    );
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
-      env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-sonnet-exhausted',
-        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
-      },
-    });
-  });
-
-  it('should exclude a token from rotation when both seven_day_sonnet and seven_day_opus weekly limits are rejected', async () => {
-    const awaitingIssue = createMockIssue({
-      url: 'url1',
-      title: 'Issue 1',
-      labels: ['category:impl'],
-      status: 'Awaiting Workspace',
-      number: 1,
-      itemId: 'item-1',
-    });
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([awaitingIssue]),
-    );
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: '',
-      stderr: '',
-      exitCode: 0,
-    });
-    const futureReset = Math.floor(Date.now() / 1000) + 3600;
-    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
-      {
-        token: 'token-all-exhausted',
-        fiveHourUtilization: 0.1,
-        blocked: false,
-        rejected: false,
-        modelWeeklyLimits: {
-          seven_day_sonnet: { rejected: true, resetsAt: futureReset },
-          seven_day_opus: { rejected: true, resetsAt: futureReset },
-        },
-      },
-    ]);
-
-    await useCase.run({
-      projectUrl: 'https://github.com/user/repo',
-      defaultAgentName: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
-    });
-
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
-  });
-
-  it('should use default model for a token with no modelWeeklyLimits entries', async () => {
-    const awaitingIssue = createMockIssue({
-      url: 'url1',
-      title: 'Issue 1',
-      labels: ['category:impl'],
-      status: 'Awaiting Workspace',
-      number: 1,
-      itemId: 'item-1',
-    });
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([awaitingIssue]),
-    );
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: '',
-      stderr: '',
-      exitCode: 0,
-    });
-    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
-      {
-        token: 'token-no-limits',
-        fiveHourUtilization: 0.1,
-        blocked: false,
-        rejected: false,
-        modelWeeklyLimits: {},
-      },
-    ]);
-
-    await useCase.run({
-      projectUrl: 'https://github.com/user/repo',
-      defaultAgentName: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
-    });
-
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][1][2]).toBe(
-      'claude-sonnet-4-6',
-    );
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
-      env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-no-limits',
-        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
-      },
-    });
-  });
-
-  it('should exclude a token when seven_day general limit is rejected even if per-model limits are available', async () => {
-    const awaitingIssue = createMockIssue({
-      url: 'url1',
-      title: 'Issue 1',
-      labels: ['category:impl'],
-      status: 'Awaiting Workspace',
-      number: 1,
-      itemId: 'item-1',
-    });
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([awaitingIssue]),
-    );
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: '',
-      stderr: '',
-      exitCode: 0,
-    });
-    const futureReset = Math.floor(Date.now() / 1000) + 3600;
-    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
-      {
-        token: 'token-general-limit-rejected',
-        fiveHourUtilization: 0.1,
-        blocked: false,
-        rejected: false,
-        modelWeeklyLimits: {
-          seven_day: { rejected: true, resetsAt: futureReset },
-          seven_day_sonnet: { rejected: false, resetsAt: futureReset },
-        },
-      },
-    ]);
-
-    await useCase.run({
-      projectUrl: 'https://github.com/user/repo',
-      defaultAgentName: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
-    });
-
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
-  });
 });
 
 describe('StartPreparationUseCase.buildRotationOrder', () => {
@@ -3669,20 +3444,22 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
     mockClaudeTokenUsageRepositoryForRotation,
   );
 
-  it('lists selected tokens first in ascending utilization order then excluded tokens', () => {
+  it('lists selected tokens first in ascending 7-day utilization order then excluded tokens', () => {
     const tokenUsages = [
       {
-        name: 'high-util',
+        name: 'high-7d-util',
         token: 'sk-ant-high',
-        fiveHourUtilization: 0.8,
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.8,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
       },
       {
-        name: 'low-util',
+        name: 'low-7d-util',
         token: 'sk-ant-low',
-        fiveHourUtilization: 0.1,
+        fiveHourUtilization: 0.5,
+        sevenDayUtilization: 0.1,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3691,6 +3468,7 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
         name: 'blocked-token',
         token: 'sk-ant-blocked',
         fiveHourUtilization: 0.0,
+        sevenDayUtilization: 0,
         blocked: true,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3698,8 +3476,8 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
     ];
     const result = useCase.buildRotationOrder(tokenUsages, 90, null);
 
-    expect(result[0].name).toBe('low-util');
-    expect(result[1].name).toBe('high-util');
+    expect(result[0].name).toBe('low-7d-util');
+    expect(result[1].name).toBe('high-7d-util');
     expect(result[2].name).toBe('blocked-token');
     expect(result[2].blocked).toBe(true);
     expect(result[2].thresholdExcluded).toBe(false);
@@ -3711,6 +3489,7 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
         name: 'my-token',
         token: 'sk-ant-secret-value',
         fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3723,12 +3502,13 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
     expect(result[0].name).toBe('my-token');
   });
 
-  it('marks thresholdExcluded true when token is at or above 95 percent utilization', () => {
+  it('marks thresholdExcluded true when token 5h utilization meets or exceeds the threshold', () => {
     const tokenUsages = [
       {
         name: 'over-threshold',
         token: 'sk-ant-over',
         fiveHourUtilization: 0.95,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3742,12 +3522,13 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
     expect(result[0].rejected).toBe(false);
   });
 
-  it('does not mark thresholdExcluded for tokens in the 90 to 94 percent utilization range because selectRotationTokens still assigns them slots', () => {
+  it('marks thresholdExcluded true for tokens at or above the 5h utilization threshold', () => {
     const tokenUsages = [
       {
-        name: 'mid-util',
-        token: 'sk-ant-mid',
-        fiveHourUtilization: 0.92,
+        name: 'at-threshold',
+        token: 'sk-ant-at',
+        fiveHourUtilization: 0.9,
+        sevenDayUtilization: 0,
         blocked: false,
         rejected: false,
         modelWeeklyLimits: {},
@@ -3756,9 +3537,9 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
     const result = useCase.buildRotationOrder(tokenUsages, 90, null);
 
     expect(result).toHaveLength(1);
-    expect(result[0].thresholdExcluded).toBe(false);
+    expect(result[0].thresholdExcluded).toBe(true);
     expect(result[0].blocked).toBe(false);
     expect(result[0].rejected).toBe(false);
-    expect(result[0].fiveHourUtilization).toBe(0.92);
+    expect(result[0].fiveHourUtilization).toBe(0.9);
   });
 });