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

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;
+  };
+}

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

@@ -0,0 +1,224 @@
+import { SessionOutputDegenerationRecoveryUseCase } from './SessionOutputDegenerationRecoveryUseCase';
+import { LiveSessionProcessSnapshotProvider } from './adapter-interfaces/LiveSessionProcessSnapshotProvider';
+import { InteractiveLiveSessionTranscriptResolver } from './adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
+import { SessionAssistantTurnsRepository } from './adapter-interfaces/SessionAssistantTurnsRepository';
+import { SessionDegenerationCooldownStateRepository } from './adapter-interfaces/SessionDegenerationCooldownStateRepository';
+import { SilentSessionNotificationRepository } from './adapter-interfaces/SilentSessionNotificationRepository';
+import { TmuxSessionRepository } from './adapter-interfaces/TmuxSessionRepository';
+import { Sleeper } from './adapter-interfaces/Sleeper';
+import { LiveSessionProcessSnapshot } from '../entities/LiveSessionProcessSnapshot';
+
+const SESSION_NAME = 'https://github.com/HiromiShikata/secretary/issues/2824';
+
+const buildSnapshot = (sessionName: string): LiveSessionProcessSnapshot => ({
+  sessions: [{ sessionName, panePids: [100] }],
+  processes: [
+    {
+      pid: 100,
+      ppid: 1,
+      commandLine: 'claude --resume',
+      sessionId: 'session-1',
+      currentSessionId: 'session-1',
+      configDir: '/home/user/.claude',
+    },
+  ],
+});
+
+const repeat = (token: string, count: number): string =>
+  Array.from({ length: count }, () => token).join(' ');
+
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+
+describe('SessionOutputDegenerationRecoveryUseCase', () => {
+  let snapshotProvider: Mocked<LiveSessionProcessSnapshotProvider>;
+  let transcriptResolver: Mocked<InteractiveLiveSessionTranscriptResolver>;
+  let assistantTurnsRepository: Mocked<SessionAssistantTurnsRepository>;
+  let notificationRepository: Mocked<SilentSessionNotificationRepository>;
+  let tmuxSessionRepository: Mocked<Pick<TmuxSessionRepository, 'killSession'>>;
+  let cooldownStateRepository: Mocked<SessionDegenerationCooldownStateRepository>;
+  let sleeper: Mocked<Sleeper>;
+  let useCase: SessionOutputDegenerationRecoveryUseCase;
+
+  const now = new Date('2026-07-26T00:00:00Z');
+  const nowEpochSeconds = Math.floor(now.getTime() / 1000);
+
+  const runWith = (params: {
+    enabled: boolean;
+    turns: string[];
+    lastResetEpochSeconds?: number;
+  }): Promise<void> => {
+    snapshotProvider.getSnapshot.mockResolvedValue(buildSnapshot(SESSION_NAME));
+    transcriptResolver.resolveTranscriptPaths.mockReturnValue(
+      new Map([[SESSION_NAME, '/fake/transcript.jsonl']]),
+    );
+    assistantTurnsRepository.listRecentAssistantTurnsBySessionName.mockResolvedValue(
+      new Map([[SESSION_NAME, params.turns]]),
+    );
+    cooldownStateRepository.loadLastResetEpochSecondsBySessionName.mockResolvedValue(
+      params.lastResetEpochSeconds === undefined
+        ? new Map()
+        : new Map([[SESSION_NAME, params.lastResetEpochSeconds]]),
+    );
+    return useCase.run({
+      enabled: params.enabled,
+      warningMessage: 'WARNING',
+      graceSeconds: 5,
+      cooldownSeconds: 300,
+      now,
+    });
+  };
+
+  beforeEach(() => {
+    snapshotProvider = {
+      getSnapshot: jest.fn(),
+    };
+    transcriptResolver = {
+      resolveTranscriptPaths: jest.fn(),
+    };
+    assistantTurnsRepository = {
+      listRecentAssistantTurnsBySessionName: jest.fn(),
+    };
+    notificationRepository = {
+      sendSelfCheckNotification: jest.fn().mockResolvedValue(undefined),
+    };
+    tmuxSessionRepository = {
+      killSession: jest.fn().mockResolvedValue(undefined),
+    };
+    cooldownStateRepository = {
+      loadLastResetEpochSecondsBySessionName: jest.fn(),
+      recordReset: jest.fn().mockResolvedValue(undefined),
+    };
+    sleeper = {
+      sleep: jest.fn().mockResolvedValue(undefined),
+    };
+    useCase = new SessionOutputDegenerationRecoveryUseCase(
+      snapshotProvider,
+      transcriptResolver,
+      assistantTurnsRepository,
+      notificationRepository,
+      tmuxSessionRepository,
+      cooldownStateRepository,
+      sleeper,
+    );
+  });
+
+  it('warns, waits the grace period, kills, and records the reset when enabled and degenerated (intra-turn)', async () => {
+    await runWith({ enabled: true, turns: [repeat('court', 40)] });
+
+    expect(
+      notificationRepository.sendSelfCheckNotification,
+    ).toHaveBeenCalledWith(SESSION_NAME, 'WARNING');
+    expect(sleeper.sleep).toHaveBeenCalledWith(5000);
+    expect(tmuxSessionRepository.killSession).toHaveBeenCalledWith(
+      SESSION_NAME,
+    );
+    expect(cooldownStateRepository.recordReset).toHaveBeenCalledWith({
+      sessionName: SESSION_NAME,
+      now,
+    });
+  });
+
+  it('does not warn or kill in dry-run but still records the reset for cooldown', async () => {
+    await runWith({ enabled: false, turns: [repeat('court', 40)] });
+
+    expect(
+      notificationRepository.sendSelfCheckNotification,
+    ).not.toHaveBeenCalled();
+    expect(sleeper.sleep).not.toHaveBeenCalled();
+    expect(tmuxSessionRepository.killSession).not.toHaveBeenCalled();
+    expect(cooldownStateRepository.recordReset).toHaveBeenCalledWith({
+      sessionName: SESSION_NAME,
+      now,
+    });
+  });
+
+  it('skips a session that was reset within the cooldown window', async () => {
+    await runWith({
+      enabled: true,
+      turns: [repeat('court', 40)],
+      lastResetEpochSeconds: nowEpochSeconds - 100,
+    });
+
+    expect(
+      notificationRepository.sendSelfCheckNotification,
+    ).not.toHaveBeenCalled();
+    expect(tmuxSessionRepository.killSession).not.toHaveBeenCalled();
+    expect(cooldownStateRepository.recordReset).not.toHaveBeenCalled();
+  });
+
+  it('acts again once the cooldown window has elapsed', async () => {
+    await runWith({
+      enabled: true,
+      turns: [repeat('court', 40)],
+      lastResetEpochSeconds: nowEpochSeconds - 301,
+    });
+
+    expect(tmuxSessionRepository.killSession).toHaveBeenCalledWith(
+      SESSION_NAME,
+    );
+  });
+
+  it('does not act on a healthy session', async () => {
+    await runWith({
+      enabled: true,
+      turns: [
+        'I finished the migration, verified the seed data, and uploaded the report.',
+      ],
+    });
+
+    expect(
+      notificationRepository.sendSelfCheckNotification,
+    ).not.toHaveBeenCalled();
+    expect(tmuxSessionRepository.killSession).not.toHaveBeenCalled();
+    expect(cooldownStateRepository.recordReset).not.toHaveBeenCalled();
+  });
+
+  it('resets a session detected only by the cross-turn signature', async () => {
+    const clean = (index: number): string =>
+      `Turn ${index}: completed and reported.`;
+    const trailing = (index: number): string =>
+      `Turn ${index}: real message.\n\ncourt`;
+    const turns = [
+      trailing(1),
+      clean(2),
+      trailing(3),
+      clean(4),
+      trailing(5),
+      clean(6),
+      trailing(7),
+      clean(8),
+      clean(9),
+      clean(10),
+    ];
+
+    await runWith({ enabled: true, turns });
+
+    expect(tmuxSessionRepository.killSession).toHaveBeenCalledWith(
+      SESSION_NAME,
+    );
+  });
+
+  it('does not act on a non-github-named interactive session', async () => {
+    snapshotProvider.getSnapshot.mockResolvedValue(buildSnapshot('app'));
+    transcriptResolver.resolveTranscriptPaths.mockReturnValue(new Map());
+    assistantTurnsRepository.listRecentAssistantTurnsBySessionName.mockResolvedValue(
+      new Map(),
+    );
+    cooldownStateRepository.loadLastResetEpochSecondsBySessionName.mockResolvedValue(
+      new Map(),
+    );
+
+    await useCase.run({
+      enabled: true,
+      warningMessage: 'WARNING',
+      graceSeconds: 5,
+      cooldownSeconds: 300,
+      now,
+    });
+
+    expect(
+      assistantTurnsRepository.listRecentAssistantTurnsBySessionName,
+    ).toHaveBeenCalledWith(new Map(), 10);
+    expect(tmuxSessionRepository.killSession).not.toHaveBeenCalled();
+  });
+});

