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

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

@@ -1,126 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { Issue } from '../../../domain/entities/Issue';
-import {
-  AWAITING_QUALITY_CHECK_STATUS_NAME,
-  IN_TMUX_STATUS_NAME,
-} from '../../../domain/entities/WorkflowStatus';
-import {
-  ClaudeInteractiveSession,
-  ClaudeInteractiveSessionRepository,
-} from '../../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
-import { InTmuxByHumanSessionTokenCountUseCase } from '../../../domain/usecases/InTmuxByHumanSessionTokenCountUseCase';
-import { InTmuxByHumanSessionTokenCountHandler } from './InTmuxByHumanSessionTokenCountHandler';
-
-class FakeClaudeInteractiveSessionRepository implements ClaudeInteractiveSessionRepository {
-  constructor(private readonly sessions: ClaudeInteractiveSession[]) {}
-  listInteractiveSessions = (): ClaudeInteractiveSession[] => this.sessions;
-}
-
-const issueUrlA = 'https://github.com/HiromiShikata/example/issues/1';
-const issueUrlB = 'https://github.com/HiromiShikata/example/issues/2';
-
-const issue = (url: string, status: string): Issue => ({
-  nameWithOwner: 'HiromiShikata/example',
-  number: 1,
-  title: 'Example issue',
-  state: 'OPEN',
-  status,
-  story: null,
-  nextActionDate: null,
-  nextActionHour: null,
-  estimationMinutes: null,
-  dependedIssueUrls: [],
-  completionDate50PercentConfidence: null,
-  url,
-  assignees: ['hiromi'],
-  labels: [],
-  org: 'HiromiShikata',
-  repo: 'example',
-  body: '',
-  itemId: 'item-1',
-  isPr: false,
-  isInProgress: false,
-  isClosed: false,
-  createdAt: new Date('2026-01-01T00:00:00Z'),
-  author: 'hiromi',
-  closingIssueReferenceUrls: [],
-  agent: null,
-  stateReason: null,
-});
-
-describe('InTmuxByHumanSessionTokenCountHandler', () => {
-  let tokenListPath: string;
-
-  beforeEach(() => {
-    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'token-list-'));
-    tokenListPath = path.join(directory, 'tokens.json');
-    fs.writeFileSync(
-      tokenListPath,
-      JSON.stringify([
-        { name: 'alpha', token: 'token-alpha' },
-        { name: 'beta', token: 'token-beta' },
-      ]),
-    );
-  });
-
-  afterEach(() => {
-    fs.rmSync(path.dirname(tokenListPath), { recursive: true, force: true });
-  });
-
-  it('writes one tab-separated line per token with In-Tmux-by-human counts', () => {
-    const handler = new InTmuxByHumanSessionTokenCountHandler(
-      new InTmuxByHumanSessionTokenCountUseCase(),
-      new FakeClaudeInteractiveSessionRepository([
-        { token: 'token-alpha', sessionId: 'session-a', issueUrl: issueUrlA },
-        { token: 'token-alpha', sessionId: 'session-a', issueUrl: issueUrlA },
-        { token: 'token-beta', sessionId: 'session-b', issueUrl: issueUrlB },
-      ]),
-    );
-
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      issues: [
-        issue(issueUrlA, IN_TMUX_STATUS_NAME),
-        issue(issueUrlB, AWAITING_QUALITY_CHECK_STATUS_NAME),
-      ],
-    });
-
-    expect(output.lines).toEqual(['alpha\t1', 'beta\t0']);
-  });
-
-  it('reports a diagnostic when no token list path is available', () => {
-    const handler = new InTmuxByHumanSessionTokenCountHandler(
-      new InTmuxByHumanSessionTokenCountUseCase(),
-      new FakeClaudeInteractiveSessionRepository([]),
-    );
-    const previous = process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
-    delete process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
-
-    const output = handler.handle({ tokenListJsonPath: null, issues: [] });
-
-    expect(output.lines).toEqual([]);
-    expect(output.diagnostics[0]).toContain('No token list path provided');
-
-    if (previous !== undefined) {
-      process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH = previous;
-    }
-  });
-
-  it('reports a diagnostic when the token list file has no usable entries', () => {
-    fs.writeFileSync(tokenListPath, JSON.stringify([]));
-    const handler = new InTmuxByHumanSessionTokenCountHandler(
-      new InTmuxByHumanSessionTokenCountUseCase(),
-      new FakeClaudeInteractiveSessionRepository([]),
-    );
-
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      issues: [],
-    });
-
-    expect(output.lines).toEqual([]);
-    expect(output.diagnostics[0]).toContain('No usable token entries');
-  });
-});

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

