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

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

package/types/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAqCA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAkD3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,EACjB,6BAA4B,MAAM,EAAE,GAAG,IAAW,KACjD,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CAsoBP;CACH"}
+{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAyCA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAkD3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,EACjB,6BAA4B,MAAM,EAAE,GAAG,IAAW,KACjD,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CA8qBP;CACH"}

package/types/adapter/entry-points/handlers/resetDegeneratedTmuxSessions.d.ts

@@ -0,0 +1,19 @@
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+export type ResetDegeneratedTmuxSessionsParams = {
+    enabled: boolean;
+    localCommandRunner: LocalCommandRunner;
+    processEnvironReader?: ProcessEnvironReader;
+    warningMessage: string;
+    graceSeconds: number;
+    cooldownSeconds: number;
+    cooldownStateFilePath: string | null;
+    now: Date;
+};
+export declare const resetDegeneratedTmuxSessions: (params: ResetDegeneratedTmuxSessionsParams) => Promise<void>;
+export declare const DEFAULT_RESET_DEGENERATED_TMUX_SESSIONS_PARAMS: {
+    readonly warningMessage: "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).";
+    readonly graceSeconds: 5;
+    readonly cooldownSeconds: 300;
+};
+//# sourceMappingURL=resetDegeneratedTmuxSessions.d.ts.map

package/types/adapter/entry-points/handlers/resetDegeneratedTmuxSessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resetDegeneratedTmuxSessions.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/resetDegeneratedTmuxSessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gEAAgE,CAAC;AACpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,kEAAkE,CAAC;AAgBxG,MAAM,MAAM,kCAAkC,GAAG;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AAEF,eAAO,MAAM,4BAA4B,GACvC,QAAQ,kCAAkC,KACzC,OAAO,CAAC,IAAI,CAkCd,CAAC;AAEF,eAAO,MAAM,8CAA8C;;;;CAIjD,CAAC"}

package/types/adapter/repositories/FileSystemSessionAssistantTurnsRepository.d.ts

@@ -0,0 +1,10 @@
+import { SessionAssistantTurnsRepository } from '../../domain/usecases/adapter-interfaces/SessionAssistantTurnsRepository';
+export declare const DEFAULT_TRANSCRIPT_TAIL_BYTES = 3000000;
+export declare class FileSystemSessionAssistantTurnsRepository implements SessionAssistantTurnsRepository {
+    private readonly tailBytes;
+    constructor(tailBytes?: number);
+    listRecentAssistantTurnsBySessionName: (transcriptPathBySessionName: Map<string, string>, maxTurnsPerSession: number) => Promise<Map<string, string[]>>;
+    private readRecentAssistantTurns;
+    private readTailLines;
+}
+//# sourceMappingURL=FileSystemSessionAssistantTurnsRepository.d.ts.map

package/types/adapter/repositories/FileSystemSessionAssistantTurnsRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystemSessionAssistantTurnsRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/FileSystemSessionAssistantTurnsRepository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AAE3H,eAAO,MAAM,6BAA6B,UAAY,CAAC;AA0BvD,qBAAa,yCAA0C,YAAW,+BAA+B;IAE7F,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,GAAE,MAAsC;IAGpE,qCAAqC,GACnC,6BAA6B,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChD,oBAAoB,MAAM,KACzB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAY/B;IAEF,OAAO,CAAC,wBAAwB,CAkC9B;IAEF,OAAO,CAAC,aAAa,CAwBnB;CACH"}

package/types/adapter/repositories/FileSystemSessionDegenerationCooldownStateRepository.d.ts

@@ -0,0 +1,15 @@
+import { SessionDegenerationCooldownStateRepository } from '../../domain/usecases/adapter-interfaces/SessionDegenerationCooldownStateRepository';
+export declare const DEFAULT_RESET_RETENTION_WINDOW_SECONDS: number;
+export declare class FileSystemSessionDegenerationCooldownStateRepository implements SessionDegenerationCooldownStateRepository {
+    private readonly stateFilePath;
+    private readonly retentionWindowSeconds;
+    constructor(stateFilePath?: string, retentionWindowSeconds?: number);
+    loadLastResetEpochSecondsBySessionName: () => Promise<Map<string, number>>;
+    recordReset: (params: {
+        sessionName: string;
+        now: Date;
+    }) => Promise<void>;
+    private readResetEntries;
+    private writeState;
+}
+//# sourceMappingURL=FileSystemSessionDegenerationCooldownStateRepository.d.ts.map

package/types/adapter/repositories/FileSystemSessionDegenerationCooldownStateRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystemSessionDegenerationCooldownStateRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/FileSystemSessionDegenerationCooldownStateRepository.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,0CAA0C,EAAE,MAAM,qFAAqF,CAAC;AAUjJ,eAAO,MAAM,sCAAsC,QAAU,CAAC;AAO9D,qBAAa,oDAAqD,YAAW,0CAA0C;IAEnH,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,sBAAsB;gBADtB,aAAa,GAAE,MAA+B,EAC9C,sBAAsB,GAAE,MAA+C;IAG1F,sCAAsC,QAAa,OAAO,CACxD,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CACpB,CAMC;IAEF,WAAW,GAAU,QAAQ;QAC3B,WAAW,EAAE,MAAM,CAAC;QACpB,GAAG,EAAE,IAAI,CAAC;KACX,KAAG,OAAO,CAAC,IAAI,CAAC,CAkBf;IAEF,OAAO,CAAC,gBAAgB,CAoCtB;IAEF,OAAO,CAAC,UAAU,CAMhB;CACH"}

package/types/domain/entities/OutputDegeneration.d.ts

@@ -0,0 +1,10 @@
+export type IntraTurnDegeneration = {
+    token: string;
+    run: number;
+    turnTokenCount: number;
+};
+export type CrossTurnDegeneration = {
+    token: string;
+    turnCount: number;
+};
+//# sourceMappingURL=OutputDegeneration.d.ts.map

package/types/domain/entities/OutputDegeneration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutputDegeneration.d.ts","sourceRoot":"","sources":["../../../src/domain/entities/OutputDegeneration.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/types/domain/usecases/OutputDegenerationDetector.d.ts

@@ -0,0 +1,32 @@
+import { CrossTurnDegeneration } from '../entities/OutputDegeneration';
+export declare const OUTPUT_DEGENERATION_REPEAT_THRESHOLD = 5;
+export declare const OUTPUT_DEGENERATION_DOMINATION_FRACTION = 0.8;
+export declare const OUTPUT_DEGENERATION_MAX_TOKEN_LENGTH = 32;
+export declare const OUTPUT_DEGENERATION_ABSOLUTE_RUN_THRESHOLD = 15;
+export declare const OUTPUT_DEGENERATION_REP4_THRESHOLD = 0.3;
+export declare const OUTPUT_DEGENERATION_REP4_MIN_TOKENS = 40;
+export declare const OUTPUT_DEGENERATION_CROSS_TURN_WINDOW = 10;
+export declare const OUTPUT_DEGENERATION_CROSS_TURN_MIN_TURNS = 4;
+export type ShortTokenRun = {
+    token: string | null;
+    run: number;
+    total: number;
+};
+export declare class OutputDegenerationDetector {
+    private readonly repeatThreshold;
+    private readonly dominationFraction;
+    private readonly maxTokenLength;
+    private readonly absoluteRunThreshold;
+    private readonly rep4Threshold;
+    private readonly rep4MinTokens;
+    private readonly crossTurnWindow;
+    private readonly crossTurnMinTurns;
+    constructor(repeatThreshold?: number, dominationFraction?: number, maxTokenLength?: number, absoluteRunThreshold?: number, rep4Threshold?: number, rep4MinTokens?: number, crossTurnWindow?: number, crossTurnMinTurns?: number);
+    maxConsecutiveShortTokenRun: (text: string) => ShortTokenRun;
+    isIntraTurnDegeneration: (text: string) => boolean;
+    detectCrossTurnDegeneration: (texts: string[]) => CrossTurnDegeneration | null;
+    private stripRepetitionExemptSpans;
+    private duplicateNgramFraction;
+    private trailingSpuriousToken;
+}
+//# sourceMappingURL=OutputDegenerationDetector.d.ts.map

package/types/domain/usecases/OutputDegenerationDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutputDegenerationDetector.d.ts","sourceRoot":"","sources":["../../../src/domain/usecases/OutputDegenerationDetector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,eAAO,MAAM,oCAAoC,IAAI,CAAC;AACtD,eAAO,MAAM,uCAAuC,MAAM,CAAC;AAC3D,eAAO,MAAM,oCAAoC,KAAK,CAAC;AACvD,eAAO,MAAM,0CAA0C,KAAK,CAAC;AAC7D,eAAO,MAAM,kCAAkC,MAAM,CAAC;AACtD,eAAO,MAAM,mCAAmC,KAAK,CAAC;AACtD,eAAO,MAAM,qCAAqC,KAAK,CAAC;AACxD,eAAO,MAAM,wCAAwC,IAAI,CAAC;AAE1D,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAUF,qBAAa,0BAA0B;IAEnC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IACrC,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;gBAPjB,eAAe,GAAE,MAA6C,EAC9D,kBAAkB,GAAE,MAAgD,EACpE,cAAc,GAAE,MAA6C,EAC7D,oBAAoB,GAAE,MAAmD,EACzE,aAAa,GAAE,MAA2C,EAC1D,aAAa,GAAE,MAA4C,EAC3D,eAAe,GAAE,MAA8C,EAC/D,iBAAiB,GAAE,MAAiD;IAGvF,2BAA2B,GAAI,MAAM,MAAM,KAAG,aAAa,CAyBzD;IAEF,uBAAuB,GAAI,MAAM,MAAM,KAAG,OAAO,CAoB/C;IAEF,2BAA2B,GACzB,OAAO,MAAM,EAAE,KACd,qBAAqB,GAAG,IAAI,CAqB7B;IAEF,OAAO,CAAC,0BAA0B,CAqBhC;IAEF,OAAO,CAAC,sBAAsB,CAiB5B;IAEF,OAAO,CAAC,qBAAqB,CAc3B;CACH"}

package/types/domain/usecases/SessionOutputDegenerationRecoveryUseCase.d.ts

@@ -0,0 +1,31 @@
+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 } from './OutputDegenerationDetector';
+export declare const DEFAULT_OUTPUT_DEGENERATION_GRACE_SECONDS = 5;
+export declare const DEFAULT_OUTPUT_DEGENERATION_COOLDOWN_SECONDS = 300;
+export declare 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 declare class SessionOutputDegenerationRecoveryUseCase {
+    private readonly liveSessionProcessSnapshotProvider;
+    private readonly interactiveLiveSessionTranscriptResolver;
+    private readonly assistantTurnsRepository;
+    private readonly notificationRepository;
+    private readonly tmuxSessionRepository;
+    private readonly cooldownStateRepository;
+    private readonly sleeper;
+    private readonly detector;
+    private readonly resolveInteractiveLiveSessions;
+    constructor(liveSessionProcessSnapshotProvider: LiveSessionProcessSnapshotProvider, interactiveLiveSessionTranscriptResolver: InteractiveLiveSessionTranscriptResolver, assistantTurnsRepository: SessionAssistantTurnsRepository, notificationRepository: SilentSessionNotificationRepository, tmuxSessionRepository: Pick<TmuxSessionRepository, 'killSession'>, cooldownStateRepository: SessionDegenerationCooldownStateRepository, sleeper: Sleeper, detector?: OutputDegenerationDetector);
+    run: (params: {
+        enabled: boolean;
+        warningMessage: string;
+        graceSeconds: number;
+        cooldownSeconds: number;
+        now: Date;
+    }) => Promise<void>;
+}
+//# sourceMappingURL=SessionOutputDegenerationRecoveryUseCase.d.ts.map

