github-issue-tower-defence-management 1.110.0 → 1.111.0

package/bin/domain/usecases/adapter-interfaces/ProcessEnvironReader.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ProcessEnvironReader.js.map

package/bin/domain/usecases/adapter-interfaces/ProcessEnvironReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessEnvironReader.js","sourceRoot":"","sources":["../../../../src/domain/usecases/adapter-interfaces/ProcessEnvironReader.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "github-issue-tower-defence-management",
-  "version": "1.110.0",
+  "version": "1.111.0",
   "description": "",
   "main": "bin/index.js",
   "scripts": {

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

@@ -108,8 +108,7 @@ export class HandleScheduledEventUseCaseHandler {
       inTmuxConsoleToken?: string;
       inTmuxProjectOrder?: string[];
       inTmuxLauncherCommand?: string;
-      sessionOutputRootDirectory?: string;
-      sessionTranscriptRootDirectory?: string;
+      silentNotificationEnabled?: boolean;
       ownerCallMarker?: string;
       subAgentOutputRootDirectory?: string;
       subAgentProcessMatchPattern?: string;
@@ -563,10 +562,9 @@ export class HandleScheduledEventUseCaseHandler {
       }
 
       try {
-        const sessionOutputRootDirectory =
-          mergedInput.sessionOutputRootDirectory ??
-          process.env.TDPM_SESSION_OUTPUT_ROOT_DIRECTORY ??
-          null;
+        const silentNotificationEnabled =
+          mergedInput.silentNotificationEnabled ??
+          process.env.TDPM_SILENT_NOTIFICATION_ENABLED === 'true';
         const subAgentOutputRootDirectory =
           mergedInput.subAgentOutputRootDirectory ??
           process.env.TDPM_SUBAGENT_OUTPUT_ROOT_DIRECTORY ??
@@ -575,10 +573,6 @@ export class HandleScheduledEventUseCaseHandler {
           mergedInput.subAgentProcessMatchPattern ??
           process.env.TDPM_SUBAGENT_PROCESS_MATCH_PATTERN ??
           null;
-        const sessionTranscriptRootDirectory =
-          mergedInput.sessionTranscriptRootDirectory ??
-          process.env.TDPM_SESSION_TRANSCRIPT_ROOT_DIRECTORY ??
-          null;
         const ownerCallMarker =
           mergedInput.ownerCallMarker ??
           process.env.TDPM_SILENT_OWNER_CALL_MARKER ??
@@ -588,13 +582,9 @@ export class HandleScheduledEventUseCaseHandler {
           process.env.TDPM_SUBAGENT_TRANSCRIPT_ROOT_DIRECTORY ??
           null;
         await notifySilentTmuxSessions({
-          project: result.project,
-          allowCacheMinutes: mergedInput.allowIssueCacheMinutes,
-          issueRepository,
+          enabled: silentNotificationEnabled,
           localCommandRunner: nodeLocalCommandRunner,
           cacheRepository: localStorageCacheRepository,
-          sessionOutputRootDirectory,
-          sessionTranscriptRootDirectory,
           ownerCallMarker,
           subAgentOutputRootDirectory,
           subAgentProcessMatchPattern,

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

@@ -1,11 +1,8 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { Issue } from '../../../domain/entities/Issue';
-import { Project } from '../../../domain/entities/Project';
 import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
-import { IN_TMUX_STATUS_NAME } from '../../../domain/entities/WorkflowStatus';
+import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
 import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCacheRepository';
 import { LocalStorageRepository } from '../../repositories/LocalStorageRepository';
 import { SilentSessionMessageTemplates } from '../../repositories/ConfigurableSilentSessionMessageComposer';
@@ -16,8 +13,10 @@ import {
 
 const NOW = new Date('2026-06-26T00:00:00.000Z');
 const NOW_EPOCH_SECONDS = Math.floor(NOW.getTime() / 1000);
-const ALLOW_CACHE_MINUTES = 10;
-const SESSION_NAME = 'https_//github_com/demo/repo/issues/1';
+const SESSION_NAME = 'workbench';
+const SESSION_ID = 'wb-uuid';
+const PANE_PID = 200;
+const CLAUDE_PID = 201;
 
 const EMPTY_TEMPLATES: SilentSessionMessageTemplates = {
   mainStalledMessage: null,
@@ -25,52 +24,6 @@ const EMPTY_TEMPLATES: SilentSessionMessageTemplates = {
   subAgentMessageFooter: null,
 };
 
-const makeProject = (): Project => ({
-  id: 'project-1',
-  url: 'https://github.com/users/user/projects/1',
-  databaseId: 1,
-  name: 'Test Project',
-  status: {
-    name: 'Status',
-    fieldId: 'field-1',
-    statuses: [],
-  },
-  nextActionDate: null,
-  nextActionHour: null,
-  story: null,
-  remainingEstimationMinutes: null,
-  dependedIssueUrlSeparatedByComma: null,
-  completionDate50PercentConfidence: null,
-});
-
-const makeIssue = (overrides: Partial<Issue> = {}): Issue => ({
-  nameWithOwner: 'demo/repo',
-  number: 1,
-  title: 'Issue 1',
-  state: 'OPEN',
-  status: IN_TMUX_STATUS_NAME,
-  story: null,
-  nextActionDate: null,
-  nextActionHour: null,
-  estimationMinutes: null,
-  dependedIssueUrls: [],
-  completionDate50PercentConfidence: null,
-  url: 'https://github.com/demo/repo/issues/1',
-  assignees: [],
-  labels: [],
-  org: 'demo',
-  repo: 'repo',
-  body: '',
-  itemId: 'item-1',
-  isPr: false,
-  isInProgress: false,
-  isClosed: false,
-  createdAt: new Date(),
-  author: '',
-  closingIssueReferenceUrls: [],
-  ...overrides,
-});
-
 type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
 
 const createMockRunner = (): Mocked<LocalCommandRunner> => ({
@@ -81,34 +34,46 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
   }),
 });
 
-const createMockIssueRepository = (
-  issues: Issue[],
-): Pick<IssueRepository, 'getAllOpened'> => ({
-  getAllOpened: jest.fn().mockResolvedValue(issues),
-});
-
 describe('notifySilentTmuxSessions', () => {
-  let outputDirectory: string;
+  let configDir: string;
   let cacheDirectory: string;
 
   beforeEach(() => {
     jest.spyOn(console, 'log').mockImplementation(() => undefined);
-    outputDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'silent-output-'));
+    configDir = fs.mkdtempSync(path.join(os.tmpdir(), 'silent-config-'));
     cacheDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'silent-cache-'));
   });
 
   afterEach(() => {
     jest.restoreAllMocks();
-    fs.rmSync(outputDirectory, { force: true, recursive: true });
+    fs.rmSync(configDir, { force: true, recursive: true });
     fs.rmSync(cacheDirectory, { force: true, recursive: true });
   });
 
-  const writeSilentOutputFile = (sessionName: string): void => {
-    const fileName = sessionName.replace(/\//g, '_');
-    const filePath = path.join(outputDirectory, fileName);
-    fs.writeFileSync(filePath, 'output', 'utf8');
-    const silentEpoch = NOW_EPOCH_SECONDS - 11 * 60;
-    fs.utimesSync(filePath, silentEpoch, silentEpoch);
+  const writeTranscript = (lines: object[]): void => {
+    const projectDirectory = path.join(configDir, 'projects', '-home-user');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDirectory, `${SESSION_ID}.jsonl`),
+      lines.map((line) => JSON.stringify(line)).join('\n'),
+      'utf8',
+    );
+  };
+
+  const silentAssistantTranscript = (): void => {
+    const silentTimestamp = new Date(
+      (NOW_EPOCH_SECONDS - 11 * 60) * 1000,
+    ).toISOString();
+    writeTranscript([
+      {
+        type: 'assistant',
+        timestamp: silentTimestamp,
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'progress update' }],
+        },
+      },
+    ]);
   };
 
   const makeCacheRepository = (): LocalStorageCacheRepository =>
@@ -117,16 +82,44 @@ describe('notifySilentTmuxSessions', () => {
       cacheDirectory,
     );
 
+  const makeEnvironReader = (): ProcessEnvironReader => ({
+    readEnviron: (pid: number) =>
+      pid === CLAUDE_PID
+        ? {
+            CLAUDE_CODE_SESSION_ID: SESSION_ID,
+            CLAUDE_CONFIG_DIR: configDir,
+          }
+        : null,
+  });
+
+  const liveSessionRunner = (): Mocked<LocalCommandRunner> => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return { stdout: `${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 ${SESSION_NAME}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+    return runner;
+  };
+
   const baseParams = (
     runner: LocalCommandRunner,
   ): Parameters<typeof notifySilentTmuxSessions>[0] => ({
-    project: makeProject(),
-    allowCacheMinutes: ALLOW_CACHE_MINUTES,
-    issueRepository: createMockIssueRepository([makeIssue()]),
+    enabled: true,
     localCommandRunner: runner,
+    processEnvironReader: makeEnvironReader(),
     cacheRepository: makeCacheRepository(),
-    sessionOutputRootDirectory: outputDirectory,
-    sessionTranscriptRootDirectory: null,
     ownerCallMarker: null,
     subAgentOutputRootDirectory: null,
     subAgentProcessMatchPattern: null,
@@ -136,20 +129,9 @@ describe('notifySilentTmuxSessions', () => {
     ...DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS,
   });
 
-  const listSessionsRunner = (): Mocked<LocalCommandRunner> => {
-    const runner = createMockRunner();
-    runner.runCommand.mockImplementation(async (program, args) => {
-      if (program === 'tmux' && args[0] === 'list-sessions') {
-        return { stdout: `${SESSION_NAME}\n`, stderr: '', exitCode: 0 };
-      }
-      return { stdout: '', stderr: '', exitCode: 0 };
-    });
-    return runner;
-  };
-
-  it('sends a main stalled notification to a silent monitored live session', async () => {
-    writeSilentOutputFile(SESSION_NAME);
-    const runner = listSessionsRunner();
+  it('sends a main stalled notification to a silent plain-named live session', async () => {
+    silentAssistantTranscript();
+    const runner = liveSessionRunner();
 
     await notifySilentTmuxSessions(baseParams(runner));
 
@@ -160,52 +142,21 @@ describe('notifySilentTmuxSessions', () => {
     expect(sendCall?.[1][4]).toContain('You have produced no output for');
   });
 
-  it('does nothing when neither output root nor sub-agent pattern is configured', async () => {
-    writeSilentOutputFile(SESSION_NAME);
-    const runner = createMockRunner();
+  it('does nothing when the step is not enabled', async () => {
+    silentAssistantTranscript();
+    const runner = liveSessionRunner();
 
     await notifySilentTmuxSessions({
       ...baseParams(runner),
-      sessionOutputRootDirectory: null,
-      subAgentProcessMatchPattern: null,
+      enabled: false,
     });
 
     expect(runner.runCommand.mock.calls).toHaveLength(0);
   });
 
-  it('sends a sub-agent notification driven by the process match pattern even when the main session is not silent', async () => {
-    const runner = createMockRunner();
-    runner.runCommand.mockImplementation(async (program, args) => {
-      if (program === 'tmux' && args[0] === 'list-sessions') {
-        return { stdout: `${SESSION_NAME}\n`, stderr: '', exitCode: 0 };
-      }
-      if (program === 'ps') {
-        return {
-          stdout: `  1200 worker session=${SESSION_NAME} label=task-a\n`,
-          stderr: '',
-          exitCode: 0,
-        };
-      }
-      return { stdout: '', stderr: '', exitCode: 0 };
-    });
-
-    await notifySilentTmuxSessions({
-      ...baseParams(runner),
-      sessionOutputRootDirectory: null,
-      subAgentProcessMatchPattern:
-        'session=(?<session>[^ ]+) label=(?<label>[^ ]+)',
-    });
-
-    const sendCall = runner.runCommand.mock.calls.find(
-      (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
-    );
-    expect(sendCall?.[1][2]).toBe(SESSION_NAME);
-    expect(sendCall?.[1][4]).toContain('task-a');
-  });
-
   it('uses the configured main stalled message template when provided', async () => {
-    writeSilentOutputFile(SESSION_NAME);
-    const runner = listSessionsRunner();
+    silentAssistantTranscript();
+    const runner = liveSessionRunner();
 
     await notifySilentTmuxSessions({
       ...baseParams(runner),
@@ -223,41 +174,28 @@ describe('notifySilentTmuxSessions', () => {
   });
 
   it('suppresses the main stalled notification when the transcript shows an unanswered owner call', async () => {
-    writeSilentOutputFile(SESSION_NAME);
-    const transcriptDirectory = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'silent-transcript-'),
-    );
-    const transcriptPath = path.join(
-      transcriptDirectory,
-      `${SESSION_NAME.replace(/\//g, '_')}.jsonl`,
-    );
-    fs.writeFileSync(
-      transcriptPath,
-      [
-        JSON.stringify({
-          type: 'user',
-          timestamp: '2026-06-25T23:00:00.000Z',
-          message: { role: 'user', content: 'go ahead' },
-        }),
-        JSON.stringify({
-          type: 'assistant',
-          timestamp: '2026-06-25T23:50:00.000Z',
-          message: {
-            role: 'assistant',
-            stop_reason: 'end_turn',
-            content: [
-              { type: 'text', text: 'waiting <<OWNER_CALL>> please decide' },
-            ],
-          },
-        }),
-      ].join('\n'),
-      'utf8',
-    );
-    const runner = listSessionsRunner();
+    writeTranscript([
+      {
+        type: 'user',
+        timestamp: '2026-06-25T23:00:00.000Z',
+        message: { role: 'user', content: 'go ahead' },
+      },
+      {
+        type: 'assistant',
+        timestamp: '2026-06-25T23:50:00.000Z',
+        message: {
+          role: 'assistant',
+          stop_reason: 'end_turn',
+          content: [
+            { type: 'text', text: 'waiting <<OWNER_CALL>> please decide' },
+          ],
+        },
+      },
+    ]);
+    const runner = liveSessionRunner();
 
     await notifySilentTmuxSessions({
       ...baseParams(runner),
-      sessionTranscriptRootDirectory: transcriptDirectory,
       ownerCallMarker: '<<OWNER_CALL>>',
     });
 
@@ -265,65 +203,19 @@ describe('notifySilentTmuxSessions', () => {
       (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
     );
     expect(sendCall).toBeUndefined();
-    fs.rmSync(transcriptDirectory, { force: true, recursive: true });
-  });
-
-  it('sends a sub-agent notification driven by a running transcript even when the main session is not silent', async () => {
-    const transcriptRoot = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'silent-subagent-tx-'),
-    );
-    const subAgentsDir = path.join(
-      transcriptRoot,
-      SESSION_NAME.replace(/\//g, '_'),
-      'subagents',
-    );
-    fs.mkdirSync(subAgentsDir, { recursive: true });
-    const agentPath = path.join(subAgentsDir, 'agent-running1.jsonl');
-    fs.writeFileSync(
-      agentPath,
-      [
-        JSON.stringify({
-          type: 'user',
-          timestamp: '2026-06-25T23:30:00.000Z',
-          message: { role: 'user' },
-        }),
-        JSON.stringify({
-          type: 'assistant',
-          timestamp: '2026-06-25T23:40:00.000Z',
-          message: { role: 'assistant', stop_reason: 'tool_use' },
-        }),
-      ].join('\n'),
-      'utf8',
-    );
-    const silentEpoch = NOW_EPOCH_SECONDS - 6 * 60;
-    fs.utimesSync(agentPath, silentEpoch, silentEpoch);
-    const runner = listSessionsRunner();
-
-    await notifySilentTmuxSessions({
-      ...baseParams(runner),
-      sessionOutputRootDirectory: null,
-      subAgentTranscriptRootDirectory: transcriptRoot,
-    });
-
-    const sendCall = runner.runCommand.mock.calls.find(
-      (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
-    );
-    expect(sendCall?.[1][2]).toBe(SESSION_NAME);
-    expect(sendCall?.[1][4]).toContain('agent-running1');
-    fs.rmSync(transcriptRoot, { force: true, recursive: true });
   });
 
   it('does not re-notify the same silent session on the next cycle within cooldown', async () => {
-    writeSilentOutputFile(SESSION_NAME);
+    silentAssistantTranscript();
     const cacheRepository = makeCacheRepository();
-    const firstRunner = listSessionsRunner();
+    const firstRunner = liveSessionRunner();
 
     await notifySilentTmuxSessions({
       ...baseParams(firstRunner),
       cacheRepository,
     });
 
-    const secondRunner = listSessionsRunner();
+    const secondRunner = liveSessionRunner();
     await notifySilentTmuxSessions({
       ...baseParams(secondRunner),
       cacheRepository,

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

@@ -1,11 +1,9 @@
-import { Project } from '../../../domain/entities/Project';
 import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
 import { SessionSubAgentActivityRepository } from '../../../domain/usecases/adapter-interfaces/SessionSubAgentActivityRepository';
 import { OwnerCallStatusProvider } from '../../../domain/usecases/adapter-interfaces/OwnerCallStatusProvider';
+import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
 import {
   NotifySilentLiveSessionsUseCase,
-  DEFAULT_MONITORED_STATUS,
   DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
@@ -13,7 +11,9 @@ import {
   DEFAULT_NOTIFICATION_STAGGER_SECONDS,
 } from '../../../domain/usecases/NotifySilentLiveSessionsUseCase';
 import { DefaultSilentSessionMessageComposer } from '../../../domain/usecases/DefaultSilentSessionMessageComposer';
-import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRepository';
+import { LocalProcessLiveSessionProcessSnapshotProvider } from '../../repositories/LocalProcessLiveSessionProcessSnapshotProvider';
+import { ProcFsProcessEnvironReader } from '../../repositories/ProcFsProcessEnvironReader';
+import { FileSystemInteractiveLiveSessionTranscriptResolver } from '../../repositories/FileSystemInteractiveLiveSessionTranscriptResolver';
 import { FileSystemSessionOutputActivityRepository } from '../../repositories/FileSystemSessionOutputActivityRepository';
 import { TmuxSilentSessionNotificationRepository } from '../../repositories/TmuxSilentSessionNotificationRepository';
 import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCacheRepository';
@@ -31,13 +31,10 @@ import {
 import { RealSleeper } from '../../repositories/RealSleeper';
 
 export type NotifySilentTmuxSessionsParams = {
-  project: Project;
-  allowCacheMinutes: number;
-  issueRepository: Pick<IssueRepository, 'getAllOpened'>;
+  enabled: boolean;
   localCommandRunner: LocalCommandRunner;
+  processEnvironReader?: ProcessEnvironReader;
   cacheRepository: Pick<LocalStorageCacheRepository, 'getLatest' | 'set'>;
-  sessionOutputRootDirectory: string | null;
-  sessionTranscriptRootDirectory: string | null;
   ownerCallMarker: string | null;
   subAgentOutputRootDirectory: string | null;
   subAgentProcessMatchPattern: string | null;
@@ -52,18 +49,10 @@ export type NotifySilentTmuxSessionsParams = {
 };
 
 const createOwnerCallStatusProvider = (
-  sessionTranscriptRootDirectory: string | null,
   ownerCallMarker: string | null,
 ): OwnerCallStatusProvider => {
-  if (
-    sessionTranscriptRootDirectory !== null &&
-    ownerCallMarker !== null &&
-    ownerCallMarker.length > 0
-  ) {
-    return new TranscriptOwnerCallStatusProvider(
-      sessionTranscriptRootDirectory,
-      ownerCallMarker,
-    );
+  if (ownerCallMarker !== null && ownerCallMarker.length > 0) {
+    return new TranscriptOwnerCallStatusProvider(ownerCallMarker);
   }
   return new NoUnansweredOwnerCallStatusProvider();
 };
@@ -97,13 +86,10 @@ export const notifySilentTmuxSessions = async (
   params: NotifySilentTmuxSessionsParams,
 ): Promise<void> => {
   const {
-    project,
-    allowCacheMinutes,
-    issueRepository,
+    enabled,
     localCommandRunner,
+    processEnvironReader,
     cacheRepository,
-    sessionOutputRootDirectory,
-    sessionTranscriptRootDirectory,
     ownerCallMarker,
     subAgentOutputRootDirectory,
     subAgentProcessMatchPattern,
@@ -116,13 +102,9 @@ export const notifySilentTmuxSessions = async (
     messageTemplates,
     now,
   } = params;
-  if (
-    sessionOutputRootDirectory === null &&
-    subAgentProcessMatchPattern === null &&
-    subAgentTranscriptRootDirectory === null
-  ) {
+  if (!enabled) {
     console.log(
-      'Silent live session notification skipped: no session output root directory, sub-agent process match pattern, or sub-agent transcript root directory is configured.',
+      'Silent live session notification skipped: not enabled (set silentNotificationEnabled or TDPM_SILENT_NOTIFICATION_ENABLED=true to enable).',
     );
     return;
   }
@@ -131,9 +113,12 @@ export const notifySilentTmuxSessions = async (
     new DefaultSilentSessionMessageComposer(),
   );
   const useCase = new NotifySilentLiveSessionsUseCase(
-    issueRepository,
-    new NodeTmuxSessionRepository(localCommandRunner),
-    new FileSystemSessionOutputActivityRepository(sessionOutputRootDirectory),
+    new LocalProcessLiveSessionProcessSnapshotProvider(
+      localCommandRunner,
+      processEnvironReader ?? new ProcFsProcessEnvironReader(),
+    ),
+    new FileSystemInteractiveLiveSessionTranscriptResolver(),
+    new FileSystemSessionOutputActivityRepository(),
     createSubAgentActivityRepository(
       subAgentTranscriptRootDirectory,
       subAgentProcessMatchPattern,
@@ -141,10 +126,7 @@ export const notifySilentTmuxSessions = async (
       localCommandRunner,
       now,
     ),
-    createOwnerCallStatusProvider(
-      sessionTranscriptRootDirectory,
-      ownerCallMarker,
-    ),
+    createOwnerCallStatusProvider(ownerCallMarker),
     new TmuxSilentSessionNotificationRepository(
       localCommandRunner,
       cacheRepository,
@@ -153,9 +135,6 @@ export const notifySilentTmuxSessions = async (
     new RealSleeper(),
   );
   await useCase.run({
-    project,
-    allowCacheMinutes,
-    monitoredStatus: DEFAULT_MONITORED_STATUS,
     mainSilentThresholdSeconds,
     subAgentSilentThresholdSeconds,
     subAgentRunningThresholdSeconds,

package/src/adapter/proxy/RateLimitCache.test.ts

@@ -15,6 +15,7 @@ import {
   writeRateLimit,
   writeSubscriptionDisabled,
 } from './RateLimitCache';
+import { OauthTokenSelectUseCase } from '../../domain/usecases/OauthTokenSelectUseCase';
 
 const isRecord = (v: unknown): v is Record<string, unknown> =>
   v !== null && typeof v === 'object' && !Array.isArray(v);
@@ -863,4 +864,66 @@ describe('RateLimitCache', () => {
       expect(snapshot?.subscriptionDisabled).toBe(false);
     });
   });
+
+  describe('writeRateLimit preserves subscriptionDisabledEpoch across header writes', () => {
+    const headerBearingResponse: Record<string, string> = {
+      'anthropic-ratelimit-unified-status': 'allowed',
+      'anthropic-ratelimit-unified-5h-status': 'allowed',
+      'anthropic-ratelimit-unified-5h-reset': '2000100',
+      'anthropic-ratelimit-unified-5h-utilization': '0.1',
+      'anthropic-ratelimit-unified-7d-status': 'allowed',
+      'anthropic-ratelimit-unified-7d-reset': '2000200',
+      'anthropic-ratelimit-unified-7d-utilization': '0.1',
+    };
+
+    it('keeps subscriptionDisabled: true after a later header-bearing 200 response', () => {
+      const token = 'sub-disabled-then-200-token';
+      writeSubscriptionDisabled(token);
+      writeRateLimit(token, headerBearingResponse, 200);
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.subscriptionDisabled).toBe(true);
+      expect(snapshot?.fiveHourReset).toBe(2000100);
+    });
+
+    it('keeps subscriptionDisabled: true after a later header-bearing 429 response', () => {
+      const token = 'sub-disabled-then-429-token';
+      writeSubscriptionDisabled(token);
+      writeRateLimit(token, headerBearingResponse, 429);
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.subscriptionDisabled).toBe(true);
+    });
+
+    it('still excludes the token from selection after a header-bearing response', () => {
+      const token = 'sub-disabled-then-200-selection-token';
+      writeSubscriptionDisabled(token);
+      writeRateLimit(token, headerBearingResponse, 200);
+      const snapshot = readRateLimit(token);
+      const useCase = new OauthTokenSelectUseCase();
+      const result = useCase.run(
+        [
+          {
+            name: 'disabled-token',
+            token,
+            snapshot:
+              snapshot === null
+                ? null
+                : {
+                    fiveHourUtilization: snapshot.fiveHourUtilization,
+                    fiveHourReset: snapshot.fiveHourReset,
+                    sevenDayUtilization: snapshot.sevenDayUtilization,
+                    sevenDayReset: snapshot.sevenDayReset,
+                  },
+            subscriptionDisabled: snapshot?.subscriptionDisabled ?? false,
+            unifiedRejected: snapshot?.unifiedRejected ?? false,
+          },
+        ],
+        Date.now() / 1000,
+      );
+      expect(result.selected).toBeNull();
+      expect(result.metrics[0]?.eligible).toBe(false);
+      expect(result.metrics[0]?.exclusionReason).toBe(
+        'organization has disabled Claude subscription access for Claude Code',
+      );
+    });
+  });
 });