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

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/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', () => {

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

@@ -0,0 +1,165 @@
+import { mock } from 'jest-mock-extended';
+import { IssueNoStatusUpdateUseCase } from './IssueNoStatusUpdateUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Issue } from '../entities/Issue';
+import { FieldOption, Project } from '../entities/Project';
+
+describe('IssueNoStatusUpdateUseCase', () => {
+  const mockIssueRepository = mock<IssueRepository>();
+
+  const awaitingWorkspaceStatus = mock<FieldOption>();
+  awaitingWorkspaceStatus.id = 'status-awaiting';
+  awaitingWorkspaceStatus.name = 'Awaiting Workspace';
+
+  const inProgressStatus = mock<FieldOption>();
+  inProgressStatus.id = 'status-in-progress';
+  inProgressStatus.name = 'In Progress';
+
+  const basicProject: Project = {
+    ...mock<Project>(),
+    status: {
+      name: 'Status',
+      fieldId: 'statusFieldId',
+      statuses: [awaitingWorkspaceStatus, inProgressStatus],
+    },
+  };
+
+  const projectWithoutAwaitingWorkspace: Project = {
+    ...mock<Project>(),
+    status: {
+      name: 'Status',
+      fieldId: 'statusFieldId',
+      statuses: [inProgressStatus],
+    },
+  };
+
+  const openNullStatusIssue: Issue = {
+    ...mock<Issue>(),
+    isClosed: false,
+    status: null,
+  };
+
+  const openInProgressIssue: Issue = {
+    ...mock<Issue>(),
+    isClosed: false,
+    status: 'In Progress',
+  };
+
+  const closedNullStatusIssue: Issue = {
+    ...mock<Issue>(),
+    isClosed: true,
+    status: null,
+  };
+
+  let useCase: IssueNoStatusUpdateUseCase;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useCase = new IssueNoStatusUpdateUseCase(mockIssueRepository);
+  });
+
+  describe('run', () => {
+    const testCases: {
+      name: string;
+      project: Project;
+      issues: Issue[];
+      expectedUpdateStatusCalls: [Project, Issue, string][];
+    }[] = [
+      {
+        name: 'should call updateStatus for open issues with null status',
+        project: basicProject,
+        issues: [openNullStatusIssue],
+        expectedUpdateStatusCalls: [
+          [basicProject, openNullStatusIssue, 'status-awaiting'],
+        ],
+      },
+      {
+        name: 'should skip issues with an existing status',
+        project: basicProject,
+        issues: [openInProgressIssue],
+        expectedUpdateStatusCalls: [],
+      },
+      {
+        name: 'should skip closed issues with null status',
+        project: basicProject,
+        issues: [closedNullStatusIssue],
+        expectedUpdateStatusCalls: [],
+      },
+      {
+        name: 'should not call updateStatus when Awaiting Workspace status does not exist in project',
+        project: projectWithoutAwaitingWorkspace,
+        issues: [openNullStatusIssue],
+        expectedUpdateStatusCalls: [],
+      },
+      {
+        name: 'should handle empty issues array',
+        project: basicProject,
+        issues: [],
+        expectedUpdateStatusCalls: [],
+      },
+      {
+        name: 'should call updateStatus only for open null-status issues among mixed issues',
+        project: basicProject,
+        issues: [
+          openNullStatusIssue,
+          openInProgressIssue,
+          closedNullStatusIssue,
+        ],
+        expectedUpdateStatusCalls: [
+          [basicProject, openNullStatusIssue, 'status-awaiting'],
+        ],
+      },
+    ];
+
+    testCases.forEach(
+      ({ name, project, issues, expectedUpdateStatusCalls }) => {
+        it(name, async () => {
+          await useCase.run({ project, issues });
+
+          expect(mockIssueRepository.updateStatus.mock.calls).toEqual(
+            expectedUpdateStatusCalls,
+          );
+        });
+      },
+    );
+
+    it('should skip archived items and continue updating remaining issues', async () => {
+      const archivedIssue: Issue = {
+        ...mock<Issue>(),
+        isClosed: false,
+        status: null,
+      };
+      const normalIssue: Issue = {
+        ...mock<Issue>(),
+        isClosed: false,
+        status: null,
+      };
+
+      mockIssueRepository.updateStatus
+        .mockRejectedValueOnce(
+          new Error('The item is archived and cannot be updated'),
+        )
+        .mockResolvedValueOnce(undefined);
+
+      await useCase.run({
+        project: basicProject,
+        issues: [archivedIssue, normalIssue],
+      });
+
+      expect(mockIssueRepository.updateStatus.mock.calls).toEqual([
+        [basicProject, archivedIssue, 'status-awaiting'],
+        [basicProject, normalIssue, 'status-awaiting'],
+      ]);
+    });
+
+    it('should re-throw non-archived errors from updateStatus', async () => {
+      mockIssueRepository.updateStatus.mockRejectedValueOnce(
+        new Error('GraphQL rate limit exceeded'),
+      );
+
+      await expect(
+        useCase.run({ project: basicProject, issues: [openNullStatusIssue] }),
+      ).rejects.toThrow('GraphQL rate limit exceeded');
+    });
+  });
+});

package/src/domain/usecases/IssueNoStatusUpdateUseCase.ts

@@ -0,0 +1,44 @@
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+import { AWAITING_WORKSPACE_STATUS_NAME } from '../entities/WorkflowStatus';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+
+const isArchivedProjectItemError = (error: unknown): boolean => {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.toLowerCase().includes('archived');
+};
+
+export class IssueNoStatusUpdateUseCase {
+  constructor(
+    readonly issueRepository: Pick<IssueRepository, 'updateStatus'>,
+  ) {}
+
+  run = async (input: { project: Project; issues: Issue[] }): Promise<void> => {
+    const awaitingWorkspaceStatus = input.project.status.statuses.find(
+      (s) => s.name === AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    if (!awaitingWorkspaceStatus) {
+      return;
+    }
+    for (const issue of input.issues) {
+      if (issue.isClosed || issue.status !== null) {
+        continue;
+      }
+      try {
+        await this.issueRepository.updateStatus(
+          input.project,
+          issue,
+          awaitingWorkspaceStatus.id,
+        );
+      } catch (error) {
+        if (isArchivedProjectItemError(error)) {
+          console.warn(
+            `IssueNoStatusUpdateUseCase: project item is archived and cannot be updated, skipping. issueUrl: ${issue.url}`,
+          );
+          continue;
+        }
+        throw error;
+      }
+    }
+  };
+}