github-issue-tower-defence-management 1.58.2 → 1.59.0

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

@@ -5,7 +5,6 @@ import {
 } from './adapter-interfaces/IssueRepository';
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
 import { LocalCommandRunner } from './adapter-interfaces/LocalCommandRunner';
-import { ClaudeRepository } from './adapter-interfaces/ClaudeRepository';
 import { ClaudeTokenUsageRepository } from './adapter-interfaces/ClaudeTokenUsageRepository';
 import { Issue } from '../entities/Issue';
 import { Project } from '../entities/Project';
@@ -91,7 +90,6 @@ describe('StartPreparationUseCase', () => {
       | 'createCommentByUrl'
     >
   >;
-  let mockClaudeRepository: Mocked<Pick<ClaudeRepository, 'getUsage'>>;
   let mockLocalCommandRunner: Mocked<LocalCommandRunner>;
   let mockClaudeTokenUsageRepository: Mocked<ClaudeTokenUsageRepository>;
   let mockProject: Project;
@@ -110,9 +108,6 @@ describe('StartPreparationUseCase', () => {
       deletePullRequestBranch: jest.fn().mockResolvedValue(undefined),
       createCommentByUrl: jest.fn().mockResolvedValue(undefined),
     };
-    mockClaudeRepository = {
-      getUsage: jest.fn().mockResolvedValue([]),
-    };
     mockLocalCommandRunner = {
       runCommand: jest.fn(),
     };
@@ -124,7 +119,6 @@ describe('StartPreparationUseCase', () => {
     useCase = new StartPreparationUseCase(
       mockProjectRepository,
       mockIssueRepository,
-      mockClaudeRepository,
       mockLocalCommandRunner,
       mockClaudeTokenUsageRepository,
     );
@@ -1262,59 +1256,25 @@ describe('StartPreparationUseCase', () => {
     expect(updatedUrls).toContain('https://github.com/user/repo/issues/101');
   });
 
-  it('should skip preparation when Claude usage is over 90%', async () => {
-    mockClaudeRepository.getUsage.mockResolvedValue([
-      { hour: 5, utilizationPercentage: 95, resetsAt: new Date() },
-    ]);
-
-    const awaitingIssues: Issue[] = [
-      createMockIssue({
-        url: 'url1',
-        title: 'Issue 1',
-        labels: [],
-        status: 'Awaiting Workspace',
-      }),
-    ];
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap(awaitingIssues),
-    );
-
-    await useCase.run({
-      projectUrl: 'https://github.com/user/repo',
-      defaultAgentName: 'agent1',
-      defaultLlmModelName: null,
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
+  it('should skip issues that have dependedIssueUrls', async () => {
+    const issueWithDependency = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      title: 'Issue with dependency',
+      labels: [],
+      status: 'Awaiting Workspace',
+      dependedIssueUrls: ['https://github.com/user/repo/issues/2'],
+    });
+    const issueWithoutDependency = createMockIssue({
+      url: 'https://github.com/user/repo/issues/3',
+      title: 'Issue without dependency',
+      labels: [],
+      status: 'Awaiting Workspace',
+      dependedIssueUrls: [],
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
-    expect(mockProjectRepository.getByUrl).not.toHaveBeenCalled();
-  });
-
-  it('should proceed with preparation when Claude usage is under 90%', async () => {
-    mockClaudeRepository.getUsage.mockResolvedValue([
-      { hour: 5, utilizationPercentage: 50, resetsAt: new Date() },
-      { hour: 168, utilizationPercentage: 30, resetsAt: new Date() },
-    ]);
-
-    const awaitingIssues: Issue[] = [
-      createMockIssue({
-        url: 'url1',
-        title: 'Issue 1',
-        labels: ['category:impl'],
-        status: 'Awaiting Workspace',
-      }),
-    ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap(awaitingIssues),
+      createMockStoryObjectMap([issueWithDependency, issueWithoutDependency]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
@@ -1336,232 +1296,201 @@ describe('StartPreparationUseCase', () => {
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+      url: 'https://github.com/user/repo/issues/3',
+      status: 'Preparation',
+    });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
   });
 
-  it('should reduce maximumPreparingIssuesCount gradually when weekly usage window exceeds threshold', async () => {
-    mockClaudeRepository.getUsage.mockResolvedValue([
-      { hour: 5, utilizationPercentage: 50, resetsAt: new Date() },
-      { hour: 168, utilizationPercentage: 91, resetsAt: new Date() },
-    ]);
+  it('should skip issues where nextActionHour is in the future', async () => {
+    jest.useFakeTimers();
+    try {
+      jest.setSystemTime(new Date('2024-01-01T10:00:00'));
 
-    const awaitingIssues: Issue[] = Array.from({ length: 10 }, (_, i) =>
-      createMockIssue({
-        url: `url${i + 1}`,
-        title: `Issue ${i + 1}`,
+      const issueWithFutureNextActionHour = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        title: 'Issue with future next action hour',
         labels: [],
         status: 'Awaiting Workspace',
-      }),
-    );
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap(awaitingIssues),
-    );
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: '',
-      stderr: '',
-      exitCode: 0,
-    });
+        nextActionHour: 15,
+      });
+      const issueWithoutNextActionHour = createMockIssue({
+        url: 'https://github.com/user/repo/issues/2',
+        title: 'Issue without next action hour',
+        labels: [],
+        status: 'Awaiting Workspace',
+        nextActionHour: null,
+      });
 
-    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,
-    });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([
+          issueWithFutureNextActionHour,
+          issueWithoutNextActionHour,
+        ]),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
 
-    const weeklyUtilization = 91;
-    const threshold = 90;
-    const defaultMax = 6;
-    const normalizedUtilizationBeyondThreshold =
-      (weeklyUtilization - threshold) / (100 - threshold);
-    const expectedMax = Math.floor(
-      defaultMax * Math.pow(1 - normalizedUtilizationBeyondThreshold, 2),
-    );
-    expect(mockProjectRepository.getByUrl).toHaveBeenCalled();
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(
-      expectedMax,
-    );
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(
-      expectedMax,
-    );
+      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(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+        url: 'https://github.com/user/repo/issues/2',
+        status: 'Preparation',
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    } finally {
+      jest.useRealTimers();
+    }
   });
 
-  it('should skip all preparation when weekly window usage reduces maximumPreparingIssuesCount to 0', async () => {
-    mockClaudeRepository.getUsage.mockResolvedValue([
-      { hour: 168, utilizationPercentage: 100, resetsAt: new Date() },
-    ]);
+  it('should skip issues where nextActionDate is tomorrow or more future', async () => {
+    jest.useFakeTimers();
+    try {
+      jest.setSystemTime(new Date('2024-01-15T10:00:00'));
 
-    const awaitingIssues: Issue[] = [
-      createMockIssue({
-        url: 'url1',
+      const issueWithFutureNextActionDate = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        title: 'Issue with future next action date',
         labels: [],
         status: 'Awaiting Workspace',
-      }),
-    ];
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap(awaitingIssues),
-    );
+        nextActionDate: new Date('2024-01-16'),
+      });
+      const issueWithoutNextActionDate = createMockIssue({
+        url: 'https://github.com/user/repo/issues/2',
+        title: 'Issue without next action date',
+        labels: [],
+        status: 'Awaiting Workspace',
+        nextActionDate: null,
+      });
 
-    await useCase.run({
-      projectUrl: 'https://github.com/user/repo',
-      defaultAgentName: 'agent1',
-      defaultLlmModelName: null,
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
-    });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([
+          issueWithFutureNextActionDate,
+          issueWithoutNextActionDate,
+        ]),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+      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(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+        url: 'https://github.com/user/repo/issues/2',
+        status: 'Preparation',
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    } finally {
+      jest.useRealTimers();
+    }
   });
 
-  it('should not apply weekly reduction when threshold is 100', async () => {
-    mockClaudeRepository.getUsage.mockResolvedValue([
-      { hour: 168, utilizationPercentage: 99, resetsAt: new Date() },
-    ]);
+  it('should not skip issues where nextActionDate is today', async () => {
+    jest.useFakeTimers();
+    try {
+      jest.setSystemTime(new Date('2024-01-15T10:00:00'));
 
-    const awaitingIssues: Issue[] = Array.from({ length: 10 }, (_, i) =>
-      createMockIssue({
-        url: `url${i + 1}`,
-        title: `Issue ${i + 1}`,
+      const issueWithTodayNextActionDate = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        title: 'Issue with today next action date',
         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: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 100,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
-    });
+        nextActionDate: new Date('2024-01-15'),
+      });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(6);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(6);
-  });
-
-  it('should still skip immediately when non-weekly window exceeds threshold', async () => {
-    mockClaudeRepository.getUsage.mockResolvedValue([
-      { hour: 5, utilizationPercentage: 95, resetsAt: new Date() },
-      { hour: 168, utilizationPercentage: 50, resetsAt: new Date() },
-    ]);
-
-    const awaitingIssues: Issue[] = [
-      createMockIssue({
-        url: 'url1',
-        labels: [],
-        status: 'Awaiting Workspace',
-      }),
-    ];
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap(awaitingIssues),
-    );
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([issueWithTodayNextActionDate]),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
 
-    await useCase.run({
-      projectUrl: 'https://github.com/user/repo',
-      defaultAgentName: 'agent1',
-      defaultLlmModelName: null,
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
-    });
+      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(mockProjectRepository.getByUrl).not.toHaveBeenCalled();
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    } finally {
+      jest.useRealTimers();
+    }
   });
 
-  it('should use maximum utilization across multiple weekly window entries for reduction', async () => {
-    mockClaudeRepository.getUsage.mockResolvedValue([
-      { hour: 168, utilizationPercentage: 91, resetsAt: new Date() },
-      { hour: 168, utilizationPercentage: 95, resetsAt: new Date() },
-    ]);
+  it('should not skip issues where nextActionDate is in the past', async () => {
+    jest.useFakeTimers();
+    try {
+      jest.setSystemTime(new Date('2024-01-15T10:00:00'));
 
-    const awaitingIssues: Issue[] = Array.from({ length: 10 }, (_, i) =>
-      createMockIssue({
-        url: `url${i + 1}`,
-        title: `Issue ${i + 1}`,
+      const issueWithPastNextActionDate = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        title: 'Issue with past next action date',
         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: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
-    });
-
-    const normalizedUtilizationBeyondThreshold = (95 - 90) / (100 - 90);
-    const expectedMax = Math.floor(
-      6 * Math.pow(1 - normalizedUtilizationBeyondThreshold, 2),
-    );
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(
-      expectedMax,
-    );
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(
-      expectedMax,
-    );
-  });
+        nextActionDate: new Date('2024-01-14'),
+      });
 
-  it('should throw error when Claude usage check fails', async () => {
-    mockClaudeRepository.getUsage.mockRejectedValue(
-      new Error('Claude credentials file not found'),
-    );
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([issueWithPastNextActionDate]),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
 
-    await expect(
-      useCase.run({
+      await useCase.run({
         projectUrl: 'https://github.com/user/repo',
         defaultAgentName: 'agent1',
-        defaultLlmModelName: null,
+        defaultLlmModelName: 'claude-sonnet-4-6',
         defaultLlmAgentName: null,
         configFilePath: '/path/to/config.yml',
         maximumPreparingIssuesCount: null,
@@ -1569,65 +1498,88 @@ describe('StartPreparationUseCase', () => {
         allowedIssueAuthors: null,
         codexHomeCandidates: null,
         allowIssueCacheMinutes: 0,
-      }),
-    ).rejects.toThrow('Claude credentials file not found');
+      });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    } finally {
+      jest.useRealTimers();
+    }
   });
 
-  it('should skip preparation when Claude usage exceeds custom threshold', async () => {
-    mockClaudeRepository.getUsage.mockResolvedValue([
-      { hour: 5, utilizationPercentage: 75, resetsAt: new Date() },
-    ]);
+  it('should not skip issues where nextActionHour is in the past or current hour', async () => {
+    jest.useFakeTimers();
+    try {
+      jest.setSystemTime(new Date('2024-01-01T15:00:00'));
 
-    const awaitingIssues: Issue[] = [
-      createMockIssue({
-        url: 'url1',
-        title: 'Issue 1',
+      const issueWithPastNextActionHour = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        title: 'Issue with past next action hour',
         labels: [],
         status: 'Awaiting Workspace',
-      }),
-    ];
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap(awaitingIssues),
-    );
+        nextActionHour: 10,
+      });
 
-    await useCase.run({
-      projectUrl: 'https://github.com/user/repo',
-      defaultAgentName: 'agent1',
-      defaultLlmModelName: null,
-      defaultLlmAgentName: null,
-      configFilePath: '/path/to/config.yml',
-      maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 70,
-      allowedIssueAuthors: null,
-      codexHomeCandidates: null,
-      allowIssueCacheMinutes: 0,
-    });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([issueWithPastNextActionHour]),
+      );
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
-    expect(mockProjectRepository.getByUrl).not.toHaveBeenCalled();
+      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(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    } finally {
+      jest.useRealTimers();
+    }
   });
 
-  it('should proceed with preparation when Claude usage is under custom threshold', async () => {
-    mockClaudeRepository.getUsage.mockResolvedValue([
-      { hour: 5, utilizationPercentage: 75, resetsAt: new Date() },
-    ]);
+  it('should skip issues from non-allowed authors', async () => {
+    const issueFromAllowedAuthor = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      title: 'Issue from allowed author',
+      labels: [],
+      status: 'Awaiting Workspace',
+      author: 'user1',
+    });
+    const issueFromNonAllowedAuthor = createMockIssue({
+      url: 'https://github.com/user/repo/issues/2',
+      title: 'Issue from non-allowed author',
+      labels: [],
+      status: 'Awaiting Workspace',
+      author: 'user3',
+    });
 
-    const awaitingIssues: Issue[] = [
-      createMockIssue({
-        url: 'url1',
-        title: 'Issue 1',
-        labels: ['category:impl'],
-        status: 'Awaiting Workspace',
-      }),
-    ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap(awaitingIssues),
+      createMockStoryObjectMap([
+        issueFromAllowedAuthor,
+        issueFromNonAllowedAuthor,
+      ]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
@@ -1642,35 +1594,39 @@ describe('StartPreparationUseCase', () => {
       defaultLlmAgentName: null,
       configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      utilizationPercentageThreshold: 80,
-      allowedIssueAuthors: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: ['user1', 'user2'],
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
   });
 
-  it('should skip issues that have dependedIssueUrls', async () => {
-    const issueWithDependency = createMockIssue({
+  it('should process all issues when allowedIssueAuthors is null', async () => {
+    const issue1 = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',
-      title: 'Issue with dependency',
+      title: 'Issue 1',
       labels: [],
       status: 'Awaiting Workspace',
-      dependedIssueUrls: ['https://github.com/user/repo/issues/2'],
+      author: 'user1',
     });
-    const issueWithoutDependency = createMockIssue({
-      url: 'https://github.com/user/repo/issues/3',
-      title: 'Issue without dependency',
+    const issue2 = createMockIssue({
+      url: 'https://github.com/user/repo/issues/2',
+      title: 'Issue 2',
       labels: [],
       status: 'Awaiting Workspace',
-      dependedIssueUrls: [],
+      author: 'user2',
     });
 
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([issueWithDependency, issueWithoutDependency]),
+      createMockStoryObjectMap([issue1, issue2]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
@@ -1691,291 +1647,462 @@ describe('StartPreparationUseCase', () => {
       allowIssueCacheMinutes: 0,
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-      url: 'https://github.com/user/repo/issues/3',
-      status: 'Preparation',
-    });
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(2);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(2);
   });
 
-  it('should skip issues where nextActionHour is in the future', async () => {
-    jest.useFakeTimers();
-    try {
-      jest.setSystemTime(new Date('2024-01-01T10:00:00'));
-
-      const issueWithFutureNextActionHour = createMockIssue({
-        url: 'https://github.com/user/repo/issues/1',
-        title: 'Issue with future next action hour',
-        labels: [],
-        status: 'Awaiting Workspace',
-        nextActionHour: 15,
-      });
-      const issueWithoutNextActionHour = createMockIssue({
-        url: 'https://github.com/user/repo/issues/2',
-        title: 'Issue without next action hour',
-        labels: [],
-        status: 'Awaiting Workspace',
-        nextActionHour: null,
-      });
+  it('should skip issues with empty author when allowedIssueAuthors is configured (deny-by-default)', async () => {
+    const issueWithEmptyAuthor = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      title: 'Issue with empty author',
+      labels: [],
+      status: 'Awaiting Workspace',
+      author: '',
+    });
+    const issueWithKnownAuthor = createMockIssue({
+      url: 'https://github.com/user/repo/issues/2',
+      title: 'Issue with known author',
+      labels: [],
+      status: 'Awaiting Workspace',
+      author: 'user1',
+      number: 2,
+      itemId: 'item-2',
+    });
 
-      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-        createMockStoryObjectMap([
-          issueWithFutureNextActionHour,
-          issueWithoutNextActionHour,
-        ]),
-      );
-      mockLocalCommandRunner.runCommand.mockResolvedValue({
-        stdout: '',
-        stderr: '',
-        exitCode: 0,
-      });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([issueWithEmptyAuthor, issueWithKnownAuthor]),
+    );
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
 
-      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,
-      });
+    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: ['user1', 'user2'],
+      codexHomeCandidates: null,
+      allowIssueCacheMinutes: 0,
+    });
 
-      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-        url: 'https://github.com/user/repo/issues/2',
-        status: 'Preparation',
-      });
-      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    } finally {
-      jest.useRealTimers();
-    }
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+      url: 'https://github.com/user/repo/issues/2',
+    });
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
   });
 
-  it('should skip issues where nextActionDate is tomorrow or more future', async () => {
-    jest.useFakeTimers();
-    try {
-      jest.setSystemTime(new Date('2024-01-15T10:00:00'));
-
-      const issueWithFutureNextActionDate = createMockIssue({
-        url: 'https://github.com/user/repo/issues/1',
-        title: 'Issue with future next action date',
-        labels: [],
-        status: 'Awaiting Workspace',
-        nextActionDate: new Date('2024-01-16'),
-      });
-      const issueWithoutNextActionDate = createMockIssue({
-        url: 'https://github.com/user/repo/issues/2',
-        title: 'Issue without next action date',
-        labels: [],
-        status: 'Awaiting Workspace',
-        nextActionDate: null,
-      });
+  it('should skip issue with empty author when allowedIssueAuthors is set', async () => {
+    const issueWithEmptyAuthor = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      title: 'Issue with empty author',
+      labels: [],
+      status: 'Awaiting Workspace',
+      author: '',
+    });
 
-      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-        createMockStoryObjectMap([
-          issueWithFutureNextActionDate,
-          issueWithoutNextActionDate,
-        ]),
-      );
-      mockLocalCommandRunner.runCommand.mockResolvedValue({
-        stdout: '',
-        stderr: '',
-        exitCode: 0,
-      });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([issueWithEmptyAuthor]),
+    );
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
 
-      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,
-      });
+    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: ['user1'],
+      codexHomeCandidates: null,
+      allowIssueCacheMinutes: 0,
+    });
 
-      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-        url: 'https://github.com/user/repo/issues/2',
-        status: 'Preparation',
-      });
-      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    } finally {
-      jest.useRealTimers();
-    }
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
   });
 
