github-issue-tower-defence-management 1.122.3 → 1.122.5

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

@@ -4,6 +4,7 @@ import {
   parseHubTaskIssueUrlFromSessionName,
   isGitHubIssueOrPullRequestSessionName,
   DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+  DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
   DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
   DEFAULT_NOTIFICATION_STAGGER_SECONDS,
@@ -28,6 +29,8 @@ import { InteractiveLiveSession } from '../entities/InteractiveLiveSession';
 type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
 
 const MAIN_STALLED_SECTION = 'MAIN_STALLED_SECTION';
+const MAIN_STALLED_STALE_OWNER_CALL_SECTION =
+  'MAIN_STALLED_STALE_OWNER_CALL_SECTION';
 const SUBAGENT_SECTION = 'SUBAGENT_SECTION';
 
 class EveryNameRecentSet extends Set<string> {
@@ -66,6 +69,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     }>,
   ): {
     mainSilentThresholdSeconds: number;
+    unansweredOwnerCallGraceSeconds: number;
     subAgentSilentThresholdSeconds: number;
     subAgentRunningThresholdSeconds: number;
     staggerSeconds: number;
@@ -75,6 +79,8 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     now: Date;
   } => ({
     mainSilentThresholdSeconds: DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+    unansweredOwnerCallGraceSeconds:
+      DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
     subAgentSilentThresholdSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
     subAgentRunningThresholdSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
     staggerSeconds: DEFAULT_NOTIFICATION_STAGGER_SECONDS,
@@ -147,9 +153,9 @@ describe('NotifySilentLiveSessionsUseCase', () => {
         .mockResolvedValue(new Map<string, SubAgentActivity[]>()),
     };
     mockOwnerCallStatusProvider = {
-      listSessionNamesWithUnansweredOwnerCall: jest
+      listUnansweredOwnerCallEpochSecondsBySessionName: jest
         .fn()
-        .mockResolvedValue(new Set<string>()),
+        .mockResolvedValue(new Map<string, number>()),
     };
     mockNotificationRepository = {
       sendSelfCheckNotification: jest.fn().mockResolvedValue(undefined),
@@ -159,11 +165,20 @@ describe('NotifySilentLiveSessionsUseCase', () => {
         .fn()
         .mockResolvedValue(everyNameRecentSet()),
       saveCandidateSessionNames: jest.fn().mockResolvedValue(undefined),
+      loadAnnouncedRunningSubAgentLabels: jest
+        .fn()
+        .mockResolvedValue(new Set<string>()),
+      saveAnnouncedRunningSubAgentLabels: jest
+        .fn()
+        .mockResolvedValue(undefined),
     };
     mockMessageComposer = {
       composeMainStalledSection: jest
         .fn()
         .mockReturnValue(MAIN_STALLED_SECTION),
+      composeMainStalledWithStaleOwnerCallSection: jest
+        .fn()
+        .mockReturnValue(MAIN_STALLED_STALE_OWNER_CALL_SECTION),
       composeSubAgentSection: jest.fn().mockReturnValue(SUBAGENT_SECTION),
     };
     mockSleeper = {
@@ -243,6 +258,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
 
   it('exposes the default thresholds as named constants', () => {
     expect(DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS).toBe(600);
+    expect(DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS).toBe(3600);
     expect(DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS).toBe(300);
     expect(DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS).toBe(900);
     expect(DEFAULT_NOTIFICATION_STAGGER_SECONDS).toBe(25);
@@ -365,36 +381,119 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       mockSessionOutputActivityRepository.listSessionOutputActivities,
     ).toHaveBeenCalledWith(expectedMap);
     expect(
-      mockOwnerCallStatusProvider.listSessionNamesWithUnansweredOwnerCall,
+      mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName,
     ).toHaveBeenCalledWith(expectedMap);
     expect(
       mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName,
     ).toHaveBeenCalledWith([GITHUB_SESSION], expectedMap);
   });
 
-  it('suppresses the stalled section and sends nothing when an owner call is pending past the threshold', async () => {
+  it('suppresses the stalled section and sends nothing while the unanswered owner call is younger than the grace period', async () => {
+    setupSilentMainSession(GITHUB_SESSION);
+    mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
+      new Map([
+        [
+          GITHUB_SESSION,
+          nowEpochSeconds - DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS + 1,
+        ],
+      ]),
+    );
+
+    await useCase.run(runParams());
+
+    expect(
+      mockMessageComposer.composeMainStalledSection,
+    ).not.toHaveBeenCalled();
+    expect(
+      mockMessageComposer.composeMainStalledWithStaleOwnerCallSection,
+    ).not.toHaveBeenCalled();
+    expect(
+      mockNotificationRepository.sendSelfCheckNotification,
+    ).not.toHaveBeenCalled();
+  });
+
+  it('sends the stale-owner-call stalled section once the unanswered owner call reaches the grace period', async () => {
+    setupSilentMainSession(GITHUB_SESSION);
+    mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
+      new Map([
+        [
+          GITHUB_SESSION,
+          nowEpochSeconds - DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
+        ],
+      ]),
+    );
+
+    await useCase.run(runParams());
+
+    expect(
+      mockMessageComposer.composeMainStalledWithStaleOwnerCallSection,
+    ).toHaveBeenCalledWith(
+      DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+      DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
+    );
+    expect(
+      mockMessageComposer.composeMainStalledSection,
+    ).not.toHaveBeenCalled();
+    expect(
+      mockNotificationRepository.sendSelfCheckNotification,
+    ).toHaveBeenCalledWith(
+      GITHUB_SESSION,
+      MAIN_STALLED_STALE_OWNER_CALL_SECTION,
+    );
+  });
+
+  it('does not send the stale-owner-call section when the owner call is past the grace period but the main output is not silent past the threshold', async () => {
     setupLiveInteractiveSession(GITHUB_SESSION);
     mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
       [
         {
           sessionName: GITHUB_SESSION,
           lastOutputEpochSeconds:
-            nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+            nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS + 1,
         },
       ],
     );
-    mockOwnerCallStatusProvider.listSessionNamesWithUnansweredOwnerCall.mockResolvedValue(
-      new Set([GITHUB_SESSION]),
+    mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
+      new Map([
+        [
+          GITHUB_SESSION,
+          nowEpochSeconds - DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
+        ],
+      ]),
     );
 
     await useCase.run(runParams());
 
     expect(
-      mockMessageComposer.composeMainStalledSection,
+      mockNotificationRepository.sendSelfCheckNotification,
     ).not.toHaveBeenCalled();
+  });
+
+  it('defers a first-cycle stale-owner-call candidate until it persists into the next cycle', async () => {
+    setupSilentMainSession(GITHUB_SESSION);
+    mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
+      new Map([
+        [
+          GITHUB_SESSION,
+          nowEpochSeconds - DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
+        ],
+      ]),
+    );
+    mockCandidateStateRepository.loadRecentCandidateSessionNames.mockResolvedValue(
+      new Set<string>(),
+    );
+
+    await useCase.run(runParams());
+
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
     ).not.toHaveBeenCalled();
+    expect(
+      mockCandidateStateRepository.saveCandidateSessionNames,
+    ).toHaveBeenCalledWith({
+      sessionNames: [GITHUB_SESSION],
+      now,
+    });
   });
 
   it('sends the main stalled section when the session is silent past the threshold and not waiting on the owner', async () => {
@@ -408,8 +507,8 @@ describe('NotifySilentLiveSessionsUseCase', () => {
         },
       ],
     );
-    mockOwnerCallStatusProvider.listSessionNamesWithUnansweredOwnerCall.mockResolvedValue(
-      new Set<string>(),
+    mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
+      new Map<string, number>(),
     );
 
     await useCase.run(runParams());
@@ -417,6 +516,9 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     expect(mockMessageComposer.composeMainStalledSection).toHaveBeenCalledWith(
       DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
     );
+    expect(
+      mockMessageComposer.composeMainStalledWithStaleOwnerCallSection,
+    ).not.toHaveBeenCalled();
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
     ).toHaveBeenCalledWith(GITHUB_SESSION, MAIN_STALLED_SECTION);
@@ -448,6 +550,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
         label: 'sub-process-1',
         silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
         runningSeconds: 60,
+        waitingOnExternalProcess: false,
       },
     ];
     mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
