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

package/src/adapter/repositories/ConfigurableSilentSessionMessageComposer.test.ts

@@ -4,18 +4,17 @@ import { SILENT_SESSION_REMINDER_SENTINEL } from '../../domain/usecases/silentSe
 
 type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
 
-const THRESHOLDS = {
-  subAgentSilentThresholdSeconds: 300,
-  subAgentRunningThresholdSeconds: 900,
-};
-
 const createFallback = (): Mocked<SilentSessionMessageComposer> => ({
   composeMainStalledSection: jest.fn().mockReturnValue('FALLBACK_MAIN'),
+  composeMainStalledWithStaleOwnerCallSection: jest
+    .fn()
+    .mockReturnValue('FALLBACK_STALE_OWNER_CALL'),
   composeSubAgentSection: jest.fn().mockReturnValue('FALLBACK_SUB'),
 });
 
 const noTemplates = {
   mainStalledMessage: null,
+  mainStalledStaleOwnerCallMessage: null,
   subAgentIdleMessageHeader: null,
   subAgentIdleMessageFooter: null,
   subAgentLongRunningMessageHeader: null,
@@ -72,22 +71,66 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
     );
   });
 
+  it('uses the fallback stale-owner-call section when no stale-owner-call template is configured', () => {
+    const fallback = createFallback();
+    const composer = new ConfigurableSilentSessionMessageComposer(
+      noTemplates,
+      fallback,
+    );
+    expect(
+      composer.composeMainStalledWithStaleOwnerCallSection(600, 3600),
+    ).toBe('FALLBACK_STALE_OWNER_CALL');
+    expect(
+      fallback.composeMainStalledWithStaleOwnerCallSection,
+    ).toHaveBeenCalledWith(600, 3600);
+  });
+
+  it('uses the configured stale-owner-call template when provided', () => {
+    const fallback = createFallback();
+    const composer = new ConfigurableSilentSessionMessageComposer(
+      {
+        ...noTemplates,
+        mainStalledStaleOwnerCallMessage: 'CUSTOM_STALE_OWNER_CALL',
+      },
+      fallback,
+      '<<OWNER_CALL>>',
+    );
+    const section = composer.composeMainStalledWithStaleOwnerCallSection(
+      600,
+      3600,
+    );
+    expect(section).toContain('CUSTOM_STALE_OWNER_CALL');
+    expect(section).toContain(SILENT_SESSION_REMINDER_SENTINEL);
+    expect(section).toContain(
+      'the configured owner-call marker tag "<<OWNER_CALL>>" as a complete matching pair',
+    );
+    expect(
+      fallback.composeMainStalledWithStaleOwnerCallSection,
+    ).not.toHaveBeenCalled();
+  });
+
   it('uses the fallback sub-agent section when no sub-agent template is configured', () => {
     const fallback = createFallback();
     const composer = new ConfigurableSilentSessionMessageComposer(
       noTemplates,
       fallback,
     );
+    const subAgent = {
+      label: 'task-a',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
     expect(
-      composer.composeSubAgentSection(
-        [{ label: 'task-a', silentSeconds: 360, runningSeconds: 1200 }],
-        THRESHOLDS,
-      ),
+      composer.composeSubAgentSection({
+        idleSubAgents: [subAgent],
+        longRunningSubAgents: [subAgent],
+      }),
     ).toBe('FALLBACK_SUB');
-    expect(fallback.composeSubAgentSection).toHaveBeenCalledWith(
-      [{ label: 'task-a', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    expect(fallback.composeSubAgentSection).toHaveBeenCalledWith({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
   });
 
   it('renders the configured idle header, list, and footer for an idle sub-agent', () => {
@@ -100,10 +143,17 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
       },
       fallback,
     );
-    const section = composer.composeSubAgentSection(
-      [{ label: 'task-a', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'task-a',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain('IDLE_HEADER');
     expect(section).toContain('task-a');
     expect(section).toContain('no output for 6m');
@@ -122,10 +172,17 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
       },
       fallback,
     );
-    const section = composer.composeSubAgentSection(
-      [{ label: 'task-b', silentSeconds: 30, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [],
+      longRunningSubAgents: [
+        {
+          label: 'task-b',
+          silentSeconds: 30,
+          runningSeconds: 1200,
+          waitingOnExternalProcess: false,
+        },
+      ],
+    });
     expect(section).toContain('LONG_HEADER');
     expect(section).toContain('task-b');
     expect(section).toContain('running for 20m');
@@ -144,10 +201,16 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
       },
       fallback,
     );
-    const section = composer.composeSubAgentSection(
-      [{ label: 'task-both', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const subAgent = {
+      label: 'task-both',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
     const [idleSection, longRunningSection] = section
       .replace(`${SILENT_SESSION_REMINDER_SENTINEL} `, '')
       .split('\n\n');
@@ -167,19 +230,21 @@ describe('ConfigurableSilentSessionMessageComposer', () => {
       },
       fallback,
     );
-    const section = composer.composeSubAgentSection(
-      [{ label: 'task-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const idleSubAgent = {
+      label: 'task-idle',
+      silentSeconds: 360,
+      runningSeconds: 60,
+      waitingOnExternalProcess: false,
+    };
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [idleSubAgent],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain('BUILTIN_IDLE');
-    expect(fallback.composeSubAgentSection).toHaveBeenCalledWith(
-      [{ label: 'task-idle', silentSeconds: 360, runningSeconds: 60 }],
-      {
-        subAgentSilentThresholdSeconds:
-          THRESHOLDS.subAgentSilentThresholdSeconds,
-        subAgentRunningThresholdSeconds: Number.POSITIVE_INFINITY,
-      },
-    );
+    expect(fallback.composeSubAgentSection).toHaveBeenCalledWith({
+      idleSubAgents: [idleSubAgent],
+      longRunningSubAgents: [],
+    });
   });
 
   it('does not double-prepend the sentinel when the template already carries it', () => {

package/src/adapter/repositories/ConfigurableSilentSessionMessageComposer.ts

@@ -2,7 +2,7 @@ import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnaps
 import { composeOwnerCallFormatGuidance } from '../../domain/usecases/DefaultSilentSessionMessageComposer';
 import {
   SilentSessionMessageComposer,
-  SubAgentStallThresholds,
+  SubAgentStallSections,
 } from '../../domain/usecases/adapter-interfaces/SilentSessionMessageComposer';
 import { SILENT_SESSION_REMINDER_SENTINEL } from '../../domain/usecases/silentSessionReminderSentinel';
 
@@ -13,6 +13,7 @@ const withReminderSentinel = (message: string): string =>
 
 export type SilentSessionMessageTemplates = {
   mainStalledMessage: string | null;
+  mainStalledStaleOwnerCallMessage: string | null;
   subAgentIdleMessageHeader: string | null;
   subAgentIdleMessageFooter: string | null;
   subAgentLongRunningMessageHeader: string | null;
@@ -40,10 +41,22 @@ export class ConfigurableSilentSessionMessageComposer implements SilentSessionMe
     );
   };
 
-  composeSubAgentSection = (
-    subAgents: SubAgentActivity[],
-    thresholds: SubAgentStallThresholds,
+  composeMainStalledWithStaleOwnerCallSection = (
+    mainSilentSeconds: number,
+    unansweredOwnerCallAgeSeconds: number,
   ): string => {
+    if (this.templates.mainStalledStaleOwnerCallMessage === null) {
+      return this.fallback.composeMainStalledWithStaleOwnerCallSection(
+        mainSilentSeconds,
+        unansweredOwnerCallAgeSeconds,
+      );
+    }
+    return withReminderSentinel(
+      `${this.templates.mainStalledStaleOwnerCallMessage} ${composeOwnerCallFormatGuidance(this.ownerCallMarker)}`,
+    );
+  };
+
+  composeSubAgentSection = (stallSections: SubAgentStallSections): string => {
     const hasIdleTemplate =
       this.templates.subAgentIdleMessageHeader !== null ||
       this.templates.subAgentIdleMessageFooter !== null;
@@ -51,17 +64,10 @@ export class ConfigurableSilentSessionMessageComposer implements SilentSessionMe
       this.templates.subAgentLongRunningMessageHeader !== null ||
       this.templates.subAgentLongRunningMessageFooter !== null;
     if (!hasIdleTemplate && !hasLongRunningTemplate) {
-      return this.fallback.composeSubAgentSection(subAgents, thresholds);
+      return this.fallback.composeSubAgentSection(stallSections);
     }
 
-    const idleSubAgents = subAgents.filter(
-      (subAgent) =>
-        subAgent.silentSeconds >= thresholds.subAgentSilentThresholdSeconds,
-    );
-    const longRunningSubAgents = subAgents.filter(
-      (subAgent) =>
-        subAgent.runningSeconds >= thresholds.subAgentRunningThresholdSeconds,
-    );
+    const { idleSubAgents, longRunningSubAgents } = stallSections;
 
     const sections: string[] = [];
     if (idleSubAgents.length > 0 && hasIdleTemplate) {
@@ -74,10 +80,9 @@ export class ConfigurableSilentSessionMessageComposer implements SilentSessionMe
       );
     } else if (idleSubAgents.length > 0) {
       sections.push(
-        this.fallback.composeSubAgentSection(idleSubAgents, {
-          subAgentSilentThresholdSeconds:
-            thresholds.subAgentSilentThresholdSeconds,
-          subAgentRunningThresholdSeconds: Number.POSITIVE_INFINITY,
+        this.fallback.composeSubAgentSection({
+          idleSubAgents,
+          longRunningSubAgents: [],
         }),
       );
     }

package/src/adapter/repositories/FileSystemInteractiveLiveSessionTranscriptResolver.test.ts

@@ -506,7 +506,7 @@ describe('parent transcript resolution feeding owner-call detection', () => {
     ]);
 
     return ownerCallStatusProvider
-      .listSessionNamesWithUnansweredOwnerCall(transcriptPaths)
+      .listUnansweredOwnerCallEpochSecondsBySessionName(transcriptPaths)
       .then((waiting) => {
         expect(waiting.has('waiting')).toBe(true);
       });

package/src/adapter/repositories/FileSystemSilentSessionCandidateStateRepository.test.ts

@@ -3,6 +3,7 @@ import * as os from 'os';
 import * as path from 'path';
 import {
   DEFAULT_STATE_RETENTION_WINDOW_SECONDS,
+  ANNOUNCED_RUNNING_RETENTION_WINDOW_SECONDS,
   FileSystemSilentSessionCandidateStateRepository,
 } from './FileSystemSilentSessionCandidateStateRepository';
 
@@ -141,6 +142,7 @@ describe('FileSystemSilentSessionCandidateStateRepository', () => {
           recordedEpochSeconds: Math.floor(secondSaveAt.getTime() / 1000),
         },
       ],
+      announcedRunningSubAgents: [],
     });
   });
 
@@ -198,4 +200,225 @@ describe('FileSystemSilentSessionCandidateStateRepository', () => {
   it('exposes the default retention window as a named constant', () => {
     expect(DEFAULT_STATE_RETENTION_WINDOW_SECONDS).toBe(60 * 60);
   });
+
+  describe('announced running sub-agent labels', () => {
+    it('round-trips saved announced labels so the next cycle reads them back', async () => {
+      const repository = new FileSystemSilentSessionCandidateStateRepository(
+        stateFilePath,
+      );
+
+      await repository.saveAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+        labels: ['sub-process-1', 'sub-process-2'],
+        now: new Date('2026-06-26T00:00:00Z'),
+      });
+      const loaded = await repository.loadAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+      });
+
+      expect(loaded).toEqual(new Set(['sub-process-1', 'sub-process-2']));
+    });
+
+    it('returns an empty set when no announcement has been recorded for the session', async () => {
+      const repository = new FileSystemSilentSessionCandidateStateRepository(
+        stateFilePath,
+      );
+
+      const loaded = await repository.loadAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+      });
+
+      expect(loaded).toEqual(new Set<string>());
+    });
+
+    it('replaces the previous announced labels of the same session', async () => {
+      const repository = new FileSystemSilentSessionCandidateStateRepository(
+        stateFilePath,
+      );
+
+      await repository.saveAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+        labels: ['sub-process-1'],
+        now: new Date('2026-06-26T00:00:00Z'),
+      });
+      await repository.saveAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+        labels: ['sub-process-2'],
+        now: new Date('2026-06-26T00:01:00Z'),
+      });
+      const loaded = await repository.loadAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+      });
+
+      expect(loaded).toEqual(new Set(['sub-process-2']));
+    });
+
+    it('removes the stored entry when saving an empty label set', async () => {
+      const repository = new FileSystemSilentSessionCandidateStateRepository(
+        stateFilePath,
+      );
+
+      await repository.saveAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+        labels: ['sub-process-1'],
+        now: new Date('2026-06-26T00:00:00Z'),
+      });
+      await repository.saveAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+        labels: [],
+        now: new Date('2026-06-26T00:01:00Z'),
+      });
+
+      expect(
+        await repository.loadAnnouncedRunningSubAgentLabels({
+          sessionName: sessionAlpha,
+        }),
+      ).toEqual(new Set<string>());
+      const persisted: unknown = JSON.parse(
+        fs.readFileSync(stateFilePath, 'utf8'),
+      );
+      expect(persisted).toEqual({
+        candidates: [],
+        announcedRunningSubAgents: [],
+      });
+    });
+
+    it('keeps the announced labels of another session when saving', async () => {
+      const repository = new FileSystemSilentSessionCandidateStateRepository(
+        stateFilePath,
+      );
+      const at = new Date('2026-06-26T00:00:00Z');
+
+      await repository.saveAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+        labels: ['sub-process-1'],
+        now: at,
+      });
+      await repository.saveAnnouncedRunningSubAgentLabels({
+        sessionName: sessionBravo,
+        labels: ['sub-process-2'],
+        now: at,
+      });
+
+      expect(
+        await repository.loadAnnouncedRunningSubAgentLabels({
+          sessionName: sessionAlpha,
+        }),
+      ).toEqual(new Set(['sub-process-1']));
+      expect(
+        await repository.loadAnnouncedRunningSubAgentLabels({
+          sessionName: sessionBravo,
+        }),
+      ).toEqual(new Set(['sub-process-2']));
+    });
+
+    it('drops an announced entry that has aged beyond the retention window on the next save', async () => {
+      const repository = new FileSystemSilentSessionCandidateStateRepository(
+        stateFilePath,
+      );
+      const firstSaveAt = new Date('2026-06-26T00:00:00Z');
+      const secondSaveAt = new Date(
+        firstSaveAt.getTime() +
+          (ANNOUNCED_RUNNING_RETENTION_WINDOW_SECONDS + 1) * 1000,
+      );
+
+      await repository.saveAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+        labels: ['sub-process-1'],
+        now: firstSaveAt,
+      });
+      await repository.saveAnnouncedRunningSubAgentLabels({
+        sessionName: sessionBravo,
+        labels: ['sub-process-2'],
+        now: secondSaveAt,
+      });
+
+      expect(
+        await repository.loadAnnouncedRunningSubAgentLabels({
+          sessionName: sessionAlpha,
+        }),
+      ).toEqual(new Set<string>());
+      expect(
+        await repository.loadAnnouncedRunningSubAgentLabels({
+          sessionName: sessionBravo,
+        }),
+      ).toEqual(new Set(['sub-process-2']));
+    });
+
+    it('preserves the candidate set when saving announced labels and preserves announced labels when saving candidates', async () => {
+      const repository = new FileSystemSilentSessionCandidateStateRepository(
+        stateFilePath,
+      );
+      const at = new Date('2026-06-26T00:00:00Z');
+
+      await repository.saveCandidateSessionNames({
+        sessionNames: [sessionAlpha],
+        now: at,
+      });
+      await repository.saveAnnouncedRunningSubAgentLabels({
+        sessionName: sessionBravo,
+        labels: ['sub-process-1'],
+        now: at,
+      });
+      await repository.saveCandidateSessionNames({
+        sessionNames: [sessionAlpha],
+        now: new Date('2026-06-26T00:01:00Z'),
+      });
+
+      const loadedCandidates = await repository.loadRecentCandidateSessionNames(
+        {
+          now: new Date('2026-06-26T00:02:00Z'),
+          recencyWindowSeconds: 15 * 60,
+        },
+      );
+      expect(loadedCandidates).toEqual(new Set([sessionAlpha]));
+      expect(
+        await repository.loadAnnouncedRunningSubAgentLabels({
+          sessionName: sessionBravo,
+        }),
+      ).toEqual(new Set(['sub-process-1']));
+    });
+
+    it('treats a corrupt state file as no recorded announcements', async () => {
+      fs.writeFileSync(stateFilePath, 'not valid json');
+      const repository = new FileSystemSilentSessionCandidateStateRepository(
+        stateFilePath,
+      );
+
+      const loaded = await repository.loadAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+      });
+
+      expect(loaded).toEqual(new Set<string>());
+    });
+
+    it('ignores a stored announced entry whose labels are malformed', async () => {
+      fs.writeFileSync(
+        stateFilePath,
+        JSON.stringify({
+          candidates: [],
+          announcedRunningSubAgents: [
+            {
+              sessionName: sessionAlpha,
+              labels: ['sub-process-1', 42],
+              recordedEpochSeconds: 1782000000,
+            },
+          ],
+        }),
+      );
+      const repository = new FileSystemSilentSessionCandidateStateRepository(
+        stateFilePath,
+      );
+
+      const loaded = await repository.loadAnnouncedRunningSubAgentLabels({
+        sessionName: sessionAlpha,
+      });
+
+      expect(loaded).toEqual(new Set<string>());
+    });
+
+    it('exposes the announced-label retention window as a named constant', () => {
+      expect(ANNOUNCED_RUNNING_RETENTION_WINDOW_SECONDS).toBe(24 * 60 * 60);
+    });
+  });
 });

