github-issue-tower-defence-management 2.19.1 → 2.19.3

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.test.ts

@@ -1,859 +0,0 @@
-import fs from 'fs';
-import YAML from 'yaml';
-import { mock } from 'jest-mock-extended';
-import { projectCacheDirectory } from '../../repositories/localStorageCacheDirectory';
-import type { Project } from '../../../domain/entities/Project';
-import type { Issue } from '../../../domain/entities/Issue';
-import type { HandleScheduledEventUseCase } from '../../../domain/usecases/HandleScheduledEventUseCase';
-
-jest.mock('fs');
-jest.mock('../../repositories/SystemDateRepository');
-jest.mock('../../repositories/LocalStorageRepository');
-jest.mock('../../repositories/GoogleSpreadsheetRepository');
-jest.mock('../../repositories/GraphqlProjectRepository');
-jest.mock('../../repositories/issue/ApiV3IssueRepository');
-jest.mock('../../repositories/issue/RestIssueRepository');
-jest.mock('../../repositories/issue/GraphqlProjectItemRepository');
-jest.mock('../../repositories/issue/ApiV3CheerioRestIssueRepository');
-jest.mock('../../repositories/LocalStorageCacheRepository');
-jest.mock('../../repositories/BaseGitHubRepository');
-
-type RunFn = HandleScheduledEventUseCase['run'];
-const capturedRunInputs: Parameters<RunFn>[] = [];
-const mockRun = jest
-  .fn()
-  .mockImplementation(async (...args: Parameters<RunFn>) => {
-    capturedRunInputs.push(args);
-    const input = args[0];
-    const mockProject = mock<Project>({ id: 'PVT_kwHOtest123' });
-    const mockIssues: Issue[] = [];
-    if (input.afterIssuesFetched) {
-      await input.afterIssuesFetched(mockProject, mockIssues);
-    }
-    return {
-      project: mockProject,
-      issues: mockIssues,
-      cacheUsed: false,
-      targetDateTimes: [],
-      rotationOrder: null,
-    };
-  });
-
-jest.mock('../../../domain/usecases/HandleScheduledEventUseCase', () => ({
-  HandleScheduledEventUseCase: jest.fn().mockImplementation(() => ({
-    run: mockRun,
-  })),
-}));
-jest.mock('../../../domain/usecases/ActionAnnouncementUseCase', () => ({
-  ActionAnnouncementUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock(
-  '../../../domain/usecases/SetWorkflowManagementIssueToStoryUseCase',
-  () => ({
-    SetWorkflowManagementIssueToStoryUseCase: jest
-      .fn()
-      .mockImplementation(() => ({})),
-  }),
-);
-jest.mock(
-  '../../../domain/usecases/ClearPastNextActionDateHourUseCase',
-  () => ({
-    ClearPastNextActionDateHourUseCase: jest
-      .fn()
-      .mockImplementation(() => ({})),
-  }),
-);
-jest.mock('../../../domain/usecases/AnalyzeProblemByIssueUseCase', () => ({
-  AnalyzeProblemByIssueUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../../domain/usecases/AnalyzeStoriesUseCase', () => ({
-  AnalyzeStoriesUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../../domain/usecases/ClearDependedIssueURLUseCase', () => ({
-  ClearDependedIssueURLUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock(
-  '../../../domain/usecases/SetDependedIssueUrlForOpenTaskPRsUseCase',
-  () => ({
-    SetDependedIssueUrlForOpenTaskPRsUseCase: jest
-      .fn()
-      .mockImplementation(() => ({})),
-  }),
-);
-jest.mock('../../../domain/usecases/CreateEstimationIssueUseCase', () => ({
-  CreateEstimationIssueUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../../domain/usecases/ChangeStatusByStoryColorUseCase', () => ({
-  ChangeStatusByStoryColorUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../../domain/usecases/SetNoStoryIssueToStoryUseCase', () => ({
-  SetNoStoryIssueToStoryUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../../domain/usecases/CreateNewStoryByLabelUseCase', () => ({
-  CreateNewStoryByLabelUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock(
-  '../../../domain/usecases/AssignNoAssigneeIssueToManagerUseCase',
-  () => ({
-    AssignNoAssigneeIssueToManagerUseCase: jest
-      .fn()
-      .mockImplementation(() => ({})),
-  }),
-);
-jest.mock('../../../domain/usecases/UpdateIssueStatusByLabelUseCase', () => ({
-  UpdateIssueStatusByLabelUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../../domain/usecases/StartPreparationUseCase', () => ({
-  StartPreparationUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/NodeLocalCommandRunner', () => ({
-  NodeLocalCommandRunner: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/OauthAPIProxyClaudeRepository', () => ({
-  OauthAPIProxyClaudeRepository: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/ProxyClaudeTokenUsageRepository', () => ({
-  ProxyClaudeTokenUsageRepository: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/ProxyRateLimitCacheRepository', () => ({
-  ProxyRateLimitCacheRepository: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../../domain/usecases/UpdateRateLimitCacheUseCase', () => ({
-  UpdateRateLimitCacheUseCase: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/GitHubIssueCommentRepository', () => ({
-  GitHubIssueCommentRepository: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('./situationFileWriter', () => ({
-  writeSituationFile: jest.fn().mockResolvedValue(undefined),
-}));
-jest.mock('./rotationOrderFileWriter', () => ({
-  writeRotationOrderFile: jest.fn(),
-}));
-jest.mock('./inTmuxByHumanDataWriter', () => ({
-  writeInTmuxByHumanData: jest.fn(),
-}));
-jest.mock('./ownerCallFileCleaner', () => ({
-  cleanClosedIssueOwnerCallFiles: jest.fn(),
-}));
-jest.mock('./consoleListsWriter', () => {
-  const actual = jest.requireActual<typeof import('./consoleListsWriter')>(
-    './consoleListsWriter',
-  );
-  return { ...actual, writeConsoleLists: jest.fn() };
-});
-
-import { HandleScheduledEventUseCaseHandler } from './HandleScheduledEventUseCaseHandler';
-import { writeSituationFile } from './situationFileWriter';
-import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
-import { cleanClosedIssueOwnerCallFiles } from './ownerCallFileCleaner';
-import { writeConsoleLists } from './consoleListsWriter';
-import { GraphqlProjectRepository } from '../../repositories/GraphqlProjectRepository';
-import { ApiV3IssueRepository } from '../../repositories/issue/ApiV3IssueRepository';
-import { RestIssueRepository } from '../../repositories/issue/RestIssueRepository';
-import { GraphqlProjectItemRepository } from '../../repositories/issue/GraphqlProjectItemRepository';
-import { ApiV3CheerioRestIssueRepository } from '../../repositories/issue/ApiV3CheerioRestIssueRepository';
-import { ProxyClaudeTokenUsageRepository } from '../../repositories/ProxyClaudeTokenUsageRepository';
-
-const MockedGraphqlProjectRepository = jest.mocked(GraphqlProjectRepository);
-const MockedApiV3IssueRepository = jest.mocked(ApiV3IssueRepository);
-const MockedRestIssueRepository = jest.mocked(RestIssueRepository);
-const MockedGraphqlProjectItemRepository = jest.mocked(
-  GraphqlProjectItemRepository,
-);
-const MockedApiV3CheerioRestIssueRepository = jest.mocked(
-  ApiV3CheerioRestIssueRepository,
-);
-const MockedProxyClaudeTokenUsageRepository = jest.mocked(
-  ProxyClaudeTokenUsageRepository,
-);
-const MockedWriteInTmuxByHumanData = jest.mocked(writeInTmuxByHumanData);
-const mockGetLastIssuesFetchedAt = jest.fn<string | null, [string]>();
-ApiV3CheerioRestIssueRepository.prototype.getLastIssuesFetchedAt =
-  mockGetLastIssuesFetchedAt;
-
-const validConfig = {
-  projectName: 'test-project',
-  org: 'TestOrg',
-  projectUrl: 'https://github.com/users/TestOrg/projects/1',
-  manager: 'TestManager',
-  urlOfStoryView: 'https://github.com/users/TestOrg/projects/1/views/1',
-  disabled: false,
-  workingReport: {
-    repo: 'test-repo',
-    members: ['TestManager'],
-    spreadsheetUrl: 'https://docs.google.com/spreadsheets/d/test/edit',
-  },
-  credentials: {
-    manager: {
-      github: { token: 'ghp_manager_token' },
-      slack: { userToken: 'xoxp-slack-token' },
-      googleServiceAccount: { serviceAccountKey: '{}' },
-    },
-    bot: {
-      github: {
-        token: 'test-token',
-      },
-    },
-  },
-};
-
-const mockFetchReturningReadme = (readme: string | null): void => {
-  const responseBody =
-    readme === null
-      ? { data: {} }
-      : { data: { organization: { projectV2: { readme } } } };
-  jest.spyOn(global, 'fetch').mockResolvedValue(
-    new Response(JSON.stringify(responseBody), {
-      status: 200,
-      headers: { 'Content-Type': 'application/json' },
-    }),
-  );
-};
-
-describe('HandleScheduledEventUseCaseHandler', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    capturedRunInputs.length = 0;
-    jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify(validConfig));
-    mockGetLastIssuesFetchedAt.mockReturnValue('2026-08-09T02:00:00.000Z');
-    mockFetchReturningReadme(null);
-  });
-
-  it('should throw when required credential fields are missing from config', async () => {
-    jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify({}));
-    const handler = new HandleScheduledEventUseCaseHandler();
-    await expect(handler.handle('config.yml', false)).rejects.toThrow(
-      'Invalid input',
-    );
-  });
-
-  it('should pass bot token to repository constructors', async () => {
-    const handler = new HandleScheduledEventUseCaseHandler();
-    await handler.handle('config.yml', false);
-
-    for (const MockedClass of [
-      MockedApiV3IssueRepository,
-      MockedRestIssueRepository,
-      MockedGraphqlProjectItemRepository,
-    ]) {
-      expect(MockedClass).toHaveBeenCalledWith(expect.anything(), 'test-token');
-    }
-
-    expect(MockedGraphqlProjectRepository).toHaveBeenCalledWith(
-      expect.anything(),
-      'test-token',
-      expect.anything(),
-    );
-
-    expect(MockedApiV3CheerioRestIssueRepository).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      'test-token',
-    );
-  });
-
-  it('should write situation file after successful run with resolved config values', async () => {
-    const configWithPreparation = {
-      ...validConfig,
-      startPreparation: {
-        defaultAgentName: 'agent1',
-        configFilePath: './config.yml',
-        maximumPreparingIssuesCount: 10,
-        utilizationPercentageThreshold: 97,
-      },
-    };
-    jest
-      .mocked(fs.readFileSync)
-      .mockReturnValue(YAML.stringify(configWithPreparation));
-
-    const handler = new HandleScheduledEventUseCaseHandler();
-    await handler.handle('config.yml', false);
-
-    const expectedCachePath = projectCacheDirectory(validConfig.projectName);
-    const firstCallArg = jest.mocked(writeSituationFile).mock.calls[0][0];
-    expect(firstCallArg.cachePath).toBe(expectedCachePath);
-    expect(firstCallArg.projectId).toBe('PVT_kwHOtest123');
-    expect(firstCallArg.config.maximumPreparingIssuesCount).toBe(10);
-    expect(firstCallArg.config.utilizationPercentageThreshold).toBe(97);
-    expect(firstCallArg.config.thresholdForAutoReject).toBe(3);
-    expect(firstCallArg.statusNames.awaitingQualityCheckStatus).toBe(
-      'Awaiting Quality Check',
-    );
-    expect(firstCallArg.statusNames.preparationStatus).toBe('Preparation');
-    expect(firstCallArg.statusNames.awaitingWorkspaceStatus).toBe(
-      'Awaiting Workspace',
-    );
-  });
-
-  it('stamps console lists with the GitHub read time the lists were built from', async () => {
-    mockGetLastIssuesFetchedAt.mockReturnValue('2026-08-09T02:02:28.649Z');
-
-    const handler = new HandleScheduledEventUseCaseHandler();
-    await handler.handle('config.yml', false);
-
-    expect(jest.mocked(writeConsoleLists)).toHaveBeenCalledTimes(1);
-    expect(jest.mocked(writeConsoleLists).mock.calls[0][0].generatedAt).toBe(
-      '2026-08-09T02:02:28Z',
-    );
-  });
-
-  it('does not write console lists when no GitHub read time was recorded', async () => {
-    mockGetLastIssuesFetchedAt.mockReturnValue(null);
-    const consoleErrorSpy = jest
-      .spyOn(console, 'error')
-      .mockImplementation(() => undefined);
-
-    const handler = new HandleScheduledEventUseCaseHandler();
-    await handler.handle('config.yml', false);
-
-    expect(jest.mocked(writeConsoleLists)).not.toHaveBeenCalled();
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      expect.stringContaining('No GitHub read time recorded'),
-    );
-    consoleErrorSpy.mockRestore();
-  });
-
-  it('should write situation file with numeric defaults when optional fields are absent', async () => {
-    const handler = new HandleScheduledEventUseCaseHandler();
-    await handler.handle('config.yml', false);
-
-    const firstCallArg = jest.mocked(writeSituationFile).mock.calls[0][0];
-    expect(firstCallArg.config.utilizationPercentageThreshold).toBe(90);
-    expect(firstCallArg.config.thresholdForAutoReject).toBe(3);
-    expect(firstCallArg.config.maximumPreparingIssuesCount).toBeNull();
-  });
-
-  it('should not write situation file when run returns null', async () => {
-    mockRun.mockResolvedValueOnce(null);
-    jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify(validConfig));
-
-    const handler = new HandleScheduledEventUseCaseHandler();
-    await handler.handle('config.yml', false);
-
-    expect(jest.mocked(writeSituationFile)).not.toHaveBeenCalled();
-  });
-
-  describe('README config overrides', () => {
-    const configWithStartPreparation = {
-      ...validConfig,
-      startPreparation: {
-        defaultAgentName: 'yaml-agent',
-        configFilePath: '/path/to/config.yml',
-        maximumPreparingIssuesCount: 10,
-        utilizationPercentageThreshold: 90,
-      },
-    };
-
-    it('should override startPreparation fields from README config', async () => {
-      const readmeContent = `<details>
-<summary>config</summary>
-maximumPreparingIssuesCount: 0
-defaultAgentName: readme-agent
-utilizationPercentageThreshold: 80
-</details>`;
-      mockFetchReturningReadme(readmeContent);
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithStartPreparation));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        startPreparation: {
-          maximumPreparingIssuesCount: 0,
-          defaultAgentName: 'readme-agent',
-          utilizationPercentageThreshold: 80,
-        },
-      });
-    });
-
-    it('should split comma-separated allowedIssueAuthors from README config', async () => {
-      const readmeContent = `<details>
-<summary>config</summary>
-allowedIssueAuthors: 'user1, user2, user3'
-</details>`;
-      mockFetchReturningReadme(readmeContent);
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithStartPreparation));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        startPreparation: {
-          allowedIssueAuthors: ['user1', 'user2', 'user3'],
-        },
-      });
-    });
-
-    it('should keep YAML values when README has no config section', async () => {
-      mockFetchReturningReadme(null);
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithStartPreparation));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        startPreparation: {
-          maximumPreparingIssuesCount: 10,
-          defaultAgentName: 'yaml-agent',
-        },
-      });
-    });
-
-    it('applies the fleet default maximumPreparingIssuesCount when neither README nor YAML provides it', async () => {
-      const configWithPreparationNoMax = {
-        ...validConfig,
-        startPreparation: {
-          defaultAgentName: 'yaml-agent',
-          configFilePath: '/path/to/config.yml',
-          utilizationPercentageThreshold: 90,
-        },
-      };
-      mockFetchReturningReadme(null);
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithPreparationNoMax));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        startPreparation: {
-          maximumPreparingIssuesCount: 80,
-        },
-      });
-    });
-
-    it('should use README token from manager credentials to fetch README', async () => {
-      mockFetchReturningReadme(null);
-      jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify(validConfig));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        'https://api.github.com/graphql',
-        expect.objectContaining({ method: 'POST' }),
-      );
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        projectUrl: validConfig.projectUrl,
-      });
-    });
-
-    it('should accept a top-level allowedIssueAuthors from the YAML config and pass it through', async () => {
-      mockFetchReturningReadme(null);
-      const configWithTopLevelAllowedIssueAuthors = {
-        ...validConfig,
-        allowedIssueAuthors: ['owner', 'dependabot[bot]'],
-      };
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithTopLevelAllowedIssueAuthors));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        allowedIssueAuthors: ['owner', 'dependabot[bot]'],
-      });
-    });
-
-    it('should split a comma-separated top-level allowedIssueAuthors string from the YAML config', async () => {
-      mockFetchReturningReadme(null);
-      const configWithCommaSeparatedAuthors = {
-        ...validConfig,
-        allowedIssueAuthors: 'owner, acme-bot ,dependabot[bot]',
-      };
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithCommaSeparatedAuthors));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        allowedIssueAuthors: ['owner', 'acme-bot', 'dependabot[bot]'],
-      });
-    });
-
-    it('should accept a top-level autoAssignManagerAuthors array from the YAML config and pass it through', async () => {
-      mockFetchReturningReadme(null);
-      const configWithAutoAssignManagerAuthors = {
-        ...validConfig,
-        autoAssignManagerAuthors: ['renovate[bot]', 'dependabot[bot]'],
-      };
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithAutoAssignManagerAuthors));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        autoAssignManagerAuthors: ['renovate[bot]', 'dependabot[bot]'],
-      });
-    });
-
-    it('should split a comma-separated top-level autoAssignManagerAuthors string from the YAML config', async () => {
-      mockFetchReturningReadme(null);
-      const configWithCommaSeparatedManagerAuthors = {
-        ...validConfig,
-        autoAssignManagerAuthors: 'renovate[bot], dependabot[bot]',
-      };
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(
-          YAML.stringify(configWithCommaSeparatedManagerAuthors),
-        );
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        autoAssignManagerAuthors: ['renovate[bot]', 'dependabot[bot]'],
-      });
-    });
-
-    it('should default autoAssignManagerAuthors to null when omitted from the YAML config and allowedIssueAuthors is also absent', async () => {
-      mockFetchReturningReadme(null);
-      jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify(validConfig));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        autoAssignManagerAuthors: null,
-      });
-    });
-
-    it('should fall back to allowedIssueAuthors for autoAssignManagerAuthors when autoAssignManagerAuthors is omitted', async () => {
-      mockFetchReturningReadme(null);
-      const configWithAllowedIssueAuthors = {
-        ...validConfig,
-        allowedIssueAuthors: ['HiromiShikata', 'umino-bot'],
-      };
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithAllowedIssueAuthors));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        autoAssignManagerAuthors: ['HiromiShikata', 'umino-bot'],
-      });
-    });
-
-    it('should prefer explicit autoAssignManagerAuthors over allowedIssueAuthors fallback', async () => {
-      mockFetchReturningReadme(null);
-      const configWithBothAuthors = {
-        ...validConfig,
-        allowedIssueAuthors: ['HiromiShikata', 'umino-bot'],
-        autoAssignManagerAuthors: ['trusted-bot'],
-      };
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithBothAuthors));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        autoAssignManagerAuthors: ['trusted-bot'],
-      });
-    });
-
-    it('should split comma-separated autoAssignManagerAuthors from README config', async () => {
-      const readmeContent = `<details>
-<summary>config</summary>
-autoAssignManagerAuthors: 'renovate[bot], dependabot[bot]'
-</details>`;
-      mockFetchReturningReadme(readmeContent);
-      jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify(validConfig));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(capturedRunInputs[0][0]).toMatchObject({
-        autoAssignManagerAuthors: ['renovate[bot]', 'dependabot[bot]'],
-      });
-    });
-  });
-
-  describe('Claude OAuth token rotation wiring', () => {
-    it('should pass top-level claudeCodeOauthTokenListJsonPath to ProxyClaudeTokenUsageRepository', async () => {
-      const configWithTokenPath = {
-        ...validConfig,
-        claudeCodeOauthTokenListJsonPath:
-          '/home/user/creds/claudeCodeOauthTokenList.json',
-        startPreparation: {
-          defaultAgentName: 'agent1',
-          configFilePath: './config.yml',
-          maximumPreparingIssuesCount: 3,
-        },
-      };
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithTokenPath));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(MockedProxyClaudeTokenUsageRepository).toHaveBeenCalledWith(
-        '/home/user/creds/claudeCodeOauthTokenList.json',
-      );
-    });
-
-    it('should pass null when claudeCodeOauthTokenListJsonPath is absent', async () => {
-      const configWithoutTokenPath = {
-        ...validConfig,
-        startPreparation: {
-          defaultAgentName: 'agent1',
-          configFilePath: './config.yml',
-          maximumPreparingIssuesCount: 3,
-        },
-      };
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithoutTokenPath));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(MockedProxyClaudeTokenUsageRepository).toHaveBeenCalledWith(null);
-    });
-
-    it('should pass null when claudeCodeOauthTokenListJsonPath is unset and startPreparation is absent', async () => {
-      jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify(validConfig));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(MockedProxyClaudeTokenUsageRepository).toHaveBeenCalledWith(null);
-    });
-
-    it('should let README claudeCodeOauthTokenListJsonPath override the YAML value', async () => {
-      const readmeContent = `<details>
-<summary>config</summary>
-claudeCodeOauthTokenListJsonPath: /readme/tokens.json
-</details>`;
-      mockFetchReturningReadme(readmeContent);
-      const configWithTokenPath = {
-        ...validConfig,
-        claudeCodeOauthTokenListJsonPath: '/yaml/tokens.json',
-        startPreparation: {
-          defaultAgentName: 'agent1',
-          configFilePath: './config.yml',
-          maximumPreparingIssuesCount: 3,
-        },
-      };
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithTokenPath));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(MockedProxyClaudeTokenUsageRepository).toHaveBeenCalledWith(
-        '/readme/tokens.json',
-      );
-    });
-  });
-
-  describe('effective config logging', () => {
-    let consoleLogSpy: jest.SpyInstance;
-
-    beforeEach(() => {
-      consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-    });
-
-    afterEach(() => {
-      consoleLogSpy.mockRestore();
-    });
-
-    it('should log the effective values with configFile source when only the YAML config sets them', async () => {
-      const configWithPreparation = {
-        ...validConfig,
-        startPreparation: {
-          defaultAgentName: 'yaml-agent',
-          defaultLlmModelName: 'yaml-model',
-          configFilePath: './config.yml',
-          maximumPreparingIssuesCount: 10,
-        },
-      };
-      mockFetchReturningReadme(null);
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithPreparation));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        'Effective maximumPreparingIssuesCount: 10 (source: configFile)',
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        'Effective defaultLlmModelName: yaml-model (source: configFile)',
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        'Effective defaultAgentName: yaml-agent (source: configFile)',
-      );
-    });
-
-    it('should log the effective values with readmeOverride source when the README config overrides them', async () => {
-      const readmeContent = `<details>
-<summary>config</summary>
-maximumPreparingIssuesCount: 3
-defaultLlmModelName: readme-model
-defaultAgentName: readme-agent
-</details>`;
-      mockFetchReturningReadme(readmeContent);
-      const configWithPreparation = {
-        ...validConfig,
-        startPreparation: {
-          defaultAgentName: 'yaml-agent',
-          defaultLlmModelName: 'yaml-model',
-          configFilePath: './config.yml',
-          maximumPreparingIssuesCount: 10,
-        },
-      };
-      jest
-        .mocked(fs.readFileSync)
-        .mockReturnValue(YAML.stringify(configWithPreparation));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        'Effective maximumPreparingIssuesCount: 3 (source: readmeOverride)',
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        'Effective defaultLlmModelName: readme-model (source: readmeOverride)',
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        'Effective defaultAgentName: readme-agent (source: readmeOverride)',
-      );
-    });
-
-    it('should log null with unset (default) source when neither README nor config provides the value', async () => {
-      mockFetchReturningReadme(null);
-      jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify(validConfig));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        'Effective maximumPreparingIssuesCount: null (source: unset (default))',
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        'Effective defaultLlmModelName: null (source: unset (default))',
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        'Effective defaultAgentName: null (source: unset (default))',
-      );
-    });
-  });
-
-  describe('inTmuxProjectOrder override', () => {
-    const getInTmuxProjectOrderArg = (): string[] | null | undefined => {
-      const call = MockedWriteInTmuxByHumanData.mock.calls[0];
-      if (call === undefined) {
-        throw new Error('writeInTmuxByHumanData was not called');
-      }
-      return call[0].inTmuxProjectOrder;
-    };
-
-    it('should use the CLI override when provided, ignoring the config value', async () => {
-      jest.mocked(fs.readFileSync).mockReturnValue(
-        YAML.stringify({
-          ...validConfig,
-          inTmuxProjectOrder: ['alpha', 'beta'],
-        }),
-      );
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false, ['gamma', 'delta']);
-
-      expect(getInTmuxProjectOrderArg()).toEqual(['gamma', 'delta']);
-    });
-
-    it('should fall back to the config value when the CLI override is null', async () => {
-      jest.mocked(fs.readFileSync).mockReturnValue(
-        YAML.stringify({
-          ...validConfig,
-          inTmuxProjectOrder: ['alpha', 'beta'],
-        }),
-      );
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false, null);
-
-      expect(getInTmuxProjectOrderArg()).toEqual(['alpha', 'beta']);
-    });
-
-    it('should fall back to the config value when the override argument is omitted', async () => {
-      jest.mocked(fs.readFileSync).mockReturnValue(
-        YAML.stringify({
-          ...validConfig,
-          inTmuxProjectOrder: ['alpha', 'beta'],
-        }),
-      );
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(getInTmuxProjectOrderArg()).toEqual(['alpha', 'beta']);
-    });
-
-    it('should pass null when neither the override nor the config provides a value', async () => {
-      jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify(validConfig));
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false, null);
-
-      expect(getInTmuxProjectOrderArg()).toBeNull();
-    });
-  });
-
-  describe('owner call file cleanup of closed issues', () => {
-    it('should hand the project issues to the cleanup with the configured project code and data directory', async () => {
-      jest.mocked(fs.readFileSync).mockReturnValue(
-        YAML.stringify({
-          ...validConfig,
-          inTmuxDataOutputDir: '/data/in-tmux-by-human',
-        }),
-      );
-      const closedIssue = {
-        url: 'https://github.com/TestOrg/test-repo/issues/9',
-        isClosed: true,
-      };
-      mockRun.mockResolvedValueOnce({
-        project: { id: 'PVT_kwHOtest123' },
-        issues: [closedIssue],
-        cacheUsed: false,
-        targetDateTimes: [],
-        rotationOrder: null,
-      });
-
-      const handler = new HandleScheduledEventUseCaseHandler();
-      await handler.handle('config.yml', false);
-
-      expect(jest.mocked(cleanClosedIssueOwnerCallFiles)).toHaveBeenCalledWith({
-        inTmuxDataOutputDir: '/data/in-tmux-by-human',
-        pjcode: validConfig.projectName,
-        issues: [closedIssue],
-      });
-    });
-  });
-});