-  it('should not skip issues where nextActionDate is today', async () => {
-    jest.useFakeTimers();
-    try {
-      jest.setSystemTime(new Date('2024-01-15T10:00:00'));
-
-      const issueWithTodayNextActionDate = createMockIssue({
-        url: 'https://github.com/user/repo/issues/1',
-        title: 'Issue with today next action date',
-        labels: [],
+  it('should not pass --codexHome when codexHomeCandidates is null', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
         status: 'Awaiting Workspace',
-        nextActionDate: new Date('2024-01-15'),
-      });
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
 
-      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-        createMockStoryObjectMap([issueWithTodayNextActionDate]),
-      );
-      mockLocalCommandRunner.runCommand.mockResolvedValue({
-        stdout: '',
-        stderr: '',
-        exitCode: 0,
-      });
+    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,
+    });
 
-      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]).toEqual([
+      'aw',
+      [
+        'url1',
+        'impl',
+        'claude-opus',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'i1',
+      ],
+    ]);
+  });
 
-      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-        url: 'https://github.com/user/repo/issues/1',
-        status: 'Preparation',
-      });
-      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    } finally {
-      jest.useRealTimers();
-    }
+  it('should not pass --codexHome when codexHomeCandidates is empty array', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        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: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+      codexHomeCandidates: [],
+      allowIssueCacheMinutes: 0,
+    });
+
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
+      'aw',
+      [
+        'url1',
+        'impl',
+        'claude-opus',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'i1',
+      ],
+    ]);
   });
 
