github-issue-tower-defence-management 1.185.0 → 1.186.0

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.ts

@@ -9,7 +9,7 @@ import {
   PullRequestReviewCommentSide,
   PullRequestReviewInlineLocation,
 } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
-import { Project } from '../../../domain/entities/Project';
+import { FieldOption, Project } from '../../../domain/entities/Project';
 import { Issue } from '../../../domain/entities/Issue';
 import { SearchedIssue } from '../../../domain/entities/SearchedIssue';
 import { StoryObjectMap } from '../../../domain/entities/StoryObjectMap';
@@ -28,7 +28,10 @@ import {
   ProjectIssuesCacheRepository,
 } from '../ProjectIssuesCacheRepository';
 import { BaseGitHubRepository } from '../BaseGitHubRepository';
-import { fetchGithubGraphql } from '../githubGraphqlClient';
+import {
+  fetchGithubGraphql,
+  postGithubGraphqlJson,
+} from '../githubGraphqlClient';
 import { normalizeFieldName } from '../utils';
 import { LocalStorageRepository } from '../LocalStorageRepository';
 import { Member } from '../../../domain/entities/Member';
@@ -687,6 +690,7 @@ export class ApiV3CheerioRestIssueRepository
       closingIssueReferenceUrls: item.closingIssueReferenceUrls,
       agent,
       isRepoArchived: item.isRepoArchived,
+      stateReason: item.stateReason,
     };
   };
   private restoreIssuesFromCache = (rawIssues: unknown): Issue[] | null => {
@@ -723,12 +727,20 @@ export class ApiV3CheerioRestIssueRepository
             ? issue.closingIssueReferenceUrls
             : [];
 
+        const stateReason =
+          'stateReason' in issue &&
+          (issue.stateReason === 'COMPLETED' ||
+            issue.stateReason === 'NOT_PLANNED' ||
+            issue.stateReason === 'REOPENED')
+            ? issue.stateReason
+            : null;
         return {
           ...issue,
           nextActionDate: nextActionDate,
           completionDate50PercentConfidence: completionDate50PercentConfidence,
           createdAt: createdAt,
           closingIssueReferenceUrls: closingIssueReferenceUrls,
+          stateReason: stateReason,
         };
       });
 
@@ -1071,6 +1083,40 @@ export class ApiV3CheerioRestIssueRepository
       { singleSelectOptionId: storyOptionId },
     );
   };
+  updateStoryOptionColor = async (
+    project: Project & { story: NonNullable<Project['story']> },
+    storyOptionId: string,
+    newColor: FieldOption['color'],
+  ): Promise<void> => {
+    const mutation = `mutation UpdateStoryOptionColor($fieldId: ID!, $options: [ProjectV2SingleSelectFieldOptionInput!]!) {
+  updateProjectV2Field(input: {
+    fieldId: $fieldId
+    singleSelectOptions: $options
+  }) {
+    projectV2Field {
+      ... on ProjectV2SingleSelectField {
+        options { id name color description }
+      }
+    }
+  }
+}`;
+    const options = project.story.stories.map((opt) => ({
+      id: opt.id,
+      name: opt.name,
+      color: opt.id === storyOptionId ? newColor : opt.color,
+      description: opt.description,
+    }));
+    const response = await postGithubGraphqlJson<{
+      errors?: { message: string }[];
+    }>({
+      ghToken: this.ghToken,
+      query: mutation,
+      variables: { fieldId: project.story.fieldId, options },
+    });
+    if (response.errors && response.errors.length > 0) {
+      throw new Error(response.errors.map((e) => e.message).join('; '));
+    }
+  };
   clearProjectField = async (
     project: Project,
     fieldId: string,

package/src/adapter/repositories/issue/GraphqlProjectItemRepository.test.ts

@@ -781,6 +781,80 @@ describe('GraphqlProjectItemRepository', () => {
       );
       warnSpy.mockRestore();
     });
