github-issue-tower-defence-management 1.140.0 → 1.140.2

package/src/adapter/repositories/FileSystemSessionOutputActivityRepository.ts

@@ -21,54 +21,34 @@ const parseEpochMilliseconds = (timestamp: string | null): number | null => {
   return Number.isNaN(parsed) ? null : parsed;
 };
 
-const readContentBlocks = (
-  message: Record<string, unknown>,
-): Record<string, unknown>[] => {
-  const content = message.content;
-  if (!Array.isArray(content)) {
-    return [];
-  }
-  return content.filter(isRecord);
-};
-
-type TranscriptActivity = {
-  lastAssistantOutputEpochSeconds: number | null;
-  hasInProgressToolCall: boolean;
-};
-
 export class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
   listSessionOutputActivities = async (
     transcriptPathBySessionName: Map<string, string>,
   ): Promise<LiveSessionOutputActivity[]> => {
     const activities: LiveSessionOutputActivity[] = [];
     for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
-      const { lastAssistantOutputEpochSeconds, hasInProgressToolCall } =
-        this.readTranscriptActivity(transcriptPath);
+      const lastAssistantOutputEpochSeconds =
+        this.readLastAssistantOutputEpochSeconds(transcriptPath);
       if (lastAssistantOutputEpochSeconds !== null) {
         activities.push({
           sessionName,
           lastOutputEpochSeconds: lastAssistantOutputEpochSeconds,
-          hasInProgressToolCall,
         });
       }
     }
     return activities;
   };
 
-  private readTranscriptActivity = (
+  private readLastAssistantOutputEpochSeconds = (
     transcriptPath: string,
-  ): TranscriptActivity => {
+  ): number | null => {
     let content: string;
     try {
       content = fs.readFileSync(transcriptPath, 'utf8');
     } catch {
-      return {
-        lastAssistantOutputEpochSeconds: null,
-        hasInProgressToolCall: false,
-      };
+      return null;
     }
     let lastAssistantOutputEpochMs: number | null = null;
-    const pendingToolUseIds = new Set<string>();
     for (const line of content.split('\n')) {
       const trimmed = line.trim();
       if (trimmed.length === 0) {
@@ -83,37 +63,15 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
       if (!isRecord(parsed)) {
         continue;
       }
-      const message = parsed.message;
       if (readString(parsed, 'type') === 'assistant') {
         const epochMs = parseEpochMilliseconds(readString(parsed, 'timestamp'));
         if (epochMs !== null) {
           lastAssistantOutputEpochMs = epochMs;
         }
       }
-      if (!isRecord(message)) {
-        continue;
-      }
-      for (const block of readContentBlocks(message)) {
-        const blockType = readString(block, 'type');
-        if (blockType === 'tool_use') {
-          const toolUseId = readString(block, 'id');
-          if (toolUseId !== null) {
-            pendingToolUseIds.add(toolUseId);
-          }
-        } else if (blockType === 'tool_result') {
-          const toolUseId = readString(block, 'tool_use_id');
-          if (toolUseId !== null) {
-            pendingToolUseIds.delete(toolUseId);
-          }
-        }
-      }
     }
-    return {
-      lastAssistantOutputEpochSeconds:
-        lastAssistantOutputEpochMs === null
-          ? null
-          : Math.floor(lastAssistantOutputEpochMs / 1000),
-      hasInProgressToolCall: pendingToolUseIds.size > 0,
-    };
+    return lastAssistantOutputEpochMs === null
+      ? null
+      : Math.floor(lastAssistantOutputEpochMs / 1000);
   };
 }

package/src/domain/entities/LiveSessionActivitySnapshot.ts

@@ -8,7 +8,6 @@ export type SubAgentActivity = {
 export type LiveSessionActivitySnapshot = {
   sessionName: string;
   mainSilentSeconds: number | null;
-  mainHasInProgressToolCall: boolean;
   subAgents: SubAgentActivity[];
   unansweredOwnerCallAgeSeconds: number | null;
 };

package/src/domain/entities/LiveSessionOutputActivity.ts

@@ -1,5 +1,4 @@
 export type LiveSessionOutputActivity = {
   sessionName: string;
   lastOutputEpochSeconds: number;
-  hasInProgressToolCall: boolean;
 };

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

@@ -10,7 +10,6 @@ import {
   DEFAULT_NOTIFICATION_STAGGER_SECONDS,
   DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
   DEFAULT_HUB_TASK_STATUS_CACHE_TTL_SECONDS,
-  IN_PROGRESS_TOOL_CALL_MAX_SUPPRESS_SECONDS,
 } from './NotifySilentLiveSessionsUseCase';
 import { Issue } from '../entities/Issue';
 import { LiveSessionProcessSnapshotProvider } from './adapter-interfaces/LiveSessionProcessSnapshotProvider';
@@ -268,7 +267,6 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
       ],
     );
