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

package/src/adapter/entry-points/handlers/resetDegeneratedTmuxSessions.test.ts

@@ -0,0 +1,69 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  resetDegeneratedTmuxSessions,
+  DEFAULT_RESET_DEGENERATED_TMUX_SESSIONS_PARAMS,
+} from './resetDegeneratedTmuxSessions';
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+
+describe('resetDegeneratedTmuxSessions', () => {
+  let temporaryDirectory: string;
+  let cooldownStateFilePath: string;
+  let loggedMessages: string[];
+  let consoleLogSpy: jest.SpiedFunction<typeof console.log>;
+
+  beforeEach(() => {
+    temporaryDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'reset-degenerated-'),
+    );
+    cooldownStateFilePath = path.join(temporaryDirectory, 'cooldown.json');
+    loggedMessages = [];
+    consoleLogSpy = jest
+      .spyOn(console, 'log')
+      .mockImplementation((...args: unknown[]): void => {
+        loggedMessages.push(args.map((arg) => String(arg)).join(' '));
+      });
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+  });
+
+  it('wires the real adapters and runs end to end without acting when no sessions exist', async () => {
+    const runCommand: jest.MockedFunction<LocalCommandRunner['runCommand']> =
+      jest.fn().mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
+    const commandRunner: LocalCommandRunner = { runCommand };
+
+    await resetDegeneratedTmuxSessions({
+      enabled: false,
+      localCommandRunner: commandRunner,
+      warningMessage:
+        DEFAULT_RESET_DEGENERATED_TMUX_SESSIONS_PARAMS.warningMessage,
+      graceSeconds: DEFAULT_RESET_DEGENERATED_TMUX_SESSIONS_PARAMS.graceSeconds,
+      cooldownSeconds:
+        DEFAULT_RESET_DEGENERATED_TMUX_SESSIONS_PARAMS.cooldownSeconds,
+      cooldownStateFilePath,
+      now: new Date('2026-07-26T00:00:00Z'),
+    });
+
+    const summaryLogged = loggedMessages.some((message) =>
+      message.includes(
+        'Output degeneration recovery: detected 0 degenerated session(s) of 0 interactive session(s)',
+      ),
+    );
+    expect(summaryLogged).toBe(true);
+    const killInvoked = runCommand.mock.calls.some((callArguments) =>
+      callArguments[1].includes('kill-session'),
+    );
+    expect(killInvoked).toBe(false);
+  });
+
+  it('exposes safe defaults with a five second grace and 300 second cooldown', () => {
+    expect(DEFAULT_RESET_DEGENERATED_TMUX_SESSIONS_PARAMS.graceSeconds).toBe(5);
+    expect(DEFAULT_RESET_DEGENERATED_TMUX_SESSIONS_PARAMS.cooldownSeconds).toBe(
+      300,
+    );
+  });
+});

package/src/adapter/entry-points/handlers/resetDegeneratedTmuxSessions.ts

