refactor: remove unwired auto-paired-mode and usage exhaustion gate

src/auto-paired-mode.ts had no production importer. Remove it together
with the helpers only it used: getClaudeUsageExhaustion /
isClaudeUsageExhausted in claude-usage.ts and getCodexUsageExhaustion /
isCodexUsageExhausted in codex-usage-collector.ts, plus their tests.

auto-paired-mode-state.json stays in the data-state allowlist: the live
data dir still has that file and an unknown state file is a startup
precondition failure.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Codex
2026-10-01 18:50:40 +09:00
parent 60ff19177a
commit 02ea212be0
6 changed files with 3 additions and 688 deletions

View File

@@ -13,6 +13,7 @@
- 웹 대시보드(`src/web-dashboard-*`, `apps/dashboard`), Android 앱(`apps/android`), Glasses UI와 이를 위해서만 있던 설정 저장소(`settings-store`, `settings-store-moa`, `room-skill-settings`, `runtime-inventory`, `codex-live-status`, `settings-effort`), `WEB_DASHBOARD_*` 설정, `dashboard:*`/`android:*` 스크립트, react·vite·playwright 의존성. 잘못된 계정(`~/.codex`)을 갱신하던 Codex 계정 새로고침 루프도 함께 제거. 호스트 증거 도구의 `dashboard_dist`/`android_debug_apk` 항목 제거. Discord 상태 대시보드는 그대로 유지
- Mixture of Agents(MoA) arbiter 프롬프트 보강, Kimi 사용량 조회/대시보드 행, `MOA_*` 설정, 코드에서 읽지 않던 `FALLBACK_*` provider 설정 예시
- 런타임에 연결되지 않았던 auto-paired-mode(`src/auto-paired-mode.ts`)와 그것만 쓰던 Claude/Codex 사용량 소진 판정 함수
### Fixed

View File

