github-issue-tower-defence-management 1.67.6 → 1.69.0

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

@@ -6,6 +6,7 @@ import {
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
 import { LocalCommandRunner } from './adapter-interfaces/LocalCommandRunner';
 import { ClaudeTokenUsageRepository } from './adapter-interfaces/ClaudeTokenUsageRepository';
+import { ClaudeTokenUsage } from '../entities/ClaudeTokenUsage';
 import { Issue } from '../entities/Issue';
 import { Project } from '../entities/Project';
 import { StoryObjectMap } from '../entities/StoryObjectMap';
@@ -152,6 +153,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
     expect(mockIssueRepository.updateStatus.mock.calls[0][0]).toBe(mockProject);
@@ -216,6 +218,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
@@ -272,6 +275,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
@@ -319,6 +323,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
@@ -367,6 +372,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
@@ -414,6 +420,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
@@ -479,6 +486,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockIssueRepository.closePullRequest).toHaveBeenCalledWith(
       newerPR.url,
@@ -567,6 +575,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockIssueRepository.closePullRequest).toHaveBeenCalledWith(
       newerPR.url,
@@ -629,6 +638,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
@@ -672,6 +682,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     // Both awaiting issues should be updated (forward iteration: url1 first, then url2)
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(2);
@@ -728,6 +739,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     // Loop doesn't run because we're already at max (6 >= 6)
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
@@ -762,6 +774,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
@@ -806,6 +819,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
@@ -850,6 +864,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
@@ -894,6 +909,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
@@ -938,6 +954,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
@@ -982,6 +999,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
@@ -1029,6 +1047,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(consoleErrorSpy).toHaveBeenCalledWith(
       'No LLM model configured for issue url1. Provide --defaultLlmModelName or add an llm-model: label.',
@@ -1076,6 +1095,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(consoleErrorSpy).toHaveBeenCalledWith(
       'No LLM model configured for issue url1. Provide --defaultLlmModelName or add an llm-model: label.',
@@ -1125,6 +1145,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     // No issues are in 'Awaiting Workspace' status, so no updates should happen
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
@@ -1159,6 +1180,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(3);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
@@ -1192,6 +1214,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(6);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(6);
@@ -1248,6 +1271,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(12);
@@ -1313,6 +1337,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(12);
@@ -1376,6 +1401,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(2);
@@ -1423,6 +1449,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
@@ -1477,6 +1504,7 @@ describe('StartPreparationUseCase', () => {
         allowedIssueAuthors: null,
         codexHomeCandidates: null,
         allowIssueCacheMinutes: 0,
+        labelsAsLlmAgentName: null,
       });
 
       expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
@@ -1534,6 +1562,7 @@ describe('StartPreparationUseCase', () => {
         allowedIssueAuthors: null,
         codexHomeCandidates: null,
         allowIssueCacheMinutes: 0,
+        labelsAsLlmAgentName: null,
       });
 
       expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
@@ -1581,6 +1610,7 @@ describe('StartPreparationUseCase', () => {
         allowedIssueAuthors: null,
         codexHomeCandidates: null,
         allowIssueCacheMinutes: 0,
+        labelsAsLlmAgentName: null,
       });
 
       expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
@@ -1628,6 +1658,7 @@ describe('StartPreparationUseCase', () => {
         allowedIssueAuthors: null,
         codexHomeCandidates: null,
         allowIssueCacheMinutes: 0,
+        labelsAsLlmAgentName: null,
       });
 
       expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
@@ -1675,6 +1706,7 @@ describe('StartPreparationUseCase', () => {
         allowedIssueAuthors: null,
         codexHomeCandidates: null,
         allowIssueCacheMinutes: 0,
+        labelsAsLlmAgentName: null,
       });
 
       expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
@@ -1728,6 +1760,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: ['user1', 'user2'],
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
@@ -1775,6 +1808,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(2);
@@ -1820,6 +1854,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: ['user1', 'user2'],
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
@@ -1859,6 +1894,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: ['user1'],
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
@@ -1895,6 +1931,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -1942,6 +1979,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: [],
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -1989,6 +2027,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: ['.codex-dev1'],
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -2056,6 +2095,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: ['.codex-dev1', '.codex-dev2'],
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
@@ -2120,6 +2160,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
@@ -2178,6 +2219,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
@@ -2205,6 +2247,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 5,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockIssueRepository.getStoryObjectMap).toHaveBeenCalledWith(
@@ -2251,6 +2294,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
@@ -2300,6 +2344,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(
@@ -2385,6 +2430,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
@@ -2441,6 +2487,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -2450,7 +2497,7 @@ describe('StartPreparationUseCase', () => {
     ).toHaveLength(0);
   });
 
-  it('should pick the token with the lowest 7-day utilization first', async () => {
+  it('should pick the token with the soonest 7-day reset deadline first', async () => {
     const awaitingIssue = createMockIssue({
       url: 'url1',
       title: 'Issue 1',
@@ -2468,24 +2515,35 @@ describe('StartPreparationUseCase', () => {
       stderr: '',
       exitCode: 0,
     });
+    const nowEpochSeconds = Math.floor(Date.now() / 1000);
     mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
       {
-        name: 'token-high-7d',
-        token: 'token-high-7d',
+        name: 'token-far-reset',
+        token: 'token-far-reset',
         fiveHourUtilization: 0.1,
         sevenDayUtilization: 0.7,
         blocked: false,
         rejected: false,
-        modelWeeklyLimits: {},
+        modelWeeklyLimits: {
+          seven_day_opus: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 100 * 3600,
+          },
+        },
       },
       {
-        name: 'token-low-7d',
-        token: 'token-low-7d',
+        name: 'token-soon-reset',
+        token: 'token-soon-reset',
         fiveHourUtilization: 0.5,
         sevenDayUtilization: 0.2,
         blocked: false,
         rejected: false,
-        modelWeeklyLimits: {},
+        modelWeeklyLimits: {
+          seven_day_opus: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 20 * 3600,
+          },
+        },
       },
     ]);
 
@@ -2500,12 +2558,13 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
       env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-low-7d',
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-soon-reset',
         ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
       },
     });
@@ -2561,6 +2620,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -2625,6 +2685,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(
@@ -2692,6 +2753,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(
@@ -2706,7 +2768,7 @@ describe('StartPreparationUseCase', () => {
     consoleWarnSpy.mockRestore();
   });
 
-  it('should sort tokens by 7-day utilization ascending when all have full process capacity', async () => {
+  it('should sort tokens by 7-day reset deadline ascending when all have full process capacity', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
         url: 'url1',
@@ -2742,33 +2804,49 @@ describe('StartPreparationUseCase', () => {
       stderr: '',
       exitCode: 0,
     });
+    const nowEpochSeconds = Math.floor(Date.now() / 1000);
     mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
       {
-        name: 'token-7d-mid',
-        token: 'token-7d-mid',
+        name: 'token-7d-mid-reset',
+        token: 'token-7d-mid-reset',
         fiveHourUtilization: 0.1,
         sevenDayUtilization: 0.5,
         blocked: false,
         rejected: false,
-        modelWeeklyLimits: {},
+        modelWeeklyLimits: {
+          seven_day_opus: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 50 * 3600,
+          },
+        },
       },
       {
-        name: 'token-7d-low',
-        token: 'token-7d-low',
+        name: 'token-7d-soon-reset',
+        token: 'token-7d-soon-reset',
         fiveHourUtilization: 0.5,
         sevenDayUtilization: 0.1,
         blocked: false,
         rejected: false,
-        modelWeeklyLimits: {},
+        modelWeeklyLimits: {
+          seven_day_opus: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 10 * 3600,
+          },
+        },
       },
       {
-        name: 'token-7d-high',
-        token: 'token-7d-high',
+        name: 'token-7d-far-reset',
+        token: 'token-7d-far-reset',
         fiveHourUtilization: 0.3,
         sevenDayUtilization: 0.7,
         blocked: false,
         rejected: false,
-        modelWeeklyLimits: {},
+        modelWeeklyLimits: {
+          seven_day_opus: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 150 * 3600,
+          },
+        },
       },
     ]);
 
@@ -2783,17 +2861,18 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toMatchObject({
-      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-7d-low' },
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-7d-soon-reset' },
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls[1][2]).toMatchObject({
-      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-7d-mid' },
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-7d-mid-reset' },
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls[2][2]).toMatchObject({
-      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-7d-high' },
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-7d-far-reset' },
     });
   });
 
@@ -2840,6 +2919,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
@@ -2901,6 +2981,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -2962,6 +3043,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -3023,6 +3105,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -3087,6 +3170,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(
@@ -3133,6 +3217,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(
@@ -3197,6 +3282,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -3261,6 +3347,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -3325,6 +3412,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -3389,6 +3477,7 @@ describe('StartPreparationUseCase', () => {
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
@@ -3399,6 +3488,431 @@ describe('StartPreparationUseCase', () => {
       },
     });
   });
+
+  it('should pick the token whose 7-day reset is sooner before the token whose 7-day reset is farther', 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 nowEpochSeconds = Math.floor(Date.now() / 1000);
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        name: 'token-b-far-reset',
+        token: 'token-b-far-reset',
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {
+          seven_day_opus: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 100 * 3600,
+          },
+        },
+      },
+      {
+        name: 'token-a-soon-reset',
+        token: 'token-a-soon-reset',
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {
+          seven_day_opus: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 20 * 3600,
+          },
+        },
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+      codexHomeCandidates: null,
+      allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
+    });
+
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-a-soon-reset',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
+  });
+
+  it('should exclude a blocked token even when it has a sooner 7-day reset than an eligible token', 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 nowEpochSeconds = Math.floor(Date.now() / 1000);
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        name: 'token-a-blocked-soon-reset',
+        token: 'token-a-blocked-soon-reset',
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.1,
+        blocked: true,
+        rejected: false,
+        modelWeeklyLimits: {
+          seven_day_opus: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 20 * 3600,
+          },
+        },
+      },
+      {
+        name: 'token-b-far-reset',
+        token: 'token-b-far-reset',
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {
+          seven_day_opus: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 100 * 3600,
+          },
+        },
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+      codexHomeCandidates: null,
+      allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
+    });
+
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-b-far-reset',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
+  });
+
+  it('should place a token whose 7-day reset is unknown after a token whose 7-day reset is known', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 1,
+        itemId: 'item-1',
+      }),
+      createMockIssue({
+        url: 'url2',
+        title: 'Issue 2',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 2,
+        itemId: 'item-2',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    const nowEpochSeconds = Math.floor(Date.now() / 1000);
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        name: 'token-a-unknown-reset',
+        token: 'token-a-unknown-reset',
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+      {
+        name: 'token-b-known-soon-reset',
+        token: 'token-b-known-soon-reset',
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {
+          seven_day_opus: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 20 * 3600,
+          },
+        },
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+      codexHomeCandidates: null,
+      allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
+    });
+
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(2);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toMatchObject({
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-b-known-soon-reset' },
+    });
+    expect(mockLocalCommandRunner.runCommand.mock.calls[1][2]).toMatchObject({
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-a-unknown-reset' },
+    });
+  });
+
+  it('should fall back to 5-hour utilization ascending as tiebreaker when 7-day reset deadlines are identical', 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 nowEpochSeconds = Math.floor(Date.now() / 1000);
+    const sharedResetsAt = nowEpochSeconds + 50 * 3600;
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        name: 'token-busy-5h',
+        token: 'token-busy-5h',
+        fiveHourUtilization: 0.6,
+        sevenDayUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {
+          seven_day_opus: { rejected: false, resetsAt: sharedResetsAt },
+        },
+      },
+      {
+        name: 'token-idle-5h',
+        token: 'token-idle-5h',
+        fiveHourUtilization: 0.1,
+        sevenDayUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {
+          seven_day_opus: { rejected: false, resetsAt: sharedResetsAt },
+        },
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+      codexHomeCandidates: null,
+      allowIssueCacheMinutes: 0,
+      labelsAsLlmAgentName: null,
+    });
+
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-idle-5h',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
+  });
+
+  describe('agent selection precedence', () => {
+    const runWithIssueLabels = async (params: {
+      labels: string[];
+      defaultAgentName: string;
+      defaultLlmAgentName: string | null;
+      labelsAsLlmAgentName: string[] | null;
+    }): Promise<string> => {
+      const awaitingIssues: Issue[] = [
+        createMockIssue({
+          url: 'url1',
+          title: 'Issue 1',
+          labels: params.labels,
+          status: 'Awaiting Workspace',
+        }),
+      ];
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap(awaitingIssues),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        defaultAgentName: params.defaultAgentName,
+        defaultLlmModelName: 'claude-opus',
+        defaultLlmAgentName: params.defaultLlmAgentName,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+        codexHomeCandidates: null,
+        allowIssueCacheMinutes: 0,
+        labelsAsLlmAgentName: params.labelsAsLlmAgentName,
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+      const awArgs = mockLocalCommandRunner.runCommand.mock.calls[0][1];
+      return awArgs[1];
+    };
+
+    it('selects explicit llm-agent: label over labelsAsLlmAgentName mapping', async () => {
+      const selectedAgent = await runWithIssueLabels({
+        labels: ['llm-agent:explicit-agent', 'story', 'category:impl'],
+        defaultAgentName: 'default-agent',
+        defaultLlmAgentName: 'default-llm-agent',
+        labelsAsLlmAgentName: ['story'],
+      });
+      expect(selectedAgent).toBe('explicit-agent');
+    });
+
+    it('uses the label name as the agent name when an issue label is listed in labelsAsLlmAgentName, over category: label', async () => {
+      const selectedAgent = await runWithIssueLabels({
+        labels: ['story', 'category:impl'],
+        defaultAgentName: 'default-agent',
+        defaultLlmAgentName: 'default-llm-agent',
+        labelsAsLlmAgentName: ['story'],
+      });
+      expect(selectedAgent).toBe('story');
+    });
+
+    it('matches labelsAsLlmAgentName entries exactly including colons in the label name', async () => {
+      const selectedAgent = await runWithIssueLabels({
+        labels: ['story:body-condition', 'category:impl'],
+        defaultAgentName: 'default-agent',
+        defaultLlmAgentName: 'default-llm-agent',
+        labelsAsLlmAgentName: ['story', 'story:body-condition'],
+      });
+      expect(selectedAgent).toBe('story:body-condition');
+    });
+
+    it('falls through to category: label when no llm-agent: label and no issue label is in labelsAsLlmAgentName', async () => {
+      const selectedAgent = await runWithIssueLabels({
+        labels: ['unrelated-label', 'category:impl'],
+        defaultAgentName: 'default-agent',
+        defaultLlmAgentName: 'default-llm-agent',
+        labelsAsLlmAgentName: ['story'],
+      });
+      expect(selectedAgent).toBe('impl');
+    });
+
+    it('falls through to defaultLlmAgentName when no llm-agent:, no labelsAsLlmAgentName match, and no category: label', async () => {
+      const selectedAgent = await runWithIssueLabels({
+        labels: ['unrelated-label'],
+        defaultAgentName: 'default-agent',
+        defaultLlmAgentName: 'default-llm-agent',
+        labelsAsLlmAgentName: ['story'],
+      });
+      expect(selectedAgent).toBe('default-llm-agent');
+    });
+
+    it('falls through to defaultAgentName when no llm-agent:, no labelsAsLlmAgentName match, no category: label, and no defaultLlmAgentName', async () => {
+      const selectedAgent = await runWithIssueLabels({
+        labels: ['unrelated-label'],
+        defaultAgentName: 'default-agent',
+        defaultLlmAgentName: null,
+        labelsAsLlmAgentName: ['story'],
+      });
+      expect(selectedAgent).toBe('default-agent');
+    });
+
+    it('ignores labels that are not listed in labelsAsLlmAgentName', async () => {
+      const selectedAgent = await runWithIssueLabels({
+        labels: ['untracked-label'],
+        defaultAgentName: 'default-agent',
+        defaultLlmAgentName: 'default-llm-agent',
+        labelsAsLlmAgentName: ['story'],
+      });
+      expect(selectedAgent).toBe('default-llm-agent');
+    });
+
+    it('ignores labels that are not listed in labelsAsLlmAgentName when other entries are present', async () => {
+      const selectedAgent = await runWithIssueLabels({
+        labels: ['untracked-label', 'another-untracked-label'],
+        defaultAgentName: 'default-agent',
+        defaultLlmAgentName: 'default-llm-agent',
+        labelsAsLlmAgentName: ['story', 'story:body-condition'],
+      });
+      expect(selectedAgent).toBe('default-llm-agent');
+    });
+
+    it('does not affect selection when labelsAsLlmAgentName is null and only category: label is present', async () => {
+      const selectedAgent = await runWithIssueLabels({
+        labels: ['category:impl'],
+        defaultAgentName: 'default-agent',
+        defaultLlmAgentName: 'default-llm-agent',
+        labelsAsLlmAgentName: null,
+      });
+      expect(selectedAgent).toBe('impl');
+    });
+  });
 });
 
 describe('StartPreparationUseCase.buildRotationOrder', () => {
@@ -3444,25 +3958,36 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
     mockClaudeTokenUsageRepositoryForRotation,
   );
 
-  it('lists selected tokens first in ascending 7-day utilization order then excluded tokens', () => {
-    const tokenUsages = [
+  it('lists selected tokens first in ascending 7-day reset deadline order then excluded tokens', () => {
+    const nowEpochSeconds = Math.floor(Date.now() / 1000);
+    const tokenUsages: ClaudeTokenUsage[] = [
       {
-        name: 'high-7d-util',
-        token: 'sk-ant-high',
+        name: 'far-7d-reset',
+        token: 'sk-ant-far',
         fiveHourUtilization: 0.1,
         sevenDayUtilization: 0.8,
         blocked: false,
         rejected: false,
-        modelWeeklyLimits: {},
+        modelWeeklyLimits: {
+          seven_day: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 100 * 3600,
+          },
+        },
       },
       {
-        name: 'low-7d-util',
-        token: 'sk-ant-low',
+        name: 'soon-7d-reset',
+        token: 'sk-ant-soon',
         fiveHourUtilization: 0.5,
         sevenDayUtilization: 0.1,
         blocked: false,
         rejected: false,
-        modelWeeklyLimits: {},
+        modelWeeklyLimits: {
+          seven_day: {
+            rejected: false,
+            resetsAt: nowEpochSeconds + 20 * 3600,
+          },
+        },
       },
       {
         name: 'blocked-token',
@@ -3476,8 +4001,8 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
     ];
     const result = useCase.buildRotationOrder(tokenUsages, 90, null);
 
-    expect(result[0].name).toBe('low-7d-util');
-    expect(result[1].name).toBe('high-7d-util');
+    expect(result[0].name).toBe('soon-7d-reset');
+    expect(result[1].name).toBe('far-7d-reset');
     expect(result[2].name).toBe('blocked-token');
     expect(result[2].blocked).toBe(true);
     expect(result[2].thresholdExcluded).toBe(false);