-  it('should not skip issues where nextActionDate is in the past', async () => {
-    jest.useFakeTimers();
-    try {
-      jest.setSystemTime(new Date('2024-01-15T10:00:00'));
+  it('should pass --codexHome with the candidate when codexHomeCandidates has one entry', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
 
-      const issueWithPastNextActionDate = createMockIssue({
-        url: 'https://github.com/user/repo/issues/1',
-        title: 'Issue with past next action date',
-        labels: [],
+    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: ['.codex-dev1'],
+      allowIssueCacheMinutes: 0,
+    });
+
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
+      'aw',
+      [
+        'url1',
+        'impl',
+        'claude-opus',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'i1',
+        '--codexHome',
+        '.codex-dev1',
+      ],
+    ]);
+  });
+
+  it('should cycle through codexHomeCandidates across multiple issues', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
         status: 'Awaiting Workspace',
-        nextActionDate: new Date('2024-01-14'),
-      });
+        number: 1,
+        itemId: 'item-1',
+      }),
+      createMockIssue({
+        url: 'url2',
+        title: 'Issue 2',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 2,
+        itemId: 'item-2',
+      }),
+      createMockIssue({
+        url: 'url3',
+        title: 'Issue 3',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 3,
+        itemId: 'item-3',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
 
-      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-        createMockStoryObjectMap([issueWithPastNextActionDate]),
-      );
-      mockLocalCommandRunner.runCommand.mockResolvedValue({
-        stdout: '',
-        stderr: '',
-        exitCode: 0,
-      });
+    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: ['.codex-dev1', '.codex-dev2'],
+      allowIssueCacheMinutes: 0,
+    });
 
