github-issue-tower-defence-management 1.40.0 → 1.41.0

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

@@ -1,19 +1,38 @@
 import { StartPreparationUseCase } from './StartPreparationUseCase';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import {
+  IssueRepository,
+  RelatedPullRequest,
+} from './adapter-interfaces/IssueRepository';
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
 import { LocalCommandRunner } from './adapter-interfaces/LocalCommandRunner';
 import { ClaudeRepository } from './adapter-interfaces/ClaudeRepository';
 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,
   title: 'Test Issue',
   state: 'OPEN',
   status: 'Backlog',
-  story: 'Default Story',
+  story: null,
   nextActionDate: null,
   nextActionHour: null,
   estimationMinutes: null,
@@ -30,12 +49,13 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   isInProgress: false,
   isClosed: false,
   createdAt: new Date(),
+  author: 'testuser',
   ...overrides,
 });
 
 const createMockProject = (): Project => ({
   id: 'project-1',
-  url: 'https://github.com/orgs/user/projects/1',
+  url: 'https://github.com/users/user/projects/1',
   databaseId: 1,
   name: 'Test Project',
   status: {
@@ -49,23 +69,7 @@ const createMockProject = (): Project => ({
   },
   nextActionDate: null,
   nextActionHour: null,
-  story: {
-    name: 'Story',
-    fieldId: 'story-field-id',
-    databaseId: 1,
-    stories: [
-      {
-        id: 'story-1',
-        name: 'Default Story',
-        color: 'GRAY',
-        description: '',
-      },
-    ],
-    workflowManagementStory: {
-      id: 'wf-1',
-      name: 'Workflow Management',
-    },
-  },
+  story: null,
   remainingEstimationMinutes: null,
   dependedIssueUrlSeparatedByComma: null,
   completionDate50PercentConfidence: null,
@@ -74,10 +78,17 @@ const createMockProject = (): Project => ({
 describe('StartPreparationUseCase', () => {
   let useCase: StartPreparationUseCase;
   let mockProjectRepository: Mocked<
-    Pick<ProjectRepository, 'findProjectIdByUrl' | 'getProject'>
+    Pick<ProjectRepository, 'getByUrl' | 'prepareStatus'>
   >;
   let mockIssueRepository: Mocked<
-    Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>
+    Pick<
+      IssueRepository,
+      | 'getAllOpened'
+      | 'getStoryObjectMap'
+      | 'update'
+      | 'findRelatedOpenPRs'
+      | 'getOpenPullRequest'
+    >
   >;
   let mockClaudeRepository: Mocked<Pick<ClaudeRepository, 'getUsage'>>;
   let mockLocalCommandRunner: Mocked<LocalCommandRunner>;
@@ -86,14 +97,19 @@ describe('StartPreparationUseCase', () => {
     jest.resetAllMocks();
     mockProject = createMockProject();
     mockProjectRepository = {
-      findProjectIdByUrl: jest.fn().mockResolvedValue('project-1'),
-      getProject: jest.fn(),
+      getByUrl: jest.fn(),
+      prepareStatus: jest
+        .fn()
+        .mockImplementation((_name: string, project: Project) =>
+          Promise.resolve(project),
+        ),
     };
     mockIssueRepository = {
-      getAllIssues: jest
-        .fn()
-        .mockResolvedValue({ issues: [], cacheUsed: false }),
-      updateStatus: jest.fn(),
+      getAllOpened: jest.fn(),
+      getStoryObjectMap: jest.fn().mockResolvedValue(new Map()),
+      update: jest.fn(),
+      findRelatedOpenPRs: jest.fn().mockResolvedValue([]),
+      getOpenPullRequest: jest.fn().mockResolvedValue(null),
     };
     mockClaudeRepository = {
       getUsage: jest.fn().mockResolvedValue([]),
@@ -108,6 +124,43 @@ describe('StartPreparationUseCase', () => {
       mockLocalCommandRunner,
     );
   });
+  it('should call prepareStatus for awaitingWorkspaceStatus and preparationStatus with chained project objects', async () => {
+    const projectAfterFirstPrepare = createMockProject();
+    const projectAfterSecondPrepare = createMockProject();
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockProjectRepository.prepareStatus
+      .mockResolvedValueOnce(projectAfterFirstPrepare)
+      .mockResolvedValueOnce(projectAfterSecondPrepare);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([]),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce([]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockProjectRepository.prepareStatus).toHaveBeenCalledTimes(2);
+    expect(mockProjectRepository.prepareStatus).toHaveBeenNthCalledWith(
+      1,
+      'Awaiting Workspace',
+      mockProject,
+    );
+    expect(mockProjectRepository.prepareStatus).toHaveBeenNthCalledWith(
+      2,
+      'Preparation',
+      projectAfterFirstPrepare,
+    );
+  });
   it('should run aw command for awaiting workspace issues', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
@@ -117,11 +170,11 @@ describe('StartPreparationUseCase', () => {
         status: 'Awaiting Workspace',
       }),
     ];
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: awaitingIssues,
-      cacheUsed: false,
-    });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -132,18 +185,383 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
       url: 'url1',
+      status: 'Preparation',
+    });
+    expect(mockIssueRepository.update.mock.calls[0][1]).toBe(mockProject);
+    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 pass --branch to aw command when issue has an existing linked PR', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    const existingPR: RelatedPullRequest = {
+      url: 'https://github.com/user/repo/pull/42',
+      branchName: 'i1',
+      isConflicted: false,
+      isPassedAllCiJob: false,
+      isCiStateSuccess: false,
+      isResolvedAllReviewComments: false,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames: [],
+    };
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([existingPR]);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+    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 pass --branch with PR branch name when issue URL is a PR URL', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'https://github.com/user/repo/pull/354',
+        title: 'PR 354',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockIssueRepository.getOpenPullRequest.mockResolvedValue({
+      url: 'https://github.com/user/repo/pull/354',
+      branchName: 'dependabot/npm_and_yarn/multi-cc382f683c',
+      isConflicted: false,
+      isPassedAllCiJob: false,
+      isCiStateSuccess: false,
+      isResolvedAllReviewComments: false,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames: [],
+    });
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
-    expect(mockIssueRepository.updateStatus.mock.calls[0][2]).toBe('2');
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][0]).toBe(
-      'aw url1 impl https://github.com/user/repo',
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
+      'aw',
+      [
+        'https://github.com/user/repo/pull/354',
+        'impl',
+        'claude-opus',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'dependabot/npm_and_yarn/multi-cc382f683c',
+      ],
+    ]);
+    expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+    expect(mockIssueRepository.getOpenPullRequest).toHaveBeenCalledWith(
+      'https://github.com/user/repo/pull/354',
+    );
+  });
+  it('should skip and not call wrapper when PR URL returns null from getOpenPullRequest', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'https://github.com/user/repo/pull/999',
+        title: 'PR 999',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockIssueRepository.getOpenPullRequest.mockResolvedValue(null);
+    const consoleWarnSpy = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => {});
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
+    expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      'Skipping non-OPEN PR https://github.com/user/repo/pull/999: wrapper requires an open PR.',
+    );
+    consoleWarnSpy.mockRestore();
+  });
+  it('should skip and not call wrapper when PR URL has open PR with null branchName', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'https://github.com/user/repo/pull/999',
+        title: 'PR 999',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockIssueRepository.getOpenPullRequest.mockResolvedValue({
+      url: 'https://github.com/user/repo/pull/999',
+      branchName: null,
+      isConflicted: false,
+      isPassedAllCiJob: false,
+      isCiStateSuccess: false,
+      isResolvedAllReviewComments: false,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames: [],
+    });
+    const consoleWarnSpy = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => {});
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      'Skipping PR https://github.com/user/repo/pull/999: head branch is unavailable.',
+    );
+    consoleWarnSpy.mockRestore();
+  });
+  it('should skip and not call wrapper when PR has branch name with shell-unsafe characters', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'https://github.com/user/repo/pull/999',
+        title: 'PR 999',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockIssueRepository.getOpenPullRequest.mockResolvedValue({
+      url: 'https://github.com/user/repo/pull/999',
+      branchName: 'evil$(rm -rf /)',
+      isConflicted: false,
+      isPassedAllCiJob: false,
+      isCiStateSuccess: false,
+      isResolvedAllReviewComments: false,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames: [],
+    });
+    const consoleErrorSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('branch name contains unexpected characters'),
+    );
+    consoleErrorSpy.mockRestore();
+  });
+  it('should skip and not call wrapper when issue has multiple related open PRs', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    const pr1: RelatedPullRequest = {
+      url: 'https://github.com/user/repo/pull/42',
+      branchName: 'i1',
+      isConflicted: false,
+      isPassedAllCiJob: false,
+      isCiStateSuccess: false,
+      isResolvedAllReviewComments: false,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames: [],
+    };
+    const pr2: RelatedPullRequest = {
+      url: 'https://github.com/user/repo/pull/43',
+      branchName: 'i1-fix',
+      isConflicted: false,
+      isPassedAllCiJob: false,
+      isCiStateSuccess: false,
+      isResolvedAllReviewComments: false,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames: [],
+    };
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([pr1, pr2]);
+    const consoleWarnSpy = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => {});
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      'Skipping issue url1: 2 related open PRs found (ambiguous).',
+    );
+    consoleWarnSpy.mockRestore();
+  });
+  it('should skip and not call wrapper when issue has one related open PR with null branchName', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    const prWithNullBranch: RelatedPullRequest = {
+      url: 'https://github.com/user/repo/pull/42',
+      branchName: null,
+      isConflicted: false,
+      isPassedAllCiJob: false,
+      isCiStateSuccess: false,
+      isResolvedAllReviewComments: false,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames: [],
+    };
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      prWithNullBranch,
+    ]);
+    const consoleWarnSpy = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => {});
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      'Skipping issue url1: related open PR has unavailable head branch.',
     );