@@ -0,0 +1,71 @@
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+import {
+  SessionOutputDegenerationRecoveryUseCase,
+  DEFAULT_OUTPUT_DEGENERATION_GRACE_SECONDS,
+  DEFAULT_OUTPUT_DEGENERATION_COOLDOWN_SECONDS,
+  DEFAULT_OUTPUT_DEGENERATION_WARNING_MESSAGE,
+} from '../../../domain/usecases/SessionOutputDegenerationRecoveryUseCase';
+import { LocalProcessLiveSessionProcessSnapshotProvider } from '../../repositories/LocalProcessLiveSessionProcessSnapshotProvider';
+import { ProcFsProcessEnvironReader } from '../../repositories/ProcFsProcessEnvironReader';
+import { FileSystemInteractiveLiveSessionTranscriptResolver } from '../../repositories/FileSystemInteractiveLiveSessionTranscriptResolver';
+import { FileSystemSessionAssistantTurnsRepository } from '../../repositories/FileSystemSessionAssistantTurnsRepository';
+import { FileSystemSessionDegenerationCooldownStateRepository } from '../../repositories/FileSystemSessionDegenerationCooldownStateRepository';
+import { TmuxSilentSessionNotificationRepository } from '../../repositories/TmuxSilentSessionNotificationRepository';
+import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRepository';
+import { RealSleeper } from '../../repositories/RealSleeper';
+
+export type ResetDegeneratedTmuxSessionsParams = {
+  enabled: boolean;
+  localCommandRunner: LocalCommandRunner;
+  processEnvironReader?: ProcessEnvironReader;
+  warningMessage: string;
+  graceSeconds: number;
+  cooldownSeconds: number;
+  cooldownStateFilePath: string | null;
+  now: Date;
+};
+
+export const resetDegeneratedTmuxSessions = async (
+  params: ResetDegeneratedTmuxSessionsParams,
+): Promise<void> => {
+  const {
+    enabled,
+    localCommandRunner,
+    processEnvironReader,
+    warningMessage,
+    graceSeconds,
+    cooldownSeconds,
+    cooldownStateFilePath,
+    now,
+  } = params;
+  const useCase = new SessionOutputDegenerationRecoveryUseCase(
+    new LocalProcessLiveSessionProcessSnapshotProvider(
+      localCommandRunner,
+      processEnvironReader ?? new ProcFsProcessEnvironReader(),
+    ),
+    new FileSystemInteractiveLiveSessionTranscriptResolver(),
+    new FileSystemSessionAssistantTurnsRepository(),
+    new TmuxSilentSessionNotificationRepository(localCommandRunner),
+    new NodeTmuxSessionRepository(localCommandRunner),
+    cooldownStateFilePath !== null
+      ? new FileSystemSessionDegenerationCooldownStateRepository(
+          cooldownStateFilePath,
+        )
+      : new FileSystemSessionDegenerationCooldownStateRepository(),
+    new RealSleeper(),
+  );
+  await useCase.run({
+    enabled,
+    warningMessage,
+    graceSeconds,
+    cooldownSeconds,
+    now,
+  });
+};
+
+export const DEFAULT_RESET_DEGENERATED_TMUX_SESSIONS_PARAMS = {
+  warningMessage: DEFAULT_OUTPUT_DEGENERATION_WARNING_MESSAGE,
+  graceSeconds: DEFAULT_OUTPUT_DEGENERATION_GRACE_SECONDS,
+  cooldownSeconds: DEFAULT_OUTPUT_DEGENERATION_COOLDOWN_SECONDS,
+} as const;

package/src/adapter/repositories/FileSystemSessionAssistantTurnsRepository.test.ts

