github-issue-tower-defence-management 2.3.0 → 2.5.0

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

@@ -4,9 +4,11 @@ import * as path from 'path';
 import { DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS } from '../../../domain/usecases/LiveSessionOauthTokenSelectUseCase';
 import {
   DEFAULT_PREPARATION_WORKER_SETTINGS,
+  DEFAULT_START_PREPARATION_FLEET_SETTINGS,
   FLEET_CONFIG_FILE_PATH_ENVIRONMENT_VARIABLE,
   loadLiveSessionOauthTokenSelectionSettings,
   loadPreparationWorkerSettings,
+  loadStartPreparationFleetSettings,
   resolveFleetConfigFilePath,
 } from './fleetConfig';
 
@@ -303,3 +305,87 @@ describe('loadPreparationWorkerSettings', () => {
     );
   });
 });
+
+describe('loadStartPreparationFleetSettings', () => {
+  let tempDir: string;
+
+  const writeFleetConfig = (content: string): string => {
+    const fleetConfigFilePath = path.join(tempDir, 'fleet.config.yaml');
+    fs.writeFileSync(fleetConfigFilePath, content);
+    return fleetConfigFilePath;
+  };
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fleet-config-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('returns the built-in settings when no fleet config path is given', () => {
+    expect(loadStartPreparationFleetSettings(null)).toEqual(
+      DEFAULT_START_PREPARATION_FLEET_SETTINGS,
+    );
+  });
+
+  it('reads maximumPreparingIssuesCount from the startPreparation section', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      ['startPreparation:', '  maximumPreparingIssuesCount: 100'].join('\n'),
+    );
+
+    expect(loadStartPreparationFleetSettings(fleetConfigFilePath)).toEqual({
+      maximumPreparingIssuesCount: 100,
+    });
+  });
+
+  it('returns the built-in settings when the fleet config has no startPreparation section', () => {
+    const fleetConfigFilePath = writeFleetConfig('inTmuxLauncherCommand: cl\n');
+
+    expect(loadStartPreparationFleetSettings(fleetConfigFilePath)).toEqual(
+      DEFAULT_START_PREPARATION_FLEET_SETTINGS,
+    );
+  });
+
+  it('returns the built-in settings for an empty fleet config file', () => {
+    const fleetConfigFilePath = writeFleetConfig('');
+
+    expect(loadStartPreparationFleetSettings(fleetConfigFilePath)).toEqual(
+      DEFAULT_START_PREPARATION_FLEET_SETTINGS,
+    );
+  });
+
+  it('throws when the fleet config file does not exist', () => {
+    expect(() =>
+      loadStartPreparationFleetSettings(path.join(tempDir, 'missing.yaml')),
+    ).toThrow();
+  });
+
+  it('throws when maximumPreparingIssuesCount is not a positive integer', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      ['startPreparation:', '  maximumPreparingIssuesCount: 0'].join('\n'),
+    );
+
+    expect(() =>
+      loadStartPreparationFleetSettings(fleetConfigFilePath),
+    ).toThrow('maximumPreparingIssuesCount');
+  });
+
+  it('throws when maximumPreparingIssuesCount is written as a string', () => {
+    const fleetConfigFilePath = writeFleetConfig(
+      ['startPreparation:', "  maximumPreparingIssuesCount: '100'"].join('\n'),
+    );
+
+    expect(() =>
+      loadStartPreparationFleetSettings(fleetConfigFilePath),
+    ).toThrow('must be a number');
+  });
+
+  it('throws when the startPreparation section is not a mapping', () => {
+    const fleetConfigFilePath = writeFleetConfig('startPreparation: 10\n');
+
+    expect(() =>
+      loadStartPreparationFleetSettings(fleetConfigFilePath),
+    ).toThrow('must be a mapping');
+  });
+});

package/src/adapter/entry-points/cli/fleetConfig.ts

@@ -11,6 +11,9 @@ export const FLEET_CONFIG_FILE_PATH_ENVIRONMENT_VARIABLE = 'TDPM_FLEET_CONFIG';
 export const LIVE_SESSION_OAUTH_TOKEN_SELECTION_SECTION_KEY =
   'liveSessionOauthTokenSelection';
 export const PREPARATION_WORKER_SECTION_KEY = 'preparationWorker';
