github-issue-tower-defence-management 1.122.10 → 1.122.12

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

@@ -388,6 +388,160 @@ describe('IssueRejectionEvaluator', () => {
       });
     });
 
+    describe('transient getOpenPullRequest failure containment', () => {
+      let warnSpy: jest.SpyInstance;
+
+      beforeEach(() => {
+        warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      });
+
+      afterEach(() => {
+        warnSpy.mockRestore();
+      });
+
+      it('should not throw and should return no rejections when getOpenPullRequest rejects for a PR item (isPr=true)', async () => {
+        mockIssueRepository.getOpenPullRequest.mockRejectedValue(
+          new Error(
+            'GraphQL errors: [{"message":"Something went wrong while executing your query"}]',
+          ),
+        );
+
+        const result = await evaluator.evaluate({
+          url: 'https://github.com/user/repo/pull/10',
+          labels: [],
+          isPr: true,
+        });
+
+        expect(result.rejections).toHaveLength(0);
+        expect(result.approvedPrUrl).toBeNull();
+      });
+
+      it('should log one warning line containing the PR URL and error message when getOpenPullRequest rejects for a PR item', async () => {
+        mockIssueRepository.getOpenPullRequest.mockRejectedValue(
+          new Error('Something went wrong while executing your query'),
+        );
+
+        await evaluator.evaluate({
+          url: 'https://github.com/user/repo/pull/10',
+          labels: [],
+          isPr: true,
+        });
+
+        expect(warnSpy).toHaveBeenCalledTimes(1);
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining('https://github.com/user/repo/pull/10'),
+        );
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining(
+            'Something went wrong while executing your query',
+          ),
+        );
+      });
+
+      it('should skip the failing URL, log a warning, and still evaluate the healthy PR in the same batch (prebuilt path)', async () => {
+        mockIssueRepository.getOpenPullRequest.mockImplementation(
+          (prUrl: string) =>
+            prUrl === 'https://github.com/user/repo/pull/8'
+              ? Promise.reject(
+                  new Error('Something went wrong while executing your query'),
+                )
+              : Promise.resolve(createReadyPr(prUrl)),
+        );
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+          },
+          [],
+          {
+            relatedOpenPrUrls: [
+              'https://github.com/user/repo/pull/8',
+              'https://github.com/user/repo/pull/9',
+            ],
+          },
+        );
+
+        expect(warnSpy).toHaveBeenCalledTimes(1);
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining('https://github.com/user/repo/pull/8'),
+        );
+        expect(result.rejections).toHaveLength(0);
+        expect(result.approvedPrUrl).toBe(
+          'https://github.com/user/repo/pull/9',
+        );
+      });
+
+      it('should not reject with PULL_REQUEST_NOT_FOUND when the only related URL fails transiently (state unknown, skipped)', async () => {
+        mockIssueRepository.getOpenPullRequest.mockRejectedValue(
+          new Error('Something went wrong while executing your query'),
+        );
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+          },
+          [],
+          { relatedOpenPrUrls: ['https://github.com/user/repo/pull/8'] },
+        );
+
+        expect(warnSpy).toHaveBeenCalledTimes(1);
+        expect(result.rejections).toHaveLength(0);
+        expect(result.approvedPrUrl).toBeNull();
+      });
+
+      it('should still evaluate the healthy remaining PR normally when it has a rejection reason (draft) after another URL fails', async () => {
+        mockIssueRepository.getOpenPullRequest.mockImplementation(
+          (prUrl: string) =>
+            prUrl === 'https://github.com/user/repo/pull/8'
+              ? Promise.reject(
+                  new Error('Something went wrong while executing your query'),
+                )
+              : Promise.resolve(createReadyPr(prUrl, { isDraft: true })),
+        );
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+          },
+          [],
+          {
+            relatedOpenPrUrls: [
+              'https://github.com/user/repo/pull/8',
+              'https://github.com/user/repo/pull/9',
+            ],
+          },
+        );
+
+        expect(result.rejections).toHaveLength(1);
+        expect(result.rejections[0].type).toBe('PULL_REQUEST_IS_DRAFT');
+        expect(result.approvedPrUrl).toBeNull();
+      });
+
+      it('should handle a non-Error rejection value without throwing', async () => {
+        mockIssueRepository.getOpenPullRequest.mockRejectedValue(
+          'string failure',
+        );
+
+        const result = await evaluator.evaluate({
+          url: 'https://github.com/user/repo/pull/10',
+          labels: [],
+          isPr: true,
+        });
+
+        expect(warnSpy).toHaveBeenCalledTimes(1);
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining('string failure'),
+        );
+        expect(result.rejections).toHaveLength(0);
+      });
+    });
+
     describe('change-target-must: label behavior', () => {
       const prUrl = 'https://github.com/user/repo/pull/1';
 

package/src/domain/usecases/IssueRejectionEvaluator.ts

@@ -67,17 +67,36 @@ export class IssueRejectionEvaluator {
       !hasLabelAsLlmAgentName &&
       (categoryLabels.length <= 0 || categoryLabels.includes('category:e2e'))
     ) {
-      const prsToCheck = issue.isPr
-        ? await this.resolveOpenPrsForPrItem(issue.url)
-        : options.relatedOpenPrUrls != null
-          ? await this.resolveOpenPrsFromUrls(options.relatedOpenPrUrls)
-          : await this.issueRepository.findRelatedOpenPRs(issue.url);
+      let prsToCheck: RelatedPullRequest[];
+      let anyPrResolutionFailed = false;
+      if (issue.isPr) {
+        const resolved = await this.resolveOpenPrsForPrItem(issue.url);
+        if (resolved === null) {
+          // getOpenPullRequest failed transiently: the PR's state is unknown
+          // for this cycle, so skip it without emitting any rejection.
+          return { rejections, approvedPrUrl };
+        }
+        prsToCheck = resolved;
+      } else if (options.relatedOpenPrUrls != null) {
+        const resolved = await this.resolveOpenPrsFromUrls(
+          options.relatedOpenPrUrls,
+        );
+        prsToCheck = resolved.prs;
+        anyPrResolutionFailed = resolved.anyResolutionFailed;
+      } else {
+        prsToCheck = await this.issueRepository.findRelatedOpenPRs(issue.url);
+      }
 
       if (prsToCheck.length <= 0) {
-        rejections.push({
-          type: 'PULL_REQUEST_NOT_FOUND',
-          detail: 'PULL_REQUEST_NOT_FOUND',
-        });
+        if (!anyPrResolutionFailed) {
+          rejections.push({
+            type: 'PULL_REQUEST_NOT_FOUND',
+            detail: 'PULL_REQUEST_NOT_FOUND',
+          });
+        }
+        // When a resolution failed and no PR resolved, the related PR state is
+        // unknown for this cycle; emit no rejection so a transient GraphQL
+        // error cannot cause a false PULL_REQUEST_NOT_FOUND revert.
       } else if (prsToCheck.length > 1) {
         rejections.push({
           type: 'MULTIPLE_PULL_REQUESTS_FOUND',
@@ -164,10 +183,21 @@ export class IssueRejectionEvaluator {
     return { rejections, approvedPrUrl };
   };
 
+  // Returns null when getOpenPullRequest throws (e.g. a transient GitHub
+  // GraphQL server error): the PR's state is unknown for this cycle and the
+  // caller skips it instead of letting the error abort the schedule cycle.
   private resolveOpenPrsForPrItem = async (
     prUrl: string,
-  ): Promise<RelatedPullRequest[]> => {
-    const pr = await this.issueRepository.getOpenPullRequest(prUrl);
+  ): Promise<RelatedPullRequest[] | null> => {
+    let pr: RelatedPullRequest | null;
+    try {
+      pr = await this.issueRepository.getOpenPullRequest(prUrl);
+    } catch (error) {
+      console.warn(
+        `IssueRejectionEvaluator: getOpenPullRequest failed, skipping PR for this cycle. prUrl: ${prUrl} error: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return null;
+    }
     if (pr === null) {
       return [];
     }
@@ -180,18 +210,34 @@ export class IssueRejectionEvaluator {
   // so the resulting set is equivalent while avoiding the per-issue timeline
   // query. Duplicate URLs are de-duplicated to mirror findRelatedOpenPRs, which
   // collapses duplicates via its internal Map keyed by PR URL.
+  //
+  // When getOpenPullRequest throws for a URL (e.g. a transient GitHub GraphQL
+  // server error), that PR is logged and skipped for this cycle while the
+  // remaining URLs are still resolved; anyResolutionFailed reports whether at
+  // least one URL failed so the caller can avoid treating an unknown state as
+  // PULL_REQUEST_NOT_FOUND.
   private resolveOpenPrsFromUrls = async (
     prUrls: string[],
-  ): Promise<RelatedPullRequest[]> => {
+  ): Promise<{ prs: RelatedPullRequest[]; anyResolutionFailed: boolean }> => {
     const uniquePrUrls = Array.from(new Set(prUrls));
     const resolvedPrs: RelatedPullRequest[] = [];
+    let anyResolutionFailed = false;
     for (const prUrl of uniquePrUrls) {
-      const pr = await this.issueRepository.getOpenPullRequest(prUrl);
+      let pr: RelatedPullRequest | null;
+      try {
+        pr = await this.issueRepository.getOpenPullRequest(prUrl);
+      } catch (error) {
+        console.warn(
+          `IssueRejectionEvaluator: getOpenPullRequest failed, skipping PR for this cycle. prUrl: ${prUrl} error: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        anyResolutionFailed = true;
+        continue;
+      }
       if (pr !== null) {
         resolvedPrs.push(pr);
       }
     }
-    return resolvedPrs;
+    return { prs: resolvedPrs, anyResolutionFailed };
   };
 
   private extractChangeTargetMustPaths = (labels: string[]): string[] => {

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

@@ -167,12 +167,6 @@ 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
@@ -573,7 +567,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     const subAgents: SubAgentActivity[] = [
       {
         label: 'sub-process-1',
-        silentSeconds: 10,
+        silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
         runningSeconds: 600,
         waitingOnExternalProcess: false,
       },
@@ -588,11 +582,33 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     });
 
     expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith({
-      idleSubAgents: [],
+      idleSubAgents: subAgents,
       longRunningSubAgents: subAgents,
     });
   });
 
+  it('suppresses the long-running section for a sub-agent that produced output recently even past the running threshold', async () => {
+    setupLiveInteractiveSession(GITHUB_SESSION);
+    const subAgents: SubAgentActivity[] = [
+      {
+        label: 'sub-process-1',
+        silentSeconds: 10,
+        runningSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
+        waitingOnExternalProcess: false,
+      },
+    ];
+    mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
+      new Map([[GITHUB_SESSION, subAgents]]),
+    );
+
+    await useCase.run(runParams());
+
+    expect(mockMessageComposer.composeSubAgentSection).not.toHaveBeenCalled();
+    expect(
+      mockNotificationRepository.sendSelfCheckNotification,
+    ).not.toHaveBeenCalled();
+  });
+
   it('excludes an owner-handover spawn from selection so no notification is sent', async () => {
     mockSnapshotProvider.getSnapshot.mockResolvedValue({
       sessions: [{ sessionName: 'aw-host', panePids: [100] }],
@@ -764,15 +780,21 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       runningSeconds: 60,
       waitingOnExternalProcess: true,
     });
-    const longRunningSubAgent = (
+    const quietLongRunningSubAgent = (
       label: string,
       waitingOnExternalProcess: boolean,
     ): SubAgentActivity => ({
       label,
-      silentSeconds: 30,
+      silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
       runningSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
       waitingOnExternalProcess,
     });
+    const producingLongRunningSubAgent = (label: string): SubAgentActivity => ({
+      label,
+      silentSeconds: 30,
+      runningSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
+      waitingOnExternalProcess: false,
+    });
 
     const setupSubAgents = (subAgents: SubAgentActivity[]): void => {
       setupLiveInteractiveSession(GITHUB_SESSION);
@@ -817,69 +839,19 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       ).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>(),
-      );
+    it('never selects a waiting sub-agent for the long-running section even when quiet past both thresholds', async () => {
+      setupSubAgents([quietLongRunningSubAgent('sub-process-1', true)]);
 
       await useCase.run(runParams());
 
+      expect(mockMessageComposer.composeSubAgentSection).not.toHaveBeenCalled();
       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']),
-      );
+    it('never selects a long-running sub-agent that produced output within the silent threshold', async () => {
+      setupSubAgents([producingLongRunningSubAgent('sub-process-1')]);
 
       await useCase.run(runParams());
 
@@ -889,98 +861,73 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       ).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']),
-      );
+    it('includes a quiet long-running sub-agent in both the idle and long-running sections', async () => {
+      setupSubAgents([quietLongRunningSubAgent('sub-process-1', false)]);
 
       await useCase.run(runParams());
 
       expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith({
-        idleSubAgents: [],
-        longRunningSubAgents: [longRunningSubAgent('sub-process-2', false)],
+        idleSubAgents: [quietLongRunningSubAgent('sub-process-1', false)],
+        longRunningSubAgents: [
+          quietLongRunningSubAgent('sub-process-1', false),
+        ],
       });
       expect(
-        mockCandidateStateRepository.saveAnnouncedRunningSubAgentLabels,
-      ).toHaveBeenCalledWith({
-        sessionName: GITHUB_SESSION,
-        labels: ['sub-process-1', 'sub-process-2'],
-        now,
-      });
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(GITHUB_SESSION, SUBAGENT_SECTION);
     });
 
-    it('clears the announced record when the label disappears from the sub-agent set', async () => {
-      setupSubAgents([]);
-      mockCandidateStateRepository.loadAnnouncedRunningSubAgentLabels.mockResolvedValue(
-        new Set(['sub-process-1']),
-      );
+    it('keeps notifying a quiet long-running sub-agent on every cycle while the condition holds', async () => {
+      setupSubAgents([quietLongRunningSubAgent('sub-process-1', false)]);
 
+      await useCase.run(runParams());
       await useCase.run(runParams());
 
       expect(
-        mockCandidateStateRepository.saveAnnouncedRunningSubAgentLabels,
-      ).toHaveBeenCalledWith({
-        sessionName: GITHUB_SESSION,
-        labels: [],
-        now,
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledTimes(2);
+      expect(
+        mockMessageComposer.composeSubAgentSection,
+      ).toHaveBeenNthCalledWith(2, {
+        idleSubAgents: [quietLongRunningSubAgent('sub-process-1', false)],
+        longRunningSubAgents: [
+          quietLongRunningSubAgent('sub-process-1', false),
+        ],
       });
     });
 
-    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);
-        },
+    it('defers a first-cycle long-running candidate until it persists into the next cycle', async () => {
+      setupSubAgents([quietLongRunningSubAgent('sub-process-1', false)]);
+      mockCandidateStateRepository.loadRecentCandidateSessionNames.mockResolvedValue(
+        new Set<string>(),
       );
 
       await useCase.run(runParams());
+
       expect(
         mockNotificationRepository.sendSelfCheckNotification,
-      ).toHaveBeenCalledTimes(1);
+      ).not.toHaveBeenCalled();
+      expect(
+        mockCandidateStateRepository.saveCandidateSessionNames,
+      ).toHaveBeenCalledWith({ sessionNames: [GITHUB_SESSION], now });
+    });
 
-      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) }),
-      );
+    it('stops notifying once the long-running sub-agent drops out of the activity snapshot', async () => {
+      setupSubAgents([quietLongRunningSubAgent('sub-process-1', false)]);
 
+      await useCase.run(runParams());
       expect(
         mockNotificationRepository.sendSelfCheckNotification,
       ).toHaveBeenCalledTimes(1);
-    });
-
-    it('does not touch the announced-label record for a main-only reminder', async () => {
-      setupSilentMainSession(GITHUB_SESSION);
 
+      mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
+        new Map<string, SubAgentActivity[]>(),
+      );
       await useCase.run(runParams());
 
       expect(
         mockNotificationRepository.sendSelfCheckNotification,
-      ).toHaveBeenCalledWith(GITHUB_SESSION, MAIN_STALLED_SECTION);
-      expect(
-        mockCandidateStateRepository.saveAnnouncedRunningSubAgentLabels,
-      ).not.toHaveBeenCalled();
+      ).toHaveBeenCalledTimes(1);
     });
   });
 