package/types/domain/usecases/SessionOutputDegenerationRecoveryUseCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionOutputDegenerationRecoveryUseCase.d.ts","sourceRoot":"","sources":["../../../src/domain/usecases/SessionOutputDegenerationRecoveryUseCase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,yDAAyD,CAAC;AAC7G,OAAO,EAAE,wCAAwC,EAAE,MAAM,+DAA+D,CAAC;AACzH,OAAO,EAAE,+BAA+B,EAAE,MAAM,sDAAsD,CAAC;AACvG,OAAO,EAAE,0CAA0C,EAAE,MAAM,iEAAiE,CAAC;AAC7H,OAAO,EAAE,mCAAmC,EAAE,MAAM,0DAA0D,CAAC;AAC/G,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AACnF,OAAO,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AACvD,OAAO,EACL,0BAA0B,EAE3B,MAAM,8BAA8B,CAAC;AAItC,eAAO,MAAM,yCAAyC,IAAI,CAAC;AAC3D,eAAO,MAAM,4CAA4C,MAAM,CAAC;AAChE,eAAO,MAAM,2CAA2C,2OACkL,CAAC;AAE3O,qBAAa,wCAAwC;IAKjD,OAAO,CAAC,QAAQ,CAAC,kCAAkC;IACnD,OAAO,CAAC,QAAQ,CAAC,wCAAwC;IACzD,OAAO,CAAC,QAAQ,CAAC,wBAAwB;IACzC,OAAO,CAAC,QAAQ,CAAC,sBAAsB;IACvC,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IAItC,OAAO,CAAC,QAAQ,CAAC,uBAAuB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAd3B,OAAO,CAAC,QAAQ,CAAC,8BAA8B,CACD;gBAG3B,kCAAkC,EAAE,kCAAkC,EACtE,wCAAwC,EAAE,wCAAwC,EAClF,wBAAwB,EAAE,+BAA+B,EACzD,sBAAsB,EAAE,mCAAmC,EAC3D,qBAAqB,EAAE,IAAI,CAC1C,qBAAqB,EACrB,aAAa,CACd,EACgB,uBAAuB,EAAE,0CAA0C,EACnE,OAAO,EAAE,OAAO,EAChB,QAAQ,GAAE,0BAA6D;IAG1F,GAAG,GAAU,QAAQ;QACnB,OAAO,EAAE,OAAO,CAAC;QACjB,cAAc,EAAE,MAAM,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,eAAe,EAAE,MAAM,CAAC;QACxB,GAAG,EAAE,IAAI,CAAC;KACX,KAAG,OAAO,CAAC,IAAI,CAAC,CAiGf;CACH"}

