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

package/src/adapter/entry-points/handlers/consoleListsWriter.test.ts

@@ -4,6 +4,15 @@ import path from 'path';
 import { mock } from 'jest-mock-extended';
 import { Issue } from '../../../domain/entities/Issue';
 import { FieldOption, Project } from '../../../domain/entities/Project';
+import {
+  buildConsoleDataResponse,
+  parseConsoleDataRoute,
+} from '../console/consoleDataDelivery';
+import {
+  CONSOLE_DONE_TAB_NAMES,
+  readDoneProjectItemIds,
+  recordDoneProjectItemId,
+} from '../console/consoleDoneStore';
 import {
   formatConsoleGeneratedAt,
   writeConsoleLists,
@@ -226,6 +235,69 @@ describe('writeConsoleLists', () => {
     });
     expect(fs.readdirSync(outDir)).toHaveLength(0);
   });
+
+  const regenerateUnread = (): void => {
+    writeConsoleLists({
+      consoleDataOutputDir: outDir,
+      pjcode: 'demo',
+      assigneeLogin: ASSIGNEE,
+      project,
+      issues: [makeIssue({ status: 'Unread', itemId: 'item-1' })],
+      generatedAt: '2026-06-14T07:22:33Z',
+    });
+  };
+
+  const unreadServedItemCount = (): number => {
+    const route = parseConsoleDataRoute('projects/demo/unread/list.json');
+    if (route === null) {
+      throw new Error('route should not be null');
+    }
+    const response = buildConsoleDataResponse(outDir, route);
+    const body: unknown = JSON.parse(response.body);
+    const items: unknown = isRecord(body) ? body.items : undefined;
+    return isUnknownArray(items) ? items.length : 0;
+  };
+
+  it('resets the done file of every tab to an empty record on regeneration', () => {
+    regenerateUnread();
+
+    for (const tab of CONSOLE_DONE_TAB_NAMES) {
+      const doneFile = path.join(outDir, 'demo', tab, '.done.json');
+      expect(fs.existsSync(doneFile)).toBe(true);
+      const raw: unknown = JSON.parse(fs.readFileSync(doneFile, 'utf8'));
+      expect(raw).toEqual({ projectItemIds: [] });
+    }
+  });
+
+  it('clears a pre-existing accumulated done file on regeneration', () => {
+    for (const id of ['PVTI_1', 'PVTI_2', 'PVTI_3']) {
+      recordDoneProjectItemId(outDir, 'demo', 'unread', id);
+    }
+    expect(readDoneProjectItemIds(outDir, 'demo', 'unread')).toHaveLength(3);
+
+    regenerateUnread();
+
+    expect(readDoneProjectItemIds(outDir, 'demo', 'unread')).toEqual([]);
+  });
+
+  it('serves the full list after regeneration despite a prior accumulated done record', () => {
+    recordDoneProjectItemId(outDir, 'demo', 'unread', 'item-1');
+
+    regenerateUnread();
+
+    expect(unreadServedItemCount()).toBe(1);
+  });
+
+  it('re-hides an item recorded as done until the next regeneration bounds it to one cycle', () => {
+    regenerateUnread();
+    expect(unreadServedItemCount()).toBe(1);
+
+    recordDoneProjectItemId(outDir, 'demo', 'unread', 'item-1');
+    expect(unreadServedItemCount()).toBe(0);
+
+    regenerateUnread();
+    expect(unreadServedItemCount()).toBe(1);
+  });
 });
 
 describe('formatConsoleGeneratedAt', () => {

package/src/adapter/entry-points/handlers/consoleListsWriter.ts

@@ -7,6 +7,7 @@ import {
   ConsoleTabName,
   GenerateConsoleListsUseCase,
 } from '../../../domain/usecases/console/GenerateConsoleListsUseCase';
+import { resetDoneProjectItemIdsAcrossTabs } from '../console/consoleDoneStore';
 
 export type ConsoleListsWriterParams = {
   consoleDataOutputDir: string | null | undefined;
@@ -61,4 +62,6 @@ export const writeConsoleLists = (params: ConsoleListsWriterParams): void => {
       lists[tab],
     );
   }
+
+  resetDoneProjectItemIdsAcrossTabs(consoleDataOutputDir, pjcode);
 };

package/src/adapter/entry-points/handlers/notifySilentTmuxSessions.ts

@@ -76,6 +76,7 @@ const createSubAgentActivityRepository = (
       new FileSystemSubAgentTranscriptDirectoryResolver(
         subAgentTranscriptRootDirectory,
       ),
+      new NodeSubAgentProcessLister(localCommandRunner),
       now,
     );
   }

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

@@ -4,11 +4,6 @@ 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'),
   composeSubAgentSection: jest.fn().mockReturnValue('FALLBACK_SUB'),
@@ -78,16 +73,22 @@ describe('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 +101,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 +130,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 +159,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 +188,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';
 
@@ -40,10 +40,7 @@ export class ConfigurableSilentSessionMessageComposer implements SilentSessionMe
     );
   };
 
-  composeSubAgentSection = (
-    subAgents: SubAgentActivity[],
-    thresholds: SubAgentStallThresholds,
-  ): string => {
+  composeSubAgentSection = (stallSections: SubAgentStallSections): string => {
     const hasIdleTemplate =
       this.templates.subAgentIdleMessageHeader !== null ||
       this.templates.subAgentIdleMessageFooter !== null;
@@ -51,17 +48,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 +64,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/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);
+    });
+  });
 });