package/src/domain/usecases/NotifySilentLiveSessionsUseCase.ts

@@ -60,8 +60,6 @@ export type HubTaskStatusResolver = Pick<IssueRepository, 'getIssueByUrl'>;
 type NotifyCandidate = {
   sessionName: string;
   message: string;
-  newlyAnnouncedRunningLabels: string[];
-  retainedAnnouncedRunningLabels: string[];
 };
 
 export class NotifySilentLiveSessionsUseCase {
@@ -144,7 +142,7 @@ export class NotifySilentLiveSessionsUseCase {
 
     const candidates: NotifyCandidate[] = [];
     for (const sessionSnapshot of snapshots) {
-      const candidate = await this.composeCandidate(sessionSnapshot, params);
+      const candidate = this.composeCandidate(sessionSnapshot, params);
       if (candidate !== null) {
         candidates.push(candidate);
       }
@@ -198,16 +196,6 @@ export class NotifySilentLiveSessionsUseCase {
       );
       sentCount += 1;
       console.log(`Notified ${candidate.sessionName}.`);
-      if (candidate.newlyAnnouncedRunningLabels.length > 0) {
-        await this.candidateStateRepository.saveAnnouncedRunningSubAgentLabels({
-          sessionName: candidate.sessionName,
-          labels: [
-            ...candidate.retainedAnnouncedRunningLabels,
-            ...candidate.newlyAnnouncedRunningLabels,
-          ],
-          now: params.now,
-        });
-      }
     }
   };
 
@@ -381,7 +369,7 @@ export class NotifySilentLiveSessionsUseCase {
     });
   };
 
