github-issue-tower-defence-management 1.139.0 → 1.140.0

package/src/domain/usecases/TokenExhaustionHandoverUseCase.ts

@@ -0,0 +1,413 @@
+import { ClaudeHandoverSession } from '../entities/ClaudeHandoverSession';
+import {
+  TokenExhaustionHandoverState,
+  TokenExhaustionHandoverStateEntry,
+} from '../entities/TokenExhaustionHandoverState';
+import { ClaudeHandoverSessionRepository } from './adapter-interfaces/ClaudeHandoverSessionRepository';
+import { ProcessSignalRepository } from './adapter-interfaces/ProcessSignalRepository';
+import { TmuxSessionRepository } from './adapter-interfaces/TmuxSessionRepository';
+import {
+  TokenModelWeeklyLimit,
+  TokenRateLimitSnapshot,
+  TokenRateLimitSnapshotRepository,
+} from './adapter-interfaces/TokenRateLimitSnapshotRepository';
+
+export const DEFAULT_TOKEN_EXHAUSTION_HANDOVER_MESSAGE =
+  'TOKEN NEAR EXHAUSTION. Within 2 minutes, write a CHECKPOINT to your assigned task issue: the in-flight subagents and what each is doing, their durable refs (branch and pull request URLs), the working directory and branch, the single concrete next action to resume, and the reason (token near exhaustion). Do this WITHOUT waiting for long-running or CI-watching subagents. Then self-kill your own tmux session with `tmux kill-session`.';
+
+export const DEFAULT_TOKEN_EXHAUSTION_HANDOVER_MESSAGE_BARE_NAME_LEADER =
+  'TOKEN NEAR EXHAUSTION. You are a resident leader with no assigned task issue. Within 2 minutes, write a CHECKPOINT for every in-flight subagent (what each is doing and its durable refs = branch and pull request URLs, plus the single concrete next action to resume and the working directory and branch) into the GitHub issue that each subagent is working on, WITHOUT waiting for long-running or CI-watching subagents. Then stop and stay idle; do NOT self-kill. This session will be terminated and relaunched on a token that still has quota so its work is preserved.';
+
+export const DEFAULT_TOKEN_EXHAUSTION_GRACE_PERIOD_SECONDS = 180;
+export const TOKEN_EXHAUSTION_SNAPSHOT_STALE_THRESHOLD_SECONDS = 900;
+export const TOKEN_EXHAUSTION_SNAPSHOT_HARD_STALE_THRESHOLD_SECONDS = 3600;
+export const TOKEN_EXHAUSTION_FIVE_HOUR_FREE_THRESHOLD = 0.1;
+export const TOKEN_EXHAUSTION_SEVEN_DAY_FREE_THRESHOLD = 0.05;
+export const TOKEN_EXHAUSTION_FIVE_HOUR_WARNING_FREE_THRESHOLD = 0.25;
+export const TOKEN_EXHAUSTION_SEVEN_DAY_WARNING_FREE_THRESHOLD = 0.15;
+
+type SnapshotVerdict = {
+  stale: boolean;
+  exhausted: boolean;
+  reason: string;
+  fiveHourFree: number;
+  sevenDayFree: number;
+  blocked: boolean;
+  weeklyCapped: boolean;
+};
+
+export type TokenExhaustionHandoverInput = {
+  enabled: boolean;
+  issueUrlLeaderMessage: string;
+  bareNameLeaderMessage: string;
+  gracePeriodSeconds: number;
+  state: TokenExhaustionHandoverState;
+  now: Date;
+};
+
+export type TokenExhaustionHandoverResult = {
+  newlyHandoverSentSessionNames: string[];
+  killedSessionNames: string[];
+  terminatedPids: number[];
+  relaunchedLeaderNames: string[];
+  leftAliveSessionNames: string[];
+  state: TokenExhaustionHandoverState;
+};
+
+export class TokenExhaustionHandoverUseCase {
+  constructor(
+    private readonly handoverSessionRepository: Pick<
+      ClaudeHandoverSessionRepository,
+      'listHandoverSessions'
+    >,
+    private readonly snapshotRepository: Pick<
+      TokenRateLimitSnapshotRepository,
+      'listSnapshots'
+    >,
+    private readonly tmuxSessionRepository: Pick<
+      TmuxSessionRepository,
+      | 'sendKeys'
+      | 'killSession'
+      | 'listLiveSessionNames'
+      | 'launchBareNameLeaderSession'
+    >,
+    private readonly processSignalRepository: ProcessSignalRepository,
+  ) {}
+
+  run = async (
+    input: TokenExhaustionHandoverInput,
+  ): Promise<TokenExhaustionHandoverResult> => {
+    const nowEpochSeconds = Math.floor(input.now.getTime() / 1000);
+    const sessions = this.handoverSessionRepository.listHandoverSessions();
+    const snapshots = this.snapshotRepository.listSnapshots();
+    const snapshotByToken = new Map(
+      snapshots.map((snapshot) => [snapshot.token, snapshot]),
+    );
+    const liveSessionNames = new Set(
+      await this.tmuxSessionRepository.listLiveSessionNames(),
+    );
+
+    const nextEntries: Record<string, TokenExhaustionHandoverStateEntry> = {
+      ...input.state.entries,
+    };
+    const newlyHandoverSentSessionNames: string[] = [];
+    const killedSessionNames: string[] = [];
+    const terminatedPids: number[] = [];
+    const relaunchedLeaderNames: string[] = [];
+    const leftAliveSessionNames: string[] = [];
+
+    for (const session of sessions) {
+      try {
+        const snapshot = snapshotByToken.get(session.token);
+        if (snapshot === undefined) {
+          continue;
+        }
+        const hasTmux = session.kind !== 'implSubagent';
+        const verdict = this.evaluateSnapshot(
+          snapshot,
+          nowEpochSeconds,
+          hasTmux,
+        );
+        const stateKey = this.stateKeyFor(session);
+
+        if (verdict.stale) {
+          continue;
+        }
+        if (!verdict.exhausted) {
+          delete nextEntries[stateKey];
+          continue;
+        }
+        if (
+          !this.isFresherTokenAvailable(
+            session.token,
+            snapshots,
+            nowEpochSeconds,
+          )
+        ) {
+          console.log(
+            `Token exhaustion handover: leaving ${this.displayName(session)} alive (token pool globally exhausted, no fresher token available)`,
+          );
+          leftAliveSessionNames.push(this.displayName(session));
+          continue;
+        }
+
+        const entry = nextEntries[stateKey];
+        if (entry === undefined) {
+          if (input.enabled) {
+            await this.sendHandover(session, input);
+          }
+          console.log(
+            `Token exhaustion handover: signaled ${this.displayName(session)} kind=${session.kind} reason=${verdict.reason} enabled=${input.enabled}`,
+          );
+          nextEntries[stateKey] = {
+            signaledAtEpoch: nowEpochSeconds,
+            pid: session.pid,
+          };
+          newlyHandoverSentSessionNames.push(this.displayName(session));
+          continue;
+        }
+
+        if (
+          nowEpochSeconds - entry.signaledAtEpoch <
+          input.gracePeriodSeconds
+        ) {
+          console.log(
+            `Token exhaustion handover: waiting for grace period for ${this.displayName(session)} remainingSeconds=${input.gracePeriodSeconds - (nowEpochSeconds - entry.signaledAtEpoch)}`,
+          );
+          continue;
+        }
+
+        const alive = hasTmux
+          ? session.sessionName !== null &&
+            liveSessionNames.has(session.sessionName)
+          : this.processSignalRepository.isProcessAlive(entry.pid);
+        if (!alive) {
+          if (input.enabled && this.needsRelaunch(session)) {
+            await this.relaunchBareNameLeader(session, relaunchedLeaderNames);
+          }
+          delete nextEntries[stateKey];
+          continue;
+        }
+
+        if (!input.enabled) {
+          console.log(
+            `Token exhaustion handover: would force-kill ${this.displayName(session)} kind=${session.kind} (dry-run, enabled=false)`,
+          );
+          delete nextEntries[stateKey];
+          continue;
+        }
+
+        await this.forceKill(session, entry);
+        if (this.needsRelaunch(session)) {
+          await this.relaunchBareNameLeader(session, relaunchedLeaderNames);
+        }
+        console.log(
+          `Token exhaustion handover: force-killed ${this.displayName(session)} kind=${session.kind}`,
+        );
+        if (hasTmux) {
+          killedSessionNames.push(this.displayName(session));
+        } else {
+          terminatedPids.push(entry.pid);
+        }
+        delete nextEntries[stateKey];
+      } catch (error) {
+        console.error(
+          `Token exhaustion handover: error processing ${this.displayName(session)}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+    }
+
+    console.log(
+      `Token exhaustion handover: cycle summary evaluated=${sessions.length} enabled=${input.enabled} signaled=${newlyHandoverSentSessionNames.length} killed=${killedSessionNames.length} terminatedPids=${terminatedPids.length} relaunched=${relaunchedLeaderNames.length} leftAlive=${leftAliveSessionNames.length}`,
+    );
+
+    return {
+      newlyHandoverSentSessionNames,
+      killedSessionNames,
+      terminatedPids,
+      relaunchedLeaderNames,
+      leftAliveSessionNames,
+      state: { entries: nextEntries },
+    };
+  };
+
+  private needsRelaunch = (session: ClaudeHandoverSession): boolean =>
+    session.kind === 'bareNameLeader' && session.name !== null;
+
+  private relaunchBareNameLeader = async (
+    session: ClaudeHandoverSession,
+    relaunchedLeaderNames: string[],
+  ): Promise<void> => {
+    if (session.name === null) {
+      return;
+    }
+    await this.tmuxSessionRepository.launchBareNameLeaderSession(session.name);
+    relaunchedLeaderNames.push(session.name);
+  };
+
+  private sendHandover = async (
+    session: ClaudeHandoverSession,
+    input: TokenExhaustionHandoverInput,
+  ): Promise<void> => {
+    if (session.kind === 'implSubagent') {
+      this.processSignalRepository.terminateProcess(session.pid);
+      return;
+    }
+    if (session.sessionName === null) {
+      return;
+    }
+    const message =
+      session.kind === 'issueUrlLeader'
+        ? input.issueUrlLeaderMessage
+        : input.bareNameLeaderMessage;
+    await this.tmuxSessionRepository.sendKeys(session.sessionName, message);
+  };
+
+  private forceKill = async (
+    session: ClaudeHandoverSession,
+    entry: TokenExhaustionHandoverStateEntry,
+  ): Promise<void> => {
+    if (session.kind === 'implSubagent') {
+      this.processSignalRepository.killProcess(entry.pid);
+      return;
+    }
+    if (session.sessionName !== null) {
+      try {
+        await this.tmuxSessionRepository.killSession(session.sessionName);
+      } catch (error) {
+        console.error(
+          `Token exhaustion handover: killSession failed for ${session.sessionName}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+    }
+    this.processSignalRepository.killProcess(entry.pid);
+  };
+
+  private stateKeyFor = (session: ClaudeHandoverSession): string =>
+    session.kind === 'implSubagent'
+      ? `pid:${session.pid}`
+      : (session.sessionName ?? `pid:${session.pid}`);
+
+  private displayName = (session: ClaudeHandoverSession): string =>
+    session.sessionName ?? `pid:${session.pid}`;
+
+  private isFresherTokenAvailable = (
+    currentToken: string,
+    snapshots: TokenRateLimitSnapshot[],
+    nowEpochSeconds: number,
+  ): boolean => {
+    for (const snapshot of snapshots) {
+      if (snapshot.token === currentToken) {
+        continue;
+      }
+      const verdict = this.evaluateSnapshot(snapshot, nowEpochSeconds, true);
+      if (!verdict.stale && !verdict.exhausted) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  private evaluateSnapshot = (
+    snapshot: TokenRateLimitSnapshot,
+    nowEpochSeconds: number,
+    hasTmux: boolean,
+  ): SnapshotVerdict => {
+    const age = nowEpochSeconds - snapshot.lastUpdatedEpoch;
+    const fiveHourFree = this.freeRatio(
+      snapshot.fiveHourUtilization,
+      snapshot.fiveHourReset,
+      nowEpochSeconds,
+    );
+    const sevenDayFree = this.freeRatio(
+      snapshot.sevenDayUtilization,
+      snapshot.sevenDayReset,
+      nowEpochSeconds,
+    );
+    const blocked =
+      snapshot.blocked ||
+      snapshot.rejected ||
+      snapshot.blockedUntilEpoch > nowEpochSeconds;
+    const weeklyCapped = this.isWeeklyCapped(
+      snapshot.modelWeeklyLimits,
+      nowEpochSeconds,
+    );
+
+    if (age > TOKEN_EXHAUSTION_SNAPSHOT_HARD_STALE_THRESHOLD_SECONDS) {
+      return {
+        stale: true,
+        exhausted: false,
+        reason: 'hard_stale',
+        fiveHourFree,
+        sevenDayFree,
+        blocked,
+        weeklyCapped,
+      };
+    }
+
+    const inWarningBand =
+      fiveHourFree < TOKEN_EXHAUSTION_FIVE_HOUR_WARNING_FREE_THRESHOLD ||
+      sevenDayFree < TOKEN_EXHAUSTION_SEVEN_DAY_WARNING_FREE_THRESHOLD ||
+      blocked ||
+      weeklyCapped;
+    if (
+      age > TOKEN_EXHAUSTION_SNAPSHOT_STALE_THRESHOLD_SECONDS &&
+      !inWarningBand
+    ) {
+      return {
+        stale: true,
+        exhausted: false,
+        reason: 'stale_healthy',
+        fiveHourFree,
+        sevenDayFree,
+        blocked,
+        weeklyCapped,
+      };
+    }
+
+    const exhausted =
+      fiveHourFree < TOKEN_EXHAUSTION_FIVE_HOUR_FREE_THRESHOLD ||
+      (hasTmux && sevenDayFree < TOKEN_EXHAUSTION_SEVEN_DAY_FREE_THRESHOLD) ||
+      blocked ||
+      weeklyCapped;
+    const reason = weeklyCapped
+      ? 'weekly_hard_cap_rejected'
+      : fiveHourFree < TOKEN_EXHAUSTION_FIVE_HOUR_FREE_THRESHOLD
+        ? 'five_hour_free_below_threshold'
+        : hasTmux && sevenDayFree < TOKEN_EXHAUSTION_SEVEN_DAY_FREE_THRESHOLD
+          ? 'seven_day_free_below_threshold'
+          : blocked
+            ? 'blocked_or_rejected'
+            : 'healthy';
+    return {
+      stale: false,
+      exhausted,
+      reason,
+      fiveHourFree,
+      sevenDayFree,
+      blocked,
+      weeklyCapped,
+    };
+  };
+
+  private freeRatio = (
+    utilization: number,
+    resetEpoch: number,
+    nowEpochSeconds: number,
+  ): number => {
+    if (resetEpoch > 0 && nowEpochSeconds > resetEpoch) {
+      return 1;
+    }
+    return 1 - this.clamp01(utilization);
+  };
+
+  private clamp01 = (value: number): number => {
+    if (value < 0) {
+      return 0;
+    }
+    if (value > 1) {
+      return 1;
+    }
+    return value;
+  };
+
+  private isWeeklyCapped = (
+    modelWeeklyLimits: TokenModelWeeklyLimit[],
+    nowEpochSeconds: number,
+  ): boolean => {
+    for (const limit of modelWeeklyLimits) {
+      if (!limit.rejected) {
+        continue;
+      }
+      if (limit.resetsAt > 0 && nowEpochSeconds > limit.resetsAt) {
+        continue;
+      }
+      return true;
+    }
+    return false;
+  };
+}

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

@@ -0,0 +1,5 @@
+import { ClaudeHandoverSession } from '../../entities/ClaudeHandoverSession';
+
+export interface ClaudeHandoverSessionRepository {
+  listHandoverSessions: () => ClaudeHandoverSession[];
+}

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

@@ -0,0 +1,5 @@
+export interface ProcessSignalRepository {
+  isProcessAlive: (pid: number) => boolean;
+  terminateProcess: (pid: number) => void;
+  killProcess: (pid: number) => void;
+}

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

@@ -0,0 +1,10 @@
+export interface SilentSessionNotifiedStateRepository {
+  loadRecentNotifiedSessionNames: (params: {
+    now: Date;
+    recencyWindowSeconds: number;
+  }) => Promise<Set<string>>;
+  saveNotifiedSessionNames: (params: {
+    sessionNames: string[];
+    now: Date;
+  }) => Promise<void>;
+}

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

@@ -11,4 +11,6 @@ export interface TmuxSessionRepository {
   ) => Promise<void>;
   killSession: (sessionName: string) => Promise<void>;
   killOwnSession: () => Promise<void>;
+  sendKeys: (sessionName: string, literalText: string) => Promise<void>;
+  launchBareNameLeaderSession: (name: string) => Promise<void>;
 }

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

@@ -0,0 +1,6 @@
+import { TokenExhaustionHandoverState } from '../../entities/TokenExhaustionHandoverState';
+
+export interface TokenExhaustionHandoverStateRepository {
+  load: () => TokenExhaustionHandoverState;
+  save: (state: TokenExhaustionHandoverState) => void;
+}

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

@@ -0,0 +1,22 @@
+export type TokenModelWeeklyLimit = {
+  rejected: boolean;
+  resetsAt: number;
+};
+
+export type TokenRateLimitSnapshot = {
+  token: string;
+  name: string;
+  fiveHourUtilization: number;
+  fiveHourReset: number;
+  sevenDayUtilization: number;
+  sevenDayReset: number;
+  blocked: boolean;
+  rejected: boolean;
+  blockedUntilEpoch: number;
+  modelWeeklyLimits: TokenModelWeeklyLimit[];
+  lastUpdatedEpoch: number;
+};
+
+export interface TokenRateLimitSnapshotRepository {
+  listSnapshots: () => TokenRateLimitSnapshot[];
+}

package/src/domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase.test.ts

@@ -72,6 +72,8 @@ const createFakeTmuxSessionRepository = (state: {
     },
     killSession: async () => undefined,
     killOwnSession: async () => undefined,
+    sendKeys: async () => undefined,
+    launchBareNameLeaderSession: async () => undefined,
   };
 };
 

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":"AAoCA,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,CAkmBP;CACH"}
+{"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"}

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

@@ -18,6 +18,7 @@ export type NotifySilentTmuxSessionsParams = {
     staggerSeconds: number;
     candidateDebounceRecencyWindowSeconds: number;
     candidateDebounceStateFilePath: string | null;
+    notifiedStateFilePath: string | null;
     activeHubTaskStatus: string | null;
     hubTaskStatusResolver: HubTaskStatusResolver | null;
     hubTaskStatusCacheStateFilePath: string | null;

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

@@ -1 +1 @@
-{"version":3,"file":"notifySilentTmuxSessions.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/notifySilentTmuxSessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gEAAgE,CAAC;AAGpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,kEAAkE,CAAC;AACxG,OAAO,EAEL,qBAAqB,EAQtB,MAAM,0DAA0D,CAAC;AAgBlE,OAAO,EAEL,6BAA6B,EAC9B,MAAM,6DAA6D,CAAC;AAKrE,MAAM,MAAM,8BAA8B,GAAG;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,4BAA4B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,0BAA0B,EAAE,MAAM,CAAC;IACnC,+BAA+B,EAAE,MAAM,CAAC;IACxC,8BAA8B,EAAE,MAAM,CAAC;IACvC,+BAA+B,EAAE,MAAM,CAAC;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,qCAAqC,EAAE,MAAM,CAAC;IAC9C,8BAA8B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,qBAAqB,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACpD,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,4BAA4B,EAAE,MAAM,CAAC;IACrC,gBAAgB,EAAE,6BAA6B,CAAC;IAChD,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AAuCF,eAAO,MAAM,wBAAwB,GACnC,QAAQ,8BAA8B,KACrC,OAAO,CAAC,IAAI,CA6Ed,CAAC;AAEF,eAAO,MAAM,0CAA0C;;;;;;;;CAS7C,CAAC"}
+{"version":3,"file":"notifySilentTmuxSessions.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/notifySilentTmuxSessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gEAAgE,CAAC;AAGpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,kEAAkE,CAAC;AACxG,OAAO,EAEL,qBAAqB,EAQtB,MAAM,0DAA0D,CAAC;AAgBlE,OAAO,EAEL,6BAA6B,EAC9B,MAAM,6DAA6D,CAAC;AAMrE,MAAM,MAAM,8BAA8B,GAAG;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,4BAA4B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,0BAA0B,EAAE,MAAM,CAAC;IACnC,+BAA+B,EAAE,MAAM,CAAC;IACxC,8BAA8B,EAAE,MAAM,CAAC;IACvC,+BAA+B,EAAE,MAAM,CAAC;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,qCAAqC,EAAE,MAAM,CAAC;IAC9C,8BAA8B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,qBAAqB,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACpD,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,4BAA4B,EAAE,MAAM,CAAC;IACrC,gBAAgB,EAAE,6BAA6B,CAAC;IAChD,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AAuCF,eAAO,MAAM,wBAAwB,GACnC,QAAQ,8BAA8B,KACrC,OAAO,CAAC,IAAI,CAmFd,CAAC;AAEF,eAAO,MAAM,0CAA0C;;;;;;;;CAS7C,CAAC"}

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

@@ -0,0 +1,14 @@
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+export type TokenExhaustionHandoverParams = {
+    enabled: boolean;
+    tokenListJsonPath: string | null;
+    handoverMessage?: string | null;
+    bareNameLeaderHandoverMessage?: string | null;
+    tokenRateLimitSnapshotBaseDir?: string | null;
+    gracePeriodSeconds?: number | null;
+    stateFilePath?: string | null;
+    localCommandRunner: LocalCommandRunner;
+    now: Date;
+};
+export declare const handleTokenExhaustionHandover: (params: TokenExhaustionHandoverParams) => Promise<void>;
+//# sourceMappingURL=tokenExhaustionHandover.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenExhaustionHandover.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/tokenExhaustionHandover.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gEAAgE,CAAC;AAgBpG,MAAM,MAAM,6BAA6B,GAAG;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,6BAA6B,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,6BAA6B,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,QAAQ,6BAA6B,KACpC,OAAO,CAAC,IAAI,CAgDd,CAAC"}

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

@@ -0,0 +1,11 @@
+import { TokenExhaustionHandoverState } from '../../domain/entities/TokenExhaustionHandoverState';
+import { TokenExhaustionHandoverStateRepository } from '../../domain/usecases/adapter-interfaces/TokenExhaustionHandoverStateRepository';
+export declare const defaultHandoverStateFilePath: () => string;
+export declare class FileHandoverStateRepository implements TokenExhaustionHandoverStateRepository {
+    private readonly filePath;
+    constructor(filePath?: string);
+    load: () => TokenExhaustionHandoverState;
+    save: (state: TokenExhaustionHandoverState) => void;
+    private parseEntries;
+}
+//# sourceMappingURL=FileHandoverStateRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileHandoverStateRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/FileHandoverStateRepository.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,4BAA4B,EAE7B,MAAM,oDAAoD,CAAC;AAC5D,OAAO,EAAE,sCAAsC,EAAE,MAAM,iFAAiF,CAAC;AAEzI,eAAO,MAAM,4BAA4B,QAAO,MAO/C,CAAC;AAKF,qBAAa,2BAA4B,YAAW,sCAAsC;IAEtF,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,GAAE,MAAuC;IAGpE,IAAI,QAAO,4BAA4B,CAcrC;IAEF,IAAI,GAAI,OAAO,4BAA4B,KAAG,IAAI,CAQhD;IAEF,OAAO,CAAC,YAAY,CAsBlB;CACH"}

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

@@ -0,0 +1,16 @@
+import { SilentSessionNotifiedStateRepository } from '../../domain/usecases/adapter-interfaces/SilentSessionNotifiedStateRepository';
+export declare class FileSystemSilentSessionNotifiedStateRepository implements SilentSessionNotifiedStateRepository {
+    private readonly stateFilePath;
+    constructor(stateFilePath?: string);
+    loadRecentNotifiedSessionNames: (params: {
+        now: Date;
+        recencyWindowSeconds: number;
+    }) => Promise<Set<string>>;
+    saveNotifiedSessionNames: (params: {
+        sessionNames: string[];
+        now: Date;
+    }) => Promise<void>;
+    private readNotifiedEntries;
+    private writeState;
+}
+//# sourceMappingURL=FileSystemSilentSessionNotifiedStateRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystemSilentSessionNotifiedStateRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/FileSystemSilentSessionNotifiedStateRepository.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oCAAoC,EAAE,MAAM,+EAA+E,CAAC;AAuBrI,qBAAa,8CAA+C,YAAW,oCAAoC;IAEvG,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,GAAE,MAA+B;IAGjE,8BAA8B,GAAU,QAAQ;QAC9C,GAAG,EAAE,IAAI,CAAC;QACV,oBAAoB,EAAE,MAAM,CAAC;KAC9B,KAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAWtB;IAEF,wBAAwB,GAAU,QAAQ;QACxC,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,GAAG,EAAE,IAAI,CAAC;KACX,KAAG,OAAO,CAAC,IAAI,CAAC,CAUf;IAEF,OAAO,CAAC,mBAAmB,CAoCzB;IAEF,OAAO,CAAC,UAAU,CAMhB;CACH"}

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

@@ -0,0 +1,8 @@
+import { ProcessSignalRepository } from '../../domain/usecases/adapter-interfaces/ProcessSignalRepository';
+export declare class NodeProcessSignalRepository implements ProcessSignalRepository {
+    isProcessAlive: (pid: number) => boolean;
+    terminateProcess: (pid: number) => void;
+    killProcess: (pid: number) => void;
+    private signal;
+}
+//# sourceMappingURL=NodeProcessSignalRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NodeProcessSignalRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/NodeProcessSignalRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,kEAAkE,CAAC;AAc3G,qBAAa,2BAA4B,YAAW,uBAAuB;IACzE,cAAc,GAAI,KAAK,MAAM,KAAG,OAAO,CAOrC;IAEF,gBAAgB,GAAI,KAAK,MAAM,KAAG,IAAI,CAEpC;IAEF,WAAW,GAAI,KAAK,MAAM,KAAG,IAAI,CAE/B;IAEF,OAAO,CAAC,MAAM,CAaZ;CACH"}

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

@@ -4,7 +4,8 @@ import { LiveTmuxSession } from '../../domain/entities/LiveTmuxSession';
 export declare class NodeTmuxSessionRepository implements TmuxSessionRepository {
     private readonly localCommandRunner;
     private readonly procDirectory;
-    constructor(localCommandRunner: LocalCommandRunner, procDirectory?: string);
+    private readonly submitDelayMilliseconds;
+    constructor(localCommandRunner: LocalCommandRunner, procDirectory?: string, submitDelayMilliseconds?: number);
     listLiveSessionNames: () => Promise<string[]>;
     listLiveSessionsWithActivity: () => Promise<LiveTmuxSession[]>;
     listInteractiveProcessCommandLines: () => Promise<string[]>;
@@ -12,5 +13,10 @@ export declare class NodeTmuxSessionRepository implements TmuxSessionRepository
     killSession: (sessionName: string) => Promise<void>;
     killOwnSession: () => Promise<void>;
     private stopScopeUnit;
+    sendKeys: (sessionName: string, literalText: string) => Promise<void>;
+    launchBareNameLeaderSession: (name: string) => Promise<void>;
+    private sendEnter;
+    private messageStillInComposer;
+    private delaySubmit;
 }
 //# sourceMappingURL=NodeTmuxSessionRepository.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"NodeTmuxSessionRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/NodeTmuxSessionRepository.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAC;AACjG,OAAO,EAAE,qBAAqB,EAAE,MAAM,gEAAgE,CAAC;AACvG,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAIxE,qBAAa,yBAA0B,YAAW,qBAAqB;IAEnE,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa;gBADb,kBAAkB,EAAE,kBAAkB,EACtC,aAAa,GAAE,MAAgB;IAGlD,oBAAoB,QAAa,OAAO,CAAC,MAAM,EAAE,CAAC,CAYhD;IAEF,4BAA4B,QAAa,OAAO,CAAC,eAAe,EAAE,CAAC,CAkBjE;IAEF,kCAAkC,QAAa,OAAO,CAAC,MAAM,EAAE,CAAC,CAY9D;IAEF,qBAAqB,GACnB,aAAa,MAAM,EACnB,iBAAiB,MAAM,EACvB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAAC,CAcd;IAEF,WAAW,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC,CActD;IAEF,cAAc,QAAa,OAAO,CAAC,IAAI,CAAC,CAatC;IAEF,OAAO,CAAC,aAAa,CAsBnB;CACH"}
+{"version":3,"file":"NodeTmuxSessionRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/NodeTmuxSessionRepository.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAC;AACjG,OAAO,EAAE,qBAAqB,EAAE,MAAM,gEAAgE,CAAC;AACvG,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAWxE,qBAAa,yBAA0B,YAAW,qBAAqB;IAEnE,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,uBAAuB;gBAFvB,kBAAkB,EAAE,kBAAkB,EACtC,aAAa,GAAE,MAAgB,EAC/B,uBAAuB,GAAE,MAA0C;IAGtF,oBAAoB,QAAa,OAAO,CAAC,MAAM,EAAE,CAAC,CAYhD;IAEF,4BAA4B,QAAa,OAAO,CAAC,eAAe,EAAE,CAAC,CAkBjE;IAEF,kCAAkC,QAAa,OAAO,CAAC,MAAM,EAAE,CAAC,CAY9D;IAEF,qBAAqB,GACnB,aAAa,MAAM,EACnB,iBAAiB,MAAM,EACvB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAAC,CAcd;IAEF,WAAW,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC,CActD;IAEF,cAAc,QAAa,OAAO,CAAC,IAAI,CAAC,CAatC;IAEF,OAAO,CAAC,aAAa,CAsBnB;IAEF,QAAQ,GACN,aAAa,MAAM,EACnB,aAAa,MAAM,KAClB,OAAO,CAAC,IAAI,CAAC,CAqBd;IAEF,2BAA2B,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC,CAc/D;IAEF,OAAO,CAAC,SAAS,CAcf;IAEF,OAAO,CAAC,sBAAsB,CAuB5B;IAEF,OAAO,CAAC,WAAW,CAOjB;CACH"}

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

@@ -0,0 +1,13 @@
+import { ClaudeHandoverSession } from '../../domain/entities/ClaudeHandoverSession';
+import { ClaudeHandoverSessionRepository } from '../../domain/usecases/adapter-interfaces/ClaudeHandoverSessionRepository';
+export declare class ProcClaudeHandoverSessionRepository implements ClaudeHandoverSessionRepository {
+    private readonly procDirectory;
+    constructor(procDirectory?: string);
+    listHandoverSessions: () => ClaudeHandoverSession[];
+    private listProcessIdDirectories;
+    private readHandoverSession;
+    private readComm;
+    private readCommandArguments;
+    private readEnviron;
+}
+//# sourceMappingURL=ProcClaudeHandoverSessionRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProcClaudeHandoverSessionRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/ProcClaudeHandoverSessionRepository.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,qBAAqB,EAEtB,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AAoG3H,qBAAa,mCAAoC,YAAW,+BAA+B;IAEvF,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,GAAE,MAA+B;IAGjE,oBAAoB,QAAO,qBAAqB,EAAE,CAShD;IAEF,OAAO,CAAC,wBAAwB,CAQ9B;IAEF,OAAO,CAAC,mBAAmB,CAiBzB;IAEF,OAAO,CAAC,QAAQ,CAOd;IAEF,OAAO,CAAC,oBAAoB,CAe1B;IAEF,OAAO,CAAC,WAAW,CA6BjB;CACH"}

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

@@ -0,0 +1,9 @@
+import { TokenRateLimitSnapshot, TokenRateLimitSnapshotRepository } from '../../domain/usecases/adapter-interfaces/TokenRateLimitSnapshotRepository';
+export declare class RateLimitSnapshotRepository implements TokenRateLimitSnapshotRepository {
+    private readonly tokenListJsonPath;
+    private readonly baseDir;
+    constructor(tokenListJsonPath: string, baseDir?: string);
+    listSnapshots: () => TokenRateLimitSnapshot[];
+    private toModelWeeklyLimits;
+}
+//# sourceMappingURL=RateLimitSnapshotRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RateLimitSnapshotRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/RateLimitSnapshotRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,sBAAsB,EACtB,gCAAgC,EACjC,MAAM,2EAA2E,CAAC;AAInF,qBAAa,2BAA4B,YAAW,gCAAgC;IAEhF,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,iBAAiB,EAAE,MAAM,EACzB,OAAO,GAAE,MAAmB;IAG/C,aAAa,QAAO,sBAAsB,EAAE,CA0B1C;IAEF,OAAO,CAAC,mBAAmB,CAMrB;CACP"}

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

@@ -1 +1 @@
-{"version":3,"file":"TmuxSilentSessionNotificationRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/TmuxSilentSessionNotificationRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mCAAmC,EAAE,MAAM,8EAA8E,CAAC;AACnI,OAAO,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAC;AAEjG,qBAAa,uCAAwC,YAAW,mCAAmC;IACrF,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,kBAAkB;IAEnE,yBAAyB,GACvB,aAAa,MAAM,EACnB,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAAC,CA4Bd;CACH"}
+{"version":3,"file":"TmuxSilentSessionNotificationRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/TmuxSilentSessionNotificationRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mCAAmC,EAAE,MAAM,8EAA8E,CAAC;AACnI,OAAO,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAC;AAKjG,qBAAa,uCAAwC,YAAW,mCAAmC;IACrF,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,kBAAkB;IAEnE,yBAAyB,GACvB,aAAa,MAAM,EACnB,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAAC,CA6Bd;CACH"}

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

@@ -0,0 +1,10 @@
+export type ClaudeHandoverSessionKind = 'issueUrlLeader' | 'bareNameLeader' | 'implSubagent';
+export type ClaudeHandoverSession = {
+    kind: ClaudeHandoverSessionKind;
+    pid: number;
+    token: string;
+    sessionName: string | null;
+    name: string | null;
+    issueUrl: string | null;
+};
+//# sourceMappingURL=ClaudeHandoverSession.d.ts.map