qwenproxy-cli 1.5.3 → 1.6.1

package/dist/index.js

@@ -150,6 +150,44 @@ var init_paths = __esm({
   }
 });
 
+// src/core/process-guard.ts
+function isPlaywrightAlreadyClosedMessage(message) {
+  if (!message) return false;
+  return message.includes("Target page, context or browser has been closed") || message.includes("Browser has been closed") || message.includes("Target closed") || message.includes("Target crashed") || message.includes("Page crashed") || message.includes("Assertion error") || message.includes("Cannot find parent object") || message.includes("Connection closed") || message.includes("session closed") || message.includes("Session closed") || message.includes("Network.setCacheDisabled") || message.includes("Protocol error") || message.includes("storageState timed out");
+}
+function isBenignTeardownError(error) {
+  if (!error) return false;
+  const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
+  return isPlaywrightAlreadyClosedMessage(message);
+}
+function installProcessTeardownGuards(label = "Process") {
+  if (guardsInstalled) return;
+  guardsInstalled = true;
+  process.on("uncaughtException", (error) => {
+    if (isBenignTeardownError(error)) {
+      const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown exception: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Uncaught Exception:`, error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isBenignTeardownError(reason)) {
+      const msg = reason instanceof Error ? reason.message : typeof reason === "object" && reason !== null && "message" in reason ? String(reason.message) : String(reason);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown rejection: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Unhandled Rejection:`, reason);
+  });
+}
+var guardsInstalled;
+var init_process_guard = __esm({
+  "src/core/process-guard.ts"() {
+    "use strict";
+    guardsInstalled = false;
+  }
+});
+
 // src/core/config.ts
 import fs2 from "node:fs";
 import dotenv from "dotenv";
