github-issue-tower-defence-management 2.19.0 → 2.19.2

package/src/adapter/entry-points/cli/index.test.ts

@@ -1,2837 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import YAML from 'yaml';
-
-jest.mock('fs', () => {
-  const actualFs: typeof fs = jest.requireActual('fs');
-  return {
-    ...actualFs,
-    readFileSync: jest.fn(actualFs.readFileSync),
-    existsSync: jest.fn(actualFs.existsSync),
-  };
-});
-import {
-  program,
-  loadConfigFile,
-  parseProjectReadmeConfig,
-  mergeConfigs,
-  fetchProjectReadme,
-  runCliProgram,
-  reportFatalErrorAndExit,
-} from './index';
-import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparationUseCase';
-import { NotifyFinishedIssuePreparationUseCase } from '../../../domain/usecases/NotifyFinishedIssuePreparationUseCase';
-import { CheckIssueReviewReadinessUseCase } from '../../../domain/usecases/CheckIssueReviewReadinessUseCase';
-import { ownerCallFileRelativePath } from '../../../domain/usecases/intmux/OwnerCallFile';
-import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
-
-jest.mock('../../../domain/usecases/StartPreparationUseCase');
-jest.mock('../../../domain/usecases/NotifyFinishedIssuePreparationUseCase');
-jest.mock('../../../domain/usecases/CheckIssueReviewReadinessUseCase');
-jest.mock('../../repositories/LocalStorageRepository', () => ({
-  LocalStorageRepository: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/LocalStorageCacheRepository', () => ({
-  LocalStorageCacheRepository: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/GraphqlProjectRepository', () => ({
-  GraphqlProjectRepository: jest.fn().mockImplementation(() => ({
-    findProjectIdByUrl: jest.fn().mockResolvedValue('PVT_kwHOtest456'),
-    getProject: jest.fn().mockResolvedValue({
-      id: 'PVT_kwHOtest456',
-      url: 'https://github.com/orgs/test/projects/1',
-      databaseId: 1,
-      name: 'test-project',
-      status: { name: 'Status', fieldId: 'statusField', statuses: [] },
-      nextActionDate: null,
-      nextActionHour: null,
-      story: null,
-      remainingEstimationMinutes: null,
-      dependedIssueUrlSeparatedByComma: null,
-      completionDate50PercentConfidence: null,
-    }),
-  })),
-}));
-jest.mock('../../repositories/issue/ApiV3IssueRepository', () => ({
-  ApiV3IssueRepository: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/issue/RestIssueRepository', () => ({
-  RestIssueRepository: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/issue/GraphqlProjectItemRepository', () => ({
-  GraphqlProjectItemRepository: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/issue/ApiV3CheerioRestIssueRepository', () => ({
-  ApiV3CheerioRestIssueRepository: jest.fn().mockImplementation(() => ({
-    getCachedProject: jest.fn().mockResolvedValue(null),
-  })),
-}));
-const mockRunCommand = jest.fn<
-  Promise<{ stdout: string; stderr: string; exitCode: number }>,
-  [string, string[]]
->();
-const mockSpawnInteractive = jest.fn<void, [string, string[]]>();
-jest.mock('../../repositories/NodeLocalCommandRunner', () => ({
-  NodeLocalCommandRunner: jest.fn().mockImplementation(() => ({
-    runCommand: mockRunCommand,
-    spawnInteractive: mockSpawnInteractive,
-  })),
-}));
-jest.mock('../../repositories/OauthAPIClaudeRepository', () => ({
-  OauthAPIClaudeRepository: jest.fn().mockImplementation(() => ({
-    getUsage: jest.fn(),
-    isClaudeAvailable: jest.fn(),
-  })),
-}));
-jest.mock('../../repositories/GitHubIssueCommentRepository', () => ({
-  GitHubIssueCommentRepository: jest.fn().mockImplementation(() => ({})),
-}));
-jest.mock('../../repositories/FetchWebhookRepository', () => ({
-  FetchWebhookRepository: jest.fn().mockImplementation(() => ({
-    sendGetRequest: jest.fn(),
-  })),
-}));
-const mockScheduleHandle = jest.fn().mockResolvedValue(null);
-jest.mock('../handlers/HandleScheduledEventUseCaseHandler', () => ({
-  HandleScheduledEventUseCaseHandler: jest.fn().mockImplementation(() => ({
-    handle: mockScheduleHandle,
-  })),
-}));
-jest.mock('../console/ensureConsoleRunning', () => ({
-  ensureConsoleRunning: jest.fn().mockResolvedValue(null),
-}));
-import * as ensureConsoleRunningModule from '../console/ensureConsoleRunning';
-import { GraphqlProjectRepository } from '../../repositories/GraphqlProjectRepository';
-
-import type { StartWebServerOptions } from '../console/webServer';
-
-const mockStartWebServer = jest
-  .fn<Promise<unknown>, [StartWebServerOptions]>()
-  .mockResolvedValue({
-    close: jest.fn(),
-    address: jest.fn().mockReturnValue({ port: 9980 }),
-  });
-jest.mock('../console/webServer', () => {
-  const actual: Record<string, unknown> = jest.requireActual(
-    '../console/webServer',
-  );
-  return {
-    ...actual,
-    startWebServer: (options: StartWebServerOptions): Promise<unknown> =>
-      mockStartWebServer(options),
-  };
-});
-
-describe('CLI', () => {
-  const originalEnv = process.env;
-  const tmpDir = path.join(__dirname, '../../../../tmp/test-cli');
-  const configFilePath = path.join(tmpDir, 'config.yml');
-  const cacheHomeDir = path.join(tmpDir, 'cache-home');
-
-  const defaultConfig = {
-    projectUrl: 'https://github.com/orgs/test/projects/1',
-    defaultAgentName: 'agent1',
-    projectName: 'test-project',
-    manager: 'test-manager',
-  };
-
-  const writeConfig = (config: Record<string, unknown>): void => {
-    fs.writeFileSync(configFilePath, YAML.stringify(config));
-  };
-
-  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' },
-      }),
-    );
-  };
-
-  beforeAll(() => {
-    if (!fs.existsSync(tmpDir)) {
-      fs.mkdirSync(tmpDir, { recursive: true });
-    }
-  });
-
-  afterAll(() => {
-    if (fs.existsSync(configFilePath)) {
-      fs.unlinkSync(configFilePath);
-    }
-    if (fs.existsSync(cacheHomeDir)) {
-      fs.rmSync(cacheHomeDir, { recursive: true, force: true });
-    }
-    if (fs.existsSync(tmpDir)) {
-      fs.rmdirSync(tmpDir);
-    }
-  });
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockFetchReturningReadme(null);
-    mockRunCommand.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
-    process.env = {
-      ...originalEnv,
-      GH_TOKEN: 'test-token',
-      XDG_CACHE_HOME: cacheHomeDir,
-    };
-    writeConfig(defaultConfig);
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  it('should export program', () => {
-    expect(program).toBeDefined();
-  });
-
-  describe('schedule --inTmuxProjectOrder', () => {
-    it('should pass the parsed, trimmed project order to the handler', async () => {
-      await program.parseAsync([
-        'node',
-        'test',
-        'schedule',
-        '-t',
-        'schedule',
-        '-c',
-        configFilePath,
-        '--inTmuxProjectOrder',
-        'alpha, beta ,gamma',
-      ]);
-
-      expect(mockScheduleHandle).toHaveBeenCalledWith(
-        configFilePath,
-        undefined,
-        ['alpha', 'beta', 'gamma'],
-      );
-    });
-
-    it('should pass null when --inTmuxProjectOrder is omitted', async () => {
-      await program.parseAsync([
-        'node',
-        'test',
-        'schedule',
-        '-t',
-        'schedule',
-        '-c',
-        configFilePath,
-      ]);
-
-      expect(mockScheduleHandle).toHaveBeenCalledWith(
-        configFilePath,
-        undefined,
-        null,
-      );
-    });
-  });
-
-  describe('loadConfigFile', () => {
-    it('should load config from YAML file', () => {
-      const config = {
-        projectUrl: 'https://github.com/orgs/test/projects/1',
-        defaultAgentName: 'agent1',
-        defaultLlmModelName: 'claude-opus-4-5',
-        defaultLlmAgentName: 'aw',
-        maximumPreparingIssuesCount: 10,
-        utilizationPercentageThreshold: 80,
-        allowedIssueAuthors: 'user1,user2',
-        thresholdForAutoReject: 5,
-        workflowBlockerResolvedWebhookUrl: 'https://example.com/webhook',
-        projectName: 'test-project',
-        codexHomeCandidates: ['.codex-dev1', '.codex-main'],
-      };
-      writeConfig(config);
-
-      const result = loadConfigFile(configFilePath);
-
-      expect(result).toEqual(config);
-    });
-
-    it('should load codexHomeCandidates string array from config file', () => {
-      const config = {
-        ...defaultConfig,
-        codexHomeCandidates: ['.codex-dev1', '.codex-dev2', '.codex-main'],
-      };
-      writeConfig(config);
-
-      const result = loadConfigFile(configFilePath);
-
-      expect(result.codexHomeCandidates).toEqual([
-        '.codex-dev1',
-        '.codex-dev2',
-        '.codex-main',
-      ]);
-    });
-
-    it('should return undefined codexHomeCandidates when not in config', () => {
-      writeConfig(defaultConfig);
-
-      const result = loadConfigFile(configFilePath);
-
-      expect(result.codexHomeCandidates).toBeUndefined();
-    });
-
-    it('should return undefined codexHomeCandidates when array contains non-string items', () => {
-      const config = {
-        ...defaultConfig,
-        codexHomeCandidates: ['.codex-dev1', 123],
-      };
-      writeConfig(config);
-
-      const result = loadConfigFile(configFilePath);
-
-      expect(result.codexHomeCandidates).toBeUndefined();
-    });
-
-    it('should return empty config for empty YAML', () => {
-      fs.writeFileSync(configFilePath, '');
-
-      const result = loadConfigFile(configFilePath);
-
-      expect(result).toEqual({});
-    });
-
-    it('should ignore non-string values for string fields', () => {
-      const config = {
-        projectUrl: 123,
-        defaultAgentName: true,
-      };
-      writeConfig(config);
-
-      const result = loadConfigFile(configFilePath);
-
-      expect(result.projectUrl).toBeUndefined();
-      expect(result.defaultAgentName).toBeUndefined();
-    });
-
-    it('should ignore non-number values for number fields', () => {
-      const config = {
-        maximumPreparingIssuesCount: 'abc',
-        utilizationPercentageThreshold: 'ghi',
-        thresholdForAutoReject: 'jkl',
-      };
-      writeConfig(config);
-
-      const result = loadConfigFile(configFilePath);
-
-      expect(result.maximumPreparingIssuesCount).toBeUndefined();
-      expect(result.utilizationPercentageThreshold).toBeUndefined();
-      expect(result.thresholdForAutoReject).toBeUndefined();
-    });
-
-    it('should return empty config for array YAML', () => {
-      fs.writeFileSync(configFilePath, '- item1\n- item2\n');
-
-      const result = loadConfigFile(configFilePath);
-
-      expect(result).toEqual({});
-    });
-
-    it('should exit with error when config file does not exist', () => {
-      const nonExistentPath = path.join(tmpDir, 'nonexistent-config.yml');
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      expect(() => loadConfigFile(nonExistentPath)).toThrow(
-        'process.exit called',
-      );
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining(
-          `Failed to load configuration file "${nonExistentPath}"`,
-        ),
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-  });
-
-  describe('parseProjectReadmeConfig', () => {
-    it('should parse YAML from details/summary config section', () => {
-      const readme = `# Project
-Some description
-<details>
-<summary>config</summary>
-defaultAgentName: 'readme-agent'
-defaultLlmModelName: 'claude-opus-4-5'
-</details>`;
-
-      const result = parseProjectReadmeConfig(readme);
-
-      expect(result.defaultAgentName).toBe('readme-agent');
-      expect(result.defaultLlmModelName).toBe('claude-opus-4-5');
-    });
-
-    it('should return empty config when no details/summary section exists', () => {
-      const readme = '# Project\nSome description without config section';
-
-      const result = parseProjectReadmeConfig(readme);
-
-      expect(result).toEqual({});
-    });
-
-    it('should return empty config when details section has empty content', () => {
-      const readme = '<details>\n<summary>config</summary>\n</details>';
-
-      const result = parseProjectReadmeConfig(readme);
-
-      expect(result).toEqual({});
-    });
-
-    it('should return empty config when YAML content is not a record', () => {
-      const readme =
-        '<details>\n<summary>config</summary>\n- item1\n- item2\n</details>';
-
-      const result = parseProjectReadmeConfig(readme);
-
-      expect(result).toEqual({});
-    });
-
-    it('should handle invalid YAML gracefully', () => {
-      const readme =
-        '<details>\n<summary>config</summary>\ninvalid: [unclosed\n</details>';
-      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-
-      const result = parseProjectReadmeConfig(readme);
-
-      expect(result).toEqual({});
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        'Failed to parse YAML from project README config section',
-      );
-
-      consoleWarnSpy.mockRestore();
-    });
-
-    it('should parse number fields from README config', () => {
-      const readme = `<details>
-<summary>config</summary>
-maximumPreparingIssuesCount: 15
-utilizationPercentageThreshold: 80
-thresholdForAutoReject: 5
-</details>`;
-
-      const result = parseProjectReadmeConfig(readme);
-
-      expect(result.maximumPreparingIssuesCount).toBe(15);
-      expect(result.utilizationPercentageThreshold).toBe(80);
-      expect(result.thresholdForAutoReject).toBe(5);
-    });
-
-    it('should be case-insensitive for the summary tag', () => {
-      const readme = `<details>
-<SUMMARY>config</SUMMARY>
-defaultAgentName: 'case-test-agent'
-</details>`;
-
-      const result = parseProjectReadmeConfig(readme);
-
-      expect(result.defaultAgentName).toBe('case-test-agent');
-    });
-
-    it('should parse codexHomeCandidates string array from README config', () => {
-      const readme = `<details>
-<summary>config</summary>
-codexHomeCandidates:
-  - .codex-dev1
-  - .codex-dev2
-  - .codex-main
-</details>`;
-
-      const result = parseProjectReadmeConfig(readme);
-
-      expect(result.codexHomeCandidates).toEqual([
-        '.codex-dev1',
-        '.codex-dev2',
-        '.codex-main',
-      ]);
-    });
-
-    it('should parse changeTargetPathAliases map from README config', () => {
-      const readme = `<details>
-<summary>config</summary>
-changeTargetPathAliases:
-  adapters: src/domain/usecases/adapter-interfaces
-  domain: src/domain
-</details>`;
-
-      const result = parseProjectReadmeConfig(readme);
-
-      expect(result.changeTargetPathAliases).toEqual({
-        adapters: 'src/domain/usecases/adapter-interfaces',
-        domain: 'src/domain',
-      });
-    });
-
-    it('should not warn when only known top-level keys are present', () => {
-      const readme = `<details>
-<summary>config</summary>
-defaultAgentName: 'agent'
-maximumPreparingIssuesCount: 5
-</details>`;
-      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-
-      const result = parseProjectReadmeConfig(
-        readme,
-        'https://github.com/orgs/example/projects/1',
-      );
-
-      expect(result.defaultAgentName).toBe('agent');
-      expect(result.maximumPreparingIssuesCount).toBe(5);
-      expect(consoleWarnSpy).not.toHaveBeenCalled();
-
-      consoleWarnSpy.mockRestore();
-    });
-
-    it('should warn for each unknown top-level key with project URL', () => {
-      const readme = `<details>
-<summary>config</summary>
-unknownOne: 'value-one'
-unknownTwo: 42
-</details>`;
-      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-
-      parseProjectReadmeConfig(
-        readme,
-        'https://github.com/orgs/example/projects/1',
-      );
-
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        'Unknown key "unknownOne" in project README config section (project URL: https://github.com/orgs/example/projects/1)',
-      );
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        'Unknown key "unknownTwo" in project README config section (project URL: https://github.com/orgs/example/projects/1)',
-      );
-      expect(consoleWarnSpy).toHaveBeenCalledTimes(2);
-
-      consoleWarnSpy.mockRestore();
-    });
-
-    it('should warn only for unknown keys in a mixed config', () => {
-      const readme = `<details>
-<summary>config</summary>
-defaultAgentName: 'agent'
-unexpectedKey: 'oops'
-</details>`;
-      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-
-      const result = parseProjectReadmeConfig(
-        readme,
-        'https://github.com/orgs/example/projects/2',
-      );
-
-      expect(result.defaultAgentName).toBe('agent');
-      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        'Unknown key "unexpectedKey" in project README config section (project URL: https://github.com/orgs/example/projects/2)',
-      );
-
-      consoleWarnSpy.mockRestore();
-    });
-
-    it('should warn for a typo of a known key (maximumPreparingIssueCount missing trailing s)', () => {
-      const readme = `<details>
-<summary>config</summary>
-maximumPreparingIssueCount: 9
-</details>`;
-      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-
-      const result = parseProjectReadmeConfig(
-        readme,
-        'https://github.com/orgs/example/projects/3',
-      );
-
-      expect(result.maximumPreparingIssuesCount).toBeUndefined();
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        'Unknown key "maximumPreparingIssueCount" in project README config section (project URL: https://github.com/orgs/example/projects/3)',
-      );
-
-      consoleWarnSpy.mockRestore();
-    });
-
-    it('should warn without project URL suffix when projectUrl is not provided', () => {
-      const readme = `<details>
-<summary>config</summary>
-mysteryKey: 'value'
-</details>`;
-      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-
-      parseProjectReadmeConfig(readme);
-
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        'Unknown key "mysteryKey" in project README config section',
-      );
-
-      consoleWarnSpy.mockRestore();
-    });
-  });
-
-  describe('mergeConfigs', () => {
-    it('should use configFile values when no overrides', () => {
-      const configFile = {
-        projectUrl: 'https://github.com/config/project',
-        defaultAgentName: 'config-agent',
-      };
-
-      const result = mergeConfigs(configFile, {}, {});
-
-      expect(result.projectUrl).toBe('https://github.com/config/project');
-      expect(result.defaultAgentName).toBe('config-agent');
-    });
-
-    it('should use CLI overrides over configFile', () => {
-      const configFile = {
-        projectUrl: 'https://github.com/config/project',
-        defaultAgentName: 'config-agent',
-      };
-      const cliOverrides = {
-        defaultAgentName: 'cli-agent',
-      };
-
-      const result = mergeConfigs(configFile, cliOverrides, {});
-
-      expect(result.projectUrl).toBe('https://github.com/config/project');
-      expect(result.defaultAgentName).toBe('cli-agent');
-    });
-
-    it('should use README overrides over both CLI and configFile', () => {
-      const configFile = {
-        projectUrl: 'https://github.com/config/project',
-        defaultAgentName: 'config-agent',
-      };
-      const cliOverrides = {
-        defaultAgentName: 'cli-agent',
-      };
-      const readmeOverrides = {
-        defaultAgentName: 'readme-agent',
-      };
-
-      const result = mergeConfigs(configFile, cliOverrides, readmeOverrides);
-
-      expect(result.projectUrl).toBe('https://github.com/config/project');
-      expect(result.defaultAgentName).toBe('readme-agent');
-    });
-
-    it('should preserve projectName from configFile', () => {
-      const configFile = {
-        projectName: 'my-project',
-        projectUrl: 'https://github.com/config/project',
-      };
-
-      const result = mergeConfigs(configFile, {}, {});
-
-      expect(result.projectName).toBe('my-project');
-    });
-  });
-
-  describe('fetchProjectReadme', () => {
-    it('should fetch README from GitHub GraphQL API', async () => {
-      const responseBody = {
-        data: {
-          organization: {
-            projectV2: { readme: '# Project README' },
-          },
-        },
-      };
-      jest
-        .spyOn(global, 'fetch')
-        .mockResolvedValue(
-          new Response(JSON.stringify(responseBody), { status: 200 }),
-        );
-
-      const result = await fetchProjectReadme(
-        'https://github.com/orgs/test-org/projects/1',
-        'test-token',
-      );
-
-      expect(result).toBe('# Project README');
-    });
-
-    it('should try user if organization readme is null', async () => {
-      const responseBody = {
-        data: {
-          organization: { projectV2: { readme: null } },
-          user: { projectV2: { readme: '# User Project README' } },
-        },
-      };
-      jest
-        .spyOn(global, 'fetch')
-        .mockResolvedValue(
-          new Response(JSON.stringify(responseBody), { status: 200 }),
-        );
-
-      const result = await fetchProjectReadme(
-        'https://github.com/users/test-user/projects/1',
-        'test-token',
-      );
-
-      expect(result).toBe('# User Project README');
-    });
-
-    it('should fetch README for user-owned project when organization is null in response', async () => {
-      const responseBody = {
-        data: {
-          organization: null,
-          user: { projectV2: { readme: '# User Owned Project README' } },
-        },
-        errors: [
-          {
-            type: 'NOT_FOUND',
-            message:
-              "Could not resolve to an Organization with the login of 'test-user'.",
-          },
-        ],
-      };
-      jest
-        .spyOn(global, 'fetch')
-        .mockResolvedValue(
-          new Response(JSON.stringify(responseBody), { status: 200 }),
-        );
-
-      const result = await fetchProjectReadme(
-        'https://github.com/users/test-user/projects/1',
-        'test-token',
-      );
-
-      expect(result).toBe('# User Owned Project README');
-    });
-
-    it('should return null and warn on failure', async () => {
-      jest.spyOn(global, 'fetch').mockRejectedValue(new Error('Network error'));
-
-      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-
-      const result = await fetchProjectReadme(
-        'https://github.com/orgs/test/projects/1',
-        'test-token',
-      );
-
-      expect(result).toBeNull();
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Failed to fetch project README'),
-      );
-
-      consoleWarnSpy.mockRestore();
-    });
-
-    it('should reflect maximumPreparingIssuesCount from user-owned project README in merged config', async () => {
-      const readmeWithConfig = [
-        '# User Project',
-        '<details>',
-        '<summary>config</summary>',
-        'maximumPreparingIssuesCount: 7',
-        '</details>',
-      ].join('\n');
-      const responseBody = {
-        data: {
-          organization: null,
-          user: { projectV2: { readme: readmeWithConfig } },
-        },
-        errors: [
-          {
-            type: 'NOT_FOUND',
-            message:
-              "Could not resolve to an Organization with the login of 'test-user'.",
-          },
-        ],
-      };
-      jest
-        .spyOn(global, 'fetch')
-        .mockResolvedValue(
-          new Response(JSON.stringify(responseBody), { status: 200 }),
-        );
-
-      const readme = await fetchProjectReadme(
-        'https://github.com/users/test-user/projects/1',
-        'test-token',
-      );
-      const readmeOverrides = parseProjectReadmeConfig(readme ?? '');
-      const merged = mergeConfigs({}, {}, readmeOverrides);
-
-      expect(merged.maximumPreparingIssuesCount).toBe(7);
-    });
-  });
-
-  describe('startDaemon', () => {
-    it('should read parameters from config file', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      expect(mockRun).toHaveBeenCalledWith({
-        projectUrl: 'https://github.com/orgs/test/projects/1',
-        defaultAgentName: 'agent1',
-        defaultLlmModelName: null,
-        fallbackLlmModelName: null,
-        defaultLlmAgentName: null,
-        configFilePath: configFilePath,
-        maximumPreparingIssuesCount: null,
-        utilizationPercentageThreshold: 90,
-        allowedIssueAuthors: null,
-        manager: 'test-manager',
-        codexHomeCandidates: null,
-        labelsAsLlmAgentName: null,
-        agents: null,
-        normalConcurrentLimit: 6,
-        maxConcurrentWorkers: 40,
-        graphqlRateLimitFloor: 500,
-      });
-    });
-
-    it('should pass the configured agent definitions to start preparation', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-      writeConfig({
-        ...defaultConfig,
-        agents: ['impl', 'chore', 'accounting'],
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({ agents: ['impl', 'chore', 'accounting'] }),
-      );
-    });
-
-    it('should allow CLI args to override config file values', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-        '--projectUrl',
-        'https://github.com/orgs/override/projects/2',
-        '--defaultAgentName',
-        'override-agent',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      expect(mockRun).toHaveBeenCalledWith({
-        projectUrl: 'https://github.com/orgs/override/projects/2',
-        defaultAgentName: 'override-agent',
-        defaultLlmModelName: null,
-        fallbackLlmModelName: null,
-        defaultLlmAgentName: null,
-        configFilePath: configFilePath,
-        maximumPreparingIssuesCount: null,
-        utilizationPercentageThreshold: 90,
-        allowedIssueAuthors: null,
-        manager: 'test-manager',
-        codexHomeCandidates: null,
-        labelsAsLlmAgentName: null,
-        agents: null,
-        normalConcurrentLimit: 6,
-        maxConcurrentWorkers: 40,
-        graphqlRateLimitFloor: 500,
-      });
-    });
-
-    it('should pass defaultLlmModelName and allowedIssueAuthors from config file', async () => {
-      const configWithLlm = {
-        ...defaultConfig,
-        defaultLlmModelName: 'claude-opus-4-5',
-        allowedIssueAuthors: 'user1,user2',
-      };
-      writeConfig(configWithLlm);
-
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          defaultLlmModelName: 'claude-opus-4-5',
-          allowedIssueAuthors: ['user1', 'user2'],
-        }),
-      );
-    });
-
-    it('should pass maximumPreparingIssuesCount from config file', async () => {
-      const configWithCount = {
-        ...defaultConfig,
-        maximumPreparingIssuesCount: 10,
-      };
-      writeConfig(configWithCount);
-
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          maximumPreparingIssuesCount: 10,
-        }),
-      );
-    });
-
-    it('should pass maximumPreparingIssuesCount from CLI overriding config', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-        '--maximumPreparingIssuesCount',
-        '20',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          maximumPreparingIssuesCount: 20,
-        }),
-      );
-    });
-
-    it('should exit with error for non-numeric maximumPreparingIssuesCount', async () => {
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'startDaemon',
-          '--configFilePath',
-          configFilePath,
-          '--maximumPreparingIssuesCount',
-          'abc',
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'Invalid value for --maximumPreparingIssuesCount. It must be a positive integer.',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should exit with error for negative maximumPreparingIssuesCount', async () => {
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'startDaemon',
-          '--configFilePath',
-          configFilePath,
-          '--maximumPreparingIssuesCount',
-          '-5',
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'Invalid value for --maximumPreparingIssuesCount. It must be a positive integer.',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should exit with error when GH_TOKEN is missing', async () => {
-      delete process.env.GH_TOKEN;
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'startDaemon',
-          '--configFilePath',
-          configFilePath,
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'GH_TOKEN environment variable is required',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should exit with error when projectUrl is missing from both CLI and config', async () => {
-      const configWithoutProjectUrl = {
-        defaultAgentName: 'agent1',
-      };
-      writeConfig(configWithoutProjectUrl);
-
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'startDaemon',
-          '--configFilePath',
-          configFilePath,
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'projectUrl is required. Provide via --projectUrl, config file, or project README.',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should exit with error when defaultAgentName is missing', async () => {
-      const configMissing = {
-        projectUrl: 'https://github.com/orgs/test/projects/1',
-      };
-      writeConfig(configMissing);
-
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'startDaemon',
-          '--configFilePath',
-          configFilePath,
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'defaultAgentName is required. Provide via --defaultAgentName, config file, or project README.',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should exit with error when manager is missing', async () => {
-      const configMissing = {
-        projectUrl: 'https://github.com/orgs/test/projects/1',
-        defaultAgentName: 'agent1',
-      };
-      writeConfig(configMissing);
-
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'startDaemon',
-          '--configFilePath',
-          configFilePath,
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'manager is required. Provide via the config file so that only issues assigned to the manager are picked up.',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should log maximumPreparingIssuesCount before calling useCase.run', async () => {
-      const configWithValues = {
-        ...defaultConfig,
-        maximumPreparingIssuesCount: 10,
-      };
-      writeConfig(configWithValues);
-
-      const callOrder: string[] = [];
-      const consoleLogSpy = jest
-        .spyOn(console, 'log')
-        .mockImplementation(() => {
-          callOrder.push('console.log');
-        });
-      const mockRun = jest.fn().mockImplementation(() => {
-        callOrder.push('useCase.run');
-        return Promise.resolve({ rotationOrder: null });
-      });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        'maximumPreparingIssuesCount: 10',
-      );
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      const logIndex = callOrder.indexOf('console.log');
-      const runIndex = callOrder.indexOf('useCase.run');
-      expect(logIndex).toBeLessThan(runIndex);
-
-      consoleLogSpy.mockRestore();
-    });
-
-    it('should apply README config overrides', async () => {
-      const readmeContent = [
-        '# Project',
-        '<details>',
-        '<summary>config</summary>',
-        'defaultAgentName: readme-agent',
-        '</details>',
-      ].join('\n');
-      mockFetchReturningReadme(readmeContent);
-
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          defaultAgentName: 'readme-agent',
-        }),
-      );
-    });
-
-    it('should pass codexHomeCandidates from config file', async () => {
-      const configWithCandidates = {
-        ...defaultConfig,
-        codexHomeCandidates: ['.codex-dev1', '.codex-dev2', '.codex-main'],
-      };
-      writeConfig(configWithCandidates);
-
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          codexHomeCandidates: ['.codex-dev1', '.codex-dev2', '.codex-main'],
-        }),
-      );
-    });
-
-    it('should pass codexHomeCandidates as null when not in config', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          codexHomeCandidates: null,
-        }),
-      );
-    });
-
-    it('should pass codexHomeCandidates from README config', async () => {
-      const readmeContent = [
-        '# Project',
-        '<details>',
-        '<summary>config</summary>',
-        'codexHomeCandidates:',
-        '  - .codex-readme1',
-        '  - .codex-readme2',
-        '</details>',
-      ].join('\n');
-      mockFetchReturningReadme(readmeContent);
-
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          codexHomeCandidates: ['.codex-readme1', '.codex-readme2'],
-        }),
-      );
-    });
-
-    it('should start web console before preparation cycle when consoleAccessToken is provided', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      const mockKill = jest.fn();
-      const callOrder: string[] = [];
-      jest
-        .mocked(ensureConsoleRunningModule.ensureConsoleRunning)
-        .mockImplementationOnce(async () => {
-          callOrder.push('ensureWebConsoleRunning');
-          return { kill: mockKill };
-        });
-      mockRun.mockImplementationOnce(async () => {
-        callOrder.push('preparationRun');
-        return { rotationOrder: null };
-      });
-
-      writeConfig({
-        ...defaultConfig,
-        consoleAccessToken: 'test-key-abc',
-        consoleProjects: {
-          acme: 'https://github.com/orgs/acme/projects/1',
-          globex: 'https://github.com/orgs/globex/projects/1',
-        },
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(callOrder).toEqual(['ensureWebConsoleRunning', 'preparationRun']);
-      expect(
-        ensureConsoleRunningModule.ensureConsoleRunning,
-      ).toHaveBeenCalledWith(configFilePath, 9980, ['acme', 'globex']);
-    });
-
-    it('should not start web console when consoleAccessToken is not provided', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      jest.mocked(ensureConsoleRunningModule.ensureConsoleRunning).mockClear();
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      expect(
-        ensureConsoleRunningModule.ensureConsoleRunning,
-      ).not.toHaveBeenCalled();
-    });
-
-    it('should register SIGTERM and SIGINT handlers when a new web console process is started', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedStartPreparationUseCase = jest.mocked(
-        StartPreparationUseCase,
-      );
-      MockedStartPreparationUseCase.mockImplementation(function (
-        this: StartPreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      const mockKill = jest.fn();
-      jest
-        .mocked(ensureConsoleRunningModule.ensureConsoleRunning)
-        .mockResolvedValueOnce({ kill: mockKill });
-
-      const processOnceSpy = jest.spyOn(process, 'once');
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'test-key-sigterm' });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'startDaemon',
-        '--configFilePath',
-        configFilePath,
-      ]);
-
-      const sigtermCall = processOnceSpy.mock.calls.find(
-        ([event]) => event === 'SIGTERM',
-      );
-      const sigintCall = processOnceSpy.mock.calls.find(
-        ([event]) => event === 'SIGINT',
-      );
-      expect(sigtermCall).toBeDefined();
-      expect(sigintCall).toBeDefined();
-
-      processOnceSpy.mockRestore();
-
-      const rawSigtermHandler = sigtermCall?.[1];
-      const rawSigintHandler = sigintCall?.[1];
-      if (typeof rawSigtermHandler !== 'function') {
-        throw new Error('Expected SIGTERM handler to be a function');
-      }
-      if (typeof rawSigintHandler !== 'function') {
-        throw new Error('Expected SIGINT handler to be a function');
-      }
-      expect(() => rawSigtermHandler()).toThrow('process.exit called');
-      expect(mockKill).toHaveBeenCalledTimes(1);
-      expect(processExitSpy).toHaveBeenCalledWith(0);
-      expect(() => rawSigintHandler()).toThrow('process.exit called');
-      expect(mockKill).toHaveBeenCalledTimes(2);
-      expect(processExitSpy).toHaveBeenCalledTimes(2);
-
-      processExitSpy.mockRestore();
-    });
-  });
-
-  describe('notifyFinishedIssuePreparation', () => {
-    it('should read parameters from config file', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedNotifyFinishedUseCase = jest.mocked(
-        NotifyFinishedIssuePreparationUseCase,
-      );
-
-      MockedNotifyFinishedUseCase.mockImplementation(function (
-        this: NotifyFinishedIssuePreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'notifyFinishedIssuePreparation',
-        '--configFilePath',
-        configFilePath,
-        '--issueUrl',
-        'https://github.com/test/repo/issues/1',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      expect(mockRun).toHaveBeenCalledWith({
-        projectUrl: 'https://github.com/orgs/test/projects/1',
-        issueUrl: 'https://github.com/test/repo/issues/1',
-        thresholdForAutoReject: 3,
-        thresholdForDispatchLoop: 6,
-        workflowBlockerResolvedWebhookUrl: null,
-        allowedIssueAuthors: null,
-        labelsAsLlmAgentName: null,
-        labelsNotRequiringPullRequest: null,
-        changeTargetPathAliases: null,
-        agents: null,
-        missingAgentName: null,
-        sessionErrorLine: null,
-        manager: 'test-manager',
-        developerAgentNames: null,
-        deferPreparation: null,
-      });
-    });
-
-    it('should allow CLI args to override config file values', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedNotifyFinishedUseCase = jest.mocked(
-        NotifyFinishedIssuePreparationUseCase,
-      );
-
-      MockedNotifyFinishedUseCase.mockImplementation(function (
-        this: NotifyFinishedIssuePreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'notifyFinishedIssuePreparation',
-        '--configFilePath',
-        configFilePath,
-        '--issueUrl',
-        'https://github.com/test/repo/issues/1',
-        '--projectUrl',
-        'https://github.com/orgs/override/projects/2',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith({
-        projectUrl: 'https://github.com/orgs/override/projects/2',
-        issueUrl: 'https://github.com/test/repo/issues/1',
-        thresholdForAutoReject: 3,
-        thresholdForDispatchLoop: 6,
-        workflowBlockerResolvedWebhookUrl: null,
-        allowedIssueAuthors: null,
-        labelsAsLlmAgentName: null,
-        labelsNotRequiringPullRequest: null,
-        changeTargetPathAliases: null,
-        agents: null,
-        missingAgentName: null,
-        sessionErrorLine: null,
-        manager: 'test-manager',
-        developerAgentNames: null,
-        deferPreparation: null,
-      });
-    });
-
-    it('should pass custom thresholdForAutoReject from config file', async () => {
-      const configWithThreshold = {
-        ...defaultConfig,
-        thresholdForAutoReject: 5,
-      };
-      writeConfig(configWithThreshold);
-
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedNotifyFinishedUseCase = jest.mocked(
-        NotifyFinishedIssuePreparationUseCase,
-      );
-
-      MockedNotifyFinishedUseCase.mockImplementation(function (
-        this: NotifyFinishedIssuePreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'notifyFinishedIssuePreparation',
-        '--configFilePath',
-        configFilePath,
-        '--issueUrl',
-        'https://github.com/test/repo/issues/1',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          thresholdForAutoReject: 5,
-        }),
-      );
-    });
-
-    it('should pass custom thresholdForAutoReject from CLI overriding config', async () => {
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedNotifyFinishedUseCase = jest.mocked(
-        NotifyFinishedIssuePreparationUseCase,
-      );
-
-      MockedNotifyFinishedUseCase.mockImplementation(function (
-        this: NotifyFinishedIssuePreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'notifyFinishedIssuePreparation',
-        '--configFilePath',
-        configFilePath,
-        '--issueUrl',
-        'https://github.com/test/repo/issues/1',
-        '--thresholdForAutoReject',
-        '7',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          thresholdForAutoReject: 7,
-        }),
-      );
-    });
-
-    it('should exit with error for invalid thresholdForAutoReject', async () => {
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'notifyFinishedIssuePreparation',
-          '--configFilePath',
-          configFilePath,
-          '--issueUrl',
-          'https://github.com/test/repo/issues/1',
-          '--thresholdForAutoReject',
-          'abc',
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'Invalid value for --thresholdForAutoReject. It must be a positive integer.',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should exit with error when GH_TOKEN is missing', async () => {
-      delete process.env.GH_TOKEN;
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'notifyFinishedIssuePreparation',
-          '--configFilePath',
-          configFilePath,
-          '--issueUrl',
-          'https://github.com/test/repo/issues/1',
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'GH_TOKEN environment variable is required',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should exit with error when projectUrl is missing', async () => {
-      const configMissing = {};
-      writeConfig(configMissing);
-
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'notifyFinishedIssuePreparation',
-          '--configFilePath',
-          configFilePath,
-          '--issueUrl',
-          'https://github.com/test/repo/issues/1',
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'projectUrl is required. Provide via --projectUrl, config file, or project README.',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should pass workflowBlockerResolvedWebhookUrl from config file', async () => {
-      const configWithWebhook = {
-        ...defaultConfig,
-        workflowBlockerResolvedWebhookUrl:
-          'https://example.com/webhook?url={URL}',
-      };
-      writeConfig(configWithWebhook);
-
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedNotifyFinishedUseCase = jest.mocked(
-        NotifyFinishedIssuePreparationUseCase,
-      );
-
-      MockedNotifyFinishedUseCase.mockImplementation(function (
-        this: NotifyFinishedIssuePreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'notifyFinishedIssuePreparation',
-        '--configFilePath',
-        configFilePath,
-        '--issueUrl',
-        'https://github.com/test/repo/issues/1',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          workflowBlockerResolvedWebhookUrl:
-            'https://example.com/webhook?url={URL}',
-        }),
-      );
-    });
-
-    it('should apply README config overrides for thresholdForAutoReject', async () => {
-      const readmeContent = [
-        '# Project',
-        '<details>',
-        '<summary>config</summary>',
-        'thresholdForAutoReject: 9',
-        '</details>',
-      ].join('\n');
-      mockFetchReturningReadme(readmeContent);
-
-      const mockRun = jest.fn().mockResolvedValue({ rotationOrder: null });
-      const MockedNotifyFinishedUseCase = jest.mocked(
-        NotifyFinishedIssuePreparationUseCase,
-      );
-
-      MockedNotifyFinishedUseCase.mockImplementation(function (
-        this: NotifyFinishedIssuePreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'notifyFinishedIssuePreparation',
-        '--configFilePath',
-        configFilePath,
-        '--issueUrl',
-        'https://github.com/test/repo/issues/1',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({
-          thresholdForAutoReject: 9,
-        }),
-      );
-    });
-
-    it('passes manager from config file to useCase.run', async () => {
-      const configWithManager = {
-        ...defaultConfig,
-        manager: 'alice',
-      };
-      writeConfig(configWithManager);
-
-      const mockRun = jest.fn().mockResolvedValue(undefined);
-      const MockedNotifyFinishedUseCase = jest.mocked(
-        NotifyFinishedIssuePreparationUseCase,
-      );
-
-      MockedNotifyFinishedUseCase.mockImplementation(function (
-        this: NotifyFinishedIssuePreparationUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'notifyFinishedIssuePreparation',
-        '--configFilePath',
-        configFilePath,
-        '--issueUrl',
-        'https://github.com/test/repo/issues/1',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledWith(
-        expect.objectContaining({ manager: 'alice' }),
-      );
-    });
-  });
-
-  describe('checkIssueReviewReadiness', () => {
-    it('should appear in the CLI help output', () => {
-      const helpText = program.helpInformation();
-      expect(helpText).toContain('checkIssueReviewReadiness');
-    });
-
-    it('should write reviewReady=true JSON to stdout when the use case reports zero rejections', async () => {
-      const mockRun = jest
-        .fn()
-        .mockResolvedValue({ reviewReady: true, rejections: [] });
-      const MockedCheckUseCase = jest.mocked(CheckIssueReviewReadinessUseCase);
-
-      MockedCheckUseCase.mockImplementation(function (
-        this: CheckIssueReviewReadinessUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      const stdoutSpy = jest
-        .spyOn(process.stdout, 'write')
-        .mockImplementation(() => true);
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'checkIssueReviewReadiness',
-        '--configFilePath',
-        configFilePath,
-        '--issueUrl',
-        'https://github.com/test/repo/issues/1',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      expect(mockRun).toHaveBeenCalledWith({
-        issueUrl: 'https://github.com/test/repo/issues/1',
-        allowedIssueAuthors: null,
-        labelsAsLlmAgentName: null,
-        labelsNotRequiringPullRequest: null,
-        developerAgentNames: null,
-      });
-      expect(stdoutSpy).toHaveBeenCalledWith(
-        `${JSON.stringify({ reviewReady: true, rejections: [] })}\n`,
-      );
-
-      stdoutSpy.mockRestore();
-    });
-
-    it('should write reviewReady=false JSON with rejections to stdout when the use case reports rejections', async () => {
-      const rejections = [
-        {
-          type: 'ANY_CI_JOB_FAILED_OR_IN_PROGRESS',
-          detail:
-            'ANY_CI_JOB_FAILED_OR_IN_PROGRESS: https://github.com/test/repo/pull/1',
-        },
-      ];
-      const mockRun = jest
-        .fn()
-        .mockResolvedValue({ reviewReady: false, rejections });
-      const MockedCheckUseCase = jest.mocked(CheckIssueReviewReadinessUseCase);
-
-      MockedCheckUseCase.mockImplementation(function (
-        this: CheckIssueReviewReadinessUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      const stdoutSpy = jest
-        .spyOn(process.stdout, 'write')
-        .mockImplementation(() => true);
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'checkIssueReviewReadiness',
-        '--configFilePath',
-        configFilePath,
-        '--issueUrl',
-        'https://github.com/test/repo/issues/1',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      expect(stdoutSpy).toHaveBeenCalledWith(
-        `${JSON.stringify({ reviewReady: false, rejections })}\n`,
-      );
-
-      stdoutSpy.mockRestore();
-    });
-
-    it('should work without --projectUrl when config has no projectUrl', async () => {
-      const configMissing = {};
-      writeConfig(configMissing);
-
-      const mockRun = jest
-        .fn()
-        .mockResolvedValue({ reviewReady: true, rejections: [] });
-      const MockedCheckUseCase = jest.mocked(CheckIssueReviewReadinessUseCase);
-
-      MockedCheckUseCase.mockImplementation(function (
-        this: CheckIssueReviewReadinessUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-
-      const stdoutSpy = jest
-        .spyOn(process.stdout, 'write')
-        .mockImplementation(() => true);
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'checkIssueReviewReadiness',
-        '--configFilePath',
-        configFilePath,
-        '--issueUrl',
-        'https://github.com/test/repo/issues/1',
-      ]);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      expect(mockRun).toHaveBeenCalledWith({
-        issueUrl: 'https://github.com/test/repo/issues/1',
-        allowedIssueAuthors: null,
-        labelsAsLlmAgentName: null,
-        labelsNotRequiringPullRequest: null,
-        developerAgentNames: null,
-      });
-
-      stdoutSpy.mockRestore();
-    });
-
-    it('should exit with error when GH_TOKEN is missing', async () => {
-      delete process.env.GH_TOKEN;
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'checkIssueReviewReadiness',
-          '--configFilePath',
-          configFilePath,
-          '--issueUrl',
-          'https://github.com/test/repo/issues/1',
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'GH_TOKEN environment variable is required',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-  });
-
-  describe('serveWeb', () => {
-    it('should appear in the CLI help output', () => {
-      const helpText = program.helpInformation();
-      expect(helpText).toContain('serveWeb');
-    });
-
-    it('should start the server on the default port 9980 when --port is omitted', async () => {
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const logSpy = jest.spyOn(console, 'log').mockImplementation();
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'serveWeb',
-        '--configFilePath',
-        configFilePath,
-        '--dashboardProjectNames',
-        'acme,globex',
-      ]);
-
-      expect(mockStartWebServer).toHaveBeenCalledTimes(1);
-      const callArg = mockStartWebServer.mock.calls[0][0];
-      expect(callArg.port).toBe(9980);
-      expect(callArg.accessToken).toBe('config-token');
-      expect(callArg.consoleDataOutputDir).toBeNull();
-      expect(callArg.dashboardProjectNames).toEqual(['acme', 'globex']);
-      expect(callArg.uiDistDir).toBe(
-        path.join(__dirname, '..', 'console', 'ui-dist'),
-      );
-      expect(fs.existsSync(path.join(callArg.uiDistDir, 'index.html'))).toBe(
-        true,
-      );
-
-      logSpy.mockRestore();
-    });
-
-    it('should exit with error when --dashboardProjectNames is omitted', async () => {
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'serveWeb',
-          '--configFilePath',
-          configFilePath,
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        '--dashboardProjectNames must list at least one project name',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-      expect(mockStartWebServer).not.toHaveBeenCalled();
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should exit with error when two --dashboardProjectNames share a display label', async () => {
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'serveWeb',
-          '--configFilePath',
-          configFilePath,
-          '--dashboardProjectNames',
-          'acme,acmelabs',
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'Dashboard project names acme and acmelabs share the display label ac',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-      expect(mockStartWebServer).not.toHaveBeenCalled();
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should validate --dashboardProjectNames before constructing the GitHub repositories', async () => {
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      jest.mocked(GraphqlProjectRepository).mockClear();
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'serveWeb',
-          '--configFilePath',
-          configFilePath,
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(jest.mocked(GraphqlProjectRepository)).not.toHaveBeenCalled();
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should use the provided --port and --consoleDataOutputDir', async () => {
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const logSpy = jest.spyOn(console, 'log').mockImplementation();
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'serveWeb',
-        '--configFilePath',
-        configFilePath,
-        '--port',
-        '12345',
-        '--consoleDataOutputDir',
-        '/tmp/console-data',
-        '--dashboardProjectNames',
-        'acme,globex',
-      ]);
-
-      const callArg = mockStartWebServer.mock.calls[0][0];
-      expect(callArg.port).toBe(12345);
-      expect(callArg.consoleDataOutputDir).toBe('/tmp/console-data');
-
-      logSpy.mockRestore();
-    });
-
-    it('should exit with error when consoleAccessToken is missing from config', async () => {
-      writeConfig(defaultConfig);
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'serveWeb',
-          '--configFilePath',
-          configFilePath,
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'consoleAccessToken is required. Provide it via the config file.',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should exit with error for an invalid --port value', async () => {
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'serveWeb',
-          '--configFilePath',
-          configFilePath,
-          '--port',
-          'not-a-number',
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should inject the resolved project and issue repository into the server', async () => {
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const logSpy = jest.spyOn(console, 'log').mockImplementation();
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'serveWeb',
-        '--configFilePath',
-        configFilePath,
-        '--dashboardProjectNames',
-        'acme,globex',
-      ]);
-
-      const callArg = mockStartWebServer.mock.calls[0][0];
-      expect(callArg.issueRepository).not.toBeNull();
-      expect(callArg.issueTitleStateCache).not.toBeNull();
-
-      const resolveProject = callArg.resolveProject;
-      if (resolveProject === null || resolveProject === undefined) {
-        throw new Error('resolveProject was not injected');
-      }
-      const binding = await resolveProject('test-project');
-      expect(binding).not.toBeNull();
-      expect(binding?.pjcode).toBe('test-project');
-      expect(binding?.project.name).toBe('test-project');
-
-      const unknownBinding = await resolveProject('not-configured');
-      expect(unknownBinding).toBeNull();
-
-      logSpy.mockRestore();
-    });
-
-    it('should exit with error when GH_TOKEN is missing', async () => {
-      delete process.env.GH_TOKEN;
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'serveWeb',
-          '--configFilePath',
-          configFilePath,
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'GH_TOKEN environment variable is required',
-      );
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('should exit with error when projectUrl is missing from config', async () => {
-      writeConfig({
-        defaultAgentName: 'agent1',
-        projectName: 'test-project',
-        consoleAccessToken: 'config-token',
-      });
-      mockFetchReturningReadme(null);
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'serveWeb',
-          '--configFilePath',
-          configFilePath,
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'projectUrl is required. Provide it via the config file or project README.',
-      );
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-  });
-
-  describe('serveConsole (deprecated alias)', () => {
-    it('should appear in the CLI help output', () => {
-      const helpText = program.helpInformation();
-      expect(helpText).toContain('serveConsole');
-    });
-
-    it('should route to the same handler as serveWeb on the default port 9980', async () => {
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const logSpy = jest.spyOn(console, 'log').mockImplementation();
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'serveConsole',
-        '--configFilePath',
-        configFilePath,
-        '--dashboardProjectNames',
-        'acme,globex',
-      ]);
-
-      expect(mockStartWebServer).toHaveBeenCalledTimes(1);
-      const callArg = mockStartWebServer.mock.calls[0][0];
-      expect(callArg.port).toBe(9980);
-      expect(callArg.accessToken).toBe('config-token');
-      expect(callArg.consoleDataOutputDir).toBeNull();
-      expect(callArg.uiDistDir).toBe(
-        path.join(__dirname, '..', 'console', 'ui-dist'),
-      );
-
-      logSpy.mockRestore();
-    });
-
-    it('should use the provided --port and --consoleDataOutputDir', async () => {
-      writeConfig({ ...defaultConfig, consoleAccessToken: 'config-token' });
-      const logSpy = jest.spyOn(console, 'log').mockImplementation();
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'serveConsole',
-        '--configFilePath',
-        configFilePath,
-        '--port',
-        '12345',
-        '--consoleDataOutputDir',
-        '/tmp/console-data',
-        '--dashboardProjectNames',
-        'acme,globex',
-      ]);
-
-      const callArg = mockStartWebServer.mock.calls[0][0];
-      expect(callArg.port).toBe(12345);
-      expect(callArg.consoleDataOutputDir).toBe('/tmp/console-data');
-
-      logSpy.mockRestore();
-    });
-  });
-
-  describe('killTmuxSession', () => {
-    it('reaches the real repository command sequence to kill a named session via --session', async () => {
-      await program.parseAsync([
-        'node',
-        'test',
-        'killTmuxSession',
-        '--session',
-        'https_//github_com/owner/repo/issues/9',
-      ]);
-
-      const expectedScopeUnitName =
-        'cl-https---github-com-owner-repo-issues-9.scope';
-      expect(mockRunCommand.mock.calls).toEqual([
-        ['systemctl', ['--user', 'reset-failed', expectedScopeUnitName]],
-        ['systemctl', ['--user', 'stop', expectedScopeUnitName]],
-        ['systemctl', ['--user', 'reset-failed', expectedScopeUnitName]],
-        [
-          'tmux',
-          ['kill-session', '-t', '=https_//github_com/owner/repo/issues/9'],
-        ],
-      ]);
-    });
-
-    it('reaches the real repository command sequence to stop its own scope via --self, without calling tmux', async () => {
-      const actualFs = jest.requireActual<typeof fs>('fs');
-      const readFileSyncMock = jest.mocked(fs.readFileSync);
-      readFileSyncMock.mockImplementation(
-        (
-          filePath: Parameters<typeof fs.readFileSync>[0],
-          options: Parameters<typeof fs.readFileSync>[1],
-        ): ReturnType<typeof fs.readFileSync> => {
-          if (filePath === '/proc/self/cgroup') {
-            return '0::/user.slice/user-1000.slice/user@1000.service/app.slice/cl-current-session.scope\n';
-          }
-          return actualFs.readFileSync(filePath, options);
-        },
-      );
-
-      await program.parseAsync(['node', 'test', 'killTmuxSession', '--self']);
-
-      expect(mockRunCommand.mock.calls).toEqual([
-        ['systemctl', ['--user', 'reset-failed', 'cl-current-session.scope']],
-        ['systemctl', ['--user', 'stop', 'cl-current-session.scope']],
-        ['systemctl', ['--user', 'reset-failed', 'cl-current-session.scope']],
-      ]);
-      expect(mockRunCommand.mock.calls.some((call) => call[0] === 'tmux')).toBe(
-        false,
-      );
-
-      readFileSyncMock.mockImplementation(actualFs.readFileSync);
-    });
-
-    it('exits with an error when neither --session nor --self is provided', async () => {
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync(['node', 'test', 'killTmuxSession']),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'Either --session <name> or --self is required',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('exits with an error when both --session and --self are provided', async () => {
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(
-        program.parseAsync([
-          'node',
-          'test',
-          'killTmuxSession',
-          '--session',
-          'some_session',
-          '--self',
-        ]),
-      ).rejects.toThrow('process.exit called');
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        '--session and --self cannot be used together',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-  });
-
-  describe('attachOrCreate', () => {
-    const issueUrl = 'https://github.com/owner/repo/issues/9';
-    let scopeLibPath = '';
-
-    beforeEach(() => {
-      scopeLibPath = path.join(
-        os.tmpdir(),
-        `test-cl-scope-lib-${Date.now()}.sh`,
-      );
-      fs.writeFileSync(scopeLibPath, '#!/bin/bash\n');
-      process.env.CL_SCOPE_LIB_PATH = scopeLibPath;
-    });
-
-    afterEach(() => {
-      if (fs.existsSync(scopeLibPath)) {
-        fs.unlinkSync(scopeLibPath);
-      }
-      delete process.env.CL_SCOPE_LIB_PATH;
-    });
-
-    it('attaches to the registered session when registry returns a live session', async () => {
-      mockRunCommand
-        .mockResolvedValueOnce({ stdout: 'wq7x3mk\n', stderr: '', exitCode: 0 })
-        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'attachOrCreate',
-        '--issueUrl',
-        issueUrl,
-      ]);
-
-      expect(mockRunCommand.mock.calls[0]).toEqual([
-        'bash',
-        [scopeLibPath, 'registry-get-session', issueUrl],
-      ]);
-      expect(mockRunCommand.mock.calls[1]).toEqual([
-        'tmux',
-        ['has-session', '-t', '=wq7x3mk'],
-      ]);
-      expect(mockSpawnInteractive).toHaveBeenCalledWith('tmux', [
-        'attach-session',
-        '-t',
-        '=wq7x3mk',
-      ]);
-    });
-
-    it('creates a new session when no registered session is found', async () => {
-      mockRunCommand.mockResolvedValueOnce({
-        stdout: '',
-        stderr: '',
-        exitCode: 0,
-      });
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'attachOrCreate',
-        '--issueUrl',
-        issueUrl,
-      ]);
-
-      expect(mockSpawnInteractive).toHaveBeenCalledWith('tmux', [
-        'new-session',
-        '-A',
-        '-s',
-        issueUrl,
-        'cl',
-        issueUrl,
-      ]);
-    });
-
-    it('creates a new session when no scope lib path is available', async () => {
-      jest
-        .mocked(fs.existsSync)
-        .mockReturnValueOnce(false)
-        .mockReturnValueOnce(false);
-
-      await program.parseAsync([
-        'node',
-        'test',
-        'attachOrCreate',
-        '--issueUrl',
-        issueUrl,
-      ]);
-
-      expect(mockRunCommand.mock.calls).toHaveLength(0);
-      expect(mockSpawnInteractive).toHaveBeenCalledWith('tmux', [
-        'new-session',
-        '-A',
-        '-s',
-        issueUrl,
-        'cl',
-        issueUrl,
-      ]);
-    });
-  });
-
-  describe('ownerCallFileAppend and ownerCallFileDelete', () => {
-    const issueUrl = 'https://github.com/OWNER/REPO/issues/1';
-    const otherIssueUrl = 'https://github.com/OWNER/REPO/issues/2';
-    const sessionName = toTmuxSessionName(issueUrl);
-    let ownerCallDataDir = '';
-    let bodyFilePath = '';
-
-    beforeEach(() => {
-      ownerCallDataDir = fs.mkdtempSync(
-        path.join(os.tmpdir(), 'owner-call-cli-'),
-      );
-      bodyFilePath = path.join(ownerCallDataDir, 'body.txt');
-      fs.writeFileSync(bodyFilePath, '  the call body\n\nsecond paragraph\n');
-    });
-
-    afterEach(() => {
-      fs.rmSync(ownerCallDataDir, { recursive: true, force: true });
-    });
-
-    // The in-tmux-by-human data the scheduled run writes into the same
-    // directory serveWeb serves: one file per project, each listing the
-    // sessions of that project by their raw issue url.
-    type InTmuxByHumanProjectData = {
-      projectCode: string;
-      sessionIssueUrls: string[];
-    };
-
-    const writeInTmuxByHumanData = (
-      projects: InTmuxByHumanProjectData[],
-    ): void => {
-      for (const project of projects) {
-        fs.writeFileSync(
-          path.join(ownerCallDataDir, `${project.projectCode}.v4.json`),
-          `${JSON.stringify({
-            version: 4,
-            overviewUrl: 'https://github.com/orgs/OWNER/projects/1',
-            tdpmConsoleUrl: 'http://localhost/projects/code',
-            newIssueUrl: 'https://github.com/OWNER/REPO/issues/new',
-            groups: [
-              {
-                story: 'a story',
-                sessions: project.sessionIssueUrls.map((url) => ({
-                  name: url,
-                  description: 'an issue title',
-                })),
-              },
-            ],
-          })}\n`,
-        );
-      }
-    };
-
-    const projectCodeListing = (
-      projects: InTmuxByHumanProjectData[],
-      url: string,
-    ): string | null =>
-      projects.find((project) => project.sessionIssueUrls.includes(url))
-        ?.projectCode ?? null;
-
-    const appendedFilePath = (projectCode: string | null): string =>
-      path.join(
-        ownerCallDataDir,
-        ownerCallFileRelativePath(projectCode, sessionName),
-      );
-
-    const runAppend = (calledAt: string): Promise<unknown> =>
-      program.parseAsync([
-        'node',
-        'test',
-        'ownerCallFileAppend',
-        '--session',
-        sessionName,
-        '--calledAt',
-        calledAt,
-        '--body-file',
-        bodyFilePath,
-        '--inTmuxDataDir',
-        ownerCallDataDir,
-      ]);
-
-    it('appends the call under the directory of the project whose session list holds the session', async () => {
-      const projects: InTmuxByHumanProjectData[] = [
-        { projectCode: 'other', sessionIssueUrls: [otherIssueUrl] },
-        { projectCode: 'umino', sessionIssueUrls: [issueUrl] },
-      ];
-      writeInTmuxByHumanData(projects);
-      const stdoutSpy = jest
-        .spyOn(process.stdout, 'write')
-        .mockImplementation(() => true);
-
-      await runAppend('2026-08-14T04:22:28Z');
-
-      const documents = YAML.parseAllDocuments(
-        fs.readFileSync(
-          appendedFilePath(projectCodeListing(projects, issueUrl)),
-          'utf-8',
-        ),
-      );
-      expect(documents).toHaveLength(1);
-      expect(documents[0].toJS()).toEqual({
-        sessionName,
-        calledAt: '2026-08-14T04:22:28Z',
-        body: '  the call body\n\nsecond paragraph\n',
-      });
-      expect(stdoutSpy).not.toHaveBeenCalled();
-
-      stdoutSpy.mockRestore();
-    });
-
-    it('appends the call under NA when no project lists the session', async () => {
-      const projects: InTmuxByHumanProjectData[] = [
-        { projectCode: 'umino', sessionIssueUrls: [otherIssueUrl] },
-      ];
-      writeInTmuxByHumanData(projects);
-
-      await runAppend('2026-08-14T04:22:28Z');
-
-      expect(projectCodeListing(projects, issueUrl)).toBeNull();
-      expect(fs.existsSync(appendedFilePath(null))).toBe(true);
-    });
-
-    it('rejects a calledAt that is not a UTC ISO-8601 timestamp with second precision', async () => {
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-
-      await expect(runAppend('2026-08-14 04:22:28')).rejects.toThrow(
-        'process.exit called',
-      );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-      expect(fs.existsSync(appendedFilePath(null))).toBe(false);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    const runDelete = (): Promise<unknown> =>
-      program.parseAsync([
-        'node',
-        'test',
-        'ownerCallFileDelete',
-        '--session',
-        sessionName,
-        '--inTmuxDataDir',
-        ownerCallDataDir,
-      ]);
-
-    it('deletes the file of the session whichever project directory holds it', async () => {
-      const projects: InTmuxByHumanProjectData[] = [
-        { projectCode: 'umino', sessionIssueUrls: [issueUrl] },
-      ];
-      writeInTmuxByHumanData(projects);
-      await runAppend('2026-08-14T04:22:28Z');
-      const writtenFilePath = appendedFilePath(
-        projectCodeListing(projects, issueUrl),
-      );
-      expect(fs.existsSync(writtenFilePath)).toBe(true);
-
-      await runDelete();
-
-      expect(fs.existsSync(writtenFilePath)).toBe(false);
-    });
-
-    it('deletes the file left behind under the project the session has since left', async () => {
-      writeInTmuxByHumanData([
-        { projectCode: 'umino', sessionIssueUrls: [issueUrl] },
-      ]);
-      await runAppend('2026-08-14T04:22:28Z');
-      writeInTmuxByHumanData([
-        { projectCode: 'umino', sessionIssueUrls: [] },
-        { projectCode: 'other', sessionIssueUrls: [issueUrl] },
-      ]);
-
-      await runDelete();
-
-      expect(fs.existsSync(appendedFilePath('umino'))).toBe(false);
-    });
-
-    it('succeeds when the file to delete is already absent', async () => {
-      await expect(runDelete()).resolves.toBeDefined();
-    });
-  });
-
-  describe('runCliProgram', () => {
-    const mockCheckUseCaseRejectingWith = (error: Error): void => {
-      const MockedCheckUseCase = jest.mocked(CheckIssueReviewReadinessUseCase);
-      MockedCheckUseCase.mockImplementation(function (
-        this: CheckIssueReviewReadinessUseCase,
-      ) {
-        this.run = jest.fn().mockRejectedValue(error);
-        return this;
-      });
-    };
-
-    const checkIssueReviewReadinessArgv = [
-      'node',
-      'test',
-      'checkIssueReviewReadiness',
-      '--configFilePath',
-      configFilePath,
-      '--issueUrl',
-      'https://github.com/test/repo/issues/1',
-    ];
-
-    it('should pass the rejection of an async action handler to the fatal error handler', async () => {
-      const thrownError = new Error('GitHub API failure');
-      mockCheckUseCaseRejectingWith(thrownError);
-      const handleFatalError = jest.fn();
-
-      await runCliProgram(checkIssueReviewReadinessArgv, handleFatalError);
-
-      expect(handleFatalError).toHaveBeenCalledTimes(1);
-      expect(handleFatalError).toHaveBeenCalledWith(thrownError);
-    });
-
-    it('should not call the fatal error handler when the async action handler succeeds', async () => {
-      const mockRun = jest
-        .fn()
-        .mockResolvedValue({ reviewReady: true, rejections: [] });
-      const MockedCheckUseCase = jest.mocked(CheckIssueReviewReadinessUseCase);
-
-      MockedCheckUseCase.mockImplementation(function (
-        this: CheckIssueReviewReadinessUseCase,
-      ) {
-        this.run = mockRun;
-        return this;
-      });
-      const stdoutSpy = jest
-        .spyOn(process.stdout, 'write')
-        .mockImplementation(() => true);
-      const handleFatalError = jest.fn();
-
-      await runCliProgram(checkIssueReviewReadinessArgv, handleFatalError);
-
-      expect(mockRun).toHaveBeenCalledTimes(1);
-      expect(handleFatalError).not.toHaveBeenCalled();
-
-      stdoutSpy.mockRestore();
-    });
-  });
-
-  describe('reportFatalErrorAndExit', () => {
-    it('should write the error to stderr and exit with code 1', () => {
-      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-      const processExitSpy = jest
-        .spyOn(process, 'exit')
-        .mockImplementation(() => {
-          throw new Error('process.exit called');
-        });
-      const thrownError = new Error('GitHub API failure');
-
-      expect(() => reportFatalErrorAndExit(thrownError)).toThrow(
-        'process.exit called',
-      );
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(thrownError);
-      expect(processExitSpy).toHaveBeenCalledWith(1);
-
-      consoleErrorSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-  });
-});