-      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(3);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][1]).toContain(
+      '--codexHome',
+    );
+    expect(
+      mockLocalCommandRunner.runCommand.mock.calls[0][1][
+        mockLocalCommandRunner.runCommand.mock.calls[0][1].indexOf(
+          '--codexHome',
+        ) + 1
+      ],
+    ).toBe('.codex-dev1');
+    expect(mockLocalCommandRunner.runCommand.mock.calls[1][1]).toContain(
+      '--codexHome',
+    );
+    expect(
+      mockLocalCommandRunner.runCommand.mock.calls[1][1][
+        mockLocalCommandRunner.runCommand.mock.calls[1][1].indexOf(
+          '--codexHome',
+        ) + 1
+      ],
+    ).toBe('.codex-dev2');
+    expect(mockLocalCommandRunner.runCommand.mock.calls[2][1]).toContain(
+      '--codexHome',
+    );
+    expect(
+      mockLocalCommandRunner.runCommand.mock.calls[2][1][
+        mockLocalCommandRunner.runCommand.mock.calls[2][1].indexOf(
+          '--codexHome',
+        ) + 1
+      ],
+    ).toBe('.codex-dev1');
+  });
 
-      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-        url: 'https://github.com/user/repo/issues/1',
-        status: 'Preparation',
-      });
-      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    } finally {
-      jest.useRealTimers();
-    }
+  it('should persist Preparation status via updateStatus with resolved status option id (regression for issue #519)', async () => {
+    const awaitingIssue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/519',
+      title: 'Regression issue',
+      labels: ['category:impl'],
+      status: 'Awaiting Workspace',
+      itemId: 'item-regression',
+    });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    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,
+    });
+
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.updateStatus.mock.calls[0][0]).toBe(mockProject);
+    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+      url: 'https://github.com/user/repo/issues/519',
+      itemId: 'item-regression',
+    });
+    expect(mockIssueRepository.updateStatus.mock.calls[0][2]).toBe('2');
+    const updateStatusCallOrder =
+      mockIssueRepository.updateStatus.mock.invocationCallOrder[0];
+    const runCommandCallOrder =
+      mockLocalCommandRunner.runCommand.mock.invocationCallOrder[0];
+    expect(updateStatusCallOrder).toBeLessThan(runCommandCallOrder);
   });
 
-  it('should not skip issues where nextActionHour is in the past or current hour', async () => {
-    jest.useFakeTimers();
-    try {
-      jest.setSystemTime(new Date('2024-01-01T15:00:00'));
+  it('should return early and log an error when preparationStatus option is not in the project', async () => {
+    const projectWithoutPreparation: Project = {
+      ...createMockProject(),
+      status: {
+        name: 'Status',
+        fieldId: 'status-field-id',
+        statuses: [
+          {
+            id: '1',
+            name: 'Awaiting Workspace',
+            color: 'GRAY',
+            description: '',
+          },
+          { id: '3', name: 'Done', color: 'GREEN', description: '' },
+        ],
+      },
+    };
+    const awaitingIssue = createMockIssue({
+      url: 'url-missing-option',
+      title: 'Missing Preparation Option',
+      labels: ['category:impl'],
+      status: 'Awaiting Workspace',
+    });
+    mockProjectRepository.getByUrl.mockResolvedValue(projectWithoutPreparation);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
+    const consoleErrorSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+
+    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,
+    });
 
-      const issueWithPastNextActionHour = createMockIssue({
-        url: 'https://github.com/user/repo/issues/1',
-        title: 'Issue with past next action hour',
-        labels: [],
-        status: 'Awaiting Workspace',
-        nextActionHour: 10,
-      });
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      "Preparation status option 'Preparation' not found in project.",
+    );
+    consoleErrorSpy.mockRestore();
+  });
 
