github-issue-tower-defence-management 1.69.5 → 1.69.7

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

@@ -9,8 +9,24 @@ import { ClaudeTokenUsageRepository } from './adapter-interfaces/ClaudeTokenUsag
 import { ClaudeTokenUsage } from '../entities/ClaudeTokenUsage';
 import { Issue } from '../entities/Issue';
 import { Project } from '../entities/Project';
+import { StoryObjectMap } from '../entities/StoryObjectMap';
 type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
 
+const createMockStoryObjectMap = (issues: Issue[]): StoryObjectMap => {
+  const map: StoryObjectMap = new Map();
+  map.set('Default Story', {
+    story: {
+      id: 'story-1',
+      name: 'Default Story',
+      color: 'GRAY',
+      description: '',
+    },
+    storyIssue: null,
+    issues: issues,
+  });
+  return map;
+};
+
 const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   nameWithOwner: 'user/repo',
   number: 1,
@@ -66,7 +82,7 @@ describe('StartPreparationUseCase', () => {
   let mockIssueRepository: Mocked<
     Pick<
       IssueRepository,
-      | 'getAllOpened'
+      | 'getStoryObjectMap'
       | 'updateStatus'
       | 'findRelatedOpenPRs'
       | 'getOpenPullRequest'
@@ -85,7 +101,7 @@ describe('StartPreparationUseCase', () => {
       getByUrl: jest.fn(),
     };
     mockIssueRepository = {
-      getAllOpened: jest.fn().mockResolvedValue([]),
+      getStoryObjectMap: jest.fn().mockResolvedValue(new Map()),
       updateStatus: jest.fn(),
       findRelatedOpenPRs: jest.fn().mockResolvedValue([]),
       getOpenPullRequest: jest.fn().mockResolvedValue(null),
@@ -118,7 +134,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -158,56 +176,6 @@ describe('StartPreparationUseCase', () => {
       ],
     ]);
   });
-  it('should move awaiting workspace issue with story=null to preparation', async () => {
-    const issueWithoutStory = createMockIssue({
-      url: 'https://github.com/user/repo/issues/55',
-      number: 55,
-      title: 'Issue without story',
-      labels: ['category:impl'],
-      status: 'Awaiting Workspace',
-      story: null,
-    });
-    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([issueWithoutStory]);
-    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,
-      labelsAsLlmAgentName: null,
-    });
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
-      url: 'https://github.com/user/repo/issues/55',
-      story: null,
-      status: 'Preparation',
-    });
-    expect(mockIssueRepository.updateStatus.mock.calls[0][2]).toBe('2');
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
-      'aw',
-      [
-        'https://github.com/user/repo/issues/55',
-        'impl',
-        'claude-opus',
-        '--configFilePath',
-        '/path/to/config.yml',
-        '--branch',
-        'i55',
-      ],
-    ]);
-  });
   it('should pass --branch to aw command when issue has an existing linked PR', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
@@ -230,7 +198,9 @@ describe('StartPreparationUseCase', () => {
       missingRequiredCheckNames: [],
     };
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([existingPR]);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
@@ -274,7 +244,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockIssueRepository.getOpenPullRequest.mockResolvedValue({
       url: 'https://github.com/user/repo/pull/354',
       branchName: 'dependabot/npm_and_yarn/multi-cc382f683c',
@@ -333,7 +305,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockIssueRepository.getOpenPullRequest.mockResolvedValue(null);
     const consoleWarnSpy = jest
       .spyOn(console, 'warn')
@@ -369,7 +343,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockIssueRepository.getOpenPullRequest.mockResolvedValue({
       url: 'https://github.com/user/repo/pull/999',
       branchName: null,
@@ -415,7 +391,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockIssueRepository.getOpenPullRequest.mockResolvedValue({
       url: 'https://github.com/user/repo/pull/999',
       branchName: 'evil$(rm -rf /)',
@@ -485,7 +463,9 @@ describe('StartPreparationUseCase', () => {
       missingRequiredCheckNames: [],
     };
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       olderPR,
       newerPR,
@@ -574,7 +554,9 @@ describe('StartPreparationUseCase', () => {
       missingRequiredCheckNames: [],
     };
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       olderPRNullBranch,
       newerPR,
@@ -636,7 +618,9 @@ describe('StartPreparationUseCase', () => {
       missingRequiredCheckNames: [],
     };
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
       prWithNullBranch,
     ]);
@@ -679,7 +663,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -734,10 +720,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([
-      ...preparationIssues,
-      ...awaitingIssues,
-    ]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([...preparationIssues, ...awaitingIssues]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -770,7 +755,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -813,7 +800,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -856,7 +845,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -899,7 +890,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -942,7 +935,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -985,7 +980,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1028,7 +1025,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1074,7 +1073,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1125,7 +1126,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(preparationIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(preparationIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1158,7 +1161,9 @@ describe('StartPreparationUseCase', () => {
       }),
     );
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1190,7 +1195,9 @@ describe('StartPreparationUseCase', () => {
       }),
     );
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1224,7 +1231,9 @@ describe('StartPreparationUseCase', () => {
       }),
     );
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1288,7 +1297,9 @@ describe('StartPreparationUseCase', () => {
       }),
     );
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1349,11 +1360,30 @@ describe('StartPreparationUseCase', () => {
       state: 'OPEN',
     });
 
+    const workflowBlockerMap: StoryObjectMap = new Map();
+    workflowBlockerMap.set('Workflow blocker', {
+      story: {
+        id: 'story-blocker',
+        name: 'Workflow blocker',
+        color: 'RED',
+        description: '',
+      },
+      storyIssue: null,
+      issues: [blockerIssue],
+    });
+    workflowBlockerMap.set('Default Story', {
+      story: {
+        id: 'story-1',
+        name: 'Default Story',
+        color: 'GRAY',
+        description: '',
+      },
+      storyIssue: null,
+      issues: [issueInBlockedRepo],
+    });
+
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([
-      blockerIssue,
-      issueInBlockedRepo,
-    ]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(workflowBlockerMap);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1399,10 +1429,9 @@ describe('StartPreparationUseCase', () => {
     });
 
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([
-      issueWithDependency,
-      issueWithoutDependency,
-    ]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([issueWithDependency, issueWithoutDependency]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1452,10 +1481,12 @@ describe('StartPreparationUseCase', () => {
       });
 
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getAllOpened.mockResolvedValue([
-        issueWithFutureNextActionHour,
-        issueWithoutNextActionHour,
-      ]);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([
+          issueWithFutureNextActionHour,
+          issueWithoutNextActionHour,
+        ]),
+      );
       mockLocalCommandRunner.runCommand.mockResolvedValue({
         stdout: '',
         stderr: '',
@@ -1508,10 +1539,12 @@ describe('StartPreparationUseCase', () => {
       });
 
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getAllOpened.mockResolvedValue([
-        issueWithFutureNextActionDate,
-        issueWithoutNextActionDate,
-      ]);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([
+          issueWithFutureNextActionDate,
+          issueWithoutNextActionDate,
+        ]),
+      );
       mockLocalCommandRunner.runCommand.mockResolvedValue({
         stdout: '',
         stderr: '',
@@ -1557,9 +1590,9 @@ describe('StartPreparationUseCase', () => {
       });
 
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getAllOpened.mockResolvedValue([
-        issueWithTodayNextActionDate,
-      ]);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([issueWithTodayNextActionDate]),
+      );
       mockLocalCommandRunner.runCommand.mockResolvedValue({
         stdout: '',
         stderr: '',
@@ -1605,9 +1638,9 @@ describe('StartPreparationUseCase', () => {
       });
 
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getAllOpened.mockResolvedValue([
-        issueWithPastNextActionDate,
-      ]);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([issueWithPastNextActionDate]),
+      );
       mockLocalCommandRunner.runCommand.mockResolvedValue({
         stdout: '',
         stderr: '',
@@ -1653,9 +1686,9 @@ describe('StartPreparationUseCase', () => {
       });
 
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getAllOpened.mockResolvedValue([
-        issueWithPastNextActionHour,
-      ]);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([issueWithPastNextActionHour]),
+      );
       mockLocalCommandRunner.runCommand.mockResolvedValue({
         stdout: '',
         stderr: '',
@@ -1704,10 +1737,12 @@ describe('StartPreparationUseCase', () => {
     });
 
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([
-      issueFromAllowedAuthor,
-      issueFromNonAllowedAuthor,
-    ]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([
+        issueFromAllowedAuthor,
+        issueFromNonAllowedAuthor,
+      ]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1753,7 +1788,9 @@ describe('StartPreparationUseCase', () => {
     });
 
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([issue1, issue2]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([issue1, issue2]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1797,10 +1834,9 @@ describe('StartPreparationUseCase', () => {
     });
 
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([
-      issueWithEmptyAuthor,
-      issueWithKnownAuthor,
-    ]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([issueWithEmptyAuthor, issueWithKnownAuthor]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1838,7 +1874,9 @@ describe('StartPreparationUseCase', () => {
     });
 
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([issueWithEmptyAuthor]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([issueWithEmptyAuthor]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1873,7 +1911,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1919,7 +1959,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -1965,7 +2007,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2031,7 +2075,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2094,7 +2140,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-regression',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2153,7 +2201,9 @@ describe('StartPreparationUseCase', () => {
       status: 'Awaiting Workspace',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(projectWithoutPreparation);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     const consoleErrorSpy = jest
       .spyOn(console, 'error')
       .mockImplementation(() => {});
@@ -2180,9 +2230,11 @@ describe('StartPreparationUseCase', () => {
     consoleErrorSpy.mockRestore();
   });
 
-  it('should pass allowIssueCacheMinutes to getAllOpened', async () => {
+  it('should pass allowIssueCacheMinutes to getStoryObjectMap', async () => {
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([]),
+    );
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
@@ -2198,7 +2250,7 @@ describe('StartPreparationUseCase', () => {
       labelsAsLlmAgentName: null,
     });
 
-    expect(mockIssueRepository.getAllOpened).toHaveBeenCalledWith(
+    expect(mockIssueRepository.getStoryObjectMap).toHaveBeenCalledWith(
       expect.objectContaining({ id: 'project-1' }),
       5,
     );
@@ -2222,10 +2274,9 @@ describe('StartPreparationUseCase', () => {
     });
 
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([
-      closedIssue,
-      openIssue,
-    ]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([closedIssue, openIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2262,7 +2313,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2337,7 +2390,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2409,7 +2464,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2450,7 +2507,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2521,7 +2580,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2581,7 +2642,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2647,7 +2710,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2731,7 +2796,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2821,7 +2888,9 @@ describe('StartPreparationUseCase', () => {
       }),
     );
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2872,7 +2941,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2932,7 +3003,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -2992,7 +3065,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3052,7 +3127,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3117,7 +3194,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3160,7 +3239,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3223,7 +3304,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3286,7 +3369,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3349,7 +3434,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3412,7 +3499,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3483,7 +3572,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3564,7 +3655,9 @@ describe('StartPreparationUseCase', () => {
       }),
     ];
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3630,7 +3723,9 @@ describe('StartPreparationUseCase', () => {
       itemId: 'item-1',
     });
     mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllOpened.mockResolvedValue([awaitingIssue]);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([awaitingIssue]),
+    );
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -3702,7 +3797,9 @@ describe('StartPreparationUseCase', () => {
         }),
       ];
       mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
-      mockIssueRepository.getAllOpened.mockResolvedValue(awaitingIssues);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap(awaitingIssues),
+      );
       mockLocalCommandRunner.runCommand.mockResolvedValue({
         stdout: '',
         stderr: '',
@@ -3827,7 +3924,7 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
   const mockIssueRepositoryForRotation: Mocked<
     Pick<
       IssueRepository,
-      | 'getAllOpened'
+      | 'getStoryObjectMap'
       | 'updateStatus'
       | 'findRelatedOpenPRs'
       | 'getOpenPullRequest'
@@ -3836,7 +3933,7 @@ describe('StartPreparationUseCase.buildRotationOrder', () => {
       | 'createCommentByUrl'
     >
   > = {
-    getAllOpened: jest.fn(),
+    getStoryObjectMap: jest.fn(),
     updateStatus: jest.fn(),
     findRelatedOpenPRs: jest.fn(),
     getOpenPullRequest: jest.fn(),