@@ -456,27 +559,23 @@ describe('NotifySilentLiveSessionsUseCase', () => {
 
     await useCase.run(runParams());
 
-    expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith(
-      subAgents,
-      {
-        subAgentSilentThresholdSeconds:
-          DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
-        subAgentRunningThresholdSeconds:
-          DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
-      },
-    );
+    expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith({
+      idleSubAgents: subAgents,
+      longRunningSubAgents: [],
+    });
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
     ).toHaveBeenCalledWith(GITHUB_SESSION, SUBAGENT_SECTION);
   });
 
-  it('passes a configured running threshold through to the sub-agent section composer', async () => {
+  it('applies a configured running threshold when selecting long-running sub-agents', async () => {
     setupLiveInteractiveSession(GITHUB_SESSION);
     const subAgents: SubAgentActivity[] = [
       {
         label: 'sub-process-1',
         silentSeconds: 10,
         runningSeconds: 600,
+        waitingOnExternalProcess: false,
       },
     ];
     mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
@@ -488,14 +587,10 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       subAgentRunningThresholdSeconds: 600,
     });
 
-    expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith(
-      subAgents,
-      {
-        subAgentSilentThresholdSeconds:
-          DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
-        subAgentRunningThresholdSeconds: 600,
-      },
-    );
+    expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith({
+      idleSubAgents: [],
+      longRunningSubAgents: subAgents,
+    });
   });
 
   it('excludes an owner-handover spawn from selection so no notification is sent', async () => {
@@ -656,6 +751,239 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     });
   });
 