package/types/domain/usecases/adapter-interfaces/SessionAssistantTurnsRepository.d.ts

@@ -0,0 +1,4 @@
+export interface SessionAssistantTurnsRepository {
+    listRecentAssistantTurnsBySessionName: (transcriptPathBySessionName: Map<string, string>, maxTurnsPerSession: number) => Promise<Map<string, string[]>>;
+}
+//# sourceMappingURL=SessionAssistantTurnsRepository.d.ts.map

package/types/domain/usecases/adapter-interfaces/SessionAssistantTurnsRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionAssistantTurnsRepository.d.ts","sourceRoot":"","sources":["../../../../src/domain/usecases/adapter-interfaces/SessionAssistantTurnsRepository.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,+BAA+B;IAC9C,qCAAqC,EAAE,CACrC,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChD,kBAAkB,EAAE,MAAM,KACvB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;CACrC"}

package/types/domain/usecases/adapter-interfaces/SessionDegenerationCooldownStateRepository.d.ts

@@ -0,0 +1,8 @@
+export interface SessionDegenerationCooldownStateRepository {
+    loadLastResetEpochSecondsBySessionName: () => Promise<Map<string, number>>;
+    recordReset: (params: {
+        sessionName: string;
+        now: Date;
+    }) => Promise<void>;
+}
+//# sourceMappingURL=SessionDegenerationCooldownStateRepository.d.ts.map

package/types/domain/usecases/adapter-interfaces/SessionDegenerationCooldownStateRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionDegenerationCooldownStateRepository.d.ts","sourceRoot":"","sources":["../../../../src/domain/usecases/adapter-interfaces/SessionDegenerationCooldownStateRepository.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,0CAA0C;IACzD,sCAAsC,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3E,WAAW,EAAE,CAAC,MAAM,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,IAAI,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5E"}