+
+    it('requests stateReason in the Issue content fragment of the GraphQL query', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost.mockReturnValueOnce(makePageResponse(false, 'cursor-1', 1));
+
+      await repository.fetchProjectItems('test-project-id');
+
+      const sentQuery = extractRequestedQueryFromMockCall(
+        mockPost.mock.calls[0],
+      );
+      expect(sentQuery).toContain('stateReason');
+    });
+
+    it('maps stateReason REOPENED from Issue content node to ProjectItem.stateReason', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            node: {
+              items: {
+                totalCount: 1,
+                pageInfo: {
+                  endCursor: 'cursor-1',
+                  startCursor: 'cursor-start',
+                  hasNextPage: false,
+                },
+                nodes: [
+                  {
+                    id: 'item-1',
+                    fieldValues: { nodes: [] },
+                    content: {
+                      repository: { nameWithOwner: 'owner/repo' },
+                      number: 1,
+                      title: 'Test Issue',
+                      state: 'OPEN',
+                      stateReason: 'REOPENED',
+                      url: 'https://github.com/owner/repo/issues/1',
+                      body: 'body',
+                      createdAt: '2024-01-01T00:00:00Z',
+                      labels: { nodes: [] },
+                      assignees: { nodes: [] },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        }),
+      );
+
+      const result = await repository.fetchProjectItems('test-project-id');
+
+      expect(result).toHaveLength(1);
+      expect(result[0].stateReason).toBe('REOPENED');
+    });
+
+    it('maps stateReason to null when the field is absent from the content node', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost.mockReturnValueOnce(makePageResponse(false, 'cursor-1', 1));
+
+      const result = await repository.fetchProjectItems('test-project-id');
+
+      expect(result).toHaveLength(1);
+      expect(result[0].stateReason).toBeNull();
+    });
   });
 
   const extractRequestedVariablesFromMockCall = (
@@ -1665,5 +1739,38 @@ describe('GraphqlProjectItemRepository', () => {
 
       warnSpy.mockRestore();
     });
+
+    it('maps stateReason from the single-item Issue response', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            repository: {
+              issue: {
+                ...makeContentNode(
+                  'https://github.com/owner/repo/issues/42',
+                  42,
+                  'Reopened Issue',
+                ),
+                stateReason: 'REOPENED',
+              },
+              pullRequest: null,
+            },
+          },
+        }),
+      );
+
+      const result = await repository.fetchProjectItemByUrl(
+        'https://github.com/owner/repo/issues/42',
+      );
+
+      expect(result).not.toBeNull();
+      expect(result?.stateReason).toBe('REOPENED');
+    });
   });
 });

package/src/adapter/repositories/issue/GraphqlProjectItemRepository.ts