@@ -1,80 +0,0 @@
-import { Issue } from '../../../domain/entities/Issue';
-import { ClaudeInteractiveSessionRepository } from '../../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
-import { InTmuxByHumanSessionTokenCountUseCase } from '../../../domain/usecases/InTmuxByHumanSessionTokenCountUseCase';
-import { OauthTokenCandidate } from '../../../domain/usecases/OauthTokenSelectUseCase';
-import { ProcClaudeInteractiveSessionRepository } from '../../repositories/ProcClaudeInteractiveSessionRepository';
-import { loadTokenEntries } from '../../proxy/TokenListLoader';
-import { resolveTokenListJsonPath } from './OauthTokenSelectHandler';
-
-export type InTmuxByHumanSessionTokenCountHandlerInput = {
-  tokenListJsonPath: string | null;
-  issues: Issue[];
-};
-
-export type InTmuxByHumanSessionTokenCountHandlerOutput = {
-  lines: string[];
-  diagnostics: string[];
-};
-
-export class InTmuxByHumanSessionTokenCountHandler {
-  constructor(
-    private readonly useCase: InTmuxByHumanSessionTokenCountUseCase = new InTmuxByHumanSessionTokenCountUseCase(),
-    private readonly interactiveSessionRepository: ClaudeInteractiveSessionRepository = new ProcClaudeInteractiveSessionRepository(),
-  ) {}
-
-  handle = (
-    input: InTmuxByHumanSessionTokenCountHandlerInput,
-  ): InTmuxByHumanSessionTokenCountHandlerOutput => {
-    const tokenListJsonPath = resolveTokenListJsonPath(input.tokenListJsonPath);
-    if (tokenListJsonPath === null) {
-      return {
-        lines: [],
-        diagnostics: [
-          'No token list path provided. Pass --tokenListJsonPath or set CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH.',
-        ],
-      };
-    }
-
-    const entries = loadTokenEntries(tokenListJsonPath);
-    if (entries === null) {
-      return {
-        lines: [],
-        diagnostics: [
-          `No usable token entries loaded from ${tokenListJsonPath}.`,
-        ],
-      };
-    }
-
-    const candidates: OauthTokenCandidate[] = entries.map(
-      ({ name, token }) => ({
-        name,
-        token,
-        snapshot: null,
-        subscriptionDisabled: false,
-        unifiedRejected: false,
-        fableRejected: false,
-      }),
-    );
-
-    const interactiveSessions =
-      this.interactiveSessionRepository.listInteractiveSessions();
-
-    const result = this.useCase.run(
-      candidates,
-      interactiveSessions,
-      input.issues,
-    );
-
-    const lines = result.counts.map((count) => `${count.name}\t${count.count}`);
-
-    const totalSessions = result.counts.reduce(
-      (sum, count) => sum + count.count,
-      0,
-    );
-    const diagnostics = [
-      `Counted ${totalSessions} live In-Tmux-by-human session(s) across ${result.counts.length} token(s).`,
-    ];
-
-    return { lines, diagnostics };
-  };
-}

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