@@ -0,0 +1,138 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemSessionAssistantTurnsRepository } from './FileSystemSessionAssistantTurnsRepository';
+
+describe('FileSystemSessionAssistantTurnsRepository', () => {
+  let temporaryDirectory: string;
+
+  beforeEach(() => {
+    temporaryDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'assistant-turns-'),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+  });
+
+  const writeTranscript = (fileName: string, lines: string[]): string => {
+    const filePath = path.join(temporaryDirectory, fileName);
+    fs.writeFileSync(filePath, `${lines.join('\n')}\n`);
+    return filePath;
+  };
+
+  it('returns recent assistant turn texts newest first, ignoring non-assistant lines', async () => {
+    const filePath = writeTranscript('transcript.jsonl', [
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'first turn' }] },
+      }),
+      JSON.stringify({
+        type: 'user',
+        message: { content: [{ type: 'text', text: 'a user turn' }] },
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        message: {
+          content: [
+            { type: 'text', text: 'second turn' },
+            { type: 'tool_use', id: 'tool-1', name: 'Bash' },
+          ],
+        },
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'third turn' }] },
+      }),
+    ]);
+
+    const repository = new FileSystemSessionAssistantTurnsRepository();
+    const result = await repository.listRecentAssistantTurnsBySessionName(
+      new Map([['session', filePath]]),
+      10,
+    );
+
+    expect(result.get('session')).toEqual([
+      'third turn',
+      'second turn',
+      'first turn',
+    ]);
+  });
+
+  it('limits the number of turns returned to maxTurnsPerSession', async () => {
+    const filePath = writeTranscript('transcript.jsonl', [
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'oldest' }] },
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'middle' }] },
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'newest' }] },
+      }),
+    ]);
+
+    const repository = new FileSystemSessionAssistantTurnsRepository();
+    const result = await repository.listRecentAssistantTurnsBySessionName(
+      new Map([['session', filePath]]),
+      2,
+    );
+
+    expect(result.get('session')).toEqual(['newest', 'middle']);
+  });
+
+  it('reads a string content assistant message', async () => {
+    const filePath = writeTranscript('transcript.jsonl', [
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: 'plain string turn' },
+      }),
+    ]);
+
+    const repository = new FileSystemSessionAssistantTurnsRepository();
+    const result = await repository.listRecentAssistantTurnsBySessionName(
+      new Map([['session', filePath]]),
+      10,
+    );
+
+    expect(result.get('session')).toEqual(['plain string turn']);
+  });
+
+  it('omits a session whose transcript is missing', async () => {
+    const repository = new FileSystemSessionAssistantTurnsRepository();
+    const result = await repository.listRecentAssistantTurnsBySessionName(
+      new Map([['session', path.join(temporaryDirectory, 'absent.jsonl')]]),
+      10,
+    );
+
+    expect(result.has('session')).toBe(false);
+  });
+
+  it('drops the first partial line when reading only the transcript tail', async () => {
+    const firstLine = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: 'partial old turn' }] },
+    });
+    const secondLine = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: 'complete new turn' }] },
+    });
+    const filePath = writeTranscript('transcript.jsonl', [
+      firstLine,
+      secondLine,
+    ]);
+
+    const tailBytes = Buffer.byteLength(`${secondLine}\n`) + 5;
+    const repository = new FileSystemSessionAssistantTurnsRepository(tailBytes);
+    const result = await repository.listRecentAssistantTurnsBySessionName(
+      new Map([['session', filePath]]),
+      10,
+    );
+
+    expect(result.get('session')).toEqual(['complete new turn']);
+  });
+});

package/src/adapter/repositories/FileSystemSessionAssistantTurnsRepository.ts

@@ -0,0 +1,113 @@
+import * as fs from 'fs';
+import { SessionAssistantTurnsRepository } from '../../domain/usecases/adapter-interfaces/SessionAssistantTurnsRepository';
+
+export const DEFAULT_TRANSCRIPT_TAIL_BYTES = 3_000_000;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const assistantText = (message: Record<string, unknown>): string => {
+  const content = message.content;
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const parts: string[] = [];
+    for (const block of content) {
+      if (
+        isRecord(block) &&
+        block.type === 'text' &&
+        typeof block.text === 'string'
+      ) {
+        parts.push(block.text);
+      }
+    }
+    return parts.join(' ');
+  }
+  return '';
+};
+
+export class FileSystemSessionAssistantTurnsRepository implements SessionAssistantTurnsRepository {
+  constructor(
+    private readonly tailBytes: number = DEFAULT_TRANSCRIPT_TAIL_BYTES,
+  ) {}
+
+  listRecentAssistantTurnsBySessionName = async (
+    transcriptPathBySessionName: Map<string, string>,
+    maxTurnsPerSession: number,
+  ): Promise<Map<string, string[]>> => {
+    const turnsBySessionName = new Map<string, string[]>();
+    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
+      const turns = this.readRecentAssistantTurns(
+        transcriptPath,
+        maxTurnsPerSession,
+      );
+      if (turns.length > 0) {
+        turnsBySessionName.set(sessionName, turns);
+      }
+    }
+    return turnsBySessionName;
+  };
+
+  private readRecentAssistantTurns = (
+    transcriptPath: string,
+    maxTurns: number,
+  ): string[] => {
+    const lines = this.readTailLines(transcriptPath);
+    const turns: string[] = [];
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      const trimmed = lines[index].trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isRecord(parsed) || parsed.type !== 'assistant') {
+        continue;
+      }
+      const message = parsed.message;
+      if (!isRecord(message)) {
+        continue;
+      }
+      const text = assistantText(message);
+      if (text.trim().length === 0) {
+        continue;
+      }
+      turns.push(text);
+      if (turns.length >= maxTurns) {
+        break;
+      }
+    }
+    return turns;
+  };
+
+  private readTailLines = (transcriptPath: string): string[] => {
+    let handle: number;
+    try {
+      handle = fs.openSync(transcriptPath, 'r');
+    } catch {
+      return [];
+    }
+    try {
+      const size = fs.fstatSync(handle).size;
+      const start = size > this.tailBytes ? size - this.tailBytes : 0;
+      const length = size - start;
+      const buffer = new Uint8Array(length);
+      fs.readSync(handle, buffer, 0, length, start);
+      let text = Buffer.from(buffer).toString('utf8');
+      if (start > 0) {
+        const newlineIndex = text.indexOf('\n');
+        text = newlineIndex === -1 ? '' : text.slice(newlineIndex + 1);
+      }
+      return text.split('\n');
+    } catch {
+      return [];
+    } finally {
+      fs.closeSync(handle);
+    }
+  };
+}

