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

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);
   };
 }

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

@@ -54,7 +54,12 @@ describe('ProcessListSessionSubAgentActivityRepository', () => {
     );
     const result = await repository.listSubAgentActivitiesBySessionName(['s1']);
     expect(result.get('s1')).toEqual([
-      { label: 'task-a', silentSeconds: 180, runningSeconds: 1200 },
+      {
+        label: 'task-a',
+        silentSeconds: 180,
+        runningSeconds: 1200,
+        waitingOnExternalProcess: false,
+      },
     ]);
   });
 
@@ -78,7 +83,12 @@ describe('ProcessListSessionSubAgentActivityRepository', () => {
     );
     const result = await repository.listSubAgentActivitiesBySessionName(['s1']);
     expect(result.get('s1')).toEqual([
-      { label: 's1', silentSeconds: 0, runningSeconds: 30 },
+      {
+        label: 's1',
+        silentSeconds: 0,
+        runningSeconds: 30,
+        waitingOnExternalProcess: false,
+      },
     ]);
   });
 

package/src/adapter/repositories/ProcessListSessionSubAgentActivityRepository.ts

@@ -43,6 +43,7 @@ export class ProcessListSessionSubAgentActivityRepository implements SessionSubA
         label,
         silentSeconds: this.silentSecondsResolver.resolveSilentSeconds(label),
         runningSeconds: process.elapsedSeconds,
+        waitingOnExternalProcess: false,
       };
       const existing = result.get(sessionName);
       if (existing === undefined) {