github-issue-tower-defence-management 1.122.3 → 1.122.5

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

@@ -1,11 +1,6 @@
 import { DefaultSilentSessionMessageComposer } from './DefaultSilentSessionMessageComposer';
 import { SILENT_SESSION_REMINDER_SENTINEL } from './silentSessionReminderSentinel';
 
-const THRESHOLDS = {
-  subAgentSilentThresholdSeconds: 300,
-  subAgentRunningThresholdSeconds: 900,
-};
-
 describe('DefaultSilentSessionMessageComposer', () => {
   const composer = new DefaultSilentSessionMessageComposer();
 
@@ -15,10 +10,16 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('embeds the reminder sentinel in the sub-agent section', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const subAgent = {
+      label: 'sub-process-1',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
     expect(section).toContain(SILENT_SESSION_REMINDER_SENTINEL);
   });
 
@@ -115,11 +116,93 @@ describe('DefaultSilentSessionMessageComposer', () => {
     expect(section).not.toContain('""');
   });
 
-  it('emits a distinct idle message for a sub-agent that is only output-idle', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
+  it('embeds the reminder sentinel in the stale-owner-call main-stalled section', () => {
+    const section = composer.composeMainStalledWithStaleOwnerCallSection(
+      600,
+      3600,
+    );
+    expect(section).toContain(SILENT_SESSION_REMINDER_SENTINEL);
+  });
+
+  it('renders the stale-owner-call section with the silent and owner-call-age minutes substituted', () => {
+    const section = composer.composeMainStalledWithStaleOwnerCallSection(
+      659,
+      3659,
+    );
+    expect(section).toContain(
+      'You have produced no output for 10 minutes, and the owner call you raised 60 minutes ago is still unanswered.',
+    );
+  });
+
+  it('directs the agent to re-raise its pending ask as a fresh fully self-contained owner call', () => {
+    const section = composer.composeMainStalledWithStaleOwnerCallSection(
+      600,
+      3600,
+    );
+    expect(section).toContain(
+      'If you are still blocked on the owner, re-raise your pending ask NOW as a fresh owner call.',
+    );
+    expect(section).toContain(
+      'Make it fully self-contained: restate the whole situation — what happened, what you are asking, and any decision needed — inside the new owner call itself',
+    );
+  });
+
+  it('directs the agent to continue autonomously when it is no longer blocked', () => {
+    const section = composer.composeMainStalledWithStaleOwnerCallSection(
+      600,
+      3600,
+    );
+    expect(section).toContain(
+      'If you are no longer blocked — the answer became unnecessary, you can proceed safely, or the information arrived another way — resume immediately and drive all remaining tasks to completion.',
+    );
+  });
+
+  it('states that the stale-owner-call reminder itself does not notify the owner', () => {
+    const section = composer.composeMainStalledWithStaleOwnerCallSection(
+      600,
+      3600,
+    );
+    expect(section).toContain(
+      'This reminder does not notify the owner; only a fresh owner call from you surfaces this session to the owner.',
+    );
+  });
+
+  it('interpolates the configured owner-call marker into the stale-owner-call format guidance', () => {
+    const markedComposer = new DefaultSilentSessionMessageComposer(
+      '<<OWNER_CALL>>',
+    );
+    const section = markedComposer.composeMainStalledWithStaleOwnerCallSection(
+      600,
+      3600,
+    );
+    expect(section).toContain(
+      'the configured owner-call marker tag "<<OWNER_CALL>>" as a complete matching pair',
     );
+    expect(section).toContain('🔴');
+  });
+
+  it('composes the stale-owner-call section distinctly from the plain main-stalled section', () => {
+    const plainSection = composer.composeMainStalledSection(600);
+    const staleSection = composer.composeMainStalledWithStaleOwnerCallSection(
+      600,
+      3600,
+    );
+    expect(staleSection).not.toBe(plainSection);
+    expect(plainSection).not.toContain('is still unanswered');
+  });
+
+  it('emits a distinct idle message for a sub-agent that is only output-idle', () => {
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain('sub-process-idle');
     expect(section).toContain('no output for 6m');
     expect(section).toContain('restart, hand off, or replace it');
@@ -128,10 +211,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('presents the system-detected idle duration as the authoritative signal in the idle message', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain(
       "The system has already detected, from each sub-process's last tool activity, that it has produced no output for about the minutes shown below.",
     );
@@ -142,10 +232,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('forbids speculation and dismissal without evidence in the idle message', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain(
       'Around five minutes of silence is a real warning of a possible hang',
     );
@@ -155,10 +252,17 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('requires a concrete cause-check covering recent activity and external-dependency waiting in the idle message', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain('determine the CAUSE by a concrete check');
     expect(section).toContain(
       'a very recent push or commit, or output from any nested sub-processes this sub-process itself started',
@@ -175,26 +279,34 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('requires logging the investigation result even though owner notification is not required', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-idle', silentSeconds: 360, runningSeconds: 60 }],
-      THRESHOLDS,
-    );
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'sub-process-idle',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
+      ],
+      longRunningSubAgents: [],
+    });
     expect(section).toContain(
       'Owner notification is not required, but you MUST output your investigation result in this session so it remains as a log.',
     );
   });
 
   it('emits a distinct long-running message for a sub-agent that has only run too long', () => {
-    const section = composer.composeSubAgentSection(
-      [
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [],
+      longRunningSubAgents: [
         {
           label: 'sub-process-long',
           silentSeconds: 30,
           runningSeconds: 1200,
+          waitingOnExternalProcess: false,
         },
       ],
-      THRESHOLDS,
-    );
+    });
     expect(section).toContain('sub-process-long');
     expect(section).toContain('running for 20m');
     expect(section).toContain('infinite loop');
@@ -209,25 +321,32 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('does not foreground the short idle time in the long-running message', () => {
-    const section = composer.composeSubAgentSection(
-      [
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [],
+      longRunningSubAgents: [
         {
           label: 'sub-process-long',
           silentSeconds: 30,
           runningSeconds: 1200,
+          waitingOnExternalProcess: false,
         },
       ],
-      THRESHOLDS,
-    );
+    });
     expect(section).not.toContain('no output for');
     expect(section).not.toContain('silent for');
   });
 
   it('emits both distinct messages for a sub-agent matching both conditions, kept separate', () => {
-    const section = composer.composeSubAgentSection(
-      [{ label: 'sub-process-both', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const subAgent = {
+      label: 'sub-process-both',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
     expect(section).toContain('no output for 6m');
     expect(section).toContain('determine the CAUSE by a concrete check');
     expect(section).toContain('running for 20m');
@@ -238,13 +357,24 @@ describe('DefaultSilentSessionMessageComposer', () => {
   });
 
   it('groups each sub-agent under the condition it matched', () => {
-    const section = composer.composeSubAgentSection(
-      [
-        { label: 'idle-only', silentSeconds: 360, runningSeconds: 60 },
-        { label: 'long-only', silentSeconds: 10, runningSeconds: 960 },
+    const section = composer.composeSubAgentSection({
+      idleSubAgents: [
+        {
+          label: 'idle-only',
+          silentSeconds: 360,
+          runningSeconds: 60,
+          waitingOnExternalProcess: false,
+        },
       ],
-      THRESHOLDS,
-    );
+      longRunningSubAgents: [
+        {
+          label: 'long-only',
+          silentSeconds: 10,
+          runningSeconds: 960,
+          waitingOnExternalProcess: false,
+        },
+      ],
+    });
     const [idleSection, longRunningSection] = section.split('\n\n');
     expect(idleSection).toContain('idle-only');
     expect(idleSection).not.toContain('long-only');
@@ -254,10 +384,16 @@ describe('DefaultSilentSessionMessageComposer', () => {
 
   it('does not contain any host-specific or internal identifiers', () => {
     const mainSection = composer.composeMainStalledSection(600);
-    const subSection = composer.composeSubAgentSection(
-      [{ label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 }],
-      THRESHOLDS,
-    );
+    const subAgent = {
+      label: 'sub-process-1',
+      silentSeconds: 360,
+      runningSeconds: 1200,
+      waitingOnExternalProcess: false,
+    };
+    const subSection = composer.composeSubAgentSection({
+      idleSubAgents: [subAgent],
+      longRunningSubAgents: [subAgent],
+    });
     const combined = `${mainSection}\n${subSection}`.toLowerCase();
     expect(combined).not.toContain('claude');
     expect(combined).not.toContain('take ownership');

package/src/domain/usecases/DefaultSilentSessionMessageComposer.ts

@@ -1,7 +1,7 @@
 import { SubAgentActivity } from '../entities/LiveSessionActivitySnapshot';
 import {
   SilentSessionMessageComposer,
-  SubAgentStallThresholds,
+  SubAgentStallSections,
 } from './adapter-interfaces/SilentSessionMessageComposer';
 import { SILENT_SESSION_REMINDER_SENTINEL } from './silentSessionReminderSentinel';
 
@@ -67,6 +67,21 @@ const composeMainStalledMessage = (
   ].join('\n');
 };
 
+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} You have produced no output for ${silentMinutes} minutes, and the owner call you raised ${ownerCallAgeMinutes} minutes ago is still unanswered. An owner call outstanding this long may have been missed, may have scrolled out of the owner's view, or may no longer reflect your current situation, so do not keep waiting on it passively. Act now, choosing one of the following:`,
+    `1. If you are still blocked on the owner, re-raise your pending ask NOW as a fresh owner call. Make it fully self-contained: restate the whole situation — what happened, what you are asking, and any decision needed — inside the new owner call itself, so the owner understands everything from that single latest message without scrolling back. ${composeOwnerCallFormatGuidance(ownerCallMarker)}`,
+    `2. If you are no longer blocked — the answer became unnecessary, you can proceed safely, or the information arrived another way — resume immediately and drive all remaining tasks to completion.`,
+    `This reminder does not notify the owner; only a fresh owner call from you surfaces this session to the owner. Also, in your next output, report an estimate of how many minutes you expect to need to finish all remaining tasks.`,
+  ].join('\n');
+};
+
 export class DefaultSilentSessionMessageComposer implements SilentSessionMessageComposer {
   constructor(private readonly ownerCallMarker: string | null = null) {}
 
@@ -74,24 +89,26 @@ export class DefaultSilentSessionMessageComposer implements SilentSessionMessage
     return composeMainStalledMessage(mainSilentSeconds, this.ownerCallMarker);
   };
 
-  composeSubAgentSection = (
-    subAgents: SubAgentActivity[],
-    thresholds: SubAgentStallThresholds,
+  composeMainStalledWithStaleOwnerCallSection = (
+    mainSilentSeconds: number,
+    unansweredOwnerCallAgeSeconds: number,
   ): string => {
-    const idleSubAgents = subAgents.filter(
-      (subAgent) =>
-        subAgent.silentSeconds >= thresholds.subAgentSilentThresholdSeconds,
-    );
-    const longRunningSubAgents = subAgents.filter(
-      (subAgent) =>
-        subAgent.runningSeconds >= thresholds.subAgentRunningThresholdSeconds,
+    return composeMainStalledWithStaleOwnerCallMessage(
+      mainSilentSeconds,
+      unansweredOwnerCallAgeSeconds,
+      this.ownerCallMarker,
     );
+  };
+
+  composeSubAgentSection = (stallSections: SubAgentStallSections): string => {
     const sections: string[] = [];
-    if (idleSubAgents.length > 0) {
-      sections.push(composeIdleSubAgentSection(idleSubAgents));
+    if (stallSections.idleSubAgents.length > 0) {
+      sections.push(composeIdleSubAgentSection(stallSections.idleSubAgents));
     }
-    if (longRunningSubAgents.length > 0) {
-      sections.push(composeLongRunningSubAgentSection(longRunningSubAgents));
+    if (stallSections.longRunningSubAgents.length > 0) {
+      sections.push(
+        composeLongRunningSubAgentSection(stallSections.longRunningSubAgents),
+      );
     }
     return sections.join('\n\n');
   };