@@ -299,7 +297,6 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: GITHUB_SESSION,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
       ],
     );
@@ -323,7 +320,6 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: pullRequestSession,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
       ],
     );
@@ -335,7 +331,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     ).toHaveBeenCalledWith(pullRequestSession, MAIN_STALLED_SECTION);
   });
 
-  it('excludes a non-github-named session from selection so it is never notified', async () => {
+  it('excludes a non-github-named session that has no resolvable transcript so it is never notified', async () => {
     mockSnapshotProvider.getSnapshot.mockResolvedValue(
       snapshotWithSessions(['workbench']),
     );
@@ -345,16 +341,15 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: 'workbench',
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
       ],
     );
 
     await useCase.run(runParams());
 
-    expect(mockTranscriptResolver.resolveTranscriptPaths).toHaveBeenCalledWith(
-      [],
-    );
+    expect(mockTranscriptResolver.resolveTranscriptPaths).toHaveBeenCalledWith([
+      sessionFor('workbench'),
+    ]);
     expect(
       mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName,
     ).toHaveBeenCalledWith([], new Map());
@@ -366,7 +361,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     ).not.toHaveBeenCalled();
   });
 
-  it('monitors only the github-named session when mixed with a non-github-named session', async () => {
+  it('monitors the github-named session and excludes a non-github-named session that has no resolvable transcript', async () => {
     mockSnapshotProvider.getSnapshot.mockResolvedValue(
       snapshotWithSessions([GITHUB_SESSION, 'orchestrator']),
     );
@@ -379,13 +374,11 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: GITHUB_SESSION,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
         {
           sessionName: 'orchestrator',
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
       ],
     );
@@ -394,6 +387,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
 
     expect(mockTranscriptResolver.resolveTranscriptPaths).toHaveBeenCalledWith([
       sessionFor(GITHUB_SESSION),
+      sessionFor('orchestrator'),
     ]);
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
@@ -501,7 +495,6 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: GITHUB_SESSION,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS + 1,
-          hasInProgressToolCall: false,
         },
       ],
     );
@@ -529,7 +522,6 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: GITHUB_SESSION,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
       ],
     );
@@ -550,7 +542,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     ).toHaveBeenCalledWith(GITHUB_SESSION, MAIN_STALLED_SECTION);
   });
 
-  it('does not send the main stalled section when the session is silent past the threshold but is waiting on a running tool call', async () => {
+  it('sends the main stalled section for a session silent past the threshold regardless of any in-progress tool call, because apparent busyness never suppresses the reminder', async () => {
     setupLiveInteractiveSession(GITHUB_SESSION);
     mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
       [
@@ -558,34 +550,6 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: GITHUB_SESSION,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: true,
-        },
-      ],
-    );
-    mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
-      new Map<string, number>(),
-    );
-
-    await useCase.run(runParams());
-
-    expect(
-      mockMessageComposer.composeMainStalledSection,
-    ).not.toHaveBeenCalled();
-    expect(
-      mockNotificationRepository.sendSelfCheckNotification,
-    ).not.toHaveBeenCalled();
-  });
-
-  it('sends the main stalled section when the in-progress tool call has been pending longer than the suppression bound', async () => {
-    setupLiveInteractiveSession(GITHUB_SESSION);
-    const pendingToolCallAgeSeconds =
-      IN_PROGRESS_TOOL_CALL_MAX_SUPPRESS_SECONDS + 60 * 60;
-    mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
-      [
-        {
-          sessionName: GITHUB_SESSION,
-          lastOutputEpochSeconds: nowEpochSeconds - pendingToolCallAgeSeconds,
-          hasInProgressToolCall: true,
         },
       ],
     );
@@ -596,7 +560,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     await useCase.run(runParams());
 
     expect(mockMessageComposer.composeMainStalledSection).toHaveBeenCalledWith(
-      pendingToolCallAgeSeconds,
+      DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
     );
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
@@ -611,7 +575,6 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: GITHUB_SESSION,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS + 1,
-          hasInProgressToolCall: false,
         },
       ],
     );
