github-issue-tower-defence-management 2.4.0 → 2.5.1

package/src/adapter/entry-points/console/ui-dist/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-C5cOzhyn.js"></script>
+    <script type="module" crossorigin src="/assets/index-CaxYBHiT.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CLHvrafO.css">
   </head>
   <body>

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(() => ({})),
 }));

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';
@@ -59,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';
@@ -463,8 +463,6 @@ export class HandleScheduledEventUseCaseHandler {
       issueRepository,
       systemDateRepository,
     );
-    const convertCheckboxToIssueInStoryIssueUseCase =
-      new ConvertCheckboxToIssueInStoryIssueUseCase(issueRepository);
     const changeStatusByStoryColorUseCase = new ChangeStatusByStoryColorUseCase(
       systemDateRepository,
       issueRepository,
@@ -560,7 +558,6 @@ export class HandleScheduledEventUseCaseHandler {
       setDependedIssueUrlForOpenTaskPRsUseCase,
       staleTaskPullRequestCloseUseCase,
       createEstimationIssueUseCase,
-      convertCheckboxToIssueInStoryIssueUseCase,
       changeStatusByStoryColorUseCase,
       setNoStoryIssueToStoryUseCase,
       createNewStoryByLabel,
@@ -694,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);
+    });
+  });
+});

package/src/domain/usecases/SubscriptionDisabledIssueUseCase.ts

