github-issue-tower-defence-management 1.140.1 → 1.141.0

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

@@ -331,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']),
     );
@@ -347,9 +347,9 @@ describe('NotifySilentLiveSessionsUseCase', () => {
 
     await useCase.run(runParams());
 
-    expect(mockTranscriptResolver.resolveTranscriptPaths).toHaveBeenCalledWith(
-      [],
-    );
+    expect(mockTranscriptResolver.resolveTranscriptPaths).toHaveBeenCalledWith([
+      sessionFor('workbench'),
+    ]);
     expect(
       mockSubAgentActivityRepository.listSubAgentActivitiesBySessionName,
     ).toHaveBeenCalledWith([], new Map());
@@ -361,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']),
     );
@@ -387,6 +387,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
 
     expect(mockTranscriptResolver.resolveTranscriptPaths).toHaveBeenCalledWith([
       sessionFor(GITHUB_SESSION),
+      sessionFor('orchestrator'),
     ]);
     expect(
       mockNotificationRepository.sendSelfCheckNotification,
@@ -691,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);
@@ -1221,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 () => {

package/src/domain/usecases/NotifySilentLiveSessionsUseCase.ts

@@ -99,20 +99,36 @@ export class NotifySilentLiveSessionsUseCase {
       await this.liveSessionProcessSnapshotProvider.getSnapshot();
     const allInteractiveSessions =
       this.resolveInteractiveLiveSessions.resolve(snapshot);
-    const interactiveSessions = allInteractiveSessions.filter((session) =>
-      isGitHubIssueOrPullRequestSessionName(session.sessionName),
+    // Resolve the on-disk Claude transcript for every interactive session
+    // before any name-based narrowing. A resolvable transcript is the proof
+    // that a session is a live Claude agent session (its transcript, keyed by
+    // the session id, is actively present on disk), independent of how the tmux
+    // session is named.
+    const transcriptPathBySessionName =
+      this.interactiveLiveSessionTranscriptResolver.resolveTranscriptPaths(
+        allInteractiveSessions,
+      );
+    // Monitor a session when it is either named after a github.com issue or
+    // pull-request URL (the hub-task sessions) or has a resolvable Claude agent
+    // transcript (role-named resident leader / PM agent sessions such as app,
+    // tdpm-cli, secretary, and the per-project *pm sessions). Gating the
+    // broadened inclusion on the resolvable transcript rather than on merely
+    // being a tmux session keeps the fail-direction safe: a genuine non-agent
+    // interactive session — a login shell, or a viewer such as sso_login or a
+    // tdpm viewer — exposes no Claude transcript on disk, so it is still
+    // excluded and never reminded.
+    const interactiveSessions = allInteractiveSessions.filter(
+      (session) =>
+        isGitHubIssueOrPullRequestSessionName(session.sessionName) ||
+        transcriptPathBySessionName.has(session.sessionName),
     );
-    const skippedNonGitHubSessionCount =
+    const skippedNonAgentSessionCount =
       allInteractiveSessions.length - interactiveSessions.length;
-    if (skippedNonGitHubSessionCount > 0) {
+    if (skippedNonAgentSessionCount > 0) {
       console.log(
-        `Silent live session notification: ignoring ${skippedNonGitHubSessionCount} non-github-named interactive session(s); only sessions named after a github.com issue or pull-request URL are monitored.`,
+        `Silent live session notification: ignoring ${skippedNonAgentSessionCount} interactive session(s) that are neither named after a github.com issue or pull-request URL nor have a resolvable Claude agent transcript.`,
       );
     }
-    const transcriptPathBySessionName =
-      this.interactiveLiveSessionTranscriptResolver.resolveTranscriptPaths(
-        interactiveSessions,
-      );
 
     // A session whose most recent assistant turn is a model refusal is
     // excluded from ALL reminder candidates (main-stall and sub-agent

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

@@ -0,0 +1,167 @@
+import {
+  OutputDegenerationDetector,
+  OUTPUT_DEGENERATION_REPEAT_THRESHOLD,
+  OUTPUT_DEGENERATION_DOMINATION_FRACTION,
+  OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH,
+  OUTPUT_DEGENERATION_ABSOLUTE_RUN_THRESHOLD,
+  OUTPUT_DEGENERATION_REP4_THRESHOLD,
+  OUTPUT_DEGENERATION_REP4_MIN_TOKENS,
+  OUTPUT_DEGENERATION_CROSS_TURN_WINDOW,
+  OUTPUT_DEGENERATION_CROSS_TURN_MIN_TURNS,
+} from './OutputDegenerationDetector';
+
+const repeat = (token: string, count: number): string =>
+  Array.from({ length: count }, () => token).join(' ');
+
+describe('OutputDegenerationDetector', () => {
+  const detector = new OutputDegenerationDetector();
+
+  describe('ported constants match the validated Python values', () => {
+    it('exposes the exact thresholds', () => {
+      expect(OUTPUT_DEGENERATION_REPEAT_THRESHOLD).toBe(5);
+      expect(OUTPUT_DEGENERATION_DOMINATION_FRACTION).toBe(0.8);
+      expect(OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH).toBe(32);
+      expect(OUTPUT_DEGENERATION_ABSOLUTE_RUN_THRESHOLD).toBe(15);
+      expect(OUTPUT_DEGENERATION_REP4_THRESHOLD).toBe(0.3);
+      expect(OUTPUT_DEGENERATION_REP4_MIN_TOKENS).toBe(40);
+      expect(OUTPUT_DEGENERATION_CROSS_TURN_WINDOW).toBe(10);
+      expect(OUTPUT_DEGENERATION_CROSS_TURN_MIN_TURNS).toBe(4);
+    });
+  });
+
+  describe('isIntraTurnDegeneration', () => {
+    it('fires on a turn dominated by a single short repeated token (positive)', () => {
+      expect(detector.isIntraTurnDegeneration(repeat('court', 40))).toBe(true);
+    });
+
+    it('does not fire on a short run just below the repeat threshold (negative)', () => {
+      expect(detector.isIntraTurnDegeneration(repeat('court', 4))).toBe(false);
+    });
+
+    it('does not fire on healthy prose with no repetition', () => {
+      const healthy =
+        'I finished the migration and verified the results against the seed data. The build passed and the report is uploaded.';
+      expect(detector.isIntraTurnDegeneration(healthy)).toBe(false);
+    });
+
+    it('fires exactly at the domination-fraction boundary (run 5 of 6 tokens)', () => {
+      expect(
+        detector.isIntraTurnDegeneration('count count count count count alpha'),
+      ).toBe(true);
+    });
+
+    it('does not fire just past the domination-fraction boundary (run 5 of 7 tokens)', () => {
+      expect(
+        detector.isIntraTurnDegeneration(
+          'count count count count count alpha beta',
+        ),
+      ).toBe(false);
+    });
+
+    it('fires on a large absolute run even when domination fails', () => {
+      const buried = `${repeat('court', 15)} ${repeat('distinct', 1)} one two three four five`;
+      expect(detector.isIntraTurnDegeneration(buried)).toBe(true);
+    });
+
+    it('fires on a repeated phrase loop via duplicated 4-gram density', () => {
+      const phraseLoop = repeat('the quick brown fox', 15);
+      expect(detector.isIntraTurnDegeneration(phraseLoop)).toBe(true);
+    });
+
+    it('does not fire on a non-dominating repeat run confined to a fenced code block', () => {
+      const variedProse = Array.from(
+        { length: 100 },
+        (_unused, index) => `word${index}`,
+      ).join(' ');
+      const withCodeBlock = `${variedProse}\n\`\`\`\n${repeat('court', 20)}\n\`\`\``;
+      expect(detector.isIntraTurnDegeneration(withCodeBlock)).toBe(false);
+    });
+
+    it('ignores repeated long tokens above the max token length', () => {
+      const longToken = 'a'.repeat(OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH + 1);
+      expect(detector.isIntraTurnDegeneration(repeat(longToken, 40))).toBe(
+        false,
+      );
+    });
+
+    it('returns false for an empty turn', () => {
+      expect(detector.isIntraTurnDegeneration('')).toBe(false);
+    });
+  });
+
+  describe('maxConsecutiveShortTokenRun', () => {
+    it('reports the dominating token and run length for logging', () => {
+      const result = detector.maxConsecutiveShortTokenRun(repeat('court', 12));
+      expect(result.token).toBe('court');
+      expect(result.run).toBe(12);
+      expect(result.total).toBe(12);
+    });
+  });
+
+  describe('detectCrossTurnDegeneration', () => {
+    const cleanEnding = (index: number): string =>
+      `Turn ${index}: I completed the step and reported the result.`;
+    const trailingTokenTurn = (index: number, token: string): string =>
+      `Turn ${index}: real message here.\n\n${token}`;
+
+    it('fires when the same trailing token recurs in 4 of the last 10 turns', () => {
+      const turns = [
+        trailingTokenTurn(1, 'court'),
+        cleanEnding(2),
+        trailingTokenTurn(3, 'court'),
+        cleanEnding(4),
+        trailingTokenTurn(5, 'court'),
+        cleanEnding(6),
+        trailingTokenTurn(7, 'court'),
+        cleanEnding(8),
+        cleanEnding(9),
+        cleanEnding(10),
+      ];
+      const result = detector.detectCrossTurnDegeneration(turns);
+      expect(result).not.toBeNull();
+      expect(result?.token).toBe('court');
+      expect(result?.turnCount).toBe(4);
+    });
+
+    it('does not fire when the trailing token recurs in only 3 of 10 turns', () => {
+      const turns = [
+        trailingTokenTurn(1, 'court'),
+        cleanEnding(2),
+        trailingTokenTurn(3, 'court'),
+        cleanEnding(4),
+        trailingTokenTurn(5, 'court'),
+        cleanEnding(6),
+        cleanEnding(7),
+        cleanEnding(8),
+        cleanEnding(9),
+        cleanEnding(10),
+      ];
+      expect(detector.detectCrossTurnDegeneration(turns)).toBeNull();
+    });
+
+    it('does not treat a bare URL or multi-word ending as a trailing token', () => {
+      const turns = [
+        'Done. See https://example.com/report',
+        'The work is complete',
+        'Result: 42',
+        'Done. See https://example.com/report',
+      ];
+      expect(detector.detectCrossTurnDegeneration(turns)).toBeNull();
+    });
+
+    it('only counts turns inside the cross-turn window', () => {
+      const withinWindow = Array.from({ length: 10 }, (_unused, index) =>
+        index < 3 ? trailingTokenTurn(index, 'court') : cleanEnding(index),
+      );
+      const beyondWindow = Array.from({ length: 5 }, (_unused, index) =>
+        trailingTokenTurn(100 + index, 'court'),
+      );
+      expect(
+        detector.detectCrossTurnDegeneration([
+          ...withinWindow,
+          ...beyondWindow,
+        ]),
+      ).toBeNull();
+    });
+  });
+});

package/src/domain/usecases/OutputDegenerationDetector.ts

@@ -0,0 +1,169 @@
+import { CrossTurnDegeneration } from '../entities/OutputDegeneration';
+
+export const OUTPUT_DEGENERATION_REPEAT_THRESHOLD = 5;
+export const OUTPUT_DEGENERATION_DOMINATION_FRACTION = 0.8;
+export const OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH = 32;
+export const OUTPUT_DEGENERATION_ABSOLUTE_RUN_THRESHOLD = 15;
+export const OUTPUT_DEGENERATION_REP4_THRESHOLD = 0.3;
+export const OUTPUT_DEGENERATION_REP4_MIN_TOKENS = 40;
+export const OUTPUT_DEGENERATION_CROSS_TURN_WINDOW = 10;
+export const OUTPUT_DEGENERATION_CROSS_TURN_MIN_TURNS = 4;
+
+export type ShortTokenRun = {
+  token: string | null;
+  run: number;
+  total: number;
+};
+
+const LIST_ITEM_LINE_PATTERN = /^\s*(?:[-*+]\s|\d+[.)]\s)/;
+const TRAILING_ALPHA_TOKEN_PATTERN = /^[A-Za-z]+$/;
+
+const splitTokens = (text: string): string[] =>
+  text.split(/\s+/).filter((token) => token.length > 0);
+
+const splitLines = (text: string): string[] => text.split(/\r\n|\r|\n/);
+
+export class OutputDegenerationDetector {
+  constructor(
+    private readonly repeatThreshold: number = OUTPUT_DEGENERATION_REPEAT_THRESHOLD,
+    private readonly dominationFraction: number = OUTPUT_DEGENERATION_DOMINATION_FRACTION,
+    private readonly maxTokenLength: number = OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH,
+    private readonly absoluteRunThreshold: number = OUTPUT_DEGENERATION_ABSOLUTE_RUN_THRESHOLD,
+    private readonly rep4Threshold: number = OUTPUT_DEGENERATION_REP4_THRESHOLD,
+    private readonly rep4MinTokens: number = OUTPUT_DEGENERATION_REP4_MIN_TOKENS,
+    private readonly crossTurnWindow: number = OUTPUT_DEGENERATION_CROSS_TURN_WINDOW,
+    private readonly crossTurnMinTurns: number = OUTPUT_DEGENERATION_CROSS_TURN_MIN_TURNS,
+  ) {}
+
+  maxConsecutiveShortTokenRun = (text: string): ShortTokenRun => {
+    let bestToken: string | null = null;
+    let bestRun = 0;
+    let totalTokens = 0;
+    let currentToken: string | null = null;
+    let currentRun = 0;
+    for (const token of splitTokens(text)) {
+      totalTokens += 1;
+      if (token.length > this.maxTokenLength) {
+        currentToken = null;
+        currentRun = 0;
+        continue;
+      }
+      if (token === currentToken) {
+        currentRun += 1;
+      } else {
+        currentToken = token;
+        currentRun = 1;
+      }
+      if (currentRun > bestRun) {
+        bestRun = currentRun;
+        bestToken = currentToken;
+      }
+    }
+    return { token: bestToken, run: bestRun, total: totalTokens };
+  };
+
+  isIntraTurnDegeneration = (text: string): boolean => {
+    const { run, total } = this.maxConsecutiveShortTokenRun(text);
+    if (total === 0) {
+      return false;
+    }
+    if (run >= this.repeatThreshold && run >= this.dominationFraction * total) {
+      return true;
+    }
+    const filtered = this.stripRepetitionExemptSpans(text);
+    const filteredRun = this.maxConsecutiveShortTokenRun(filtered);
+    if (filteredRun.run >= this.absoluteRunThreshold) {
+      return true;
+    }
+    if (
+      filteredRun.total >= this.rep4MinTokens &&
+      this.duplicateNgramFraction(filtered, 4) >= this.rep4Threshold
+    ) {
+      return true;
+    }
+    return false;
+  };
+
+  detectCrossTurnDegeneration = (
+    texts: string[],
+  ): CrossTurnDegeneration | null => {
+    const counts = new Map<string, number>();
+    for (const text of texts.slice(0, this.crossTurnWindow)) {
+      const token = this.trailingSpuriousToken(text);
+      if (token === null) {
+        continue;
+      }
+      counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+    let bestToken: string | null = null;
+    let bestCount = 0;
+    for (const [token, count] of counts) {
+      if (count > bestCount) {
+        bestCount = count;
+        bestToken = token;
+      }
+    }
+    if (bestToken !== null && bestCount >= this.crossTurnMinTurns) {
+      return { token: bestToken, turnCount: bestCount };
+    }
+    return null;
+  };
+
+  private stripRepetitionExemptSpans = (text: string): string => {
+    const keptLines: string[] = [];
+    let inFence = false;
+    for (const line of splitLines(text)) {
+      const stripped = line.trim();
+      if (stripped.startsWith('```') || stripped.startsWith('~~~')) {
+        inFence = !inFence;
+        continue;
+      }
+      if (inFence) {
+        continue;
+      }
+      if (line.includes('|')) {
+        continue;
+      }
+      if (LIST_ITEM_LINE_PATTERN.test(line)) {
+        continue;
+      }
+      keptLines.push(line);
+    }
+    return keptLines.join('\n');
+  };
+
+  private duplicateNgramFraction = (text: string, n: number): number => {
+    const tokens = splitTokens(text).filter(
+      (token) => token.length <= this.maxTokenLength,
+    );
+    if (tokens.length < n + 1) {
+      return 0;
+    }
+    const ngrams: string[] = [];
+    for (let index = 0; index <= tokens.length - n; index += 1) {
+      ngrams.push(tokens.slice(index, index + n).join('\u0000'));
+    }
+    const total = ngrams.length;
+    if (total < 2) {
+      return 0;
+    }
+    const unique = new Set(ngrams).size;
+    return 1 - unique / total;
+  };
+
+  private trailingSpuriousToken = (text: string): string | null => {
+    const stripped = text.replace(/\s+$/, '');
+    if (stripped.length === 0) {
+      return null;
+    }
+    const lines = splitLines(stripped);
+    const lastLine = lines[lines.length - 1].trim();
+    if (lastLine.length === 0 || lastLine.length > this.maxTokenLength) {
+      return null;
+    }
+    if (!TRAILING_ALPHA_TOKEN_PATTERN.test(lastLine)) {
+      return null;
+    }
+    return lastLine;
+  };
+}