github-issue-tower-defence-management 1.103.1 → 1.104.0

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

@@ -14,6 +14,7 @@ export type ProjectItem = {
   assignees: string[];
   createdAt: string;
   author: string;
+  closingIssueReferenceUrls: string[];
   customFields: {
     name: string;
     value: string | null;
@@ -214,6 +215,11 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!) {
               repository {
                 nameWithOwner
               }
+              closingIssuesReferences(first: 50) {
+                nodes {
+                  url
+                }
+              }
             }
           }
         }
@@ -257,6 +263,7 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!) {
               author: { login: string } | null;
               labels: { nodes: { name: string }[] };
               assignees: { nodes: { login: string }[] };
+              closingIssuesReferences?: { nodes: { url: string }[] };
             };
           }[];
         };
@@ -309,6 +316,7 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!) {
                     author: { login: string } | null;
                     labels: { nodes: { name: string }[] };
                     assignees: { nodes: { login: string }[] };
+                    closingIssuesReferences?: { nodes: { url: string }[] };
                   };
                 }[];
               };
@@ -364,6 +372,7 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!) {
               author: { login: string } | null;
               labels: { nodes: { name: string }[] };
               assignees: { nodes: { login: string }[] };
+              closingIssuesReferences?: { nodes: { url: string }[] };
             };
           }[];
         };
