github-issue-tower-defence-management 1.122.8 → 1.122.10

package/src/domain/entities/Project.ts

@@ -3,14 +3,7 @@ export type FieldOption = {
   id: string;
   name: string;
   color:
-    | 'GRAY'
-    | 'BLUE'
-    | 'GREEN'
-    | 'YELLOW'
-    | 'ORANGE'
-    | 'RED'
-    | 'PINK'
-    | 'PURPLE';
+    'GRAY' | 'BLUE' | 'GREEN' | 'YELLOW' | 'ORANGE' | 'RED' | 'PINK' | 'PURPLE';
   description: string;
 };
 export type Project = {

package/src/domain/usecases/AssignNoAssigneeIssueToManagerUseCase.test.ts

@@ -185,9 +185,9 @@ describe('AssignNoAssigneeIssueToManagerUseCase', () => {
         ...basicIssue,
         url: 'https://github.com/testOrg/testRepo/issues/44',
       };
+      const nonErrorValue: unknown = 'string-failure';
       mockIssueRepository.updateAssigneeList.mockImplementationOnce(() => {
-        const nonError: unknown = 'string-failure';
-        throw nonError;
+        throw nonErrorValue;
       });
 
       await expect(

package/src/domain/usecases/DefaultSilentSessionMessageComposer.test.ts

@@ -48,7 +48,9 @@ describe('DefaultSilentSessionMessageComposer', () => {
         'Keep a monitor in place that notices when a sub-agent has produced no output for about 5 minutes.',
       ),
     ).toBe(1);
-    expect(occurrences('share it through a new owner-call')).toBe(1);
+    expect(
+      occurrences('work the owner asked for has been completed or answered'),
+    ).toBe(1);
   });
 
   it('requests a remaining-minutes estimate in the next output', () => {
@@ -63,40 +65,38 @@ describe('DefaultSilentSessionMessageComposer', () => {
     expect(section).toContain('No output has been observed for 10 minutes.');
   });
 
-  it('states the owner-call tag format exactly once: complete pair on one line, content starting with the red-circle emoji, self-contained', () => {
+  it('states the owner-call format guidance exactly once, deferring to the session-documented format', () => {
     const section = composer.composeMainStalledSection(600);
     const formatOccurrences =
-      section.split('complete opening and closing pair on one line').length - 1;
+      section.split('in the format documented for this session').length - 1;
     expect(formatOccurrences).toBe(1);
-    expect(section).toContain('🔴');
+    expect(section).toContain('written to be self-contained');
     expect(section).toContain(
-      'with the content starting immediately with the 🔴 emoji',
+      'so the owner can understand the situation from that single message',
     );
-    expect(section).toContain('written to be self-contained');
   });
 
   it('explains that the owner is notified only when an owner-call is raised', () => {
     const section = composer.composeMainStalledSection(600);
-    expect(section).toContain('the owner is notified only when one is raised');
-  });
-
-  it('interpolates the configured owner-call marker into the format guidance when provided', () => {
-    const markedComposer = new DefaultSilentSessionMessageComposer(
-      '<<OWNER_CALL>>',
-    );
-    const section = markedComposer.composeMainStalledSection(600);
     expect(section).toContain(
-      'owner-call marker tag "<<OWNER_CALL>>" as a complete opening and closing pair on one line',
+      'The owner is notified only when an owner-call is raised.',
     );
-    expect(section).toContain('🔴');
   });
 
-  it('falls back to generic owner-call format guidance when no marker is configured', () => {
+  it('frames a completed owner request as awaiting acknowledgment rather than a no-action case', () => {
     const section = composer.composeMainStalledSection(600);
     expect(section).toContain(
-      'owner-call marker tag as a complete opening and closing pair on one line',
+      "a completion still awaits the owner's acknowledgment",
     );
-    expect(section).not.toContain('""');
+    expect(section).toContain('so it is not a no-action case');
+  });
+
+  it('contains no marker-tag example, tag name, or angle bracket in the format guidance', () => {
+    const section = composer.composeMainStalledSection(600);
+    expect(section).not.toContain('marker tag');
+    expect(section).not.toContain('opening and closing pair');
+    expect(section).not.toContain('<');
+    expect(section).not.toContain('>');
   });
 
   it('embeds the reminder sentinel in the stale-owner-call main-stalled section', () => {
@@ -166,22 +166,19 @@ describe('DefaultSilentSessionMessageComposer', () => {
       3600,
     );
     const formatOccurrences =
-      section.split('complete opening and closing pair on one line').length - 1;
+      section.split('in the format documented for this session').length - 1;
     expect(formatOccurrences).toBe(1);
   });
 
-  it('interpolates the configured owner-call marker into the stale-owner-call format guidance', () => {
-    const markedComposer = new DefaultSilentSessionMessageComposer(
-      '<<OWNER_CALL>>',
-    );
-    const section = markedComposer.composeMainStalledWithStaleOwnerCallSection(
+  it('contains no marker-tag example, tag name, or angle bracket in the stale-owner-call section', () => {
+    const section = composer.composeMainStalledWithStaleOwnerCallSection(
       600,
       3600,
     );
-    expect(section).toContain(
-      'owner-call marker tag "<<OWNER_CALL>>" as a complete opening and closing pair on one line',
-    );
-    expect(section).toContain('🔴');
+    expect(section).not.toContain('marker tag');
+    expect(section).not.toContain('opening and closing pair');
+    expect(section).not.toContain('<');
+    expect(section).not.toContain('>');
   });
 
   it('composes the stale-owner-call section distinctly from the plain main-stalled section', () => {
@@ -350,9 +347,6 @@ describe('DefaultSilentSessionMessageComposer', () => {
       /do not wait passively/i,
       /is prohibited/i,
     ];
-    const markedComposer = new DefaultSilentSessionMessageComposer(
-      '<<OWNER_CALL>>',
-    );
     const subAgent = {
       label: 'sub-process-1',
       silentSeconds: 360,
@@ -361,9 +355,7 @@ describe('DefaultSilentSessionMessageComposer', () => {
     };
     const composedDefaultTexts = [
       composer.composeMainStalledSection(600),
-      markedComposer.composeMainStalledSection(600),
       composer.composeMainStalledWithStaleOwnerCallSection(600, 3600),
-      markedComposer.composeMainStalledWithStaleOwnerCallSection(600, 3600),
       composer.composeSubAgentSection({
         idleSubAgents: [subAgent],
         longRunningSubAgents: [subAgent],
@@ -376,6 +368,34 @@ describe('DefaultSilentSessionMessageComposer', () => {
     }
   });
 
+  it('composes default texts free of angle-bracket tag examples and emoji characters', () => {
+    const emojiPattern =
+      /[\u{1F000}-\u{1FAFF}\u{2190}-\u{21FF}\u{2300}-\u{23FF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}]/u;
+    const subAgent = {
+      label: 'sub-process-1',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const composedDefaultTexts = [
+      composer.composeMainStalledSection(600),
+      composer.composeMainStalledWithStaleOwnerCallSection(600, 3600),
+      composer.composeSubAgentSection({
+        idleSubAgents: [subAgent],
+        longRunningSubAgents: [subAgent],
+      }),
+    ];
+    for (const text of composedDefaultTexts) {
+      expect(text).not.toContain('<');
+      expect(text).not.toContain('>');
+      expect(text).not.toMatch(emojiPattern);
+      expect(text).not.toContain('\u{FE0F}');
+      expect(text).not.toContain('\u{200D}');
+      // The bracketed reminder sentinel remains allowed.
+      expect(text).toContain(SILENT_SESSION_REMINDER_SENTINEL);
+    }
+  });
+
   it('does not contain any host-specific or internal identifiers', () => {
     const mainSection = composer.composeMainStalledSection(600);
     const subAgent = {

package/src/domain/usecases/DefaultSilentSessionMessageComposer.ts

@@ -42,29 +42,18 @@ const composeLongRunningSubAgentSection = (
   ].join('\n');
 };
 
-export const composeOwnerCallFormatGuidance = (
-  ownerCallMarker: string | null,
-): string => {
-  const tagLabel =
-    ownerCallMarker !== null && ownerCallMarker.length > 0
-      ? ` "${ownerCallMarker}"`
-      : '';
-  return `Format reminder: write the owner-call marker tag${tagLabel} as a complete opening and closing pair on one line, with the content starting immediately with the 🔴 emoji and written to be self-contained, so the owner can understand the situation, the ask, and any decision needed from that single message.`;
+export const composeOwnerCallFormatGuidance = (): string => {
+  return 'Please share it through a new owner-call in the format documented for this session, written to be self-contained so the owner can understand the situation from that single message.';
 };
 
-const composeMainStalledMessage = (
-  mainSilentSeconds: number,
-  ownerCallMarker: string | null,
-): string => {
+const composeMainStalledMessage = (mainSilentSeconds: number): string => {
   const minutes = Math.floor(mainSilentSeconds / 60);
   return [
     `${SILENT_SESSION_REMINDER_SENTINEL} This is an automated status check. No output has been observed for ${minutes} minutes. If you are waiting on an external process, no action is needed — please log one line explaining the wait. Otherwise please continue with the next step, with these points in mind:`,
     `1. Keep the session task list current, marking finished items as done.`,
     `2. Run independent pieces of work in parallel across sub-agents.`,
     `3. Keep a monitor in place that notices when a sub-agent has produced no output for about 5 minutes.`,
-    `4. When an owner decision is needed, or when an owner request has been completed or answered, please share it through a new owner-call — the owner is notified only when one is raised. ${composeOwnerCallFormatGuidance(
-      ownerCallMarker,
-    )}`,
+    `4. When an owner decision is needed, or when work the owner asked for has been completed or answered, please share it through a new owner-call — a completion still awaits the owner's acknowledgment, so it is not a no-action case. The owner is notified only when an owner-call is raised. ${composeOwnerCallFormatGuidance()}`,
     `Please also include in your next output an estimate of the remaining minutes to finish all tasks.`,
   ].join('\n');
 };
@@ -72,24 +61,19 @@ const composeMainStalledMessage = (
 const composeMainStalledWithStaleOwnerCallMessage = (
   mainSilentSeconds: number,
   unansweredOwnerCallAgeSeconds: number,
-  ownerCallMarker: string | null,
 ): string => {
   const silentMinutes = Math.floor(mainSilentSeconds / 60);
   const ownerCallAgeMinutes = Math.floor(unansweredOwnerCallAgeSeconds / 60);
   return [
     `${SILENT_SESSION_REMINDER_SENTINEL} This is an automated status check. No output has been observed for ${silentMinutes} minutes, and the owner call raised ${ownerCallAgeMinutes} minutes ago has not yet been acknowledged by the owner.`,
-    `An owner call without an acknowledgment — whether it carried a completion report, a question, or a decision request — is still awaiting the owner's acknowledgment, and the earlier message may have been missed. Please re-raise its content as a fresh, self-contained owner call. ${composeOwnerCallFormatGuidance(
-      ownerCallMarker,
-    )}`,
+    `An owner call without an acknowledgment — whether it carried a completion report, a question, or a decision request — is still awaiting the owner's acknowledgment, and the earlier message may have been missed. Please re-raise its content as a fresh, self-contained owner call. ${composeOwnerCallFormatGuidance()}`,
     `Please also include in your next output an estimate of the remaining minutes to finish all tasks.`,
   ].join('\n');
 };
 
 export class DefaultSilentSessionMessageComposer implements SilentSessionMessageComposer {
-  constructor(private readonly ownerCallMarker: string | null = null) {}
-
   composeMainStalledSection = (mainSilentSeconds: number): string => {
-    return composeMainStalledMessage(mainSilentSeconds, this.ownerCallMarker);
+    return composeMainStalledMessage(mainSilentSeconds);
   };
 
   composeMainStalledWithStaleOwnerCallSection = (
@@ -99,7 +83,6 @@ export class DefaultSilentSessionMessageComposer implements SilentSessionMessage
     return composeMainStalledWithStaleOwnerCallMessage(
       mainSilentSeconds,
       unansweredOwnerCallAgeSeconds,
-      this.ownerCallMarker,
     );
   };
 

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -33,9 +33,7 @@ export class IllegalIssueStatusError extends Error {
   }
 }
 type RejectedReasonType =
-  | 'NO_REPORT_FROM_AGENT_BOT'
-  | 'REPORT_HAS_NEXT_STEP'
-  | PrRejectedReasonType;
+  'NO_REPORT_FROM_AGENT_BOT' | 'REPORT_HAS_NEXT_STEP' | PrRejectedReasonType;
 
 export class NotifyFinishedIssuePreparationUseCase {
   private readonly issueRejectionEvaluator: IssueRejectionEvaluator;

package/src/domain/usecases/NotifySilentLiveSessionsUseCase.test.ts

@@ -17,6 +17,7 @@ import { InteractiveLiveSessionTranscriptResolver } from './adapter-interfaces/I
 import { SessionOutputActivityRepository } from './adapter-interfaces/SessionOutputActivityRepository';
 import { SessionSubAgentActivityRepository } from './adapter-interfaces/SessionSubAgentActivityRepository';
 import { OwnerCallStatusProvider } from './adapter-interfaces/OwnerCallStatusProvider';
+import { RefusalTailStatusProvider } from './adapter-interfaces/RefusalTailStatusProvider';
 import { SilentSessionNotificationRepository } from './adapter-interfaces/SilentSessionNotificationRepository';
 import { SilentSessionCandidateStateRepository } from './adapter-interfaces/SilentSessionCandidateStateRepository';
 import { SilentSessionHubTaskStatusCacheRepository } from './adapter-interfaces/SilentSessionHubTaskStatusCacheRepository';
@@ -52,6 +53,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
   let mockSleeper: Mocked<Sleeper>;
   let mockHubTaskStatusResolver: Mocked<HubTaskStatusResolver>;
   let mockHubTaskStatusCacheRepository: Mocked<SilentSessionHubTaskStatusCacheRepository>;
+  let mockRefusalTailStatusProvider: Mocked<RefusalTailStatusProvider>;
   const now = new Date('2026-06-26T00:00:00Z');
   const nowEpochSeconds = Math.floor(now.getTime() / 1000);
   const GITHUB_SESSION = 'https_//github_com/HiromiShikata/repo/issues/42';
@@ -191,6 +193,11 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       loadHubTaskStatus: jest.fn().mockResolvedValue(null),
       saveHubTaskStatus: jest.fn().mockResolvedValue(undefined),
     };
+    mockRefusalTailStatusProvider = {
+      listRefusalTailedSessionNames: jest
+        .fn()
+        .mockResolvedValue(new Set<string>()),
+    };
     useCase = new NotifySilentLiveSessionsUseCase(
       mockSnapshotProvider,
       mockTranscriptResolver,
@@ -203,6 +210,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       mockSleeper,
       mockHubTaskStatusResolver,
       mockHubTaskStatusCacheRepository,
+      mockRefusalTailStatusProvider,
     );
   });
 
@@ -388,7 +396,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     ).toHaveBeenCalledWith([GITHUB_SESSION], expectedMap);
   });
 
-  it('suppresses the stalled section and sends nothing while the unanswered owner call is younger than the grace period', async () => {
+  it('suppresses the stalled section and sends nothing while the latest owner call is unanswered', async () => {
     setupSilentMainSession(GITHUB_SESSION);
     mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
       new Map([
@@ -412,47 +420,33 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     ).not.toHaveBeenCalled();
   });
 
-  it('sends the stale-owner-call stalled section once the unanswered owner call reaches the grace period', async () => {
+  it('suppresses the reminder even when the unanswered owner call is far older than the former grace period (10 hours)', async () => {
     setupSilentMainSession(GITHUB_SESSION);
     mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
-      new Map([
-        [
-          GITHUB_SESSION,
-          nowEpochSeconds - DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
-        ],
-      ]),
+      new Map([[GITHUB_SESSION, nowEpochSeconds - 10 * 60 * 60]]),
     );
 
     await useCase.run(runParams());
 
     expect(
       mockMessageComposer.composeMainStalledWithStaleOwnerCallSection,
-    ).toHaveBeenCalledWith(
-      DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-      DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
-    );
+    ).not.toHaveBeenCalled();
     expect(
       mockMessageComposer.composeMainStalledSection,
     ).not.toHaveBeenCalled();
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
-    ).toHaveBeenCalledWith(
-      GITHUB_SESSION,
-      MAIN_STALLED_STALE_OWNER_CALL_SECTION,
-    );
+    ).not.toHaveBeenCalled();
+    expect(
+      mockCandidateStateRepository.saveCandidateSessionNames,
+    ).toHaveBeenCalledWith({
+      sessionNames: [],
+      now,
+    });
   });
 
-  it('does not send the stale-owner-call section when the owner call is past the grace period but the main output is not silent past the threshold', async () => {
-    setupLiveInteractiveSession(GITHUB_SESSION);
-    mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
-      [
-        {
-          sessionName: GITHUB_SESSION,
-          lastOutputEpochSeconds:
-            nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS + 1,
-        },
-      ],
-    );
+  it('suppresses the reminder at exactly the former grace-period age instead of firing the stale-owner-call section', async () => {
+    setupSilentMainSession(GITHUB_SESSION);
     mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
       new Map([
         [
@@ -464,13 +458,28 @@ describe('NotifySilentLiveSessionsUseCase', () => {
 
     await useCase.run(runParams());
 
+    expect(
+      mockMessageComposer.composeMainStalledWithStaleOwnerCallSection,
+    ).not.toHaveBeenCalled();
+    expect(
+      mockMessageComposer.composeMainStalledSection,
+    ).not.toHaveBeenCalled();
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
     ).not.toHaveBeenCalled();
   });
 
-  it('defers a first-cycle stale-owner-call candidate until it persists into the next cycle', async () => {
-    setupSilentMainSession(GITHUB_SESSION);
+  it('does not send anything when the owner call is old and the main output is not silent past the threshold', async () => {
+    setupLiveInteractiveSession(GITHUB_SESSION);
+    mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+      [
+        {
+          sessionName: GITHUB_SESSION,
+          lastOutputEpochSeconds:
+            nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS + 1,
+        },
+      ],
+    );
     mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
       new Map([
         [
@@ -479,21 +488,12 @@ describe('NotifySilentLiveSessionsUseCase', () => {
         ],
       ]),
     );
-    mockCandidateStateRepository.loadRecentCandidateSessionNames.mockResolvedValue(
-      new Set<string>(),
-    );
 
     await useCase.run(runParams());
 
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
     ).not.toHaveBeenCalled();
-    expect(
-      mockCandidateStateRepository.saveCandidateSessionNames,
-    ).toHaveBeenCalledWith({
-      sessionNames: [GITHUB_SESSION],
-      now,
-    });
   });
 
   it('sends the main stalled section when the session is silent past the threshold and not waiting on the owner', async () => {
@@ -1485,6 +1485,145 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     });
   });
 
+  describe('refusal-tailed session gating', () => {
+    it('excludes a main-stalled session whose last assistant turn is a refusal and logs one skip line', async () => {
+      setupSilentMainSession(GITHUB_SESSION);
+      mockRefusalTailStatusProvider.listRefusalTailedSessionNames.mockResolvedValue(
+        new Set([GITHUB_SESSION]),
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockMessageComposer.composeMainStalledSection,
+      ).not.toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+      const skipLines = jest
+        .mocked(console.log)
+        .mock.calls.filter(
+          (call) =>
+            typeof call[0] === 'string' &&
+            call[0].includes('last assistant turn was a model refusal'),
+        );
+      expect(skipLines).toEqual([
+        [
+          `Skipping ${GITHUB_SESSION}: last assistant turn was a model refusal; suppressing reminders until a non-refusal turn appears.`,
+        ],
+      ]);
+    });
+
+    it('excludes a refusal-tailed session from the sub-agent reminder branch as well', async () => {
+      setupLiveInteractiveSession(GITHUB_SESSION);
+      const subAgents: SubAgentActivity[] = [
+        {
+          label: 'sub-process-1',
+          silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ];
+      mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
+        new Map([[GITHUB_SESSION, subAgents]]),
+      );
+      mockRefusalTailStatusProvider.listRefusalTailedSessionNames.mockResolvedValue(
+        new Set([GITHUB_SESSION]),
+      );
+
+      await useCase.run(runParams());
+
+      expect(mockMessageComposer.composeSubAgentSection).not.toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+      expect(
+        mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName,
+      ).toHaveBeenCalledWith([], transcriptMapFor([GITHUB_SESSION]));
+    });
+
+    it('passes the resolved transcript paths to the refusal-tail provider', async () => {
+      setupSilentMainSession(GITHUB_SESSION);
+
+      await useCase.run(runParams());
+
+      expect(
+        mockRefusalTailStatusProvider.listRefusalTailedSessionNames,
+      ).toHaveBeenCalledWith(transcriptMapFor([GITHUB_SESSION]));
+    });
+
+    it('notifies a session again once the provider stops reporting it (a non-refusal turn followed the refusal)', async () => {
+      setupSilentMainSession(GITHUB_SESSION);
+      mockRefusalTailStatusProvider.listRefusalTailedSessionNames.mockResolvedValue(
+        new Set<string>(),
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(GITHUB_SESSION, MAIN_STALLED_SECTION);
+    });
+
+    it('excludes only the refusal-tailed session when mixed with a healthy stalled session', async () => {
+      mockSnapshotProvider.getSnapshot.mockResolvedValue(
+        snapshotWithSessions([GITHUB_SESSION_ALPHA, GITHUB_SESSION_BRAVO]),
+      );
+      mockTranscriptResolver.resolveTranscriptPaths.mockReturnValue(
+        transcriptMapFor([GITHUB_SESSION_ALPHA, GITHUB_SESSION_BRAVO]),
+      );
+      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+        [
+          {
+            sessionName: GITHUB_SESSION_ALPHA,
+            lastOutputEpochSeconds:
+              nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+          },
+          {
+            sessionName: GITHUB_SESSION_BRAVO,
+            lastOutputEpochSeconds:
+              nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+          },
+        ],
+      );
+      mockRefusalTailStatusProvider.listRefusalTailedSessionNames.mockResolvedValue(
+        new Set([GITHUB_SESSION_ALPHA]),
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledTimes(1);
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(GITHUB_SESSION_BRAVO, MAIN_STALLED_SECTION);
+    });
+
+    it('keeps the existing behavior when no refusal-tail provider is configured', async () => {
+      const useCaseWithoutProvider = new NotifySilentLiveSessionsUseCase(
+        mockSnapshotProvider,
+        mockTranscriptResolver,
+        mockSessionOutputActivityRepository,
+        mockSubAgentActivityRepository,
+        mockOwnerCallStatusProvider,
+        mockNotificationRepository,
+        mockCandidateStateRepository,
+        mockMessageComposer,
+        mockSleeper,
+        mockHubTaskStatusResolver,
+        mockHubTaskStatusCacheRepository,
+      );
+      setupSilentMainSession(GITHUB_SESSION);
+
+      await useCaseWithoutProvider.run(runParams());
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(GITHUB_SESSION, MAIN_STALLED_SECTION);
+    });
+  });
+
   describe('isGitHubIssueOrPullRequestSessionName', () => {
     it('accepts the encoded form of a github.com issue URL session name', () => {
       expect(

package/src/domain/usecases/NotifySilentLiveSessionsUseCase.ts

@@ -3,6 +3,7 @@ import { InteractiveLiveSession } from '../entities/InteractiveLiveSession';
 import { LiveSessionProcessSnapshotProvider } from './adapter-interfaces/LiveSessionProcessSnapshotProvider';
 import { InteractiveLiveSessionTranscriptResolver } from './adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
 import { OwnerCallStatusProvider } from './adapter-interfaces/OwnerCallStatusProvider';
+import { RefusalTailStatusProvider } from './adapter-interfaces/RefusalTailStatusProvider';
 import { SessionOutputActivityRepository } from './adapter-interfaces/SessionOutputActivityRepository';
 import { SessionSubAgentActivityRepository } from './adapter-interfaces/SessionSubAgentActivityRepository';
 import { SilentSessionMessageComposer } from './adapter-interfaces/SilentSessionMessageComposer';
@@ -14,6 +15,10 @@ import { IssueRepository } from './adapter-interfaces/IssueRepository';
 import { ResolveInteractiveLiveSessionsUseCase } from './ResolveInteractiveLiveSessionsUseCase';
 
 export const DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS = 10 * 60;
+// Retained only for backward compatibility of the configuration surface
+// (TDPM_SILENT_UNANSWERED_OWNER_CALL_GRACE_SECONDS). The value is no longer
+// consulted: an unanswered owner call suppresses the main-stall reminder
+// unconditionally (treated as an infinite grace). See composeCandidate.
 export const DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS = 60 * 60;
 export const DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS = 5 * 60;
 export const DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS = 15 * 60;
@@ -75,6 +80,7 @@ export class NotifySilentLiveSessionsUseCase {
     private readonly sleeper: Sleeper,
     private readonly hubTaskStatusResolver: HubTaskStatusResolver | null = null,
     private readonly hubTaskStatusCacheRepository: SilentSessionHubTaskStatusCacheRepository | null = null,
+    private readonly refusalTailStatusProvider: RefusalTailStatusProvider | null = null,
   ) {}
 
   run = async (params: {
@@ -107,8 +113,31 @@ export class NotifySilentLiveSessionsUseCase {
         interactiveSessions,
       );
 
+    // A session whose most recent assistant turn is a model refusal is
+    // excluded from ALL reminder candidates (main-stall and sub-agent
+    // branches alike): each reminder delivery re-sends the full session
+    // context to the API and is guaranteed to produce another refusal, so
+    // reminding such a session only burns tokens. The gate is state-based
+    // (no time windows) and self-clears once a non-refusal assistant turn
+    // appears after the refusal.
+    const refusalTailedSessionNames =
+      this.refusalTailStatusProvider === null
+        ? new Set<string>()
+        : await this.refusalTailStatusProvider.listRefusalTailedSessionNames(
+            transcriptPathBySessionName,
+          );
+    const monitoredSessions = interactiveSessions.filter((session) => {
+      if (!refusalTailedSessionNames.has(session.sessionName)) {
+        return true;
+      }
+      console.log(
+        `Skipping ${session.sessionName}: last assistant turn was a model refusal; suppressing reminders until a non-refusal turn appears.`,
+      );
+      return false;
+    });
+
     const snapshots = await this.collectSnapshots(
-      interactiveSessions,
+      monitoredSessions,
       transcriptPathBySessionName,
       params.now,
     );
@@ -367,22 +396,23 @@ export class NotifySilentLiveSessionsUseCase {
     const mainSilentSeconds = snapshot.mainSilentSeconds;
     const unansweredOwnerCallAgeSeconds =
       snapshot.unansweredOwnerCallAgeSeconds;
-    const suppressedByRecentOwnerCall =
-      unansweredOwnerCallAgeSeconds !== null &&
-      unansweredOwnerCallAgeSeconds <
-        thresholds.unansweredOwnerCallGraceSeconds;
+    // Owner-defined rule: whenever the latest owner call is newer than the
+    // latest owner reply (i.e. the call is unanswered), the session is
+    // waiting on the owner and MUST NOT receive a main-stall reminder —
+    // unconditionally, with no age or grace expiry. The persistent unread
+    // indicator in the owner's app covers the missed-call case, so a
+    // time-based re-fire is unnecessary. `unansweredOwnerCallGraceSeconds`
+    // is retained in the parameters only for backward compatibility of the
+    // call signature and is intentionally ignored (treated as infinite).
+    const suppressedByUnansweredOwnerCall =
+      unansweredOwnerCallAgeSeconds !== null;
     const mainTriggered =
       mainSilentSeconds !== null &&
       mainSilentSeconds >= thresholds.mainSilentThresholdSeconds &&
-      !suppressedByRecentOwnerCall;
+      !suppressedByUnansweredOwnerCall;
     if (mainTriggered) {
       sections.push(
-        unansweredOwnerCallAgeSeconds !== null
-          ? this.messageComposer.composeMainStalledWithStaleOwnerCallSection(
-              mainSilentSeconds,
-              unansweredOwnerCallAgeSeconds,
-            )
-          : this.messageComposer.composeMainStalledSection(mainSilentSeconds),
+        this.messageComposer.composeMainStalledSection(mainSilentSeconds),
       );
     }
 

package/src/domain/usecases/adapter-interfaces/RefusalTailStatusProvider.ts

@@ -0,0 +1,5 @@
+export interface RefusalTailStatusProvider {
+  listRefusalTailedSessionNames: (
+    transcriptPathBySessionName: Map<string, string>,
+  ) => Promise<Set<string>>;
+}