@@ -1,491 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import {
-  ClaudeLiveSession,
-  ClaudeLiveSessionRepository,
-} from '../../../domain/usecases/adapter-interfaces/ClaudeLiveSessionRepository';
-import {
-  DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-  LiveSessionOauthTokenSelectUseCase,
-} from '../../../domain/usecases/LiveSessionOauthTokenSelectUseCase';
-import { FABLE_LIMIT_TYPE, hashToken } from '../../proxy/RateLimitCache';
-import { LiveSessionOauthTokenSelectHandler } from './LiveSessionOauthTokenSelectHandler';
-
-const NOW = 2_000_000;
-const HOUR = 3600;
-const DAY = 86400;
-
-type FakeHeaders = {
-  fiveHourUtilization: number;
-  fiveHourReset: number;
-  sevenDayUtilization: number;
-  sevenDayReset: number;
-};
-
-class FakeClaudeLiveSessionRepository implements ClaudeLiveSessionRepository {
-  constructor(private readonly sessions: ClaudeLiveSession[]) {}
-
-  listLiveSessions = (): ClaudeLiveSession[] => this.sessions;
-}
-
-describe('LiveSessionOauthTokenSelectHandler', () => {
-  let tempDir: string;
-  let cacheDirectory: string;
-  let tokenListPath: string;
-  const originalTokenListEnv =
-    process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
-  const originalCacheEnv = process.env.TDPM_RATELIMIT_CACHE_DIR;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'select-live-token-'));
-    cacheDirectory = path.join(tempDir, 'cache');
-    fs.mkdirSync(cacheDirectory, { recursive: true });
-    tokenListPath = path.join(tempDir, 'tokens.json');
-    delete process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
-    delete process.env.TDPM_RATELIMIT_CACHE_DIR;
-  });
-
-  afterEach(() => {
-    if (originalTokenListEnv === undefined) {
-      delete process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
-    } else {
-      process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH = originalTokenListEnv;
-    }
-    if (originalCacheEnv === undefined) {
-      delete process.env.TDPM_RATELIMIT_CACHE_DIR;
-    } else {
-      process.env.TDPM_RATELIMIT_CACHE_DIR = originalCacheEnv;
-    }
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  const writeTokenList = (entries: { name: string; token: string }[]): void => {
-    fs.writeFileSync(tokenListPath, JSON.stringify(entries));
-  };
-
-  const writeCache = (token: string, headers: FakeHeaders): void => {
-    const payload = {
-      ts: NOW,
-      headers: {
-        'anthropic-ratelimit-unified-status': 'allowed',
-        'anthropic-ratelimit-unified-5h-status': 'allowed',
-        'anthropic-ratelimit-unified-5h-reset': String(headers.fiveHourReset),
-        'anthropic-ratelimit-unified-5h-utilization': String(
-          headers.fiveHourUtilization,
-        ),
-        'anthropic-ratelimit-unified-7d-status': 'allowed',
-        'anthropic-ratelimit-unified-7d-reset': String(headers.sevenDayReset),
-        'anthropic-ratelimit-unified-7d-utilization': String(
-          headers.sevenDayUtilization,
-        ),
-      },
-      modelWeeklyLimits: {},
-    };
-    fs.writeFileSync(
-      path.join(cacheDirectory, `${hashToken(token)}.json`),
-      JSON.stringify(payload),
-    );
-  };
-
-  const writeSubscriptionDisabledCache = (
-    token: string,
-    epochSeconds: number = Date.now() / 1000,
-  ): void => {
-    const payload = { subscriptionDisabledEpoch: epochSeconds };
-    fs.writeFileSync(
-      path.join(cacheDirectory, `${hashToken(token)}.json`),
-      JSON.stringify(payload),
-    );
-  };
-
-  const writeCacheWithHeaders = (
-    token: string,
-    headers: Record<string, string>,
-  ): void => {
-    const payload = { ts: NOW, headers, modelWeeklyLimits: {} };
-    fs.writeFileSync(
-      path.join(cacheDirectory, `${hashToken(token)}.json`),
-      JSON.stringify(payload),
-    );
-  };
-
-  const buildHandler = (
-    sessions: ClaudeLiveSession[],
-  ): LiveSessionOauthTokenSelectHandler =>
-    new LiveSessionOauthTokenSelectHandler(
-      new LiveSessionOauthTokenSelectUseCase(),
-      new FakeClaudeLiveSessionRepository(sessions),
-    );
-
-  const writeFableRejectionCache = (token: string, resetsAt: number): void => {
-    const payload = {
-      ts: NOW,
-      headers: {
-        'anthropic-ratelimit-unified-status': 'allowed',
-        'anthropic-ratelimit-unified-5h-status': 'allowed',
-        'anthropic-ratelimit-unified-5h-reset': String(NOW + HOUR),
-        'anthropic-ratelimit-unified-5h-utilization': '0.1',
-        'anthropic-ratelimit-unified-7d-status': 'allowed',
-        'anthropic-ratelimit-unified-7d-reset': String(NOW + DAY),
-        'anthropic-ratelimit-unified-7d-utilization': '0.1',
-      },
-      modelWeeklyLimits: {
-        [FABLE_LIMIT_TYPE]: { rejected: true, resetsAt },
-      },
-    };
-    fs.writeFileSync(
-      path.join(cacheDirectory, `${hashToken(token)}.json`),
-      JSON.stringify(payload),
-    );
-  };
-
-  it('excludes a token whose fable marker is set even when it is unoccupied', () => {
-    writeTokenList([
-      { name: 'fable-out', token: 'fake-fable-out' },
-      { name: 'active', token: 'fake-active' },
-    ]);
-    writeFableRejectionCache('fake-fable-out', NOW + HOUR);
-    writeCache('fake-active', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + DAY,
-    });
-
-    const handler = buildHandler([]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedName).toBe('active');
-    expect(output.diagnostics.join('\n')).toContain(
-      'fable weekly limit exhausted',
-    );
-  });
-
-  it('selects the soonest resetting eligible token even when it already carries a live session', () => {
-    writeTokenList([
-      { name: 'busy', token: 'fake-busy' },
-      { name: 'idle', token: 'fake-idle' },
-    ]);
-    writeCache('fake-busy', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + 2 * DAY,
-    });
-    writeCache('fake-idle', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + 6 * DAY,
-    });
-
-    const handler = buildHandler([
-      { token: 'fake-busy', sessionKey: 'session-a' },
-    ]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedName).toBe('busy');
-    expect(output.selectedToken).toBe('fake-busy');
-    expect(output.diagnostics.join('\n')).toContain(
-      'busy: 1/10 live session(s)',
-    );
-  });
-
-  it('breaks an occupancy tie by the soonest 7d reset', () => {
-    writeTokenList([
-      { name: 'far', token: 'fake-far' },
-      { name: 'soon', token: 'fake-soon' },
-    ]);
-    writeCache('fake-far', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + 6 * DAY,
-    });
-    writeCache('fake-soon', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + 2 * DAY,
-    });
-
-    const handler = buildHandler([
-      { token: 'fake-far', sessionKey: 'session-a' },
-      { token: 'fake-soon', sessionKey: 'session-b' },
-    ]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedName).toBe('soon');
-  });
-
-  it('dedupes child processes that share a session id when counting occupancy', () => {
-    writeTokenList([
-      { name: 'oneSession', token: 'fake-one' },
-      { name: 'twoSessions', token: 'fake-two' },
-    ]);
-    writeCache('fake-one', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + 2 * DAY,
-    });
-    writeCache('fake-two', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + 6 * DAY,
-    });
-
-    const handler = buildHandler([
-      { token: 'fake-one', sessionKey: 'session-a' },
-      { token: 'fake-one', sessionKey: 'session-a' },
-      { token: 'fake-two', sessionKey: 'session-b' },
-      { token: 'fake-two', sessionKey: 'session-c' },
-    ]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedName).toBe('oneSession');
-  });
-
-  it('excludes a rate-limit-ineligible token even when it is unoccupied', () => {
-    writeTokenList([
-      { name: 'blocked', token: 'fake-blocked' },
-      { name: 'free', token: 'fake-free' },
-    ]);
-    writeCache('fake-blocked', {
-      fiveHourUtilization: 0.9,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + DAY,
-    });
-    writeCache('fake-free', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + DAY,
-    });
-
-    const handler = buildHandler([
-      { token: 'fake-free', sessionKey: 'session-a' },
-    ]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedName).toBe('free');
-  });
-
-  it('returns no token and a threshold-naming diagnostic without leaking the token when no token passes the filter', () => {
-    writeTokenList([{ name: 'busy', token: 'fake-busy' }]);
-    writeCache('fake-busy', {
-      fiveHourUtilization: 0.9,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + DAY,
-    });
-
-    const handler = buildHandler([]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedToken).toBeNull();
-    expect(output.selectedName).toBeNull();
-    const diagnostics = output.diagnostics.join('\n');
-    expect(diagnostics).toContain('No eligible token');
-    expect(diagnostics).toContain('5h >= 25% free');
-    expect(diagnostics).toContain('7d >= 1% free');
-    expect(diagnostics).not.toContain('fake-busy');
-  });
-
-  it('returns the token on the selected path when an eligible token exists', () => {
-    writeTokenList([{ name: 'free', token: 'fake-free' }]);
-    writeCache('fake-free', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + DAY,
-    });
-
-    const handler = buildHandler([]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedToken).toBe('fake-free');
-    expect(output.selectedName).toBe('free');
-    expect(output.diagnostics.join('\n')).not.toContain('No eligible token');
-  });
-
-  it('includes the selection weight in the diagnostic line for each candidate', () => {
-    writeTokenList([{ name: 'foo', token: 'fake-foo' }]);
-    writeCache('fake-foo', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + DAY,
-    });
-
-    const handler = buildHandler([]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    const diagnostics = output.diagnostics.join('\n');
-    expect(diagnostics).toMatch(/foo:.*, weight 1 ->/);
-  });
-
-  it('returns a diagnostic when no token list path is resolvable', () => {
-    const handler = buildHandler([]);
-    const output = handler.handle({
-      tokenListJsonPath: null,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedToken).toBeNull();
-    expect(output.diagnostics.join('\n')).toContain('No token list path');
-  });
-
-  it('returns a diagnostic when the token list file has no usable entries', () => {
-    fs.writeFileSync(tokenListPath, JSON.stringify([]));
-
-    const handler = buildHandler([]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedToken).toBeNull();
-    expect(output.diagnostics.join('\n')).toContain('No usable token entries');
-  });
-
-  it('excludes a subscription-disabled token even when it has zero live sessions', () => {
-    writeTokenList([
-      { name: 'disabled', token: 'fake-disabled' },
-      { name: 'active', token: 'fake-active' },
-    ]);
-    writeSubscriptionDisabledCache('fake-disabled');
-    writeCache('fake-active', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + DAY,
-    });
-
-    const handler = buildHandler([
-      { token: 'fake-active', sessionKey: 'session-a' },
-    ]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedName).toBe('active');
-    expect(output.diagnostics.join('\n')).toContain(
-      'organization has disabled Claude subscription access for Claude Code',
-    );
-  });
-
-  it('excludes a unified-rejected token even when it has zero live sessions', () => {
-    writeTokenList([
-      { name: 'rejected', token: 'fake-rejected' },
-      { name: 'active', token: 'fake-active' },
-    ]);
-    writeCacheWithHeaders('fake-rejected', {
-      'anthropic-ratelimit-unified-status': 'rejected',
-      'anthropic-ratelimit-unified-5h-status': 'allowed',
-      'anthropic-ratelimit-unified-5h-reset': String(NOW + HOUR),
-      'anthropic-ratelimit-unified-5h-utilization': '0.1',
-      'anthropic-ratelimit-unified-7d-status': 'allowed',
-      'anthropic-ratelimit-unified-7d-reset': String(NOW + DAY),
-      'anthropic-ratelimit-unified-7d-utilization': '0.1',
-    });
-    writeCache('fake-active', {
-      fiveHourUtilization: 0.1,
-      fiveHourReset: NOW + HOUR,
-      sevenDayUtilization: 0.1,
-      sevenDayReset: NOW + DAY,
-    });
-
-    const handler = buildHandler([
-      { token: 'fake-active', sessionKey: 'session-a' },
-    ]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedName).toBe('active');
-    expect(output.diagnostics.join('\n')).toContain('rejected');
-  });
-
-  it('returns null and a no-eligible-token diagnostic when every token is unusable', () => {
-    writeTokenList([
-      { name: 'disabled', token: 'fake-disabled' },
-      { name: 'rejected', token: 'fake-rejected' },
-    ]);
-    writeSubscriptionDisabledCache('fake-disabled');
-    writeCacheWithHeaders('fake-rejected', {
-      'anthropic-ratelimit-unified-status': 'rejected',
-      'anthropic-ratelimit-unified-5h-status': 'allowed',
-      'anthropic-ratelimit-unified-5h-reset': String(NOW + HOUR),
-      'anthropic-ratelimit-unified-5h-utilization': '0.1',
-      'anthropic-ratelimit-unified-7d-status': 'allowed',
-      'anthropic-ratelimit-unified-7d-reset': String(NOW + DAY),
-      'anthropic-ratelimit-unified-7d-utilization': '0.1',
-    });
-
-    const handler = buildHandler([]);
-    const output = handler.handle({
-      tokenListJsonPath: tokenListPath,
-      cacheDirectory,
-      nowEpochSeconds: NOW,
-      selectionSettings: DEFAULT_LIVE_SESSION_OAUTH_TOKEN_SELECTION_SETTINGS,
-    });
-
-    expect(output.selectedToken).toBeNull();
-    expect(output.selectedName).toBeNull();
-    expect(output.diagnostics.join('\n')).toContain('No eligible token');
-  });
-});