+export const START_PREPARATION_SECTION_KEY = 'startPreparation';
+
+export const DEFAULT_FLEET_MAXIMUM_PREPARING_ISSUES_COUNT = 80;
 
 export type PreparationWorkerSettings = {
   normalConcurrentLimit: number;
@@ -20,6 +23,15 @@ export const DEFAULT_PREPARATION_WORKER_SETTINGS: PreparationWorkerSettings = {
   normalConcurrentLimit: NORMAL_CONCURRENT_LIMIT,
 };
 
+export type StartPreparationFleetSettings = {
+  maximumPreparingIssuesCount: number;
+};
+
+export const DEFAULT_START_PREPARATION_FLEET_SETTINGS: StartPreparationFleetSettings =
+  {
+    maximumPreparingIssuesCount: DEFAULT_FLEET_MAXIMUM_PREPARING_ISSUES_COUNT,
+  };
+
 export const resolveFleetConfigFilePath = (
   cliValue: string | null,
 ): string | null => {
@@ -168,3 +180,29 @@ export const loadPreparationWorkerSettings = (
     ),
   };
 };
+
+export const loadStartPreparationFleetSettings = (
+  fleetConfigFilePath: string | null,
+): StartPreparationFleetSettings => {
+  if (fleetConfigFilePath === null) {
+    return DEFAULT_START_PREPARATION_FLEET_SETTINGS;
+  }
+  const section = readFleetConfigSection(
+    fleetConfigFilePath,
+    START_PREPARATION_SECTION_KEY,
+  );
+  if (section === null) {
+    return DEFAULT_START_PREPARATION_FLEET_SETTINGS;
+  }
+  return {
+    maximumPreparingIssuesCount: readBoundedNumber(
+      section,
+      START_PREPARATION_SECTION_KEY,
+      'maximumPreparingIssuesCount',
+      fleetConfigFilePath,
+      DEFAULT_START_PREPARATION_FLEET_SETTINGS.maximumPreparingIssuesCount,
+      (value) => Number.isInteger(value) && value >= 1,
+      'integer of at least 1',
+    ),
+  };
+};

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

@@ -83,14 +83,6 @@ jest.mock(
 jest.mock('../../../domain/usecases/CreateEstimationIssueUseCase', () => ({
   CreateEstimationIssueUseCase: jest.fn().mockImplementation(() => ({})),
 }));
-jest.mock(
-  '../../../domain/usecases/ConvertCheckboxToIssueInStoryIssueUseCase',
-  () => ({
-    ConvertCheckboxToIssueInStoryIssueUseCase: jest
-      .fn()
-      .mockImplementation(() => ({})),
-  }),
-);
 jest.mock('../../../domain/usecases/ChangeStatusByStoryColorUseCase', () => ({
   ChangeStatusByStoryColorUseCase: jest.fn().mockImplementation(() => ({})),
 }));
@@ -419,6 +411,30 @@ allowedIssueAuthors: 'user1, user2, user3'
       });
     });
 
+    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));

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