+    consoleWarnSpy.mockRestore();
   });
   it('should assign workspace to awaiting issues', async () => {
     const awaitingIssues: Issue[] = [
@@ -160,11 +578,11 @@ describe('StartPreparationUseCase', () => {
         status: 'Awaiting Workspace',
       }),
     ];
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: awaitingIssues,
-      cacheUsed: false,
-    });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -175,19 +593,29 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(2);
-    expect(mockIssueRepository.updateStatus.mock.calls[0][1]).toMatchObject({
+    // Both awaiting issues should be updated (forward iteration: url1 first, then url2)
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(2);
+    expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
       url: 'url1',
+      status: 'Preparation',
     });
-    expect(mockIssueRepository.updateStatus.mock.calls[1][1]).toMatchObject({
+    expect(mockIssueRepository.update.mock.calls[1][0]).toMatchObject({
       url: 'url2',
+      status: 'Preparation',
     });
+    expect(mockIssueRepository.update.mock.calls[0][1]).toBe(mockProject);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(2);
   });
   it('should stop assigning after maximum preparing issues count is reached', async () => {
+    // When we already have 6 preparation issues and max is 6 (default),
+    // the loop condition prevents processing any new issues
     const preparationIssues: Issue[] = Array.from({ length: 6 }, (_, i) =>
       createMockIssue({
         url: `url${i + 1}`,
@@ -204,11 +632,14 @@ describe('StartPreparationUseCase', () => {
         status: 'Awaiting Workspace',
       }),
     ];
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: [...preparationIssues, ...awaitingIssues],
-      cacheUsed: false,
-    });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([...preparationIssues, ...awaitingIssues]),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+      ...preparationIssues,
+      ...awaitingIssues,
+    ]);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -219,13 +650,18 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
+    // Loop doesn't run because we're already at max (6 >= 6)
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
   });