-      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-        createMockStoryObjectMap([issueWithPastNextActionHour]),
-      );
-      mockLocalCommandRunner.runCommand.mockResolvedValue({
-        stdout: '',
-        stderr: '',
-        exitCode: 0,
-      });
+  it('should pass allowIssueCacheMinutes to getStoryObjectMap', async () => {
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([]),
+    );
 
-      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,
-      });
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+      codexHomeCandidates: null,
+      allowIssueCacheMinutes: 5,
+    });
 
-      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-      expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-        url: 'https://github.com/user/repo/issues/1',
-        status: 'Preparation',
-      });
-      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    } finally {
-      jest.useRealTimers();
-    }
+    expect(mockIssueRepository.getStoryObjectMap).toHaveBeenCalledWith(
+      expect.objectContaining({ id: 'project-1' }),
+      5,
+    );
   });
 
-  it('should skip issues from non-allowed authors', async () => {
-    const issueFromAllowedAuthor = createMockIssue({
+  it('should skip closed issues in awaiting workspace status', async () => {
+    const closedIssue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',
-      title: 'Issue from allowed author',
+      title: 'Closed issue',
       labels: [],
       status: 'Awaiting Workspace',
-      author: 'user1',
+      isClosed: true,
     });
-    const issueFromNonAllowedAuthor = createMockIssue({
+    const openIssue = createMockIssue({
       url: 'https://github.com/user/repo/issues/2',
-      title: 'Issue from non-allowed author',
+      number: 2,
+      title: 'Open issue',
       labels: [],
       status: 'Awaiting Workspace',
-      author: 'user3',
+      isClosed: false,
     });
 
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([
-        issueFromAllowedAuthor,
-        issueFromNonAllowedAuthor,
-      ]),
+      createMockStoryObjectMap([closedIssue, openIssue]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
@@ -1991,49 +2118,49 @@ describe('StartPreparationUseCase', () => {
       configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
       utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: ['user1', 'user2'],
+      allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
     });
 
     expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
     expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-      url: 'https://github.com/user/repo/issues/1',
-      status: 'Preparation',
+      url: 'https://github.com/user/repo/issues/2',
     });
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
   });
 
-  it('should process all issues when allowedIssueAuthors is null', async () => {
-    const issue1 = createMockIssue({
-      url: 'https://github.com/user/repo/issues/1',
+  it('should pass CLAUDE_CODE_OAUTH_TOKEN and ANTHROPIC_BASE_URL to runCommand when tokens are available', async () => {
+    const awaitingIssue = createMockIssue({
+      url: 'url1',
       title: 'Issue 1',
-      labels: [],
-      status: 'Awaiting Workspace',
-      author: 'user1',
-    });
-    const issue2 = createMockIssue({
-      url: 'https://github.com/user/repo/issues/2',
-      title: 'Issue 2',
-      labels: [],
+      labels: ['category:impl'],
       status: 'Awaiting Workspace',
-      author: 'user2',
+      number: 1,
+      itemId: 'item-1',
     });
-
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([issue1, issue2]),
+      createMockStoryObjectMap([awaitingIssue]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
       exitCode: 0,
     });
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        token: 'token-a',
+        fiveHourUtilization: 0,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+    ]);
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
       defaultAgentName: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmModelName: 'claude-opus',
       defaultLlmAgentName: null,
       configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
@@ -2043,112 +2170,184 @@ describe('StartPreparationUseCase', () => {
       allowIssueCacheMinutes: 0,
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(2);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(2);
-  });
-
-  it('should skip issues with empty author when allowedIssueAuthors is configured (deny-by-default)', async () => {
-    const issueWithEmptyAuthor = createMockIssue({
-      url: 'https://github.com/user/repo/issues/1',
-      title: 'Issue with empty author',
-      labels: [],
-      status: 'Awaiting Workspace',
-      author: '',
-    });
-    const issueWithKnownAuthor = createMockIssue({
-      url: 'https://github.com/user/repo/issues/2',
-      title: 'Issue with known author',
-      labels: [],
-      status: 'Awaiting Workspace',
-      author: 'user1',
-      number: 2,
-      itemId: 'item-2',
+    expect(
+      mockClaudeTokenUsageRepository.getAvailableTokenUsages.mock.calls,
+    ).toHaveLength(1);
+    expect(
+      mockClaudeTokenUsageRepository.ensureObservable.mock.calls,
+    ).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-a',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
     });
+  });
 
+  it('should rotate Claude OAuth tokens round-robin across multiple awaiting issues', 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',
+      }),
+      createMockIssue({
+        url: 'url3',
+        title: 'Issue 3',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+        number: 3,
+        itemId: 'item-3',
+      }),
+    ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([issueWithEmptyAuthor, issueWithKnownAuthor]),
+      createMockStoryObjectMap(awaitingIssues),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
       exitCode: 0,
     });
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        token: 'token-a',
+        fiveHourUtilization: 0,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-b',
+        fiveHourUtilization: 0,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+    ]);
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
       defaultAgentName: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmModelName: 'claude-opus',
       defaultLlmAgentName: null,
       configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
       utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: ['user1', 'user2'],
+      allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-      url: 'https://github.com/user/repo/issues/2',
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toMatchObject({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-a',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
+    expect(mockLocalCommandRunner.runCommand.mock.calls[1][2]).toMatchObject({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-b',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
+    expect(mockLocalCommandRunner.runCommand.mock.calls[2][2]).toMatchObject({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-a',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
     });
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
   });
 
-  it('should skip issue with empty author when allowedIssueAuthors is set', async () => {
-    const issueWithEmptyAuthor = createMockIssue({
-      url: 'https://github.com/user/repo/issues/1',
-      title: 'Issue with empty author',
-      labels: [],
+  it('should not inject env when no tokens are available', async () => {
+    const awaitingIssue = createMockIssue({
+      url: 'url1',
+      title: 'Issue 1',
+      labels: ['category:impl'],
       status: 'Awaiting Workspace',
-      author: '',
+      number: 1,
+      itemId: 'item-1',
     });
-
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([issueWithEmptyAuthor]),
+      createMockStoryObjectMap([awaitingIssue]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
       exitCode: 0,
     });
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue(
+      [],
+    );
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
       defaultAgentName: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmModelName: 'claude-opus',
       defaultLlmAgentName: null,
       configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
       utilizationPercentageThreshold: 90,
-      allowedIssueAuthors: ['user1'],
+      allowedIssueAuthors: null,
       codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toBeUndefined();
+    expect(
+      mockClaudeTokenUsageRepository.ensureObservable.mock.calls,
+    ).toHaveLength(0);
   });
 
-  it('should not pass --codexHome when codexHomeCandidates is null', async () => {
-    const awaitingIssues: Issue[] = [
-      createMockIssue({
-        url: 'url1',
-        title: 'Issue 1',
-        labels: ['category:impl'],
-        status: 'Awaiting Workspace',
-      }),
-    ];
+  it('should pick the least-utilized token first', 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(awaitingIssues),
+      createMockStoryObjectMap([awaitingIssue]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
       exitCode: 0,
     });
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        token: 'token-high',
+        fiveHourUtilization: 0.8,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-low',
+        fiveHourUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+    ]);
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
@@ -2164,38 +2363,48 @@ describe('StartPreparationUseCase', () => {
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
-      'aw',
-      [
-        'url1',
-        'impl',
-        'claude-opus',
-        '--configFilePath',
-        '/path/to/config.yml',
-        '--branch',
-        'i1',
-      ],
-    ]);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-low',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
   });
 
-  it('should not pass --codexHome when codexHomeCandidates is empty array', async () => {
-    const awaitingIssues: Issue[] = [
-      createMockIssue({
-        url: 'url1',
-        title: 'Issue 1',
-        labels: ['category:impl'],
-        status: 'Awaiting Workspace',
-      }),
-    ];
+  it('should exclude blocked tokens from rotation', 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(awaitingIssues),
+      createMockStoryObjectMap([awaitingIssue]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
       exitCode: 0,
     });
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        token: 'token-blocked',
+        fiveHourUtilization: 0.05,
+        blocked: true,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-ok',
+        fiveHourUtilization: 0.5,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+    ]);
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
@@ -2206,43 +2415,56 @@ describe('StartPreparationUseCase', () => {
       maximumPreparingIssuesCount: null,
       utilizationPercentageThreshold: 90,
       allowedIssueAuthors: null,
-      codexHomeCandidates: [],
+      codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
-      'aw',
-      [
-        'url1',
-        'impl',
-        'claude-opus',
-        '--configFilePath',
-        '/path/to/config.yml',
-        '--branch',
-        'i1',
-      ],
-    ]);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-ok',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
   });
 
-  it('should pass --codexHome with the candidate when codexHomeCandidates has one entry', async () => {
-    const awaitingIssues: Issue[] = [
-      createMockIssue({
-        url: 'url1',
-        title: 'Issue 1',
-        labels: ['category:impl'],
-        status: 'Awaiting Workspace',
-      }),
-    ];
+  it('should skip preparation when every configured token is blocked', 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(awaitingIssues),
+      createMockStoryObjectMap([awaitingIssue]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
       exitCode: 0,
     });
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        token: 'token-a',
+        fiveHourUtilization: 0.05,
+        blocked: true,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-b',
+        fiveHourUtilization: 0.08,
+        blocked: true,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+    ]);
+    const consoleWarnSpy = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => {});
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
@@ -2253,28 +2475,23 @@ describe('StartPreparationUseCase', () => {
       maximumPreparingIssuesCount: null,
       utilizationPercentageThreshold: 90,
       allowedIssueAuthors: null,
-      codexHomeCandidates: ['.codex-dev1'],
+      codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
     });
 
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
-      'aw',
-      [
-        'url1',
-        'impl',
-        'claude-opus',
-        '--configFilePath',
-        '/path/to/config.yml',
-        '--branch',
-        'i1',
-        '--codexHome',
-        '.codex-dev1',
-      ],
-    ]);
+    expect(
+      mockClaudeTokenUsageRepository.ensureObservable.mock.calls,
+    ).toHaveLength(0);
+    expect(mockProjectRepository.getByUrl).not.toHaveBeenCalled();
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Skipping starting preparation'),
+    );
+    consoleWarnSpy.mockRestore();
   });
 
