github-issue-tower-defence-management 1.125.4 → 1.126.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "github-issue-tower-defence-management",
-  "version": "1.125.4",
+  "version": "1.126.0",
   "description": "",
   "main": "bin/index.js",
   "scripts": {

package/src/adapter/entry-points/handlers/situationFileWriter.test.ts

@@ -121,6 +121,42 @@ describe('writeSituationFile', () => {
       );
     });
 
+    it('excludes closed items without reactivation triggers from immediately actionable counts', async () => {
+      const issues = [
+        createIssue({
+          status: 'Awaiting quality check',
+          state: 'CLOSED',
+          isClosed: true,
+        }),
+        createIssue({
+          status: 'Awaiting quality check',
+          state: 'MERGED',
+          isClosed: true,
+          isPr: true,
+        }),
+        createIssue({ status: 'Awaiting quality check' }),
+        createIssue({
+          status: 'Awaiting workspace',
+          state: 'CLOSED',
+          isClosed: true,
+        }),
+        createIssue({ status: 'Awaiting workspace' }),
+      ];
+
+      await writeSituationFile({ ...baseParams, issues });
+
+      expect(jest.mocked(fs.writeFileSync)).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.stringContaining(
+          '"awaitingQualityCheckImmediatelyActionable":1',
+        ),
+      );
+      expect(jest.mocked(fs.writeFileSync)).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.stringContaining('"awaitingWorkspaceImmediatelyActionable":1'),
+      );
+    });
+
     it('counts preparation total correctly', async () => {
       const issues = [
         createIssue({ status: 'Preparation' }),

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

@@ -48,6 +48,7 @@ const toPercent = (used: number, total: number): number =>
   total > 0 ? Math.round((used / total) * 1000) / 10 : 0;
 
 const isImmediatelyActionable = (issue: Issue): boolean =>
+  !issue.isClosed &&
   issue.dependedIssueUrls.length === 0 &&
   issue.nextActionDate === null &&
   issue.nextActionHour === null;

package/src/adapter/repositories/ConfigurableSilentSessionMessageComposer.test.ts

@@ -71,6 +71,42 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
     expect(section).not.toContain('\u{FE0F}');
   });
 
+  it('appends the self-diagnosis guidance to the configured main template', () => {
+    const fallback = createFallback();
+    const composer = new ConfigurableSilentSessionMessageComposer(
+      {
+        ...noTemplates,
+        mainStalledMessage: 'CUSTOM_MAIN',
+      },
+      fallback,
+    );
+    const section = composer.composeMainStalledSection(600);
+    expect(section).toContain(
+      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
+    );
+    expect(section).toContain(
+      're-raise the pending request as a new owner-call in that format',
+    );
+  });
+
+  it('omits the self-diagnosis guidance from the configured stale-owner-call template section', () => {
+    const fallback = createFallback();
+    const composer = new ConfigurableSilentSessionMessageComposer(
+      {
+        ...noTemplates,
+        mainStalledStaleOwnerCallMessage: 'CUSTOM_STALE',
+      },
+      fallback,
+    );
+    const section = composer.composeMainStalledWithStaleOwnerCallSection(
+      600,
+      3600,
+    );
+    expect(section).not.toContain(
+      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
+    );
+  });
+
   it('uses the fallback stale-owner-call section when no stale-owner-call template is configured', () => {
     const fallback = createFallback();
     const composer = new ConfigurableSilentSessionMessageComposer(

package/src/adapter/repositories/ConfigurableSilentSessionMessageComposer.ts

@@ -1,5 +1,8 @@
 import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnapshot';
-import { composeOwnerCallFormatGuidance } from '../../domain/usecases/DefaultSilentSessionMessageComposer';
+import {
+  composeMainStalledSelfDiagnosisGuidance,
+  composeOwnerCallFormatGuidance,
+} from '../../domain/usecases/DefaultSilentSessionMessageComposer';
 import {
   SilentSessionMessageComposer,
   SubAgentStallSections,
@@ -36,7 +39,7 @@ export class ConfigurableSilentSessionMessageComposer implements SilentSessionMe
       return this.fallback.composeMainStalledSection(mainSilentSeconds);
     }
     return withReminderSentinel(
-      `${this.templates.mainStalledMessage} ${composeOwnerCallFormatGuidance()}`,
+      `${this.templates.mainStalledMessage} ${composeOwnerCallFormatGuidance()} ${composeMainStalledSelfDiagnosisGuidance()}`,
     );
   };
 

package/src/adapter/repositories/githubGraphqlClient.test.ts

@@ -14,8 +14,10 @@ jest.mock('ky', () => ({
   __esModule: true,
 }));
 
+import net from 'node:net';
 import {
   GITHUB_GRAPHQL_ENDPOINT,
+  GITHUB_GRAPHQL_REQUEST_TIMEOUT_MS,
   RATE_LIMIT_SELECTION,
   extractGraphqlOperationName,
   fetchGithubGraphql,
@@ -247,5 +249,58 @@ describe('githubGraphqlClient', () => {
       expect(response.status).toBe(403);
       expect(consoleLogSpy).not.toHaveBeenCalled();
     });
+
+    it('has a default request timeout bound of 120 seconds', () => {
+      expect(GITHUB_GRAPHQL_REQUEST_TIMEOUT_MS).toBe(120_000);
+    });
+
+    it('passes an abort signal to fetch by default', async () => {
+      const fetchMock = jest
+        .fn()
+        .mockResolvedValue(new Response('{}', { status: 200 }));
+      global.fetch = fetchMock;
+      await fetchGithubGraphql({
+        ghToken: 'token-b',
+        query: 'query PullRequestStatus($a: Int!) { x }',
+      });
+      const call = getMockCallArguments(fetchMock, 0);
+      const init = expectRecord(call[1]);
+      expect(init.signal).toBeInstanceOf(AbortSignal);
+    });
+
+    it('rejects with a TimeoutError within the bound when the server never responds', async () => {
+      const realFetch = originalFetch;
+      const openSockets = new Set<net.Socket>();
+      const server = net.createServer((socket) => {
+        openSockets.add(socket);
+        socket.on('close', () => openSockets.delete(socket));
+      });
+      await new Promise<void>((resolve) =>
+        server.listen(0, '127.0.0.1', resolve),
+      );
+      const address = server.address();
+      if (address === null || typeof address === 'string') {
+        throw new Error('Expected the server to listen on a TCP port');
+      }
+      const localEndpoint = `http://127.0.0.1:${address.port}/`;
+      global.fetch = (_input: RequestInfo | URL, init?: RequestInit) =>
+        realFetch(localEndpoint, init);
+      try {
+        const startedAt = Date.now();
+        await expect(
+          fetchGithubGraphql({
+            ghToken: 'token-b',
+            query: 'query PullRequestStatus($a: Int!) { x }',
+            timeoutMs: 300,
+          }),
+        ).rejects.toMatchObject({ name: 'TimeoutError' });
+        expect(Date.now() - startedAt).toBeLessThan(4000);
+      } finally {
+        for (const socket of openSockets) {
+          socket.destroy();
+        }
+        await new Promise<void>((resolve) => server.close(() => resolve()));
+      }
+    });
   });
 });

