github-issue-tower-defence-management 2.19.0 → 2.19.2

package/src/domain/usecases/OauthTokenSelectUseCase.ts

@@ -1,274 +0,0 @@
-export type OauthTokenWindowSnapshot = {
-  fiveHourUtilization: number;
-  fiveHourReset: number;
-  sevenDayUtilization: number;
-  sevenDayReset: number;
-};
-
-export type OauthTokenCandidate = {
-  name: string;
-  token: string;
-  snapshot: OauthTokenWindowSnapshot | null;
-  subscriptionDisabled: boolean;
-  unifiedRejected: boolean;
-  fableRejected: boolean;
-  selectionWeight?: number;
-};
-
-export type SelectionRandom = () => number;
-
-export const DEFAULT_SELECTION_WEIGHT = 1;
-
-export const selectionWeightOf = (candidate: OauthTokenCandidate): number => {
-  const weight = candidate.selectionWeight ?? DEFAULT_SELECTION_WEIGHT;
-  return weight > 0 ? weight : 0;
-};
-
-export type OauthTokenCandidateMetrics = {
-  name: string;
-  fiveHourFreeRatio: number;
-  sevenDayFreeRatio: number;
-  sevenDayEndEpoch: number;
-  eligible: boolean;
-  exclusionReason: string | null;
-  drawWeight: number;
-};
-
-export type OauthTokenSelectResult = {
-  selected: OauthTokenCandidate | null;
-  metrics: OauthTokenCandidateMetrics[];
-};
-
-export type OauthTokenSelectionThresholds = {
-  fiveHourMinFreeRatio: number;
-  sevenDayMinFreeRatio: number;
-};
-
-const SECONDS_PER_DAY = 86400;
-const SEVEN_DAYS_IN_SECONDS = 7 * SECONDS_PER_DAY;
-
-export const FIVE_HOUR_MIN_FREE_RATIO = 0.25;
-export const SEVEN_DAY_MIN_FREE_RATIO = 0.03;
-
-export const DEFAULT_OAUTH_TOKEN_SELECTION_THRESHOLDS: OauthTokenSelectionThresholds =
-  {
-    fiveHourMinFreeRatio: FIVE_HOUR_MIN_FREE_RATIO,
-    sevenDayMinFreeRatio: SEVEN_DAY_MIN_FREE_RATIO,
-  };
-
-export const CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS: OauthTokenSelectionThresholds =
-  {
-    fiveHourMinFreeRatio: 0.6,
-    sevenDayMinFreeRatio: 0.14,
-  };
-
-export const SEVEN_DAY_WINDOW_HOURS = 168;
-export const MIN_HOURS_TO_RESET = 1;
-const SECONDS_PER_HOUR = 3600;
-
-export const sevenDayUrgencyFactor = (
-  sevenDayFreeRatio: number,
-  sevenDayEndEpoch: number,
-  nowEpochSeconds: number,
-): number => {
-  const hoursToReset = Math.max(
-    (sevenDayEndEpoch - nowEpochSeconds) / SECONDS_PER_HOUR,
-    MIN_HOURS_TO_RESET,
-  );
-  return sevenDayFreeRatio * (SEVEN_DAY_WINDOW_HOURS / hoursToReset);
-};
-
-export const selectWeightedCandidate = <Entry>(
-  eligible: Entry[],
-  weightOf: (entry: Entry) => number,
-  deterministicBest: Entry,
-  random: SelectionRandom,
-): Entry => {
-  if (eligible.length <= 1) {
-    return deterministicBest;
-  }
-  const weights = eligible.map((entry) => Math.max(weightOf(entry), 0));
-  const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
-  const uniform = weights.every((weight) => weight === weights[0]);
-  if (uniform || totalWeight <= 0) {
-    return deterministicBest;
-  }
-  let threshold = random() * totalWeight;
-  for (let index = 0; index < eligible.length; index += 1) {
-    threshold -= weights[index];
-    if (threshold < 0) {
-      return eligible[index];
-    }
-  }
-  return eligible[eligible.length - 1];
-};
-
-export class OauthTokenSelectUseCase {
-  run = (
-    candidates: OauthTokenCandidate[],
-    nowEpochSeconds: number,
-    random: SelectionRandom = Math.random,
-    thresholds: OauthTokenSelectionThresholds = DEFAULT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
-  ): OauthTokenSelectResult => {
-    const evaluated = candidates.map((candidate) => {
-      const evaluatedMetric = this.evaluate(
-        candidate,
-        nowEpochSeconds,
-        thresholds,
-      );
-      return {
-        candidate,
-        metric: {
-          ...evaluatedMetric,
-          drawWeight: evaluatedMetric.eligible
-            ? selectionWeightOf(candidate) *
-              sevenDayUrgencyFactor(
-                evaluatedMetric.sevenDayFreeRatio,
-                evaluatedMetric.sevenDayEndEpoch,
-                nowEpochSeconds,
-              )
-            : 0,
-        },
-      };
-    });
-
-    const eligible = evaluated.filter((entry) => entry.metric.eligible);
-    const metrics = evaluated.map((entry) => entry.metric);
-
-    if (eligible.length === 0) {
-      return { selected: null, metrics };
-    }
-
-    const deterministicBest = eligible.reduce((bestEntry, currentEntry) =>
-      currentEntry.metric.sevenDayEndEpoch < bestEntry.metric.sevenDayEndEpoch
-        ? currentEntry
-        : bestEntry,
-    );
-
-    const selected = selectWeightedCandidate(
-      eligible,
-      (entry) => entry.metric.drawWeight,
-      deterministicBest,
-      random,
-    );
-
-    return { selected: selected.candidate, metrics };
-  };
-
-  private evaluate = (
-    candidate: OauthTokenCandidate,
-    nowEpochSeconds: number,
-    thresholds: OauthTokenSelectionThresholds,
-  ): Omit<OauthTokenCandidateMetrics, 'drawWeight'> => {
-    const fiveHourFreeRatio = this.fiveHourFreeRatio(
-      candidate.snapshot,
-      nowEpochSeconds,
-    );
-    const sevenDayFreeRatio = this.sevenDayFreeRatio(
-      candidate.snapshot,
-      nowEpochSeconds,
-    );
-    const sevenDayEndEpoch = this.sevenDayEndEpoch(
-      candidate.snapshot,
-      nowEpochSeconds,
-    );
-
-    const exclusionReason = this.exclusionReason(
-      candidate.subscriptionDisabled,
-      candidate.unifiedRejected,
-      candidate.fableRejected,
-      fiveHourFreeRatio,
-      sevenDayFreeRatio,
-      thresholds,
-    );
-
-    return {
-      name: candidate.name,
-      fiveHourFreeRatio,
-      sevenDayFreeRatio,
-      sevenDayEndEpoch,
-      eligible: exclusionReason === null,
-      exclusionReason,
-    };
-  };
-
-  private exclusionReason = (
-    subscriptionDisabled: boolean,
-    unifiedRejected: boolean,
-    fableRejected: boolean,
-    fiveHourFreeRatio: number,
-    sevenDayFreeRatio: number,
-    thresholds: OauthTokenSelectionThresholds,
-  ): string | null => {
-    if (subscriptionDisabled) {
-      return 'organization has disabled Claude subscription access for Claude Code';
-    }
-    if (unifiedRejected) {
-      return 'token request was rejected (anthropic-ratelimit-unified-status: rejected)';
-    }
-    if (fableRejected) {
-      return 'fable weekly limit exhausted (a fable request was rejected with HTTP 429)';
-    }
-    if (fiveHourFreeRatio < thresholds.fiveHourMinFreeRatio) {
-      return `5h window only ${this.toPercent(fiveHourFreeRatio)}% free (requires >= ${this.toPercent(thresholds.fiveHourMinFreeRatio)}%)`;
-    }
-    if (sevenDayFreeRatio < thresholds.sevenDayMinFreeRatio) {
-      return `7d window only ${this.toPercent(sevenDayFreeRatio)}% free (requires >= ${this.toPercent(thresholds.sevenDayMinFreeRatio)}%)`;
-    }
-    return null;
-  };
-
-  private fiveHourFreeRatio = (
-    snapshot: OauthTokenWindowSnapshot | null,
-    nowEpochSeconds: number,
-  ): number => {
-    if (snapshot === null) {
-      return 1;
-    }
-    if (this.windowExpired(snapshot.fiveHourReset, nowEpochSeconds)) {
-      return 1;
-    }
-    return this.freeRatioFromUtilization(snapshot.fiveHourUtilization);
-  };
-
-  private sevenDayFreeRatio = (
-    snapshot: OauthTokenWindowSnapshot | null,
-    nowEpochSeconds: number,
-  ): number => {
-    if (snapshot === null) {
-      return 1;
-    }
-    if (this.windowExpired(snapshot.sevenDayReset, nowEpochSeconds)) {
-      return 1;
-    }
-    return this.freeRatioFromUtilization(snapshot.sevenDayUtilization);
-  };
-
-  private sevenDayEndEpoch = (
-    snapshot: OauthTokenWindowSnapshot | null,
-    nowEpochSeconds: number,
-  ): number => {
-    if (snapshot === null) {
-      return nowEpochSeconds + SEVEN_DAYS_IN_SECONDS;
-    }
-    if (snapshot.sevenDayReset <= 0) {
-      return nowEpochSeconds + SEVEN_DAYS_IN_SECONDS;
-    }
-    if (this.windowExpired(snapshot.sevenDayReset, nowEpochSeconds)) {
-      return nowEpochSeconds + SEVEN_DAYS_IN_SECONDS;
-    }
-    return snapshot.sevenDayReset;
-  };
-
-  private windowExpired = (
-    resetEpoch: number,
-    nowEpochSeconds: number,
-  ): boolean => resetEpoch > 0 && nowEpochSeconds > resetEpoch;
-
-  private freeRatioFromUtilization = (utilization: number): number => {
-    const bounded = Math.min(Math.max(utilization, 0), 1);
-    return 1 - bounded;
-  };
-
-  private toPercent = (ratio: number): number => Math.round(ratio * 100);
-}

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

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

package/src/domain/usecases/OutputDegenerationDetector.ts

@@ -1,169 +0,0 @@
-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;
-  };
-}