-  private composeCandidate = async (
+  private composeCandidate = (
     snapshot: LiveSessionActivitySnapshot,
     thresholds: {
       mainSilentThresholdSeconds: number;
@@ -390,7 +378,7 @@ export class NotifySilentLiveSessionsUseCase {
       subAgentRunningThresholdSeconds: number;
       now: Date;
     },
-  ): Promise<NotifyCandidate | null> => {
+  ): NotifyCandidate | null => {
     const sections: string[] = [];
 
     const mainSilentSeconds = snapshot.mainSilentSeconds;
@@ -421,20 +409,24 @@ export class NotifySilentLiveSessionsUseCase {
         !subAgent.waitingOnExternalProcess &&
         subAgent.silentSeconds >= thresholds.subAgentSilentThresholdSeconds,
     );
+    // The long-running advisory is gated on output recency, mirroring the
+    // idle branch: a sub-agent that produced output recently is working, no
+    // matter how long it has been running, so it is never selected. Only a
+    // sub-agent that is BOTH long-running and quiet (and not waiting on a
+    // live external process) qualifies, and it is re-selected on EVERY cycle
+    // while the condition holds — there is intentionally no fire-once state
+    // and no time-window suppression, matching the idle-branch semantics.
     const longRunningSubAgents = snapshot.subAgents.filter(
       (subAgent) =>
-        subAgent.runningSeconds >= thresholds.subAgentRunningThresholdSeconds,
-    );
-    const retainedAnnouncedRunningLabels =
-      await this.reconcileAnnouncedRunningLabels(snapshot, thresholds.now);
-    const newlyLongRunningSubAgents = longRunningSubAgents.filter(
-      (subAgent) => !retainedAnnouncedRunningLabels.includes(subAgent.label),
+        !subAgent.waitingOnExternalProcess &&
+        subAgent.runningSeconds >= thresholds.subAgentRunningThresholdSeconds &&
+        subAgent.silentSeconds >= thresholds.subAgentSilentThresholdSeconds,
     );
-    if (idleSubAgents.length > 0 || newlyLongRunningSubAgents.length > 0) {
+    if (idleSubAgents.length > 0 || longRunningSubAgents.length > 0) {
       sections.push(
         this.messageComposer.composeSubAgentSection({
           idleSubAgents,
-          longRunningSubAgents: newlyLongRunningSubAgents,
+          longRunningSubAgents,
         }),
       );
     }
@@ -445,34 +437,6 @@ export class NotifySilentLiveSessionsUseCase {
     return {
       sessionName: snapshot.sessionName,
       message: sections.join('\n\n'),
-      newlyAnnouncedRunningLabels: newlyLongRunningSubAgents.map(
-        (subAgent) => subAgent.label,
-      ),
-      retainedAnnouncedRunningLabels,
     };
   };
-
-  private reconcileAnnouncedRunningLabels = async (
-    snapshot: LiveSessionActivitySnapshot,
-    now: Date,
-  ): Promise<string[]> => {
-    const announcedLabels =
-      await this.candidateStateRepository.loadAnnouncedRunningSubAgentLabels({
-        sessionName: snapshot.sessionName,
-      });
-    const currentLabels = new Set(
-      snapshot.subAgents.map((subAgent) => subAgent.label),
-    );
-    const retainedLabels = Array.from(announcedLabels).filter((label) =>
-      currentLabels.has(label),
-    );
-    if (retainedLabels.length !== announcedLabels.size) {
-      await this.candidateStateRepository.saveAnnouncedRunningSubAgentLabels({
-        sessionName: snapshot.sessionName,
-        labels: retainedLabels,
-        now,
-      });
-    }
-    return retainedLabels;
-  };
 }