@foxden-app/foxclaw 0.3.14 → 0.3.17

package/dist/codex_app/local_usage.d.ts

@@ -14,6 +14,10 @@ export interface CodexLocalUsageStats {
     outputSpeed: CodexLocalOutputSpeedStats;
     latestSessionMtimeMs: number | null;
 }
+export interface CodexLocalUsageSnapshot {
+    computedAtMs: number;
+    stats: CodexLocalUsageStats;
+}
 export interface CodexLocalOutputSpeedStats {
     samples: number;
     outputTokens: number;
@@ -22,3 +26,5 @@ export interface CodexLocalOutputSpeedStats {
     latestSampleAtMs: number | null;
 }
 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

@@ -37,6 +37,24 @@ export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
         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');
 }
@@ -128,6 +146,37 @@ function emptyOutputSpeedStats() {
         latestSampleAtMs: null,
     };
 }
+function isCodexLocalUsageStats(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const stats = value;
+    const totals = stats.totals;
+    const speed = stats.outputSpeed;
+    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(speed)
+        && isFiniteNumber(speed?.samples)
+        && isFiniteNumber(speed?.outputTokens)
+        && isFiniteNumber(speed?.seconds)
+        && isNullableFiniteNumber(speed?.latestTokensPerSecond)
+        && isNullableFiniteNumber(speed?.latestSampleAtMs)
+        && 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');
     const outputTokens = numberField(usage, 'output_tokens', 'outputTokens');

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;
@@ -266,6 +270,13 @@ export declare class BridgeSessionCore {
     private formatCodexLocalOutputSpeedStatusLines;
     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 [];
             }
@@ -4523,6 +4549,9 @@ export class BridgeSessionCore {
                     reasoning: formatTokenCount(stats.totals.reasoningOutputTokens),
                 }),
                 ...this.formatCodexLocalOutputSpeedStatusLines(locale, stats),
