github-issue-tower-defence-management 1.117.10 → 1.118.1

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

@@ -1,6 +1,11 @@
 import { DefaultSilentSessionMessageComposer } from './DefaultSilentSessionMessageComposer';
 import { SILENT_SESSION_REMINDER_SENTINEL } from './silentSessionReminderSentinel';
 
+const THRESHOLDS = {
+  subAgentSilentThresholdSeconds: 300,
+  subAgentRunningThresholdSeconds: 900,
+};
+
 describe('DefaultSilentSessionMessageComposer', () => {
   const composer = new DefaultSilentSessionMessageComposer();
 
@@ -10,9 +15,10 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('embeds the reminder sentinel in the sub-agent section', () => {
-    const section = composer.composeSubAgentSection([
-      { label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 },
-    ]);
+    const section = composer.composeSubAgentSection(
+      [{ label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 }],
+      THRESHOLDS,
+    );
     expect(section).toContain(SILENT_SESSION_REMINDER_SENTINEL);
   });
 
@@ -99,23 +105,93 @@ describe('DefaultSilentSessionMessageComposer', () => {
     expect(section).not.toContain('""');
   });
 
-  it('lists each sub-agent with its silent and running minutes', () => {
-    const section = composer.composeSubAgentSection([
-      { label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 },
-      { label: 'sub-process-2', silentSeconds: 0, runningSeconds: 960 },
-    ]);
-    expect(section).toContain('sub-process-1');
-    expect(section).toContain('silent for 6m');
+  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,
+    );
+    expect(section).toContain('sub-process-idle');
+    expect(section).toContain('no output for 6m');
+    expect(section).toContain('may be stalled');
+    expect(section).toContain('restart, hand off, or replace it');
+    expect(section).toContain('waiting on an external dependency');
+    expect(section).not.toContain('infinite loop');
+  });
+
+  it('emits a distinct long-running message for a sub-agent that has only run too long', () => {
+    const section = composer.composeSubAgentSection(
+      [
+        {
+          label: 'sub-process-long',
+          silentSeconds: 30,
+          runningSeconds: 1200,
+        },
+      ],
+      THRESHOLDS,
+    );
+    expect(section).toContain('sub-process-long');
     expect(section).toContain('running for 20m');
-    expect(section).toContain('sub-process-2');
-    expect(section).toContain('running for 16m');
+    expect(section).toContain('infinite loop');
+    expect(section).toContain('too large');
+    expect(section).toContain('not making forward progress');
+    expect(section).toContain(
+      'do not dismiss it merely because it produced output recently',
+    );
+    expect(section).toContain(
+      'break the task down, restart, hand off, or replace',
+    );
+  });
+
+  it('does not foreground the short idle time in the long-running message', () => {
+    const section = composer.composeSubAgentSection(
+      [
+        {
+          label: 'sub-process-long',
+          silentSeconds: 30,
+          runningSeconds: 1200,
+        },
+      ],
+      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,
+    );
+    expect(section).toContain('no output for 6m');
+    expect(section).toContain('may be stalled');
+    expect(section).toContain('running for 20m');
+    expect(section).toContain('infinite loop');
+    const sentinelOccurrences =
+      section.split(SILENT_SESSION_REMINDER_SENTINEL).length - 1;
+    expect(sentinelOccurrences).toBe(2);
+  });
+
+  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 },
+      ],
+      THRESHOLDS,
+    );
+    const [idleSection, longRunningSection] = section.split('\n\n');
+    expect(idleSection).toContain('idle-only');
+    expect(idleSection).not.toContain('long-only');
+    expect(longRunningSection).toContain('long-only');
+    expect(longRunningSection).not.toContain('idle-only');
   });
 
   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 },
-    ]);
+    const subSection = composer.composeSubAgentSection(
+      [{ label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 }],
+      THRESHOLDS,
+    );
     const combined = `${mainSection}\n${subSection}`.toLowerCase();
     expect(combined).not.toContain('claude');
     expect(combined).not.toContain('take ownership');

package/src/domain/usecases/DefaultSilentSessionMessageComposer.ts

@@ -1,5 +1,8 @@
 import { SubAgentActivity } from '../entities/LiveSessionActivitySnapshot';
