github-issue-tower-defence-management 1.175.1 → 1.177.0

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-BhDothvr.js"></script>
+    <script type="module" crossorigin src="/assets/index-D6aAQrf7.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Bh2slMtk.css">
   </head>
   <body>

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

@@ -297,6 +297,8 @@ export class HandleScheduledEventUseCaseHandler {
         input.claudeCodeOauthTokenListJsonPath,
       thresholdForAutoReject:
         readmeConfig.thresholdForAutoReject ?? input.thresholdForAutoReject,
+      developerAgentName:
+        readmeConfig.developerAgentName ?? input.developerAgentName ?? null,
       startPreparation: input.startPreparation
         ? {
             ...input.startPreparation,

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

@@ -72,6 +72,7 @@ const buildProjectItem = (url: string, title: string): ProjectItem => ({
   updatedAt: '2026-07-06T00:00:00.000Z',
   author: '',
   closingIssueReferenceUrls: [],
+  isRepoArchived: false,
   customFields: [],
 });
 
@@ -116,6 +117,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
             closingIssueReferenceUrls: [
               'https://github.com/HiromiShikata/test-repository/issues/7',
             ],
+            isRepoArchived: false,
             customFields: [
               { name: 'nextActionDate', value: '2000-01-01' },
               { name: 'nextActionHour', value: '1' },
@@ -153,6 +155,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
             'https://github.com/HiromiShikata/test-repository/issues/7',
           ],
           agent: null,
+          isRepoArchived: false,
         },
       },
       {
@@ -172,6 +175,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
             updatedAt: '2024-01-02T00:00:00Z',
             author: '',
             closingIssueReferenceUrls: [],
+            isRepoArchived: false,
             customFields: [
               {
                 name: 'DependedIssueUrls',
@@ -210,6 +214,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
           author: '',
           closingIssueReferenceUrls: [],
           agent: null,
+          isRepoArchived: false,
         },
       },
     ];

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

@@ -686,6 +686,7 @@ export class ApiV3CheerioRestIssueRepository
       author: item.author,
       closingIssueReferenceUrls: item.closingIssueReferenceUrls,
       agent,
