github-issue-tower-defence-management 1.114.2 → 1.115.1

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

@@ -3,9 +3,8 @@ import * as os from 'os';
 import * as path from 'path';
 import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
 import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
-import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCacheRepository';
-import { LocalStorageRepository } from '../../repositories/LocalStorageRepository';
 import { SilentSessionMessageTemplates } from '../../repositories/ConfigurableSilentSessionMessageComposer';
+import { Issue } from '../../../domain/entities/Issue';
 import { SILENT_SESSION_REMINDER_SENTINEL } from '../../../domain/usecases/silentSessionReminderSentinel';
 import {
   notifySilentTmuxSessions,
@@ -37,18 +36,15 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
 
 describe('notifySilentTmuxSessions', () => {
   let configDir: string;
-  let cacheDirectory: string;
 
   beforeEach(() => {
     jest.spyOn(console, 'log').mockImplementation(() => undefined);
     configDir = fs.mkdtempSync(path.join(os.tmpdir(), 'silent-config-'));
-    cacheDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'silent-cache-'));
   });
 
   afterEach(() => {
     jest.restoreAllMocks();
     fs.rmSync(configDir, { force: true, recursive: true });
-    fs.rmSync(cacheDirectory, { force: true, recursive: true });
   });
 
   const writeTranscript = (lines: object[]): void => {
@@ -77,17 +73,6 @@ describe('notifySilentTmuxSessions', () => {
     ]);
   };
 
-  const makeCacheRepository = (): LocalStorageCacheRepository =>
-    new LocalStorageCacheRepository(
-      new LocalStorageRepository(),
-      cacheDirectory,
-    );
-
-  const makeCacheRepositoryAt = (
-    basePath: string,
-  ): LocalStorageCacheRepository =>
-    new LocalStorageCacheRepository(new LocalStorageRepository(), basePath);
-
   const makeEnvironReader = (): ProcessEnvironReader => ({
     readEnviron: (pid: number) =>
       pid === CLAUDE_PID
@@ -125,11 +110,12 @@ describe('notifySilentTmuxSessions', () => {
     enabled: true,
     localCommandRunner: runner,
     processEnvironReader: makeEnvironReader(),
-    cacheRepository: makeCacheRepository(),
     ownerCallMarker: null,
     subAgentOutputRootDirectory: null,
     subAgentProcessMatchPattern: null,
     subAgentTranscriptRootDirectory: null,
+    activeHubTaskStatus: null,
+    hubTaskStatusResolver: null,
     messageTemplates: EMPTY_TEMPLATES,
     now: NOW,
     ...DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS,
@@ -216,81 +202,143 @@ describe('notifySilentTmuxSessions', () => {
     expect(sendCall).toBeUndefined();
   });
 
-  it('does not re-notify the same silent session on the next cycle within cooldown', async () => {
+  it('re-notifies the same silent session on the next cycle with no cooldown suppression', async () => {
     silentAssistantTranscript();
-    const cacheRepository = makeCacheRepository();
     const firstRunner = liveSessionRunner();
 
-    await notifySilentTmuxSessions({
-      ...baseParams(firstRunner),
-      cacheRepository,
-    });
+    await notifySilentTmuxSessions(baseParams(firstRunner));
+
+    const firstSendCall = firstRunner.runCommand.mock.calls.find(
+      (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
+    );
+    expect(firstSendCall?.[1][2]).toBe(SESSION_NAME);
 
     const secondRunner = liveSessionRunner();
     await notifySilentTmuxSessions({
       ...baseParams(secondRunner),
-      cacheRepository,
       now: new Date(NOW.getTime() + 60 * 1000),
     });
 
     const secondSendCall = secondRunner.runCommand.mock.calls.find(
       (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
     );
-    expect(secondSendCall).toBeUndefined();
+    expect(secondSendCall?.[1][2]).toBe(SESSION_NAME);
   });
 
-  it('shares the cooldown across project passes when a single project-independent cache scope is used', async () => {
-    silentAssistantTranscript();
-    // The handler runs once per project over the same global set of tmux
-    // sessions. When the silent-session cooldown lives in one shared cache
-    // scope, a second per-project pass for the same session within the cooldown
-    // window must NOT re-send, even though it is a different project pass.
-    const sharedCacheBasePath = path.join(cacheDirectory, 'shared');
-    const firstRunner = liveSessionRunner();
+  const HUB_TASK_SESSION_NAME =
+    'https://github.com/HiromiShikata/repo/issues/42';
 
-    await notifySilentTmuxSessions({
-      ...baseParams(firstRunner),
-      cacheRepository: makeCacheRepositoryAt(sharedCacheBasePath),
+  const writeUrlSessionTranscript = (): void => {
+    const projectDirectory = path.join(configDir, 'projects', '-home-user');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    const silentTimestamp = new Date(
+      (NOW_EPOCH_SECONDS - 11 * 60) * 1000,
+    ).toISOString();
+    fs.writeFileSync(
+      path.join(projectDirectory, `${SESSION_ID}.jsonl`),
+      JSON.stringify({
+        type: 'assistant',
+        timestamp: silentTimestamp,
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'progress update' }],
+        },
+      }),
+      'utf8',
+    );
+  };
+
+  const urlSessionRunner = (): Mocked<LocalCommandRunner> => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return {
+          stdout: `${HUB_TASK_SESSION_NAME}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      if (program === 'tmux' && args[0] === 'list-panes') {
+        return { stdout: `${PANE_PID}\n`, stderr: '', exitCode: 0 };
+      }
+      if (program === 'ps') {
+        return {
+          stdout: `  ${PANE_PID}       1 shell\n  ${CLAUDE_PID}     ${PANE_PID} claude --name ${HUB_TASK_SESSION_NAME}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
     });
+    return runner;
+  };
+
+  const makeIssue = (overrides: {
+    state: Issue['state'];
+    status: string | null;
+  }): Issue => ({
+    nameWithOwner: 'HiromiShikata/repo',
+    number: 42,
+    title: 'Hub task',
+    state: overrides.state,
+    status: overrides.status,
+    story: null,
+    nextActionDate: null,
+    nextActionHour: null,
+    estimationMinutes: null,
+    dependedIssueUrls: [],
+    completionDate50PercentConfidence: null,
+    url: HUB_TASK_SESSION_NAME,
+    assignees: [],
+    labels: [],
+    org: 'HiromiShikata',
+    repo: 'repo',
+    body: '',
+    itemId: 'item-id',
+    isPr: false,
+    isInProgress: false,
+    isClosed: overrides.state !== 'OPEN',
+    createdAt: NOW,
+    author: 'HiromiShikata',
+    closingIssueReferenceUrls: [],
+  });
+
+  it('skips a URL-named session whose hub task is no longer in the active status', async () => {
+    writeUrlSessionTranscript();
+    const runner = urlSessionRunner();
+    const getIssueByUrl = jest
+      .fn()
+      .mockResolvedValue(makeIssue({ state: 'OPEN', status: 'Todo' }));
 
-    const secondRunner = liveSessionRunner();
     await notifySilentTmuxSessions({
-      ...baseParams(secondRunner),
-      cacheRepository: makeCacheRepositoryAt(sharedCacheBasePath),
-      now: new Date(NOW.getTime() + 60 * 1000),
+      ...baseParams(runner),
+      activeHubTaskStatus: 'In tmux',
+      hubTaskStatusResolver: { getIssueByUrl },
     });
 
-    const secondSendCall = secondRunner.runCommand.mock.calls.find(
+    expect(getIssueByUrl).toHaveBeenCalledWith(HUB_TASK_SESSION_NAME);
+    const sendCall = runner.runCommand.mock.calls.find(
       (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
     );
-    expect(secondSendCall).toBeUndefined();
+    expect(sendCall).toBeUndefined();
   });
 
-  it('re-sends within the cooldown window when each project pass uses its own cache scope', async () => {
-    silentAssistantTranscript();
-    // This reproduces the per-project cooldown defect: when each project pass
-    // stores its cooldown under its own project-scoped cache path, the same
-    // session is notified once per project within the cooldown window.
-    const firstRunner = liveSessionRunner();
-    await notifySilentTmuxSessions({
-      ...baseParams(firstRunner),
-      cacheRepository: makeCacheRepositoryAt(
-        path.join(cacheDirectory, 'umino'),
-      ),
-    });
+  it('sends to a URL-named session whose hub task is in the active status', async () => {
+    writeUrlSessionTranscript();
+    const runner = urlSessionRunner();
+    const getIssueByUrl = jest
+      .fn()
+      .mockResolvedValue(makeIssue({ state: 'OPEN', status: 'In tmux' }));
 
-    const secondRunner = liveSessionRunner();
     await notifySilentTmuxSessions({
-      ...baseParams(secondRunner),
-      cacheRepository: makeCacheRepositoryAt(
-        path.join(cacheDirectory, 'xmile'),
-      ),
-      now: new Date(NOW.getTime() + 60 * 1000),
+      ...baseParams(runner),
+      activeHubTaskStatus: 'In tmux',
+      hubTaskStatusResolver: { getIssueByUrl },
     });
 
-    const secondSendCall = secondRunner.runCommand.mock.calls.find(
+    const sendCall = runner.runCommand.mock.calls.find(
       (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
     );
-    expect(secondSendCall?.[1][2]).toBe(SESSION_NAME);
+    expect(sendCall?.[1][2]).toBe(HUB_TASK_SESSION_NAME);
   });
 });

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

@@ -4,10 +4,10 @@ import { OwnerCallStatusProvider } from '../../../domain/usecases/adapter-interf
 import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
 import {
   NotifySilentLiveSessionsUseCase,
+  HubTaskStatusResolver,
   DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
-  DEFAULT_NOTIFICATION_COOLDOWN_SECONDS,
   DEFAULT_NOTIFICATION_STAGGER_SECONDS,
 } from '../../../domain/usecases/NotifySilentLiveSessionsUseCase';
 import { DefaultSilentSessionMessageComposer } from '../../../domain/usecases/DefaultSilentSessionMessageComposer';
@@ -16,7 +16,6 @@ import { ProcFsProcessEnvironReader } from '../../repositories/ProcFsProcessEnvi
 import { FileSystemInteractiveLiveSessionTranscriptResolver } from '../../repositories/FileSystemInteractiveLiveSessionTranscriptResolver';
 import { FileSystemSessionOutputActivityRepository } from '../../repositories/FileSystemSessionOutputActivityRepository';
 import { TmuxSilentSessionNotificationRepository } from '../../repositories/TmuxSilentSessionNotificationRepository';
-import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCacheRepository';
 import { NoUnansweredOwnerCallStatusProvider } from '../../repositories/NoUnansweredOwnerCallStatusProvider';
 import { TranscriptOwnerCallStatusProvider } from '../../repositories/TranscriptOwnerCallStatusProvider';
 import { ProcessListSessionSubAgentActivityRepository } from '../../repositories/ProcessListSessionSubAgentActivityRepository';
@@ -34,7 +33,6 @@ export type NotifySilentTmuxSessionsParams = {
   enabled: boolean;
   localCommandRunner: LocalCommandRunner;
   processEnvironReader?: ProcessEnvironReader;
-  cacheRepository: Pick<LocalStorageCacheRepository, 'getLatest' | 'set'>;
   ownerCallMarker: string | null;
   subAgentOutputRootDirectory: string | null;
   subAgentProcessMatchPattern: string | null;
@@ -42,8 +40,9 @@ export type NotifySilentTmuxSessionsParams = {
   mainSilentThresholdSeconds: number;
   subAgentSilentThresholdSeconds: number;
   subAgentRunningThresholdSeconds: number;
-  cooldownSeconds: number;
   staggerSeconds: number;
+  activeHubTaskStatus: string | null;
+  hubTaskStatusResolver: HubTaskStatusResolver | null;
   messageTemplates: SilentSessionMessageTemplates;
   now: Date;
 };
@@ -89,7 +88,6 @@ export const notifySilentTmuxSessions = async (
     enabled,
     localCommandRunner,
     processEnvironReader,
-    cacheRepository,
     ownerCallMarker,
     subAgentOutputRootDirectory,
     subAgentProcessMatchPattern,
@@ -97,8 +95,9 @@ export const notifySilentTmuxSessions = async (
     mainSilentThresholdSeconds,
     subAgentSilentThresholdSeconds,
     subAgentRunningThresholdSeconds,
-    cooldownSeconds,
     staggerSeconds,
+    activeHubTaskStatus,
+    hubTaskStatusResolver,
     messageTemplates,
     now,
   } = params;
@@ -127,19 +126,17 @@ export const notifySilentTmuxSessions = async (
       now,
     ),
     createOwnerCallStatusProvider(ownerCallMarker),
-    new TmuxSilentSessionNotificationRepository(
-      localCommandRunner,
-      cacheRepository,
-    ),
+    new TmuxSilentSessionNotificationRepository(localCommandRunner),
     messageComposer,
     new RealSleeper(),
+    hubTaskStatusResolver,
   );
   await useCase.run({
     mainSilentThresholdSeconds,
     subAgentSilentThresholdSeconds,
     subAgentRunningThresholdSeconds,
-    cooldownSeconds,
     staggerSeconds,
+    activeHubTaskStatus,
     now,
   });
 };
@@ -148,6 +145,5 @@ export const DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS = {
   mainSilentThresholdSeconds: DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
   subAgentSilentThresholdSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
   subAgentRunningThresholdSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
-  cooldownSeconds: DEFAULT_NOTIFICATION_COOLDOWN_SECONDS,
   staggerSeconds: DEFAULT_NOTIFICATION_STAGGER_SECONDS,
 } as const;

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

@@ -1,5 +1,4 @@
 import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { LocalStorageCacheRepository } from './LocalStorageCacheRepository';
 import { TmuxSilentSessionNotificationRepository } from './TmuxSilentSessionNotificationRepository';
 
 type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
@@ -12,22 +11,11 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
   }),
 });
 
-const createMockCacheRepository = (): Mocked<
-  Pick<LocalStorageCacheRepository, 'getLatest' | 'set'>
-> => ({
-  getLatest: jest.fn().mockResolvedValue(null),
-  set: jest.fn().mockResolvedValue(undefined),
-});
-
 describe('TmuxSilentSessionNotificationRepository', () => {
   describe('sendSelfCheckNotification', () => {
     it('sends the message literally then submits it with Enter', async () => {
       const runner = createMockRunner();
-      const cache = createMockCacheRepository();
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        cache,
-      );
+      const repository = new TmuxSilentSessionNotificationRepository(runner);
 
       await repository.sendSelfCheckNotification(
         'https_//github_com/owner/repo/issues/9',
@@ -57,11 +45,7 @@ describe('TmuxSilentSessionNotificationRepository', () => {
         stderr: "can't find session",
         exitCode: 1,
       });
-      const cache = createMockCacheRepository();
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        cache,
-      );
+      const repository = new TmuxSilentSessionNotificationRepository(runner);
 
       await expect(
         repository.sendSelfCheckNotification('missing_session', 'message'),
@@ -70,84 +54,4 @@ describe('TmuxSilentSessionNotificationRepository', () => {
       );
     });
   });
-
-  describe('getLastNotifiedEpochSeconds', () => {
-    it('returns the cached epoch seconds for a session', async () => {
-      const runner = createMockRunner();
-      const cache = createMockCacheRepository();
-      cache.getLatest.mockResolvedValue({
-        value: { epochSeconds: 1700000000 },
-        timestamp: new Date(),
-      });
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        cache,
-      );
-
-      const result = await repository.getLastNotifiedEpochSeconds(
-        'https_//github_com/owner/repo/issues/9',
-      );
-
-      expect(result).toBe(1700000000);
-      expect(cache.getLatest).toHaveBeenCalledWith(
-        'silent-session-notification/https___github_com_owner_repo_issues_9',
-      );
-    });
-
-    it('returns null when no cache entry exists', async () => {
-      const runner = createMockRunner();
-      const cache = createMockCacheRepository();
-      cache.getLatest.mockResolvedValue(null);
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        cache,
-      );
-
-      const result = await repository.getLastNotifiedEpochSeconds(
-        'https_//github_com/owner/repo/issues/9',
-      );
-
-      expect(result).toBeNull();
-    });
-
-    it('returns null when the cached value has no numeric epoch', async () => {
-      const runner = createMockRunner();
-      const cache = createMockCacheRepository();
-      cache.getLatest.mockResolvedValue({
-        value: {},
-        timestamp: new Date(),
-      });
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        cache,
-      );
-
-      const result = await repository.getLastNotifiedEpochSeconds(
-        'https_//github_com/owner/repo/issues/9',
-      );
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('setLastNotifiedEpochSeconds', () => {
-    it('persists the epoch seconds keyed by the sanitized session name', async () => {
-      const runner = createMockRunner();
-      const cache = createMockCacheRepository();
-      const repository = new TmuxSilentSessionNotificationRepository(
-        runner,
-        cache,
-      );
-
-      await repository.setLastNotifiedEpochSeconds(
-        'https_//github_com/owner/repo/issues/9',
-        1700000000,
-      );
-
-      expect(cache.set).toHaveBeenCalledWith(
-        'silent-session-notification/https___github_com_owner_repo_issues_9',
-        { epochSeconds: 1700000000 },
-      );
-    });
-  });
 });

package/src/adapter/repositories/TmuxSilentSessionNotificationRepository.ts

@@ -1,49 +1,8 @@
 import { SilentSessionNotificationRepository } from '../../domain/usecases/adapter-interfaces/SilentSessionNotificationRepository';
 import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { LocalStorageCacheRepository } from './LocalStorageCacheRepository';
-
-const CACHE_KEY_PREFIX = 'silent-session-notification';
-
-const readEpochSeconds = (value: object): number | null => {
-  if (!('epochSeconds' in value)) {
-    return null;
-  }
-  const candidate = value.epochSeconds;
-  if (typeof candidate !== 'number') {
-    return null;
-  }
-  return candidate;
-};
 
 export class TmuxSilentSessionNotificationRepository implements SilentSessionNotificationRepository {
-  constructor(
-    private readonly localCommandRunner: LocalCommandRunner,
-    private readonly cacheRepository: Pick<
-      LocalStorageCacheRepository,
-      'getLatest' | 'set'
-    >,
-  ) {}
-
-  getLastNotifiedEpochSeconds = async (
-    sessionName: string,
-  ): Promise<number | null> => {
-    const cached = await this.cacheRepository.getLatest(
-      this.toCacheKey(sessionName),
-    );
-    if (cached === null) {
-      return null;
-    }
-    return readEpochSeconds(cached.value);
-  };
-
-  setLastNotifiedEpochSeconds = async (
-    sessionName: string,
-    epochSeconds: number,
-  ): Promise<void> => {
-    await this.cacheRepository.set(this.toCacheKey(sessionName), {
-      epochSeconds,
-    });
-  };
+  constructor(private readonly localCommandRunner: LocalCommandRunner) {}
 
   sendSelfCheckNotification = async (
     sessionName: string,
@@ -77,7 +36,4 @@ export class TmuxSilentSessionNotificationRepository implements SilentSessionNot
       );
     }
   };
-
-  private toCacheKey = (sessionName: string): string =>
-    `${CACHE_KEY_PREFIX}/${sessionName.replace(/\//g, '_')}`;
 }