-import { SilentSessionMessageComposer } from './adapter-interfaces/SilentSessionMessageComposer';
+import {
+  SilentSessionMessageComposer,
+  SubAgentStallThresholds,
+} from './adapter-interfaces/SilentSessionMessageComposer';
 import { SILENT_SESSION_REMINDER_SENTINEL } from './silentSessionReminderSentinel';
 
 const formatMinutes = (seconds: number): string => {
@@ -7,6 +10,38 @@ const formatMinutes = (seconds: number): string => {
   return `${minutes}m`;
 };
 
+const composeIdleSubAgentSection = (
+  idleSubAgents: SubAgentActivity[],
+): string => {
+  const lines = idleSubAgents.map(
+    (subAgent) =>
+      `- ${subAgent.label}: no output for ${formatMinutes(
+        subAgent.silentSeconds,
+      )}`,
+  );
+  return [
+    `${SILENT_SESSION_REMINDER_SENTINEL} The following sub-process(es) have produced no output for several minutes and may be stalled:`,
+    ...lines,
+    'Check each one. If it is stuck, take action (restart, hand off, or replace it). If it is legitimately waiting on an external dependency (continuous integration, an external API, or another process), let it continue.',
+  ].join('\n');
+};
+
+const composeLongRunningSubAgentSection = (
+  longRunningSubAgents: SubAgentActivity[],
+): string => {
+  const lines = longRunningSubAgents.map(
+    (subAgent) =>
+      `- ${subAgent.label}: running for ${formatMinutes(
+        subAgent.runningSeconds,
+      )}`,
+  );
+  return [
+    `${SILENT_SESSION_REMINDER_SENTINEL} The following sub-process(es) have been running longer than a task should normally take, which may mean an infinite loop, a task that is too large, or being stuck in an incorrect approach that is not making forward progress:`,
+    ...lines,
+    'Verify each one is genuinely advancing toward completion; do not dismiss it merely because it produced output recently. If it is not progressing, intervene: break the task down, restart, hand off, or replace it.',
+  ].join('\n');
+};
+
 const composeOwnerCallFormatGuidance = (
   ownerCallMarker: string | null,
 ): string => {
@@ -39,17 +74,25 @@ export class DefaultSilentSessionMessageComposer implements SilentSessionMessage
     return composeMainStalledMessage(mainSilentSeconds, this.ownerCallMarker);
   };
 
-  composeSubAgentSection = (subAgents: SubAgentActivity[]): string => {
-    const lines = subAgents.map(
+  composeSubAgentSection = (
+    subAgents: SubAgentActivity[],
+    thresholds: SubAgentStallThresholds,
+  ): string => {
+    const idleSubAgents = subAgents.filter(
+      (subAgent) =>
+        subAgent.silentSeconds >= thresholds.subAgentSilentThresholdSeconds,
+    );
+    const longRunningSubAgents = subAgents.filter(
       (subAgent) =>
-        `- ${subAgent.label}: silent for ${formatMinutes(
-          subAgent.silentSeconds,
-        )}, running for ${formatMinutes(subAgent.runningSeconds)}`,
+        subAgent.runningSeconds >= thresholds.subAgentRunningThresholdSeconds,
     );
-    return [
-      `${SILENT_SESSION_REMINDER_SENTINEL} The following sub-processes have been silent or running for a long time:`,
-      ...lines,
-      'If a sub-process is stalled, take action (restart, hand off, or replace it). If it is legitimately waiting on an external dependency (continuous integration, an external API, or another process), let it continue.',
-    ].join('\n');
+    const sections: string[] = [];
+    if (idleSubAgents.length > 0) {
+      sections.push(composeIdleSubAgentSection(idleSubAgents));
+    }
+    if (longRunningSubAgents.length > 0) {
+      sections.push(composeLongRunningSubAgentSection(longRunningSubAgents));
+    }
+    return sections.join('\n\n');
   };
 }

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

@@ -8,6 +8,7 @@ import {
   DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
   DEFAULT_NOTIFICATION_STAGGER_SECONDS,
   DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
+  DEFAULT_HUB_TASK_STATUS_CACHE_TTL_SECONDS,
 } from './NotifySilentLiveSessionsUseCase';
 import { Issue } from '../entities/Issue';
 import { LiveSessionProcessSnapshotProvider } from './adapter-interfaces/LiveSessionProcessSnapshotProvider';
@@ -17,6 +18,7 @@ import { SessionSubAgentActivityRepository } from './adapter-interfaces/SessionS
 import { OwnerCallStatusProvider } from './adapter-interfaces/OwnerCallStatusProvider';
 import { SilentSessionNotificationRepository } from './adapter-interfaces/SilentSessionNotificationRepository';
 import { SilentSessionCandidateStateRepository } from './adapter-interfaces/SilentSessionCandidateStateRepository';
+import { SilentSessionHubTaskStatusCacheRepository } from './adapter-interfaces/SilentSessionHubTaskStatusCacheRepository';
 import { SilentSessionMessageComposer } from './adapter-interfaces/SilentSessionMessageComposer';
 import { Sleeper } from './adapter-interfaces/Sleeper';
 import { SubAgentActivity } from '../entities/LiveSessionActivitySnapshot';
@@ -46,6 +48,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
   let mockMessageComposer: Mocked<SilentSessionMessageComposer>;
   let mockSleeper: Mocked<Sleeper>;
   let mockHubTaskStatusResolver: Mocked<HubTaskStatusResolver>;
+  let mockHubTaskStatusCacheRepository: Mocked<SilentSessionHubTaskStatusCacheRepository>;
   const now = new Date('2026-06-26T00:00:00Z');
   const nowEpochSeconds = Math.floor(now.getTime() / 1000);
   const GITHUB_SESSION = 'https_//github_com/HiromiShikata/repo/issues/42';
@@ -58,6 +61,8 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     overrides?: Partial<{
       activeHubTaskStatus: string | null;
       candidateDebounceRecencyWindowSeconds: number;
+      hubTaskStatusCacheTtlSeconds: number;
+      now: Date;
     }>,
   ): {
     mainSilentThresholdSeconds: number;
@@ -66,6 +71,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     staggerSeconds: number;
     candidateDebounceRecencyWindowSeconds: number;
     activeHubTaskStatus: string | null;
+    hubTaskStatusCacheTtlSeconds: number;
     now: Date;
   } => ({
     mainSilentThresholdSeconds: DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
@@ -75,6 +81,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     candidateDebounceRecencyWindowSeconds:
       DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
     activeHubTaskStatus: null,
+    hubTaskStatusCacheTtlSeconds: DEFAULT_HUB_TASK_STATUS_CACHE_TTL_SECONDS,
     now,
     ...overrides,
   });
@@ -165,6 +172,10 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     mockHubTaskStatusResolver = {
       getIssueByUrl: jest.fn().mockResolvedValue(null),
     };
+    mockHubTaskStatusCacheRepository = {
+      loadHubTaskStatus: jest.fn().mockResolvedValue(null),
+      saveHubTaskStatus: jest.fn().mockResolvedValue(undefined),
+    };
     useCase = new NotifySilentLiveSessionsUseCase(
       mockSnapshotProvider,
       mockTranscriptResolver,
@@ -176,6 +187,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       mockMessageComposer,
       mockSleeper,
       mockHubTaskStatusResolver,
+      mockHubTaskStatusCacheRepository,
     );
   });
 