package/src/domain/usecases/SessionOutputDegenerationRecoveryUseCase.ts

@@ -0,0 +1,142 @@
+import { LiveSessionProcessSnapshotProvider } from './adapter-interfaces/LiveSessionProcessSnapshotProvider';
+import { InteractiveLiveSessionTranscriptResolver } from './adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
+import { SessionAssistantTurnsRepository } from './adapter-interfaces/SessionAssistantTurnsRepository';
+import { SessionDegenerationCooldownStateRepository } from './adapter-interfaces/SessionDegenerationCooldownStateRepository';
+import { SilentSessionNotificationRepository } from './adapter-interfaces/SilentSessionNotificationRepository';
+import { TmuxSessionRepository } from './adapter-interfaces/TmuxSessionRepository';
+import { Sleeper } from './adapter-interfaces/Sleeper';
+import {
+  OutputDegenerationDetector,
+  OUTPUT_DEGENERATION_CROSS_TURN_WINDOW,
+} from './OutputDegenerationDetector';
+import { ResolveInteractiveLiveSessionsUseCase } from './ResolveInteractiveLiveSessionsUseCase';
+import { isGitHubIssueOrPullRequestSessionName } from './NotifySilentLiveSessionsUseCase';
+
+export const DEFAULT_OUTPUT_DEGENERATION_GRACE_SECONDS = 5;
+export const DEFAULT_OUTPUT_DEGENERATION_COOLDOWN_SECONDS = 300;
+export const DEFAULT_OUTPUT_DEGENERATION_WARNING_MESSAGE =
+  'OUTPUT DEGENERATION DETECTED: your session is about to be reset. Immediately write a checkpoint to your assigned task issue (single concrete next action to resume, working directory and branch, in-flight sub-agent branch/PR URLs).';
+
+export class SessionOutputDegenerationRecoveryUseCase {
+  private readonly resolveInteractiveLiveSessions =
+    new ResolveInteractiveLiveSessionsUseCase();
+
+  constructor(
+    private readonly liveSessionProcessSnapshotProvider: LiveSessionProcessSnapshotProvider,
+    private readonly interactiveLiveSessionTranscriptResolver: InteractiveLiveSessionTranscriptResolver,
+    private readonly assistantTurnsRepository: SessionAssistantTurnsRepository,
+    private readonly notificationRepository: SilentSessionNotificationRepository,
+    private readonly tmuxSessionRepository: Pick<
+      TmuxSessionRepository,
+      'killSession'
+    >,
+    private readonly cooldownStateRepository: SessionDegenerationCooldownStateRepository,
+    private readonly sleeper: Sleeper,
+    private readonly detector: OutputDegenerationDetector = new OutputDegenerationDetector(),
+  ) {}
+
+  run = async (params: {
+    enabled: boolean;
+    warningMessage: string;
+    graceSeconds: number;
+    cooldownSeconds: number;
+    now: Date;
+  }): Promise<void> => {
+    const snapshot =
+      await this.liveSessionProcessSnapshotProvider.getSnapshot();
+    const allInteractiveSessions =
+      this.resolveInteractiveLiveSessions.resolve(snapshot);
+    const interactiveSessions = allInteractiveSessions.filter((session) =>
+      isGitHubIssueOrPullRequestSessionName(session.sessionName),
+    );
+
+    const transcriptPathBySessionName =
+      this.interactiveLiveSessionTranscriptResolver.resolveTranscriptPaths(
+        interactiveSessions,
+      );
+    const turnsBySessionName =
+      await this.assistantTurnsRepository.listRecentAssistantTurnsBySessionName(
+        transcriptPathBySessionName,
+        OUTPUT_DEGENERATION_CROSS_TURN_WINDOW,
+      );
+    const lastResetBySessionName =
+      await this.cooldownStateRepository.loadLastResetEpochSecondsBySessionName();
+
+    const nowEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    let detectedCount = 0;
+    let resetCount = 0;
+    let dryRunCount = 0;
+    let cooldownSkippedCount = 0;
+
+    for (const session of interactiveSessions) {
+      const sessionName = session.sessionName;
+      const lastResetEpochSeconds = lastResetBySessionName.get(sessionName);
+      if (
+        lastResetEpochSeconds !== undefined &&
+        nowEpochSeconds - lastResetEpochSeconds < params.cooldownSeconds
+      ) {
+        cooldownSkippedCount += 1;
+        continue;
+      }
+
+      const turns = turnsBySessionName.get(sessionName) ?? [];
+      const newestTurn = turns.length > 0 ? turns[0] : null;
+      const intraTurn =
+        newestTurn !== null &&
+        this.detector.isIntraTurnDegeneration(newestTurn);
+      const crossTurn = this.detector.detectCrossTurnDegeneration(turns);
+      if (!intraTurn && crossTurn === null) {
+        continue;
+      }
+      detectedCount += 1;
+
+      if (intraTurn && newestTurn !== null) {
+        const { token, run, total } =
+          this.detector.maxConsecutiveShortTokenRun(newestTurn);
+        console.log(
+          `Output degeneration detected (intra-turn) session=${sessionName} token=${JSON.stringify(token)} run=${run} turnTokens=${total} enabled=${params.enabled}`,
+        );
+      }
+      if (crossTurn !== null) {
+        console.log(
+          `Output degeneration detected (cross-turn) session=${sessionName} token=${JSON.stringify(crossTurn.token)} turns=${crossTurn.turnCount}/${Math.min(turns.length, OUTPUT_DEGENERATION_CROSS_TURN_WINDOW)} enabled=${params.enabled}`,
+        );
+      }
+
+      if (params.enabled) {
+        try {
+          await this.notificationRepository.sendSelfCheckNotification(
+            sessionName,
+            params.warningMessage,
+          );
+          await this.sleeper.sleep(params.graceSeconds * 1000);
+          await this.tmuxSessionRepository.killSession(sessionName);
+          resetCount += 1;
+          console.log(
+            `Output degeneration reset session=${sessionName} graceSeconds=${params.graceSeconds}`,
+          );
+        } catch (error) {
+          console.error(
+            `Failed to reset degenerated session ${sessionName}: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+          );
+          continue;
+        }
+      } else {
+        dryRunCount += 1;
+        console.log(
+          `Output degeneration dry-run: would warn and reset session=${sessionName}`,
+        );
+      }
+      await this.cooldownStateRepository.recordReset({
+        sessionName,
+        now: params.now,
+      });
+    }
+
+    console.log(
+      `Output degeneration recovery: detected ${detectedCount} degenerated session(s) of ${interactiveSessions.length} interactive session(s); reset ${resetCount}, dry-run would-reset ${dryRunCount}, cooldown-skipped ${cooldownSkippedCount}.`,
+    );
+  };
+}

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

@@ -0,0 +1,6 @@
+export interface SessionAssistantTurnsRepository {
+  listRecentAssistantTurnsBySessionName: (
+    transcriptPathBySessionName: Map<string, string>,
+    maxTurnsPerSession: number,
+  ) => Promise<Map<string, string[]>>;
+}

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

@@ -0,0 +1,4 @@
+export interface SessionDegenerationCooldownStateRepository {
+  loadLastResetEpochSecondsBySessionName: () => Promise<Map<string, number>>;
+  recordReset: (params: { sessionName: string; now: Date }) => Promise<void>;
+}