-  it('should append logFilePath to aw command when provided', async () => {
+  it('should pass configFilePath to aw command', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
         url: 'url1',
@@ -234,11 +670,11 @@ describe('StartPreparationUseCase', () => {
         status: 'Awaiting Workspace',
       }),
     ];
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: awaitingIssues,
-      cacheUsed: false,
-    });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -249,16 +685,28 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
-      logFilePath: '/path/to/log.txt',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][0]).toBe(
-      'aw url1 impl https://github.com/user/repo --logFilePath /path/to/log.txt',
-    );
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
+      'aw',
+      [
+        'url1',
+        'impl',
+        'claude-opus',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'i1',
+      ],
+    ]);
   });
-  it('should not append logFilePath to aw command when not provided', async () => {
+  it('should use configFilePath in aw command', async () => {
     const awaitingIssues: Issue[] = [
       createMockIssue({
         url: 'url1',
@@ -267,11 +715,11 @@ describe('StartPreparationUseCase', () => {
         status: 'Awaiting Workspace',
       }),
     ];
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: awaitingIssues,
-      cacheUsed: false,
-    });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -282,28 +730,41 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
-    expect(mockLocalCommandRunner.runCommand.mock.calls[0][0]).toBe(
-      'aw url1 impl https://github.com/user/repo',
-    );
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
+      'aw',
+      [
+        'url1',
+        'impl',
+        'claude-opus',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'i1',
+      ],
+    ]);
   });