@@ -1,179 +0,0 @@
/**
* Auto paired-mode degrade/restore.
*
* When all configured Claude accounts are at/over the 95% exhaustion threshold,
* paired (tribunal) rooms cannot meaningfully run their reviewer/arbiter
* because the gate blocks Claude turns. To keep the user-facing rooms
* responsive, we temporarily flip selected rooms to `single` mode and notify
* each affected channel. When usage recovers we flip them back to `tribunal`.
*
* Selection (Option B agreed with the user):
* - The most-recently-active room (per chats.last_message_time)
* - All rooms that are currently in-flight (queue status === 'processing')
* - Deduplicated; rooms whose owner is `claude-code` are skipped because
* degrading them does not help — the 95% gate blocks them either way.
*
* Restore behavior:
* - Only restore a room if it is still in 'single' (don't override a manual
* user change made during the degrade window).
*/
import fs from 'fs';
import path from 'path';
import { getClaudeUsageExhaustion } from './claude-usage.js';
import { DATA_DIR } from './config.js';
import {
getAllChats,
getAllRoomBindings,
getEffectiveRoomMode,
getStoredRoomSettings,
setExplicitRoomMode,
} from './db.js';
import { logger } from './logger.js';
import { readJsonFile, writeJsonFile } from './utils.js';
const STATE_PATH = path.join(DATA_DIR, 'auto-paired-mode-state.json');
const DEGRADE_NOTICE =
'클로드 사용량이 95%를 넘어 잠시 single 모드로 전환했어요. 사용량이 회복되면 paired 모드로 다시 켤게요.';
const RESTORE_NOTICE = '클로드 사용량이 회복돼서 paired 모드로 다시 켰어요.';
interface DowngradeRecord {
chatJid: string;
atIso: string;
}
interface AutoPairedModeState {
exhausted: boolean;
downgraded: DowngradeRecord[];
}
export interface AutoPairedModeDeps {
queue?: {
getStatuses(jids: string[]): Array<{ jid: string; status: string }>;
};
sendNotice: (chatJid: string, text: string) => Promise<void>;
}
function loadState(): AutoPairedModeState {
const raw = readJsonFile<AutoPairedModeState>(STATE_PATH);
if (!raw || typeof raw !== 'object') {
return { exhausted: false, downgraded: [] };
}
return {
exhausted: Boolean(raw.exhausted),
downgraded: Array.isArray(raw.downgraded) ? raw.downgraded : [],
};
}
function saveState(state: AutoPairedModeState): void {
try {
fs.mkdirSync(path.dirname(STATE_PATH), { recursive: true });
writeJsonFile(STATE_PATH, state);
} catch (err) {
logger.warn({ err }, 'auto-paired-mode: failed to persist state');
}
}
function pickCandidates(deps: AutoPairedModeDeps): string[] {
const bindings = getAllRoomBindings();
const allJids = Object.keys(bindings);
if (allJids.length === 0) return [];
const candidates = new Set<string>();
// Most-recently-active room first (chats ordered DESC by last_message_time).
const chats = getAllChats();
const recent = chats.find((c) => allJids.includes(c.jid));
if (recent) candidates.add(recent.jid);
// Currently in-flight rooms.
if (deps.queue) {
for (const status of deps.queue.getStatuses(allJids)) {
if (status.status === 'processing') candidates.add(status.jid);
}
}
// Skip claude-owned rooms (Option B).
const result: string[] = [];
for (const jid of candidates) {
const settings = getStoredRoomSettings(jid);
if (settings?.ownerAgentType === 'claude-code') continue;
if (getEffectiveRoomMode(jid) !== 'tribunal') continue;
result.push(jid);
}
return result;
}
export async function evaluateAndApplyAutoPairedMode(
deps: AutoPairedModeDeps,
): Promise<void> {
const exhaustion = getClaudeUsageExhaustion();
const state = loadState();
if (exhaustion.exhausted && !state.exhausted) {
// Transition: healthy → exhausted. Downgrade selected rooms.
const targets = pickCandidates(deps);
const downgraded: DowngradeRecord[] = [];
for (const jid of targets) {
try {
setExplicitRoomMode(jid, 'single');
downgraded.push({ chatJid: jid, atIso: new Date().toISOString() });
logger.info(
{ jid },
'auto-paired-mode: downgraded room to single (claude exhausted)',
);
try {
await deps.sendNotice(jid, DEGRADE_NOTICE);
} catch (err) {
logger.warn(
{ err, jid },
'auto-paired-mode: failed to send degrade notice',
);
}
} catch (err) {
logger.warn({ err, jid }, 'auto-paired-mode: failed to downgrade room');
}
}
saveState({ exhausted: true, downgraded });
return;
}
if (!exhaustion.exhausted && state.exhausted) {
// Transition: exhausted → healthy. Restore previously-downgraded rooms.
for (const record of state.downgraded) {
try {
if (getEffectiveRoomMode(record.chatJid) !== 'single') {
// Respect manual user changes during the degrade window.
logger.info(
{ jid: record.chatJid },
'auto-paired-mode: skip restore (room is no longer single)',
);
continue;
}
setExplicitRoomMode(record.chatJid, 'tribunal');
logger.info(
{ jid: record.chatJid },
'auto-paired-mode: restored room to tribunal',
);
try {
await deps.sendNotice(record.chatJid, RESTORE_NOTICE);
} catch (err) {
logger.warn(
{ err, jid: record.chatJid },
'auto-paired-mode: failed to send restore notice',
);
}
} catch (err) {
logger.warn(
{ err, jid: record.chatJid },
'auto-paired-mode: failed to restore room',
);
}
}
saveState({ exhausted: false, downgraded: [] });
return;
}
// Steady state — nothing to do.
}

View File

