github-issue-tower-defence-management 1.117.8 → 1.117.9

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

@@ -36,10 +36,15 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
 
 describe('notifySilentTmuxSessions', () => {
   let configDir: string;
+  let candidateStateFilePath: string;
 
   beforeEach(() => {
     jest.spyOn(console, 'log').mockImplementation(() => undefined);
     configDir = fs.mkdtempSync(path.join(os.tmpdir(), 'silent-config-'));
+    candidateStateFilePath = path.join(
+      configDir,
+      'silent-session-candidates.json',
+    );
   });
 
   afterEach(() => {
@@ -47,6 +52,18 @@ describe('notifySilentTmuxSessions', () => {
     fs.rmSync(configDir, { force: true, recursive: true });
   });
 
+  const seedPreviousCandidates = (sessionNames: string[]): void => {
+    fs.writeFileSync(
+      candidateStateFilePath,
+      JSON.stringify({
+        candidates: sessionNames.map((sessionName) => ({
+          sessionName,
+          recordedEpochSeconds: NOW_EPOCH_SECONDS,
+        })),
+      }),
+    );
+  };
+
   const writeTranscript = (lines: object[]): void => {
     const projectDirectory = path.join(configDir, 'projects', '-home-user');
     fs.mkdirSync(projectDirectory, { recursive: true });
@@ -114,6 +131,7 @@ describe('notifySilentTmuxSessions', () => {
     subAgentOutputRootDirectory: null,
     subAgentProcessMatchPattern: null,
     subAgentTranscriptRootDirectory: null,
+    candidateDebounceStateFilePath: candidateStateFilePath,
     activeHubTaskStatus: null,
     hubTaskStatusResolver: null,
     messageTemplates: EMPTY_TEMPLATES,
@@ -121,8 +139,9 @@ describe('notifySilentTmuxSessions', () => {
     ...DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS,
   });
 
-  it('sends a main stalled notification to a silent github-named live session', async () => {
+  it('sends a main stalled notification to a silent github-named live session that was already a candidate in the previous cycle', async () => {
     silentAssistantTranscript();
+    seedPreviousCandidates([SESSION_NAME]);
     const runner = liveSessionRunner();
 
     await notifySilentTmuxSessions(baseParams(runner));
@@ -134,6 +153,18 @@ describe('notifySilentTmuxSessions', () => {
     expect(sendCall?.[1][4]).toContain('You have produced no output for');
   });
 
+  it('does not notify a silent github-named live session on its first candidate cycle', async () => {
+    silentAssistantTranscript();
+    const runner = liveSessionRunner();
+
+    await notifySilentTmuxSessions(baseParams(runner));
+
+    const sendCall = runner.runCommand.mock.calls.find(
+      (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
+    );
+    expect(sendCall).toBeUndefined();
+  });
+
   it('sends no notification to a silent non-github-named live session', async () => {
     silentAssistantTranscript();
     const runner = createMockRunner();
@@ -176,6 +207,7 @@ describe('notifySilentTmuxSessions', () => {
 
   it('uses the configured main stalled message template when provided', async () => {
     silentAssistantTranscript();
+    seedPreviousCandidates([SESSION_NAME]);
     const runner = liveSessionRunner();
 
     await notifySilentTmuxSessions({
@@ -230,7 +262,7 @@ describe('notifySilentTmuxSessions', () => {
     expect(sendCall).toBeUndefined();
   });
 
-  it('re-notifies the same silent session on the next cycle with no cooldown suppression', async () => {
+  it('defers the first cycle then notifies on the next cycle once the persisted candidate state confirms a second consecutive cycle', async () => {
     silentAssistantTranscript();
     const firstRunner = liveSessionRunner();
 
@@ -239,7 +271,7 @@ describe('notifySilentTmuxSessions', () => {
     const firstSendCall = firstRunner.runCommand.mock.calls.find(
       (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
     );
-    expect(firstSendCall?.[1][2]).toBe(SESSION_NAME);
+    expect(firstSendCall).toBeUndefined();
 
     const secondRunner = liveSessionRunner();
     await notifySilentTmuxSessions({
@@ -333,6 +365,7 @@ describe('notifySilentTmuxSessions', () => {
 
   it('skips a URL-named session whose hub task is no longer in the active status', async () => {
     writeUrlSessionTranscript();
+    seedPreviousCandidates([HUB_TASK_SESSION_NAME]);
     const runner = urlSessionRunner();
     const getIssueByUrl = jest
       .fn()
@@ -353,6 +386,7 @@ describe('notifySilentTmuxSessions', () => {
 
   it('sends to a URL-named session whose hub task is in the active status', async () => {
     writeUrlSessionTranscript();
+    seedPreviousCandidates([HUB_TASK_SESSION_NAME]);
     const runner = urlSessionRunner();
     const getIssueByUrl = jest
       .fn()

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

@@ -9,6 +9,7 @@ import {
   DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
   DEFAULT_NOTIFICATION_STAGGER_SECONDS,
+  DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
 } from '../../../domain/usecases/NotifySilentLiveSessionsUseCase';
 import { DefaultSilentSessionMessageComposer } from '../../../domain/usecases/DefaultSilentSessionMessageComposer';
 import { LocalProcessLiveSessionProcessSnapshotProvider } from '../../repositories/LocalProcessLiveSessionProcessSnapshotProvider';
@@ -28,6 +29,7 @@ import {
   SilentSessionMessageTemplates,
 } from '../../repositories/ConfigurableSilentSessionMessageComposer';
 import { RealSleeper } from '../../repositories/RealSleeper';
+import { FileSystemSilentSessionCandidateStateRepository } from '../../repositories/FileSystemSilentSessionCandidateStateRepository';
 
 export type NotifySilentTmuxSessionsParams = {
   enabled: boolean;
@@ -41,6 +43,8 @@ export type NotifySilentTmuxSessionsParams = {
   subAgentSilentThresholdSeconds: number;
   subAgentRunningThresholdSeconds: number;
   staggerSeconds: number;
+  candidateDebounceRecencyWindowSeconds: number;
+  candidateDebounceStateFilePath: string | null;
   activeHubTaskStatus: string | null;
   hubTaskStatusResolver: HubTaskStatusResolver | null;
   messageTemplates: SilentSessionMessageTemplates;
@@ -96,6 +100,8 @@ export const notifySilentTmuxSessions = async (
     subAgentSilentThresholdSeconds,
     subAgentRunningThresholdSeconds,
     staggerSeconds,
+    candidateDebounceRecencyWindowSeconds,
+    candidateDebounceStateFilePath,
     activeHubTaskStatus,
     hubTaskStatusResolver,
     messageTemplates,
@@ -127,6 +133,11 @@ export const notifySilentTmuxSessions = async (
     ),
     createOwnerCallStatusProvider(ownerCallMarker),
     new TmuxSilentSessionNotificationRepository(localCommandRunner),
+    candidateDebounceStateFilePath !== null
+      ? new FileSystemSilentSessionCandidateStateRepository(
+          candidateDebounceStateFilePath,
+        )
+      : new FileSystemSilentSessionCandidateStateRepository(),
     messageComposer,
     new RealSleeper(),
     hubTaskStatusResolver,
@@ -136,6 +147,7 @@ export const notifySilentTmuxSessions = async (
     subAgentSilentThresholdSeconds,
     subAgentRunningThresholdSeconds,
     staggerSeconds,
+    candidateDebounceRecencyWindowSeconds,
     activeHubTaskStatus,
     now,
   });
@@ -146,4 +158,6 @@ export const DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS = {
   subAgentSilentThresholdSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
   subAgentRunningThresholdSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
   staggerSeconds: DEFAULT_NOTIFICATION_STAGGER_SECONDS,
+  candidateDebounceRecencyWindowSeconds:
+    DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
 } as const;

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

@@ -0,0 +1,201 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  DEFAULT_STATE_RETENTION_WINDOW_SECONDS,
+  FileSystemSilentSessionCandidateStateRepository,
+} from './FileSystemSilentSessionCandidateStateRepository';
+
+describe('FileSystemSilentSessionCandidateStateRepository', () => {
+  let rootDirectory: string;
+  let stateFilePath: string;
+
+  beforeEach(() => {
+    rootDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'silent-session-candidate-state-'),
+    );
+    stateFilePath = path.join(rootDirectory, 'silent-session-candidates.json');
+  });
+
+  afterEach(() => {
+    fs.rmSync(rootDirectory, { force: true, recursive: true });
+  });
+
+  const sessionAlpha = 'https://github.com/HiromiShikata/repo/issues/100';
+  const sessionBravo = 'https://github.com/HiromiShikata/repo/issues/200';
+
+  it('round-trips a saved candidate set so the next cycle reads it back', async () => {
+    const repository = new FileSystemSilentSessionCandidateStateRepository(
+      stateFilePath,
+    );
+    const now = new Date('2026-06-26T00:00:00Z');
+
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionAlpha, sessionBravo],
+      now,
+    });
+    const loaded = await repository.loadRecentCandidateSessionNames({
+      now: new Date('2026-06-26T00:01:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set([sessionAlpha, sessionBravo]));
+  });
+
+  it('returns an empty set when no state file exists yet', async () => {
+    const repository = new FileSystemSilentSessionCandidateStateRepository(
+      stateFilePath,
+    );
+
+    const loaded = await repository.loadRecentCandidateSessionNames({
+      now: new Date('2026-06-26T00:00:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set<string>());
+  });
+
+  it('excludes an entry older than the recency window when loading', async () => {
+    const repository = new FileSystemSilentSessionCandidateStateRepository(
+      stateFilePath,
+    );
+    const savedAt = new Date('2026-06-26T00:00:00Z');
+
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionAlpha],
+      now: savedAt,
+    });
+    const loaded = await repository.loadRecentCandidateSessionNames({
+      now: new Date('2026-06-26T00:16:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set<string>());
+  });
+
+  it('includes an entry recorded exactly at the recency-window boundary', async () => {
+    const repository = new FileSystemSilentSessionCandidateStateRepository(
+      stateFilePath,
+    );
+    const savedAt = new Date('2026-06-26T00:00:00Z');
+
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionAlpha],
+      now: savedAt,
+    });
+    const loaded = await repository.loadRecentCandidateSessionNames({
+      now: new Date('2026-06-26T00:15:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set([sessionAlpha]));
+  });
+
+  it('preserves another recent session recorded by a concurrent run when saving a disjoint set', async () => {
+    const repository = new FileSystemSilentSessionCandidateStateRepository(
+      stateFilePath,
+    );
+    const firstSaveAt = new Date('2026-06-26T00:00:00Z');
+    const secondSaveAt = new Date('2026-06-26T00:00:30Z');
+
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionAlpha],
+      now: firstSaveAt,
+    });
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionBravo],
+      now: secondSaveAt,
+    });
+    const loaded = await repository.loadRecentCandidateSessionNames({
+      now: new Date('2026-06-26T00:01:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set([sessionAlpha, sessionBravo]));
+  });
+
+  it('drops a stored entry that has aged beyond the retention window on the next save', async () => {
+    const repository = new FileSystemSilentSessionCandidateStateRepository(
+      stateFilePath,
+      60 * 60,
+    );
+    const firstSaveAt = new Date('2026-06-26T00:00:00Z');
+    const secondSaveAt = new Date('2026-06-26T01:30:00Z');
+
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionAlpha],
+      now: firstSaveAt,
+    });
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionBravo],
+      now: secondSaveAt,
+    });
+
+    const persisted: unknown = JSON.parse(
+      fs.readFileSync(stateFilePath, 'utf8'),
+    );
+    expect(persisted).toEqual({
+      candidates: [
+        {
+          sessionName: sessionBravo,
+          recordedEpochSeconds: Math.floor(secondSaveAt.getTime() / 1000),
+        },
+      ],
+    });
+  });
+
+  it('refreshes the timestamp of a session that is a candidate again', async () => {
+    const repository = new FileSystemSilentSessionCandidateStateRepository(
+      stateFilePath,
+    );
+    const firstSaveAt = new Date('2026-06-26T00:00:00Z');
+    const secondSaveAt = new Date('2026-06-26T00:14:00Z');
+
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionAlpha],
+      now: firstSaveAt,
+    });
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionAlpha],
+      now: secondSaveAt,
+    });
+    const loaded = await repository.loadRecentCandidateSessionNames({
+      now: new Date('2026-06-26T00:20:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set([sessionAlpha]));
+  });
+
+  it('treats a corrupt state file as no previous candidates', async () => {
+    fs.writeFileSync(stateFilePath, 'not valid json');
+    const repository = new FileSystemSilentSessionCandidateStateRepository(
+      stateFilePath,
+    );
+
+    const loaded = await repository.loadRecentCandidateSessionNames({
+      now: new Date('2026-06-26T00:00:00Z'),
+      recencyWindowSeconds: 15 * 60,
+    });
+
+    expect(loaded).toEqual(new Set<string>());
+  });
+
+  it('creates the parent directory when the configured path does not exist yet', async () => {
+    const nestedPath = path.join(rootDirectory, 'nested', 'dir', 'state.json');
+    const repository = new FileSystemSilentSessionCandidateStateRepository(
+      nestedPath,
+    );
+
+    await repository.saveCandidateSessionNames({
+      sessionNames: [sessionAlpha],
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+
+    expect(fs.existsSync(nestedPath)).toBe(true);
+  });
+
+  it('exposes the default retention window as a named constant', () => {
+    expect(DEFAULT_STATE_RETENTION_WINDOW_SECONDS).toBe(60 * 60);
+  });
+});

package/src/adapter/repositories/FileSystemSilentSessionCandidateStateRepository.ts

@@ -0,0 +1,115 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { SilentSessionCandidateStateRepository } from '../../domain/usecases/adapter-interfaces/SilentSessionCandidateStateRepository';
+
+type StoredCandidateEntry = {
+  sessionName: 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;
+
+const defaultStateFilePath = (): string => {
+  const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+  return path.join(base, 'tdpm', 'silent-session-candidates.json');
+};
+
+export class FileSystemSilentSessionCandidateStateRepository implements SilentSessionCandidateStateRepository {
+  constructor(
+    private readonly stateFilePath: string = defaultStateFilePath(),
+    private readonly retentionWindowSeconds: number = DEFAULT_STATE_RETENTION_WINDOW_SECONDS,
+  ) {}
+
+  loadRecentCandidateSessionNames = async (params: {
+    now: Date;
+    recencyWindowSeconds: number;
+  }): Promise<Set<string>> => {
+    const nowEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const oldestAllowedEpochSeconds =
+      nowEpochSeconds - params.recencyWindowSeconds;
+    const entries = this.readEntries();
+    const recentSessionNames = new Set<string>();
+    for (const entry of entries) {
+      if (entry.recordedEpochSeconds >= oldestAllowedEpochSeconds) {
+        recentSessionNames.add(entry.sessionName);
+      }
+    }
+    return recentSessionNames;
+  };
+
+  saveCandidateSessionNames = async (params: {
+    sessionNames: string[];
+    now: Date;
+  }): Promise<void> => {
+    const recordedEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const oldestRetainedEpochSeconds =
+      recordedEpochSeconds - this.retentionWindowSeconds;
+    const currentSessionNames = new Set(params.sessionNames);
+    const mergedBySessionName = new Map<string, StoredCandidateEntry>();
+    for (const entry of this.readEntries()) {
+      if (
+        entry.recordedEpochSeconds >= oldestRetainedEpochSeconds &&
+        !currentSessionNames.has(entry.sessionName)
+      ) {
+        mergedBySessionName.set(entry.sessionName, entry);
+      }
+    }
+    for (const sessionName of currentSessionNames) {
+      mergedBySessionName.set(sessionName, {
+        sessionName,
+        recordedEpochSeconds,
+      });
+    }
+    this.writeEntries(Array.from(mergedBySessionName.values()));
+  };
+
+  private readEntries = (): StoredCandidateEntry[] => {
+    let raw: string;
+    try {
+      raw = fs.readFileSync(this.stateFilePath, 'utf8');
+    } catch {
+      return [];
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+    if (!isRecord(parsed)) {
+      return [];
+    }
+    const storedEntries = parsed.candidates;
+    if (!Array.isArray(storedEntries)) {
+      return [];
+    }
+    const entries: StoredCandidateEntry[] = [];
+    for (const storedEntry of storedEntries) {
+      if (!isRecord(storedEntry)) {
+        continue;
+      }
+      const sessionName = storedEntry.sessionName;
+      const recordedEpochSeconds = storedEntry.recordedEpochSeconds;
+      if (
+        typeof sessionName === 'string' &&
+        typeof recordedEpochSeconds === 'number' &&
+        Number.isFinite(recordedEpochSeconds)
+      ) {
+        entries.push({ sessionName, recordedEpochSeconds });
+      }
+    }
+    return entries;
+  };
+
+  private writeEntries = (entries: StoredCandidateEntry[]): 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.renameSync(temporaryPath, this.stateFilePath);
+  };
+}