-  it('should handle no awaiting workspace issues gracefully', async () => {
-    const preparationIssues: Issue[] = [
+  it('should use llm-agent label over category label and defaultLlmAgentName', async () => {
+    const awaitingIssues: Issue[] = [
       createMockIssue({
         url: 'url1',
         title: 'Issue 1',
-        labels: [],
-        status: 'Preparation',
+        labels: ['llm-agent:research', 'category:impl'],
+        status: 'Awaiting Workspace',
       }),
     ];
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: preparationIssues,
-      cacheUsed: false,
-    });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -314,26 +775,41 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: 'default-llm-agent',
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
-    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]).toEqual([
+      'aw',
+      [
+        'url1',
+        'research',
+        'claude-sonnet-4-6',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'i1',
+      ],
+    ]);
   });
-  it('should use custom maximumPreparingIssuesCount when provided', async () => {
-    const awaitingIssues: Issue[] = Array.from({ length: 10 }, (_, i) =>
+  it('should use category label over defaultLlmAgentName when no llm-agent label', async () => {
+    const awaitingIssues: Issue[] = [
       createMockIssue({
-        url: `url${i + 1}`,
-        title: `Issue ${i + 1}`,
-        labels: [],
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
         status: 'Awaiting Workspace',
       }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
     );
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: awaitingIssues,
-      cacheUsed: false,
-    });
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -344,26 +820,41 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
-      maximumPreparingIssuesCount: 3,
-      allowIssueCacheMinutes: 60,
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: 'default-llm-agent',
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(3);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
+      'aw',
+      [
+        'url1',
+        'impl',
+        'claude-sonnet-4-6',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'i1',
+      ],
+    ]);
   });
-  it('should use default maximumPreparingIssuesCount of 6 when null is provided', async () => {
-    const awaitingIssues: Issue[] = Array.from({ length: 12 }, (_, i) =>
+  it('should use defaultLlmAgentName over defaultAgentName when no label', async () => {
+    const awaitingIssues: Issue[] = [
       createMockIssue({
-        url: `url${i + 1}`,
-        title: `Issue ${i + 1}`,
+        url: 'url1',
+        title: 'Issue 1',
         labels: [],
         status: 'Awaiting Workspace',
       }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
     );
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: awaitingIssues,
-      cacheUsed: false,
-    });
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -374,197 +865,322 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: 'default-llm-agent',
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(6);
-    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(6);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
+      'aw',
+      [
+        'url1',
+        'default-llm-agent',
+        'claude-sonnet-4-6',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'i1',
+      ],
+    ]);
   });
-
-  it('should skip issues from blocked repositories (not the blocker issue itself)', async () => {
-    const blockerIssue = createMockIssue({
-      url: 'https://github.com/user/repo/issues/100',
-      title: 'Blocker Issue',
-      labels: [],
-      status: 'Awaiting Workspace',
-      state: 'OPEN',
-      story: 'Workflow blocker',
-    });
-
-    const blockedIssue = createMockIssue({
-      url: 'https://github.com/user/repo/issues/101',
-      title: 'Blocked Issue',
-      labels: [],
-      status: 'Awaiting Workspace',
-      state: 'OPEN',
-    });
-
-    const projectWithBlocker = {
-      ...createMockProject(),
-      story: {
-        name: 'Story',
-        fieldId: 'story-field-id',
-        databaseId: 1,
-        stories: [
-          {
-            id: 'story-blocker',
-            name: 'Workflow blocker',
-            color: 'RED' as const,
-            description: '',
-          },
-          {
-            id: 'story-1',
-            name: 'Default Story',
-            color: 'GRAY' as const,
-            description: '',
-          },
-        ],
-        workflowManagementStory: {
-          id: 'wf-1',
-          name: 'Workflow Management',
-        },
-      },
-    };
-
-    mockProjectRepository.getProject.mockResolvedValue(projectWithBlocker);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: [blockerIssue, blockedIssue],
-      cacheUsed: false,
-    });
+  it('should use llm-model label over defaultLlmModelName', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl', 'llm-model:claude-sonnet'],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
       exitCode: 0,
     });