package/src/adapter/repositories/FileSystemSessionDegenerationCooldownStateRepository.test.ts

@@ -0,0 +1,85 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemSessionDegenerationCooldownStateRepository } from './FileSystemSessionDegenerationCooldownStateRepository';
+
+describe('FileSystemSessionDegenerationCooldownStateRepository', () => {
+  let temporaryDirectory: string;
+  let stateFilePath: string;
+
+  beforeEach(() => {
+    temporaryDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'degeneration-cooldown-'),
+    );
+    stateFilePath = path.join(temporaryDirectory, 'cooldown.json');
+  });
+
+  afterEach(() => {
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+  });
+
+  it('returns an empty map when no state file exists', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+    );
+    expect(await repository.loadLastResetEpochSecondsBySessionName()).toEqual(
+      new Map(),
+    );
+  });
+
+  it('persists and reloads a per-session reset time', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+    );
+    const now = new Date('2026-07-26T00:00:00Z');
+    await repository.recordReset({ sessionName: 'session-a', now });
+
+    const reloaded = await repository.loadLastResetEpochSecondsBySessionName();
+    expect(reloaded.get('session-a')).toBe(Math.floor(now.getTime() / 1000));
+  });
+
+  it('keeps distinct sessions separate and overwrites the same session', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+    );
+    await repository.recordReset({
+      sessionName: 'session-a',
+      now: new Date('2026-07-26T00:00:00Z'),
+    });
+    await repository.recordReset({
+      sessionName: 'session-b',
+      now: new Date('2026-07-26T00:01:00Z'),
+    });
+    await repository.recordReset({
+      sessionName: 'session-a',
+      now: new Date('2026-07-26T00:02:00Z'),
+    });
+
+    const reloaded = await repository.loadLastResetEpochSecondsBySessionName();
+    expect(reloaded.get('session-a')).toBe(
+      Math.floor(new Date('2026-07-26T00:02:00Z').getTime() / 1000),
+    );
+    expect(reloaded.get('session-b')).toBe(
+      Math.floor(new Date('2026-07-26T00:01:00Z').getTime() / 1000),
+    );
+  });
+
+  it('drops entries older than the retention window on the next write', async () => {
+    const repository = new FileSystemSessionDegenerationCooldownStateRepository(
+      stateFilePath,
+      60,
+    );
+    await repository.recordReset({
+      sessionName: 'stale-session',
+      now: new Date('2026-07-26T00:00:00Z'),
+    });
+    await repository.recordReset({
+      sessionName: 'fresh-session',
+      now: new Date('2026-07-26T00:05:00Z'),
+    });
+
+    const reloaded = await repository.loadLastResetEpochSecondsBySessionName();
+    expect(reloaded.has('stale-session')).toBe(false);
+    expect(reloaded.has('fresh-session')).toBe(true);
+  });
+});

