github-issue-tower-defence-management 1.138.0 → 1.139.1

package/src/adapter/repositories/TranscriptSessionSubAgentActivityRepository.ts

@@ -2,9 +2,14 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnapshot';
 import { SessionSubAgentActivityRepository } from '../../domain/usecases/adapter-interfaces/SessionSubAgentActivityRepository';
+import { SubAgentLivenessResolver } from '../../domain/usecases/adapter-interfaces/SubAgentLivenessResolver';
 import { SubAgentProcessLister } from '../../domain/usecases/adapter-interfaces/SubAgentProcessLister';
 import { SubAgentTranscriptDirectoryResolver } from '../../domain/usecases/adapter-interfaces/SubAgentTranscriptDirectoryResolver';
 
+const alwaysIndeterminateLivenessResolver: SubAgentLivenessResolver = {
+  resolveLiveSubAgentIds: async () => null,
+};
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null;
 
@@ -190,7 +195,14 @@ const parseTranscript = (content: string): ParsedTranscript => {
 
 const clampToZero = (value: number): number => (value > 0 ? value : 0);
 
-const parseKilledOrFailedAgentIds = (content: string): Set<string> => {
+const TERMINAL_TASK_NOTIFICATION_STATUSES = new Set([
+  'completed',
+  'killed',
+  'failed',
+  'stopped',
+]);
+
+const parseTerminalAgentIds = (content: string): Set<string> => {
   const result = new Set<string>();
   for (const line of content.split('\n')) {
     const trimmed = line.trim();
@@ -216,13 +228,16 @@ const parseKilledOrFailedAgentIds = (content: string): Set<string> => {
     if (notifContent === null) {
       continue;
     }
-    const taskIdMatch = notifContent.match(/<task-id>(a[0-9a-f]+)<\/task-id>/);
     const statusMatch = notifContent.match(/<status>([^<]+)<\/status>/);
-    if (!taskIdMatch || !statusMatch) {
+    if (statusMatch === null) {
       continue;
     }
-    const status = statusMatch[1];
-    if (status === 'killed' || status === 'failed') {
+    if (!TERMINAL_TASK_NOTIFICATION_STATUSES.has(statusMatch[1])) {
+      continue;
+    }
+    for (const taskIdMatch of notifContent.matchAll(
+      /<task-id>(a[0-9a-f]+)<\/task-id>/g,
+    )) {
       result.add(taskIdMatch[1]);
     }
   }
@@ -234,6 +249,7 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
     private readonly directoryResolver: SubAgentTranscriptDirectoryResolver,
     private readonly processLister: SubAgentProcessLister,
     private readonly now: Date,
+    private readonly livenessResolver: SubAgentLivenessResolver = alwaysIndeterminateLivenessResolver,
   ) {}
 
   listSubAgentActivitiesBySessionName = async (
@@ -262,12 +278,17 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
       if (directory === null) {
         continue;
       }
-      const killedOrFailedAgentIds =
-        this.loadKilledOrFailedAgentIds(mainTranscriptPath);
+      const terminalAgentIds = this.loadTerminalAgentIds(mainTranscriptPath);
+      const liveSubAgentIds =
+        await this.livenessResolver.resolveLiveSubAgentIds({
+          sessionName,
+          mainTranscriptPath,
+        });
       const activities = await this.collectActivities(
         directory,
         nowEpochSeconds,
-        killedOrFailedAgentIds,
+        terminalAgentIds,
+        liveSubAgentIds,
         loadNormalizedProcessCommandLines,
       );
       if (activities.length > 0) {
@@ -277,7 +298,7 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
     return result;
   };
 
-  private loadKilledOrFailedAgentIds = (
+  private loadTerminalAgentIds = (
     mainTranscriptPath: string | null,
   ): Set<string> => {
     if (mainTranscriptPath === null) {
@@ -289,13 +310,14 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
     } catch {
       return new Set();
     }
-    return parseKilledOrFailedAgentIds(content);
+    return parseTerminalAgentIds(content);
   };
 
   private collectActivities = async (
     directory: string,
     nowEpochSeconds: number,
-    killedOrFailedAgentIds: Set<string>,
+    terminalAgentIds: Set<string>,
+    liveSubAgentIds: Set<string> | null,
     loadNormalizedProcessCommandLines: () => Promise<string[]>,
   ): Promise<SubAgentActivity[]> => {
     let entries: fs.Dirent[];
@@ -311,7 +333,10 @@ export class TranscriptSessionSubAgentActivityRepository implements SessionSubAg
         continue;
       }
       const agentId = fileName.slice('agent-'.length, -'.jsonl'.length);
-      if (killedOrFailedAgentIds.has(agentId)) {
+      if (terminalAgentIds.has(agentId)) {
+        continue;
+      }
+      if (liveSubAgentIds !== null && !liveSubAgentIds.has(agentId)) {
         continue;
       }
       const filePath = path.join(directory, fileName);

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

@@ -21,6 +21,7 @@ import { OwnerCallStatusProvider } from './adapter-interfaces/OwnerCallStatusPro
 import { RefusalTailStatusProvider } from './adapter-interfaces/RefusalTailStatusProvider';
 import { SilentSessionNotificationRepository } from './adapter-interfaces/SilentSessionNotificationRepository';
 import { SilentSessionCandidateStateRepository } from './adapter-interfaces/SilentSessionCandidateStateRepository';
+import { SilentSessionNotifiedStateRepository } from './adapter-interfaces/SilentSessionNotifiedStateRepository';
 import { SilentSessionHubTaskStatusCacheRepository } from './adapter-interfaces/SilentSessionHubTaskStatusCacheRepository';
 import { SilentSessionMessageComposer } from './adapter-interfaces/SilentSessionMessageComposer';
 import { Sleeper } from './adapter-interfaces/Sleeper';
@@ -50,6 +51,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
   let mockOwnerCallStatusProvider: Mocked<OwnerCallStatusProvider>;
   let mockNotificationRepository: Mocked<SilentSessionNotificationRepository>;
   let mockCandidateStateRepository: Mocked<SilentSessionCandidateStateRepository>;
+  let mockNotifiedStateRepository: Mocked<SilentSessionNotifiedStateRepository>;
   let mockMessageComposer: Mocked<SilentSessionMessageComposer>;
   let mockSleeper: Mocked<Sleeper>;
   let mockHubTaskStatusResolver: Mocked<HubTaskStatusResolver>;
@@ -169,6 +171,12 @@ describe('NotifySilentLiveSessionsUseCase', () => {
         .mockResolvedValue(everyNameRecentSet()),
       saveCandidateSessionNames: jest.fn().mockResolvedValue(undefined),
     };
+    mockNotifiedStateRepository = {
+      loadRecentNotifiedSessionNames: jest
+        .fn()
+        .mockResolvedValue(new Set<string>()),
+      saveNotifiedSessionNames: jest.fn().mockResolvedValue(undefined),
+    };
     mockMessageComposer = {
       composeMainStalledSection: jest
         .fn()
@@ -201,6 +209,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       mockOwnerCallStatusProvider,
       mockNotificationRepository,
       mockCandidateStateRepository,
+      mockNotifiedStateRepository,
       mockMessageComposer,
       mockSleeper,
       mockHubTaskStatusResolver,
@@ -209,6 +218,20 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     );
   });
 
+  // Simulates the on-disk fire-once latch across the per-cycle fresh monitor
+  // process: load returns the currently persisted set, save overwrites it.
+  const wireStatefulNotifiedLatch = (): void => {
+    let persistedNotifiedSessionNames = new Set<string>();
+    mockNotifiedStateRepository.loadRecentNotifiedSessionNames.mockImplementation(
+      async () => new Set(persistedNotifiedSessionNames),
+    );
+    mockNotifiedStateRepository.saveNotifiedSessionNames.mockImplementation(
+      async ({ sessionNames }) => {
+        persistedNotifiedSessionNames = new Set(sessionNames);
+      },
+    );
+  };
+
   const issueFor = (overrides: Partial<Issue>): Issue => ({
     nameWithOwner: 'HiromiShikata/repo',
     number: 42,
@@ -706,7 +729,8 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     ).not.toHaveBeenCalled();
   });
 
-  it('re-notifies a persistent stall on every cycle once it has been a candidate in the previous cycle', async () => {
+  it('notifies a persistent stall only once per silent episode instead of every cycle', async () => {
+    wireStatefulNotifiedLatch();
     setupLiveInteractiveSession(GITHUB_SESSION);
     mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
       [
@@ -719,18 +743,60 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       ],
     );
 
+    await useCase.run(runParams());
     await useCase.run(runParams());
     await useCase.run(runParams());
 
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
-    ).toHaveBeenCalledTimes(2);
+    ).toHaveBeenCalledTimes(1);
+    expect(
+      mockNotificationRepository.sendSelfCheckNotification,
+    ).toHaveBeenCalledWith(GITHUB_SESSION, MAIN_STALLED_SECTION);
+  });
+
+  it('re-notifies a session after its silent episode resolves and a new one begins', async () => {
+    wireStatefulNotifiedLatch();
+    setupLiveInteractiveSession(GITHUB_SESSION);
+    const stalled = [
+      {
+        sessionName: GITHUB_SESSION,
+        lastOutputEpochSeconds:
+          nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+        hasInProgressToolCall: false,
+      },
+    ];
+    const active = [
+      {
+        sessionName: GITHUB_SESSION,
+        lastOutputEpochSeconds: nowEpochSeconds,
+        hasInProgressToolCall: false,
+      },
+    ];
+
+    mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+      stalled,
+    );
+    await useCase.run(runParams());
+    expect(
+      mockNotificationRepository.sendSelfCheckNotification,
+    ).toHaveBeenCalledTimes(1);
+
+    mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+      active,
+    );
+    await useCase.run(runParams());
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
-    ).toHaveBeenNthCalledWith(1, GITHUB_SESSION, MAIN_STALLED_SECTION);
+    ).toHaveBeenCalledTimes(1);
+
+    mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+      stalled,
+    );
+    await useCase.run(runParams());
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
-    ).toHaveBeenNthCalledWith(2, GITHUB_SESSION, MAIN_STALLED_SECTION);
+    ).toHaveBeenCalledTimes(2);
   });
 
   describe('two-consecutive-cycle debounce', () => {
@@ -832,6 +898,147 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     });
   });
 