-
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-opus',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
-
-    const blockerUpdateCalls =
-      mockIssueRepository.updateStatus.mock.calls.filter(
-        (call) => call[1].url === 'https://github.com/user/repo/issues/100',
-      );
-    expect(blockerUpdateCalls).toHaveLength(1);
-
-    const blockedUpdateCalls =
-      mockIssueRepository.updateStatus.mock.calls.filter(
-        (call) => call[1].url === blockedIssue.url,
-      );
-    expect(blockedUpdateCalls).toHaveLength(0);
-
-    const blockedRunCommandCalls =
-      mockLocalCommandRunner.runCommand.mock.calls.filter((call) =>
-        call.some(
-          (arg) => typeof arg === 'string' && arg.includes(blockedIssue.url),
-        ),
-      );
-    expect(blockedRunCommandCalls).toHaveLength(0);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
+      'aw',
+      [
+        'url1',
+        'impl',
+        'claude-sonnet',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'i1',
+      ],
+    ]);
   });
-
-  it('should process the blocker issue even when repository is blocked', async () => {
-    const blockerIssue = createMockIssue({
-      url: 'https://github.com/user/repo/issues/100',
-      title: 'Blocker Issue',
-      labels: [],
-      status: 'Awaiting Workspace',
-      state: 'OPEN',
-      story: 'Workflow blocker',
+  it('should log error and skip issue when no llm-model label and no defaultLlmModelName', 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),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
     });
-
-    const projectWithBlocker = {
-      ...createMockProject(),
-      story: {
-        name: 'Story',
-        fieldId: 'story-field-id',
-        databaseId: 1,
-        stories: [
-          {
-            id: 'story-blocker',
-            name: 'Workflow blocker',
-            color: 'RED' as const,
-            description: '',
-          },
-        ],
-        workflowManagementStory: {
-          id: 'wf-1',
-          name: 'Workflow Management',
-        },
-      },
-    };
-
-    mockProjectRepository.getProject.mockResolvedValue(projectWithBlocker);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: [blockerIssue],
-      cacheUsed: false,
+    const consoleErrorSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'No LLM model configured for issue url1. Provide --defaultLlmModelName or add an llm-model: label.',
+    );
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+    consoleErrorSpy.mockRestore();
+  });
+  it('should continue processing subsequent issues when one issue has no model configured', async () => {
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1 (no model)',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      }),
+      createMockIssue({
+        url: 'url2',
+        title: 'Issue 2 (with model label)',
+        labels: ['category:impl', 'llm-model:claude-sonnet-4-6'],
+        status: 'Awaiting Workspace',
+        number: 2,
+        itemId: 'item-2',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
       exitCode: 0,
     });
-
+    const consoleErrorSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
-
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-    expect(mockIssueRepository.updateStatus.mock.calls[0][1].url).toBe(
-      'https://github.com/user/repo/issues/100',
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'No LLM model configured for issue url1. Provide --defaultLlmModelName or add an llm-model: label.',
     );
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0]).toEqual([
+      'aw',
+      [
+        'url2',
+        'impl',
+        'claude-sonnet-4-6',
+        '--configFilePath',
+        '/path/to/config.yml',
+        '--branch',
+        'i2',
+      ],
+    ]);
+    consoleErrorSpy.mockRestore();
+  });
+  it('should handle no awaiting workspace issues gracefully', async () => {
+    // Test that the loop handles an empty awaiting workspace issues array
+    const preparationIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        title: 'Issue 1',
+        labels: [],
+        status: 'Preparation',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(preparationIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(preparationIssues);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+    // No issues are in 'Awaiting Workspace' status, so no updates should happen
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+  });
+  it('should use custom maximumPreparingIssuesCount when provided', async () => {
+    const awaitingIssues: Issue[] = Array.from({ length: 10 }, (_, i) =>
+      createMockIssue({
+        url: `url${i + 1}`,
+        title: `Issue ${i + 1}`,
+        labels: [],
+        status: 'Awaiting Workspace',
+      }),
+    );
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: 3,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(3);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(3);
+  });
+  it('should use default maximumPreparingIssuesCount of 6 when null is provided', async () => {
+    const awaitingIssues: Issue[] = Array.from({ length: 12 }, (_, i) =>
+      createMockIssue({
+        url: `url${i + 1}`,
+        title: `Issue ${i + 1}`,
+        labels: [],
+        status: 'Awaiting Workspace',
+      }),
+    );
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(6);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(6);
   });
 
-  it('should process awaiting issue when workflow blocker story has no open blocker issues', async () => {
-    const awaitingIssue = createMockIssue({
+  it('should not skip issues from repositories with workflow blockers', async () => {
+    const blockerIssue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/100',
+      title: 'Blocker Issue',
+      labels: [],
+      status: 'Awaiting Workspace',
+      state: 'OPEN',
+    });
+
+    const issueInBlockedRepo = createMockIssue({
       url: 'https://github.com/user/repo/issues/101',
-      title: 'Awaiting Issue',
+      title: 'Issue in blocked repo',
       labels: [],
       status: 'Awaiting Workspace',
       state: 'OPEN',
     });
 
-    const projectWithBlocker = {
-      ...createMockProject(),
+    const workflowBlockerMap: StoryObjectMap = new Map();
+    workflowBlockerMap.set('Workflow blocker', {
       story: {
-        name: 'Story',
-        fieldId: 'story-field-id',
-        databaseId: 1,
-        stories: [
-          {
-            id: 'story-1',
-            name: 'Default Story',
-            color: 'GRAY' as const,
-            description: '',
-          },
-          {
-            id: 'story-blocker',
-            name: 'Workflow blocker',
-            color: 'RED' as const,
-            description: '',
-          },
-        ],
-        workflowManagementStory: {
-          id: 'wf-1',
-          name: 'Workflow Management',
-        },
+        id: 'story-blocker',
+        name: 'Workflow blocker',
+        color: 'RED',
+        description: '',
       },
-    };
-
-    mockProjectRepository.getProject.mockResolvedValue(projectWithBlocker);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: [awaitingIssue],
-      cacheUsed: false,
+      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.getStoryObjectMap.mockResolvedValue(workflowBlockerMap);
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+      blockerIssue,
+      issueInBlockedRepo,
+    ]);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -576,14 +1192,20 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
-    expect(mockIssueRepository.updateStatus.mock.calls[0][1].url).toBe(
-      'https://github.com/user/repo/issues/101',
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(2);
+    const updatedUrls = mockIssueRepository.update.mock.calls.map(
+      (call) => call[0].url,
     );
+    expect(updatedUrls).toContain('https://github.com/user/repo/issues/100');
+    expect(updatedUrls).toContain('https://github.com/user/repo/issues/101');
   });
 
   it('should skip preparation when Claude usage is over 90%', async () => {
@@ -599,24 +1221,28 @@ describe('StartPreparationUseCase', () => {
         status: 'Awaiting Workspace',
       }),
     ];
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: awaitingIssues,
-      cacheUsed: false,
-    });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
 
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(0);
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
-    expect(mockProjectRepository.findProjectIdByUrl).not.toHaveBeenCalled();
+    expect(mockProjectRepository.getByUrl).not.toHaveBeenCalled();
   });
 
   it('should proceed with preparation when Claude usage is under 90%', async () => {
@@ -633,11 +1259,11 @@ describe('StartPreparationUseCase', () => {
         status: 'Awaiting Workspace',
       }),
     ];
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: awaitingIssues,
-      cacheUsed: false,
-    });
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -649,39 +1275,298 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
   });
 
