github-issue-tower-defence-management 2.10.1 → 2.11.0

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

@@ -97,6 +97,7 @@ describe('ConflictedIssueRevertUseCase', () => {
     getAllIssues: jest.Mock;
     getOpenPullRequests: jest.Mock;
     updateStatus: jest.Mock;
+    updateBranch: jest.Mock;
   };
   let mockIssueCommentRepository: {
     createComment: jest.Mock;
@@ -122,6 +123,7 @@ describe('ConflictedIssueRevertUseCase', () => {
       }),
       getOpenPullRequests: jest.fn().mockResolvedValue(new Map()),
       updateStatus: jest.fn().mockResolvedValue(undefined),
+      updateBranch: jest.fn().mockResolvedValue(false),
     };
 
     mockIssueCommentRepository = {
@@ -144,7 +146,6 @@ describe('ConflictedIssueRevertUseCase', () => {
     });
 
     const excludedStatuses = [
-      'Awaiting Workspace',
       'Done',
       'Icebox',
       'Failed Preparation',
@@ -170,6 +171,73 @@ describe('ConflictedIssueRevertUseCase', () => {
       });
     });
 
+    it('should process Awaiting Workspace issues when their linked PR is conflicted and update-branch fails', async () => {
+      const issue = createMockIssue({ status: 'Awaiting Workspace' });
+      const prItem = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/1',
+        closingIssueReferenceUrls: [issue.url],
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue, prItem],
+        cacheUsed: false,
+      });
+      const conflictedPr = createMockRelatedPullRequest({
+        url: prItem.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      mockIssueRepository.getOpenPullRequests.mockResolvedValue(
+        new Map([[conflictedPr.url, conflictedPr]]),
+      );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
+
+      await useCase.run({ projectUrl });
+
+      expect(mockIssueRepository.updateBranch).toHaveBeenCalledWith(
+        conflictedPr.url,
+      );
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        issue,
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        issue,
+        'conflict',
+      );
+    });
+
+    it('should not update status or post comment when Awaiting Workspace PR update-branch succeeds', async () => {
+      const issue = createMockIssue({ status: 'Awaiting Workspace' });
+      const prItem = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/1',
+        closingIssueReferenceUrls: [issue.url],
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue, prItem],
+        cacheUsed: false,
+      });
+      const conflictedPr = createMockRelatedPullRequest({
+        url: prItem.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      mockIssueRepository.getOpenPullRequests.mockResolvedValue(
+        new Map([[conflictedPr.url, conflictedPr]]),
+      );
+      mockIssueRepository.updateBranch.mockResolvedValue(true);
+
+      await useCase.run({ projectUrl });
+
+      expect(mockIssueRepository.updateBranch).toHaveBeenCalledWith(
+        conflictedPr.url,
+      );
+      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+    });
+
     it('should skip PR items when scanning for target task issues', async () => {
       const prIssue = createMockIssue({
         url: 'https://github.com/user/repo/issues/1',
@@ -195,6 +263,7 @@ describe('ConflictedIssueRevertUseCase', () => {
       mockIssueRepository.getOpenPullRequests.mockResolvedValue(
         new Map([[conflictedPr.url, conflictedPr]]),
       );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
 
       await useCase.run({ projectUrl });
 
@@ -255,7 +324,85 @@ describe('ConflictedIssueRevertUseCase', () => {
       expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
     });
 
-    it('should update status and post conflict comment when linked PR is conflicted', async () => {
+    it('should update status and post conflict comment when linked PR is conflicted and update-branch fails', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      const prItem = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/1',
+        closingIssueReferenceUrls: [issue.url],
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue, prItem],
+        cacheUsed: false,
+      });
+      const conflictedPr = createMockRelatedPullRequest({
+        url: prItem.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      mockIssueRepository.getOpenPullRequests.mockResolvedValue(
+        new Map([[conflictedPr.url, conflictedPr]]),
+      );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
+
+      await useCase.run({ projectUrl });
+
+      expect(mockIssueRepository.updateBranch).toHaveBeenCalledWith(
+        conflictedPr.url,
+      );
+      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+        mockProject,
+        issue,
+        'awaiting-workspace-id',
+      );
+      expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+        issue,
+        'conflict',
+      );
+    });
+
+    it('should propagate errors thrown by updateBranch', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      const prItem = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/1',
+        closingIssueReferenceUrls: [issue.url],
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue, prItem],
+        cacheUsed: false,
+      });
+      const conflictedPr = createMockRelatedPullRequest({
+        url: prItem.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      mockIssueRepository.getOpenPullRequests.mockResolvedValue(
+        new Map([[conflictedPr.url, conflictedPr]]),
+      );
+      mockIssueRepository.updateBranch.mockRejectedValue(
+        new Error(
+          'Failed to update branch for PR https://github.com/user/repo/pull/1: 500 Internal Server Error',
+        ),
+      );
+
+      await expect(useCase.run({ projectUrl })).rejects.toThrow(
+        'Failed to update branch for PR',
+      );
+      expect(mockIssueRepository.updateBranch).toHaveBeenCalledWith(
+        conflictedPr.url,
+      );
+      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+    });
+
+    it('should not update status or post comment when update-branch succeeds for the conflicted PR', async () => {
       const issue = createMockIssue({
         url: 'https://github.com/user/repo/issues/1',
         status: 'Preparation',
@@ -277,6 +424,105 @@ describe('ConflictedIssueRevertUseCase', () => {
       mockIssueRepository.getOpenPullRequests.mockResolvedValue(
         new Map([[conflictedPr.url, conflictedPr]]),
       );
+      mockIssueRepository.updateBranch.mockResolvedValue(true);
+
+      await useCase.run({ projectUrl });
+
+      expect(mockIssueRepository.updateBranch).toHaveBeenCalledWith(
+        conflictedPr.url,
+      );
+      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+      expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+    });
+
+    it('should call update-branch only for conflicted PRs, not for all linked PRs', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      const prItem1 = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/1',
+        number: 1,
+        closingIssueReferenceUrls: [issue.url],
+      });
+      const prItem2 = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/2',
+        number: 2,
+        closingIssueReferenceUrls: [issue.url],
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue, prItem1, prItem2],
+        cacheUsed: false,
+      });
+      const conflictedPr = createMockRelatedPullRequest({
+        url: prItem1.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      const mergeablePr = createMockRelatedPullRequest({
+        url: prItem2.url,
+        isConflicted: false,
+        mergeable: 'MERGEABLE',
+      });
+      mockIssueRepository.getOpenPullRequests.mockResolvedValue(
+        new Map([
+          [conflictedPr.url, conflictedPr],
+          [mergeablePr.url, mergeablePr],
+        ]),
+      );
+      mockIssueRepository.updateBranch.mockResolvedValue(true);
+
+      await useCase.run({ projectUrl });
+
+      expect(mockIssueRepository.updateBranch).toHaveBeenCalledTimes(1);
+      expect(mockIssueRepository.updateBranch).toHaveBeenCalledWith(
+        conflictedPr.url,
+      );
+      expect(mockIssueRepository.updateBranch).not.toHaveBeenCalledWith(
+        mergeablePr.url,
+      );
+    });
+
+    it('should fall back to status update when any conflicted PR update-branch fails', async () => {
+      const issue = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      const prItem1 = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/1',
+        number: 1,
+        closingIssueReferenceUrls: [issue.url],
+      });
+      const prItem2 = createMockPrItem({
+        url: 'https://github.com/user/repo/pull/2',
+        number: 2,
+        closingIssueReferenceUrls: [issue.url],
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue, prItem1, prItem2],
+        cacheUsed: false,
+      });
+      const conflictedPr1 = createMockRelatedPullRequest({
+        url: prItem1.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      const conflictedPr2 = createMockRelatedPullRequest({
+        url: prItem2.url,
+        isConflicted: true,
+        mergeable: 'CONFLICTING',
+      });
+      mockIssueRepository.getOpenPullRequests.mockResolvedValue(
+        new Map([
+          [conflictedPr1.url, conflictedPr1],
+          [conflictedPr2.url, conflictedPr2],
+        ]),
+      );
+      mockIssueRepository.updateBranch
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce(false);
 
       await useCase.run({ projectUrl });
 
@@ -313,6 +559,7 @@ describe('ConflictedIssueRevertUseCase', () => {
       mockIssueRepository.getOpenPullRequests.mockResolvedValue(
         new Map([[conflictedPr.url, conflictedPr]]),
       );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
 
       await useCase.run({ projectUrl });
 
@@ -430,6 +677,7 @@ describe('ConflictedIssueRevertUseCase', () => {
           [mergeablePr.url, mergeablePr],
         ]),
       );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
 
       await useCase.run({ projectUrl });
 
@@ -491,7 +739,7 @@ describe('ConflictedIssueRevertUseCase', () => {
       expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
     });
 
-    it('should perform status update before comment posting', async () => {
+    it('should call update-branch before status update and comment when update-branch fails', async () => {
       const callOrder: string[] = [];
       const issue = createMockIssue({
         url: 'https://github.com/user/repo/issues/1',
@@ -514,6 +762,10 @@ describe('ConflictedIssueRevertUseCase', () => {
       mockIssueRepository.getOpenPullRequests.mockResolvedValue(
         new Map([[conflictedPr.url, conflictedPr]]),
       );
+      mockIssueRepository.updateBranch.mockImplementation(() => {
+        callOrder.push('updateBranch');
+        return Promise.resolve(false);
+      });
       mockIssueRepository.updateStatus.mockImplementation(() => {
         callOrder.push('updateStatus');
         return Promise.resolve();
@@ -525,7 +777,11 @@ describe('ConflictedIssueRevertUseCase', () => {
 
       await useCase.run({ projectUrl });
 
-      expect(callOrder).toEqual(['updateStatus', 'createComment']);
+      expect(callOrder).toEqual([
+        'updateBranch',
+        'updateStatus',
+        'createComment',
+      ]);
     });
 
     it('should fetch all PR URLs in a single batched call', async () => {
@@ -567,7 +823,7 @@ describe('ConflictedIssueRevertUseCase', () => {
       );
     });
 
-    it('should process multiple conflicted issues in one run', async () => {
+    it('should process multiple conflicted issues in one run when update-branch fails for both', async () => {
       const issue1 = createMockIssue({
         url: 'https://github.com/user/repo/issues/1',
         number: 1,
@@ -609,6 +865,7 @@ describe('ConflictedIssueRevertUseCase', () => {
           [conflictedPr2.url, conflictedPr2],
         ]),
       );
+      mockIssueRepository.updateBranch.mockResolvedValue(false);
 
       await useCase.run({ projectUrl });
 

package/src/domain/usecases/ConflictedIssueRevertUseCase.ts

@@ -11,7 +11,6 @@ import {
 } from '../entities/WorkflowStatus';
 
 const EXCLUDED_STATUSES = new Set([
-  AWAITING_WORKSPACE_STATUS_NAME,
   DONE_STATUS_NAME,
   ICEBOX_STATUS_NAME,
   FAILED_PREPARATION_STATUS_NAME,
@@ -26,7 +25,7 @@ export class ConflictedIssueRevertUseCase {
     >,
     private readonly issueRepository: Pick<
       IssueRepository,
-      'getAllIssues' | 'getOpenPullRequests' | 'updateStatus'
+      'getAllIssues' | 'getOpenPullRequests' | 'updateStatus' | 'updateBranch'
     >,
     private readonly issueCommentRepository: Pick<
       IssueCommentRepository,
@@ -98,8 +97,17 @@ export class ConflictedIssueRevertUseCase {
         continue;
       }
 
-      const hasConflict = relatedPrs.some((pr) => pr.isConflicted);
-      if (!hasConflict) {
+      const conflictedPrs = relatedPrs.filter((pr) => pr.isConflicted);
+      if (conflictedPrs.length === 0) {
+        continue;
+      }
+
+      const allBranchesUpdated = (
+        await Promise.all(
+          conflictedPrs.map((pr) => this.issueRepository.updateBranch(pr.url)),
+        )
+      ).every(Boolean);
+      if (allBranchesUpdated) {
         continue;
       }
 

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

@@ -10,6 +10,7 @@ import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
 import { LocalCommandRunner } from './adapter-interfaces/LocalCommandRunner';
 import { ClaudeTokenUsageRepository } from './adapter-interfaces/ClaudeTokenUsageRepository';
 import { TakeOwnershipSpawnRepository } from './adapter-interfaces/TakeOwnershipSpawnRepository';
+import { GitHubGraphqlRateLimitRepository } from './adapter-interfaces/GitHubGraphqlRateLimitRepository';
 import { ClaudeTokenUsage } from '../entities/ClaudeTokenUsage';
 import { Issue } from '../entities/Issue';
 import { FieldOption, Project } from '../entities/Project';
@@ -109,6 +110,7 @@ describe('StartPreparationUseCase', () => {
   let mockLocalCommandRunner: Mocked<LocalCommandRunner>;
   let mockClaudeTokenUsageRepository: Mocked<ClaudeTokenUsageRepository>;
   let mockTakeOwnershipSpawnRepository: Mocked<TakeOwnershipSpawnRepository>;
+  let mockGitHubGraphqlRateLimitRepository: Mocked<GitHubGraphqlRateLimitRepository>;
   let mockProject: Project;
   beforeEach(() => {
     jest.resetAllMocks();
@@ -144,12 +146,16 @@ describe('StartPreparationUseCase', () => {
       listSpawns: jest.fn().mockReturnValue([]),
       listRunningIssueUrls: jest.fn().mockReturnValue([]),
     };
+    mockGitHubGraphqlRateLimitRepository = {
+      getRemainingRequestCount: jest.fn().mockResolvedValue(null),
+    };
     useCase = new StartPreparationUseCase(
       mockProjectRepository,
       mockIssueRepository,
       mockLocalCommandRunner,
       mockClaudeTokenUsageRepository,
       mockTakeOwnershipSpawnRepository,
+      mockGitHubGraphqlRateLimitRepository,
     );
   });
   it('should run aw command for awaiting workspace issues', async () => {
@@ -627,6 +633,225 @@ describe('StartPreparationUseCase', () => {
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
   });
 
+  it('skips all spawning when active worker count meets the maxConcurrentWorkers cap', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'https://github.com/user/repo/issues/10',
+        status: 'Awaiting Workspace',
+        author: 'testuser',
+      }),
+      createMockIssue({
+        number: 2,
+        url: 'https://github.com/user/repo/issues/11',
+        status: 'Awaiting Workspace',
+        author: 'testuser',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockTakeOwnershipSpawnRepository.listRunningIssueUrls.mockReturnValue([
+      'https://github.com/user/repo/issues/1',
+      'https://github.com/user/repo/issues/2',
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      fallbackLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: ['testuser'],
+      manager: 'manager-user',
+      codexHomeCandidates: null,
+      labelsAsLlmAgentName: null,
+      maxConcurrentWorkers: 2,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    expect(
+      mockLocalCommandRunner.runCommand.mock.calls.map((c) => c[0]),
+    ).not.toContain('aw');
+  });
+
+  it('stops spawning mid-loop when workers started in the run bring the count to the cap', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'https://github.com/user/repo/issues/10',
+        status: 'Awaiting Workspace',
+        author: 'testuser',
+      }),
+      createMockIssue({
+        number: 2,
+        url: 'https://github.com/user/repo/issues/11',
+        status: 'Awaiting Workspace',
+        author: 'testuser',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValue([]);
+    mockTakeOwnershipSpawnRepository.listRunningIssueUrls.mockReturnValue([]);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      fallbackLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: ['testuser'],
+      manager: 'manager-user',
+      codexHomeCandidates: null,
+      labelsAsLlmAgentName: null,
+      maxConcurrentWorkers: 1,
+    });
+
+    const awCalls = mockLocalCommandRunner.runCommand.mock.calls.filter(
+      (call) => call[0] === 'aw',
+    );
+    expect(awCalls).toHaveLength(1);
+  });
+
+  it('skips the preparation cycle when GraphQL rate limit is below the floor', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'https://github.com/user/repo/issues/10',
+        status: 'Awaiting Workspace',
+        author: 'testuser',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockGitHubGraphqlRateLimitRepository.getRemainingRequestCount.mockResolvedValue(
+      499,
+    );
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      fallbackLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: ['testuser'],
+      manager: 'manager-user',
+      codexHomeCandidates: null,
+      labelsAsLlmAgentName: null,
+      graphqlRateLimitFloor: 500,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    expect(
+      mockLocalCommandRunner.runCommand.mock.calls.map((c) => c[0]),
+    ).not.toContain('aw');
+  });
+
+  it('proceeds with spawning when GraphQL remaining equals the floor exactly', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'https://github.com/user/repo/issues/10',
+        status: 'Awaiting Workspace',
+        author: 'testuser',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValue([]);
+    mockGitHubGraphqlRateLimitRepository.getRemainingRequestCount.mockResolvedValue(
+      500,
+    );
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      fallbackLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: ['testuser'],
+      manager: 'manager-user',
+      codexHomeCandidates: null,
+      labelsAsLlmAgentName: null,
+      graphqlRateLimitFloor: 500,
+    });
+
+    const awCalls = mockLocalCommandRunner.runCommand.mock.calls.filter(
+      (call) => call[0] === 'aw',
+    );
+    expect(awCalls).toHaveLength(1);
+  });
+
+  it('proceeds with spawning when GraphQL rate limit check returns null', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'https://github.com/user/repo/issues/10',
+        status: 'Awaiting Workspace',
+        author: 'testuser',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValue([]);
+    mockGitHubGraphqlRateLimitRepository.getRemainingRequestCount.mockResolvedValue(
+      null,
+    );
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      fallbackLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: ['testuser'],
+      manager: 'manager-user',
+      codexHomeCandidates: null,
+      labelsAsLlmAgentName: null,
+      graphqlRateLimitFloor: 500,
+    });
+
+    const awCalls = mockLocalCommandRunner.runCommand.mock.calls.filter(
+      (call) => call[0] === 'aw',
+    );
+    expect(awCalls).toHaveLength(1);
+  });
+
   it('should pass --branch to aw command when issue has an existing linked PR', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
@@ -7055,6 +7280,7 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
       listSpawns: jest.fn().mockReturnValue([]),
       listRunningIssueUrls: jest.fn().mockReturnValue([]),
     },
+    { getRemainingRequestCount: jest.fn().mockResolvedValue(null) },
   );
 
   it('lists selected tokens first in ascending 7-day reset deadline order then excluded tokens', () => {
@@ -7354,6 +7580,7 @@ describe('StartPreparationUseCase.getTokenConcurrentLimit', () => {
         listSpawns: jest.fn().mockReturnValue([]),
         listRunningIssueUrls: jest.fn().mockReturnValue([]),
       },
+      { getRemainingRequestCount: jest.fn().mockResolvedValue(null) },
     );
   });
 
@@ -7465,6 +7692,7 @@ describe('StartPreparationUseCase.run normalConcurrentLimit', () => {
       mockLocalCommandRunner,
       mockClaudeTokenUsageRepository,
       mockTakeOwnershipSpawnRepository,
+      { getRemainingRequestCount: jest.fn().mockResolvedValue(null) },
     );
 
     await useCase.run({
@@ -7542,6 +7770,7 @@ describe('StartPreparationUseCase.fetchSpawnCandidateBranchSources', () => {
         listSpawns: jest.fn().mockReturnValue([]),
         listRunningIssueUrls: jest.fn().mockReturnValue([]),
       },
+      { getRemainingRequestCount: jest.fn().mockResolvedValue(null) },
     );
 
   it('looks up related open pull requests for issue urls concurrently up to the configured limit', async () => {