+  describe('sub-agent state-based reminder judgment', () => {
+    const hungSubAgent = (label: string): SubAgentActivity => ({
+      label,
+      silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+      runningSeconds: 60,
+      waitingOnExternalProcess: false,
+    });
+    const waitingSubAgent = (label: string): SubAgentActivity => ({
+      label,
+      silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+      runningSeconds: 60,
+      waitingOnExternalProcess: true,
+    });
+    const longRunningSubAgent = (
+      label: string,
+      waitingOnExternalProcess: boolean,
+    ): SubAgentActivity => ({
+      label,
+      silentSeconds: 30,
+      runningSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
+      waitingOnExternalProcess,
+    });
+
+    const setupSubAgents = (subAgents: SubAgentActivity[]): void => {
+      setupLiveInteractiveSession(GITHUB_SESSION);
+      mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
+        new Map([[GITHUB_SESSION, subAgents]]),
+      );
+    };
+
+    it('never selects a waiting sub-agent as a silent-reminder candidate', async () => {
+      setupSubAgents([waitingSubAgent('sub-process-1')]);
+
+      await useCase.run(runParams());
+
+      expect(mockMessageComposer.composeSubAgentSection).not.toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('notifies a hung sub-agent whose in-flight tool has no live process', async () => {
+      setupSubAgents([hungSubAgent('sub-process-1')]);
+
+      await useCase.run(runParams());
+
+      expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith({
+        idleSubAgents: [hungSubAgent('sub-process-1')],
+        longRunningSubAgents: [],
+      });
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(GITHUB_SESSION, SUBAGENT_SECTION);
+    });
+
+    it('keeps notifying a hung sub-agent on every cycle while the condition holds', async () => {
+      setupSubAgents([hungSubAgent('sub-process-1')]);
+
+      await useCase.run(runParams());
+      await useCase.run(runParams());
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledTimes(2);
+    });
+
+    it('announces a running-threshold crossing for a waiting sub-agent without any idle section', async () => {
+      setupSubAgents([
+        {
+          label: 'sub-process-1',
+          silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+          runningSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
+          waitingOnExternalProcess: true,
+        },
+      ]);
+
+      await useCase.run(runParams());
+
+      expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith({
+        idleSubAgents: [],
+        longRunningSubAgents: [
+          {
+            label: 'sub-process-1',
+            silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+            runningSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
+            waitingOnExternalProcess: true,
+          },
+        ],
+      });
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(GITHUB_SESSION, SUBAGENT_SECTION);
+    });
+
+    it('records the announced running label only after the notification is sent', async () => {
+      setupSubAgents([longRunningSubAgent('sub-process-1', false)]);
+
+      await useCase.run(runParams());
+
+      expect(
+        mockCandidateStateRepository.saveAnnouncedRunningSubAgentLabels,
+      ).toHaveBeenCalledWith({
+        sessionName: GITHUB_SESSION,
+        labels: ['sub-process-1'],
+        now,
+      });
+    });
+
+    it('does not record an announced running label when the first-cycle debounce defers the send', async () => {
+      setupSubAgents([longRunningSubAgent('sub-process-1', false)]);
+      mockCandidateStateRepository.loadRecentCandidateSessionNames.mockResolvedValue(
+        new Set<string>(),
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+      expect(
+        mockCandidateStateRepository.saveAnnouncedRunningSubAgentLabels,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('does not repeat the running announcement while the same label stays over the threshold', async () => {
+      setupSubAgents([longRunningSubAgent('sub-process-1', false)]);
+      mockCandidateStateRepository.loadAnnouncedRunningSubAgentLabels.mockResolvedValue(
+        new Set(['sub-process-1']),
+      );
+
+      await useCase.run(runParams());
+
+      expect(mockMessageComposer.composeSubAgentSection).not.toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('announces only the new label when another announced label is still over the threshold', async () => {
+      setupSubAgents([
+        longRunningSubAgent('sub-process-1', false),
+        longRunningSubAgent('sub-process-2', false),
+      ]);
+      mockCandidateStateRepository.loadAnnouncedRunningSubAgentLabels.mockResolvedValue(
+        new Set(['sub-process-1']),
+      );
+
+      await useCase.run(runParams());
+
+      expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith({
+        idleSubAgents: [],
+        longRunningSubAgents: [longRunningSubAgent('sub-process-2', false)],
+      });
+      expect(
+        mockCandidateStateRepository.saveAnnouncedRunningSubAgentLabels,
+      ).toHaveBeenCalledWith({
+        sessionName: GITHUB_SESSION,
+        labels: ['sub-process-1', 'sub-process-2'],
+        now,
+      });
+    });
+
+    it('clears the announced record when the label disappears from the sub-agent set', async () => {
+      setupSubAgents([]);
+      mockCandidateStateRepository.loadAnnouncedRunningSubAgentLabels.mockResolvedValue(
+        new Set(['sub-process-1']),
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockCandidateStateRepository.saveAnnouncedRunningSubAgentLabels,
+      ).toHaveBeenCalledWith({
+        sessionName: GITHUB_SESSION,
+        labels: [],
+        now,
+      });
+    });
+
+    it('announces exactly once per crossing across use-case instances sharing the persisted state', async () => {
+      setupSubAgents([longRunningSubAgent('sub-process-1', false)]);
+      const announcedLabelsBySessionName = new Map<string, string[]>();
+      mockCandidateStateRepository.loadAnnouncedRunningSubAgentLabels.mockImplementation(
+        async ({ sessionName }) =>
+          new Set(announcedLabelsBySessionName.get(sessionName) ?? []),
+      );
+      mockCandidateStateRepository.saveAnnouncedRunningSubAgentLabels.mockImplementation(
+        async ({ sessionName, labels }) => {
+          announcedLabelsBySessionName.set(sessionName, labels);
+        },
+      );
+
+      await useCase.run(runParams());
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledTimes(1);
+
+      const secondUseCase = new NotifySilentLiveSessionsUseCase(
+        mockSnapshotProvider,
+        mockTranscriptResolver,
+        mockSessionOutputActivityRepository,
+        mockSubAgentActivityRepository,
+        mockOwnerCallStatusProvider,
+        mockNotificationRepository,
+        mockCandidateStateRepository,
+        mockMessageComposer,
+        mockSleeper,
+        mockHubTaskStatusResolver,
+        mockHubTaskStatusCacheRepository,
+      );
+      await secondUseCase.run(
+        runParams({ now: new Date(now.getTime() + 60 * 1000) }),
+      );
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not touch the announced-label record for a main-only reminder', async () => {
+      setupSilentMainSession(GITHUB_SESSION);
+
+      await useCase.run(runParams());
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(GITHUB_SESSION, MAIN_STALLED_SECTION);
+      expect(
+        mockCandidateStateRepository.saveAnnouncedRunningSubAgentLabels,
+      ).not.toHaveBeenCalled();
+    });
+  });
+
   it('sends to multiple sessions sequentially with a stagger delay between sends', async () => {
     mockSnapshotProvider.getSnapshot.mockResolvedValue(
       snapshotWithSessions([GITHUB_SESSION_ALPHA, GITHUB_SESSION_BRAVO]),