@@ -435,6 +444,7 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!) {
           author: { login: string } | null;
           labels: { nodes: { name: string }[] };
           assignees: { nodes: { login: string }[] };
+          closingIssuesReferences?: { nodes: { url: string }[] };
         };
       }[] = pageNodes;
       projectItems.forEach((item) => {
@@ -453,6 +463,10 @@ query GetProjectItems($projectId: ID!, $after: String, $first: Int!) {
           assignees: item.content.assignees?.nodes?.map((a) => a.login) || [],
           createdAt: item.content.createdAt || new Date().toISOString(),
           author: item.content.author?.login || '',
+          closingIssueReferenceUrls:
+            item.content.closingIssuesReferences?.nodes
+              ?.map((node) => node.url)
+              .filter((url) => url.length > 0) || [],
           customFields: item.fieldValues.nodes
             .filter((field) => !!field.field)
             .map((field) => {
@@ -768,6 +782,11 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       repository {
         nameWithOwner
       }
+      closingIssuesReferences(first: 50) {
+        nodes {
+          url
+        }
+      }
       projectItems(first: 10) {
         nodes {
           id
@@ -843,6 +862,7 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       labels: { nodes: { name: string }[] };
       assignees: { nodes: { login: string }[] };
       repository: { nameWithOwner: string };
+      closingIssuesReferences?: { nodes: { url: string }[] };
       projectItems: {
         nodes: {
           id: string;
@@ -914,6 +934,10 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       assignees: content.assignees?.nodes?.map((a) => a.login) || [],
       createdAt: content.createdAt || new Date().toISOString(),
       author: content.author?.login || '',
+      closingIssueReferenceUrls:
+        content.closingIssuesReferences?.nodes
+          ?.map((node) => node.url)
+          .filter((url) => url.length > 0) || [],
       customFields: item.fieldValues.nodes
         .filter((field) => !!field.field)
         .map((field) => {

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

@@ -50,6 +50,7 @@ const buildIssue = (overrides: Partial<Issue> = {}): Issue => ({
   isClosed: false,
   createdAt: new Date(),
   author: '',
+  closingIssueReferenceUrls: [],
   ...overrides,
 });
 

package/src/domain/entities/Issue.ts

@@ -24,4 +24,5 @@ export type Issue = {
   isClosed: boolean;
   createdAt: Date;
   author: string;
+  closingIssueReferenceUrls: string[];
 };

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

@@ -27,6 +27,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   isClosed: false,
   createdAt: new Date('2000-01-01T00:00:00Z'),
   author: 'test-user',
+  closingIssueReferenceUrls: [],
   ...overrides,
 });
 

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

@@ -67,6 +67,7 @@ describe('GetStoryObjectMapUseCase', () => {
     isClosed: false,
     createdAt: new Date(),
     author: '',
+    closingIssueReferenceUrls: [],
     ...overrides,
   });
 

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

@@ -47,6 +47,7 @@ const issue = (url: string, status: string): Issue => ({
   isClosed: false,
   createdAt: new Date('2026-01-01T00:00:00Z'),
   author: 'hiromi',
+  closingIssueReferenceUrls: [],
 });
 
 describe('InTmuxByHumanSessionTokenCountUseCase', () => {

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

@@ -72,6 +72,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   isClosed: false,
   createdAt: new Date(),
   author: '',
+  closingIssueReferenceUrls: [],
   ...overrides,
 });
 

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

@@ -80,6 +80,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   isClosed: false,
   createdAt: new Date(),
   author: '',
+  closingIssueReferenceUrls: [],
   ...overrides,
 });
 

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

@@ -32,6 +32,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   isClosed: false,
   createdAt: new Date(),
   author: '',
+  closingIssueReferenceUrls: [],
   ...overrides,
 });
 

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

@@ -28,6 +28,7 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
     isPr: false,
     isClosed: false,
     state: 'OPEN',
+    closingIssueReferenceUrls: [],
   };
   const closedTaskIssue: Issue = {
     ...mock<Issue>(),
@@ -35,50 +36,28 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
     isPr: false,
     isClosed: true,
     state: 'CLOSED',
+    closingIssueReferenceUrls: [],
   };
-  const prItem: Issue = {
+
+  const openPrClosingIssue1: Issue = {
     ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/pull/10',
+    url: 'https://github.com/owner/repo/pull/100',
     isPr: true,
     isClosed: false,
     state: 'OPEN',
+    closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/1'],
   };
 
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
-  it('should call setDependedIssueUrl for each related open PR linked to an open task issue', async () => {
-    mockIssueRepository.findRelatedOpenPRs.mockImplementation(
-      async (issueUrl) => {
-        if (issueUrl === openTaskIssue.url) {
-          return [
-            {
-              url: 'https://github.com/owner/repo/pull/100',
-              branchName: null,
-              createdAt: new Date(0),
-              isDraft: false,
-              isConflicted: false,
-              isPassedAllCiJob: true,
-              isCiStateSuccess: true,
-              isResolvedAllReviewComments: true,
-              isBranchOutOfDate: false,
-              missingRequiredCheckNames: [],
-            },
-          ];
-        }
-        return [];
-      },
-    );
-
+  it('should call setDependedIssueUrl for each open PR whose closing keyword targets an open task issue', async () => {
     await useCase.run({
       project: projectWithField,
-      issues: [openTaskIssue],
+      issues: [openTaskIssue, openPrClosingIssue1],
     });
 
-    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
-      openTaskIssue.url,
-    );
     expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledTimes(1);
     expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
       'https://github.com/owner/repo/pull/100',
@@ -87,41 +66,108 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
     );
   });
 
+  it('should never call the per-issue timeline lookup', async () => {
+    await useCase.run({
+      project: projectWithField,
+      issues: [openTaskIssue, openPrClosingIssue1],
+    });
+
+    expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+  });
+
   it('should skip closed task issues so that PRs linked only to a closed task are not touched', async () => {
-    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+    const openPrClosingClosedIssue: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/101',
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/2'],
+    };
 
     await useCase.run({
       project: projectWithField,
-      issues: [closedTaskIssue],
+      issues: [closedTaskIssue, openPrClosingClosedIssue],
     });
 
-    expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
     expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
   });
 
-  it('should skip PR project items themselves and only iterate task issues', async () => {
-    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+  it('should ignore closed PRs even when they declare a closing keyword for an open task issue', async () => {
+    const closedPrClosingIssue1: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/102',
+      isPr: true,
+      isClosed: true,
+      state: 'CLOSED',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/1'],
+    };
 
     await useCase.run({
       project: projectWithField,
-      issues: [prItem],
+      issues: [openTaskIssue, closedPrClosingIssue1],
     });
 
-    expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
     expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
   });
 
-  it('should not call setDependedIssueUrl when no related open PRs are found for an open task issue', async () => {
-    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+  it('should ignore bare mentions because they are absent from the closing-keyword set', async () => {
+    const openPrMentioningButNotClosing: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/103',
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: [],
+    };
 
     await useCase.run({
       project: projectWithField,
-      issues: [openTaskIssue],
+      issues: [openTaskIssue, openPrMentioningButNotClosing],
     });
 
-    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
-      openTaskIssue.url,
+    expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
+  });
+
+  it('should map a cross-repo closing target by full issue URL', async () => {
+    const crossRepoOpenTaskIssue: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/other-repo/issues/9',
+      isPr: false,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: [],
+    };
+    const openPrClosingCrossRepoIssue: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/104',
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: [
+        'https://github.com/owner/other-repo/issues/9',
+      ],
+    };
+
+    await useCase.run({
+      project: projectWithField,
+      issues: [crossRepoOpenTaskIssue, openPrClosingCrossRepoIssue],
+    });
+
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledTimes(1);
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+      'https://github.com/owner/repo/pull/104',
+      projectWithField,
+      crossRepoOpenTaskIssue.url,
     );
+  });
+
+  it('should not call setDependedIssueUrl when no open PR closes an open task issue', async () => {
+    await useCase.run({
+      project: projectWithField,
+      issues: [openTaskIssue],
+    });
+
     expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
   });
 
@@ -130,75 +176,72 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
 
     await useCase.run({
       project: projectWithoutField,
-      issues: [openTaskIssue],
+      issues: [openTaskIssue, openPrClosingIssue1],
     });
 
-    expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
     expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
     expect(warnSpy).toHaveBeenCalled();
 
     warnSpy.mockRestore();
   });
 
-  it('should iterate over each open task issue and request its related open PRs independently', async () => {
+  it('should set dependencies for multiple open task issues from their respective open PRs', async () => {
     const secondOpenTaskIssue: Issue = {
       ...mock<Issue>(),
       url: 'https://github.com/owner/repo/issues/3',
       isPr: false,
       isClosed: false,
       state: 'OPEN',
+      closingIssueReferenceUrls: [],
+    };
+    const openPrClosingIssue3: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/200',
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/3'],
     };
-
-    mockIssueRepository.findRelatedOpenPRs.mockImplementation(
-      async (issueUrl) => {
-        if (issueUrl === openTaskIssue.url) {
-          return [
-            {
-              url: 'https://github.com/owner/repo/pull/100',
-              branchName: null,
-              createdAt: new Date(0),
-              isDraft: false,
-              isConflicted: false,
-              isPassedAllCiJob: true,
-              isCiStateSuccess: true,
-              isResolvedAllReviewComments: true,
-              isBranchOutOfDate: false,
-              missingRequiredCheckNames: [],
-            },
-          ];
-        }
-        if (issueUrl === secondOpenTaskIssue.url) {
-          return [
-            {
-              url: 'https://github.com/owner/repo/pull/200',
-              branchName: null,
-              createdAt: new Date(0),
-              isDraft: false,
-              isConflicted: false,
-              isPassedAllCiJob: true,
-              isCiStateSuccess: true,
-              isResolvedAllReviewComments: true,
-              isBranchOutOfDate: false,
-              missingRequiredCheckNames: [],
-            },
-          ];
-        }
-        return [];
-      },
-    );
 
     await useCase.run({
       project: projectWithField,
-      issues: [openTaskIssue, closedTaskIssue, prItem, secondOpenTaskIssue],
+      issues: [
+        openTaskIssue,
+        closedTaskIssue,
+        openPrClosingIssue1,
+        secondOpenTaskIssue,
+        openPrClosingIssue3,
+      ],
     });
 
-    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledTimes(2);
-    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledTimes(2);
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+      'https://github.com/owner/repo/pull/100',
+      projectWithField,
       openTaskIssue.url,
     );
-    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+      'https://github.com/owner/repo/pull/200',
+      projectWithField,
       secondOpenTaskIssue.url,
     );
+  });
+
+  it('should set dependencies for every open PR that closes the same open task issue', async () => {
+    const secondOpenPrClosingIssue1: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/105',
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/1'],
+    };
+
+    await useCase.run({
+      project: projectWithField,
+      issues: [openTaskIssue, openPrClosingIssue1, secondOpenPrClosingIssue1],
+    });
+
     expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledTimes(2);
     expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
       'https://github.com/owner/repo/pull/100',
@@ -206,9 +249,9 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
       openTaskIssue.url,
     );
     expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