@@ -289,11 +327,11 @@ var init_config = __esm({
       // nothing in this window is dead and should fail fast, retryable).
       QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("60000"),
       TOTAL_REQUEST_TIMEOUT: z.string().default("600000"),
-      // Mid-stream silence window for thinking models: 3 min with ZERO upstream
+      // Mid-stream silence window for thinking models: 5 min with ZERO upstream
       // bytes is a dead stream (WAF swallow / dropped connection) — fail fast and
       // let the retry policy rotate accounts. Flowing reasoning chunks RESET this
       // timer, so legitimate slow thinking is never cut; only total silence is.
-      REASONING_MODEL_TIMEOUT: z.string().default("180000"),
+      REASONING_MODEL_TIMEOUT: z.string().default("300000"),
       CACHE_TTL: z.string().default("3600"),
       RESPONSE_TTL: z.string().default("1800"),
       CACHE_COMPRESSION_ENABLED: z.string().default("true"),
@@ -1592,7 +1630,26 @@ function runMigrations(db2) {
       instruction_hash TEXT NOT NULL,
       updated_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
+
+    CREATE TABLE IF NOT EXISTS account_daily_usage (
+      account_id TEXT NOT NULL,
+      date_utc TEXT NOT NULL,
+      prompt_tokens INTEGER NOT NULL DEFAULT 0,
+      completion_tokens INTEGER NOT NULL DEFAULT 0,
+      weighted_tokens REAL NOT NULL DEFAULT 0,
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      turns_count INTEGER NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (account_id, date_utc)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_daily_usage_date ON account_daily_usage(date_utc);
   `);
+  try {
+    db2.exec(`ALTER TABLE account_daily_usage ADD COLUMN weighted_tokens REAL DEFAULT 0;`);
+  } catch (err) {
+    if (!isDuplicateColumnError(err)) throw err;
+  }
   try {
     db2.exec(
       `ALTER TABLE accounts ADD COLUMN cooldown_until INTEGER DEFAULT 0;`
@@ -1693,7 +1750,11 @@ function saveAuthSession(accountId, session) {
     ) VALUES (
       ?, ?, ?, ?, ?, ?,
       ?, ?, ?, ?,
-      ?, ?, ?, ?, datetime('now')
+      COALESCE(?, (SELECT user_id FROM qwen_auth_sessions WHERE account_id = ?)),
+      ?,
+      COALESCE(?, (SELECT refresh_token FROM qwen_auth_sessions WHERE account_id = ?)),
+      ?,
+      datetime('now')
     )
   `);
   stmt.run(
@@ -1708,8 +1769,10 @@ function saveAuthSession(accountId, session) {
     session.secChUaPlatform || null,
     session.version || null,
     session.userId || null,
+    accountId,
     session.tokenExpiresAt || null,
     session.refreshToken || null,
+    accountId,
     session.capturedAt ?? Date.now()
   );
 }
@@ -4235,6 +4298,8 @@ var init_clean_cache = __esm({
   "src/clean-cache.ts"() {
     "use strict";
     init_playwright();
+    init_process_guard();
+    installProcessTeardownGuards("CleanCache");
     isDirectRun = process.argv[1] && (process.argv[1].endsWith("clean-cache.ts") || process.argv[1].endsWith("clean-cache.js"));
     if (isDirectRun) {
       main().catch((err) => {
@@ -4459,15 +4524,18 @@ function loadStorageState(accountId) {
     return void 0;
   }
 }
-async function saveStorageState(context, accountId, timeoutMs = 5e3) {
+async function saveStorageState(context, accountId, timeoutMs = 1e4) {
   try {
     const stateFile = getStorageStatePath(accountId);
     const dir = path6.dirname(stateFile);
     if (!fs9.existsSync(dir)) {
       fs9.mkdirSync(dir, { recursive: true });
     }
+    const rawPromise = context.storageState({ path: stateFile }).catch(() => {
+      return void 0;
+    });
     await withTimeout(
-      context.storageState({ path: stateFile }),
+      rawPromise,
       timeoutMs,
       `storageState timed out after ${timeoutMs}ms`
     );
@@ -5194,6 +5262,11 @@ async function getBasicHeaders(accountId) {
   if (!page) {
     throw new Error(`Playwright not initialized for account: ${accountId}`);
   }
+  const inFlightInit = inFlightAccountInits.get(accountId);
+  if (inFlightInit) {
+    await inFlightInit.catch(() => {
+    });
+  }
   const release = await acquireAccountMutex(
     accountId,
     `headers:${accountId.substring(0, 12)}`
@@ -6668,6 +6741,11 @@ async function captureQwenHeaders(accountId, pageOverride, timeoutMs = config.ti
           const { saveAuthSession: saveAuthSession2 } = await Promise.resolve().then(() => (init_database(), database_exports));
           const { parseJwtExpiry: parseJwtExpiry2 } = await Promise.resolve().then(() => (init_jwt(), jwt_exports));
           const tokenExpiry = parseJwtExpiry2(capturedHeaders.cookie);
+          let rTok;
+          try {
+            rTok = (await page.evaluate(() => localStorage.getItem("refresh_token") || "")).trim() || void 0;
+          } catch {
+          }
           saveAuthSession2(accountId, {
             cookie: capturedHeaders.cookie,
             userAgent: capturedHeaders["user-agent"],
@@ -6679,6 +6757,7 @@ async function captureQwenHeaders(accountId, pageOverride, timeoutMs = config.ti
             secChUaPlatform: capturedHeaders["sec-ch-ua-platform"],
             version: capturedHeaders["version"],
             tokenExpiresAt: tokenExpiry || void 0,
+            refreshToken: rTok,
             capturedAt: Date.now()
           });
         } catch {
@@ -6710,38 +6789,57 @@ async function captureQwenHeaders(accountId, pageOverride, timeoutMs = config.ti
         const isAuthUrl = currentUrl.includes("/auth") || currentUrl.includes("/login");
         const isSuspectedGuest = isAuthUrl || attempt >= 2 && !await isPageLoggedIn(page, 5e3);
         if (isSuspectedGuest) {
-          const { getAccountCredentials: getAccountCredentials2 } = await Promise.resolve().then(() => (init_accounts(), accounts_exports));
-          const creds = getAccountCredentials2(accountId);
-          if (creds && creds.email && creds.password) {
-            console.warn(
-              `\u26A0\uFE0F  [Playwright] Session expired or guest state detected during header capture for ${accountId}; re-authenticating...`
+          const silentRefresh = await refreshAccountToken(accountId);
+          if (silentRefresh.success) {
+            console.log(
+              `\u26A1 [Playwright] Token refreshed silently during header capture for ${accountId}`
             );
-            armOverallDeadline();
-            const ok = await loginToQwen(accountId, creds.email, creds.password);
-            if (ok) {
+            if (isAuthUrl) {
               await page.goto(qwenUrl("/"), {
                 waitUntil: "domcontentloaded",
                 timeout: Math.min(config.timeouts.navigation, timeoutMs)
               });
-              await sleep2(2e3);
+              await sleep2(1500);
+            }
+            if (await isPageLoggedIn(page, 5e3)) {
+              armOverallDeadline();
             }
-            if (!ok || !await isPageLoggedIn(page, 6e3)) {
+          }
+          const stillSuspected = !silentRefresh.success || !await isPageLoggedIn(page, 2e3);
+          if (stillSuspected) {
+            const { getAccountCredentials: getAccountCredentials2 } = await Promise.resolve().then(() => (init_accounts(), accounts_exports));
+            const creds = getAccountCredentials2(accountId);
+            if (creds && creds.email && creds.password) {
+              console.warn(
+                `\u26A0\uFE0F  [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) {
+                await page.goto(qwenUrl("/"), {
+                  waitUntil: "domcontentloaded",
+                  timeout: Math.min(config.timeouts.navigation, timeoutMs)
+                });
+                await sleep2(2e3);
+              }
+              if (!ok || !await isPageLoggedIn(page, 6e3)) {
+                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;
           }
         }
         if (settled || page.isClosed()) return;
@@ -7057,7 +7155,13 @@ async function refreshHeadersInternal(accountId, timeoutMs = config.timeouts.hea
             `[Playwright] Navigation check failed during refresh for ${accountId}:`,
             navErr.message
           );
-          await executeReauth();
+          if (await isPageLoggedIn(page, 3e3)) {
+          } else {
+            const refreshed = await refreshAccountToken(accountId);
+            if (!refreshed.success) {
+              await executeReauth();
+            }
+          }
         }
       }
       if (hasRequiredQwenHeaders(cache3.headers)) {
@@ -7071,6 +7175,11 @@ async function refreshHeadersInternal(accountId, timeoutMs = config.timeouts.hea
             const { saveAuthSession: saveAuthSession2 } = await Promise.resolve().then(() => (init_database(), database_exports));
             const tokenCookie = liveCookies.find((c) => c.name === "token");
             const exp = tokenCookie ? parseJwtExpiry(tokenCookie.value) : void 0;
+            let rTok;
+            try {
+              rTok = (await page.evaluate(() => localStorage.getItem("refresh_token") || "")).trim() || void 0;
+            } catch {
+            }
             saveAuthSession2(accountId, {
               cookie: cookieStr,
               userAgent: cache3.headers["user-agent"] || "",
@@ -7082,6 +7191,7 @@ async function refreshHeadersInternal(accountId, timeoutMs = config.timeouts.hea
               secChUaPlatform: cache3.headers["sec-ch-ua-platform"] || void 0,
               version: cache3.headers["version"] || void 0,
               tokenExpiresAt: exp || void 0,
+              refreshToken: rTok,
               capturedAt: Date.now()
             });
           } catch {
@@ -7468,8 +7578,10 @@ async function keepAlivePlaywrightAccount(accountId) {
     if (!page || page.isClosed()) return false;
     const now = Date.now();
     const currentUrl = page.url();
+    const lastRefreshAttempt = lastProactiveTokenRefresh.get(accountId) ?? 0;
     const cookie = await getCookies(accountId);
-    if (cookie && isTokenExpiringSoon(cookie, 5)) {
+    if (cookie && isTokenExpiringSoon(cookie, 5) && now - lastRefreshAttempt > 6e4) {
+      lastProactiveTokenRefresh.set(accountId, now);
       console.log(
         `\u{1F493} [SessionKeeper] Account ${accountId} access token expiring soon (<5m); silently refreshing...`
       );
@@ -7513,6 +7625,7 @@ function cleanupPlaywrightAccountState(accountId) {
   cookieCaches.delete(accountId);
   lastAccountActivity.delete(accountId);
   lastKeepAliveNavigation.delete(accountId);
+  lastProactiveTokenRefresh.delete(accountId);
   clearFingerprintCache(accountId);
   unmarkAccountHeadersReady(accountId);
 }
@@ -7696,7 +7809,7 @@ async function getTokenDiagnostics(accountId) {
     }
   };
 }
-var requireLocal, contextInitHooks, ACCOUNT_MUTEX_MAX_HOLD_MS, accountMutexes, accountContexts, accountPages, cachedUserAgents, inFlightAccountInits, sharedBrowser, sharedBrowserPromise, headerCaches, HEADER_CACHE_TTL, HEADER_REFRESH_THRESHOLD, COOKIE_CACHE_TTL, cookieCaches, lastAccountActivity, lastKeepAliveNavigation, profileResetQueue, profileResetChain, closingAllPlaywright, sleep2, HEADER_CAPTURE_SETTLE_MS, PLAYWRIGHT_MUTEX_WAIT_MS, ACCOUNT_PAGE_OPERATION_TIMEOUT_MS, SESSION_PROBE_NAVIGATION_TIMEOUT_MS, HEADER_CAPTURE_TRIGGER_GRACE_MS, FIRST_TRIGGER_GRACE_MS, HEADER_CAPTURE_TRIGGER_ATTEMPTS, CHAT_INPUT_APPEAR_TIMEOUT_MS, CHAT_INPUT_ACTION_TIMEOUT_MS, PROFILE_RESET_TIMEOUT_MS;
+var requireLocal, contextInitHooks, ACCOUNT_MUTEX_MAX_HOLD_MS, accountMutexes, accountContexts, accountPages, cachedUserAgents, inFlightAccountInits, sharedBrowser, sharedBrowserPromise, headerCaches, HEADER_CACHE_TTL, HEADER_REFRESH_THRESHOLD, COOKIE_CACHE_TTL, cookieCaches, lastAccountActivity, lastKeepAliveNavigation, lastProactiveTokenRefresh, profileResetQueue, profileResetChain, closingAllPlaywright, sleep2, HEADER_CAPTURE_SETTLE_MS, PLAYWRIGHT_MUTEX_WAIT_MS, ACCOUNT_PAGE_OPERATION_TIMEOUT_MS, SESSION_PROBE_NAVIGATION_TIMEOUT_MS, HEADER_CAPTURE_TRIGGER_GRACE_MS, FIRST_TRIGGER_GRACE_MS, HEADER_CAPTURE_TRIGGER_ATTEMPTS, CHAT_INPUT_APPEAR_TIMEOUT_MS, CHAT_INPUT_ACTION_TIMEOUT_MS, PROFILE_RESET_TIMEOUT_MS;
 var init_playwright = __esm({
   "src/services/playwright.ts"() {
     "use strict";
@@ -7732,6 +7845,7 @@ var init_playwright = __esm({
     cookieCaches = /* @__PURE__ */ new Map();
     lastAccountActivity = /* @__PURE__ */ new Map();
     lastKeepAliveNavigation = /* @__PURE__ */ new Map();
+    lastProactiveTokenRefresh = /* @__PURE__ */ new Map();
     profileResetQueue = /* @__PURE__ */ new Map();
     profileResetChain = Promise.resolve();
     closingAllPlaywright = false;
@@ -8547,9 +8661,13 @@ var init_model_registry = __esm({
 // src/services/captcha-coordinator.ts
 var captcha_coordinator_exports = {};
 __export(captcha_coordinator_exports, {
+  isCaptchaRecoveryActive: () => isCaptchaRecoveryActive,
   recoverBaxiaCaptcha: () => recoverBaxiaCaptcha,
   solveChallengeOnPage: () => solveChallengeOnPage
 });
+function isCaptchaRecoveryActive(accountId) {
+  return activeCaptchaRecoveries.has(accountId);
+}
 async function gotoBestEffort(page, url) {
   await page.goto(url, {
     waitUntil: "domcontentloaded",
@@ -8592,11 +8710,12 @@ async function recoverBaxiaCaptcha(accountId, label, options = {}) {
     return false;
   }
   metrics.increment("captcha.challenges.detected", 1, { solver });
-  const challengeUrl = options.challengeBody ? extractBaxiaChallengeUrl(options.challengeBody, config.qwen.baseUrl) : null;
   const solverOperationTimeoutMs = Math.max(
     15e3,
     config.captcha.timeoutMs + config.captcha.maxAttempts * (3e3 + config.captcha.retryDelayMs + config.captcha.settleMs) + 2 * CHALLENGE_NAVIGATION_TIMEOUT_MS
   );
+  const challengeUrl = options.challengeBody ? extractBaxiaChallengeUrl(options.challengeBody, config.qwen.baseUrl) : null;
+  activeCaptchaRecoveries.add(accountId);
   try {
     const solved = await withAccountPage(
       accountId,
@@ -8629,9 +8748,11 @@ async function recoverBaxiaCaptcha(accountId, label, options = {}) {
       detail
     });
     return false;
+  } finally {
+    activeCaptchaRecoveries.delete(accountId);
   }
 }
-var CHALLENGE_NAVIGATION_TIMEOUT_MS, CHALLENGE_PATH_MARKER, FAILED_RECOVERY_BACKOFF_MS, lastFailedRecoveryAt;
+var CHALLENGE_NAVIGATION_TIMEOUT_MS, CHALLENGE_PATH_MARKER, FAILED_RECOVERY_BACKOFF_MS, lastFailedRecoveryAt, activeCaptchaRecoveries;
 var init_captcha_coordinator = __esm({
   "src/services/captcha-coordinator.ts"() {
     "use strict";
@@ -8644,6 +8765,7 @@ var init_captcha_coordinator = __esm({
     CHALLENGE_PATH_MARKER = "_____tmd_____";
     FAILED_RECOVERY_BACKOFF_MS = 3e4;
     lastFailedRecoveryAt = /* @__PURE__ */ new Map();
+    activeCaptchaRecoveries = /* @__PURE__ */ new Set();
   }
 });
 
@@ -9336,6 +9458,11 @@ function isCorruptedChatHistoryError(err) {
   const message = errMessage(err).toLowerCase();
   return message.includes("first message must not") || message.includes("first message must be") || message.includes("must not assistant message") || message.includes("must not be assistant");
 }
+function isInternalServerError(err) {
+  const code = errCode(err).toLowerCase();
+  const message = errMessage(err).toLowerCase();
+  return code === "internal_error" || code === "internal_server_error" || code === "server_error" || code === "server_busy" || code === "busy" || message.includes("internal_error") || message.includes("ocorreu um erro inesperado") || message.includes("unexpected error") || message.includes("internal server error");
+}
 function makeRetryAction(reason, overrides = {}) {
   return {
     retryable: true,
@@ -9442,6 +9569,15 @@ function classifyRetryAction(err, options) {
       accountCooldownReason: quota.accountCooldownReason
     });
   }
+  if (isInternalServerError(err) && !(err instanceof QwenUpstreamError)) {
+    const typed = err;
+    return makeRetryAction("upstream_internal_error", {
+      switchAccount: typed.switchAccount !== false,
+      forceNewChat: true,
+      retryWithFullPrompt: true,
+      retryAfterMs: typed.retryAfterMs ?? Math.min(baseDelayMs * 2, 3e3)
+    });
+  }
   if (isNetworkLikeError(err) || err instanceof QwenUpstreamUnavailableError || err instanceof QwenUpstreamError || isAbortError(err)) {
     const typed = err;
     return makeRetryAction(
@@ -11110,6 +11246,7 @@ __export(qwen_exports, {
   fetchRemoteQwenChats: () => fetchRemoteQwenChats,
   flushLogicalThreadState: () => flushLogicalThreadState,
   getAnyCachedQwenModels: () => getAnyCachedQwenModels,
+  getInFlightPersonalizationCount: () => getInFlightPersonalizationCount,
   getLogicalThreadState: () => getLogicalThreadState,
   getQwenErrorCode: () => getQwenErrorCode,
   getSessionParent: () => getSessionParent,
@@ -12042,12 +12179,51 @@ async function createQwenBrowserResponse(accountId, url, method, headers, body,
     captchaWatcher?.stop();
   }
 }
+function getInFlightPersonalizationCount() {
+  return inFlightPersonalizationSyncs.size;
+}
 async function syncQwenRequestPersonalization(instruction, accountId, metadata = {}) {
-  if (isAuthMockEnabled()) {
-    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;
+  }
+  let syncPromise;
+  syncPromise = (async () => {
+    await Promise.resolve();
+    try {
+      if (isAuthMockEnabled()) {
+        const delay = parseInt(process.env.TEST_PERSONALIZATION_DELAY_MS || "0", 10);
+        if (delay > 0) {
+          await sleep5(delay);
+        }
+        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, accountId, metadata, cacheKey, sent, syncHash) {
   let forceRefresh = false;
   try {
     const basic = await getBasicHeaders2(accountId);
@@ -12065,8 +12241,6 @@ async function syncQwenRequestPersonalization(instruction, accountId, metadata =
   });
   let currentSettings = 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;
   const cachedHash = lastSyncedPersonalizationHashes.get(cacheKey);
   if (!bypassCache && syncHash && cachedHash === syncHash) {
@@ -13411,7 +13585,7 @@ async function createQwenStreamInternal(prompt, enableThinking, modelId, forcedP
     clearTimeout(timeoutId);
   }
 }
-var sleep5, BROWSER_STREAM_BINDING, BROWSER_ABORTERS_KEY, BROWSER_STREAM_FLUSH_BYTES, BROWSER_STREAM_FLUSH_MS, METADATA_TIMEOUT_PER_PAYLOAD_MB_MS, POST_CAPTCHA_METADATA_GRACE_MS, browserStreamStates, browserStreamBindingPages, browserStreamBindingContexts, MODEL_CACHE_TTL_MS, modelsCache, nativeToolsDisabled, disablingNativeToolsInProgress, lastSyncedPersonalizationHashes, directSettingsFetchConsecutiveFailures, DIRECT_SETTINGS_FETCH_BLOCK_THRESHOLD, directSettingsFetchBlocked, DIRECT_SETTINGS_FETCH_TIMEOUT_MS, activePersonalizationByAccount, accountStreamMutexes, QWEN_SAFE_SETTINGS_PATCH, QWEN_SAFE_SETTINGS_HASH, DISABLE_TOOLS_MAX_RETRIES, DISABLE_TOOLS_BACKOFF_MS, UPSTREAM_RESPONSE_PREVIEW_BYTES;
+var sleep5, BROWSER_STREAM_BINDING, BROWSER_ABORTERS_KEY, BROWSER_STREAM_FLUSH_BYTES, BROWSER_STREAM_FLUSH_MS, METADATA_TIMEOUT_PER_PAYLOAD_MB_MS, POST_CAPTCHA_METADATA_GRACE_MS, browserStreamStates, browserStreamBindingPages, browserStreamBindingContexts, MODEL_CACHE_TTL_MS, modelsCache, nativeToolsDisabled, disablingNativeToolsInProgress, lastSyncedPersonalizationHashes, directSettingsFetchConsecutiveFailures, DIRECT_SETTINGS_FETCH_BLOCK_THRESHOLD, directSettingsFetchBlocked, DIRECT_SETTINGS_FETCH_TIMEOUT_MS, activePersonalizationByAccount, accountStreamMutexes, QWEN_SAFE_SETTINGS_PATCH, QWEN_SAFE_SETTINGS_HASH, inFlightPersonalizationSyncs, DISABLE_TOOLS_MAX_RETRIES, DISABLE_TOOLS_BACKOFF_MS, UPSTREAM_RESPONSE_PREVIEW_BYTES;
 var init_qwen = __esm({
   "src/services/qwen.ts"() {
     "use strict";
@@ -13498,6 +13672,7 @@ var init_qwen = __esm({
       }
     };
     QWEN_SAFE_SETTINGS_HASH = crypto7.createHash("sha256").update(JSON.stringify(QWEN_SAFE_SETTINGS_PATCH)).digest("hex").slice(0, 12);
+    inFlightPersonalizationSyncs = /* @__PURE__ */ new Map();
     DISABLE_TOOLS_MAX_RETRIES = 3;
     DISABLE_TOOLS_BACKOFF_MS = 2e3;
     UPSTREAM_RESPONSE_PREVIEW_BYTES = 8 * 1024;
@@ -15945,6 +16120,12 @@ async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false) {
           `\u274C [DeleteChats] [${currentIdx}/${totalCount}] Falha ao apagar conversas de ${maskEmail(account.email)}:`,
           error instanceof Error ? error.message : String(error)
         );
+      } finally {
+        if (!keepBrowserOpen) {
+          const { closePlaywrightForAccount: closePlaywrightForAccount2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
+          await closePlaywrightForAccount2(account.id).catch(() => {
+          });
+        }
       }
     }
   } finally {
@@ -16430,8 +16611,9 @@ function resolveInitialAccount(preferredAccountId, excludeAccountIds) {
     syncCooldownsFromDb(configuredAccounts);
     const excluded = new Set(excludeAccountIds ?? []);
     if (typeof preferredAccountId === "string" && preferredAccountId) {
+      const needle = preferredAccountId.toLowerCase();
       const preferred = configuredAccounts.find(
-        (candidate) => candidate.id === preferredAccountId
+        (candidate) => candidate.id === preferredAccountId || candidate.id.toLowerCase().startsWith(needle) || candidate.email.toLowerCase() === needle || candidate.email.toLowerCase().includes(needle)
       );
       if (preferred && !getAccountCooldownInfo(preferred.id)) {
         return { account: preferred, configuredAccounts };
@@ -16786,7 +16968,12 @@ function shouldWaitQueueForever(isThreadOwnerWaiting, heldByOtherSession, hasFre
 }
 async function tryCreateStreamWithRetry(params, accountId, accountEmail) {
   const maxAttempts = Math.max(1, config.retry.maxAttempts);
-  const maxAccountSwitches = Math.max(0, config.retry.maxAccountSwitches);
+  const accounts = loadAccounts();
+  const configuredAccountCount = accounts.length;
+  const maxAccountSwitches = Math.max(
+    config.retry.maxAccountSwitches,
+    Math.min(configuredAccountCount - 1, 6)
+  );
   let attemptsLeft = maxAttempts;
   let retryDelay = config.retry.baseDelayMs;
   let attempt = 0;
@@ -16798,7 +16985,6 @@ async function tryCreateStreamWithRetry(params, accountId, accountEmail) {
   let chatInProgressOriginAccountEmail = null;
   let lastAttemptError = null;
   let invalidInputSameAccountRetried = false;
-  const accounts = loadAccounts();
   const isSingleAccount = accounts.length <= 1;
   let currentAccountId = accountId;
   let currentAccountEmail = accountEmail;
@@ -17011,14 +17197,24 @@ ${loopReminder}` : truncation.prompt;
       const acquireDeadlineMs = config.concurrency.acquireDeadlineMs;
       let acquireDeadlineTimer;
       const acquireDeadline = new Promise((_, reject) => {
-        acquireDeadlineTimer = setTimeout(() => {
+        const checkDeadline = async () => {
+          try {
+            const { isCaptchaRecoveryActive: isCaptchaRecoveryActive2 } = await Promise.resolve().then(() => (init_captcha_coordinator(), captcha_coordinator_exports));
+            if (currentAccountId && isCaptchaRecoveryActive2(currentAccountId)) {
+              acquireDeadlineTimer = setTimeout(checkDeadline, 3e4);
+              acquireDeadlineTimer.unref?.();
+              return;
+            }
+          } catch {
+          }
           acquireAbort.abort();
           const err2 = new Error(
             `Acquire deadline (${acquireDeadlineMs}ms) exceeded creating stream on ${currentAccountEmail}`
           );
           err2.code = "acquire_deadline";
           reject(err2);
-        }, acquireDeadlineMs);
+        };
+        acquireDeadlineTimer = setTimeout(checkDeadline, acquireDeadlineMs);
         acquireDeadlineTimer.unref?.();
       });
       result = await Promise.race([
@@ -17300,6 +17496,10 @@ ${loopReminder}` : truncation.prompt;
         currentAccountId = nextAccount.id;
         currentAccountEmail = maskEmail(nextAccount.email);
         accountSwitches++;
+        const isRealQuotaError = policy.reason === "quota_or_rate_limit" && (policy.accountCooldownReason === "RateLimited" || policy.accountCooldownReason === "QuotaExceeded");
+        if (isRealQuotaError) {
+          attemptsLeft = Math.max(attemptsLeft, 1);
+        }
         if (params.useThreadNative) {
           const abandonedChatId = params.existingThread?.chatSessionId;
           if (abandonedChatId) {
@@ -19920,6 +20120,199 @@ var init_token_estimation_metrics = __esm({
   }
 });
 
+// src/core/daily-usage.ts
+var daily_usage_exports = {};
+__export(daily_usage_exports, {
+  DAILY_ACCOUNT_TOKEN_BASELINE: () => DAILY_ACCOUNT_TOKEN_BASELINE,
+  MODEL_DAILY_OUTPUT_BASELINES: () => MODEL_DAILY_OUTPUT_BASELINES,
+  STANDARD_DAILY_TOKEN_BASELINE: () => STANDARD_DAILY_TOKEN_BASELINE,
+  getAccountDailyUsage: () => getAccountDailyUsage,
+  getAllAccountsDailyUsage: () => getAllAccountsDailyUsage,
+  getModelQuotaWeight: () => getModelQuotaWeight,
+  getPoolDailyUsageSummary: () => getPoolDailyUsageSummary,
+  getUtcDateString: () => getUtcDateString,
+  recordTurnUsage: () => recordTurnUsage
+});
+function getModelQuotaWeight(model) {
+  if (!model) return 1;
+  const resolved = mapClientModelToQwen(model).toLowerCase();
+  if (resolved.includes("max")) {
+    return STANDARD_DAILY_TOKEN_BASELINE / MODEL_DAILY_OUTPUT_BASELINES.max;
+  }
+  if (resolved.includes("omni") || resolved.includes("flash")) {
+    return STANDARD_DAILY_TOKEN_BASELINE / MODEL_DAILY_OUTPUT_BASELINES.omni;
+  }
+  return 1;
+}
+function getUtcDateString(timestampMs = Date.now()) {
+  return new Date(timestampMs).toISOString().slice(0, 10);
+}
+function recordTurnUsage(accountId, usage, modelOrDate, maybeDateUtc) {
+  if (!accountId || accountId === "global") return;
+  let model;
+  let dateUtc;
+  if (modelOrDate && /^\d{4}-\d{2}-\d{2}$/.test(modelOrDate)) {
+    dateUtc = modelOrDate;
+    model = void 0;
+  } else {
+    model = modelOrDate;
+    dateUtc = maybeDateUtc || getUtcDateString();
+  }
+  const prompt = Math.max(0, Number(usage.prompt_tokens) || 0);
+  const completion = Math.max(0, Number(usage.completion_tokens) || 0);
+  const total = Math.max(
+    prompt + completion,
+    Number(usage.total_tokens) || prompt + completion
+  );
+  const weight = getModelQuotaWeight(model);
+  const weighted = completion * weight;
+  try {
+    const db2 = getDatabase();
+    db2.prepare(
+      `
+      INSERT INTO account_daily_usage (
+        account_id, date_utc, prompt_tokens, completion_tokens, weighted_tokens, total_tokens, turns_count, updated_at
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, 1, datetime('now')
+      )
+      ON CONFLICT(account_id, date_utc) DO UPDATE SET
+        prompt_tokens = prompt_tokens + excluded.prompt_tokens,
+        completion_tokens = completion_tokens + excluded.completion_tokens,
+        weighted_tokens = weighted_tokens + excluded.weighted_tokens,
+        total_tokens = total_tokens + excluded.total_tokens,
+        turns_count = turns_count + 1,
+        updated_at = datetime('now')
+    `
+    ).run(accountId, dateUtc, prompt, completion, weighted, total);
+  } catch (err) {
+  }
+}
+function getAccountDailyUsage(accountId, dateUtc = getUtcDateString()) {
+  try {
+    const db2 = getDatabase();
+    const row = db2.prepare(
+      `SELECT prompt_tokens, completion_tokens, weighted_tokens, total_tokens, turns_count
+         FROM account_daily_usage
+         WHERE account_id = ? AND date_utc = ?`
+    ).get(accountId, dateUtc);
+    const promptTokens = Number(row?.prompt_tokens) || 0;
+    const completionTokens = Number(row?.completion_tokens) || 0;
+    const weightedTokens = Number(row?.weighted_tokens) || completionTokens;
+    const totalTokens = Number(row?.total_tokens) || 0;
+    const turnsCount = Number(row?.turns_count) || 0;
+    const usagePercent = Math.min(
+      100,
+      Math.round(weightedTokens / STANDARD_DAILY_TOKEN_BASELINE * 100)
+    );
+    return {
+      accountId,
+      dateUtc,
+      promptTokens,
+      completionTokens,
+      weightedTokens,
+      totalTokens,
+      turnsCount,
+      usagePercent
+    };
+  } catch {
+    return {
+      accountId,
+      dateUtc,
+      promptTokens: 0,
+      completionTokens: 0,
+      weightedTokens: 0,
+      totalTokens: 0,
+      turnsCount: 0,
+      usagePercent: 0
+    };
+  }
+}
+function getAllAccountsDailyUsage(dateUtc = getUtcDateString()) {
+  const result = /* @__PURE__ */ new Map();
+  try {
+    const db2 = getDatabase();
+    const rows = db2.prepare(
+      `SELECT account_id, prompt_tokens, completion_tokens, weighted_tokens, total_tokens, turns_count
+         FROM account_daily_usage
+         WHERE date_utc = ?`
+    ).all(dateUtc);
+    for (const row of rows) {
+      const promptTokens = Number(row.prompt_tokens) || 0;
+      const completionTokens = Number(row.completion_tokens) || 0;
+      const weightedTokens = Number(row.weighted_tokens) || completionTokens;
+      const totalTokens = Number(row.total_tokens) || 0;
+      const turnsCount = Number(row.turns_count) || 0;
+      const usagePercent = Math.min(
+        100,
+        Math.round(weightedTokens / STANDARD_DAILY_TOKEN_BASELINE * 100)
+      );
+      result.set(row.account_id, {
+        accountId: row.account_id,
+        dateUtc,
+        promptTokens,
+        completionTokens,
+        weightedTokens,
+        totalTokens,
+        turnsCount,
+        usagePercent
+      });
+    }
+  } catch {
+  }
+  return result;
+}
+function getPoolDailyUsageSummary(targetAccountIds, dateUtc = getUtcDateString()) {
+  const accounts = targetAccountIds && targetAccountIds.length > 0 ? targetAccountIds : loadAccounts().map((a) => a.id);
+  const accountCount = Math.max(1, accounts.length);
+  const poolCapacityTokens = accountCount * STANDARD_DAILY_TOKEN_BASELINE;
+  const usageMap = getAllAccountsDailyUsage(dateUtc);
+  let totalPromptTokens = 0;
+  let totalCompletionTokens = 0;
+  let totalWeightedTokens = 0;
+  let totalTokens = 0;
+  let totalTurns = 0;
+  for (const id of accounts) {
+    const usage = usageMap.get(id);
+    if (usage) {
+      totalPromptTokens += usage.promptTokens;
+      totalCompletionTokens += usage.completionTokens;
+      totalWeightedTokens += usage.weightedTokens;
+      totalTokens += usage.totalTokens;
+      totalTurns += usage.turnsCount;
+    }
+  }
+  const poolUsagePercent = Math.min(
+    100,
+    Math.round(totalWeightedTokens / poolCapacityTokens * 100)
+  );
+  return {
+    dateUtc,
+    totalPromptTokens,
+    totalCompletionTokens,
+    totalWeightedTokens,
+    totalTokens,
+    totalTurns,
+    poolCapacityTokens,
+    poolUsagePercent
+  };
+}
+var STANDARD_DAILY_TOKEN_BASELINE, DAILY_ACCOUNT_TOKEN_BASELINE, MODEL_DAILY_OUTPUT_BASELINES;
+var init_daily_usage = __esm({
+  "src/core/daily-usage.ts"() {
+    "use strict";
+    init_database();
+    init_accounts();
+    init_model_alias();
+    STANDARD_DAILY_TOKEN_BASELINE = 5e5;
+    DAILY_ACCOUNT_TOKEN_BASELINE = STANDARD_DAILY_TOKEN_BASELINE;
+    MODEL_DAILY_OUTPUT_BASELINES = {
+      max: 28e4,
+      plus: 5e5,
+      omni: 62e4
+    };
+  }
+});
+
 // src/routes/chat/streaming.ts
 import { stream as honoStream } from "hono/streaming";
 function firstString(...values) {
@@ -20425,6 +20818,9 @@ Please retry your tool call(s) with correct JSON and valid tool names from the a
       mode: "non-stream",
       context: currentTokenEstimationContext
     });
+    if (activeAccountId && usage) {
+      recordTurnUsage(activeAccountId, usage, body.model);
+    }
     if (pendingParentId) {
       rememberParent(pendingParentId);
     }
@@ -20520,6 +20916,9 @@ async function processStreamingResponse(params) {
     let activeReader = null;
     let invalidInputSameAccountRetries = 0;
     let chatInProgressSameAccountRetries = 0;
+    let antiBotSameAccountRetries = 0;
+    const totalConfiguredAccounts = loadAccounts().length;
+    let quotaRotationsLeft = Math.min(Math.max(1, totalConfiguredAccounts - 1), 6);
     let streamCompletedOk = false;
     let stoppedByToolCap = false;
     const runDisconnectTeardown = () => {
@@ -20877,13 +21276,18 @@ async function processStreamingResponse(params) {
             reason: "network"
           }
         ) : null;
-        if (!normalizedError || clientDisconnected && !gracePending || c.req.raw.signal.aborted || retryContext.retriesLeft <= 0 || !midStreamRetry || emittedModelOutput) {
+        if (!normalizedError || clientDisconnected && !gracePending || c.req.raw.signal.aborted || !midStreamRetry || emittedModelOutput) {
           return false;
         }
         const policy = classifyRetryAction(normalizedError, {
           requestAborted: c.req.raw.signal.aborted
         });
         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;
+        }
         if (logger.isLevelEnabled("info")) {
           console.log(
             `\u{1F9ED} [Chat] Stream recovery policy | account=${currentAccountId} | reason=${policy.reason} | retryable=${policy.retryable} | switch=${policy.switchAccount} | newChat=${policy.forceNewChat} | fullPrompt=${policy.retryWithFullPrompt} | retryAfter=${policy.retryAfterMs}ms`
@@ -20892,9 +21296,13 @@ async function processStreamingResponse(params) {
         if (policy.reason === "corrupted_chat_history") {
           invalidateLogicalThreadParent(midStreamRetry.sessionId);
         }
-        retryContext.retriesLeft--;
+        if (isRealQuotaError) {
+          quotaRotationsLeft--;
+        } else {
+          retryContext.retriesLeft--;
+        }
         console.warn(
-          `\u{1F504} [Chat] Stream recovery | account=${currentAccountId} | reason=${policy.reason} | error=${normalizedError.message.substring(0, 150)} | retries_left=${retryContext.retriesLeft}`
+          `\u{1F504} [Chat] Stream recovery | account=${currentAccountId} | reason=${policy.reason} | error=${normalizedError.message.substring(0, 150)} | retries_left=${isRealQuotaError ? quotaRotationsLeft : retryContext.retriesLeft}`
         );
         const retryInvalidInputOnSameAccount = shouldRetryInvalidInputOnSameAccount(
           policy.reason,
@@ -20916,7 +21324,16 @@ async function processStreamingResponse(params) {
           );
           return false;
         }
-        const switchAccount = policy.switchAccount && !retryInvalidInputOnSameAccount;
+        let switchAccount = policy.switchAccount && !retryInvalidInputOnSameAccount;
+        if (policy.reason === "anti_bot") {
+          if (antiBotSameAccountRetries === 0) {
+            antiBotSameAccountRetries++;
+            switchAccount = false;
+          } else {
+            switchAccount = true;
+            markAccountRateLimited(currentAccountId, 6e4, "AntiBotWafChallenge");
+          }
+        }
         if (switchAccount && (policy.accountCooldownMs ?? 0) > 0) {
           markAccountRateLimited(
             currentAccountId,
@@ -20928,6 +21345,33 @@ async function processStreamingResponse(params) {
           Promise.resolve().then(() => (init_playwright(), playwright_exports)).then(({ refreshAccountToken: refreshAccountToken2 }) => refreshAccountToken2(currentAccountId)).catch(() => {
           });
         }
+        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(() => void 0);
+          }
+        }
         retryContext.releaseAccountLease?.();
         retryContext.releaseAccountLease = null;
         await reader.cancel().catch(() => void 0);
@@ -21775,6 +22219,9 @@ Please retry your tool call(s) with correct JSON and valid tool names from the a
           mode: "stream",
           context: currentTokenEstimationContext
         });
+        if (activeAccountId && usage) {
+          recordTurnUsage(activeAccountId, usage, body.model);
+        }
       } else {
         if (isToolcallDebugEnabled()) {
           logger.debug(
@@ -21980,6 +22427,7 @@ var init_streaming = __esm({
     init_qwen_url();
     init_qwen();
     init_account();
+    init_accounts();
     init_account_manager();
     init_account_concurrency();
     init_retry_policy();
@@ -21995,6 +22443,7 @@ var init_streaming = __esm({
     init_errors2();
     init_retry_policy();
     init_token_estimation_metrics();
+    init_daily_usage();
     init_context_meter();
     init_helpers();
     MAX_INITIAL_PROTOCOL_BYTES = 64 * 1024;
@@ -22434,7 +22883,7 @@ async function chatCompletions(c) {
       updateLogicalThread: parallelEscape ? false : ctx.updateLogicalThread,
       allowThreadReuse: ctx.allowThreadReuse,
       forceNewChat: parallelEscape,
-      preferredAccountId: void 0,
+      preferredAccountId: c.req.header("x-qwenproxy-account") || void 0,
       messageCount: msgCount,
       fullMessageCount: parsed.messageCount,
       toolsCount: declaredTools.length || void 0,
@@ -25936,7 +26385,7 @@ function getAppVersion() {
     }
   } catch {
   }
-  cachedVersion = "v1.5.3";
+  cachedVersion = "v1.6.1";
   return cachedVersion;
 }
 var cachedVersion;
@@ -26645,7 +27094,8 @@ var init_server = __esm({
           captchasDetected: Number(metrics.get("captcha.challenges.detected")?.value ?? 0),
           captchasSolved: Number(metrics.get("captcha.solves.succeeded")?.value ?? 0),
           chatsCleaned: Number(metrics.get("chats.cleaned")?.value ?? 0)
-        }
+        },
+        dailyUsage: (await Promise.resolve().then(() => (init_daily_usage(), daily_usage_exports))).getPoolDailyUsageSummary()
       });
     });
     app5.get("/diagnostics/tokens", async (c) => {
@@ -27407,12 +27857,17 @@ async function fetchProxyStatus() {
     }
   } catch {
   }
+  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
+      streamLimit: concurrency?.limit ?? config.concurrency.maxStreamsPerAccount,
+      dailyTokens: daily?.completionTokens ?? 0,
+      dailyUsagePercent: daily?.usagePercent ?? 0,
+      dailyTurns: daily?.turnsCount ?? 0
     };
   });
   let rssMb = 0;
@@ -27471,6 +27926,7 @@ async function fetchProxyStatus() {
       cacheHitRatio,
       cacheBytesSaved
     },
+    dailyUsage: getPoolDailyUsageSummary(cachedAccounts.map((a) => a.id)),
     accounts
   };
 }
@@ -27611,6 +28067,7 @@ var init_proxy_client = __esm({
     init_account_concurrency();
     init_memory_usage();
     init_metrics();
+    init_daily_usage();
     init_model_alias();
     init_model_alias();
     cachedAccounts = [];
@@ -28341,12 +28798,24 @@ var init_status_view = __esm({
         const poolPct = accounts.length > 0 ? Math.round(availableCount / accounts.length * 100) : 0;
         const poolColor = poolPct >= 70 ? theme.green : poolPct >= 40 ? theme.yellow : theme.red;
         const poolBar = renderProgressBar(poolPct, 8, poolColor);
+        const poolDailyUsage = data?.dailyUsage;
+        const poolUsagePct = poolDailyUsage?.poolUsagePercent ?? 0;
+        const poolUsageColor = poolUsagePct >= 80 ? theme.red : poolUsagePct >= 40 ? theme.yellow : theme.cyan;
+        const poolUsageBar = renderProgressBar(poolUsagePct, 8, poolUsageColor);
         const innerRightW = Math.max(30, rightW - 2);
-        const emailWidth = Math.max(16, Math.min(20, innerRightW - 27));
+        const showUsageCol = innerRightW >= 52;
+        const emailWidth = showUsageCol ? Math.max(14, Math.min(18, innerRightW - 33)) : Math.max(16, Math.min(20, innerRightW - 27));
         const rightContent = [
           `  ${theme.bold("Disponibilidade:")} [${poolBar}] ${poolColor(`${availableCount}/${accounts.length} (${poolPct}%)`)}`,
+          ...poolDailyUsage ? [
+            `  ${theme.bold("Cota Pool Hoje:")} [${poolUsageBar}] ${poolUsageColor(
+              `${poolUsagePct}%`
+            )} ${theme.dim(
+              `(~${Math.round(poolDailyUsage.totalTokens / 1e3)}k tok)`
+            )}`
+          ] : [],
           `  ${theme.dim("\u2500".repeat(Math.max(32, innerRightW - 2)))}`,
-          `  ${theme.dim(`#   ${pad("Conta", emailWidth)} Carga  Status`)}`,
+          `  ${theme.dim(`#   ${pad("Conta", emailWidth)} Carga  ${showUsageCol ? "Uso%  " : ""}Status`)}`,
           `  ${theme.dim("\u2500".repeat(Math.max(32, innerRightW - 2)))}`
         ];
         if (accounts.length === 0) {
@@ -28358,7 +28827,17 @@ var init_status_view = __esm({
             const name = pad(truncate(acc.emailOrName, emailWidth - 1), emailWidth);
             const active = acc.activeStreams || 0;
             const limit = acc.streamLimit || 1;
-            const loadBadge = active > 0 ? theme.yellow(`[${active}/${limit}]`) : theme.dim(`[0/${limit}]`);
+            const usagePct = acc.dailyUsagePercent ?? 0;
+            let loadBadge;
+            if (active > 0) {
+              loadBadge = theme.yellow(`[${active}/${limit}]`);
+            } else if (!showUsageCol && usagePct > 0) {
+              const pctColor = usagePct >= 80 ? theme.red : usagePct >= 40 ? theme.yellow : theme.cyan;
+              loadBadge = pctColor(pad(`[${usagePct}%]`, 5));
+            } else {
+              loadBadge = theme.dim(`[0/${limit}]`);
+            }
+            const usageCol = 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))) + " " : "";
             let status = theme.green(`${glyphs.bullet} Pronto`);
             if (active > 0 && !acc.onCooldown && acc.headersReady) {
               status = theme.yellow(`\u25CF Gerando `);
@@ -28375,7 +28854,7 @@ var init_status_view = __esm({
             } else if (!acc.headersReady) {
               status = acc.isInitialized ? theme.yellow(`\u25D0 Aquecendo...`) : theme.muted(`\u25CB Standby`);
             }
-            rightContent.push(`  ${num}${name} ${loadBadge} ${status}`);
+            rightContent.push(`  ${num}${name} ${loadBadge} ${usageCol}${status}`);
           });
         }
         const summaryParts = [];
@@ -32757,6 +33236,7 @@ var init_accounts_view = __esm({
     init_accounts();
     init_server_manager();
     init_config();
+    init_status_view();
     AccountsView = class {
       id = "accounts";
       title = "Contas";
@@ -33522,9 +34002,11 @@ var init_accounts_view = __esm({
         if (this.selectedIndex >= accounts.length && accounts.length > 0) {
           this.selectedIndex = accounts.length - 1;
         }
+        const showUsageCol = leftW >= 48;
+        const headerUsage = showUsageCol ? "Uso%  " : "";
         const leftContent = [
           "",
-          `  ${theme.dim("#   Conta                 Status")}`,
+          `  ${theme.dim(`#   Conta                 ${headerUsage}Status`)}`,
           `  ${theme.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`
         ];
         if (accounts.length === 0) {
@@ -33569,7 +34051,9 @@ var init_accounts_view = __esm({
             } else if (!acc.headersReady) {
               status = acc.isInitialized ? theme.yellow(`\u25D0 Aquecendo...`) : theme.muted(`\u25CB 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) {
@@ -33610,6 +34094,12 @@ var init_accounts_view = __esm({
           rightContent.push(`  ${theme.bold("Conta:")}      ${theme.cyan(email)}`);
           rightContent.push(`  ${theme.bold("Sistema ID:")} ${theme.muted(selected.id.slice(0, 14))}`);
           rightContent.push(`  ${theme.bold("N\xEDvel:")}      ${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 / 1e3)}k / ${usageTurns} reqs)`)}`);
           const cdStatus = selected.onCooldown ? theme.yellow(`[!] Cooldown ${Math.round(selected.remainingCooldownMs / 6e4)}m`) : theme.green(`${glyphs.check} Dispon\xEDvel`);
           rightContent.push(`  ${theme.bold("Estado:")}     ${cdStatus}`);
           const hStatus = selected.headersReady ? theme.green(`${glyphs.check} Capturados`) : selected.isInitialized ? theme.yellow(`\u25D0 Aquecendo...`) : theme.muted(`${glyphs.circle} Standby (Sob Demanda)`);
@@ -34418,6 +34908,7 @@ var init_app = __esm({
 
 // src/index.ts
 init_paths();
+init_process_guard();
 init_server();
 import dotenv2 from "dotenv";
 import fs26 from "node:fs";
@@ -34433,24 +34924,7 @@ if (fs26.existsSync(envPath)) {
 } else {
   dotenv2.config({ quiet: true });
 }
-process.on("uncaughtException", async (error) => {
-  const { isPlaywrightAlreadyClosedError: isPlaywrightAlreadyClosedError2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
-  if (isPlaywrightAlreadyClosedError2(error)) {
-    const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
-    console.warn(`\u26A0\uFE0F  [Playwright] Handled benign driver teardown exception: ${msg}`);
-    return;
-  }
-  console.error("\u274C [Process] Uncaught Exception:", error);
-});
-process.on("unhandledRejection", async (reason) => {
-  const { isPlaywrightAlreadyClosedError: isPlaywrightAlreadyClosedError2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
-  if (isPlaywrightAlreadyClosedError2(reason)) {
-    const msg = reason instanceof Error ? reason.message : typeof reason === "object" && reason !== null && "message" in reason ? String(reason.message) : String(reason);
-    console.warn(`\u26A0\uFE0F  [Playwright] Handled benign driver teardown rejection: ${msg}`);
-    return;
-  }
-  console.error("\u274C [Process] Unhandled Rejection:", reason);
-});
+installProcessTeardownGuards("Playwright");
 var isTui = process.argv.includes("--tui") || process.env.QWEN_TUI === "true";
 if (isTui) {
   const { TuiApp: TuiApp2 } = await Promise.resolve().then(() => (init_app(), app_exports));