@@ -0,0 +1,74 @@
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+
+export type SubscriptionDisabledTokenEntry = {
+  name: string;
+  subscriptionDisabled: boolean;
+};
+
+export class SubscriptionDisabledIssueUseCase {
+  constructor(
+    private readonly issueRepository: Pick<
+      IssueRepository,
+      'searchIssue' | 'createNewIssue' | 'createCommentByUrl'
+    >,
+  ) {}
+
+  run = async (input: {
+    tokenEntries: SubscriptionDisabledTokenEntry[];
+    org: string;
+    repo: string;
+  }): Promise<void> => {
+    for (const entry of input.tokenEntries) {
+      if (!entry.subscriptionDisabled) {
+        continue;
+      }
+      try {
+        await this.handleDisabledToken(entry.name, input.org, input.repo);
+      } catch (error) {
+        console.error(
+          `SubscriptionDisabledIssue: error handling token ${entry.name}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+  };
+
+  private handleDisabledToken = async (
+    tokenName: string,
+    org: string,
+    repo: string,
+  ): Promise<void> => {
+    const issueTitle = `Restore Claude subscription access for ${tokenName}`;
+    const existingIssues = await this.issueRepository.searchIssue({
+      owner: org,
+      repositoryName: repo,
+      type: 'issue',
+      state: 'open',
+      title: issueTitle,
+    });
+    const existingIssue = existingIssues.find(
+      (issue) => issue.title === issueTitle,
+    );
+
+    if (existingIssue) {
+      await this.issueRepository.createCommentByUrl(
+        existingIssue.url,
+        `The Claude subscription access for the token displayed as \`${tokenName}\` remains disabled. Please restore the account's Claude Code subscription access.`,
+      );
+      console.log(
+        `SubscriptionDisabledIssue: commented on existing issue for token ${tokenName}: ${existingIssue.url}`,
+      );
+    } else {
+      const issueNumber = await this.issueRepository.createNewIssue(
+        org,
+        repo,
+        issueTitle,
+        `The Claude subscription access for the token displayed as \`${tokenName}\` has been disabled.\n\nPlease restore the account's Claude Code subscription access to resume operations.`,
+        [],
+        [],
+      );
+      console.log(
+        `SubscriptionDisabledIssue: created issue #${issueNumber} for token ${tokenName}`,
+      );
+    }
+  };
+}

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

@@ -964,5 +964,88 @@ describe('TriagerApprovalDispatchUseCase', () => {
       expect(mockIssueRepository.updateStory.mock.calls).toEqual([]);
       expect(mockIssueRepository.setIssueAgentField.mock.calls).toHaveLength(1);
     });
+
+    it('should not dispatch again when TRIAGER_PROPOSAL_APPROVED was already posted after the approval', async () => {
+      const issue = createMockIssue({
+        status: 'Awaiting Workspace',
+        author: 'owner-user',
+        agent: null,
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue],
+        cacheUsed: false,
+      });
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createComment(
+          'bot',
+          TRIAGER_PROPOSAL_COMMENT(
+            'developer',
+            'regular / workflow improvement',
+            false,
+          ),
+        ),
+        createComment('owner-user', 'ok'),
+        createComment(
+          'bot',
+          'Auto Status Check: TRIAGER_PROPOSAL_APPROVED\nAgent: developer\nStory: regular / workflow improvement',
+        ),
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/orgs/owner/projects/1',
+        allowedIssueAuthors: ['owner-user'],
+      });
+
+      expect(mockIssueRepository.updateStatus.mock.calls).toEqual([]);
+      expect(mockIssueRepository.setIssueAgentField.mock.calls).toEqual([]);
+      expect(mockIssueCommentRepository.createComment.mock.calls).toEqual([]);
+    });
+
+    it('should dispatch again when the issue returns to AW after the agent ran and TRIAGER_PROPOSAL_APPROVED was posted without a subsequent new proposal+approval', async () => {
+      const issue = createMockIssue({
+        status: 'Awaiting Workspace',
+        author: 'owner-user',
+        agent: null,
+      });
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        project: mockProject,
+        issues: [issue],
+        cacheUsed: false,
+      });
+      // second proposal after TRIAGER_PROPOSAL_APPROVED, with a new owner approval
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createComment(
+          'bot',
+          TRIAGER_PROPOSAL_COMMENT(
+            'developer',
+            'regular / workflow improvement',
+            false,
+          ),
+        ),
+        createComment('owner-user', 'ok'),
+        createComment(
+          'bot',
+          'Auto Status Check: TRIAGER_PROPOSAL_APPROVED\nAgent: developer\nStory: regular / workflow improvement',
+        ),
+        createComment(
+          'bot',
+          TRIAGER_PROPOSAL_COMMENT(
+            'developer',
+            'regular / workflow improvement',
+            true,
+          ),
+        ),
+        createComment('owner-user', 'ok'),
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/orgs/owner/projects/1',
+        allowedIssueAuthors: ['owner-user'],
+      });
+
+      expect(mockIssueRepository.updateStatus.mock.calls).toHaveLength(1);
+      expect(mockIssueRepository.setIssueAgentField.mock.calls).toHaveLength(1);
+    });
   });
 });

package/src/domain/usecases/TriagerApprovalDispatchUseCase.ts

@@ -197,7 +197,7 @@ export class TriagerApprovalDispatchUseCase {
         continue;
       }
 
-      let approved = false;
+      let approvalIndex = -1;
       for (let i = firstProposalIndex + 1; i < comments.length; i++) {
         const comment = comments[i];
         if (
@@ -207,12 +207,20 @@ export class TriagerApprovalDispatchUseCase {
             allowedIssueAuthors ?? [],
           )
         ) {
-          approved = true;
-          break;
+          approvalIndex = i;
         }
       }
 
-      if (!approved) {
+      if (approvalIndex === -1) {
+        continue;
+      }
+
+      const alreadyDispatched = comments
+        .slice(approvalIndex + 1)
+        .some((c) =>
+          c.content.startsWith('Auto Status Check: TRIAGER_PROPOSAL_APPROVED'),
+        );
+      if (alreadyDispatched) {
         continue;
       }
 

package/types/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAqDA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AA2D3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,EACjB,6BAA4B,MAAM,EAAE,GAAG,IAAW,KACjD,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CA40BP;CACH"}
+{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAsDA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AA0D3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,EACjB,6BAA4B,MAAM,EAAE,GAAG,IAAW,KACjD,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CAy1BP;CACH"}