@@ -729,6 +692,117 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     ).not.toHaveBeenCalled();
   });
 
+  describe('role-named resident leader and PM agent sessions', () => {
+    it('reminds a role-named leader agent session that has a resolvable transcript and is silent past the threshold', async () => {
+      setupLiveInteractiveSession('secretary');
+      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+        [
+          {
+            sessionName: 'secretary',
+            lastOutputEpochSeconds:
+              nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+          },
+        ],
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockMessageComposer.composeMainStalledSection,
+      ).toHaveBeenCalledWith(DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS);
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith('secretary', MAIN_STALLED_SECTION);
+    });
+
+    it('excludes a non-agent interactive session with no resolvable transcript (for example a viewer named sso_login)', async () => {
+      mockSnapshotProvider.getSnapshot.mockResolvedValue(
+        snapshotWithSessions(['sso_login']),
+      );
+      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+        [
+          {
+            sessionName: 'sso_login',
+            lastOutputEpochSeconds:
+              nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+          },
+        ],
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockTranscriptResolver.resolveTranscriptPaths,
+      ).toHaveBeenCalledWith([sessionFor('sso_login')]);
+      expect(
+        mockMessageComposer.composeMainStalledSection,
+      ).not.toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('reminds both a github-named session and a role-named leader session in the same cycle', async () => {
+      mockSnapshotProvider.getSnapshot.mockResolvedValue(
+        snapshotWithSessions([GITHUB_SESSION, 'app']),
+      );
+      mockTranscriptResolver.resolveTranscriptPaths.mockReturnValue(
+        transcriptMapFor([GITHUB_SESSION, 'app']),
+      );
+      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+        [
+          {
+            sessionName: GITHUB_SESSION,
+            lastOutputEpochSeconds:
+              nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+          },
+          {
+            sessionName: 'app',
+            lastOutputEpochSeconds:
+              nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+          },
+        ],
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledTimes(2);
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(GITHUB_SESSION, MAIN_STALLED_SECTION);
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith('app', MAIN_STALLED_SECTION);
+    });
+
+    it('parks a role-named leader session while its latest owner call is unanswered', async () => {
+      setupLiveInteractiveSession('uminopm');
+      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+        [
+          {
+            sessionName: 'uminopm',
+            lastOutputEpochSeconds:
+              nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+          },
+        ],
+      );
+      mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
+        new Map([['uminopm', nowEpochSeconds - 60]]),
+      );
+
+      await useCase.run(runParams());
+
+      expect(
+        mockMessageComposer.composeMainStalledSection,
+      ).not.toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+    });
+  });
+
   it('notifies a persistent stall only once per silent episode instead of every cycle', async () => {
     wireStatefulNotifiedLatch();
     setupLiveInteractiveSession(GITHUB_SESSION);
@@ -738,7 +812,6 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: GITHUB_SESSION,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
       ],
     );
@@ -763,14 +836,12 @@ describe('NotifySilentLiveSessionsUseCase', () => {
         sessionName: GITHUB_SESSION,
         lastOutputEpochSeconds:
           nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-        hasInProgressToolCall: false,
       },
     ];
     const active = [
       {
         sessionName: GITHUB_SESSION,
         lastOutputEpochSeconds: nowEpochSeconds,
-        hasInProgressToolCall: false,
       },
     ];
 
@@ -808,7 +879,6 @@ describe('NotifySilentLiveSessionsUseCase', () => {
             sessionName: GITHUB_SESSION,
             lastOutputEpochSeconds:
               nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-            hasInProgressToolCall: false,
           },
         ],
       );
@@ -898,7 +968,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     });
   });
 