+                t(locale, 'status_codex_local_snapshot_at', {
+                    value: formatLocalTimestamp(snapshot.computedAtMs / 1000),
+                }),
             ];
         }
         catch (error) {
@@ -4554,13 +4583,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 +7142,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 +7242,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 +7260,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 +7797,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_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_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_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_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/dist/main.js

@@ -9,7 +9,7 @@ import { APP_HOME, DEFAULT_ENV_PATH, DEFAULT_LOG_PATH, DEFAULT_STATUS_PATH, getL
 import { acquireProcessLock, LockHeldError } from './lock.js';
 import { readRuntimeStatus, writeRuntimeStatus } from './runtime.js';
 import { refreshFoxclawExecStartDropIns, removeFoxclawExecStartDropIns } from './systemd.js';
-import { createSelfUpdateRuntime, performSelfUpdate } from './update.js';
+import { createSelfUpdateRuntime, inferPnpmHomeFromEntryPoint, performSelfUpdate } from './update.js';
 const rawCommand = process.argv[2];
 const command = rawCommand || 'serve';
 loadEnv();
@@ -776,9 +776,17 @@ function stopLaunchd() {
     console.log(`Stopped ${plist}`);
 }
 function buildServicePath(nodeDir) {
+    const pnpmPath = resolveCommand('pnpm');
+    const inferredPnpmHome = inferPnpmHomeFromEntryPoint(entryPoint) || '';
+    const configuredPnpmHome = process.env.PNPM_HOME?.trim() || '';
     const parts = [
         path.join(process.env.HOME || '', '.local', 'bin'),
         nodeDir,
+        inferredPnpmHome,
+        inferredPnpmHome ? path.join(inferredPnpmHome, 'bin') : '',
+        configuredPnpmHome,
+        configuredPnpmHome ? path.join(configuredPnpmHome, 'bin') : '',
+        pnpmPath ? path.dirname(pnpmPath) : '',
         '/usr/local/sbin',
         '/usr/local/bin',
         '/usr/sbin',

package/dist/update.d.ts

@@ -41,7 +41,8 @@ export interface SelfUpdateOutcome {
     error: string | null;
 }
 export declare function selfUpdateStatusPath(statusPath: string): string;
-export declare function resolveSelfUpdateInstaller(entryPoint: string, nodePath?: string, exists?: (target: string) => boolean): SelfUpdateInstaller;
+export declare function inferPnpmHomeFromEntryPoint(entryPoint: string): string | null;
+export declare function resolveSelfUpdateInstaller(entryPoint: string, nodePath?: string, exists?: (target: string) => boolean, env?: NodeJS.ProcessEnv): SelfUpdateInstaller;
 export declare function readSelfUpdateStatus(statusFile: string): SelfUpdateStatus | null;
 export declare function writeSelfUpdateStatus(statusFile: string, status: SelfUpdateStatus): void;
 export declare function createSelfUpdateRuntime(options: CreateSelfUpdateRuntimeOptions): SelfUpdateRuntime;

package/dist/update.js

@@ -7,21 +7,42 @@ const UPDATE_STATUS_FILENAME = 'self-update.json';
 export function selfUpdateStatusPath(statusPath) {
     return path.join(path.dirname(statusPath), UPDATE_STATUS_FILENAME);
 }
-export function resolveSelfUpdateInstaller(entryPoint, nodePath = process.execPath, exists = fs.existsSync) {
+export function inferPnpmHomeFromEntryPoint(entryPoint) {
     const normalizedEntryPoint = entryPoint.replace(/\\/g, '/');
     const globalMarker = '/global/';
     const globalIndex = normalizedEntryPoint.indexOf(globalMarker);
-    if (globalIndex > 0 && normalizedEntryPoint.includes('/.pnpm/')) {
-        const pnpmHome = normalizedEntryPoint.slice(0, globalIndex);
-        const pnpmCommand = path.join(pnpmHome, process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm');
-        if (!exists(pnpmCommand)) {
-            throw new Error(`Current installation is managed by pnpm, but pnpm was not found at ${pnpmCommand}.`);
+    if (globalIndex <= 0 || !normalizedEntryPoint.includes('/.pnpm/')) {
+        return null;
+    }
+    return normalizedEntryPoint.slice(0, globalIndex);
+}
+export function resolveSelfUpdateInstaller(entryPoint, nodePath = process.execPath, exists = fs.existsSync, env = process.env) {
+    const pnpmHome = inferPnpmHomeFromEntryPoint(entryPoint);
+    if (pnpmHome) {
+        const commandName = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
+        const candidates = executableCandidates(commandName, nodePath, env, [
+            path.join(pnpmHome, commandName),
+            path.join(pnpmHome, 'bin', commandName),
+            env.PNPM_HOME?.trim() ? path.join(env.PNPM_HOME.trim(), commandName) : '',
+            env.PNPM_HOME?.trim() ? path.join(env.PNPM_HOME.trim(), 'bin', commandName) : '',
+        ]);
+        const pnpmCommand = candidates.find((candidate) => exists(candidate));
+        if (pnpmCommand) {
+            return {
+                manager: 'pnpm',
+                command: pnpmCommand,
+                installArgs: ['add', '--global', PACKAGE_SPEC],
+                rootArgs: ['root', '--global'],
+            };
         }
+        const npmCommandName = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const npmCommand = executableCandidates(npmCommandName, nodePath, env)
+            .find((candidate) => exists(candidate)) ?? npmCommandName;
         return {
             manager: 'pnpm',
-            command: pnpmCommand,
-            installArgs: ['add', '--global', PACKAGE_SPEC],
-            rootArgs: ['root', '--global'],
+            command: npmCommand,
+            installArgs: ['exec', '--yes', '--package=pnpm@latest', '--', 'pnpm', 'add', '--global', PACKAGE_SPEC],
+            rootArgs: ['exec', '--yes', '--package=pnpm@latest', '--', 'pnpm', 'root', '--global'],
         };
     }
     const adjacentNpm = path.join(path.dirname(nodePath), process.platform === 'win32' ? 'npm.cmd' : 'npm');
@@ -117,13 +138,14 @@ export function performSelfUpdate(options) {
     const env = options.env ?? process.env;
     let toVersion = null;
     try {
-        const installer = resolveSelfUpdateInstaller(options.entryPoint, options.nodePath);
+        const installer = resolveSelfUpdateInstaller(options.entryPoint, options.nodePath, fs.existsSync, env);
+        const installerEnv = buildInstallerEnv(options.entryPoint, installer, env);
         console.log(`[UPDATE] Installing ${PACKAGE_SPEC} with ${installer.manager}...`);
-        runInherited(installer.command, installer.installArgs, env);
-        const updatedEntryPoint = resolveUpdatedEntryPoint(installer, env);
+        runInherited(installer.command, installer.installArgs, installerEnv);
+        const updatedEntryPoint = resolveUpdatedEntryPoint(installer, installerEnv);
         toVersion = readInstalledPackageVersion(updatedEntryPoint);
         console.log('[UPDATE] Running checks and restarting the FoxClaw service...');
-        runInherited(options.nodePath, [updatedEntryPoint, 'start'], env);
+        runInherited(options.nodePath, [updatedEntryPoint, 'start'], installerEnv);
         completeNotification(options.notificationFile, 'succeeded', toVersion, null);
         console.log(`[OK] FoxClaw updated and restarted: ${options.version} -> ${toVersion}`);
         return {
@@ -145,6 +167,32 @@ export function performSelfUpdate(options) {
         };
     }
 }
+function executableCandidates(commandName, nodePath, env, preferred = []) {
+    return [
+        ...preferred,
+        path.join(path.dirname(nodePath), commandName),
+        ...(env.PATH || '').split(path.delimiter).filter(Boolean).map((dir) => path.join(dir, commandName)),
+    ].filter((candidate, index, all) => candidate && all.indexOf(candidate) === index);
+}
+function buildInstallerEnv(entryPoint, installer, env) {
+    const pnpmHome = installer.manager === 'pnpm' ? inferPnpmHomeFromEntryPoint(entryPoint) : null;
+    if (!pnpmHome) {
+        return env;
+    }
+    const configuredPnpmHome = env.PNPM_HOME?.trim() || pnpmHome;
+    const pathEntries = [
+        configuredPnpmHome,
+        path.join(configuredPnpmHome, 'bin'),
+        pnpmHome,
+        path.join(pnpmHome, 'bin'),
+        ...(env.PATH || '').split(path.delimiter).filter(Boolean),
+    ];
+    return {
+        ...env,
+        PNPM_HOME: configuredPnpmHome,
+        PATH: pathEntries.filter((entry, index, all) => all.indexOf(entry) === index).join(path.delimiter),
+    };
+}
 function runInherited(command, args, env) {
     const result = spawnSync(command, args, { stdio: 'inherit', env });
     if (result.error) {

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 output-speed metrics use a background-generated historical snapshot instead of scanning large logs during the request.
 - `/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/输出速度使用后台生成的历史快照，避免状态查询现场扫描大量日志。
 - `/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.14",
+  "version": "0.3.17",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",