+      isRepoArchived: item.isRepoArchived,
     };
   };
   private restoreIssuesFromCache = (rawIssues: unknown): Issue[] | null => {

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

@@ -17,6 +17,7 @@ export type ProjectItem = {
   updatedAt: string;
   author: string;
   closingIssueReferenceUrls: string[];
+  isRepoArchived: boolean;
   customFields: {
     name: string;
     value: string | null;
@@ -38,7 +39,7 @@ type ProjectV2ItemFieldValueNode = {
   };
 };
 type ProjectV2ItemContentNode = {
-  repository: { nameWithOwner: string };
+  repository: { nameWithOwner: string; isArchived: boolean };
   number: number;
   title: string;
   state: string;
@@ -139,6 +140,7 @@ const PROJECT_V2_ITEM_FIELD_VALUES_AND_CONTENT_SELECTION = `
               }
               repository {
                 nameWithOwner
+                isArchived
               }
             }
             ... on PullRequest {
@@ -163,6 +165,7 @@ const PROJECT_V2_ITEM_FIELD_VALUES_AND_CONTENT_SELECTION = `
               }
               repository {
                 nameWithOwner
+                isArchived
               }
               closingIssuesReferences(first: 50) {
                 nodes {
@@ -393,7 +396,7 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!, $query: Str
               }[];
             };
             content: {
-              repository: { nameWithOwner: string };
+              repository: { nameWithOwner: string; isArchived: boolean };
               number: number;
               title: string;
               state: string;
@@ -443,7 +446,7 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!, $query: Str
                     }[];
                   };
                   content: {
-                    repository: { nameWithOwner: string };
+                    repository: { nameWithOwner: string; isArchived: boolean };
                     number: number;
                     title: string;
                     state: string;
@@ -506,7 +509,7 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!, $query: Str
               }[];
             };
             content: {
-              repository: { nameWithOwner: string };
+              repository: { nameWithOwner: string; isArchived: boolean };
               number: number;
               title: string;
               state: string;
@@ -630,6 +633,7 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!, $query: Str
         item.content.closingIssuesReferences?.nodes
           ?.map((node) => node.url)
           .filter((url) => url.length > 0) || [],
+      isRepoArchived: item.content.repository.isArchived ?? false,
       customFields: item.fieldValues.nodes
         .filter((field) => !!field.field)
         .map((field) => {
@@ -1064,6 +1068,7 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       }
       repository {
         nameWithOwner
+        isArchived
       }
       projectItems(first: 10) {
         nodes {
@@ -1142,6 +1147,7 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       }
       repository {
         nameWithOwner
+        isArchived
       }
       closingIssuesReferences(first: 50) {
         nodes {
@@ -1223,7 +1229,7 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       author: { login: string } | null;
       labels: { nodes: { name: string }[] };
       assignees: { nodes: { login: string }[] };
-      repository: { nameWithOwner: string };
+      repository: { nameWithOwner: string; isArchived: boolean };
       closingIssuesReferences?: { nodes: { url: string }[] };
       projectItems: {
         nodes: {
@@ -1302,6 +1308,7 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
         content.closingIssuesReferences?.nodes
           ?.map((node) => node.url)
           .filter((url) => url.length > 0) || [],
+      isRepoArchived: content.repository.isArchived ?? false,
       customFields: item.fieldValues.nodes
         .filter((field) => !!field.field)
         .map((field) => {

package/src/domain/entities/Issue.ts

@@ -26,4 +26,5 @@ export type Issue = {
   author: string;
   closingIssueReferenceUrls: string[];
   agent: string | null;
+  isRepoArchived?: boolean;
 };

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

@@ -507,6 +507,55 @@ describe('AssignNoAssigneeIssueToManagerUseCase', () => {
       });
     });
 
+    it('should skip issues in archived repositories', async () => {
+      const archivedIssue = {
+        ...basicIssue,
+        isRepoArchived: true,
+      };
+
+      await useCase.run({
+        issues: [archivedIssue],
+        manager: 'manager1',
+        cacheUsed: false,
+      });
+
+      expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([]);
+    });
+
+    it('should assign manager to issues in non-archived repositories', async () => {
+      const nonArchivedIssue = {
+        ...basicIssue,
+        isRepoArchived: false,
+      };
+
+      await useCase.run({
+        issues: [nonArchivedIssue],
+        manager: 'manager1',
+        cacheUsed: false,
+      });
+
+      expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([
+        [nonArchivedIssue, ['manager1']],
+      ]);
+    });
+
+    it('should assign manager to issues where isRepoArchived is undefined', async () => {
+      const issueWithoutArchivedFlag = {
+        ...basicIssue,
+        isRepoArchived: undefined,
+      };
+
+      await useCase.run({
+        issues: [issueWithoutArchivedFlag],
+        manager: 'manager1',
+        cacheUsed: false,
+      });
+
+      expect(mockIssueRepository.updateAssigneeList.mock.calls).toEqual([
+        [issueWithoutArchivedFlag, ['manager1']],
+      ]);
+    });
+
     it('should rethrow non-Error thrown values without logging', async () => {
       const failingIssue = {
         ...basicIssue,

package/src/domain/usecases/AssignNoAssigneeIssueToManagerUseCase.ts

@@ -30,7 +30,11 @@ export class AssignNoAssigneeIssueToManagerUseCase {
       assignees: Member['name'][];
       state: Issue['state'];
       author: string;
+      isRepoArchived?: boolean;
     }): boolean => {
+      if (target.isRepoArchived) {
+        return false;
+      }
       if (target.assignees.length > 0 || target.state !== 'OPEN') {
         return false;
       }

package/src/domain/usecases/CheckIssueReviewReadinessUseCase.ts

@@ -44,6 +44,7 @@ export class CheckIssueReviewReadinessUseCase {
     allowedIssueAuthors?: string[] | null;
     labelsAsLlmAgentName?: string[] | null;
     labelsNotRequiringPullRequest?: string[] | null;
+    developerAgentName?: string | null;
   }): Promise<IssueReviewReadinessResult> => {
     const issue = await this.issueRepository.getIssueByUrl(params.issueUrl);
 
@@ -88,6 +89,7 @@ export class CheckIssueReviewReadinessUseCase {
       await this.issueRejectionEvaluator.evaluate(
         issue,
         resolveLabelsNotRequiringPullRequest(params),
+        { developerAgentName: params.developerAgentName },
       );
 
     const requiredPrRejections = isPullRequestDeclaredUnnecessary(

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -188,6 +188,7 @@ export class HandleScheduledEventUseCase {
     queryToAddProject?: string | null;
     storyProgressCommentEnabled?: boolean;
     dailySecurityScan?: DailySecurityScanConfig | null;
+    developerAgentName?: string | null;
   }): Promise<{
     project: Project;
     issues: Issue[];
@@ -436,6 +437,7 @@ ${JSON.stringify(e)}
       labelsNotRequiringPullRequest: input.labelsNotRequiringPullRequest,
       changeTargetPathAliases: input.changeTargetPathAliases,
       allowedIssueAuthors,
+      developerAgentName: input.developerAgentName,
     });
     await this.triagerApprovalDispatchUseCase.run({
       projectUrl: input.projectUrl,

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

@@ -203,6 +203,61 @@ describe('IssueRejectionEvaluator', () => {
       expect(result.approvedPrUrl).toBeNull();
     });
 
+    it('should require PR evaluation for custom developer agent name when it matches issue agent', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      const result = await evaluator.evaluate(
+        {
+          url: 'https://github.com/user/repo/issues/1',
+          labels: [],
+          isPr: false,
+          agent: 'my-developer',
+        },
+        [],
+        { developerAgentName: 'my-developer' },
+      );
+
+      expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();
+      expect(result.rejections).toHaveLength(1);
+      expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
+    });
+
+    it('should not require PR evaluation when issue agent does not match custom developer agent name', async () => {
+      const result = await evaluator.evaluate(
+        {
+          url: 'https://github.com/user/repo/issues/1',
+          labels: [],
+          isPr: false,
+          agent: 'other-agent',
+        },
+        [],
+        { developerAgentName: 'my-developer' },
+      );
+
+      expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+      expect(result.rejections).toHaveLength(0);
+      expect(result.approvedPrUrl).toBeNull();
+    });
+
+    it('should default to developer when developerAgentName is null', async () => {
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      const result = await evaluator.evaluate(
+        {
+          url: 'https://github.com/user/repo/issues/1',
+          labels: [],
+          isPr: false,
+          agent: 'developer',
+        },
+        [],
+        { developerAgentName: null },
+      );
+
+      expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalled();
+      expect(result.rejections).toHaveLength(1);
+      expect(result.rejections[0].type).toBe('PULL_REQUEST_NOT_FOUND');
+    });
+
     it('should not reject for draft state when issue has non-e2e category label', async () => {
       const result = await evaluator.evaluate({
         url: 'https://github.com/user/repo/issues/1',

package/src/domain/usecases/IssueRejectionEvaluator.ts

@@ -34,6 +34,9 @@ export type EvaluateOptions = {
   // getOpenPullRequest call, which keeps the transient-failure handling that
   // distinguishes an unknown state from an absent pull request.
   resolvedOpenPrByUrl?: ReadonlyMap<string, RelatedPullRequest | null> | null;
+  // The agent name treated as the developer agent for PR/CI/conflict checks.
+  // When null or undefined, defaults to 'developer'.
+  developerAgentName?: string | null;
 };
 
 export class IssueRejectionEvaluator {
@@ -62,7 +65,11 @@ export class IssueRejectionEvaluator {
     let approvedPrUrl: string | null = null;
 
     if (
-      this.requiresPullRequestEvaluation(issue, labelsNotRequiringPullRequest)
+      this.requiresPullRequestEvaluation(
+        issue,
+        labelsNotRequiringPullRequest,
+        options.developerAgentName,
+      )
     ) {
       let prsToCheck: RelatedPullRequest[];
       let anyPrResolutionFailed = false;
@@ -190,12 +197,14 @@ export class IssueRejectionEvaluator {
   requiresPullRequestEvaluation = (
     issue: { labels: string[]; body?: string | null; agent?: string | null },
     labelsNotRequiringPullRequest: string[] = [],
+    developerAgentName?: string | null,
   ): boolean => {
     const categoryLabels = issue.labels.filter((label) =>
       label.startsWith('category:'),
     );
+    const effectiveDeveloperAgentName = developerAgentName ?? 'developer';
     const isNonDeveloperAgent =
-      issue.agent != null && issue.agent !== 'developer';
+      issue.agent != null && issue.agent !== effectiveDeveloperAgentName;
     const hasLabelNotRequiringPullRequest = issue.labels.some((label) =>
       labelsNotRequiringPullRequest.includes(label),
     );

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

@@ -1703,6 +1703,37 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     );
   });
 
+  it('should reject a missing PR when the issue agent matches developerAgentName', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      agent: 'my-agent',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({ content: 'From: :robot: Test report' }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+      developerAgentName: 'my-agent',
+    });
+
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://github.com/user/repo/issues/1',
+      }),
+      expect.stringContaining('PULL_REQUEST_NOT_FOUND'),
+    );
+  });
+
   it('should reject when multiple PRs are found', async () => {
     const issue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -109,6 +109,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     missingAgentName?: string | null;
     sessionErrorLine?: string | null;
     manager?: string | null;
+    developerAgentName?: string | null;
   }): Promise<void> => {
     const project = await this.projectRepository.getByUrl(params.projectUrl);
 
@@ -256,6 +257,7 @@ export class NotifyFinishedIssuePreparationUseCase {
       comments,
       isTrustedAuthor,
       resolveLabelsNotRequiringPullRequest(params),
+      params.developerAgentName,
     );
 
     const rejectionStatusMessage =
@@ -468,6 +470,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     comments: { author: string; content: string }[],
     isTrustedAuthor: (author: string) => boolean,
     labelsNotRequiringPullRequest: string[],
+    developerAgentName?: string | null,
   ): Promise<{
     rejections: { type: RejectedReasonType; detail: string }[];
     approvedPrUrl: string | null;
@@ -495,6 +498,7 @@ export class NotifyFinishedIssuePreparationUseCase {
       await this.issueRejectionEvaluator.evaluate(
         issue,
         labelsNotRequiringPullRequest,
+        { developerAgentName },
       );
     const requiredPrRejections = isPullRequestDeclaredUnnecessary(
       comments,

package/src/domain/usecases/RevertNotReadyReviewQueueIssueUseCase.ts

@@ -64,6 +64,7 @@ export class RevertNotReadyReviewQueueIssueUseCase {
     labelsNotRequiringPullRequest?: string[] | null;
     changeTargetPathAliases?: Record<string, string> | null;
     allowedIssueAuthors?: string[] | null;
+    developerAgentName?: string | null;
   }): Promise<void> => {
     const allowedIssueAuthors = params.allowedIssueAuthors ?? null;
     const projectId = await this.projectRepository.findProjectIdByUrl(
@@ -102,6 +103,7 @@ export class RevertNotReadyReviewQueueIssueUseCase {
       this.issueRejectionEvaluator.requiresPullRequestEvaluation(
         item,
         labelsNotRequiringPullRequest,
+        params.developerAgentName,
       );
 
     const resolvedOpenPrByUrl = await this.issueRepository.getOpenPullRequests(
@@ -132,6 +134,7 @@ export class RevertNotReadyReviewQueueIssueUseCase {
               relatedOpenPrUrls:
                 relatedOpenPrUrlsByIssueUrl.get(issue.url) ?? null,
               resolvedOpenPrByUrl,
+              developerAgentName: params.developerAgentName,
             },
           );
         if (

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

@@ -1013,6 +1013,144 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     ).toBe(false);
   });
 
+  it('should move open issue with Done status to Awaiting Workspace even when project has canonical statuses', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
+    const canonicalStatuses = buildCanonicalStatuses();
+    const awaitingWorkspaceId = canonicalStatuses[0].id;
+    const project = buildProject(canonicalStatuses);
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    const openDoneIssue = buildIssue({
+      number: 10,
+      url: 'https://github.com/test-org/test-repo/issues/10',
+      itemId: 'item-10',
+      state: 'OPEN',
+      status: DONE_STATUS_NAME,
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      project: mock<Project>(),
+      issues: [openDoneIssue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.updateStatus.mockResolvedValue(undefined);
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledTimes(1);
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      openDoneIssue,
+      awaitingWorkspaceId,
+    );
+    expect(mockProjectRepository.updateStatusList).not.toHaveBeenCalled();
+  });
+
+  it('should move open issue with null status to Awaiting Workspace even when project has canonical statuses', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
+    const canonicalStatuses = buildCanonicalStatuses();
+    const awaitingWorkspaceId = canonicalStatuses[0].id;
+    const project = buildProject(canonicalStatuses);
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    const openNullStatusIssue = buildIssue({
+      number: 11,
+      url: 'https://github.com/test-org/test-repo/issues/11',
+      itemId: 'item-11',
+      state: 'OPEN',
+      status: null,
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      project: mock<Project>(),
+      issues: [openNullStatusIssue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.updateStatus.mockResolvedValue(undefined);
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledTimes(1);
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      openNullStatusIssue,
+      awaitingWorkspaceId,
+    );
+    expect(mockProjectRepository.updateStatusList).not.toHaveBeenCalled();
+  });
+
+  it('should not move closed issue with Done status to Awaiting Workspace', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
+    const project = buildProject(buildCanonicalStatuses());
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    const closedDoneIssue = buildIssue({
+      number: 12,
+      url: 'https://github.com/test-org/test-repo/issues/12',
+      itemId: 'item-12',
+      state: 'CLOSED',
+      isClosed: true,
+      status: DONE_STATUS_NAME,
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      project: mock<Project>(),
+      issues: [closedDoneIssue],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    expect(mockProjectRepository.updateStatusList).not.toHaveBeenCalled();
+  });
+
+  it('should not move closed issue with null status to Awaiting Workspace', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
+    const project = buildProject(buildCanonicalStatuses());
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    const closedNullStatusIssue = buildIssue({
+      number: 13,
+      url: 'https://github.com/test-org/test-repo/issues/13',
+      itemId: 'item-13',
+      state: 'CLOSED',
+      isClosed: true,
+      status: null,
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      project: mock<Project>(),
+      issues: [closedNullStatusIssue],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    expect(mockProjectRepository.updateStatusList).not.toHaveBeenCalled();
+  });
+
   it('should migrate issues from Unread to Awaiting Workspace when both statuses exist in the project', async () => {
     const mockProjectRepository =
       mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();