package/src/adapter/repositories/FileSystemSessionDegenerationCooldownStateRepository.ts

@@ -0,0 +1,105 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { SessionDegenerationCooldownStateRepository } from '../../domain/usecases/adapter-interfaces/SessionDegenerationCooldownStateRepository';
+
+type StoredResetEntry = {
+  sessionName: string;
+  resetEpochSeconds: number;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+export const DEFAULT_RESET_RETENTION_WINDOW_SECONDS = 60 * 60;
+
+const defaultStateFilePath = (): string => {
+  const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+  return path.join(base, 'tdpm', 'output-degeneration-cooldown.json');
+};
+
+export class FileSystemSessionDegenerationCooldownStateRepository implements SessionDegenerationCooldownStateRepository {
+  constructor(
+    private readonly stateFilePath: string = defaultStateFilePath(),
+    private readonly retentionWindowSeconds: number = DEFAULT_RESET_RETENTION_WINDOW_SECONDS,
+  ) {}
+
+  loadLastResetEpochSecondsBySessionName = async (): Promise<
+    Map<string, number>
+  > => {
+    const lastResetBySessionName = new Map<string, number>();
+    for (const entry of this.readResetEntries()) {
+      lastResetBySessionName.set(entry.sessionName, entry.resetEpochSeconds);
+    }
+    return lastResetBySessionName;
+  };
+
+  recordReset = async (params: {
+    sessionName: string;
+    now: Date;
+  }): Promise<void> => {
+    const resetEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const oldestRetainedEpochSeconds =
+      resetEpochSeconds - this.retentionWindowSeconds;
+    const mergedBySessionName = new Map<string, StoredResetEntry>();
+    for (const entry of this.readResetEntries()) {
+      if (
+        entry.resetEpochSeconds >= oldestRetainedEpochSeconds &&
+        entry.sessionName !== params.sessionName
+      ) {
+        mergedBySessionName.set(entry.sessionName, entry);
+      }
+    }
+    mergedBySessionName.set(params.sessionName, {
+      sessionName: params.sessionName,
+      resetEpochSeconds,
+    });
+    this.writeState(Array.from(mergedBySessionName.values()));
+  };
+
+  private readResetEntries = (): StoredResetEntry[] => {
+    let raw: string;
+    try {
+      raw = fs.readFileSync(this.stateFilePath, 'utf8');
+    } catch {
+      return [];
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+    if (!isRecord(parsed)) {
+      return [];
+    }
+    const storedEntries = parsed.resets;
+    if (!Array.isArray(storedEntries)) {
+      return [];
+    }
+    const entries: StoredResetEntry[] = [];
+    for (const storedEntry of storedEntries) {
+      if (!isRecord(storedEntry)) {
+        continue;
+      }
+      const sessionName = storedEntry.sessionName;
+      const resetEpochSeconds = storedEntry.resetEpochSeconds;
+      if (
+        typeof sessionName === 'string' &&
+        typeof resetEpochSeconds === 'number' &&
+        Number.isFinite(resetEpochSeconds)
+      ) {
+        entries.push({ sessionName, resetEpochSeconds });
+      }
+    }
+    return entries;
+  };
+
+  private writeState = (resets: StoredResetEntry[]): void => {
+    const directory = path.dirname(this.stateFilePath);
+    fs.mkdirSync(directory, { recursive: true });
+    const temporaryPath = `${this.stateFilePath}.${process.pid}.tmp`;
+    fs.writeFileSync(temporaryPath, JSON.stringify({ resets }));
+    fs.renameSync(temporaryPath, this.stateFilePath);
+  };
+}

package/src/domain/entities/OutputDegeneration.ts

@@ -0,0 +1,10 @@
+export type IntraTurnDegeneration = {
+  token: string;
+  run: number;
+  turnTokenCount: number;
+};
+
+export type CrossTurnDegeneration = {
+  token: string;
+  turnCount: number;
+};