qwenproxy-cli 1.5.3 → 1.6.1

package/src/routes/chat/streaming.ts

@@ -18,6 +18,7 @@ import {
   setToolCapNotice,
 } from "../../services/qwen.ts";
 import { acquireUpstreamStream } from "./account.ts";
+import { loadAccounts } from "../../core/accounts.ts";
 import { markAccountRateLimited, computeQuotaCooldownMs } from "../../core/account-manager.ts";
 import {
   clearTemporaryBusy,
@@ -60,6 +61,7 @@ import {
   logTokenEstimationSample,
   type TokenEstimationContext,
 } from "../../services/token-estimation-metrics.ts";
+import { recordTurnUsage } from "../../core/daily-usage.ts";
 import {
   enrichUsageWithContextMeter,
   getContextMeterHeaders,
@@ -781,6 +783,10 @@ export async function processNonStreamingResponse(
       context: currentTokenEstimationContext,
     });
 
+    if (activeAccountId && usage) {
+      recordTurnUsage(activeAccountId, usage, body.model);
+    }
+
     // The response was fully processed: persist the next-turn parent.
     if (pendingParentId) {
       rememberParent(pendingParentId);
@@ -900,6 +906,9 @@ export async function processStreamingResponse(
     let activeReader: ReadableStreamDefaultReader<Uint8Array> | null = null;
     let invalidInputSameAccountRetries = 0;
     let chatInProgressSameAccountRetries = 0;
+    let antiBotSameAccountRetries = 0;
+    const totalConfiguredAccounts = loadAccounts().length;
+    let quotaRotationsLeft = Math.min(Math.max(1, totalConfiguredAccounts - 1), 6);
     // Set when the terminal [DONE] reached the client. The `| recovered`
     // suffix on Stream done must only appear for attempts that COMPLETED after
     // a mid-stream retry, not for failed attempts that consumed retries.
@@ -1372,7 +1381,6 @@ export async function processStreamingResponse(
           !normalizedError ||
           (clientDisconnected && !gracePending) ||
           c.req.raw.signal.aborted ||
-          retryContext.retriesLeft <= 0 ||
           !midStreamRetry ||
           emittedModelOutput
         ) {
@@ -1384,6 +1392,19 @@ export async function processStreamingResponse(
         });
         if (!policy.retryable) return false;
 
+        const isRealQuotaError =
+          policy.reason === "quota_or_rate_limit" &&
+          (policy.accountCooldownReason === "RateLimited" ||
+            policy.accountCooldownReason === "QuotaExceeded");
+
+        const hasBudget = isRealQuotaError
+          ? quotaRotationsLeft > 0
+          : retryContext.retriesLeft > 0;
+
+        if (!hasBudget) {
+          return false;
+        }
+
         // Full recovery decision — same rationale as the create-path policy
         // log: the failure line shows the error, this line shows WHY the
         // chosen action (retry same / switch / new chat / cooldown) was taken.
@@ -1397,9 +1418,13 @@ export async function processStreamingResponse(
           invalidateLogicalThreadParent(midStreamRetry.sessionId);
         }
 
-        retryContext.retriesLeft--;
+        if (isRealQuotaError) {
+          quotaRotationsLeft--;
+        } else {
+          retryContext.retriesLeft--;
+        }
         console.warn(
-          `🔄 [Chat] Stream recovery | account=${currentAccountId} | reason=${policy.reason} | error=${normalizedError.message.substring(0, 150)} | retries_left=${retryContext.retriesLeft}`,
+          `🔄 [Chat] Stream recovery | account=${currentAccountId} | reason=${policy.reason} | error=${normalizedError.message.substring(0, 150)} | retries_left=${isRealQuotaError ? quotaRotationsLeft : retryContext.retriesLeft}`,
         );
 
         const retryInvalidInputOnSameAccount =
@@ -1432,9 +1457,19 @@ export async function processStreamingResponse(
           );
           return false;
         }
-        const switchAccount =
+        let switchAccount =
           policy.switchAccount && !retryInvalidInputOnSameAccount;
 
+        if (policy.reason === "anti_bot") {
+          if (antiBotSameAccountRetries === 0) {
+            antiBotSameAccountRetries++;
+            switchAccount = false;
+          } else {
+            switchAccount = true;
+            markAccountRateLimited(currentAccountId, 60_000, "AntiBotWafChallenge");
+          }
+        }
+
         if (
           switchAccount &&
           (policy.accountCooldownMs ?? 0) > 0
@@ -1452,6 +1487,35 @@ export async function processStreamingResponse(
             .catch(() => {});
         }
 
+        // Preventative stop: signal Qwen to stop generating on the backend before switching
+        if (currentUiSessionId && targetResponseId) {
+          const streamData = getStream(completionId);
+          const stopHeaders = streamData?.headers;
+          if (stopHeaders?.cookie && stopHeaders["user-agent"]) {
+            void requestQwenTextInBrowser(
+              currentAccountId,
+              "POST",
+              `/api/v2/chat/completions/stop?chat_id=${encodeURIComponent(currentUiSessionId)}`,
+              buildQwenRequestHeaders({
+                cookie: stopHeaders.cookie,
+                userAgent: stopHeaders["user-agent"],
+                bxUa: stopHeaders["bx-ua"],
+                bxUmidtoken: stopHeaders["bx-umidtoken"],
+                bxV: stopHeaders["bx-v"],
+                chatSessionId: currentUiSessionId,
+              }),
+              JSON.stringify({
+                chat_id: currentUiSessionId,
+                response_id: targetResponseId,
+              }),
+              {
+                referrer: qwenUrl(`/c/${encodeURIComponent(currentUiSessionId)}`),
+                noMutexRecovery: true,
+              },
+            ).catch(() => undefined);
+          }
+        }
+
         retryContext.releaseAccountLease?.();
         retryContext.releaseAccountLease = null;
         await reader.cancel().catch(() => undefined);
@@ -2566,6 +2630,10 @@ export async function processStreamingResponse(
           mode: "stream",
           context: currentTokenEstimationContext,
         });
+
+        if (activeAccountId && usage) {
+          recordTurnUsage(activeAccountId, usage, body.model);
+        }
       } else {
         if (isToolcallDebugEnabled()) {
           logger.debug(

package/src/services/captcha-coordinator.ts

@@ -21,6 +21,11 @@ const CHALLENGE_PATH_MARKER = "_____tmd_____";
  */
 const FAILED_RECOVERY_BACKOFF_MS = 30_000;
 const lastFailedRecoveryAt = new Map<string, number>();
+const activeCaptchaRecoveries = new Set<string>();
+
+export function isCaptchaRecoveryActive(accountId: string): boolean {
+  return activeCaptchaRecoveries.has(accountId);
+}
 
 async function gotoBestEffort(page: Page, url: string): Promise<void> {
   // A WAF-blocked navigation can time out while still having rendered the
@@ -105,13 +110,6 @@ export async function recoverBaxiaCaptcha(
 
   metrics.increment("captcha.challenges.detected", 1, { solver });
 
-  const challengeUrl = options.challengeBody
-    ? extractBaxiaChallengeUrl(options.challengeBody, config.qwen.baseUrl)
-    : null;
-
-  // The slider itself waits up to 5s for each attempt. Keep the page
-  // operation alive for the full bounded solver budget so a slow challenge
-  // cannot be mistaken for a stuck browser. Do not clamp to timeouts.page.
   // Two navigations (open the challenge, return to the chat page) are part of
   // the recovery, so their budget belongs in the same total.
   const solverOperationTimeoutMs = Math.max(
@@ -122,6 +120,11 @@ export async function recoverBaxiaCaptcha(
       2 * CHALLENGE_NAVIGATION_TIMEOUT_MS,
   );
 
+  const challengeUrl = options.challengeBody
+    ? extractBaxiaChallengeUrl(options.challengeBody, config.qwen.baseUrl)
+    : null;
+
+  activeCaptchaRecoveries.add(accountId);
   try {
     // recoverOnTimeout: false ensures that if the captcha solve times out,
     // withAccountPage does NOT destructively kill the browser context, which
@@ -160,5 +163,7 @@ export async function recoverBaxiaCaptcha(
       detail,
     });
     return false;
+  } finally {
+    activeCaptchaRecoveries.delete(accountId);
   }
 }

package/src/services/chat-cleanup.ts

@@ -108,6 +108,11 @@ export async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false):
           `❌ [DeleteChats] [${currentIdx}/${totalCount}] Falha ao apagar conversas de ${maskEmail(account.email)}:`,
           error instanceof Error ? error.message : String(error),
         );
+      } finally {
+        if (!keepBrowserOpen) {
+          const { closePlaywrightForAccount } = await import("./playwright.ts");
+          await closePlaywrightForAccount(account.id).catch(() => {});
+        }
       }
     }
   } finally {

package/src/services/playwright.ts

@@ -287,7 +287,7 @@ export function loadStorageState(accountId: string): string | undefined {
 export async function saveStorageState(
   context: BrowserContext,
   accountId: string,
-  timeoutMs = 5_000,
+  timeoutMs = 10_000,
 ): Promise<void> {
   try {
     const stateFile = getStorageStatePath(accountId);
@@ -295,8 +295,12 @@ export async function saveStorageState(
     if (!fs.existsSync(dir)) {
       fs.mkdirSync(dir, { recursive: true });
     }
+    const rawPromise = context.storageState({ path: stateFile }).catch(() => {
+      // Swallowed on context teardown to avoid unhandled rejection if withTimeout already fired
+      return undefined as any;
+    });
     await withTimeout(
-      context.storageState({ path: stateFile }),
+      rawPromise,
       timeoutMs,
       `storageState timed out after ${timeoutMs}ms`,
     );
@@ -512,6 +516,7 @@ const COOKIE_CACHE_TTL = 15 * 60 * 1000; // 15 minutes
 const cookieCaches = new Map<string, { cookie: string; timestamp: number }>();
 const lastAccountActivity = new Map<string, number>();
 const lastKeepAliveNavigation = new Map<string, number>();
+const lastProactiveTokenRefresh = new Map<string, number>();
 const profileResetQueue = new Map<string, Promise<void>>();
 let profileResetChain: Promise<void> = Promise.resolve();
 let closingAllPlaywright = false;
@@ -1228,6 +1233,11 @@ export async function getBasicHeaders(accountId: string): Promise<{
     throw new Error(`Playwright not initialized for account: ${accountId}`);
   }
 
+  const inFlightInit = inFlightAccountInits.get(accountId);
+  if (inFlightInit) {
+    await inFlightInit.catch(() => {});
+  }
+
   // Acquire mutex to prevent concurrent browser access
   const release = await acquireAccountMutex(
     accountId,
@@ -3068,6 +3078,12 @@ export async function captureQwenHeaders(
         const { saveAuthSession } = await import("../core/database.ts");
         const { parseJwtExpiry } = await import("../utils/jwt.ts");
         const tokenExpiry = parseJwtExpiry(capturedHeaders.cookie);
+        let rTok: string | undefined;
+        try {
+          rTok =
+            (await page.evaluate(() => localStorage.getItem("refresh_token") || "")).trim() ||
+            undefined;
+        } catch {}
         saveAuthSession(accountId, {
           cookie: capturedHeaders.cookie,
           userAgent: capturedHeaders["user-agent"],
@@ -3079,6 +3095,7 @@ export async function captureQwenHeaders(
           secChUaPlatform: capturedHeaders["sec-ch-ua-platform"],
           version: capturedHeaders["version"],
           tokenExpiresAt: tokenExpiry || undefined,
+          refreshToken: rTok,
           capturedAt: Date.now(),
         });
       } catch {}
@@ -3121,40 +3138,61 @@ export async function captureQwenHeaders(
       const isAuthUrl = currentUrl.includes("/auth") || currentUrl.includes("/login");
       const isSuspectedGuest = isAuthUrl || (attempt >= 2 && !(await isPageLoggedIn(page, 5000)));
       if (isSuspectedGuest) {
-        const { getAccountCredentials } = await import("../core/accounts.ts");
-        const creds = getAccountCredentials(accountId);
-        if (creds && creds.email && creds.password) {
-          console.warn(
-            `⚠️  [Playwright] Session expired or guest state detected during header capture for ${accountId}; re-authenticating...`,
+        // Try fast silent token refresh first using the 30-day refresh_token in-page (~200ms)
+        const silentRefresh = await refreshAccountToken(accountId);
+        if (silentRefresh.success) {
+          console.log(
+            `⚡ [Playwright] Token refreshed silently during header capture for ${accountId}`,
           );
-          armOverallDeadline();
-          const ok = await loginToQwen(accountId, creds.email, creds.password);
-          if (ok) {
-            // Re-login navigated; load the chat page and wait for hydration so
-            // the check below probes a live authenticated chat page.
+          if (isAuthUrl) {
             await page.goto(qwenUrl("/"), {
               waitUntil: "domcontentloaded",
               timeout: Math.min(config.timeouts.navigation, timeoutMs),
             });
-            await sleep(2000);
+            await sleep(1500);
+          }
+          if (await isPageLoggedIn(page, 5000)) {
+            armOverallDeadline();
           }
-          if (!ok || !(await isPageLoggedIn(page, 6000))) {
+        }
+
+        const stillSuspected = !silentRefresh.success || !(await isPageLoggedIn(page, 2000));
+        if (stillSuspected) {
+          const { getAccountCredentials } = await import("../core/accounts.ts");
+          const creds = getAccountCredentials(accountId);
+          if (creds && creds.email && creds.password) {
+            console.warn(
+              `⚠️  [Playwright] Session expired or guest state detected during header capture for ${accountId}; re-authenticating...`,
+            );
+            armOverallDeadline();
+            const ok = await loginToQwen(accountId, creds.email, creds.password);
+            if (ok) {
+              // Re-login navigated; load the chat page and wait for hydration so
+              // the check below probes a live authenticated chat page.
+              await page.goto(qwenUrl("/"), {
+                waitUntil: "domcontentloaded",
+                timeout: Math.min(config.timeouts.navigation, timeoutMs),
+              });
+              await sleep(2000);
+            }
+            if (!ok || !(await isPageLoggedIn(page, 6000))) {
+              settle(
+                new Error(
+                  `Header capture failed for ${accountId}: re-login after session expiry did not succeed`,
+                ),
+              );
+              return;
+            }
+            armOverallDeadline();
+            if (settled || page.isClosed()) return;
+          } else {
             settle(
               new Error(
-                `Header capture failed for ${accountId}: re-login after session expiry did not succeed`,
+                `Header capture failed for ${accountId}: session expired and no credentials available for re-login (run 'qpx login')`,
               ),
             );
             return;
           }
-          armOverallDeadline();
-          if (settled || page.isClosed()) return;
-        } else {
-          settle(
-            new Error(
-              `Header capture failed for ${accountId}: session expired and no credentials available for re-login (run 'qpx login')`,
-            ),
-          );
-          return;
         }
       }
 
@@ -3593,7 +3631,15 @@ async function refreshHeadersInternal(
             `[Playwright] Navigation check failed during refresh for ${accountId}:`,
             (navErr as Error).message,
           );
-          await executeReauth();
+          if (await isPageLoggedIn(page, 3000)) {
+            // Still authenticated despite navigation timeout; do not escalate to slow form re-auth
+          } else {
+            // Try silent in-page token refresh before executing full form login
+            const refreshed = await refreshAccountToken(accountId);
+            if (!refreshed.success) {
+              await executeReauth();
+            }
+          }
         }
       }
 
@@ -3610,6 +3656,12 @@ async function refreshHeadersInternal(
             const { saveAuthSession } = await import("../core/database.ts");
             const tokenCookie = liveCookies.find((c) => c.name === "token");
             const exp = tokenCookie ? parseJwtExpiry(tokenCookie.value) : undefined;
+            let rTok: string | undefined;
+            try {
+              rTok =
+                (await page.evaluate(() => localStorage.getItem("refresh_token") || "")).trim() ||
+                undefined;
+            } catch {}
             saveAuthSession(accountId, {
               cookie: cookieStr,
               userAgent: cache.headers["user-agent"] || "",
@@ -3621,6 +3673,7 @@ async function refreshHeadersInternal(
               secChUaPlatform: cache.headers["sec-ch-ua-platform"] || undefined,
               version: cache.headers["version"] || undefined,
               tokenExpiresAt: exp || undefined,
+              refreshToken: rTok,
               capturedAt: Date.now(),
             });
           } catch {}
@@ -4169,8 +4222,10 @@ export async function keepAlivePlaywrightAccount(
     const currentUrl = page.url();
 
     // Proactive session check: if token expires within 5 minutes, refresh in-page silently using refreshAccountToken
+    const lastRefreshAttempt = lastProactiveTokenRefresh.get(accountId) ?? 0;
     const cookie = await getCookies(accountId);
-    if (cookie && isTokenExpiringSoon(cookie, 5)) {
+    if (cookie && isTokenExpiringSoon(cookie, 5) && now - lastRefreshAttempt > 60_000) {
+      lastProactiveTokenRefresh.set(accountId, now);
       console.log(
         `💓 [SessionKeeper] Account ${accountId} access token expiring soon (<5m); silently refreshing...`,
       );
@@ -4233,6 +4288,7 @@ function cleanupPlaywrightAccountState(accountId: string): void {
   cookieCaches.delete(accountId);
   lastAccountActivity.delete(accountId);
   lastKeepAliveNavigation.delete(accountId);
+  lastProactiveTokenRefresh.delete(accountId);
   clearFingerprintCache(accountId);
   // The account's context died/closed — its captured headers are stale or the
   // page is gone, so it must not be selected by the rotation gate until a

package/src/services/qwen.ts

@@ -1540,6 +1540,12 @@ async function createQwenBrowserResponse(
   }
 }
 
+const inFlightPersonalizationSyncs = new Map<string, Promise<boolean>>();
+
+export function getInFlightPersonalizationCount(): number {
+  return inFlightPersonalizationSyncs.size;
+}
+
 export async function syncQwenRequestPersonalization(
   instruction: string,
   accountId?: string,
@@ -1552,15 +1558,67 @@ export async function syncQwenRequestPersonalization(
     forceSync?: boolean;
   } = {},
 ): Promise<boolean> {
-  if (isAuthMockEnabled()) {
-    // Test hook: force the sync to report "not applied" so the fail-fast
-    // contract (personalization-required suite) is exercisable in mock mode.
-    if (process.env.TEST_PERSONALIZATION_SYNC_FAIL === "true") return false;
-    return true;
+  const cacheKey = accountId || "global";
+  const sent = textSize(instruction);
+  const syncHash = sent.hash ? `${sent.hash}:${QWEN_SAFE_SETTINGS_HASH}` : null;
+  const inFlightKey = `${cacheKey}:${syncHash || "empty"}`;
+
+  const existingInFlight = inFlightPersonalizationSyncs.get(inFlightKey);
+  if (existingInFlight) {
+    logger.debug("[Qwen] Personalization sync already in flight, sharing promise", {
+      accountId: cacheKey,
+    });
+    return existingInFlight;
   }
-  // instruction pode ser vazia para limpar personalization
 
-  const cacheKey = accountId || "global";
+  let syncPromise!: Promise<boolean>;
+  syncPromise = (async () => {
+    await Promise.resolve();
+    try {
+      if (isAuthMockEnabled()) {
+        const delay = parseInt(process.env.TEST_PERSONALIZATION_DELAY_MS || "0", 10);
+        if (delay > 0) {
+          await sleep(delay);
+        }
+        // Test hook: force the sync to report "not applied" so the fail-fast
+        // contract (personalization-required suite) is exercisable in mock mode.
+        if (process.env.TEST_PERSONALIZATION_SYNC_FAIL === "true") return false;
+        return true;
+      }
+      return await syncQwenRequestPersonalizationInternal(
+        instruction,
+        accountId,
+        metadata,
+        cacheKey,
+        sent,
+        syncHash,
+      );
+    } finally {
+      if (inFlightPersonalizationSyncs.get(inFlightKey) === syncPromise) {
+        inFlightPersonalizationSyncs.delete(inFlightKey);
+      }
+    }
+  })();
+
+  inFlightPersonalizationSyncs.set(inFlightKey, syncPromise);
+  return syncPromise;
+}
+
+async function syncQwenRequestPersonalizationInternal(
+  instruction: string,
+  accountId: string | undefined,
+  metadata: {
+    model?: string;
+    toolsCount?: number;
+    sessionId?: string | null;
+    promptChars?: number;
+    forceSync?: boolean;
+  },
+  cacheKey: string,
+  sent: ReturnType<typeof textSize>,
+  syncHash: string | null,
+): Promise<boolean> {
+  // instruction pode ser vazia para limpar personalization
 
   // Proactive token renewal: refresh BEFORE attempting personalization
   // to avoid 401 errors that waste time on retry
@@ -1584,8 +1642,6 @@ export async function syncQwenRequestPersonalization(
   let currentSettings: any = null;
   let payload = buildQwenSettingsUpdatePayload(currentSettings, instruction);
 
-  const sent = textSize(instruction);
-  const syncHash = sent.hash ? `${sent.hash}:${QWEN_SAFE_SETTINGS_HASH}` : null;
   const bypassCache = metadata.forceSync === true;
 
   // 1. Check memory cache (skipped on forceSync)

package/src/tui/proxy-client.ts

@@ -15,6 +15,10 @@ import { isPlaywrightInitialized } from "../services/playwright.ts";
 import { getAccountConcurrencySnapshot } from "../core/account-concurrency.ts";
 import { getRssUsageSnapshot } from "../core/memory-usage.ts";
 import { metrics } from "../core/metrics.ts";
+import {
+  getAllAccountsDailyUsage,
+  getPoolDailyUsageSummary,
+} from "../core/daily-usage.ts";
 import type { ProxyStatusSnapshot } from "./types.ts";
 
 export function maskAccountIdentifier(idOrEmail: string): string {
@@ -153,13 +157,18 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
     }
   } catch {}
 
-  // Attach concurrency to accounts
+  // Attach concurrency and daily usage to accounts
+  const dailyUsageMap = getAllAccountsDailyUsage();
   const accounts = cachedAccounts.map((acc) => {
     const concurrency = concurrencyMap.get(acc.id);
+    const daily = dailyUsageMap.get(acc.id);
     return {
       ...acc,
       activeStreams: concurrency?.active ?? 0,
       streamLimit: concurrency?.limit ?? config.concurrency.maxStreamsPerAccount,
+      dailyTokens: daily?.completionTokens ?? 0,
+      dailyUsagePercent: daily?.usagePercent ?? 0,
+      dailyTurns: daily?.turnsCount ?? 0,
     };
   });
   // RAM usage
@@ -220,6 +229,7 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
       cacheHitRatio,
       cacheBytesSaved,
     },
+    dailyUsage: getPoolDailyUsageSummary(cachedAccounts.map((a) => a.id)),
     accounts,
   };
 }

package/src/tui/types.ts

@@ -38,6 +38,14 @@ export interface ProxyStatusSnapshot {
     cacheHitRatio?: number;
     cacheBytesSaved?: number;
   };
+  dailyUsage?: {
+    poolUsagePercent: number;
+    totalPromptTokens: number;
+    totalCompletionTokens: number;
+    totalTokens: number;
+    totalTurns: number;
+    poolCapacityTokens: number;
+  };
   accounts: Array<{
     id: string;
     emailOrName: string;
@@ -50,5 +58,8 @@ export interface ProxyStatusSnapshot {
     isInitialized?: boolean;
     activeStreams?: number;
     streamLimit?: number;
+    dailyTokens?: number;
+    dailyUsagePercent?: number;
+    dailyTurns?: number;
   }>;
 }

package/src/tui/views/accounts-view.ts

@@ -19,6 +19,7 @@ import {
 } from "../../core/accounts.ts";
 import { ServerManager } from "../server-manager.ts";
 import { config } from "../../core/config.ts";
+import { renderProgressBar } from "./status-view.ts";
 export function formatCooldownReason(reason?: string | null, maxLen = 28): string {
   if (!reason) return theme.yellow("Cooldown ativo");
   if (
@@ -938,9 +939,11 @@ export class AccountsView implements TuiView {
     }
 
     // Left Panel: Accounts List Table
+    const showUsageCol = leftW >= 48;
+    const headerUsage = showUsageCol ? "Uso%  " : "";
     const leftContent: string[] = [
       "",
-      `  ${theme.dim("#   Conta                 Status")}`,
+      `  ${theme.dim(`#   Conta                 ${headerUsage}Status`)}`,
       `  ${theme.dim("───────────────────────────────────────")}`,
     ];
 
@@ -997,7 +1000,14 @@ export class AccountsView implements TuiView {
             : theme.muted(`○ Standby     `);
         }
 
-        const line = `${pointer}${num}${name}${status}`;
+        const usagePct = acc.dailyUsagePercent ?? 0;
+        const usagePctStr = showUsageCol
+          ? (usagePct > 0
+              ? (usagePct >= 80 ? theme.red(pad(`${usagePct}%`, 5)) : usagePct >= 40 ? theme.yellow(pad(`${usagePct}%`, 5)) : theme.cyan(pad(`${usagePct}%`, 5)))
+              : theme.dim(pad("0%", 5))) + " "
+          : "";
+
+        const line = `${pointer}${num}${name}${usagePctStr}${status}`;
         if (isHovered) {
           leftContent.push(theme.bgHover(line));
         } else if (isFocused) {
@@ -1046,6 +1056,13 @@ export class AccountsView implements TuiView {
       rightContent.push(`  ${theme.bold("Sistema ID:")} ${theme.muted(selected.id.slice(0, 14))}`);
       rightContent.push(`  ${theme.bold("Nível:")}      ${selected.priority}`);
 
+      const usagePct = selected.dailyUsagePercent ?? 0;
+      const usageTokens = selected.dailyTokens ?? 0;
+      const usageTurns = selected.dailyTurns ?? 0;
+      const usageColor = usagePct >= 80 ? theme.red : usagePct >= 40 ? theme.yellow : theme.cyan;
+      const usageBar = renderProgressBar(usagePct, 6, usageColor);
+      rightContent.push(`  ${theme.bold("Cota Hoje:")}  [${usageBar}] ${usageColor(`${usagePct}%`)} ${theme.dim(`(~${Math.round(usageTokens / 1000)}k / ${usageTurns} reqs)`)}`);
+
       const cdStatus = selected.onCooldown
         ? theme.yellow(`[!] Cooldown ${Math.round(selected.remainingCooldownMs / 60000)}m`)
         : theme.green(`${glyphs.check} Disponível`);