-      'https://github.com/owner/repo/pull/200',
+      'https://github.com/owner/repo/pull/105',
       projectWithField,
-      secondOpenTaskIssue.url,
+      openTaskIssue.url,
     );
   });
 
@@ -216,33 +259,23 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
     const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
     const failingPrUrl = 'https://github.com/owner/repo/pull/100';
     const succeedingPrUrl = 'https://github.com/owner/repo/pull/200';
+    const failingPr: Issue = {
+      ...mock<Issue>(),
+      url: failingPrUrl,
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/1'],
+    };
+    const succeedingPr: Issue = {
+      ...mock<Issue>(),
+      url: succeedingPrUrl,
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/1'],
+    };
 
-    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
-      {
-        url: failingPrUrl,
-        branchName: null,
-        createdAt: new Date(0),
-        isDraft: false,
-        isConflicted: false,
-        isPassedAllCiJob: true,
-        isCiStateSuccess: true,
-        isResolvedAllReviewComments: true,
-        isBranchOutOfDate: false,
-        missingRequiredCheckNames: [],
-      },
-      {
-        url: succeedingPrUrl,
-        branchName: null,
-        createdAt: new Date(0),
-        isDraft: false,
-        isConflicted: false,
-        isPassedAllCiJob: true,
-        isCiStateSuccess: true,
-        isResolvedAllReviewComments: true,
-        isBranchOutOfDate: false,
-        missingRequiredCheckNames: [],
-      },
-    ]);
     mockIssueRepository.setDependedIssueUrl.mockImplementation(
       async (prUrl) => {
         if (prUrl === failingPrUrl) {
@@ -254,7 +287,7 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
     await expect(
       useCase.run({
         project: projectWithField,
-        issues: [openTaskIssue],
+        issues: [openTaskIssue, failingPr, succeedingPr],
       }),
     ).resolves.toBeUndefined();
 

package/src/domain/usecases/SetDependedIssueUrlForOpenTaskPRsUseCase.ts

@@ -4,10 +4,7 @@ import { IssueRepository } from './adapter-interfaces/IssueRepository';
 
 export class SetDependedIssueUrlForOpenTaskPRsUseCase {
   constructor(
-    readonly issueRepository: Pick<
-      IssueRepository,
-      'findRelatedOpenPRs' | 'setDependedIssueUrl'
-    >,
+    readonly issueRepository: Pick<IssueRepository, 'setDependedIssueUrl'>,
   ) {}
 
   run = async (input: { project: Project; issues: Issue[] }): Promise<void> => {
@@ -17,26 +14,54 @@ export class SetDependedIssueUrlForOpenTaskPRsUseCase {
       );
       return;
     }
+    const openPrUrlsByClosedIssueUrl = this.buildOpenPrUrlsByClosedIssueUrl(
+      input.issues,
+    );
     for (const issue of input.issues) {
       if (issue.isPr || issue.isClosed) {
         continue;
       }
-      const relatedOpenPRs = await this.issueRepository.findRelatedOpenPRs(
-        issue.url,
-      );
-      for (const pr of relatedOpenPRs) {
+      const relatedOpenPrUrls = openPrUrlsByClosedIssueUrl.get(issue.url);
+      if (!relatedOpenPrUrls) {
+        continue;
+      }
+      for (const prUrl of relatedOpenPrUrls) {
         try {
           await this.issueRepository.setDependedIssueUrl(
-            pr.url,
+            prUrl,
             input.project,
             issue.url,
           );
         } catch (error) {
           console.warn(
-            `Failed to set depended issue URL for PR ${pr.url}, skipping and continuing with remaining PRs: ${error instanceof Error ? error.message : String(error)}`,
+            `Failed to set depended issue URL for PR ${prUrl}, skipping and continuing with remaining PRs: ${error instanceof Error ? error.message : String(error)}`,
           );
         }
       }
     }
   };
+
+  private buildOpenPrUrlsByClosedIssueUrl = (
+    issues: Issue[],
+  ): Map<string, string[]> => {
+    const openPrUrlsByClosedIssueUrl = new Map<string, Set<string>>();
+    for (const issue of issues) {
+      if (!issue.isPr || issue.isClosed) {
+        continue;
+      }
+      for (const closedIssueUrl of issue.closingIssueReferenceUrls) {
+        const existing = openPrUrlsByClosedIssueUrl.get(closedIssueUrl);
+        if (existing) {
+          existing.add(issue.url);
+        } else {
+          openPrUrlsByClosedIssueUrl.set(closedIssueUrl, new Set([issue.url]));
+        }
+      }
+    }
+    const result = new Map<string, string[]>();
+    for (const [closedIssueUrl, prUrls] of openPrUrlsByClosedIssueUrl) {
+      result.set(closedIssueUrl, Array.from(prUrls));
+    }
+    return result;
+  };
 }

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

@@ -72,6 +72,7 @@ const buildIssue = (overrides: Partial<Issue>): Issue => ({
   isClosed: false,
   createdAt: new Date('2024-01-01'),
   author: 'user',
+  closingIssueReferenceUrls: [],
   ...overrides,
 });
 

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

@@ -51,6 +51,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   isClosed: false,
   createdAt: new Date(),
   author: 'testuser',
+  closingIssueReferenceUrls: [],
   ...overrides,
 });
 

package/src/domain/usecases/console/GenerateConsoleListsUseCase.test.ts

@@ -82,6 +82,7 @@ const makeIssue = (overrides: Partial<Issue>): Issue => {
     isClosed: false,
     createdAt: new Date('2026-06-13T08:18:45.000Z'),
     author: 'someone',
+    closingIssueReferenceUrls: [],
     ...overrides,
   };
 };

package/src/domain/usecases/intmux/GenerateInTmuxByHumanDataUseCase.test.ts

@@ -79,6 +79,7 @@ const makeIssue = (overrides: Partial<Issue>): Issue => {
     isClosed: false,
     createdAt: new Date('2026-06-13T08:18:45.000Z'),
     author: 'someone',
+    closingIssueReferenceUrls: [],
     ...overrides,
   };
 };

package/src/domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase.test.ts

@@ -37,6 +37,7 @@ const makeIssue = (overrides: Partial<Issue> = {}): Issue => {
     isClosed: false,
     createdAt: new Date(),
     author: '',
+    closingIssueReferenceUrls: [],
     ...overrides,
   };
 };