package/src/adapter/repositories/githubGraphqlClient.ts

@@ -2,6 +2,8 @@ import ky from 'ky';
 
 export const GITHUB_GRAPHQL_ENDPOINT = 'https://api.github.com/graphql';
 
+export const GITHUB_GRAPHQL_REQUEST_TIMEOUT_MS = 120_000;
+
 export const RATE_LIMIT_SELECTION = 'rateLimit { cost remaining }';
 
 export type GithubGraphqlRateLimit = {
@@ -99,6 +101,7 @@ export const fetchGithubGraphql = async (params: {
   ghToken: string;
   query: string;
   variables?: Record<string, unknown>;
+  timeoutMs?: number;
 }): Promise<Response> => {
   const response = await fetch(GITHUB_GRAPHQL_ENDPOINT, {
     method: 'POST',
@@ -110,6 +113,9 @@ export const fetchGithubGraphql = async (params: {
       query: injectRateLimitSelection(params.query),
       variables: params.variables,
     }),
+    signal: AbortSignal.timeout(
+      params.timeoutMs ?? GITHUB_GRAPHQL_REQUEST_TIMEOUT_MS,
+    ),
   });
   if (response.ok) {
     const responseBody: unknown = await response

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

@@ -1981,6 +1981,8 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     timeline?: () => Response | object;
     mergeability?: () => Response | object;
     slimPullRequest?: (variables: {
+      owner?: string;
+      repo?: string;
       prNumber: number;
       reviewThreadsAfter: string | null;
     }) => Response | object;
@@ -2003,6 +2005,8 @@ describe('ApiV3CheerioRestIssueRepository', () => {
   type GraphqlRequestBody = {
     query: string;
     variables: {
+      owner?: string;
+      repo?: string;
       prNumber: number;
       reviewThreadsAfter: string | null;
     };
@@ -2024,6 +2028,14 @@ describe('ApiV3CheerioRestIssueRepository', () => {
       typeof rawVariables === 'object' && rawVariables !== null
         ? rawVariables
         : {};
+    const owner =
+      'owner' in variables && typeof variables.owner === 'string'
+        ? variables.owner
+        : undefined;
+    const repo =
+      'repo' in variables && typeof variables.repo === 'string'
+        ? variables.repo
+        : undefined;
     const prNumber =
       'prNumber' in variables && typeof variables.prNumber === 'number'
         ? variables.prNumber
@@ -2033,7 +2045,10 @@ describe('ApiV3CheerioRestIssueRepository', () => {
       typeof variables.reviewThreadsAfter === 'string'
         ? variables.reviewThreadsAfter
         : null;
-    return { query: parsed.query, variables: { prNumber, reviewThreadsAfter } };
+    return {
+      query: parsed.query,
+      variables: { owner, repo, prNumber, reviewThreadsAfter },
+    };
   };
 
   const mockFetchRoutes = (routes: FetchRoutes) =>
@@ -2966,6 +2981,72 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     });
   });
 
+  describe('findRelatedOpenPRs cross-repo PR', () => {
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('queries the PR repository owner and name when the PR is in a different repository than the issue', async () => {
+      const capturedSlimVariables: Array<{
+        owner?: string;
+        repo?: string;
+        prNumber: number;
+      }> = [];
+
+      mockFetchRoutes({
+        timeline: () => ({
+          data: {
+            repository: {
+              issue: {
+                timelineItems: {
+                  pageInfo: { endCursor: null, hasNextPage: false },
+                  nodes: [
+                    {
+                      __typename: 'CrossReferencedEvent',
+                      willCloseTarget: true,
+                      source: {
+                        __typename: 'PullRequest',
+                        url: 'https://github.com/HiromiShikata/secretary/pull/2751',
+                        number: 2751,
+                        state: 'OPEN',
+                        createdAt: '2024-01-01T00:00:00Z',
+                        isDraft: false,
+                        mergeable: 'MERGEABLE',
+                        headRefName: 'close-ufw-port-9981-i30106',
+                        baseRefName: 'main',
+                        baseRef: { name: 'main' },
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        }),
+        slimPullRequest: (variables) => {
+          capturedSlimVariables.push(variables);
+          return buildSlimPullRequestResponse({
+            url: 'https://github.com/HiromiShikata/secretary/pull/2751',
+          });
+        },
+      });
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      const result = await repository.findRelatedOpenPRs(
+        'https://github.com/HiromiShikata/umino-corporait-operation/issues/30106',
+      );
+
+      expect(result).toHaveLength(1);
+      expect(result[0].url).toBe(
+        'https://github.com/HiromiShikata/secretary/pull/2751',
+      );
+      expect(capturedSlimVariables).toHaveLength(1);
+      expect(capturedSlimVariables[0].owner).toBe('HiromiShikata');
+      expect(capturedSlimVariables[0].repo).toBe('secretary');
+      expect(capturedSlimVariables[0].prNumber).toBe(2751);
+    });
+  });
+
   const createApiV3CheerioRestIssueRepository = () => {
     const apiV3IssueRepository = mock<ApiV3IssueRepository>();
     const restIssueRepository = mock<RestIssueRepository>();

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

@@ -1493,6 +1493,10 @@ export class ApiV3CheerioRestIssueRepository
         const pr = item.source;
         const prUrl = pr.url || '';
 
+        if (!prUrl) continue;
+
+        const { owner: prOwner, repo: prRepo } = this.parseIssueUrl(prUrl);
+
         let isConflicted = pr.mergeable === 'CONFLICTING';
         let mergeable: string | null = pr.mergeable ?? null;
         if (
@@ -1507,8 +1511,8 @@ export class ApiV3CheerioRestIssueRepository
           } | null;
           try {
             resolved = await this.resolveMergeabilityWithRetry(
-              owner,
-              repo,
+              prOwner,
+              prRepo,
               pr.number,
             );
           } catch (error) {
@@ -1538,8 +1542,8 @@ export class ApiV3CheerioRestIssueRepository
         let prStatus: RelatedPullRequest;
         try {
           const slimPullRequest = await this.fetchSlimPullRequest(
-            owner,
-            repo,
+            prOwner,
+            prRepo,
             pr.number,
           );
           if (!slimPullRequest || slimPullRequest.state !== 'OPEN') {
@@ -1550,12 +1554,16 @@ export class ApiV3CheerioRestIssueRepository
           }
           const baseRefName =
             slimPullRequest.baseRefName ?? pr.baseRefName ?? pr.baseRef?.name;
-          prStatus = await this.buildRelatedPullRequestFromSlim(owner, repo, {
-            ...slimPullRequest,
-            url: slimPullRequest.url || prUrl,
-            headRefName: slimPullRequest.headRefName ?? pr.headRefName,
-            baseRefName,
-          });
+          prStatus = await this.buildRelatedPullRequestFromSlim(
+            prOwner,
+            prRepo,
+            {
+              ...slimPullRequest,
+              url: slimPullRequest.url || prUrl,
+              headRefName: slimPullRequest.headRefName ?? pr.headRefName,
+              baseRefName,
+            },
+          );
         } catch (error) {
           const errorMessage =
             error instanceof Error ? error.message : String(error);

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

@@ -99,6 +99,60 @@ describe('DefaultSilentSessionMessageComposer', () => {
     expect(section).not.toContain('>');
   });
 
+  it('explains in the main-stalled section that the reminder reaches only sessions without a registered unanswered owner-call', () => {
+    const section = composer.composeMainStalledSection(600);
+    expect(section).toContain(
+      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
+    );
+  });
+
+  it('explains in the main-stalled section that receiving the reminder while believing an owner-call is pending means the call was not registered and the owner was not notified', () => {
+    const section = composer.composeMainStalledSection(600);
+    expect(section).toContain(
+      'If you believe you have already raised an owner-call and are waiting for the owner',
+    );
+    expect(section).toContain(
+      'receiving this reminder means that call was not registered',
+    );
+    expect(section).toContain('the owner has not been notified');
+  });
+
+  it('instructs in the main-stalled section to review the documented owner-call format and re-raise the pending request', () => {
+    const section = composer.composeMainStalledSection(600);
+    expect(section).toContain(
+      'please review the documented owner-call format for this session',
+    );
+    expect(section).toContain(
+      're-raise the pending request as a new owner-call in that format',
+    );
+  });
+
+  it('omits the self-diagnosis guidance from the stale-owner-call section', () => {
+    const section = composer.composeMainStalledWithStaleOwnerCallSection(
+      600,
+      3600,
+    );
+    expect(section).not.toContain(
+      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
+    );
+  });
+
+  it('omits the self-diagnosis guidance from the sub-agent sections', () => {
+    const subAgent = {
+      label: 'sub-process-1',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
+    expect(section).not.toContain(
+      'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
+    );
+  });
+
   it('embeds the reminder sentinel in the stale-owner-call main-stalled section', () => {
     const section = composer.composeMainStalledWithStaleOwnerCallSection(
       600,

package/src/domain/usecases/DefaultSilentSessionMessageComposer.ts

@@ -46,6 +46,14 @@ export const composeOwnerCallFormatGuidance = (): string => {
   return 'Please share it through a new owner-call in the format documented for this session, written to be self-contained so the owner can understand the situation from that single message.';
 };
 
+export const composeMainStalledSelfDiagnosisGuidance = (): string => {
+  return [
+    'This reminder is delivered only to sessions that have no registered unanswered owner-call.',
+    "If you believe you have already raised an owner-call and are waiting for the owner's reply, receiving this reminder means that call was not registered — its format or delivery method was incorrect — and the owner has not been notified.",
+    'In that case, please review the documented owner-call format for this session and re-raise the pending request as a new owner-call in that format.',
+  ].join(' ');
+};
+
 const composeMainStalledMessage = (mainSilentSeconds: number): string => {
   const minutes = Math.floor(mainSilentSeconds / 60);
   return [
@@ -54,6 +62,7 @@ const composeMainStalledMessage = (mainSilentSeconds: number): string => {
     `2. Run independent pieces of work in parallel across sub-agents.`,
     `3. Keep a monitor in place that notices when a sub-agent has produced no output for about 5 minutes.`,
     `4. When an owner decision is needed, or when work the owner asked for has been completed or answered, please share it through a new owner-call — a completion still awaits the owner's acknowledgment, so it is not a no-action case. The owner is notified only when an owner-call is raised. ${composeOwnerCallFormatGuidance()}`,
+    composeMainStalledSelfDiagnosisGuidance(),
     `Please also include in your next output an estimate of the remaining minutes to finish all tasks.`,
   ].join('\n');
 };

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

@@ -1056,6 +1056,24 @@ describe('HandleScheduledEventUseCase', () => {
         expect(mockIssueRepository.createCommentByUrl).not.toHaveBeenCalled();
       });
 
+      it('should not create or comment an incident issue for a fetch AbortSignal timeout DOMException', async () => {
+        const timeoutError = new DOMException(
+          'The operation was aborted due to timeout',
+          'TimeoutError',
+        );
+        mockRevertNotReadyReviewQueueIssueUseCase.run.mockRejectedValueOnce(
+          timeoutError,
+        );
+
+        await expect(useCase.run(errorInput)).rejects.toThrow(
+          'The operation was aborted due to timeout',
+        );
+
+        expect(mockIssueRepository.searchIssue).not.toHaveBeenCalled();
+        expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
+        expect(mockIssueRepository.createCommentByUrl).not.toHaveBeenCalled();
+      });
+
       it('should not create or comment an incident issue for a ky TimeoutError (matched by error name)', async () => {
         const timeoutError = new Error(
           'Request timed out: POST https://api.github.com/graphql',