-  it('should cycle through codexHomeCandidates across multiple issues', async () => {
+  it('should return all tokens sorted ascending when all are below the threshold', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
         url: 'url1',
@@ -2310,6 +2527,29 @@ describe('StartPreparationUseCase', () => {
       stderr: '',
       exitCode: 0,
     });
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        token: 'token-mid',
+        fiveHourUtilization: 0.5,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-low',
+        fiveHourUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-high',
+        fiveHourUtilization: 0.8,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+    ]);
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
@@ -2320,118 +2560,56 @@ describe('StartPreparationUseCase', () => {
       maximumPreparingIssuesCount: null,
       utilizationPercentageThreshold: 90,
       allowedIssueAuthors: null,
-      codexHomeCandidates: ['.codex-dev1', '.codex-dev2'],
+      codexHomeCandidates: null,
       allowIssueCacheMinutes: 0,
     });
 
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][1]).toContain(
-      '--codexHome',
-    );
-    expect(
-      mockLocalCommandRunner.runCommand.mock.calls[0][1][
-        mockLocalCommandRunner.runCommand.mock.calls[0][1].indexOf(
-          '--codexHome',
-        ) + 1
-      ],
-    ).toBe('.codex-dev1');
-    expect(mockLocalCommandRunner.runCommand.mock.calls[1][1]).toContain(
-      '--codexHome',
-    );
-    expect(
-      mockLocalCommandRunner.runCommand.mock.calls[1][1][
-        mockLocalCommandRunner.runCommand.mock.calls[1][1].indexOf(
-          '--codexHome',
-        ) + 1
-      ],
-    ).toBe('.codex-dev2');
-    expect(mockLocalCommandRunner.runCommand.mock.calls[2][1]).toContain(
-      '--codexHome',
-    );
-    expect(
-      mockLocalCommandRunner.runCommand.mock.calls[2][1][
-        mockLocalCommandRunner.runCommand.mock.calls[2][1].indexOf(
-          '--codexHome',
-        ) + 1
-      ],
-    ).toBe('.codex-dev1');
-  });
-
-  it('should persist Preparation status via updateStatus with resolved status option id (regression for issue #519)', async () => {
-    const awaitingIssue = createMockIssue({
-      url: 'https://github.com/user/repo/issues/519',
-      title: 'Regression issue',
-      labels: ['category:impl'],
-      status: 'Awaiting Workspace',
-      itemId: 'item-regression',
-    });
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([awaitingIssue]),
-    );
-    mockLocalCommandRunner.runCommand.mockResolvedValue({
-      stdout: '',
-      stderr: '',
-      exitCode: 0,
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toMatchObject({
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-low' },
     });
-
-    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,
+    expect(mockLocalCommandRunner.runCommand.mock.calls[1][2]).toMatchObject({
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-mid' },
     });
-
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-    expect(mockIssueRepository.updateStatus.mock.calls[0][0]).toBe(mockProject);
-    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-      url: 'https://github.com/user/repo/issues/519',
-      itemId: 'item-regression',
+    expect(mockLocalCommandRunner.runCommand.mock.calls[2][2]).toMatchObject({
+      env: { CLAUDE_CODE_OAUTH_TOKEN: 'token-high' },
     });
-    expect(mockIssueRepository.updateStatus.mock.calls[0][2]).toBe('2');
-    const updateStatusCallOrder =
-      mockIssueRepository.updateStatus.mock.invocationCallOrder[0];
-    const runCommandCallOrder =
-      mockLocalCommandRunner.runCommand.mock.invocationCallOrder[0];
-    expect(updateStatusCallOrder).toBeLessThan(runCommandCallOrder);
   });
 
-  it('should return early and log an error when preparationStatus option is not in the project', async () => {
-    const projectWithoutPreparation: Project = {
-      ...createMockProject(),
-      status: {
-        name: 'Status',
-        fieldId: 'status-field-id',
-        statuses: [
-          {
-            id: '1',
-            name: 'Awaiting Workspace',
-            color: 'GRAY',
-            description: '',
-          },
-          { id: '3', name: 'Done', color: 'GREEN', description: '' },
-        ],
-      },
-    };
-    const awaitingIssue = createMockIssue({
-      url: 'url-missing-option',
-      title: 'Missing Preparation Option',
+  it('should exclude a token whose 5h utilization is at or above the threshold', async () => {
+    const awaitingIssue = createMockIssue({
+      url: 'url1',
+      title: 'Issue 1',
       labels: ['category:impl'],
       status: 'Awaiting Workspace',
+      number: 1,
+      itemId: 'item-1',
     });
-    mockProjectRepository.getByUrl.mockResolvedValue(projectWithoutPreparation);
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.getStoryObjectMap.mockResolvedValue(
       createMockStoryObjectMap([awaitingIssue]),
     );
-    const consoleErrorSpy = jest
-      .spyOn(console, 'error')
-      .mockImplementation(() => {});
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        token: 'token-at-threshold',
+        fiveHourUtilization: 0.9,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-below',
+        fiveHourUtilization: 0.4,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+    ]);
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
@@ -2446,70 +2624,111 @@ describe('StartPreparationUseCase', () => {
       allowIssueCacheMinutes: 0,
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      "Preparation status option 'Preparation' not found in project.",
-    );
-    consoleErrorSpy.mockRestore();
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-below',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
   });
 
-  it('should pass allowIssueCacheMinutes to getStoryObjectMap', async () => {
+  it('should exclude a rejected token from rotation', 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([]),
+      createMockStoryObjectMap([awaitingIssue]),
     );
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        token: 'token-rejected',
+        fiveHourUtilization: 0.1,
+        blocked: false,
+        rejected: true,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-ok',
+        fiveHourUtilization: 0.5,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+    ]);
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
       defaultAgentName: 'agent1',
-      defaultLlmModelName: null,
+      defaultLlmModelName: 'claude-opus',
       defaultLlmAgentName: null,
       configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
       utilizationPercentageThreshold: 90,
       allowedIssueAuthors: null,
       codexHomeCandidates: null,
-      allowIssueCacheMinutes: 5,
+      allowIssueCacheMinutes: 0,
     });
 
-    expect(mockIssueRepository.getStoryObjectMap).toHaveBeenCalledWith(
-      expect.objectContaining({ id: 'project-1' }),
-      5,
-    );
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-ok',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
   });
 