-  describe('fire-once latch and input-state gating', () => {
+  describe('fire-once latch', () => {
     const setupSilentGithubSession = (): void => {
       setupLiveInteractiveSession(GITHUB_SESSION);
       mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
@@ -907,19 +977,11 @@ describe('NotifySilentLiveSessionsUseCase', () => {
             sessionName: GITHUB_SESSION,
             lastOutputEpochSeconds:
               nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-            hasInProgressToolCall: false,
           },
         ],
       );
     };
 
-    const idleSubAgent = (label: string): SubAgentActivity => ({
-      label,
-      silentSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
-      runningSeconds: 60,
-      waitingOnExternalProcess: false,
-    });
-
     it('loads the fire-once latch using the configured recency window', async () => {
       setupSilentGithubSession();
 
@@ -973,69 +1035,17 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       ).toHaveBeenCalledWith({ sessionNames: [], now });
     });
 
-    it('does not inject into a session whose main REPL has an in-progress tool call even when a sub-agent advisory qualifies', async () => {
-      setupLiveInteractiveSession(GITHUB_SESSION);
-      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
-        [
-          {
-            sessionName: GITHUB_SESSION,
-            lastOutputEpochSeconds: nowEpochSeconds,
-            hasInProgressToolCall: true,
-          },
-        ],
-      );
-      mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
-        new Map([[GITHUB_SESSION, [idleSubAgent('sub-process-1')]]]),
-      );
+    it('sends the reminder for a silent session even when its main REPL is mid-turn, because apparent busyness no longer defers delivery', async () => {
+      setupSilentGithubSession();
 
       await useCase.run(runParams());
 
-      expect(mockMessageComposer.composeSubAgentSection).toHaveBeenCalled();
       expect(
         mockNotificationRepository.sendSelfCheckNotification,
-      ).not.toHaveBeenCalled();
+      ).toHaveBeenCalledWith(GITHUB_SESSION, MAIN_STALLED_SECTION);
       expect(
         mockNotifiedStateRepository.saveNotifiedSessionNames,
-      ).toHaveBeenCalledWith({ sessionNames: [], now });
-    });
-
-    it('delivers the deferred reminder once the main REPL becomes input-ready', async () => {
-      wireStatefulNotifiedLatch();
-      setupLiveInteractiveSession(GITHUB_SESSION);
-      mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName.mockResolvedValue(
-        new Map([[GITHUB_SESSION, [idleSubAgent('sub-process-1')]]]),
-      );
-
-      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
-        [
-          {
-            sessionName: GITHUB_SESSION,
-            lastOutputEpochSeconds: nowEpochSeconds,
-            hasInProgressToolCall: true,
-          },
-        ],
-      );
-      await useCase.run(runParams());
-      expect(
-        mockNotificationRepository.sendSelfCheckNotification,
-      ).not.toHaveBeenCalled();
-
-      mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
-        [
-          {
-            sessionName: GITHUB_SESSION,
-            lastOutputEpochSeconds: nowEpochSeconds,
-            hasInProgressToolCall: false,
-          },
-        ],
-      );
-      await useCase.run(runParams());
-      expect(
-        mockNotificationRepository.sendSelfCheckNotification,
-      ).toHaveBeenCalledTimes(1);
-      expect(
-        mockNotificationRepository.sendSelfCheckNotification,
-      ).toHaveBeenCalledWith(GITHUB_SESSION, SUBAGENT_SECTION);
+      ).toHaveBeenCalledWith({ sessionNames: [GITHUB_SESSION], now });
     });
   });
 
@@ -1218,13 +1228,11 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: GITHUB_SESSION_ALPHA,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
         {
           sessionName: GITHUB_SESSION_BRAVO,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
       ],
     );
@@ -1260,7 +1268,6 @@ describe('NotifySilentLiveSessionsUseCase', () => {
           sessionName: GITHUB_SESSION,
           lastOutputEpochSeconds:
             nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-          hasInProgressToolCall: false,
         },
       ],
     );
@@ -1326,15 +1333,15 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       ).not.toHaveBeenCalled();
     });
 
-    it('excludes a non-github-named session before the hub-task gate so the resolver is never consulted', async () => {
-      setupSilentMainSession('workbench');
+    it('does not consult the hub-task resolver for a role-named leader session that has no hub task URL, and still reminds it', async () => {
+      setupSilentMainSession('tdpm-cli');
 
       await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
 
       expect(mockHubTaskStatusResolver.getIssueByUrl).not.toHaveBeenCalled();
       expect(
         mockNotificationRepository.sendSelfCheckNotification,
-      ).not.toHaveBeenCalled();
+      ).toHaveBeenCalledWith('tdpm-cli', MAIN_STALLED_SECTION);
     });
 
     it('does not call the resolver at all when the active status is unconfigured', async () => {
@@ -1802,13 +1809,11 @@ describe('NotifySilentLiveSessionsUseCase', () => {
             sessionName: GITHUB_SESSION_ALPHA,
             lastOutputEpochSeconds:
               nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-            hasInProgressToolCall: false,
           },
           {
             sessionName: GITHUB_SESSION_BRAVO,
             lastOutputEpochSeconds:
               nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-            hasInProgressToolCall: false,
           },
         ],
       );