@@ -18,6 +18,7 @@ export type ProjectItem = {
   author: string;
   closingIssueReferenceUrls: string[];
   isRepoArchived: boolean;
+  stateReason: 'COMPLETED' | 'NOT_PLANNED' | 'REOPENED' | null;
   customFields: {
     name: string;
     value: string | null;
@@ -51,6 +52,7 @@ type ProjectV2ItemContentNode = {
   labels: { nodes: { name: string }[] };
   assignees: { nodes: { login: string }[] };
   closingIssuesReferences?: { nodes: { url: string }[] };
+  stateReason?: string | null;
 };
 type ProjectV2ItemNode = {
   id: string;
@@ -121,6 +123,7 @@ const PROJECT_V2_ITEM_FIELD_VALUES_AND_CONTENT_SELECTION = `
               number
               title
               state
+              stateReason
               url
               body
               createdAt
@@ -186,6 +189,19 @@ export const RATE_LIMIT_MAX_BACKOFF_MS = 300000;
 const sleep = (ms: number): Promise<void> =>
   new Promise((resolve) => setTimeout(resolve, ms));
 
+const toStateReason = (
+  value: string | null | undefined,
+): 'COMPLETED' | 'NOT_PLANNED' | 'REOPENED' | null => {
+  if (
+    value === 'COMPLETED' ||
+    value === 'NOT_PLANNED' ||
+    value === 'REOPENED'
+  ) {
+    return value;
+  }
+  return null;
+};
+
 const parseNonNegativeIntegerHeader = (value: string | null): number | null => {
   if (value === null) {
     return null;
@@ -634,6 +650,7 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!, $query: Str
           ?.map((node) => node.url)
           .filter((url) => url.length > 0) || [],
       isRepoArchived: item.content.repository.isArchived ?? false,
+      stateReason: toStateReason(item.content.stateReason),
       customFields: item.fieldValues.nodes
         .filter((field) => !!field.field)
         .map((field) => {
@@ -1049,6 +1066,7 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       number
       title
       state
+      stateReason
       url
       body
       createdAt
@@ -1222,6 +1240,7 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       number: number;
       title: string;
       state: string;
+      stateReason?: string | null;
       url: string;
       body: string;
       createdAt: string;
@@ -1309,6 +1328,7 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
           ?.map((node) => node.url)
           .filter((url) => url.length > 0) || [],
       isRepoArchived: content.repository.isArchived ?? false,
+      stateReason: toStateReason(content.stateReason),
       customFields: item.fieldValues.nodes
         .filter((field) => !!field.field)
         .map((field) => {

package/src/adapter/repositories/issue/RestIssueRepository.test.ts

@@ -52,6 +52,7 @@ const buildIssue = (overrides: Partial<Issue> = {}): Issue => ({
   author: '',
   closingIssueReferenceUrls: [],
   agent: null,
+  stateReason: null,
   ...overrides,
 });
 

package/src/domain/entities/ClaudeHandoverSession.ts

@@ -8,4 +8,5 @@ export type ClaudeHandoverSession = {
   sessionName: string | null;
   name: string | null;
   issueUrl: string | null;
+  runsUnderWorkspacePreparationScript: boolean;
 };

package/src/domain/entities/Issue.ts

@@ -27,4 +27,5 @@ export type Issue = {
   closingIssueReferenceUrls: string[];
   agent: string | null;
   isRepoArchived?: boolean;
+  stateReason: 'COMPLETED' | 'NOT_PLANNED' | 'REOPENED' | null;
 };

package/src/domain/entities/Project.ts

@@ -1,9 +1,18 @@
+export const FIELD_OPTION_COLORS = [
+  'GRAY',
+  'BLUE',
+  'GREEN',
+  'YELLOW',
+  'ORANGE',
+  'RED',
+  'PINK',
+  'PURPLE',
+] as const;
 export type StoryOption = FieldOption;
 export type FieldOption = {
   id: string;
   name: string;
-  color:
-    'GRAY' | 'BLUE' | 'GREEN' | 'YELLOW' | 'ORANGE' | 'RED' | 'PINK' | 'PURPLE';
+  color: (typeof FIELD_OPTION_COLORS)[number];
   description: string;
 };
 

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

@@ -28,6 +28,7 @@ const createIssue = (overrides: Partial<Issue> = {}): Issue => ({
   author: 'author',
   closingIssueReferenceUrls: [],
   agent: null,
+  stateReason: null,
   ...overrides,
 });
 

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

@@ -29,6 +29,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   author: 'test-user',
   closingIssueReferenceUrls: [],
   agent: null,
+  stateReason: null,
   ...overrides,
 });
 

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

@@ -70,6 +70,7 @@ describe('GetStoryObjectMapUseCase', () => {
     author: '',
     closingIssueReferenceUrls: [],
     agent: null,
+    stateReason: null,
     ...overrides,
   });
 

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

@@ -21,6 +21,7 @@ import { SetNoStoryIssueToStoryUseCase } from './SetNoStoryIssueToStoryUseCase';
 import { CreateNewStoryByLabelUseCase } from './CreateNewStoryByLabelUseCase';
 import { AssignNoAssigneeIssueToManagerUseCase } from './AssignNoAssigneeIssueToManagerUseCase';
 import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCase';
+import { IssueNoStatusUpdateUseCase } from './IssueNoStatusUpdateUseCase';
 import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
@@ -31,6 +32,7 @@ import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCa
 import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
 import { DailySecurityScanUseCase } from './DailySecurityScanUseCase';
 import { QualityCheckAdvanceUseCase } from './QualityCheckAdvanceUseCase';
+import { ReopenedDoneIssueRevertUseCase } from './ReopenedDoneIssueRevertUseCase';
 
 describe('HandleScheduledEventUseCase', () => {
   describe('createTargetDateTimes', () => {
@@ -121,6 +123,7 @@ describe('HandleScheduledEventUseCase', () => {
       mock<AssignNoAssigneeIssueToManagerUseCase>();
     const mockUpdateIssueStatusByLabelUseCase =
       mock<UpdateIssueStatusByLabelUseCase>();
+    const mockIssueNoStatusUpdateUseCase = mock<IssueNoStatusUpdateUseCase>();
     const mockStartPreparationUseCase = mock<StartPreparationUseCase>();
     const mockRevertOrphanedPreparationUseCase =
       mock<RevertOrphanedPreparationUseCase>();
@@ -133,6 +136,8 @@ describe('HandleScheduledEventUseCase', () => {
     const mockUpdateRateLimitCacheUseCase = mock<UpdateRateLimitCacheUseCase>();
     const mockDailySecurityScanUseCase = mock<DailySecurityScanUseCase>();
     const mockAdvanceQualityCheckUseCase = mock<QualityCheckAdvanceUseCase>();
+    const mockReopenedDoneIssueRevertUseCase =
+      mock<ReopenedDoneIssueRevertUseCase>();
     const mockDateRepository = mock<DateRepository>();
     const mockSpreadsheetRepository = mock<SpreadsheetRepository>();
     const mockProjectRepository = mock<ProjectRepository>();
@@ -156,6 +161,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockCreateNewStoryByLabelUseCase,
       mockAssignNoAssigneeIssueToManagerUseCase,
       mockUpdateIssueStatusByLabelUseCase,
+      mockIssueNoStatusUpdateUseCase,
       mockStartPreparationUseCase,
       mockRevertOrphanedPreparationUseCase,
       mockRevertNotReadyReviewQueueIssueUseCase,
@@ -164,6 +170,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockUpdateRateLimitCacheUseCase,
       mockDailySecurityScanUseCase,
       mockAdvanceQualityCheckUseCase,
+      mockReopenedDoneIssueRevertUseCase,
       mockDateRepository,
       mockSpreadsheetRepository,
       mockProjectRepository,
@@ -240,6 +247,41 @@ describe('HandleScheduledEventUseCase', () => {
       });
     });
 
+    it('should call IssueNoStatusUpdateUseCase with project and issues when startPreparation is configured', 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,
+        startPreparation: {
+          defaultAgentName: 'agent1',
+          configFilePath: '/path/to/config.yml',
+          maximumPreparingIssuesCount: null,
+        },
+      };
+
+      const mockProject = mock<Project>();
+      const mockIssues = [mock<Issue>()];
+      mockIssueRepository.getAllIssues.mockResolvedValue({
+        issues: mockIssues,
+        project: mockProject,
+        cacheUsed: false,
+      });
+      await useCase.run(input);
+
+      expect(mockIssueNoStatusUpdateUseCase.run).toHaveBeenCalledWith({
+        project: mockProject,
+        issues: mockIssues,
+      });
+    });
+
     it('should call TriagerApprovalDispatchUseCase with project URL', async () => {
       const input = {
         projectName: 'test-project',
@@ -1616,6 +1658,105 @@ describe('HandleScheduledEventUseCase', () => {
         expect(mockStartPreparationUseCase.run).toHaveBeenCalled();
       });
     });
+
+    describe('reopenedDoneIssueRevertUseCase', () => {
+      const baseInput = {
+        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,
+      };
+
+      it('does not call reopenedDoneIssueRevertUseCase when startPreparation is absent', async () => {
+        await useCase.run(baseInput);
+
+        expect(mockReopenedDoneIssueRevertUseCase.run).not.toHaveBeenCalled();
+      });
+
+      it('does not call reopenedDoneIssueRevertUseCase when autoRevertReopenedDoneEnabled is absent', async () => {
+        await useCase.run({
+          ...baseInput,
+          startPreparation: {
+            defaultAgentName: 'agent1',
+            configFilePath: '/path/to/config.yml',
+            maximumPreparingIssuesCount: null,
+            autoAdvanceQualityCheckEnabled: false,
+          },
+        });
+
+        expect(mockReopenedDoneIssueRevertUseCase.run).not.toHaveBeenCalled();
+      });
+
+      it('does not call reopenedDoneIssueRevertUseCase when autoRevertReopenedDoneEnabled is false', async () => {
+        await useCase.run({
+          ...baseInput,
+          startPreparation: {
+            defaultAgentName: 'agent1',
+            configFilePath: '/path/to/config.yml',
+            maximumPreparingIssuesCount: null,
+            autoAdvanceQualityCheckEnabled: false,
+            autoRevertReopenedDoneEnabled: false,
+          },
+        });
+
+        expect(mockReopenedDoneIssueRevertUseCase.run).not.toHaveBeenCalled();
+      });
+
+      it('calls reopenedDoneIssueRevertUseCase with project and issues when autoRevertReopenedDoneEnabled is true', async () => {
+        const mockProject = mock<Project>();
+        const mockIssues: Issue[] = [];
+        mockIssueRepository.getAllIssues.mockResolvedValue({
+          issues: mockIssues,
+          project: mockProject,
+          cacheUsed: false,
+        });
+
+        await useCase.run({
+          ...baseInput,
+          startPreparation: {
+            defaultAgentName: 'agent1',
+            configFilePath: '/path/to/config.yml',
+            maximumPreparingIssuesCount: null,
+            autoAdvanceQualityCheckEnabled: false,
+            autoRevertReopenedDoneEnabled: true,
+          },
+        });
+
+        expect(mockReopenedDoneIssueRevertUseCase.run).toHaveBeenCalledWith({
+          project: mockProject,
+          issues: mockIssues,
+        });
+      });
+
+      it('continues to startPreparationUseCase when reopenedDoneIssueRevertUseCase.run rejects', async () => {
+        mockReopenedDoneIssueRevertUseCase.run.mockRejectedValue(
+          new AggregateError(
+            [new Error('GitHub API error')],
+            'Failed to revert 1 reopened Done issue(s)',
+          ),
+        );
+
+        await useCase.run({
+          ...baseInput,
+          startPreparation: {
+            defaultAgentName: 'agent1',
+            configFilePath: '/path/to/config.yml',
+            maximumPreparingIssuesCount: null,
+            autoAdvanceQualityCheckEnabled: false,
+            autoRevertReopenedDoneEnabled: true,
+          },
+        });
+
+        expect(mockStartPreparationUseCase.run).toHaveBeenCalled();
+      });
+    });
   });
 
   describe('storyIssues', () => {
@@ -1637,6 +1778,7 @@ describe('HandleScheduledEventUseCase', () => {
       mock<CreateNewStoryByLabelUseCase>(),
       mock<AssignNoAssigneeIssueToManagerUseCase>(),
       mock<UpdateIssueStatusByLabelUseCase>(),
+      mock<IssueNoStatusUpdateUseCase>(),
       mock<StartPreparationUseCase>(),
       mock<RevertOrphanedPreparationUseCase>(),
       mock<RevertNotReadyReviewQueueIssueUseCase>(),
@@ -1645,6 +1787,7 @@ describe('HandleScheduledEventUseCase', () => {
       null,
       null,
       mock<QualityCheckAdvanceUseCase>(),
+      mock<ReopenedDoneIssueRevertUseCase>(),
       mock<DateRepository>(),
       mock<SpreadsheetRepository>(),
       mock<ProjectRepository>(),
@@ -1701,6 +1844,7 @@ describe('HandleScheduledEventUseCase', () => {
       author: '',
       closingIssueReferenceUrls: [],
       agent: null,
+      stateReason: null,
     };
 
     it('should return storyIssue as null when the only matching issue is closed', async () => {

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -21,6 +21,7 @@ import { SetNoStoryIssueToStoryUseCase } from './SetNoStoryIssueToStoryUseCase';
 import { CreateNewStoryByLabelUseCase } from './CreateNewStoryByLabelUseCase';
 import { AssignNoAssigneeIssueToManagerUseCase } from './AssignNoAssigneeIssueToManagerUseCase';
 import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCase';
+import { IssueNoStatusUpdateUseCase } from './IssueNoStatusUpdateUseCase';
 import {
   RotationOrderEntry,
   StartPreparationUseCase,
@@ -40,6 +41,7 @@ import {
   DailySecurityScanUseCase,
 } from './DailySecurityScanUseCase';
 import { QualityCheckAdvanceUseCase } from './QualityCheckAdvanceUseCase';
+import { ReopenedDoneIssueRevertUseCase } from './ReopenedDoneIssueRevertUseCase';
 
 export class ProjectNotFoundError extends Error {
   constructor(message: string) {
@@ -133,6 +135,7 @@ export class HandleScheduledEventUseCase {
     readonly createNewStoryByLabelUseCase: CreateNewStoryByLabelUseCase,
     readonly assignNoAssigneeIssueToManagerUseCase: AssignNoAssigneeIssueToManagerUseCase,
     readonly updateIssueStatusByLabelUseCase: UpdateIssueStatusByLabelUseCase,
+    readonly issueNoStatusUpdateUseCase: IssueNoStatusUpdateUseCase,
     readonly startPreparationUseCase: StartPreparationUseCase,
     readonly revertOrphanedPreparationUseCase: RevertOrphanedPreparationUseCase,
     readonly revertNotReadyReviewQueueIssueUseCase: RevertNotReadyReviewQueueIssueUseCase,
@@ -141,6 +144,7 @@ export class HandleScheduledEventUseCase {
     readonly updateRateLimitCacheUseCase: UpdateRateLimitCacheUseCase | null,
     readonly dailySecurityScanUseCase: DailySecurityScanUseCase | null,
     readonly qualityCheckAdvanceUseCase: QualityCheckAdvanceUseCase,
+    readonly reopenedDoneIssueRevertUseCase: ReopenedDoneIssueRevertUseCase,
     readonly dateRepository: DateRepository,
     readonly spreadsheetRepository: SpreadsheetRepository,
     readonly projectRepository: ProjectRepository,
@@ -180,6 +184,7 @@ export class HandleScheduledEventUseCase {
       awLogStaleThresholdMinutes?: number;
       awaitingQualityCheckStatus?: string | null;
       autoAdvanceQualityCheckEnabled?: boolean;
+      autoRevertReopenedDoneEnabled?: boolean;
       labelsAsLlmAgentName?: string[] | null;
     } | null;
     thresholdForAutoReject?: number;
@@ -473,6 +478,16 @@ ${JSON.stringify(e)}
           allowedIssueAuthors,
         });
       }
+      if (input.startPreparation.autoRevertReopenedDoneEnabled) {
+        try {
+          await this.reopenedDoneIssueRevertUseCase.run({ project, issues });
+        } catch (revertError) {
+          console.error(
+            `[HandleScheduledEvent] Failed to revert reopened Done issues for project ${project.url}: ${revertError instanceof Error ? revertError.message : String(revertError)}`,
+            revertError,
+          );
+        }
+      }
       if (input.startPreparation.autoAdvanceQualityCheckEnabled) {
         try {
           await this.qualityCheckAdvanceUseCase.run({
@@ -489,6 +504,7 @@ ${JSON.stringify(e)}
           );
         }
       }
+      await this.issueNoStatusUpdateUseCase.run({ project, issues });
       const preparationResult = await this.startPreparationUseCase.run({
         projectUrl: input.projectUrl,
         defaultAgentName: input.startPreparation.defaultAgentName,

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

@@ -52,6 +52,7 @@ const issue = (url: string, status: string): Issue => ({
   author: 'hiromi',
   closingIssueReferenceUrls: [],
   agent: null,
+  stateReason: null,
 });
 
 describe('InTmuxByHumanSessionTokenCountUseCase', () => {