-  it('should skip closed issues in awaiting workspace status', async () => {
-    const closedIssue = createMockIssue({
-      url: 'https://github.com/user/repo/issues/1',
-      title: 'Closed issue',
-      labels: [],
-      status: 'Awaiting Workspace',
-      isClosed: true,
-    });
-    const openIssue = createMockIssue({
-      url: 'https://github.com/user/repo/issues/2',
-      number: 2,
-      title: 'Open issue',
-      labels: [],
+  it('should re-admit a token after its 5h window reset normalizes utilization to 0 and clears rejection', async () => {
+    const awaitingIssue = createMockIssue({
+      url: 'url1',
+      title: 'Issue 1',
+      labels: ['category:impl'],
       status: 'Awaiting Workspace',
-      isClosed: false,
+      number: 1,
+      itemId: 'item-1',
     });
-
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
     mockIssueRepository.getStoryObjectMap.mockResolvedValue(
-      createMockStoryObjectMap([closedIssue, openIssue]),
+      createMockStoryObjectMap([awaitingIssue]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
       exitCode: 0,
     });
+    mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
+      {
+        token: 'token-reset',
+        fiveHourUtilization: 0,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-busy',
+        fiveHourUtilization: 0.5,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
+    ]);
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
       defaultAgentName: 'agent1',
-      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmModelName: 'claude-opus',
       defaultLlmAgentName: null,
       configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
@@ -2519,13 +2738,16 @@ describe('StartPreparationUseCase', () => {
       allowIssueCacheMinutes: 0,
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-      url: 'https://github.com/user/repo/issues/2',
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-reset',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
     });
   });
 
-  it('should pass CLAUDE_CODE_OAUTH_TOKEN and ANTHROPIC_BASE_URL to runCommand when tokens are available', async () => {
+  it('should exclude a token whose 5h window has not reset and remains at or above threshold', async () => {
     const awaitingIssue = createMockIssue({
       url: 'url1',
       title: 'Issue 1',
@@ -2544,7 +2766,20 @@ describe('StartPreparationUseCase', () => {
       exitCode: 0,
     });
     mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
-      { token: 'token-a', fiveHourUtilization: 0, blocked: false },
+      {
+        token: 'token-saturated',
+        fiveHourUtilization: 0.95,
+        blocked: false,
+        rejected: true,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-ok',
+        fiveHourUtilization: 0.2,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
     ]);
 
     await useCase.run({
@@ -2560,51 +2795,27 @@ describe('StartPreparationUseCase', () => {
       allowIssueCacheMinutes: 0,
     });
 
-    expect(
-      mockClaudeTokenUsageRepository.getAvailableTokenUsages.mock.calls,
-    ).toHaveLength(1);
-    expect(
-      mockClaudeTokenUsageRepository.ensureObservable.mock.calls,
-    ).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
       env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-a',
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-ok',
         ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
       },
     });
   });
 
-  it('should rotate Claude OAuth tokens round-robin across multiple awaiting issues', 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',
-      }),
-      createMockIssue({
-        url: 'url3',
-        title: 'Issue 3',
-        labels: ['category:impl'],
-        status: 'Awaiting Workspace',
-        number: 3,
-        itemId: 'item-3',
-      }),
-    ];
+  it('should skip preparation when every configured token is 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(awaitingIssues),
+      createMockStoryObjectMap([awaitingIssue]),
     );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
@@ -2612,9 +2823,24 @@ describe('StartPreparationUseCase', () => {
       exitCode: 0,
     });
     mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
-      { token: 'token-a', fiveHourUtilization: 0, blocked: false },
-      { token: 'token-b', fiveHourUtilization: 0, blocked: false },
+      {
+        token: 'token-a',
+        fiveHourUtilization: 0.1,
+        blocked: false,
+        rejected: true,
+        modelWeeklyLimits: {},
+      },
+      {
+        token: 'token-b',
+        fiveHourUtilization: 0.2,
+        blocked: false,
+        rejected: true,
+        modelWeeklyLimits: {},
+      },
     ]);
+    const consoleWarnSpy = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => {});
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
@@ -2629,28 +2855,18 @@ describe('StartPreparationUseCase', () => {
       allowIssueCacheMinutes: 0,
     });
 
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toMatchObject({
-      env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-a',
-        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
-      },
-    });
-    expect(mockLocalCommandRunner.runCommand.mock.calls[1][2]).toMatchObject({
-      env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-b',
-        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
-      },
-    });
-    expect(mockLocalCommandRunner.runCommand.mock.calls[2][2]).toMatchObject({
-      env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-a',
-        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
-      },
-    });
+    expect(
+      mockClaudeTokenUsageRepository.ensureObservable.mock.calls,
+    ).toHaveLength(0);
+    expect(mockProjectRepository.getByUrl).not.toHaveBeenCalled();
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Skipping starting preparation'),
+    );
+    consoleWarnSpy.mockRestore();
   });
 