@@ -10,6 +10,7 @@ import {
 import { writeDashboardRow } from './dashboardRowWriter';
 import { writeMachineStatus } from './machineStatusWriter';
 import { writeTokenStatus } from './tokenStatusWriter';
+import { handleSubscriptionDisabledTokens } from './subscriptionDisabledTokenHandler';
 import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
 import { cleanClosedIssueOwnerCallFiles } from './ownerCallFileCleaner';
 import { reconcileInTmuxByHumanSessions } from './inTmuxByHumanSessionReconciler';
@@ -32,6 +33,10 @@ import {
   fetchProjectReadme,
   parseProjectReadmeConfig,
 } from '../cli/projectConfig';
+import {
+  loadStartPreparationFleetSettings,
+  resolveFleetConfigFilePath,
+} from '../cli/fleetConfig';
 import { SystemDateRepository } from '../../repositories/SystemDateRepository';
 import { LocalStorageRepository } from '../../repositories/LocalStorageRepository';
 import { GoogleSpreadsheetRepository } from '../../repositories/GoogleSpreadsheetRepository';
@@ -55,7 +60,6 @@ import { ClearDependedIssueURLUseCase } from '../../../domain/usecases/ClearDepe
 import { SetDependedIssueUrlForOpenTaskPRsUseCase } from '../../../domain/usecases/SetDependedIssueUrlForOpenTaskPRsUseCase';
 import { StaleTaskPullRequestCloseUseCase } from '../../../domain/usecases/StaleTaskPullRequestCloseUseCase';
 import { CreateEstimationIssueUseCase } from '../../../domain/usecases/CreateEstimationIssueUseCase';
-import { ConvertCheckboxToIssueInStoryIssueUseCase } from '../../../domain/usecases/ConvertCheckboxToIssueInStoryIssueUseCase';
 import { ChangeStatusByStoryColorUseCase } from '../../../domain/usecases/ChangeStatusByStoryColorUseCase';
 import { SetNoStoryIssueToStoryUseCase } from '../../../domain/usecases/SetNoStoryIssueToStoryUseCase';
 import { CreateNewStoryByLabelUseCase } from '../../../domain/usecases/CreateNewStoryByLabelUseCase';
@@ -272,6 +276,10 @@ export class HandleScheduledEventUseCaseHandler {
       ? parseProjectReadmeConfig(readme, input.projectUrl)
       : {};
 
+    const startPreparationFleetSettings = loadStartPreparationFleetSettings(
+      resolveFleetConfigFilePath(null),
+    );
+
     const normalizeAllowedIssueAuthors = (
       value: string | string[] | null | undefined,
     ): string[] | null => {
@@ -323,7 +331,8 @@ export class HandleScheduledEventUseCaseHandler {
               input.startPreparation.defaultLlmAgentName,
             maximumPreparingIssuesCount:
               readmeConfig.maximumPreparingIssuesCount ??
-              input.startPreparation.maximumPreparingIssuesCount,
+              input.startPreparation.maximumPreparingIssuesCount ??
+              startPreparationFleetSettings.maximumPreparingIssuesCount,
             utilizationPercentageThreshold:
               readmeConfig.utilizationPercentageThreshold ??
               input.startPreparation.utilizationPercentageThreshold,
@@ -454,8 +463,6 @@ export class HandleScheduledEventUseCaseHandler {
       issueRepository,
       systemDateRepository,
     );
-    const convertCheckboxToIssueInStoryIssueUseCase =
-      new ConvertCheckboxToIssueInStoryIssueUseCase(issueRepository);
     const changeStatusByStoryColorUseCase = new ChangeStatusByStoryColorUseCase(
       systemDateRepository,
       issueRepository,
@@ -551,7 +558,6 @@ export class HandleScheduledEventUseCaseHandler {
       setDependedIssueUrlForOpenTaskPRsUseCase,
       staleTaskPullRequestCloseUseCase,
       createEstimationIssueUseCase,
-      convertCheckboxToIssueInStoryIssueUseCase,
       changeStatusByStoryColorUseCase,
       setNoStoryIssueToStoryUseCase,
       createNewStoryByLabel,
@@ -685,6 +691,22 @@ export class HandleScheduledEventUseCaseHandler {
         );
       }
 
+      try {
+        await handleSubscriptionDisabledTokens({
+          tokenListJsonPath:
+            mergedInput.claudeCodeOauthTokenListJsonPath ?? null,
+          org: input.org,
+          repo: input.workingReport.repo,
+          issueRepository,
+        });
+      } catch (error) {
+        console.error(
+          `Failed to handle subscription disabled tokens: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+
       const inTmuxNow = new Date();
 
       const inTmuxGetuid = process.getuid?.bind(process);

package/src/adapter/entry-points/handlers/subscriptionDisabledTokenHandler.ts

@@ -0,0 +1,41 @@
+import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import { SubscriptionDisabledIssueUseCase } from '../../../domain/usecases/SubscriptionDisabledIssueUseCase';
+import { loadTokenEntries } from '../../proxy/TokenListLoader';
+import { readRateLimit } from '../../proxy/RateLimitCache';
+
+export type SubscriptionDisabledTokenHandlerParams = {
+  tokenListJsonPath: string | null;
+  org: string;
+  repo: string;
+  issueRepository: Pick<
+    IssueRepository,
+    'searchIssue' | 'createNewIssue' | 'createCommentByUrl'
+  >;
+};
+
+export const handleSubscriptionDisabledTokens = async (
+  params: SubscriptionDisabledTokenHandlerParams,
+): Promise<void> => {
+  const { tokenListJsonPath, org, repo, issueRepository } = params;
+
+  if (tokenListJsonPath === null) {
+    return;
+  }
+
+  const entries = loadTokenEntries(tokenListJsonPath);
+  if (entries === null) {
+    return;
+  }
+
+  const tokenEntries = entries.map((entry) => ({
+    name: entry.name,
+    subscriptionDisabled:
+      readRateLimit(entry.token)?.subscriptionDisabled ?? false,
+  }));
+
+  await new SubscriptionDisabledIssueUseCase(issueRepository).run({
+    tokenEntries,
+    org,
+    repo,
+  });
+};

package/src/adapter/repositories/githubGraphqlClient.test.ts

@@ -126,12 +126,12 @@ describe('githubGraphqlClient', () => {
         '    at postGithubGraphqlJson (/app/bin/adapter/repositories/githubGraphqlClient.js:120:22)',
         '    at GraphqlProjectItemRepository.fetchProjectItemByUrl (/app/bin/adapter/repositories/issue/GraphqlProjectItemRepository.js:1042:11)',
         '    at ApiV3CheerioRestIssueRepository.getIssueByUrl (/app/bin/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.js:813:11)',
-        '    at async ConvertCheckboxToIssueInStoryIssueUseCase.run (/app/bin/domain/usecases/ConvertCheckboxToIssueInStoryIssueUseCase.js:63:31)',
+        '    at async ChangeStatusByStoryColorUseCase.run (/app/bin/domain/usecases/ChangeStatusByStoryColorUseCase.js:63:31)',
         '    at async HandleScheduledEventUseCase.runSlowSweepUseCases (/app/bin/domain/usecases/HandleScheduledEventUseCase.js:552:5)',
       ].join('\n');
 
       expect(extractGraphqlCallSite(stack)).toBe(
-        'GraphqlProjectItemRepository<-ApiV3CheerioRestIssueRepository<-ConvertCheckboxToIssueInStoryIssueUseCase',
+        'GraphqlProjectItemRepository<-ApiV3CheerioRestIssueRepository<-ChangeStatusByStoryColorUseCase',
       );
     });
 

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

@@ -9,7 +9,6 @@ import { ClearDependedIssueURLUseCase } from './ClearDependedIssueURLUseCase';
 import { SetDependedIssueUrlForOpenTaskPRsUseCase } from './SetDependedIssueUrlForOpenTaskPRsUseCase';
 import { StaleTaskPullRequestCloseUseCase } from './StaleTaskPullRequestCloseUseCase';
 import { CreateEstimationIssueUseCase } from './CreateEstimationIssueUseCase';
-import { ConvertCheckboxToIssueInStoryIssueUseCase } from './ConvertCheckboxToIssueInStoryIssueUseCase';
 import { DateRepository } from './adapter-interfaces/DateRepository';
 import { SpreadsheetRepository } from './adapter-interfaces/SpreadsheetRepository';
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
@@ -112,8 +111,6 @@ describe('HandleScheduledEventUseCase', () => {
       mock<StaleTaskPullRequestCloseUseCase>();
     const mockCreateEstimationIssueUseCase =
       mock<CreateEstimationIssueUseCase>();
-    const mockConvertCheckboxToIssueInStoryIssueUseCase =
-      mock<ConvertCheckboxToIssueInStoryIssueUseCase>();
     const mockChangeStatusByStoryColorUseCase =
       mock<ChangeStatusByStoryColorUseCase>();
     const mockSetNoStoryIssueToStoryUseCase =
@@ -158,7 +155,6 @@ describe('HandleScheduledEventUseCase', () => {
       mockSetDependedIssueUrlForOpenTaskPRsUseCase,
       mockStaleTaskPullRequestCloseUseCase,
       mockCreateEstimationIssueUseCase,
-      mockConvertCheckboxToIssueInStoryIssueUseCase,
       mockChangeStatusByStoryColorUseCase,
       mockSetNoStoryIssueToStoryUseCase,
       mockCreateNewStoryByLabelUseCase,
@@ -353,57 +349,6 @@ describe('HandleScheduledEventUseCase', () => {
       expect(mockProjectRepository.findProjectIdByUrl).toHaveBeenCalled();
     });
 
-    it('should pass createTaskFromStoryBodyCheckboxEnabled false to ConvertCheckboxToIssueInStoryIssueUseCase when the field is absent', async () => {
-      const input = {
-        projectName: 'test-project',
-        org: 'test-org',
-        projectUrl: 'https://github.com/test-org/test-project',
-        manager: 'test-manager',
-        workingReport: {
-          repo: 'test-repo',
-          members: ['member1'],
-          spreadsheetUrl: 'https://docs.google.com/spreadsheets/test',
-        },
-        urlOfStoryView: 'https://github.com/test-org/test-project/issues',
-        disabled: false,
-      };
-
-      await useCase.run(input);
-      expect(
-        mockConvertCheckboxToIssueInStoryIssueUseCase.run,
-      ).toHaveBeenCalledWith(
-        expect.objectContaining({
-          createTaskFromStoryBodyCheckboxEnabled: false,
-        }),
-      );
-    });
-
-    it('should pass createTaskFromStoryBodyCheckboxEnabled true to ConvertCheckboxToIssueInStoryIssueUseCase when the field is true', async () => {
-      const input = {
-        projectName: 'test-project',
-        org: 'test-org',
-        projectUrl: 'https://github.com/test-org/test-project',
-        manager: 'test-manager',
-        workingReport: {
-          repo: 'test-repo',
-          members: ['member1'],
-          spreadsheetUrl: 'https://docs.google.com/spreadsheets/test',
-        },
-        urlOfStoryView: 'https://github.com/test-org/test-project/issues',
-        disabled: false,
-        createTaskFromStoryBodyCheckboxEnabled: true,
-      };
-
-      await useCase.run(input);
-      expect(
-        mockConvertCheckboxToIssueInStoryIssueUseCase.run,
-      ).toHaveBeenCalledWith(
-        expect.objectContaining({
-          createTaskFromStoryBodyCheckboxEnabled: true,
-        }),
-      );
-    });
-
     it('should pass storyProgressCommentEnabled true to AnalyzeProblemByIssueUseCase when the field is absent', async () => {
       const input = {
         projectName: 'test-project',
@@ -1872,7 +1817,6 @@ describe('HandleScheduledEventUseCase', () => {
       mock<SetDependedIssueUrlForOpenTaskPRsUseCase>(),
       mock<StaleTaskPullRequestCloseUseCase>(),
       mock<CreateEstimationIssueUseCase>(),
-      mock<ConvertCheckboxToIssueInStoryIssueUseCase>(),
       mock<ChangeStatusByStoryColorUseCase>(),
       mock<SetNoStoryIssueToStoryUseCase>(),
       mock<CreateNewStoryByLabelUseCase>(),

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -15,7 +15,6 @@ import { ClearDependedIssueURLUseCase } from './ClearDependedIssueURLUseCase';
 import { SetDependedIssueUrlForOpenTaskPRsUseCase } from './SetDependedIssueUrlForOpenTaskPRsUseCase';
 import { StaleTaskPullRequestCloseUseCase } from './StaleTaskPullRequestCloseUseCase';
 import { CreateEstimationIssueUseCase } from './CreateEstimationIssueUseCase';
-import { ConvertCheckboxToIssueInStoryIssueUseCase } from './ConvertCheckboxToIssueInStoryIssueUseCase';
 import { ChangeStatusByStoryColorUseCase } from './ChangeStatusByStoryColorUseCase';
 import { SetNoStoryIssueToStoryUseCase } from './SetNoStoryIssueToStoryUseCase';
 import { CreateNewStoryByLabelUseCase } from './CreateNewStoryByLabelUseCase';
@@ -130,7 +129,6 @@ export class HandleScheduledEventUseCase {
     readonly setDependedIssueUrlForOpenTaskPRsUseCase: SetDependedIssueUrlForOpenTaskPRsUseCase,
     readonly staleTaskPullRequestCloseUseCase: StaleTaskPullRequestCloseUseCase,
     readonly createEstimationIssueUseCase: CreateEstimationIssueUseCase,
-    readonly convertCheckboxToIssueInStoryIssueUseCase: ConvertCheckboxToIssueInStoryIssueUseCase,
     readonly changeStatusByStoryColorUseCase: ChangeStatusByStoryColorUseCase,
     readonly setNoStoryIssueToStoryUseCase: SetNoStoryIssueToStoryUseCase,
     readonly createNewStoryByLabelUseCase: CreateNewStoryByLabelUseCase,
@@ -191,7 +189,6 @@ export class HandleScheduledEventUseCase {
     } | null;
     thresholdForAutoReject?: number;
     thresholdForDispatchLoop?: number;
-    createTaskFromStoryBodyCheckboxEnabled?: boolean;
     queryToAddProjectEnabled?: boolean;
     queryToAddProject?: string | null;
     storyProgressCommentEnabled?: boolean;
@@ -615,16 +612,6 @@ ${JSON.stringify(e)}
       urlOfStoryView: input.urlOfStoryView,
       storyObjectMap: storyObjectMap,
     });
-    await this.convertCheckboxToIssueInStoryIssueUseCase.run({
-      project,
-      issues,
-      cacheUsed,
-      urlOfStoryView: input.urlOfStoryView,
-      storyObjectMap: storyObjectMap,
-      manager: input.manager,
-      createTaskFromStoryBodyCheckboxEnabled:
-        input.createTaskFromStoryBodyCheckboxEnabled ?? false,
-    });
     await this.changeStatusByStoryColorUseCase.run({
       project,
       cacheUsed,

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

@@ -0,0 +1,197 @@
+import { mock } from 'jest-mock-extended';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { SubscriptionDisabledIssueUseCase } from './SubscriptionDisabledIssueUseCase';
+
+const ORG = 'test-org';
+const REPO = 'test-repo';
+
+const buildEntry = (name: string, subscriptionDisabled: boolean) => ({
+  name,
+  subscriptionDisabled,
+});
+
+describe('SubscriptionDisabledIssueUseCase', () => {
+  describe('when no tokens are disabled', () => {
+    it('does not create any issue or comment', async () => {
+      const mockIssueRepository = mock<IssueRepository>();
+
+      const useCase = new SubscriptionDisabledIssueUseCase(mockIssueRepository);
+
+      await useCase.run({
+        tokenEntries: [buildEntry('dev1', false), buildEntry('dev2', false)],
+        org: ORG,
+        repo: REPO,
+      });
+
+      expect(mockIssueRepository.searchIssue.mock.calls).toHaveLength(0);
+      expect(mockIssueRepository.createNewIssue.mock.calls).toHaveLength(0);
+      expect(mockIssueRepository.createCommentByUrl.mock.calls).toHaveLength(0);
+    });
+  });
+
+  describe('when a token is disabled and no open issue exists', () => {
+    it('creates a new issue naming the token by display name only', async () => {
+      const mockIssueRepository = mock<IssueRepository>();
+      mockIssueRepository.searchIssue.mockResolvedValue([]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(42);
+
+      const useCase = new SubscriptionDisabledIssueUseCase(mockIssueRepository);
+
+      await useCase.run({
+        tokenEntries: [buildEntry('dev3', true)],
+        org: ORG,
+        repo: REPO,
+      });
+
+      expect(mockIssueRepository.searchIssue.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.searchIssue.mock.calls[0][0]).toEqual({
+        owner: ORG,
+        repositoryName: REPO,
+        type: 'issue',
+        state: 'open',
+        title: 'Restore Claude subscription access for dev3',
+      });
+      expect(mockIssueRepository.createNewIssue.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.createNewIssue.mock.calls[0][0]).toBe(ORG);
+      expect(mockIssueRepository.createNewIssue.mock.calls[0][1]).toBe(REPO);
+      expect(mockIssueRepository.createNewIssue.mock.calls[0][2]).toBe(
+        'Restore Claude subscription access for dev3',
+      );
+      expect(mockIssueRepository.createNewIssue.mock.calls[0][3]).toContain(
+        'dev3',
+      );
+      expect(mockIssueRepository.createCommentByUrl.mock.calls).toHaveLength(0);
+    });
+
+    it('does not include the token value in the issue body', async () => {
+      const mockIssueRepository = mock<IssueRepository>();
+      mockIssueRepository.searchIssue.mockResolvedValue([]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(1);
+
+      const useCase = new SubscriptionDisabledIssueUseCase(mockIssueRepository);
+
+      const SECRET_TOKEN = 'sk-ant-secret-abc123';
+      await useCase.run({
+        tokenEntries: [{ name: 'dev3', subscriptionDisabled: true }],
+        org: ORG,
+        repo: REPO,
+      });
+
+      expect(mockIssueRepository.createNewIssue.mock.calls[0][3]).not.toContain(
+        SECRET_TOKEN,
+      );
+    });
+  });
+
+  describe('when a token is disabled and an open issue already exists', () => {
+    it('comments on the existing issue instead of creating a new one', async () => {
+      const mockIssueRepository = mock<IssueRepository>();
+      const existingIssueUrl =
+        'https://github.com/test-org/test-repo/issues/99';
+      mockIssueRepository.searchIssue.mockResolvedValue([
+        {
+          url: existingIssueUrl,
+          title: 'Restore Claude subscription access for dev3',
+          number: '99',
+        },
+      ]);
+
+      const useCase = new SubscriptionDisabledIssueUseCase(mockIssueRepository);
+
+      await useCase.run({
+        tokenEntries: [buildEntry('dev3', true)],
+        org: ORG,
+        repo: REPO,
+      });
+
+      expect(mockIssueRepository.createNewIssue.mock.calls).toHaveLength(0);
+      expect(mockIssueRepository.createCommentByUrl.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.createCommentByUrl.mock.calls[0][0]).toBe(
+        existingIssueUrl,
+      );
+      expect(mockIssueRepository.createCommentByUrl.mock.calls[0][1]).toContain(
+        'dev3',
+      );
+    });
+  });
+
+  describe('when multiple tokens have different states', () => {
+    it('only handles disabled tokens', async () => {
+      const mockIssueRepository = mock<IssueRepository>();
+      mockIssueRepository.searchIssue.mockResolvedValue([]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(1);
+
+      const useCase = new SubscriptionDisabledIssueUseCase(mockIssueRepository);
+
+      await useCase.run({
+        tokenEntries: [
+          buildEntry('dev1', false),
+          buildEntry('dev2', true),
+          buildEntry('dev3', false),
+          buildEntry('dev4', true),
+        ],
+        org: ORG,
+        repo: REPO,
+      });
+
+      expect(mockIssueRepository.searchIssue.mock.calls).toHaveLength(2);
+      expect(mockIssueRepository.createNewIssue.mock.calls).toHaveLength(2);
+      expect(mockIssueRepository.searchIssue.mock.calls[0][0]).toEqual(
+        expect.objectContaining({
+          title: 'Restore Claude subscription access for dev2',
+        }),
+      );
+      expect(mockIssueRepository.searchIssue.mock.calls[1][0]).toEqual(
+        expect.objectContaining({
+          title: 'Restore Claude subscription access for dev4',
+        }),
+      );
+    });
+  });
+
+  describe('when the token list is empty', () => {
+    it('does nothing', async () => {
+      const mockIssueRepository = mock<IssueRepository>();
+
+      const useCase = new SubscriptionDisabledIssueUseCase(mockIssueRepository);
+
+      await useCase.run({
+        tokenEntries: [],
+        org: ORG,
+        repo: REPO,
+      });
+
+      expect(mockIssueRepository.searchIssue.mock.calls).toHaveLength(0);
+      expect(mockIssueRepository.createNewIssue.mock.calls).toHaveLength(0);
+      expect(mockIssueRepository.createCommentByUrl.mock.calls).toHaveLength(0);
+    });
+  });
+
+  describe('when searchIssue returns issues but none with exact title match', () => {
+    it('creates a new issue when title does not exactly match', async () => {
+      const mockIssueRepository = mock<IssueRepository>();
+      mockIssueRepository.searchIssue.mockResolvedValue([
+        {
+          url: 'https://github.com/test-org/test-repo/issues/5',
+          title: 'Restore Claude subscription access for dev3-old',
+          number: '5',
+        },
+      ]);
+      mockIssueRepository.createNewIssue.mockResolvedValue(6);
+
+      const useCase = new SubscriptionDisabledIssueUseCase(mockIssueRepository);
+
+      await useCase.run({
+        tokenEntries: [buildEntry('dev3', true)],
+        org: ORG,
+        repo: REPO,
+      });
+
+      expect(mockIssueRepository.createNewIssue.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.createNewIssue.mock.calls[0][2]).toBe(
+        'Restore Claude subscription access for dev3',
+      );
+      expect(mockIssueRepository.createCommentByUrl.mock.calls).toHaveLength(0);
+    });
+  });
+});