package/src/adapter/repositories/FileSystemSilentSessionCandidateStateRepository.ts

@@ -8,10 +8,17 @@ type StoredCandidateEntry = {
   recordedEpochSeconds: number;
 };
 
+type StoredAnnouncedRunningEntry = {
+  sessionName: string;
+  labels: string[];
+  recordedEpochSeconds: number;
+};
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value);
 
 export const DEFAULT_STATE_RETENTION_WINDOW_SECONDS = 60 * 60;
+export const ANNOUNCED_RUNNING_RETENTION_WINDOW_SECONDS = 24 * 60 * 60;
 
 const defaultStateFilePath = (): string => {
   const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
@@ -31,7 +38,7 @@ export class FileSystemSilentSessionCandidateStateRepository implements SilentSe
     const nowEpochSeconds = Math.floor(params.now.getTime() / 1000);
     const oldestAllowedEpochSeconds =
       nowEpochSeconds - params.recencyWindowSeconds;
-    const entries = this.readEntries();
+    const entries = this.readCandidateEntries();
     const recentSessionNames = new Set<string>();
     for (const entry of entries) {
       if (entry.recordedEpochSeconds >= oldestAllowedEpochSeconds) {
@@ -50,7 +57,7 @@ export class FileSystemSilentSessionCandidateStateRepository implements SilentSe
       recordedEpochSeconds - this.retentionWindowSeconds;
     const currentSessionNames = new Set(params.sessionNames);
     const mergedBySessionName = new Map<string, StoredCandidateEntry>();
-    for (const entry of this.readEntries()) {
+    for (const entry of this.readCandidateEntries()) {
       if (
         entry.recordedEpochSeconds >= oldestRetainedEpochSeconds &&
         !currentSessionNames.has(entry.sessionName)
@@ -64,26 +71,65 @@ export class FileSystemSilentSessionCandidateStateRepository implements SilentSe
         recordedEpochSeconds,
       });
     }
-    this.writeEntries(Array.from(mergedBySessionName.values()));
+    this.writeState(
+      Array.from(mergedBySessionName.values()),
+      this.readAnnouncedRunningEntries(),
+    );
+  };
+
+  loadAnnouncedRunningSubAgentLabels = async (params: {
+    sessionName: string;
+  }): Promise<Set<string>> => {
+    const entry = this.readAnnouncedRunningEntries().find(
+      (candidate) => candidate.sessionName === params.sessionName,
+    );
+    return new Set(entry?.labels ?? []);
+  };
+
+  saveAnnouncedRunningSubAgentLabels = async (params: {
+    sessionName: string;
+    labels: string[];
+    now: Date;
+  }): Promise<void> => {
+    const recordedEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const oldestRetainedEpochSeconds =
+      recordedEpochSeconds - ANNOUNCED_RUNNING_RETENTION_WINDOW_SECONDS;
+    const retainedEntries = this.readAnnouncedRunningEntries().filter(
+      (entry) =>
+        entry.sessionName !== params.sessionName &&
+        entry.recordedEpochSeconds >= oldestRetainedEpochSeconds,
+    );
+    if (params.labels.length > 0) {
+      retainedEntries.push({
+        sessionName: params.sessionName,
+        labels: params.labels,
+        recordedEpochSeconds,
+      });
+    }
+    this.writeState(this.readCandidateEntries(), retainedEntries);
   };
 
-  private readEntries = (): StoredCandidateEntry[] => {
+  private readState = (): Record<string, unknown> => {
     let raw: string;
     try {
       raw = fs.readFileSync(this.stateFilePath, 'utf8');
     } catch {
-      return [];
+      return {};
     }
     let parsed: unknown;
     try {
       parsed = JSON.parse(raw);
     } catch {
-      return [];
+      return {};
     }
     if (!isRecord(parsed)) {
-      return [];
+      return {};
     }
-    const storedEntries = parsed.candidates;
+    return parsed;
+  };
+
+  private readCandidateEntries = (): StoredCandidateEntry[] => {
+    const storedEntries = this.readState().candidates;
     if (!Array.isArray(storedEntries)) {
       return [];
     }
@@ -105,11 +151,49 @@ export class FileSystemSilentSessionCandidateStateRepository implements SilentSe
     return entries;
   };
 
-  private writeEntries = (entries: StoredCandidateEntry[]): void => {
+  private readAnnouncedRunningEntries = (): StoredAnnouncedRunningEntry[] => {
+    const storedEntries = this.readState().announcedRunningSubAgents;
+    if (!Array.isArray(storedEntries)) {
+      return [];
+    }
+    const entries: StoredAnnouncedRunningEntry[] = [];
+    for (const storedEntry of storedEntries) {
+      if (!isRecord(storedEntry)) {
+        continue;
+      }
+      const sessionName = storedEntry.sessionName;
+      const recordedEpochSeconds = storedEntry.recordedEpochSeconds;
+      const storedLabels = storedEntry.labels;
+      if (
+        typeof sessionName !== 'string' ||
+        typeof recordedEpochSeconds !== 'number' ||
+        !Number.isFinite(recordedEpochSeconds) ||
+        !Array.isArray(storedLabels)
+      ) {
+        continue;
+      }
+      const labels = storedLabels.filter(
+        (label): label is string => typeof label === 'string',
+      );
+      if (labels.length !== storedLabels.length) {
+        continue;
+      }
+      entries.push({ sessionName, labels, recordedEpochSeconds });
+    }
+    return entries;
+  };
+
+  private writeState = (
+    candidates: StoredCandidateEntry[],
+    announcedRunningSubAgents: StoredAnnouncedRunningEntry[],
+  ): void => {
     const directory = path.dirname(this.stateFilePath);
     fs.mkdirSync(directory, { recursive: true });
     const temporaryPath = `${this.stateFilePath}.${process.pid}.tmp`;
-    fs.writeFileSync(temporaryPath, JSON.stringify({ candidates: entries }));
+    fs.writeFileSync(
+      temporaryPath,
+      JSON.stringify({ candidates, announcedRunningSubAgents }),
+    );
     fs.renameSync(temporaryPath, this.stateFilePath);
   };
 }