@@ -446,12 +458,46 @@ describe('NotifySilentLiveSessionsUseCase', () => {
 
     expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith(
       subAgents,
+      {
+        subAgentSilentThresholdSeconds:
+          DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+        subAgentRunningThresholdSeconds:
+          DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
+      },
     );
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
     ).toHaveBeenCalledWith(GITHUB_SESSION, SUBAGENT_SECTION);
   });
 
+  it('passes a configured running threshold through to the sub-agent section composer', async () => {
+    setupLiveInteractiveSession(GITHUB_SESSION);
+    const subAgents: SubAgentActivity[] = [
+      {
+        label: 'sub-process-1',
+        silentSeconds: 10,
+        runningSeconds: 600,
+      },
+    ];
+    mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
+      new Map([[GITHUB_SESSION, subAgents]]),
+    );
+
+    await useCase.run({
+      ...runParams(),
+      subAgentRunningThresholdSeconds: 600,
+    });
+
+    expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalledWith(
+      subAgents,
+      {
+        subAgentSilentThresholdSeconds:
+          DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+        subAgentRunningThresholdSeconds: 600,
+      },
+    );
+  });
+
   it('excludes an owner-handover spawn from selection so no notification is sent', async () => {
     mockSnapshotProvider.getSnapshot.mockResolvedValue({
       sessions: [{ sessionName: 'aw-host', panePids: [100] }],
@@ -770,14 +816,11 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       warnSpy.mockRestore();
     });
 
-    it('fails open without a warning when the hub task is not a resolvable tracked task', async () => {
+    it('fails open with a distinct no-cache warning when the hub task is not a resolvable tracked task and no cached status exists', async () => {
       setupSilentMainSession(HUB_TASK_SESSION);
       const warnSpy = jest
         .spyOn(console, 'warn')
         .mockImplementation(() => undefined);
-      const logSpy = jest
-        .spyOn(console, 'log')
-        .mockImplementation(() => undefined);
       mockHubTaskStatusResolver.getIssueByUrl.mockResolvedValue(null);
 
       await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
@@ -785,9 +828,12 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       expect(
         mockNotificationRepository.sendSelfCheckNotification,
       ).toHaveBeenCalledWith(HUB_TASK_SESSION, MAIN_STALLED_SECTION);
-      expect(warnSpy).not.toHaveBeenCalled();
-      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('fail-open'));
-      logSpy.mockRestore();
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('no cached status'),
+      );
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('fail-open'),
+      );
       warnSpy.mockRestore();
     });
 
@@ -839,7 +885,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       ).not.toHaveBeenCalled();
     });
 