-  it('should not inject env when no tokens are available', async () => {
+  it('should proceed with legacy spawn without env injection when no token list is configured', async () => {
     const awaitingIssue = createMockIssue({
       url: 'url1',
       title: 'Issue 1',
@@ -2685,14 +2901,76 @@ describe('StartPreparationUseCase', () => {
       allowIssueCacheMinutes: 0,
     });
 
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toBeUndefined();
     expect(
       mockClaudeTokenUsageRepository.ensureObservable.mock.calls,
     ).toHaveLength(0);
+    expect(mockProjectRepository.getByUrl).toHaveBeenCalled();
+    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toBeUndefined();
   });
 
-  it('should pick the least-utilized token first', 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',
+      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 },
+        },
+      },
+      {
+        token: 'token-ok',
+        fiveHourUtilization: 0.5,
+        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][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-ok',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
+  });
+
+  it('should re-admit a token whose seven_day_sonnet rejection has been cleared by stale-reset expiry', async () => {
     const awaitingIssue = createMockIssue({
       url: 'url1',
       title: 'Issue 1',
@@ -2710,15 +2988,30 @@ describe('StartPreparationUseCase', () => {
       stderr: '',
       exitCode: 0,
     });
+    const pastReset = Math.floor(Date.now() / 1000) - 3600;
     mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
-      { token: 'token-high', fiveHourUtilization: 80, blocked: false },
-      { token: 'token-low', fiveHourUtilization: 10, blocked: false },
+      {
+        token: 'token-recovered',
+        fiveHourUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {
+          seven_day_sonnet: { rejected: false, resetsAt: pastReset },
+        },
+      },
+      {
+        token: 'token-busy',
+        fiveHourUtilization: 0.5,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
     ]);
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
       defaultAgentName: 'agent1',
-      defaultLlmModelName: 'claude-opus',
+      defaultLlmModelName: 'claude-sonnet-4-6',
       defaultLlmAgentName: null,
       configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
@@ -2731,13 +3024,13 @@ 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-recovered',
         ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
       },
     });
   });
 
-  it('should exclude blocked tokens from rotation', async () => {
+  it('should not exclude a token for a sonnet-only rejection when the model is opus', async () => {
     const awaitingIssue = createMockIssue({
       url: 'url1',
       title: 'Issue 1',
@@ -2755,9 +3048,24 @@ describe('StartPreparationUseCase', () => {
       stderr: '',
       exitCode: 0,
     });
+    const futureReset = Math.floor(Date.now() / 1000) + 3600;
     mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
-      { token: 'token-blocked', fiveHourUtilization: 5, blocked: true },
-      { token: 'token-ok', fiveHourUtilization: 50, blocked: false },
+      {
+        token: 'token-sonnet-exhausted',
+        fiveHourUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {
+          seven_day_sonnet: { rejected: true, resetsAt: futureReset },
+        },
+      },
+      {
+        token: 'token-higher-util',
+        fiveHourUtilization: 0.5,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
     ]);
 
     await useCase.run({
@@ -2776,13 +3084,13 @@ describe('StartPreparationUseCase', () => {
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
       env: {
-        CLAUDE_CODE_OAUTH_TOKEN: 'token-ok',
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-sonnet-exhausted',
         ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
       },
     });
   });
 
-  it('should not inject env when every available token is blocked', async () => {
+  it('should exclude a token whose generic seven_day weekly limit is rejected regardless of model', async () => {
     const awaitingIssue = createMockIssue({
       url: 'url1',
       title: 'Issue 1',
@@ -2800,9 +3108,24 @@ describe('StartPreparationUseCase', () => {
       stderr: '',
       exitCode: 0,
     });
+    const futureReset = Math.floor(Date.now() / 1000) + 3600;
     mockClaudeTokenUsageRepository.getAvailableTokenUsages.mockResolvedValue([
-      { token: 'token-a', fiveHourUtilization: 5, blocked: true },
-      { token: 'token-b', fiveHourUtilization: 8, blocked: true },
+      {
+        token: 'token-weekly-exhausted',
+        fiveHourUtilization: 0.1,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {
+          seven_day: { rejected: true, resetsAt: futureReset },
+        },
+      },
+      {
+        token: 'token-ok',
+        fiveHourUtilization: 0.5,
+        blocked: false,
+        rejected: false,
+        modelWeeklyLimits: {},
+      },
     ]);
 
     await useCase.run({
@@ -2818,10 +3141,12 @@ describe('StartPreparationUseCase', () => {
       allowIssueCacheMinutes: 0,
     });
 
-    expect(
-      mockClaudeTokenUsageRepository.ensureObservable.mock.calls,
-    ).toHaveLength(0);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toBeUndefined();
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][2]).toEqual({
+      env: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-ok',
+        ANTHROPIC_BASE_URL: 'http://127.0.0.1:8787',
+      },
+    });
   });
 });