+  describe('fire-once latch and input-state gating', () => {
+    const setupSilentGithubSession = (): void => {
+      setupLiveInteractiveSession(GITHUB_SESSION);
+      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+        [
+          {
+            sessionName: GITHUB_SESSION,
+            lastOutputEpochSeconds:
+              nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+            hasInProgressToolCall: false,
+          },
+        ],
+      );
+    };
+
+    const idleSubAgent = (label: string): SubAgentActivity => ({
+      label,
+      silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+      runningSeconds: 60,
+      waitingOnExternalProcess: false,
+    });
+
+    it('loads the fire-once latch using the configured recency window', async () => {
+      setupSilentGithubSession();
+
+      await useCase.run(
+        runParams({ candidateDebounceRecencyWindowSeconds: 900 }),
+      );
+
+      expect(
+        mockNotifiedStateRepository.loadRecentNotifiedSessionNames,
+      ).toHaveBeenCalledWith({ now, recencyWindowSeconds: 900 });
+    });
+
+    it('persists the sent session in the fire-once latch on a send cycle', async () => {
+      setupSilentGithubSession();
+
+      await useCase.run(runParams());
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(GITHUB_SESSION, MAIN_STALLED_SECTION);
+      expect(
+        mockNotifiedStateRepository.saveNotifiedSessionNames,
+      ).toHaveBeenCalledWith({ sessionNames: [GITHUB_SESSION], now });
+    });
+
+    it('does not re-send but keeps the latch for a session already notified this episode', async () => {
+      setupSilentGithubSession();
+      mockNotifiedStateRepository.loadRecentNotifiedSessionNames.mockResolvedValue(
+        new Set([GITHUB_SESSION]),
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+      expect(
+        mockNotifiedStateRepository.saveNotifiedSessionNames,
+      ).toHaveBeenCalledWith({ sessionNames: [GITHUB_SESSION], now });
+    });
+
+    it('prunes the fire-once latch for a previously notified session that is no longer a candidate', async () => {
+      mockNotifiedStateRepository.loadRecentNotifiedSessionNames.mockResolvedValue(
+        new Set([GITHUB_SESSION]),
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockNotifiedStateRepository.saveNotifiedSessionNames,
+      ).toHaveBeenCalledWith({ sessionNames: [], now });
+    });
+
+    it('does not inject into a session whose main REPL has an in-progress tool call even when a sub-agent advisory qualifies', async () => {
+      setupLiveInteractiveSession(GITHUB_SESSION);
+      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+        [
+          {
+            sessionName: GITHUB_SESSION,
+            lastOutputEpochSeconds: nowEpochSeconds,
+            hasInProgressToolCall: true,
+          },
+        ],
+      );
+      mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
+        new Map([[GITHUB_SESSION, [idleSubAgent('sub-process-1')]]]),
+      );
+
+      await useCase.run(runParams());
+
+      expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+      expect(
+        mockNotifiedStateRepository.saveNotifiedSessionNames,
+      ).toHaveBeenCalledWith({ sessionNames: [], now });
+    });
+
+    it('delivers the deferred reminder once the main REPL becomes input-ready', async () => {
+      wireStatefulNotifiedLatch();
+      setupLiveInteractiveSession(GITHUB_SESSION);
+      mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
+        new Map([[GITHUB_SESSION, [idleSubAgent('sub-process-1')]]]),
+      );
+
+      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+        [
+          {
+            sessionName: GITHUB_SESSION,
+            lastOutputEpochSeconds: nowEpochSeconds,
+            hasInProgressToolCall: true,
+          },
+        ],
+      );
+      await useCase.run(runParams());
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+
+      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+        [
+          {
+            sessionName: GITHUB_SESSION,
+            lastOutputEpochSeconds: nowEpochSeconds,
+            hasInProgressToolCall: false,
+          },
+        ],
+      );
+      await useCase.run(runParams());
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledTimes(1);
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(GITHUB_SESSION, SUBAGENT_SECTION);
+    });
+  });
+
   describe('sub-agent state-based reminder judgment', () => {
     const hungSubAgent = (label: string): SubAgentActivity => ({
       label,
@@ -893,7 +1100,8 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       ).toHaveBeenCalledWith(GITHUB_SESSION, SUBAGENT_SECTION);
     });
 
-    it('keeps notifying a hung sub-agent on every cycle while the condition holds', async () => {
+    it('notifies a hung sub-agent only once per episode instead of every cycle', async () => {
+      wireStatefulNotifiedLatch();
       setupSubAgents([hungSubAgent('sub-process-1')]);
 
       await useCase.run(runParams());
@@ -901,7 +1109,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
 
       expect(
         mockNotificationRepository.sendSelfCheckNotification,
-      ).toHaveBeenCalledTimes(2);
+      ).toHaveBeenCalledTimes(1);
     });
 
     it('never selects a waiting sub-agent for the long-running section even when quiet past both thresholds', async () => {
@@ -942,7 +1150,8 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       ).toHaveBeenCalledWith(GITHUB_SESSION, SUBAGENT_SECTION);
     });
 
-    it('keeps notifying a quiet long-running sub-agent on every cycle while the condition holds', async () => {
+    it('notifies a quiet long-running sub-agent only once per episode while still evaluating it every cycle', async () => {
+      wireStatefulNotifiedLatch();
       setupSubAgents([quietLongRunningSubAgent('sub-process-1', false)]);
 
       await useCase.run(runParams());
@@ -950,7 +1159,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
 
       expect(
         mockNotificationRepository.sendSelfCheckNotification,
-      ).toHaveBeenCalledTimes(2);
+      ).toHaveBeenCalledTimes(1);
       expect(
         mockMessageComposer.composeSubAgentSection,
       ).toHaveBeenNthCalledWith(2, {
@@ -1626,6 +1835,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
         mockOwnerCallStatusProvider,
         mockNotificationRepository,
         mockCandidateStateRepository,
+        mockNotifiedStateRepository,
         mockMessageComposer,
         mockSleeper,
         mockHubTaskStatusResolver,

package/src/domain/usecases/NotifySilentLiveSessionsUseCase.ts

@@ -9,6 +9,7 @@ import { SessionSubAgentActivityRepository } from './adapter-interfaces/SessionS
 import { SilentSessionMessageComposer } from './adapter-interfaces/SilentSessionMessageComposer';
 import { SilentSessionNotificationRepository } from './adapter-interfaces/SilentSessionNotificationRepository';
 import { SilentSessionCandidateStateRepository } from './adapter-interfaces/SilentSessionCandidateStateRepository';
+import { SilentSessionNotifiedStateRepository } from './adapter-interfaces/SilentSessionNotifiedStateRepository';
 import { SilentSessionHubTaskStatusCacheRepository } from './adapter-interfaces/SilentSessionHubTaskStatusCacheRepository';
 import { Sleeper } from './adapter-interfaces/Sleeper';
 import { IssueRepository } from './adapter-interfaces/IssueRepository';
@@ -70,6 +71,7 @@ type NotifyCandidate = {
   sessionName: string;
   message: string;
   sectionLabels: string[];
+  mainInputBusy: boolean;
 };
 
 export class NotifySilentLiveSessionsUseCase {
@@ -84,6 +86,7 @@ export class NotifySilentLiveSessionsUseCase {
     private readonly ownerCallStatusProvider: OwnerCallStatusProvider,
     private readonly notificationRepository: SilentSessionNotificationRepository,
     private readonly candidateStateRepository: SilentSessionCandidateStateRepository,
+    private readonly notifiedStateRepository: SilentSessionNotifiedStateRepository,
     private readonly messageComposer: SilentSessionMessageComposer,
     private readonly sleeper: Sleeper,
     private readonly hubTaskStatusResolver: HubTaskStatusResolver | null = null,
@@ -185,8 +188,44 @@ export class NotifySilentLiveSessionsUseCase {
       `Silent live session notification: ${debouncedCandidates.length} debounced candidate(s) of ${candidates.length} current candidate(s) across ${interactiveSessions.length} interactive session(s); ${suppressedFirstCycleCount} first-cycle candidate(s) deferred until they persist into the next cycle.`,
     );
 
+    // Fire-once latch: the set of sessions already reminded during their
+    // current silent episode. A session that is still a candidate this cycle
+    // and was already reminded is NOT re-injected, so a continuous silent
+    // episode produces exactly one reminder instead of one every schedule
+    // cycle. The latch is keyed by the globally-unique session name and
+    // persisted across the per-cycle fresh monitor process on disk.
+    const currentCandidateSessionNames = new Set(
+      candidates.map((candidate) => candidate.sessionName),
+    );
+    const previouslyNotifiedSessionNames =
+      await this.notifiedStateRepository.loadRecentNotifiedSessionNames({
+        now: params.now,
+        recencyWindowSeconds: params.candidateDebounceRecencyWindowSeconds,
+      });
+
     let sentCount = 0;
+    const notifiedThisCycleSessionNames: string[] = [];
     for (const candidate of debouncedCandidates) {
+      if (previouslyNotifiedSessionNames.has(candidate.sessionName)) {
+        console.log(
+          `Skipping ${candidate.sessionName}: the current silent-episode reminder was already delivered; not re-injecting until the condition resolves and re-arises.`,
+        );
+        continue;
+      }
+      // Input-state gating: a session whose main REPL is mid-turn — currently
+      // running an in-progress tool call, which includes waiting on a
+      // long-running sub-agent — cannot accept an injected prompt cleanly, so
+      // the reminder is deferred rather than piled into a busy input box. The
+      // session stays a candidate, so it is reminded once it becomes
+      // input-ready. A tool call pending past
+      // IN_PROGRESS_TOOL_CALL_MAX_SUPPRESS_SECONDS is treated as hung and no
+      // longer counts as busy (see composeCandidate).
+      if (candidate.mainInputBusy) {
+        console.log(
+          `Skipping ${candidate.sessionName}: main REPL is not in an input-accepting state (in-progress tool call); deferring reminder until it is idle.`,
+        );
+        continue;
+      }
       if (
         !(await this.isHubTaskActive(
           candidate.sessionName,
@@ -205,6 +244,7 @@ export class NotifySilentLiveSessionsUseCase {
         candidate.message,
       );
       sentCount += 1;
+      notifiedThisCycleSessionNames.push(candidate.sessionName);
       // One line per send, grep-stable on the `Notified ` prefix: the
       // ISO-8601 UTC timestamp disambiguates concurrent schedule runs and
       // the section list records what the message actually contained.
@@ -212,6 +252,25 @@ export class NotifySilentLiveSessionsUseCase {
         `Notified ${candidate.sessionName} at=${params.now.toISOString()} sections=[${candidate.sectionLabels.join(',')}]`,
       );
     }
+
+    // Persist the latch for the next cycle: keep every already-latched session
+    // that is STILL a candidate (refreshing its timestamp so a continuous
+    // episode stays latched) plus the sessions notified this cycle, and prune
+    // any latched session that is no longer a candidate so its episode ends and
+    // a later re-qualification fires a fresh reminder.
+    const retainedNotifiedSessionNames = [
+      ...previouslyNotifiedSessionNames,
+    ].filter((sessionName) => currentCandidateSessionNames.has(sessionName));
+    const notifiedSessionNamesToPersist = Array.from(
+      new Set([
+        ...retainedNotifiedSessionNames,
+        ...notifiedThisCycleSessionNames,
+      ]),
+    );
+    await this.notifiedStateRepository.saveNotifiedSessionNames({
+      sessionNames: notifiedSessionNamesToPersist,
+      now: params.now,
+    });
   };
 
   private isHubTaskActive = async (
@@ -488,6 +547,7 @@ export class NotifySilentLiveSessionsUseCase {
       sessionName: snapshot.sessionName,
       message: sections.join('\n\n'),
       sectionLabels,
+      mainInputBusy: suppressedByInProgressToolCall,
     };
   };
 }

package/src/domain/usecases/adapter-interfaces/SilentSessionNotifiedStateRepository.ts

@@ -0,0 +1,10 @@
+export interface SilentSessionNotifiedStateRepository {
+  loadRecentNotifiedSessionNames: (params: {
+    now: Date;
+    recencyWindowSeconds: number;
+  }) => Promise<Set<string>>;
+  saveNotifiedSessionNames: (params: {
+    sessionNames: string[];
+    now: Date;
+  }) => Promise<void>;
+}

package/src/domain/usecases/adapter-interfaces/SubAgentLivenessResolver.ts

@@ -0,0 +1,6 @@
+export interface SubAgentLivenessResolver {
+  resolveLiveSubAgentIds: (params: {
+    sessionName: string;
+    mainTranscriptPath: string | null;
+  }) => Promise<Set<string> | null>;
+}

package/types/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAkCA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAkD3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,EACjB,6BAA4B,MAAM,EAAE,GAAG,IAAW,KACjD,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CAylBP;CACH"}
+{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAoCA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAkD3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,EACjB,6BAA4B,MAAM,EAAE,GAAG,IAAW,KACjD,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CAumBP;CACH"}

package/types/adapter/entry-points/handlers/notifySilentTmuxSessions.d.ts

@@ -10,6 +10,7 @@ export type NotifySilentTmuxSessionsParams = {
     subAgentOutputRootDirectory: string | null;
     subAgentProcessMatchPattern: string | null;
     subAgentTranscriptRootDirectory: string | null;
+    subAgentRuntimeRootDirectory: string | null;
     mainSilentThresholdSeconds: number;
     unansweredOwnerCallGraceSeconds: number;
     subAgentSilentThresholdSeconds: number;
@@ -17,6 +18,7 @@ export type NotifySilentTmuxSessionsParams = {
     staggerSeconds: number;
     candidateDebounceRecencyWindowSeconds: number;
     candidateDebounceStateFilePath: string | null;
+    notifiedStateFilePath: string | null;
     activeHubTaskStatus: string | null;
     hubTaskStatusResolver: HubTaskStatusResolver | null;
     hubTaskStatusCacheStateFilePath: string | null;

package/types/adapter/entry-points/handlers/notifySilentTmuxSessions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notifySilentTmuxSessions.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/notifySilentTmuxSessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gEAAgE,CAAC;AAGpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,kEAAkE,CAAC;AACxG,OAAO,EAEL,qBAAqB,EAQtB,MAAM,0DAA0D,CAAC;AAelE,OAAO,EAEL,6BAA6B,EAC9B,MAAM,6DAA6D,CAAC;AAKrE,MAAM,MAAM,8BAA8B,GAAG;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,0BAA0B,EAAE,MAAM,CAAC;IACnC,+BAA+B,EAAE,MAAM,CAAC;IACxC,8BAA8B,EAAE,MAAM,CAAC;IACvC,+BAA+B,EAAE,MAAM,CAAC;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,qCAAqC,EAAE,MAAM,CAAC;IAC9C,8BAA8B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,qBAAqB,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACpD,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,4BAA4B,EAAE,MAAM,CAAC;IACrC,gBAAgB,EAAE,6BAA6B,CAAC;IAChD,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AAqCF,eAAO,MAAM,wBAAwB,GACnC,QAAQ,8BAA8B,KACrC,OAAO,CAAC,IAAI,CA2Ed,CAAC;AAEF,eAAO,MAAM,0CAA0C;;;;;;;;CAS7C,CAAC"}
+{"version":3,"file":"notifySilentTmuxSessions.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/notifySilentTmuxSessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gEAAgE,CAAC;AAGpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,kEAAkE,CAAC;AACxG,OAAO,EAEL,qBAAqB,EAQtB,MAAM,0DAA0D,CAAC;AAgBlE,OAAO,EAEL,6BAA6B,EAC9B,MAAM,6DAA6D,CAAC;AAMrE,MAAM,MAAM,8BAA8B,GAAG;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,4BAA4B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,0BAA0B,EAAE,MAAM,CAAC;IACnC,+BAA+B,EAAE,MAAM,CAAC;IACxC,8BAA8B,EAAE,MAAM,CAAC;IACvC,+BAA+B,EAAE,MAAM,CAAC;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,qCAAqC,EAAE,MAAM,CAAC;IAC9C,8BAA8B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,qBAAqB,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACpD,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,4BAA4B,EAAE,MAAM,CAAC;IACrC,gBAAgB,EAAE,6BAA6B,CAAC;IAChD,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AAuCF,eAAO,MAAM,wBAAwB,GACnC,QAAQ,8BAA8B,KACrC,OAAO,CAAC,IAAI,CAmFd,CAAC;AAEF,eAAO,MAAM,0CAA0C;;;;;;;;CAS7C,CAAC"}

package/types/adapter/repositories/FileSystemSilentSessionNotifiedStateRepository.d.ts

@@ -0,0 +1,16 @@
+import { SilentSessionNotifiedStateRepository } from '../../domain/usecases/adapter-interfaces/SilentSessionNotifiedStateRepository';
+export declare class FileSystemSilentSessionNotifiedStateRepository implements SilentSessionNotifiedStateRepository {
+    private readonly stateFilePath;
+    constructor(stateFilePath?: string);
+    loadRecentNotifiedSessionNames: (params: {
+        now: Date;
+        recencyWindowSeconds: number;
+    }) => Promise<Set<string>>;
+    saveNotifiedSessionNames: (params: {
+        sessionNames: string[];
+        now: Date;
+    }) => Promise<void>;
+    private readNotifiedEntries;
+    private writeState;
+}
+//# sourceMappingURL=FileSystemSilentSessionNotifiedStateRepository.d.ts.map

package/types/adapter/repositories/FileSystemSilentSessionNotifiedStateRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystemSilentSessionNotifiedStateRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/FileSystemSilentSessionNotifiedStateRepository.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oCAAoC,EAAE,MAAM,+EAA+E,CAAC;AAuBrI,qBAAa,8CAA+C,YAAW,oCAAoC;IAEvG,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,GAAE,MAA+B;IAGjE,8BAA8B,GAAU,QAAQ;QAC9C,GAAG,EAAE,IAAI,CAAC;QACV,oBAAoB,EAAE,MAAM,CAAC;KAC9B,KAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAWtB;IAEF,wBAAwB,GAAU,QAAQ;QACxC,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,GAAG,EAAE,IAAI,CAAC;KACX,KAAG,OAAO,CAAC,IAAI,CAAC,CAUf;IAEF,OAAO,CAAC,mBAAmB,CAoCzB;IAEF,OAAO,CAAC,UAAU,CAMhB;CACH"}

package/types/adapter/repositories/FileSystemSubAgentLivenessResolver.d.ts

@@ -0,0 +1,11 @@
+import { SubAgentLivenessResolver } from '../../domain/usecases/adapter-interfaces/SubAgentLivenessResolver';
+export declare class FileSystemSubAgentLivenessResolver implements SubAgentLivenessResolver {
+    private readonly runtimeRootDirectory;
+    constructor(runtimeRootDirectory: string | null);
+    resolveLiveSubAgentIds: (params: {
+        sessionName: string;
+        mainTranscriptPath: string | null;
+    }) => Promise<Set<string> | null>;
+    private resolveRunningSubAgentsFilePath;
+}
+//# sourceMappingURL=FileSystemSubAgentLivenessResolver.d.ts.map

package/types/adapter/repositories/FileSystemSubAgentLivenessResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystemSubAgentLivenessResolver.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/FileSystemSubAgentLivenessResolver.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAE,MAAM,mEAAmE,CAAC;AAI7G,qBAAa,kCAAmC,YAAW,wBAAwB;IACrE,OAAO,CAAC,QAAQ,CAAC,oBAAoB;gBAApB,oBAAoB,EAAE,MAAM,GAAG,IAAI;IAEhE,sBAAsB,GAAU,QAAQ;QACtC,WAAW,EAAE,MAAM,CAAC;QACpB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;KACnC,KAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAqB7B;IAEF,OAAO,CAAC,+BAA+B,CAoBrC;CACH"}

package/types/adapter/repositories/TmuxSilentSessionNotificationRepository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TmuxSilentSessionNotificationRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/TmuxSilentSessionNotificationRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mCAAmC,EAAE,MAAM,8EAA8E,CAAC;AACnI,OAAO,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAC;AAEjG,qBAAa,uCAAwC,YAAW,mCAAmC;IACrF,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,kBAAkB;IAEnE,yBAAyB,GACvB,aAAa,MAAM,EACnB,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAAC,CA4Bd;CACH"}
+{"version":3,"file":"TmuxSilentSessionNotificationRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/TmuxSilentSessionNotificationRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mCAAmC,EAAE,MAAM,8EAA8E,CAAC;AACnI,OAAO,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAC;AAKjG,qBAAa,uCAAwC,YAAW,mCAAmC;IACrF,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,kBAAkB;IAEnE,yBAAyB,GACvB,aAAa,MAAM,EACnB,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAAC,CA6Bd;CACH"}

package/types/adapter/repositories/TranscriptSessionSubAgentActivityRepository.d.ts

@@ -1,5 +1,6 @@
 import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnapshot';
 import { SessionSubAgentActivityRepository } from '../../domain/usecases/adapter-interfaces/SessionSubAgentActivityRepository';
+import { SubAgentLivenessResolver } from '../../domain/usecases/adapter-interfaces/SubAgentLivenessResolver';
 import { SubAgentProcessLister } from '../../domain/usecases/adapter-interfaces/SubAgentProcessLister';
 import { SubAgentTranscriptDirectoryResolver } from '../../domain/usecases/adapter-interfaces/SubAgentTranscriptDirectoryResolver';
 export declare const normalizeCommandFragment: (command: string) => string;
@@ -7,9 +8,10 @@ export declare class TranscriptSessionSubAgentActivityRepository implements Sess
     private readonly directoryResolver;
     private readonly processLister;
     private readonly now;
-    constructor(directoryResolver: SubAgentTranscriptDirectoryResolver, processLister: SubAgentProcessLister, now: Date);
+    private readonly livenessResolver;
+    constructor(directoryResolver: SubAgentTranscriptDirectoryResolver, processLister: SubAgentProcessLister, now: Date, livenessResolver?: SubAgentLivenessResolver);
     listSubAgentActivitiesBySessionName: (sessionNames: string[], transcriptPathBySessionName: Map<string, string>) => Promise<Map<string, SubAgentActivity[]>>;
-    private loadKilledOrFailedAgentIds;
+    private loadTerminalAgentIds;
     private collectActivities;
     private toActivity;
     private hasLiveMatchingProcess;