-    it('fails open without throwing or warning for a real tmux session-name form whose repository is unresolvable', async () => {
+    it('fails open without throwing for a real tmux session-name form whose repository is unresolvable and has no cached status', async () => {
       const REAL_TMUX_SESSION =
         'https_//github_com/example-org/example-repo/issues/2350';
       const CANONICAL_ISSUE_URL =
@@ -860,7 +906,204 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       expect(
         mockNotificationRepository.sendSelfCheckNotification,
       ).toHaveBeenCalledWith(REAL_TMUX_SESSION, MAIN_STALLED_SECTION);
-      expect(warnSpy).not.toHaveBeenCalled();
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('no cached status'),
+      );
+      warnSpy.mockRestore();
+    });
+
+    it('suppresses a resolved CLOSED hub task and writes the resolved status to the cache', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      mockHubTaskStatusResolver.getIssueByUrl.mockResolvedValue(
+        issueFor({
+          url: HUB_TASK_SESSION,
+          state: 'CLOSED',
+          status: ACTIVE_STATUS,
+          isClosed: true,
+        }),
+      );
+
+      await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+      expect(
+        mockHubTaskStatusCacheRepository.saveHubTaskStatus,
+      ).toHaveBeenCalledWith({
+        url: HUB_TASK_SESSION,
+        state: 'CLOSED',
+        status: ACTIVE_STATUS,
+        now,
+      });
+    });
+
+    it('suppresses a resolved Done (non-active project status) hub task', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      mockHubTaskStatusResolver.getIssueByUrl.mockResolvedValue(
+        issueFor({ url: HUB_TASK_SESSION, state: 'OPEN', status: 'Done' }),
+      );
+
+      await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('sends a resolved active hub task and writes its status to the cache', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      mockHubTaskStatusResolver.getIssueByUrl.mockResolvedValue(
+        issueFor({
+          url: HUB_TASK_SESSION,
+          state: 'OPEN',
+          status: ACTIVE_STATUS,
+        }),
+      );
+
+      await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(HUB_TASK_SESSION, MAIN_STALLED_SECTION);
+      expect(
+        mockHubTaskStatusCacheRepository.saveHubTaskStatus,
+      ).toHaveBeenCalledWith({
+        url: HUB_TASK_SESSION,
+        state: 'OPEN',
+        status: ACTIVE_STATUS,
+        now,
+      });
+    });
+
+    it('decides from a fresh cached entry without consulting the resolver', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      mockHubTaskStatusCacheRepository.loadHubTaskStatus.mockResolvedValue({
+        url: HUB_TASK_SESSION,
+        state: 'OPEN',
+        status: ACTIVE_STATUS,
+        recordedEpochSeconds: nowEpochSeconds - 60,
+      });
+
+      await useCase.run(
+        runParams({
+          activeHubTaskStatus: ACTIVE_STATUS,
+          hubTaskStatusCacheTtlSeconds: 300,
+        }),
+      );
+
+      expect(mockHubTaskStatusResolver.getIssueByUrl).not.toHaveBeenCalled();
+      expect(
+        mockHubTaskStatusCacheRepository.saveHubTaskStatus,
+      ).not.toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(HUB_TASK_SESSION, MAIN_STALLED_SECTION);
+    });
+
+    it('suppresses from a fresh cached closed entry without consulting the resolver', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      mockHubTaskStatusCacheRepository.loadHubTaskStatus.mockResolvedValue({
+        url: HUB_TASK_SESSION,
+        state: 'CLOSED',
+        status: ACTIVE_STATUS,
+        recordedEpochSeconds: nowEpochSeconds - 60,
+      });
+
+      await useCase.run(
+        runParams({
+          activeHubTaskStatus: ACTIVE_STATUS,
+          hubTaskStatusCacheTtlSeconds: 300,
+        }),
+      );
+
+      expect(mockHubTaskStatusResolver.getIssueByUrl).not.toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('re-resolves when the cached entry is older than the configured time-to-live', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      mockHubTaskStatusCacheRepository.loadHubTaskStatus.mockResolvedValue({
+        url: HUB_TASK_SESSION,
+        state: 'OPEN',
+        status: ACTIVE_STATUS,
+        recordedEpochSeconds: nowEpochSeconds - 600,
+      });
+      mockHubTaskStatusResolver.getIssueByUrl.mockResolvedValue(
+        issueFor({
+          url: HUB_TASK_SESSION,
+          state: 'OPEN',
+          status: ACTIVE_STATUS,
+        }),
+      );
+
+      await useCase.run(
+        runParams({
+          activeHubTaskStatus: ACTIVE_STATUS,
+          hubTaskStatusCacheTtlSeconds: 300,
+        }),
+      );
+
+      expect(mockHubTaskStatusResolver.getIssueByUrl).toHaveBeenCalledWith(
+        HUB_TASK_SESSION,
+      );
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(HUB_TASK_SESSION, MAIN_STALLED_SECTION);
+    });
+
+    it('falls back to an expired cached active entry and still sends when live resolution returns null', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      mockHubTaskStatusCacheRepository.loadHubTaskStatus.mockResolvedValue({
+        url: HUB_TASK_SESSION,
+        state: 'OPEN',
+        status: ACTIVE_STATUS,
+        recordedEpochSeconds: nowEpochSeconds - 600,
+      });
+      mockHubTaskStatusResolver.getIssueByUrl.mockResolvedValue(null);
+
+      await useCase.run(
+        runParams({
+          activeHubTaskStatus: ACTIVE_STATUS,
+          hubTaskStatusCacheTtlSeconds: 300,
+        }),
+      );
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(HUB_TASK_SESSION, MAIN_STALLED_SECTION);
+    });
+
+    it('falls back to an expired cached closed entry and suppresses when live resolution throws', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      const warnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => undefined);
+      mockHubTaskStatusCacheRepository.loadHubTaskStatus.mockResolvedValue({
+        url: HUB_TASK_SESSION,
+        state: 'CLOSED',
+        status: ACTIVE_STATUS,
+        recordedEpochSeconds: nowEpochSeconds - 600,
+      });
+      mockHubTaskStatusResolver.getIssueByUrl.mockRejectedValue(
+        new Error('GraphQL rate limit'),
+      );
+
+      await useCase.run(
+        runParams({
+          activeHubTaskStatus: ACTIVE_STATUS,
+          hubTaskStatusCacheTtlSeconds: 300,
+        }),
+      );
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('expired cached status'),
+      );
       warnSpy.mockRestore();
     });