-  it('should skip preparation when any Claude usage window exceeds 90%', async () => {
+  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() },
     ]);
 
+    const awaitingIssues: Issue[] = Array.from({ length: 10 }, (_, i) =>
+      createMockIssue({
+        url: `url${i + 1}`,
+        title: `Issue ${i + 1}`,
+        labels: [],
+        status: 'Awaiting Workspace',
+      }),
+    );
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
     await useCase.run({
       projectUrl: 'https://github.com/user/repo',
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
     });
 
-    expect(mockProjectRepository.findProjectIdByUrl).not.toHaveBeenCalled();
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(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.update.mock.calls).toHaveLength(expectedMax);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(
+      expectedMax,
+    );
+  });
+
+  it('should skip all preparation when weekly window usage reduces maximumPreparingIssuesCount to 0', async () => {
+    mockClaudeRepository.getUsage.mockResolvedValue([
+      { hour: 168, utilizationPercentage: 100, resetsAt: new Date() },
+    ]);
+
+    const awaitingIssues: Issue[] = [
+      createMockIssue({
+        url: 'url1',
+        labels: [],
+        status: 'Awaiting Workspace',
+      }),
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+  });
+
+  it('should not apply weekly reduction when threshold is 100', async () => {
+    mockClaudeRepository.getUsage.mockResolvedValue([
+      { hour: 168, utilizationPercentage: 99, resetsAt: new Date() },
+    ]);
+
+    const awaitingIssues: Issue[] = Array.from({ length: 10 }, (_, i) =>
+      createMockIssue({
+        url: `url${i + 1}`,
+        title: `Issue ${i + 1}`,
+        labels: [],
+        status: 'Awaiting Workspace',
+      }),
+    );
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 100,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.update.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),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockProjectRepository.getByUrl).not.toHaveBeenCalled();
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
   });
 
