@foxden-app/foxclaw 0.3.15 → 0.3.18

package/dist/codex_app/local_usage.d.ts

@@ -11,14 +11,21 @@ export interface CodexLocalUsageStats {
     turns: number;
     usageEvents: number;
     totals: CodexLocalUsageTotals;
-    outputSpeed: CodexLocalOutputSpeedStats;
+    responseThroughput: CodexLocalResponseThroughputStats;
     latestSessionMtimeMs: number | null;
 }
-export interface CodexLocalOutputSpeedStats {
-    samples: number;
-    outputTokens: number;
+export interface CodexLocalUsageSnapshot {
+    computedAtMs: number;
+    stats: CodexLocalUsageStats;
+}
+export interface CodexLocalResponseThroughputStats {
+    completedTurns: number;
+    visibleOutputTokens: number;
     seconds: number;
-    latestTokensPerSecond: number | null;
-    latestSampleAtMs: number | null;
+    recentCompletedTurns: number;
+    recentVisibleOutputTokens: number;
+    recentSeconds: number;
 }
 export declare function readCodexLocalUsageStats(codexHome?: string): Promise<CodexLocalUsageStats>;
+export declare function readCodexLocalUsageSnapshot(snapshotPath: string): Promise<CodexLocalUsageSnapshot | null>;
+export declare function writeCodexLocalUsageSnapshot(snapshotPath: string, snapshot: CodexLocalUsageSnapshot): Promise<void>;

package/dist/codex_app/local_usage.js

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import readline from 'node:readline';
+const RECENT_COMPLETED_TURNS = 10;
 export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
     const sessionFiles = await listJsonlFiles([
         path.join(codexHome, 'sessions'),
@@ -13,7 +14,7 @@ export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
     let sessionsWithUsage = 0;
     let usageEvents = 0;
     let latestSessionMtimeMs = null;
-    const outputSpeed = emptyOutputSpeedStats();
+    const completedTurnSamples = [];
     for (const filePath of sessionFiles) {
         const stat = await fs.stat(filePath).catch(() => null);
         if (stat) {
@@ -21,7 +22,7 @@ export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
         }
         const fileUsage = await readSessionUsage(filePath, turnIds);
         usageEvents += fileUsage.usageEvents;
-        addOutputSpeed(outputSpeed, fileUsage.outputSpeed);
+        completedTurnSamples.push(...fileUsage.completedTurnSamples);
         if (fileUsage.totalUsage) {
             sessionsWithUsage += 1;
             addUsage(totals, fileUsage.totalUsage);
@@ -33,10 +34,28 @@ export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
         turns: turnIds.size,
         usageEvents,
         totals,
-        outputSpeed,
+        responseThroughput: summarizeResponseThroughput(completedTurnSamples),
         latestSessionMtimeMs,
     };
 }
+export async function readCodexLocalUsageSnapshot(snapshotPath) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(snapshotPath, 'utf8'));
+        if (!isFiniteNumber(parsed.computedAtMs) || !isCodexLocalUsageStats(parsed.stats)) {
+            return null;
+        }
+        return { computedAtMs: parsed.computedAtMs, stats: parsed.stats };
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeCodexLocalUsageSnapshot(snapshotPath, snapshot) {
+    await fs.mkdir(path.dirname(snapshotPath), { recursive: true });
+    const temporaryPath = `${snapshotPath}.${process.pid}.tmp`;
+    await fs.writeFile(temporaryPath, `${JSON.stringify(snapshot, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await fs.rename(temporaryPath, snapshotPath);
+}
 function resolveCodexHome() {
     return process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
 }
@@ -69,8 +88,8 @@ async function readSessionUsage(filePath, turnIds) {
     const reader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let totalUsage = null;
     let usageEvents = 0;
-    let generationStartMs = null;
-    const outputSpeed = emptyOutputSpeedStats();
+    let activeTurn = null;
+    const completedTurnSamples = [];
     try {
         for await (const line of reader) {
             if (!line.trim())
@@ -87,28 +106,49 @@ async function readSessionUsage(filePath, turnIds) {
             if (turnId) {
                 turnIds.add(turnId);
             }
-            if (timestampMs !== null && isGenerationBoundary(event)) {
-                generationStartMs = timestampMs;
+            if (timestampMs !== null
+                && turnId
+                && event?.type === 'event_msg'
+                && event?.payload?.type === 'task_started') {
+                activeTurn = { turnId, startedAtMs: timestampMs, visibleOutputTokens: 0 };
             }
             const info = event?.payload?.info;
             const lastTokenUsage = info?.last_token_usage ?? info?.lastTokenUsage;
             if (lastTokenUsage) {
                 usageEvents += 1;
-                addOutputSpeedSample(outputSpeed, lastTokenUsage, generationStartMs, timestampMs);
-                if (timestampMs !== null) {
-                    generationStartMs = timestampMs;
+                if (activeTurn) {
+                    activeTurn.visibleOutputTokens += visibleOutputTokens(lastTokenUsage);
                 }
             }
             const totalTokenUsage = info?.total_token_usage ?? info?.totalTokenUsage;
             if (totalTokenUsage) {
                 totalUsage = totalTokenUsage;
             }
+            const completedTurn = activeTurn;
+            if (completedTurn !== null
+                && timestampMs !== null
+                && turnId
+                && completedTurn.turnId === turnId
+                && event?.type === 'event_msg'
+                && (event?.payload?.type === 'task_complete' || event?.payload?.type === 'turn_aborted')) {
+                if (event.payload.type === 'task_complete' && completedTurn.visibleOutputTokens > 0) {
+                    const seconds = (timestampMs - completedTurn.startedAtMs) / 1000;
+                    if (Number.isFinite(seconds) && seconds > 0) {
+                        completedTurnSamples.push({
+                            completedAtMs: timestampMs,
+                            visibleOutputTokens: completedTurn.visibleOutputTokens,
+                            seconds,
+                        });
+                    }
+                }
+                activeTurn = null;
+            }
         }
     }
     finally {
         reader.close();
     }
-    return { usageEvents, totalUsage, outputSpeed };
+    return { usageEvents, totalUsage, completedTurnSamples };
 }
 function emptyTotals() {
     return {
@@ -119,14 +159,37 @@ function emptyTotals() {
         totalTokens: 0,
     };
 }
-function emptyOutputSpeedStats() {
-    return {
-        samples: 0,
-        outputTokens: 0,
-        seconds: 0,
-        latestTokensPerSecond: null,
-        latestSampleAtMs: null,
-    };
+function isCodexLocalUsageStats(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const stats = value;
+    const totals = stats.totals;
+    const throughput = stats.responseThroughput;
+    return isFiniteNumber(stats.sessionFiles)
+        && isFiniteNumber(stats.sessionsWithUsage)
+        && isFiniteNumber(stats.turns)
+        && isFiniteNumber(stats.usageEvents)
+        && Boolean(totals)
+        && isFiniteNumber(totals?.inputTokens)
+        && isFiniteNumber(totals?.cachedInputTokens)
+        && isFiniteNumber(totals?.outputTokens)
+        && isFiniteNumber(totals?.reasoningOutputTokens)
+        && isFiniteNumber(totals?.totalTokens)
+        && Boolean(throughput)
+        && isFiniteNumber(throughput?.completedTurns)
+        && isFiniteNumber(throughput?.visibleOutputTokens)
+        && isFiniteNumber(throughput?.seconds)
+        && isFiniteNumber(throughput?.recentCompletedTurns)
+        && isFiniteNumber(throughput?.recentVisibleOutputTokens)
+        && isFiniteNumber(throughput?.recentSeconds)
+        && isNullableFiniteNumber(stats.latestSessionMtimeMs);
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isNullableFiniteNumber(value) {
+    return value === null || isFiniteNumber(value);
 }
 function addUsage(totals, usage) {
     const inputTokens = numberField(usage, 'input_tokens', 'inputTokens');
@@ -138,34 +201,21 @@ function addUsage(totals, usage) {
     totals.reasoningOutputTokens += numberField(usage, 'reasoning_output_tokens', 'reasoningOutputTokens');
     totals.totalTokens += totalTokens || inputTokens + outputTokens;
 }
-function addOutputSpeed(target, source) {
-    target.samples += source.samples;
-    target.outputTokens += source.outputTokens;
-    target.seconds += source.seconds;
-    if (source.latestTokensPerSecond !== null
-        && source.latestSampleAtMs !== null
-        && (target.latestSampleAtMs === null || source.latestSampleAtMs > target.latestSampleAtMs)) {
-        target.latestTokensPerSecond = source.latestTokensPerSecond;
-        target.latestSampleAtMs = source.latestSampleAtMs;
-    }
+function visibleOutputTokens(usage) {
+    return Math.max(0, numberField(usage, 'output_tokens', 'outputTokens')
+        - numberField(usage, 'reasoning_output_tokens', 'reasoningOutputTokens'));
 }
-function addOutputSpeedSample(stats, usage, generationStartMs, timestampMs) {
-    if (generationStartMs === null || timestampMs === null || timestampMs <= generationStartMs) {
-        return;
-    }
-    const outputTokens = numberField(usage, 'output_tokens', 'outputTokens');
-    if (outputTokens <= 0) {
-        return;
-    }
-    const seconds = (timestampMs - generationStartMs) / 1000;
-    if (!Number.isFinite(seconds) || seconds <= 0) {
-        return;
-    }
-    stats.samples += 1;
-    stats.outputTokens += outputTokens;
-    stats.seconds += seconds;
-    stats.latestTokensPerSecond = outputTokens / seconds;
-    stats.latestSampleAtMs = timestampMs;
+function summarizeResponseThroughput(samples) {
+    const ordered = samples.slice().sort((left, right) => left.completedAtMs - right.completedAtMs);
+    const recent = ordered.slice(-RECENT_COMPLETED_TURNS);
+    return {
+        completedTurns: ordered.length,
+        visibleOutputTokens: ordered.reduce((total, sample) => total + sample.visibleOutputTokens, 0),
+        seconds: ordered.reduce((total, sample) => total + sample.seconds, 0),
+        recentCompletedTurns: recent.length,
+        recentVisibleOutputTokens: recent.reduce((total, sample) => total + sample.visibleOutputTokens, 0),
+        recentSeconds: recent.reduce((total, sample) => total + sample.seconds, 0),
+    };
 }
 function numberField(source, snakeKey, camelKey) {
     const snakeValue = source[snakeKey];
@@ -180,15 +230,3 @@ function parseTimestampMs(value) {
     const timestamp = Date.parse(value);
     return Number.isFinite(timestamp) ? timestamp : null;
 }
-function isGenerationBoundary(event) {
-    const payload = event?.payload;
-    if (event?.type === 'response_item' && payload?.type === 'function_call_output') {
-        return true;
-    }
-    if (event?.type !== 'event_msg') {
-        return false;
-    }
-    return payload?.type === 'task_started'
-        || payload?.type === 'exec_command_end'
-        || payload?.type === 'user_message';
-}

package/dist/controller/controller.d.ts

@@ -32,6 +32,10 @@ export declare class BridgeSessionCore {
     private authRotationInProgress;
     private authRotationFailedTargets;
     private localUsageCache;
+    private localUsageCacheLoaded;
+    private localUsageRefresh;
+    private authQuotaSnapshots;
+    private authQuotaSnapshotsLoaded;
     private lastRemoteControlStatus;
     private pendingThreadRenames;
     private pendingThreadNewCwds;
@@ -263,9 +267,16 @@ export declare class BridgeSessionCore {
     private buildNativeCollaborationMode;
     private buildCodexUsageStatusLines;
     private buildCodexLocalUsageStatusLines;
-    private formatCodexLocalOutputSpeedStatusLines;
+    private formatCodexLocalResponseThroughputStatusLines;
     private resolveFastStatusLabel;
     private readCachedCodexLocalUsageStats;
+    private refreshCodexLocalUsageIfNeeded;
+    private refreshCodexLocalUsageStats;
+    private codexLocalUsageSnapshotPath;
+    private refreshCurrentCodexAuthQuota;
+    private readCodexAuthQuotaSnapshots;
+    private writeCodexAuthQuotaSnapshots;
+    private codexAuthQuotaSnapshotPath;
     private sendThreadContextSummary;
     private handleModelCommand;
     private handleEffortCommand;

package/dist/controller/controller.js

@@ -11,7 +11,7 @@ import { TELEGRAM_MESSAGE_LIMIT, chunkTelegramMessage, chunkTelegramStreamMessag
 import { isDefaultTelegramScope, resolveTelegramAddressing } from '../telegram/addressing.js';
 import { BRIDGE_SCOPE_WEIXIN_PREFIX, parseTelegramTargetFromBridgeScope, parseWeixinBridgeScope } from '../core/bridge_scope.js';
 import { resolveTelegramRenderRoute } from '../telegram/rendering.js';
-import { readCodexLocalUsageStats } from '../codex_app/local_usage.js';
+import { readCodexLocalUsageSnapshot, readCodexLocalUsageStats, writeCodexLocalUsageSnapshot, } from '../codex_app/local_usage.js';
 import { normalizeTurnActivityEvent, } from './activity.js';
 import { normalizeAccessPreset, resolveAccessMode } from './access.js';
 import { diffObservedTurn, findLatestTurn, findLiveTurn } from './observer.js';
@@ -23,7 +23,9 @@ class UserFacingError extends Error {
 const OBSERVED_THREAD_POLL_MS = 1500;
 const OBSERVED_CLI_USER_LABEL = 'codex-cli-user';
 const DEFAULT_COLLABORATION_MODE = 'default';
-const CODEX_LOCAL_USAGE_CACHE_MS = 30_000;
+const CODEX_LOCAL_USAGE_REFRESH_MS = 30 * 60_000;
+const CODEX_LOCAL_USAGE_SNAPSHOT_FILENAME = 'codex-local-usage.json';
+const CODEX_AUTH_QUOTA_SNAPSHOT_FILENAME = 'codex-auth-quota.json';
 const USER_INPUT_SUBMITTED_NOTICE_MS = 90_000;
 const SELF_UPDATE_STATUS_POLL_MS = 1000;
 const PLAN_IMPLEMENTATION_CODING_MESSAGE = 'Implement the plan.';
@@ -110,6 +112,10 @@ export class BridgeSessionCore {
     authRotationInProgress = false;
     authRotationFailedTargets = new Set();
     localUsageCache = null;
+    localUsageCacheLoaded = false;
+    localUsageRefresh = null;
+    authQuotaSnapshots = {};
+    authQuotaSnapshotsLoaded = false;
     lastRemoteControlStatus = null;
     pendingThreadRenames = new Map();
     pendingThreadNewCwds = new Map();
@@ -186,6 +192,9 @@ export class BridgeSessionCore {
         await this.app.start();
         await this.restorePendingUserInputs();
         await this.cleanupStaleTurnPreviews();
+        void this.refreshCodexLocalUsageIfNeeded().catch((error) => {
+            this.logger.warn('codex.local_usage_background_refresh_failed', { error: formatUserError(error) });
+        });
         this.updateStatus();
     }
     /** Begin Telegram Bot API long-polling after handlers and Codex are ready. */
@@ -348,7 +357,11 @@ export class BridgeSessionCore {
                 const binding = this.store.getBinding(scopeId);
                 const settings = this.store.getChatSettings(scopeId);
                 const access = this.resolveEffectiveAccess(scopeId, settings);
-                const fastStatus = await this.resolveFastStatusLabel(locale, settings);
+                const [fastStatus, codexUsageLines, codexLocalUsageLines] = await Promise.all([
+                    this.resolveFastStatusLabel(locale, settings),
+                    this.buildCodexUsageStatusLines(locale),
+                    this.buildCodexLocalUsageStatusLines(locale),
+                ]);
                 const appServer = this.app.getServerStatus();
                 const appServerLabel = appServer.pid && appServer.port
                     ? `${appServer.running ? t(locale, 'status_app_server_running') : t(locale, 'status_app_server_stale')} pid=${appServer.pid} port=${appServer.port}`
@@ -376,8 +389,8 @@ export class BridgeSessionCore {
                     t(locale, 'status_pending_user_inputs', { value: this.store.countPendingUserInputs() }),
                     t(locale, 'status_active_turns', { value: this.activeTurns.size }),
                 ];
-                lines.push(...await this.buildCodexUsageStatusLines(locale));
-                lines.push(...await this.buildCodexLocalUsageStatusLines(locale));
+                lines.push(...codexUsageLines);
+                lines.push(...codexLocalUsageLines);
                 await this.sendMessage(scopeId, lines.join('\n'));
                 return;
             }
@@ -3743,6 +3756,7 @@ export class BridgeSessionCore {
             return;
         }
         const state = await this.listCodexAuthState();
+        await this.refreshCurrentCodexAuthQuota(state);
         const record = {
             localId: crypto.randomBytes(8).toString('hex'),
             chatId: scopeId,
@@ -4384,7 +4398,12 @@ export class BridgeSessionCore {
         return candidate ? { candidate, fromLabel: state.currentLabel, toLabel: await authPathDisplayLabel(candidate.path) } : null;
     }
     async listCodexAuthState() {
-        return listCodexAuthState(this.store.listDisabledCodexAuthCandidateNames());
+        const state = await listCodexAuthState(this.store.listDisabledCodexAuthCandidateNames());
+        const snapshots = await this.readCodexAuthQuotaSnapshots();
+        state.candidates.forEach((candidate) => {
+            candidate.quota = snapshots[candidate.name] ?? null;
+        });
+        return state;
     }
     async readCodexAuthSwitchLabels(candidate) {
         const state = await this.listCodexAuthState();
@@ -4486,7 +4505,7 @@ export class BridgeSessionCore {
             }
             lines.push(t(locale, 'status_codex_usage_window', {
                 window: formatRateLimitWindowLabel(locale, window, kind),
-                percent: formatUsagePercent(window.usedPercent),
+                percent: formatRemainingUsagePercent(window.usedPercent),
                 reset: window.resetsAt
                     ? t(locale, 'status_codex_usage_reset', { value: formatLocalTimestamp(window.resetsAt) })
                     : '',
@@ -4505,7 +4524,14 @@ export class BridgeSessionCore {
     }
     async buildCodexLocalUsageStatusLines(locale) {
         try {
-            const stats = await this.readCachedCodexLocalUsageStats();
+            const snapshot = await this.readCachedCodexLocalUsageStats();
+            void this.refreshCodexLocalUsageIfNeeded(snapshot).catch((error) => {
+                this.logger.warn('codex.local_usage_background_refresh_failed', { error: formatUserError(error) });
+            });
+            if (!snapshot) {
+                return [t(locale, 'status_codex_local_usage_refreshing')];
+            }
+            const stats = snapshot.stats;
             if (stats.sessionFiles === 0 || stats.sessionsWithUsage === 0) {
                 return [];
             }
@@ -4518,11 +4544,15 @@ export class BridgeSessionCore {
                 t(locale, 'status_codex_local_tokens', {
                     total: formatTokenCount(stats.totals.totalTokens),
                     input: formatTokenCount(stats.totals.inputTokens),
+                    visible: formatTokenCount(Math.max(0, stats.totals.outputTokens - stats.totals.reasoningOutputTokens)),
                     output: formatTokenCount(stats.totals.outputTokens),
                     cached: formatTokenCount(stats.totals.cachedInputTokens),
                     reasoning: formatTokenCount(stats.totals.reasoningOutputTokens),
                 }),
-                ...this.formatCodexLocalOutputSpeedStatusLines(locale, stats),
+                ...this.formatCodexLocalResponseThroughputStatusLines(locale, stats),
+                t(locale, 'status_codex_local_snapshot_at', {
+                    value: formatLocalTimestamp(snapshot.computedAtMs / 1000),
+                }),
             ];
         }
         catch (error) {
@@ -4530,16 +4560,21 @@ export class BridgeSessionCore {
             return [t(locale, 'status_codex_local_usage_unavailable', { error: formatShortStatusError(error) })];
         }
     }
-    formatCodexLocalOutputSpeedStatusLines(locale, stats) {
-        const speed = stats.outputSpeed;
-        if (speed.samples === 0 || speed.outputTokens <= 0 || speed.seconds <= 0) {
+    formatCodexLocalResponseThroughputStatusLines(locale, stats) {
+        const throughput = stats.responseThroughput;
+        if (throughput.completedTurns === 0
+            || throughput.visibleOutputTokens <= 0
+            || throughput.seconds <= 0
+            || throughput.recentCompletedTurns === 0
+            || throughput.recentVisibleOutputTokens <= 0
+            || throughput.recentSeconds <= 0) {
             return [];
         }
-        const avg = speed.outputTokens / speed.seconds;
-        return [t(locale, 'status_codex_local_speed', {
-                avg: formatCompactNumber(avg),
-                latest: speed.latestTokensPerSecond === null ? t(locale, 'unknown') : formatCompactNumber(speed.latestTokensPerSecond),
-                samples: formatTokenCount(speed.samples),
+        return [t(locale, 'status_codex_local_throughput', {
+                overall: formatCompactNumber(throughput.visibleOutputTokens / throughput.seconds),
+                recent: formatCompactNumber(throughput.recentVisibleOutputTokens / throughput.recentSeconds),
+                recentTurns: formatTokenCount(throughput.recentCompletedTurns),
+                turns: formatTokenCount(throughput.completedTurns),
             })];
     }
     async resolveFastStatusLabel(locale, settings) {
@@ -4554,13 +4589,87 @@ export class BridgeSessionCore {
         }
     }
     async readCachedCodexLocalUsageStats() {
-        const now = Date.now();
-        if (this.localUsageCache && this.localUsageCache.expiresAt > now) {
-            return this.localUsageCache.stats;
+        if (this.localUsageCacheLoaded) {
+            return this.localUsageCache;
         }
+        this.localUsageCache = await readCodexLocalUsageSnapshot(this.codexLocalUsageSnapshotPath());
+        this.localUsageCacheLoaded = true;
+        return this.localUsageCache;
+    }
+    async refreshCodexLocalUsageIfNeeded(snapshot) {
+        const current = snapshot === undefined ? await this.readCachedCodexLocalUsageStats() : snapshot;
+        if (current && Date.now() - current.computedAtMs < CODEX_LOCAL_USAGE_REFRESH_MS) {
+            return;
+        }
+        if (this.localUsageRefresh) {
+            return;
+        }
+        this.localUsageRefresh = this.refreshCodexLocalUsageStats().finally(() => {
+            this.localUsageRefresh = null;
+        });
+        await this.localUsageRefresh;
+    }
+    async refreshCodexLocalUsageStats() {
         const stats = await readCodexLocalUsageStats();
-        this.localUsageCache = { stats, expiresAt: now + CODEX_LOCAL_USAGE_CACHE_MS };
-        return stats;
+        const snapshot = { computedAtMs: Date.now(), stats };
+        this.localUsageCache = snapshot;
+        this.localUsageCacheLoaded = true;
+        await writeCodexLocalUsageSnapshot(this.codexLocalUsageSnapshotPath(), snapshot);
+    }
+    codexLocalUsageSnapshotPath() {
+        return path.join(path.dirname(this.config.statusPath), CODEX_LOCAL_USAGE_SNAPSHOT_FILENAME);
+    }
+    async refreshCurrentCodexAuthQuota(state) {
+        const candidate = state.candidates.find(entry => entry.isCurrent);
+        if (!candidate) {
+            return;
+        }
+        try {
+            const snapshot = selectCodexRateLimitSnapshot(await this.app.readAccountRateLimits());
+            if (!snapshot) {
+                return;
+            }
+            const quota = authQuotaSnapshotFromRateLimit(snapshot);
+            candidate.quota = quota;
+            this.authQuotaSnapshots[candidate.name] = quota;
+            await this.writeCodexAuthQuotaSnapshots();
+        }
+        catch (error) {
+            this.logger.warn('codex.auth_quota_refresh_failed', { error: formatUserError(error) });
+        }
+    }
+    async readCodexAuthQuotaSnapshots() {
+        if (this.authQuotaSnapshotsLoaded) {
+            return this.authQuotaSnapshots;
+        }
+        this.authQuotaSnapshotsLoaded = true;
+        try {
+            const parsed = JSON.parse(await fs.readFile(this.codexAuthQuotaSnapshotPath(), 'utf8'));
+            if (parsed && typeof parsed === 'object') {
+                for (const [name, value] of Object.entries(parsed)) {
+                    if (isCodexAuthQuotaSnapshot(value)) {
+                        this.authQuotaSnapshots[name] = value;
+                    }
+                }
+            }
+        }
+        catch {
+            // A missing or invalid historical cache should not block the auth panel.
+        }
+        return this.authQuotaSnapshots;
+    }
+    async writeCodexAuthQuotaSnapshots() {
+        const snapshotPath = this.codexAuthQuotaSnapshotPath();
+        await fs.mkdir(path.dirname(snapshotPath), { recursive: true });
+        const temporaryPath = `${snapshotPath}.${process.pid}.tmp`;
+        await fs.writeFile(temporaryPath, `${JSON.stringify(this.authQuotaSnapshots, null, 2)}\n`, {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+        await fs.rename(temporaryPath, snapshotPath);
+    }
+    codexAuthQuotaSnapshotPath() {
+        return path.join(path.dirname(this.config.statusPath), CODEX_AUTH_QUOTA_SNAPSHOT_FILENAME);
     }
     async sendThreadContextSummary(scopeId, locale, threadId) {
         try {
@@ -7039,6 +7148,7 @@ async function listCodexAuthState(disabledNames = new Set()) {
             isCurrent: currentTargetPath === candidatePath,
             disabled: disabledNames.has(entry.name),
             mtimeMs: stat.mtimeMs,
+            quota: null,
         });
     }
     candidates.sort((left, right) => left.name.localeCompare(right.name, undefined, { numeric: true }));
@@ -7138,12 +7248,13 @@ function renderAuthListMessage(locale, state, includeWeixinCopyPaste = false) {
         return lines.join('\n');
     }
     lines.push(t(locale, 'auth_candidate_count', { value: state.candidates.length }));
+    lines.push(t(locale, 'auth_quota_legend'));
     state.candidates.forEach((candidate, index) => {
         const marker = candidate.isCurrent ? ' *' : '';
         const status = candidate.disabled
             ? t(locale, 'auth_candidate_status_disabled')
             : t(locale, 'auth_candidate_status_enabled');
-        lines.push(`${index + 1}. ${candidate.name}${marker} [${status}]`);
+        lines.push(`${index + 1}. ${formatAuthQuotaPrefix(candidate.quota)}|${candidate.name}${marker} [${status}]`);
     });
     if (includeWeixinCopyPaste) {
         lines.push('', t(locale, 'weixin_copy_paste_divider'), t(locale, 'weixin_copy_auth_title'), ...state.candidates.map((_candidate, index) => `/auth use ${index + 1}`), ...state.candidates.map((candidate, index) => candidate.disabled
@@ -7155,7 +7266,7 @@ function renderAuthListMessage(locale, state, includeWeixinCopyPaste = false) {
 function authChoiceKeyboard(locale, record) {
     const rows = record.candidates.map((candidate, index) => [
         {
-            text: clipButtonText(`${candidate.isCurrent ? '✅ ' : '🔐 '}${candidate.name}${candidate.disabled ? ' · off' : ''}`),
+            text: clipButtonText(`${candidate.isCurrent ? '✅ ' : '🔐 '}${formatAuthQuotaPrefix(candidate.quota)}|${candidate.name}${candidate.disabled ? ' · off' : ''}`),
             callback_data: `auth:${record.localId}:${index}`,
         },
         {
@@ -7692,6 +7803,44 @@ function formatUsagePercent(value) {
     }
     return formatCompactNumber(value);
 }
+function formatRemainingUsagePercent(usedPercent) {
+    const remainingPercent = remainingUsagePercent(usedPercent);
+    return remainingPercent === null ? '?' : formatUsagePercent(remainingPercent);
+}
+function authQuotaSnapshotFromRateLimit(snapshot) {
+    return {
+        capturedAtMs: Date.now(),
+        primaryRemainingPercent: snapshot.primary ? remainingUsagePercent(snapshot.primary.usedPercent) : null,
+        secondaryRemainingPercent: snapshot.secondary ? remainingUsagePercent(snapshot.secondary.usedPercent) : null,
+    };
+}
+function remainingUsagePercent(usedPercent) {
+    if (!Number.isFinite(usedPercent)) {
+        return null;
+    }
+    return Math.max(0, Math.min(100, 100 - usedPercent));
+}
+function formatAuthQuotaPrefix(snapshot) {
+    if (!snapshot) {
+        return '--|--';
+    }
+    const primary = snapshot.primaryRemainingPercent === null ? '--' : formatUsagePercent(snapshot.primaryRemainingPercent);
+    const secondary = snapshot.secondaryRemainingPercent === null ? '--' : formatUsagePercent(snapshot.secondaryRemainingPercent);
+    return `${primary}|${secondary}`;
+}
+function isCodexAuthQuotaSnapshot(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const snapshot = value;
+    return typeof snapshot.capturedAtMs === 'number'
+        && Number.isFinite(snapshot.capturedAtMs)
+        && isNullableFiniteNumber(snapshot.primaryRemainingPercent)
+        && isNullableFiniteNumber(snapshot.secondaryRemainingPercent);
+}
+function isNullableFiniteNumber(value) {
+    return value === null || (typeof value === 'number' && Number.isFinite(value));
+}
 function formatCompactNumber(value) {
     return Number.isInteger(value) ? String(value) : value.toFixed(1).replace(/\.0$/, '');
 }

package/dist/i18n.d.ts

@@ -90,7 +90,7 @@ declare const MESSAGES: {
         readonly status_app_server: "Codex app-server: {value}";
         readonly status_app_server_running: "running";
         readonly status_app_server_stale: "stale";
-        readonly status_user_agent: "User agent: {value}";
+        readonly status_user_agent: "Codex/FoxClaw agent: {value}";
         readonly status_current_thread: "Current thread: {value}";
         readonly status_configured_model: "Configured model: {value}";
         readonly status_configured_effort: "Configured effort: {value}";
@@ -107,12 +107,14 @@ declare const MESSAGES: {
         readonly status_codex_account: "Codex account: {value}";
         readonly status_codex_plan: "Codex plan: {value}";
         readonly status_codex_usage_title: "Codex usage ({value}):";
-        readonly status_codex_usage_window: "{window}: {percent}% used{reset}";
+        readonly status_codex_usage_window: "{window}: {percent}% remaining{reset}";
         readonly status_codex_usage_reset: ", resets {value}";
         readonly status_codex_usage_unavailable: "Codex usage: unavailable ({error})";
         readonly status_codex_local_history: "Codex local history: {sessions} sessions, {turns} turns, {events} usage records";
-        readonly status_codex_local_tokens: "Codex local tokens: total {total}; input {input}, output {output}, cached input {cached}, reasoning output {reasoning}";
-        readonly status_codex_local_speed: "Codex local output speed: avg {avg} token/s, latest {latest} token/s ({samples} samples)";
+        readonly status_codex_local_tokens: "Codex local tokens: total {total}; input {input}, visible output {visible}, reasoning output {reasoning}, total output {output}, cached input {cached}";
+        readonly status_codex_local_throughput: "Codex visible reply throughput (end-to-end, excluding reasoning): overall {overall} token/s, last {recentTurns} completed turns {recent} token/s ({turns} completed turns sampled)";
+        readonly status_codex_local_snapshot_at: "Codex local stats snapshot: {value}";
+        readonly status_codex_local_usage_refreshing: "Codex local history: building snapshot in background";
         readonly status_codex_local_usage_unavailable: "Codex local history: unavailable ({error})";
         readonly status_codex_credits: "Codex credits: {value}";
         readonly status_codex_limit_reached: "Codex limit: {value}";
@@ -131,6 +133,7 @@ declare const MESSAGES: {
         readonly auth_current: "Current auth: {value}";
         readonly auth_dir: "Auth dir: {value}";
         readonly auth_candidate_count: "Candidates: {value}";
+        readonly auth_quota_legend: "Quota remaining: 5h|7d|auth";
         readonly auth_candidate_status_enabled: "enabled";
         readonly auth_candidate_status_disabled: "disabled";
         readonly auth_candidate_enabled: "Enabled auth candidate for auto-rotation: {value}";
@@ -651,7 +654,7 @@ declare const MESSAGES: {
         readonly status_app_server: "Codex app-server：{value}";
         readonly status_app_server_running: "运行中";
         readonly status_app_server_stale: "失效";
-        readonly status_user_agent: "客户端：{value}";
+        readonly status_user_agent: "Codex/FoxClaw 标识：{value}";
         readonly status_current_thread: "当前线程：{value}";
         readonly status_configured_model: "已配置模型：{value}";
         readonly status_configured_effort: "已配置推理强度：{value}";
@@ -668,12 +671,14 @@ declare const MESSAGES: {
         readonly status_codex_account: "Codex 账号：{value}";
         readonly status_codex_plan: "Codex 套餐：{value}";
         readonly status_codex_usage_title: "Codex 用量（{value}）：";
-        readonly status_codex_usage_window: "{window}：已用 {percent}%{reset}";
+        readonly status_codex_usage_window: "{window}：剩余 {percent}%{reset}";
         readonly status_codex_usage_reset: "，重置时间 {value}";
         readonly status_codex_usage_unavailable: "Codex 用量：无法获取（{error}）";
         readonly status_codex_local_history: "Codex 本地历史：{sessions} 个会话，{turns} 轮，{events} 条用量记录";
-        readonly status_codex_local_tokens: "Codex 本地 Token：总计 {total}；输入 {input}，输出 {output}，缓存输入 {cached}，推理输出 {reasoning}";
-        readonly status_codex_local_speed: "Codex 本地输出速度：平均 {avg} token/s，最近 {latest} token/s（{samples} 个样本）";
+        readonly status_codex_local_tokens: "Codex 本地 Token：总计 {total}；输入 {input}，可见输出 {visible}，推理输出 {reasoning}，总输出 {output}，缓存输入 {cached}";
+        readonly status_codex_local_throughput: "Codex 可见答复吞吐（端到端，排除推理 token）：整体 {overall} token/s，最近 {recentTurns} 个完成轮次 {recent} token/s（{turns} 个完成轮次样本）";
+        readonly status_codex_local_snapshot_at: "Codex 本地统计快照：{value}";
+        readonly status_codex_local_usage_refreshing: "Codex 本地历史：正在后台生成统计快照";
         readonly status_codex_local_usage_unavailable: "Codex 本地历史：无法获取（{error}）";
         readonly status_codex_credits: "Codex 额度：{value}";
         readonly status_codex_limit_reached: "Codex 限制：{value}";
@@ -692,6 +697,7 @@ declare const MESSAGES: {
         readonly auth_current: "当前 auth：{value}";
         readonly auth_dir: "Auth 目录：{value}";
         readonly auth_candidate_count: "候选数量：{value}";
+        readonly auth_quota_legend: "额度剩余：5h|7d|auth";
         readonly auth_candidate_status_enabled: "启用";
         readonly auth_candidate_status_disabled: "禁用";
         readonly auth_candidate_enabled: "已启用 auth 候选自动轮换：{value}";

package/dist/i18n.js

@@ -88,7 +88,7 @@ const MESSAGES = {
         status_app_server: 'Codex app-server: {value}',
         status_app_server_running: 'running',
         status_app_server_stale: 'stale',
-        status_user_agent: 'User agent: {value}',
+        status_user_agent: 'Codex/FoxClaw agent: {value}',
         status_current_thread: 'Current thread: {value}',
         status_configured_model: 'Configured model: {value}',
         status_configured_effort: 'Configured effort: {value}',
@@ -105,12 +105,14 @@ const MESSAGES = {
         status_codex_account: 'Codex account: {value}',
         status_codex_plan: 'Codex plan: {value}',
         status_codex_usage_title: 'Codex usage ({value}):',
-        status_codex_usage_window: '{window}: {percent}% used{reset}',
+        status_codex_usage_window: '{window}: {percent}% remaining{reset}',
         status_codex_usage_reset: ', resets {value}',
         status_codex_usage_unavailable: 'Codex usage: unavailable ({error})',
         status_codex_local_history: 'Codex local history: {sessions} sessions, {turns} turns, {events} usage records',
-        status_codex_local_tokens: 'Codex local tokens: total {total}; input {input}, output {output}, cached input {cached}, reasoning output {reasoning}',
-        status_codex_local_speed: 'Codex local output speed: avg {avg} token/s, latest {latest} token/s ({samples} samples)',
+        status_codex_local_tokens: 'Codex local tokens: total {total}; input {input}, visible output {visible}, reasoning output {reasoning}, total output {output}, cached input {cached}',
+        status_codex_local_throughput: 'Codex visible reply throughput (end-to-end, excluding reasoning): overall {overall} token/s, last {recentTurns} completed turns {recent} token/s ({turns} completed turns sampled)',
+        status_codex_local_snapshot_at: 'Codex local stats snapshot: {value}',
+        status_codex_local_usage_refreshing: 'Codex local history: building snapshot in background',
         status_codex_local_usage_unavailable: 'Codex local history: unavailable ({error})',
         status_codex_credits: 'Codex credits: {value}',
         status_codex_limit_reached: 'Codex limit: {value}',
@@ -129,6 +131,7 @@ const MESSAGES = {
         auth_current: 'Current auth: {value}',
         auth_dir: 'Auth dir: {value}',
         auth_candidate_count: 'Candidates: {value}',
+        auth_quota_legend: 'Quota remaining: 5h|7d|auth',
         auth_candidate_status_enabled: 'enabled',
         auth_candidate_status_disabled: 'disabled',
         auth_candidate_enabled: 'Enabled auth candidate for auto-rotation: {value}',
@@ -649,7 +652,7 @@ const MESSAGES = {
         status_app_server: 'Codex app-server：{value}',
         status_app_server_running: '运行中',
         status_app_server_stale: '失效',
-        status_user_agent: '客户端：{value}',
+        status_user_agent: 'Codex/FoxClaw 标识：{value}',
         status_current_thread: '当前线程：{value}',
         status_configured_model: '已配置模型：{value}',
         status_configured_effort: '已配置推理强度：{value}',
@@ -666,12 +669,14 @@ const MESSAGES = {
         status_codex_account: 'Codex 账号：{value}',
         status_codex_plan: 'Codex 套餐：{value}',
         status_codex_usage_title: 'Codex 用量（{value}）：',
-        status_codex_usage_window: '{window}：已用 {percent}%{reset}',
+        status_codex_usage_window: '{window}：剩余 {percent}%{reset}',
         status_codex_usage_reset: '，重置时间 {value}',
         status_codex_usage_unavailable: 'Codex 用量：无法获取（{error}）',
         status_codex_local_history: 'Codex 本地历史：{sessions} 个会话，{turns} 轮，{events} 条用量记录',
-        status_codex_local_tokens: 'Codex 本地 Token：总计 {total}；输入 {input}，输出 {output}，缓存输入 {cached}，推理输出 {reasoning}',
-        status_codex_local_speed: 'Codex 本地输出速度：平均 {avg} token/s，最近 {latest} token/s（{samples} 个样本）',
+        status_codex_local_tokens: 'Codex 本地 Token：总计 {total}；输入 {input}，可见输出 {visible}，推理输出 {reasoning}，总输出 {output}，缓存输入 {cached}',
+        status_codex_local_throughput: 'Codex 可见答复吞吐（端到端，排除推理 token）：整体 {overall} token/s，最近 {recentTurns} 个完成轮次 {recent} token/s（{turns} 个完成轮次样本）',
+        status_codex_local_snapshot_at: 'Codex 本地统计快照：{value}',
+        status_codex_local_usage_refreshing: 'Codex 本地历史：正在后台生成统计快照',
         status_codex_local_usage_unavailable: 'Codex 本地历史：无法获取（{error}）',
         status_codex_credits: 'Codex 额度：{value}',
         status_codex_limit_reached: 'Codex 限制：{value}',
@@ -690,6 +695,7 @@ const MESSAGES = {
         auth_current: '当前 auth：{value}',
         auth_dir: 'Auth 目录：{value}',
         auth_candidate_count: '候选数量：{value}',
+        auth_quota_legend: '额度剩余：5h|7d|auth',
         auth_candidate_status_enabled: '启用',
         auth_candidate_status_disabled: '禁用',
         auth_candidate_enabled: '已启用 auth 候选自动轮换：{value}',

package/docs/user-manual.md

@@ -230,7 +230,7 @@ Later commands are sorted by recent usage. Plain text, photos, and files continu
 
 ### 3.2 `/status`, `/account`, `/quota`, `/update`
 
-- `/status`: FoxClaw, app-server, current thread binding, model, access, and Codex usage summary.
+- `/status`: FoxClaw, app-server, current thread binding, model, access, and Codex usage summary. Local session, token, and visible-reply-throughput metrics use a background-generated historical snapshot instead of scanning large logs during the request; throughput is computed end-to-end for completed turns, excluding reasoning tokens while including waiting and tool execution time.
 - `/account`: current Codex account.
 - `/quota`: Codex usage and quota window.
 - `/update`: upgrade FoxClaw, run checks, and restart the service; it refuses while a turn, approval, or question is active, then reports the result after restart.
@@ -387,7 +387,7 @@ If the login is cancelled or fails, FoxClaw tries to restore the previous auth t
 
 ### 6.3 The `/auth` Panel
 
-`/auth` lists candidate accounts, the current account, and the auth directory. It also provides buttons for switching, disabling, login, and reload.
+`/auth` lists candidate accounts, the current account, and the auth directory. It also provides buttons for switching, disabling, login, and reload. The `5h|7d` numbers before each filename are the last recorded remaining percentages for the two quota windows; the current auth is refreshed when the panel opens, while other candidates are not switched merely to query quota.
 
 Approximation:
 
@@ -396,16 +396,17 @@ Codex auth
 Current: auth.json_personal
 Auth dir: /home/alice/.codex
 Candidates: 2
-1. auth.json_personal * [enabled]
-2. auth.json_team [enabled]
+Quota remaining: 5h|7d|auth
+1. 20|25|auth.json_personal * [enabled]
+2. --|--|auth.json_team [enabled]
 
-[✅ auth.json_personal] [✅]
-[🔐 auth.json_team]     [✅]
+[✅ 20|25|auth.json_personal] [✅]
+[🔐 --|--|auth.json_team]     [✅]
 [🛡️ Access]             [🔑 Login]
 [🔄 Reload auth]
 ```
 
-The right-side `✅` / `⏸️` button shows the current state. Tapping it toggles enabled/disabled, and the refreshed list shows the new state.
+The right-side `✅` / `⏸️` button shows the current state. Tapping it toggles enabled/disabled, and the refreshed list shows the new state. `--|--` means no quota snapshot has been observed for that candidate yet.
 
 Equivalent commands:
 

package/docs/zh/user-manual.md

@@ -230,7 +230,7 @@ TG_ALLOWED_TOPIC_ID=42
 
 ### 3.2 `/status`、`/account`、`/quota`、`/update`
 
-- `/status`：查看 FoxClaw、app-server、当前绑定线程、模型、权限和 Codex 用量摘要。
+- `/status`：查看 FoxClaw、app-server、当前绑定线程、模型、权限和 Codex 用量摘要。本地 session/Token/可见答复吞吐使用后台生成的历史快照，避免状态查询现场扫描大量日志；答复吞吐按完成轮次端到端耗时计算，排除推理 token，但包含等待与工具执行时间。
 - `/account`：查看当前 Codex 登录账号。
 - `/quota`：查看 Codex 用量和额度窗口。
 - `/update`：升级 FoxClaw、自检并重启服务；当前有运行中回复、审批或待确认问题时会拒绝执行，重启后会回报结果。
@@ -387,7 +387,7 @@ cp -L ~/.codex/auth.json ~/.codex/auth.json_personal
 
 ### 6.3 `/auth` 面板
 
-`/auth` 会列出候选账号、当前账号和 auth 目录，并提供按钮切换、禁用、登录和重载。
+`/auth` 会列出候选账号、当前账号和 auth 目录，并提供按钮切换、禁用、登录和重载。每个候选名前的 `5h|7d` 数字表示上次记录到的两个额度窗口剩余百分比；当前 auth 会在打开面板时刷新，其他候选不会为了查询额度被自动切换。
 
 示意：
 
@@ -396,16 +396,17 @@ Codex auth
 Current: auth.json_personal
 Auth dir: /home/alice/.codex
 Candidates: 2
-1. auth.json_personal * [enabled]
-2. auth.json_team [enabled]
+额度剩余：5h|7d|auth
+1. 20|25|auth.json_personal * [enabled]
+2. --|--|auth.json_team [enabled]
 
-[✅ auth.json_personal] [✅]
-[🔐 auth.json_team]     [✅]
+[✅ 20|25|auth.json_personal] [✅]
+[🔐 --|--|auth.json_team]     [✅]
 [🛡️ Access]             [🔑 设备登录]
 [🔄 Reload auth]
 ```
 
-右侧 `✅` / `⏸️` 表示当前状态。点一下会切换启用/禁用，列表刷新后图标会随状态变化。
+右侧 `✅` / `⏸️` 表示当前状态。点一下会切换启用/禁用，列表刷新后图标会随状态变化。`--|--` 表示该候选还没有额度历史快照。
 
 命令等价用法：
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.3.15",
+  "version": "0.3.18",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",

package/skills/foxclaw/SKILL.md

@@ -190,10 +190,12 @@ Use this checklist when the user asks for standard closing actions, release wrap
    - If `doctor` fails only because `DEFAULT_CWD` is missing, report that separately; do not treat it as evidence that the service update failed.
 7. Publish to npm when requested:
    - Prefer GitHub Actions trusted publishing via `.github/workflows/publish.yml`: bump and commit the package version, push `main`, then push a matching `v<version>` tag. The tag version must match `package.json`.
+   - Treat `workflow_dispatch` only as a retry path from an existing matching release tag; do not manually run publishing from `main`.
    - Configure npmjs.com trusted publishing for `foxden-app/foxclaw` and workflow `publish.yml`; do not store npm tokens if OIDC trusted publishing is available.
    - Temporary fallback: store an npm automation/bypass-2FA token as the GitHub Actions secret `NPM_TOKEN`. Never print the token or commit it.
    - Check `npm whoami` and `npm view @foxden-app/foxclaw version`.
    - If the target version is already published, bump with `npm version patch --no-git-tag-version` before validation and commit.
+   - If a workflow fails before `npm publish`, inspect that failed GitHub Actions step before attributing it to npm trusted publishing.
    - Manual fallback only: run `BROWSER=true npm publish` in a TTY.
    - If npm returns `ENEEDAUTH`, report that npm publish is blocked by registry login and leave the package unreported as published.
    - Never print npm tokens or `.npmrc` auth values.

package/skills/npm-publish/SKILL.md

@@ -73,6 +73,8 @@ Use this path when the repo has `.github/workflows/publish.yml` and npmjs.com ha
    npm view <package-name> version
    ```
 
+If the workflow provides `workflow_dispatch` as a recovery path, dispatch it only from an existing release tag whose version matches `package.json`. Do not dispatch publishing from a branch containing an unpublished version unless the workflow explicitly resolves and validates a release tag.
+
 Do not store or print npm tokens when trusted publishing is available. If trusted publishing is not configured on npmjs.com, the workflow can use a GitHub Actions secret named `NPM_TOKEN` as a temporary fallback. Store only automation/bypass-2FA tokens there, never paste tokens in chat or commit them.
 
 ### Manual Publish
@@ -124,4 +126,5 @@ Press ENTER to open in the browser...
 - If `xdg-open` fails because the environment has no browser, rerun with `BROWSER=true npm publish`.
 - If the auth link expires or the publish process exits, rerun `BROWSER=true npm publish` to generate a new link.
 - If the user provides a classic authenticator OTP instead of using the web link, publish can be retried with `npm publish --otp <code>`, but prefer web auth when the user asks for a clickable confirmation link.
+- If a GitHub Actions release fails before the `npm publish` step, such as during checkout or action download authentication, do not diagnose it as a trusted publishing rejection. Inspect the failed step and GitHub Actions status first.
 - Never print npm tokens or `.npmrc` auth values.