@@ -637,103 +637,3 @@ export async function fetchAllClaudeUsage(): Promise<ClaudeAccountUsage[]> {
// Legacy alias
export const fetchClaudeUsageViaCli = fetchClaudeUsage;
// ── Exhaustion gate ───────────────────────────────────────────────────────
//
// Threshold above which a Claude account is considered "out of budget" for
// the purpose of admitting new turns. A turn is blocked only when *every*
// Claude account is either at/over this threshold on either window or
// already in a rate-limit cooldown.
export const CLAUDE_EXHAUSTION_THRESHOLD_PCT = 95;
export interface UsageExhaustionInfo {
exhausted: boolean;
/** ISO timestamp of the soonest reset that would relieve exhaustion. */
nextResetAt: string | null;
}
/** Normalise the API's utilization field (which can be fractional or percent). */
function normaliseUtilization(u: number | undefined): number {
if (u == null || !Number.isFinite(u)) return 0;
return u >= 0 && u < 1 ? u * 100 : u;
}
function parseResetMs(s: string | undefined | null): number | null {
if (!s) return null;
const t = Date.parse(s);
return Number.isFinite(t) ? t : null;
}
/**
* Reports whether every configured Claude account is either ≥ 95% on a
* window or in a rate-limit cooldown, and — when so — the soonest moment at
* which any one account is expected to recover.
*
* Reads the on-disk usage cache (refreshed every minute by the dashboard
* renderer); performs no network I/O. Returns `exhausted: false` when there
* are no configured tokens, or when usage data is missing for any account
* (err on letting work through).
*/
export function getClaudeUsageExhaustion(): UsageExhaustionInfo {
loadUsageDiskCache();
const allTokens = getAllTokens();
if (allTokens.length === 0) return { exhausted: false, nextResetAt: null };
let earliestRecoveryMs = Infinity;
for (const t of allTokens) {
if (t.isRateLimited) {
// Rate-limit recovery time is not exposed on the token snapshot here;
// we treat it as "unknown but eventually". Skip from the min calc.
continue;
}
const credsToken = readCredentialsAccessToken(t.index);
const readKeys = getUsageCacheReadKeys(t.token, t.index, credsToken);
let entry: UsageCacheEntry | undefined;
for (const key of readKeys) {
if (usageDiskCache[key]) {
entry = usageDiskCache[key];
break;
}
}
if (!entry) return { exhausted: false, nextResetAt: null };
const h5 = normaliseUtilization(entry.usage.five_hour?.utilization);
const d7 = normaliseUtilization(entry.usage.seven_day?.utilization);
if (Math.max(h5, d7) < CLAUDE_EXHAUSTION_THRESHOLD_PCT) {
return { exhausted: false, nextResetAt: null };
}
// This account is exhausted. It becomes available again when whichever
// window(s) are over the threshold drop back below it. We approximate
// that as max(reset of each window currently ≥ threshold).
const h5ResetMs =
h5 >= CLAUDE_EXHAUSTION_THRESHOLD_PCT
? parseResetMs(entry.usage.five_hour?.resets_at)
: null;
const d7ResetMs =
d7 >= CLAUDE_EXHAUSTION_THRESHOLD_PCT
? parseResetMs(entry.usage.seven_day?.resets_at)
: null;
const candidates = [h5ResetMs, d7ResetMs].filter(
(v): v is number => v != null,
);
if (candidates.length > 0) {
const accountRecovery = Math.max(...candidates);
if (accountRecovery < earliestRecoveryMs) {
earliestRecoveryMs = accountRecovery;
}
}
}
const nextResetAt = Number.isFinite(earliestRecoveryMs)
? new Date(earliestRecoveryMs).toISOString()
: null;
return { exhausted: true, nextResetAt };
}
/** Backwards-compat boolean wrapper. */
export function isClaudeUsageExhausted(): boolean {
return getClaudeUsageExhaustion().exhausted;
}

View File

@@ -40,26 +40,6 @@ export interface CodexUsageRefreshResult {
/** Full scan interval — exported so the orchestrator can schedule it. */
export const CODEX_FULL_SCAN_INTERVAL = 3_600_000; // 1 hour
/**
* Threshold above which a Codex account is considered "out of budget" for
* the purpose of admitting new turns. A turn is blocked only when *every*
* Codex account is either at/over this threshold on either window or
* already in a rate-limit cooldown.
*/
export const CODEX_EXHAUSTION_THRESHOLD_PCT = 95;
export interface UsageExhaustionInfo {
exhausted: boolean;
/** ISO timestamp of the soonest reset that would relieve exhaustion. */
nextResetAt: string | null;
}
function parseResetMs(s: string | undefined | null): number | null {
if (!s) return null;
const t = Date.parse(s);
return Number.isFinite(t) ? t : null;
}
/** Coerce a string-or-number resetsAt (numeric epoch in seconds) to ISO. */
function toIsoMaybe(value: string | number | undefined): string | undefined {
if (value == null) return undefined;
@@ -71,59 +51,6 @@ function toIsoMaybe(value: string | number | undefined): string | undefined {
return Number.isFinite(ms) ? new Date(ms).toISOString() : undefined;
}
/**
* Reports whether every configured Codex account is either ≥ 95% on a
* window or in a rate-limit cooldown, and — when so — the soonest moment
* at which any one account is expected to recover.
*
* Reads the in-process rotation snapshot; performs no I/O. Returns
* `exhausted: false` when there are no configured accounts, or when usage
* data is missing for any account (err on letting work through).
*/
export function getCodexUsageExhaustion(): UsageExhaustionInfo {
const accounts = getAllCodexAccounts();
if (accounts.length === 0) return { exhausted: false, nextResetAt: null };
let earliestRecoveryMs = Infinity;
for (const a of accounts) {
if (a.isRateLimited) continue; // counts as exhausted, recovery unknown here
const h5 = a.cachedUsagePct;
const d7 = a.cachedUsageD7Pct;
// -1 / undefined means "unknown" → treat as headroom
if (h5 == null || h5 < 0 || d7 == null || d7 < 0) {
return { exhausted: false, nextResetAt: null };
}
if (Math.max(h5, d7) < CODEX_EXHAUSTION_THRESHOLD_PCT) {
return { exhausted: false, nextResetAt: null };
}
const h5ResetMs =
h5 >= CODEX_EXHAUSTION_THRESHOLD_PCT ? parseResetMs(a.resetAt) : null;
const d7ResetMs =
d7 >= CODEX_EXHAUSTION_THRESHOLD_PCT ? parseResetMs(a.resetD7At) : null;
const candidates = [h5ResetMs, d7ResetMs].filter(
(v): v is number => v != null,
);
if (candidates.length > 0) {
const accountRecovery = Math.max(...candidates);
if (accountRecovery < earliestRecoveryMs) {
earliestRecoveryMs = accountRecovery;
}
}
}
const nextResetAt = Number.isFinite(earliestRecoveryMs)
? new Date(earliestRecoveryMs).toISOString()
: null;
return { exhausted: true, nextResetAt };
}
/** Backwards-compat boolean wrapper. */
export function isCodexUsageExhausted(): boolean {
return getCodexUsageExhaustion().exhausted;
}
function getFnmCodexBinDirs(): string[] {
const fnmRoot = path.join(os.homedir(), '.local', 'share', 'fnm');
const dirs: string[] = [];

View File

@@ -7,6 +7,8 @@ const ALLOWED_DATA_JSON_PATTERNS = [
/^codex-warmup-state\.json$/,
/^claude-usage-cache\.json$/,
/^restart-context\..+\.json$/,
// Leftover from the removed auto-paired-mode feature. Kept allowed so an
// existing file does not block startup; drop once deployments delete it.
/^auto-paired-mode-state\.json$/,
];

View File

@@ -1,336 +0,0 @@
/**
* Unit tests for the 95% usage-exhaustion helpers (Claude + Codex).
*
* These do not exercise the real disk cache or rotation state; they mock
* just enough to verify the gate's truth-table:
*
* - no accounts → false (don't block)
* - missing data on any → false (don't block)
* - rate-limited account → counts as exhausted
* - any account < 95% → false (route there instead)
* - all accounts ≥ 95% → true, with earliest expected recovery time
*/
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
vi.mock('./logger.js', () => ({
logger: {
info: vi.fn(),
warn: vi.fn(),
error: vi.fn(),
debug: vi.fn(),
},
}));
vi.mock('./config.js', () => ({
DATA_DIR: '/tmp/ejclaw-usage-exhaustion-data',
}));
const { getAllTokensMock } = vi.hoisted(() => ({
getAllTokensMock: vi.fn(),
}));
vi.mock('./token-rotation.js', () => ({
getAllTokens: getAllTokensMock,
getCurrentToken: () => null,
getConfiguredClaudeTokens: () => [],
}));
const { getAllCodexAccountsMock } = vi.hoisted(() => ({
getAllCodexAccountsMock: vi.fn(),
}));
vi.mock('./codex-token-rotation.js', () => ({
getAllCodexAccounts: getAllCodexAccountsMock,
getCodexAuthPath: () => null,
updateCodexAccountUsage: vi.fn(),
}));
const { readJsonFileMock } = vi.hoisted(() => ({
readJsonFileMock: vi.fn(),
}));
vi.mock('./utils.js', async () => {
const actual =
await vi.importActual<typeof import('./utils.js')>('./utils.js');
return {
...actual,
readJsonFile: readJsonFileMock,
writeJsonFile: vi.fn(),
};
});
afterEach(() => {
vi.resetModules();
vi.clearAllMocks();
});
describe('getClaudeUsageExhaustion', () => {
beforeEach(() => {
readJsonFileMock.mockReturnValue({});
});
it('returns exhausted=false when no tokens are configured', async () => {
getAllTokensMock.mockReturnValue([]);
const { getClaudeUsageExhaustion } = await import('./claude-usage.js');
expect(getClaudeUsageExhaustion()).toEqual({
exhausted: false,
nextResetAt: null,
});
});
it('returns exhausted=false when an account has no cached usage', async () => {
getAllTokensMock.mockReturnValue([
{
token: 'sk-ant-oat01-aaaaaaaa',
index: 0,
masked: 'aaa',
isActive: true,
isRateLimited: false,
},
]);
readJsonFileMock.mockReturnValue({}); // empty cache
const { getClaudeUsageExhaustion } = await import('./claude-usage.js');
expect(getClaudeUsageExhaustion().exhausted).toBe(false);
});
it('returns exhausted=true with the earliest recovery when all accounts are exhausted', async () => {
const reset0 = new Date('2026-04-28T01:00:00Z').toISOString();
const reset1 = new Date('2026-04-28T03:00:00Z').toISOString();
getAllTokensMock.mockReturnValue([
{
token: 'sk-ant-oat01-aaaaaaaa',
index: 0,
masked: 'aaa',
isActive: true,
isRateLimited: false,
},
{
token: 'sk-ant-oat01-bbbbbbbb',
index: 1,
masked: 'bbb',
isActive: false,
isRateLimited: false,
},
]);
readJsonFileMock.mockReturnValue({
'account-0': {
usage: {
five_hour: { utilization: 96, resets_at: reset0 },
seven_day: { utilization: 50, resets_at: '' },
},
fetchedAt: Date.now(),
},
'account-1': {
usage: {
five_hour: { utilization: 30, resets_at: '' },
seven_day: { utilization: 99, resets_at: reset1 },
},
fetchedAt: Date.now(),
},
});
const { getClaudeUsageExhaustion } = await import('./claude-usage.js');
const info = getClaudeUsageExhaustion();
expect(info.exhausted).toBe(true);
// Earliest recovery is account-0 (5h reset at reset0).
expect(info.nextResetAt).toBe(reset0);
});
it('returns exhausted=false when at least one account still has headroom', async () => {
getAllTokensMock.mockReturnValue([
{
token: 'sk-ant-oat01-aaaaaaaa',
index: 0,
masked: 'aaa',
isActive: true,
isRateLimited: false,
},
{
token: 'sk-ant-oat01-bbbbbbbb',
index: 1,
masked: 'bbb',
isActive: false,
isRateLimited: false,
},
]);
readJsonFileMock.mockReturnValue({
'account-0': {
usage: {
five_hour: { utilization: 99 },
seven_day: { utilization: 99 },
},
fetchedAt: Date.now(),
},
'account-1': {
usage: {
five_hour: { utilization: 80 },
seven_day: { utilization: 70 },
},
fetchedAt: Date.now(),
},
});
const { getClaudeUsageExhaustion } = await import('./claude-usage.js');
expect(getClaudeUsageExhaustion().exhausted).toBe(false);
});
it('treats rate-limited accounts as exhausted', async () => {
getAllTokensMock.mockReturnValue([
{
token: 'sk-ant-oat01-aaaaaaaa',
index: 0,
masked: 'aaa',
isActive: false,
isRateLimited: true,
},
]);
readJsonFileMock.mockReturnValue({});
const { getClaudeUsageExhaustion } = await import('./claude-usage.js');
expect(getClaudeUsageExhaustion().exhausted).toBe(true);
});
it('handles utilization on the 0–1 scale (legacy fractional form)', async () => {
getAllTokensMock.mockReturnValue([
{
token: 'sk-ant-oat01-aaaaaaaa',
index: 0,
masked: 'aaa',
isActive: true,
isRateLimited: false,
},
]);
readJsonFileMock.mockReturnValue({
'account-0': {
usage: {
five_hour: { utilization: 0.97 },
seven_day: { utilization: 0.4 },
},
fetchedAt: Date.now(),
},
});
const { getClaudeUsageExhaustion } = await import('./claude-usage.js');
expect(getClaudeUsageExhaustion().exhausted).toBe(true);
});
it('treats percent-scale utilization=1 as 1%, not 100%', async () => {
getAllTokensMock.mockReturnValue([
{
token: 'sk-ant-oat01-aaaaaaaa',
index: 0,
masked: 'aaa',
isActive: true,
isRateLimited: false,
},
]);
readJsonFileMock.mockReturnValue({
'account-0': {
usage: {
five_hour: { utilization: 1 },
seven_day: { utilization: 40 },
},
fetchedAt: Date.now(),
},
});
const { getClaudeUsageExhaustion } = await import('./claude-usage.js');
expect(getClaudeUsageExhaustion().exhausted).toBe(false);
});
});
describe('getCodexUsageExhaustion', () => {
it('returns exhausted=false when no Codex accounts are configured', async () => {
getAllCodexAccountsMock.mockReturnValue([]);
const { getCodexUsageExhaustion } =
await import('./codex-usage-collector.js');
expect(getCodexUsageExhaustion()).toEqual({
exhausted: false,
nextResetAt: null,
});
});
it('returns exhausted=false when an account has unknown usage (-1)', async () => {
getAllCodexAccountsMock.mockReturnValue([
{
index: 0,
accountId: 'a',
planType: 'pro',
isActive: true,
isRateLimited: false,
cachedUsagePct: -1,
cachedUsageD7Pct: -1,
},
]);
const { getCodexUsageExhaustion } =
await import('./codex-usage-collector.js');
expect(getCodexUsageExhaustion().exhausted).toBe(false);
});
it('returns exhausted=true with earliest recovery when all accounts are exhausted', async () => {
const reset0 = new Date('2026-04-28T02:00:00Z').toISOString();
const reset1 = new Date('2026-04-28T05:00:00Z').toISOString();
getAllCodexAccountsMock.mockReturnValue([
{
index: 0,
accountId: 'a',
planType: 'pro',
isActive: true,
isRateLimited: false,
cachedUsagePct: 96,
cachedUsageD7Pct: 40,
resetAt: reset0,
},
{
index: 1,
accountId: 'b',
planType: 'pro',
isActive: false,
isRateLimited: false,
cachedUsagePct: 30,
cachedUsageD7Pct: 99,
resetD7At: reset1,
},
]);
const { getCodexUsageExhaustion } =
await import('./codex-usage-collector.js');
const info = getCodexUsageExhaustion();
expect(info.exhausted).toBe(true);
expect(info.nextResetAt).toBe(reset0);
});
it('returns exhausted=false when at least one Codex account has headroom', async () => {
getAllCodexAccountsMock.mockReturnValue([
{
index: 0,
accountId: 'a',
planType: 'pro',
isActive: true,
isRateLimited: false,
cachedUsagePct: 99,
cachedUsageD7Pct: 99,
},
{
index: 1,
accountId: 'b',
planType: 'pro',
isActive: false,
isRateLimited: false,
cachedUsagePct: 50,
cachedUsageD7Pct: 80,
},
]);
const { getCodexUsageExhaustion } =
await import('./codex-usage-collector.js');
expect(getCodexUsageExhaustion().exhausted).toBe(false);
});
it('treats rate-limited Codex accounts as exhausted', async () => {
getAllCodexAccountsMock.mockReturnValue([
{
index: 0,
accountId: 'a',
planType: 'pro',
isActive: false,
isRateLimited: true,
cachedUsagePct: 10,
cachedUsageD7Pct: 10,
},
]);
const { getCodexUsageExhaustion } =
await import('./codex-usage-collector.js');
expect(getCodexUsageExhaustion().exhausted).toBe(true);
});
});