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

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

@@ -1,11 +1,6 @@
 import { DefaultSilentSessionMessageComposer } from './DefaultSilentSessionMessageComposer';
 import { SILENT_SESSION_REMINDER_SENTINEL } from './silentSessionReminderSentinel';
 
-const THRESHOLDS = {
-  subAgentSilentThresholdSeconds: 300,
-  subAgentRunningThresholdSeconds: 900,
-};
-
 describe('DefaultSilentSessionMessageComposer', () => {
   const composer = new DefaultSilentSessionMessageComposer();
 
@@ -15,10 +10,16 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('embeds the reminder sentinel in the sub-agent section', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const subAgent = {
+      label: 'sub-process-1',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
     expect(section).toContain(SILENT_SESSION_REMINDER_SENTINEL);
   });
 
@@ -116,10 +117,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('emits a distinct idle message for a sub-agent that is only output-idle', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain('sub-process-idle');
     expect(section).toContain('no output for 6m');
     expect(section).toContain('restart, hand off, or replace it');
@@ -128,10 +136,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('presents the system-detected idle duration as the authoritative signal in the idle message', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain(
       "The system has already detected, from each sub-process's last tool activity, that it has produced no output for about the minutes shown below.",
     );
@@ -142,10 +157,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('forbids speculation and dismissal without evidence in the idle message', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain(
       'Around five minutes of silence is a real warning of a possible hang',
     );
@@ -155,10 +177,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('requires a concrete cause-check covering recent activity and external-dependency waiting in the idle message', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain('determine the CAUSE by a concrete check');
     expect(section).toContain(
       'a very recent push or commit, or output from any nested sub-processes this sub-process itself started',
@@ -175,26 +204,34 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('requires logging the investigation result even though owner notification is not required', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain(
       'Owner notification is not required, but you MUST output your investigation result in this session so it remains as a log.',
     );
   });
 
   it('emits a distinct long-running message for a sub-agent that has only run too long', () => {
-    const section = composer.composeSubAgentSection(
-      [
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [],
+      longRunningSubAgents: [
         {
           label: 'sub-process-long',
           silentSeconds: 30,
           runningSeconds: 1200,
+          waitingOnExternalProcess: false,
         },
       ],
-      THRESHOLDS,
-    );
+    });
     expect(section).toContain('sub-process-long');
     expect(section).toContain('running for 20m');
     expect(section).toContain('infinite loop');
@@ -209,25 +246,32 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('does not foreground the short idle time in the long-running message', () => {
-    const section = composer.composeSubAgentSection(
-      [
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [],
+      longRunningSubAgents: [
         {
           label: 'sub-process-long',
           silentSeconds: 30,
           runningSeconds: 1200,
+          waitingOnExternalProcess: false,
         },
       ],
-      THRESHOLDS,
-    );
+    });
     expect(section).not.toContain('no output for');
     expect(section).not.toContain('silent for');
   });
 
   it('emits both distinct messages for a sub-agent matching both conditions, kept separate', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-both', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const subAgent = {
+      label: 'sub-process-both',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
     expect(section).toContain('no output for 6m');
     expect(section).toContain('determine the CAUSE by a concrete check');
     expect(section).toContain('running for 20m');
@@ -238,13 +282,24 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('groups each sub-agent under the condition it matched', () => {
-    const section = composer.composeSubAgentSection(
-      [
-        { label: 'idle-only', silentSeconds: 360, runningSeconds: 60 },
-        { label: 'long-only', silentSeconds: 10, runningSeconds: 960 },
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'idle-only',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
       ],
-      THRESHOLDS,
-    );
+      longRunningSubAgents: [
+        {
+          label: 'long-only',
+          silentSeconds: 10,
+          runningSeconds: 960,
+          waitingOnExternalProcess: false,
+        },
+      ],
+    });
     const [idleSection, longRunningSection] = section.split('\n\n');
     expect(idleSection).toContain('idle-only');
     expect(idleSection).not.toContain('long-only');
@@ -254,10 +309,16 @@ describe('DefaultSilentSessionMessageComposer', () => {
 
   it('does not contain any host-specific or internal identifiers', () => {
     const mainSection = composer.composeMainStalledSection(600);
-    const subSection = composer.composeSubAgentSection(
-      [{ label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const subAgent = {
+      label: 'sub-process-1',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const subSection = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
     const combined = `${mainSection}\n${subSection}`.toLowerCase();
     expect(combined).not.toContain('claude');
     expect(combined).not.toContain('take ownership');

package/src/domain/usecases/DefaultSilentSessionMessageComposer.ts

@@ -1,7 +1,7 @@
 import { SubAgentActivity } from '../entities/LiveSessionActivitySnapshot';
 import {
   SilentSessionMessageComposer,
-  SubAgentStallThresholds,
+  SubAgentStallSections,
 } from './adapter-interfaces/SilentSessionMessageComposer';
 import { SILENT_SESSION_REMINDER_SENTINEL } from './silentSessionReminderSentinel';
 
@@ -74,24 +74,15 @@ export class DefaultSilentSessionMessageComposer implements SilentSessionMessage
     return composeMainStalledMessage(mainSilentSeconds, this.ownerCallMarker);
   };
 
-  composeSubAgentSection = (
-    subAgents: SubAgentActivity[],
-    thresholds: SubAgentStallThresholds,
-  ): string => {
-    const idleSubAgents = subAgents.filter(
-      (subAgent) =>
-        subAgent.silentSeconds >= thresholds.subAgentSilentThresholdSeconds,
-    );
-    const longRunningSubAgents = subAgents.filter(
-      (subAgent) =>
-        subAgent.runningSeconds >= thresholds.subAgentRunningThresholdSeconds,
-    );
+  composeSubAgentSection = (stallSections: SubAgentStallSections): string => {
     const sections: string[] = [];
-    if (idleSubAgents.length > 0) {
-      sections.push(composeIdleSubAgentSection(idleSubAgents));
+    if (stallSections.idleSubAgents.length > 0) {
+      sections.push(composeIdleSubAgentSection(stallSections.idleSubAgents));
     }
-    if (longRunningSubAgents.length > 0) {
-      sections.push(composeLongRunningSubAgentSection(longRunningSubAgents));
+    if (stallSections.longRunningSubAgents.length > 0) {
+      sections.push(
+        composeLongRunningSubAgentSection(stallSections.longRunningSubAgents),
+      );
     }
     return sections.join('\n\n');
   };

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

@@ -159,6 +159,12 @@ 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
@@ -448,6 +454,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
         label: 'sub-process-1',
         silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
         runningSeconds: 60,
+        waitingOnExternalProcess: false,
       },
     ];
     mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
@@ -456,27 +463,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 +491,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 +655,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]),