-  it('should proceed with preparation when Claude usage check fails', async () => {
+  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() },
+    ]);
+
+    const awaitingIssues: Issue[] = Array.from({ length: 10 }, (_, i) =>
+      createMockIssue({
+        url: `url${i + 1}`,
+        title: `Issue ${i + 1}`,
+        labels: [],
+        status: 'Awaiting Workspace',
+      }),
+    );
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+
+    const normalizedUtilizationBeyondThreshold = (95 - 90) / (100 - 90);
+    const expectedMax = Math.floor(
+      6 * Math.pow(1 - normalizedUtilizationBeyondThreshold, 2),
+    );
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(expectedMax);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(
+      expectedMax,
+    );
+  });
+
+  it('should throw error when Claude usage check fails', async () => {
     mockClaudeRepository.getUsage.mockRejectedValue(
       new Error('Claude credentials file not found'),
     );
 
+    await expect(
+      useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        preparationStatus: 'Preparation',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: null,
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+      }),
+    ).rejects.toThrow('Claude credentials file not found');
+
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(0);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+  });
+
+  it('should skip preparation when Claude usage exceeds custom threshold', async () => {
+    mockClaudeRepository.getUsage.mockResolvedValue([
+      { hour: 5, utilizationPercentage: 75, 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),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: null,
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 70,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.update.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 custom threshold', async () => {
+    mockClaudeRepository.getUsage.mockResolvedValue([
+      { hour: 5, utilizationPercentage: 75, resetsAt: new Date() },
+    ]);
+
     const awaitingIssues: Issue[] = [
       createMockIssue({
         url: 'url1',
@@ -690,11 +1575,528 @@ describe('StartPreparationUseCase', () => {
         status: 'Awaiting Workspace',
       }),
     ];
-    mockProjectRepository.getProject.mockResolvedValue(mockProject);
-    mockIssueRepository.getAllIssues.mockResolvedValue({
-      issues: awaitingIssues,
-      cacheUsed: false,
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap(awaitingIssues),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 80,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+  });
+
+  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: [],
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([issueWithDependency, issueWithoutDependency]),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+      issueWithDependency,
+      issueWithoutDependency,
+    ]);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
+      url: 'https://github.com/user/repo/issues/3',
+      status: 'Preparation',
     });
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+  });
+
+  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,
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([
+          issueWithFutureNextActionHour,
+          issueWithoutNextActionHour,
+        ]),
+      );
+      mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+        issueWithFutureNextActionHour,
+        issueWithoutNextActionHour,
+      ]);
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        preparationStatus: 'Preparation',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-sonnet-4-6',
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
+        url: 'https://github.com/user/repo/issues/2',
+        status: 'Preparation',
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  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,
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([
+          issueWithFutureNextActionDate,
+          issueWithoutNextActionDate,
+        ]),
+      );
+      mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+        issueWithFutureNextActionDate,
+        issueWithoutNextActionDate,
+      ]);
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        preparationStatus: 'Preparation',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-sonnet-4-6',
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
+        url: 'https://github.com/user/repo/issues/2',
+        status: 'Preparation',
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  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: [],
+        status: 'Awaiting Workspace',
+        nextActionDate: new Date('2024-01-15'),
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([issueWithTodayNextActionDate]),
+      );
+      mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+        issueWithTodayNextActionDate,
+      ]);
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        preparationStatus: 'Preparation',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-sonnet-4-6',
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  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 issueWithPastNextActionDate = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        title: 'Issue with past next action date',
+        labels: [],
+        status: 'Awaiting Workspace',
+        nextActionDate: new Date('2024-01-14'),
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([issueWithPastNextActionDate]),
+      );
+      mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+        issueWithPastNextActionDate,
+      ]);
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        preparationStatus: 'Preparation',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-sonnet-4-6',
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  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 issueWithPastNextActionHour = createMockIssue({
+        url: 'https://github.com/user/repo/issues/1',
+        title: 'Issue with past next action hour',
+        labels: [],
+        status: 'Awaiting Workspace',
+        nextActionHour: 10,
+      });
+
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+        createMockStoryObjectMap([issueWithPastNextActionHour]),
+      );
+      mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+        issueWithPastNextActionHour,
+      ]);
+      mockLocalCommandRunner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+
+      await useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        awaitingWorkspaceStatus: 'Awaiting Workspace',
+        preparationStatus: 'Preparation',
+        defaultAgentName: 'agent1',
+        defaultLlmModelName: 'claude-sonnet-4-6',
+        defaultLlmAgentName: null,
+        configFilePath: '/path/to/config.yml',
+        maximumPreparingIssuesCount: null,
+        utilizationPercentageThreshold: 90,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
+        url: 'https://github.com/user/repo/issues/1',
+        status: 'Preparation',
+      });
+      expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  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',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([
+        issueFromAllowedAuthor,
+        issueFromNonAllowedAuthor,
+      ]),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+      issueFromAllowedAuthor,
+      issueFromNonAllowedAuthor,
+    ]);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: ['user1', 'user2'],
+    });
+
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+    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',
+      title: 'Issue 1',
+      labels: [],
+      status: 'Awaiting Workspace',
+      author: 'user1',
+    });
+    const issue2 = createMockIssue({
+      url: 'https://github.com/user/repo/issues/2',
+      title: 'Issue 2',
+      labels: [],
+      status: 'Awaiting Workspace',
+      author: 'user2',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([issue1, issue2]),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce([issue1, issue2]);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(2);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(2);
+  });
+
+  it('should not skip issues with empty author (tower defence issues)', async () => {
+    const towerDefenceIssue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      title: 'Tower defence issue',
+      labels: [],
+      status: 'Awaiting Workspace',
+      author: '',
+    });
+    const normalIssue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/2',
+      title: 'Normal issue',
+      labels: [],
+      status: 'Awaiting Workspace',
+      author: 'user1',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(
+      createMockStoryObjectMap([towerDefenceIssue, normalIssue]),
+    );
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+      towerDefenceIssue,
+      normalIssue,
+    ]);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
+      maximumPreparingIssuesCount: null,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: ['user1', 'user2'],
+    });
+
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(2);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(2);
+  });
+
+  it('should not skip issues without author property when allowedIssueAuthors is set', async () => {
+    const issueWithoutAuthor = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      title: 'Issue without author property',
+      labels: [],
+      status: 'Awaiting Workspace',
+      author: '',
+    });
+
+    const storyObjectMap: StoryObjectMap = new Map();
+    storyObjectMap.set('Default Story', {
+      story: {
+        id: 'story-1',
+        name: 'Default Story',
+        color: 'GRAY',
+        description: '',
+      },
+      storyIssue: null,
+      issues: [issueWithoutAuthor],
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getStoryObjectMap.mockResolvedValue(storyObjectMap);
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+      issueWithoutAuthor,
+    ]);
     mockLocalCommandRunner.runCommand.mockResolvedValue({
       stdout: '',
       stderr: '',
@@ -706,11 +2108,15 @@ describe('StartPreparationUseCase', () => {
       awaitingWorkspaceStatus: 'Awaiting Workspace',
       preparationStatus: 'Preparation',
       defaultAgentName: 'agent1',
+      defaultLlmModelName: 'claude-sonnet-4-6',
+      defaultLlmAgentName: null,
+      configFilePath: '/path/to/config.yml',
       maximumPreparingIssuesCount: null,
-      allowIssueCacheMinutes: 60,
+      utilizationPercentageThreshold: 90,
+      allowedIssueAuthors: ['user1'],
     });
 
-    expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
     expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
   });
 });