@goodandready/dsh-subscriptions 0.6.61 → 0.6.62

package/README.md

@@ -244,6 +244,10 @@ dsh-subscriptions:
   codexFastMode: false      # v0.4.17: service_tier priority (1.5x speed tier)
   composerQuota: 'off'      # v0.4.18: composer indicator: off | percent | bar | forecast
   enableToasts: true        # v0.6.59: real-time in-app toast alerts on quarantine and quota events
+  enableQueue: true         # v0.6.62: bounded concurrency queue to prevent bursts of 429 errors
+  accountMaxConcurrency: 2  # v0.6.62: max concurrent active streams per account
+  maxQueueSize: 20          # v0.6.62: max queue depth before load shedding / reject
+  queueTimeoutMs: 30000     # v0.6.62: max queue wait duration in ms before timeout
   # Per-slot fields (v0.4.9): expiresAt (ms epoch), proxyUrl (http/https/socks5://)
   accounts:
     codex:

package/README.ru.md

@@ -217,6 +217,10 @@ dsh-subscriptions:
   codexFastMode: false      # v0.4.17: service_tier priority (скоростной тир 1.5x)
   composerQuota: 'off'      # v0.4.18: индикатор в строке ввода: off | percent | bar | forecast
   enableToasts: true        # v0.6.59: всплывающие уведомления при событиях карантина и квот
+  enableQueue: true         # v0.6.62: ограниченная очередь параллельных запросов к аккаунту
+  accountMaxConcurrency: 2  # v0.6.62: макс. число параллельных стримов на аккаунт
+  maxQueueSize: 20          # v0.6.62: макс. глубина очереди до сброса нагрузки
+  queueTimeoutMs: 30000     # v0.6.62: таймаут ожидания слота в очереди в мс
   # Поля слота (v0.4.9): expiresAt (ms), proxyUrl (http/https/socks5://)
   accounts:
     codex:

package/README.zh.md

@@ -126,6 +126,10 @@ graph LR
 * **手动隔离管理（暂停与预热探测）**：支持在设置面板的账户卡片中一键暂停隔离活跃账户（`POST /dsh-subscriptions/quarantine/park`），或立即触发真实上游预热微探测（`probeWarmup`）并在验证成功后即时解除隔离（`POST /dsh-subscriptions/quarantine/probe`）。
 * **动态额度重置倒计时**：在顶部会话栏 `SubsPill` 和账户卡片中秒级动态更新，精准展示滚动配额窗口（`five_hour`、`seven_day`、`primary_window`）的剩余解锁时间。
 * **应用内即时弹窗提醒（Toast）**：当账户进入隔离、健康恢复解除隔离或额度达到预警线时，在聊天界面弹出轻量级浮动提醒。通过 `enableToasts: true` 控制。
+  enableQueue: true         # v0.6.62: 账户并发请求排队与限流
+  accountMaxConcurrency: 2  # v0.6.62: 单账户最大并行活跃流
+  maxQueueSize: 20          # v0.6.62: 队列最大等待深度
+  queueTimeoutMs: 30000     # v0.6.62: 队列最大等待超时时间（毫秒）
 * **自动化 Webhook 告警集成**：通过 `notifyQuarantineEntered` 与 `notifyQuarantineReleased` 自动向外部通知系统派发隔离生命周期事件。
 
 ### Antigravity 客户端密钥架构与无感 CLI 令牌刷新 (v0.6.60)

package/lib/analytics.js

@@ -0,0 +1,338 @@
+// Subscription and cache analytics, performance aggregates, and quota forecasting.
+// Enforces 0 Cyrillic characters.
+
+export function calculatePercentile(values, percentile) {
+  if (!Array.isArray(values) || values.length === 0) return null
+  const sorted = [...values].sort((a, b) => a - b)
+  const index = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.ceil((percentile / 100) * sorted.length) - 1)
+  )
+  return sorted[index]
+}
+
+export function calculateCacheMetrics(entries = []) {
+  let promptTokens = 0
+  let completionTokens = 0
+  let cacheReadTokens = 0
+  let cacheCreationTokens = 0
+  let requestsWithCacheRead = 0
+
+  for (const r of entries) {
+    if (!r) continue
+    const prompt = typeof r.inputTokens === 'number'
+      ? r.inputTokens
+      : (r.tokens && typeof r.tokens.prompt === 'number' ? r.tokens.prompt : 0)
+    const completion = typeof r.outputTokens === 'number'
+      ? r.outputTokens
+      : (r.tokens && typeof r.tokens.completion === 'number' ? r.tokens.completion : 0)
+    const read = typeof r.cacheReadTokens === 'number'
+      ? r.cacheReadTokens
+      : (r.tokens && typeof r.tokens.cacheRead === 'number' ? r.tokens.cacheRead : 0)
+    const creation = typeof r.cacheCreationTokens === 'number'
+      ? r.cacheCreationTokens
+      : (r.tokens && typeof r.tokens.cacheCreation === 'number' ? r.tokens.cacheCreation : 0)
+
+    promptTokens += prompt
+    completionTokens += completion
+    cacheReadTokens += read
+    cacheCreationTokens += creation
+    if (read > 0) requestsWithCacheRead++
+  }
+
+  const totalTokens = promptTokens + completionTokens
+  const cacheTotal = promptTokens + cacheReadTokens
+  const cacheHitRate = cacheTotal > 0
+    ? Math.round((cacheReadTokens / cacheTotal) * 1000) / 10
+    : 0
+
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    cacheReadTokens,
+    cacheCreationTokens,
+    cacheHitRate,
+    requestsWithCacheRead,
+    cacheHitCount: requestsWithCacheRead,
+  }
+}
+
+export function calculatePerformanceMetrics(entries = []) {
+  const ttftList = []
+  const tpsList = []
+  const latencyList = []
+
+  let ttftSum = 0
+  let tpsSum = 0
+  let latencySum = 0
+
+  for (const r of entries) {
+    if (!r) continue
+    if (typeof r.ttftMs === 'number' && r.ttftMs >= 0) {
+      ttftList.push(r.ttftMs)
+      ttftSum += r.ttftMs
+    }
+    if (typeof r.tps === 'number' && r.tps > 0) {
+      tpsList.push(r.tps)
+      tpsSum += r.tps
+    }
+    if (typeof r.ms === 'number' && r.ms > 0) {
+      latencyList.push(r.ms)
+      latencySum += r.ms
+    }
+  }
+
+  const count = entries.length
+  return {
+    ttft: {
+      count: ttftList.length,
+      avgMs: ttftList.length > 0 ? Math.round(ttftSum / ttftList.length) : null,
+      p95Ms: calculatePercentile(ttftList, 95),
+      minMs: ttftList.length > 0 ? Math.min(...ttftList) : null,
+      maxMs: ttftList.length > 0 ? Math.max(...ttftList) : null,
+    },
+    tps: {
+      count: tpsList.length,
+      avg: tpsList.length > 0 ? Math.round((tpsSum / tpsList.length) * 10) / 10 : null,
+      p95: calculatePercentile(tpsList, 95),
+      min: tpsList.length > 0 ? Math.min(...tpsList) : null,
+      max: tpsList.length > 0 ? Math.max(...tpsList) : null,
+    },
+    latency: {
+      count: latencyList.length,
+      avgMs: latencyList.length > 0 ? Math.round(latencySum / latencyList.length) : 0,
+      p95Ms: calculatePercentile(latencyList, 95),
+      minMs: latencyList.length > 0 ? Math.min(...latencyList) : 0,
+      maxMs: latencyList.length > 0 ? Math.max(...latencyList) : 0,
+      totalRequests: count,
+    },
+  }
+}
+
+export function calculateHourlyBuckets(entries = [], nowMs = Date.now()) {
+  const buckets = []
+  const ONE_HOUR = 3600000
+
+  for (let i = 23; i >= 0; i--) {
+    const end = nowMs - (i * ONE_HOUR)
+    const start = end - ONE_HOUR
+    const dateObj = new Date(start)
+    const hourNum = dateObj.getHours()
+    const hourStr = String(hourNum).padStart(2, '0') + ':00'
+
+    buckets.push({
+      hour: hourNum,
+      label: hourStr,
+      start,
+      end,
+      requests: 0,
+      successCount: 0,
+      errorCount: 0,
+      promptTokens: 0,
+      completionTokens: 0,
+      cacheReadTokens: 0,
+      totalTokens: 0,
+    })
+  }
+
+  const cutoff = nowMs - (24 * ONE_HOUR)
+  for (const r of entries) {
+    if (!r || !r.ts || r.ts < cutoff || r.ts > nowMs) continue
+    const age = nowMs - r.ts
+    const bucketIndex = 23 - Math.floor(age / ONE_HOUR)
+    if (bucketIndex >= 0 && bucketIndex < 24) {
+      const b = buckets[bucketIndex]
+      b.requests++
+      const st = Number(r.status || 0)
+      if (st >= 200 && st < 400) b.successCount++
+      else if (st >= 400) b.errorCount++
+
+      const prompt = Number(r.inputTokens || (r.tokens && r.tokens.prompt) || 0)
+      const completion = Number(r.outputTokens || (r.tokens && r.tokens.completion) || 0)
+      const cacheRead = Number(r.cacheReadTokens || (r.tokens && r.tokens.cacheRead) || 0)
+
+      b.promptTokens += prompt
+      b.completionTokens += completion
+      b.cacheReadTokens += cacheRead
+      b.totalTokens += (prompt + completion)
+    }
+  }
+
+  return buckets
+}
+
+export function calculateAccountBreakdown(entries = [], accounts = []) {
+  const map = {}
+  const labels = {}
+  for (const a of accounts) {
+    if (a && a.ref) {
+      labels[a.ref] = a.label || a.ref
+    }
+  }
+
+  for (const r of entries) {
+    if (!r || !r.ref) continue
+    const ref = r.ref
+    if (!map[ref]) {
+      map[ref] = {
+        ref,
+        provider: r.provider || 'unknown',
+        label: labels[ref] || r.accountLabel || ref,
+        totalRequests: 0,
+        successRequests: 0,
+        errorRequests: 0,
+        promptTokens: 0,
+        completionTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        ttftSum: 0,
+        ttftCount: 0,
+        tpsSum: 0,
+        tpsCount: 0,
+        latencySum: 0,
+      }
+    }
+    const acc = map[ref]
+    acc.totalRequests++
+    const st = Number(r.status || 0)
+    if (st >= 200 && st < 400) acc.successRequests++
+    else if (st >= 400) acc.errorRequests++
+
+    const prompt = Number(r.inputTokens || (r.tokens && r.tokens.prompt) || 0)
+    const completion = Number(r.outputTokens || (r.tokens && r.tokens.completion) || 0)
+    const cacheRead = Number(r.cacheReadTokens || (r.tokens && r.tokens.cacheRead) || 0)
+    const cacheCreation = Number(r.cacheCreationTokens || (r.tokens && r.tokens.cacheCreation) || 0)
+
+    acc.promptTokens += prompt
+    acc.completionTokens += completion
+    acc.cacheReadTokens += cacheRead
+    acc.cacheCreationTokens += cacheCreation
+
+    if (typeof r.ttftMs === 'number' && r.ttftMs >= 0) {
+      acc.ttftSum += r.ttftMs
+      acc.ttftCount++
+    }
+    if (typeof r.tps === 'number' && r.tps > 0) {
+      acc.tpsSum += r.tps
+      acc.tpsCount++
+    }
+    if (typeof r.ms === 'number' && r.ms > 0) {
+      acc.latencySum += r.ms
+    }
+  }
+
+  const result = {}
+  for (const [ref, acc] of Object.entries(map)) {
+    const totalCache = acc.promptTokens + acc.cacheReadTokens
+    result[ref] = {
+      ref,
+      provider: acc.provider,
+      label: acc.label,
+      totalRequests: acc.totalRequests,
+      successRequests: acc.successRequests,
+      errorRequests: acc.errorRequests,
+      promptTokens: acc.promptTokens,
+      completionTokens: acc.completionTokens,
+      cacheReadTokens: acc.cacheReadTokens,
+      cacheCreationTokens: acc.cacheCreationTokens,
+      cacheHitRate: totalCache > 0 ? Math.round((acc.cacheReadTokens / totalCache) * 1000) / 10 : 0,
+      avgTtftMs: acc.ttftCount > 0 ? Math.round(acc.ttftSum / acc.ttftCount) : null,
+      avgTps: acc.tpsCount > 0 ? Math.round((acc.tpsSum / acc.tpsCount) * 10) / 10 : null,
+      avgLatencyMs: acc.totalRequests > 0 ? Math.round(acc.latencySum / acc.totalRequests) : 0,
+    }
+  }
+  return result
+}
+
+export function calculateQuotaForecast(accounts = [], entries = [], nowMs = Date.now()) {
+  const ONE_HOUR = 3600000
+  const ONE_DAY = 24 * ONE_HOUR
+  const forecast = []
+
+  for (const acc of accounts) {
+    if (!acc || !acc.ref) continue
+    const quota = acc.quota
+    const ref = acc.ref
+
+    // Calculate recent usage over the past 24 hours for this account
+    let tokens24h = 0
+    let requests24h = 0
+    let tokens1h = 0
+    let requests1h = 0
+
+    for (const r of entries) {
+      if (!r || r.ref !== ref || !r.ts) continue
+      const age = nowMs - r.ts
+      if (age <= ONE_DAY) {
+        const total = Number(r.inputTokens || (r.tokens && r.tokens.prompt) || 0) +
+                      Number(r.outputTokens || (r.tokens && r.tokens.completion) || 0)
+        tokens24h += total
+        requests24h++
+        if (age <= ONE_HOUR) {
+          tokens1h += total
+          requests1h++
+        }
+      }
+    }
+
+    const burnRateTokensPerHour = requests1h > 0 ? tokens1h : Math.round(tokens24h / 24)
+
+    let willExhaustBeforeReset = false
+    let projectedExhaustionAt = null
+    let hoursToExhaustion = null
+    let remainingMs = null
+
+    if (quota && typeof quota.percentage === 'number') {
+      const remainingPercent = Math.max(0, Math.min(100, quota.percentage))
+      const resetAt = typeof quota.resetAt === 'number' ? quota.resetAt : null
+
+      if (resetAt && resetAt > nowMs) {
+        remainingMs = resetAt - nowMs
+      }
+
+      // If quota is low and active burn rate exists
+      if (burnRateTokensPerHour > 0 && remainingPercent > 0) {
+        // Approximate burn rate percentage per hour based on 24h consumption
+        // If 24h consumed tokens24h and quota dropped, estimate burn % per hour
+        const estimatedPercentPerHour = tokens24h > 0 ? Math.max(0.5, (100 - remainingPercent) / 24) : 0
+        if (estimatedPercentPerHour > 0) {
+          hoursToExhaustion = Math.round((remainingPercent / estimatedPercentPerHour) * 10) / 10
+          const msToExhaustion = hoursToExhaustion * ONE_HOUR
+          if (remainingMs !== null && msToExhaustion < remainingMs) {
+            willExhaustBeforeReset = true
+            projectedExhaustionAt = nowMs + msToExhaustion
+          }
+        }
+      }
+    }
+
+    forecast.push({
+      ref,
+      provider: acc.provider,
+      label: acc.label || ref,
+      quotaPercent: quota && typeof quota.percentage === 'number' ? quota.percentage : null,
+      resetAt: quota && typeof quota.resetAt === 'number' ? quota.resetAt : null,
+      burnRateTokensPerHour,
+      requests24h,
+      tokens24h,
+      hoursToExhaustion,
+      willExhaustBeforeReset,
+      projectedExhaustionAt,
+    })
+  }
+
+  return forecast
+}
+
+export function calculateAnalytics(entries = [], accounts = [], nowMs = Date.now()) {
+  return {
+    generatedAt: new Date(nowMs).toISOString(),
+    totalRequests: entries.length,
+    cache: calculateCacheMetrics(entries),
+    performance: calculatePerformanceMetrics(entries),
+    hourly: calculateHourlyBuckets(entries, nowMs),
+    accounts: calculateAccountBreakdown(entries, accounts),
+    forecast: calculateQuotaForecast(accounts, entries, nowMs),
+  }
+}

package/lib/client.js

@@ -122,6 +122,10 @@ window.__ModuleLoader__.load({
     '.dsub-stat-box{padding:10px 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-2);display:flex;flex-direction:column;gap:3px}' +
     '.dsub-stat-val{font-size:16.5px;font-weight:700;color:var(--dsw-alias-label-primary)}' +
     '.dsub-stat-lbl{font-size:11.5px;color:var(--dsw-alias-label-secondary)}' +
+    '.dsub-chart-wrap{display:flex;align-items:flex-end;gap:3px;height:52px;padding:6px 0;margin-top:8px;border-bottom:1px solid var(--dsw-alias-border-l3)}' +
+    '.dsub-chart-bar{flex:1;background:var(--dsw-alias-brand-primary);border-radius:2px 2px 0 0;min-height:3px;transition:height .2s ease;opacity:0.85;cursor:pointer}' +
+    '.dsub-chart-bar:hover{opacity:1;background:var(--dsw-alias-state-success-primary)}' +
+    '.dsub-chart-labels{display:flex;justify-content:space-between;font-size:10px;color:var(--dsw-alias-label-secondary);margin-top:3px}' +
     '.dsub-alert-ok{padding:8px 12px;border-radius:8px;background:color-mix(in srgb,var(--dsw-alias-state-success-primary) 10%,transparent);color:var(--dsw-alias-state-success-primary);font-size:12.5px;border:1px solid color-mix(in srgb,var(--dsw-alias-state-success-primary) 25%,transparent)}' +
     '.dsub-alert-bad{padding:8px 12px;border-radius:8px;background:color-mix(in srgb,var(--dsw-alias-state-error-primary) 10%,transparent);color:var(--dsw-alias-state-error-primary);font-size:12.5px;border:1px solid color-mix(in srgb,var(--dsw-alias-state-error-primary) 25%,transparent)}' +
     '.dsub-btn-primary{background:var(--dsw-alias-label-primary) !important;color:var(--dsw-alias-bg-layer-3) !important;border-color:transparent !important;font-weight:600}' +
@@ -569,6 +573,27 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "toastReleased": "Account active and healthy",
       "toastQuotaWarning": "Quota threshold exceeded",
       "enableToasts": "In-app toast alerts",
+      "groupQueue": "Concurrency & Request Queue",
+      "enableQueue": "Enable request queue",
+      "enableQueueHint": "Queue excess requests when account hits concurrency limit instead of failing with 429",
+      "accountMaxConcurrency": "Max concurrent streams per account",
+      "accountMaxConcurrencyHint": "Maximum simultaneous streaming requests allowed per account (default 2)",
+      "maxQueueSize": "Max queue depth",
+      "maxQueueSizeHint": "Maximum queued requests per account before rejecting with overflow (default 20)",
+      "queueTimeoutSec": "Queue wait timeout (seconds)",
+      "queueTimeoutSecHint": "Maximum wait time in queue before timeout rejection (default 30s)",
+      "analyticsTitle": "Subscription & Cache Analytics",
+      "analyticsDesc": "Cache hit rate, token caching efficiency, TTFT latency, generation speed, and 24h activity",
+      "ttftMetric": "TTFT Latency",
+      "speedMetric": "Speed",
+      "queueActive": "Active Streams",
+      "queueWaiting": "Queued",
+      "queueRejected": "Rejected",
+      "activity24h": "24-Hour Activity Distribution",
+      "forecastTitle": "Quota Exhaustion Forecast",
+      "forecastRunway": "Estimated runway",
+      "forecastBurnRate": "Burn rate",
+      "forecastExhaustWarning": "Quota projected to exhaust before reset window",
       "field.enableToasts": "Show popup toast notifications on quarantine or quota events"
 };
 
@@ -791,6 +816,27 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "toastReleased": "账户已解除隔离恢复使用",
       "toastQuotaWarning": "额度预警",
       "enableToasts": "应用内弹窗提醒",
+      "groupQueue": "并发限制与请求队列",
+      "enableQueue": "启用并发请求排队",
+      "enableQueueHint": "当账户达到并发上限时将多余请求排队等待，避免直接触发 429 报错",
+      "accountMaxConcurrency": "单账户最大并发流数",
+      "accountMaxConcurrencyHint": "每个账户允许同时执行的最大流式请求数（默认 2）",
+      "maxQueueSize": "队列最大等待深度",
+      "maxQueueSizeHint": "每个账户允许排队的最大请求数，超限后拒绝执行（默认 20）",
+      "queueTimeoutSec": "排队超时时间（秒）",
+      "queueTimeoutSecHint": "在队列中等待槽位的最长时间，超时后自动放弃并回退（默认 30 秒）",
+      "analyticsTitle": "订阅与缓存深度分析",
+      "analyticsDesc": "缓存命中率、Token 缓存效率、首字响应延迟 (TTFT)、生成速度及 24 小时负载分布",
+      "ttftMetric": "首字响应延迟 (TTFT)",
+      "speedMetric": "生成速度",
+      "queueActive": "活跃流",
+      "queueWaiting": "排队中",
+      "queueRejected": "已拒绝",
+      "activity24h": "24 小时活动分布",
+      "forecastTitle": "额度消耗预测与预警",
+      "forecastRunway": "预计可用时间",
+      "forecastBurnRate": "消耗速率",
+      "forecastExhaustWarning": "预计在额度重置前耗尽",
       "field.enableToasts": "当账户发生隔离或额度达到警戒线时显示即时弹窗提醒"
 };
     // #51: live countdown to the quota window reset (account.quota.resetAt).
@@ -1015,6 +1061,8 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       const [checkRes, setCheckRes] = React.useState({})
       const [hostPing, setHostPing] = React.useState({ ok: true, latencyMs: null })
       const [telemetry, setTelemetry] = React.useState(null)
+      const [analytics, setAnalytics] = React.useState(null)
+      const [queueStats, setQueueStats] = React.useState(null)
       const [smoke, setSmoke] = React.useState({ testing: false, result: null })
       const [updater, setUpdater] = React.useState({ checking: false, updating: false, status: null, message: '' })
       const [backupModal, setBackupModal] = React.useState(null)
@@ -1117,6 +1165,14 @@ const cssId = 'dsh-subscriptions/settings.module.css'
           .then((r) => r.json())
           .then((d) => { if (d && d.ok && d.telemetry) setTelemetry(d.telemetry) })
           .catch(() => {})
+        fetch('/dsh-subscriptions/analytics', { cache: 'no-store' })
+          .then((r) => r.json())
+          .then((d) => { if (d && d.ok && d.analytics) setAnalytics(d.analytics) })
+          .catch(() => {})
+        fetch('/dsh-subscriptions/queue', { cache: 'no-store' })
+          .then((r) => r.json())
+          .then((d) => { if (d && d.ok && d.queue) setQueueStats(d.queue) })
+          .catch(() => {})
       }
 
       const runSmokeTest = async (provider, index) => {
@@ -1506,6 +1562,68 @@ const cssId = 'dsh-subscriptions/settings.module.css'
             React.createElement('div', { className: 'dsub-stat-lbl' }, t('statsLastActivity')),
           ),
         ) : null,
+        (analytics && (analytics.totalRequests > 0 || (analytics.hourly && analytics.hourly.some(function(b) { return b.requests > 0 })))) || (queueStats && (queueStats.totalActive > 0 || queueStats.totalQueued > 0)) ? React.createElement('details', { className: 'dsub-group', open: true, style: { marginBottom: '14px' } },
+          React.createElement('summary', { className: 'dsub-groupHead' }, '📊 ' + t('analyticsTitle')),
+          React.createElement('div', { className: 'dsub-sub', style: { marginTop: '4px' } }, t('analyticsDesc')),
+          React.createElement('div', { className: 'dsub-grid-2', style: { marginTop: '10px' } },
+            React.createElement('div', { className: 'dsub-stat-box' },
+              React.createElement('div', { className: 'dsub-stat-val' }, ((analytics && analytics.cache && analytics.cache.cacheHitRate) || 0) + '%'),
+              React.createElement('div', { className: 'dsub-stat-lbl' }, t('cacheHitRate') + (analytics && analytics.cache ? ' (' + (analytics.cache.cacheReadTokens || 0).toLocaleString() + ' tok)' : '')),
+            ),
+            React.createElement('div', { className: 'dsub-stat-box' },
+              React.createElement('div', { className: 'dsub-stat-val' }, (analytics && analytics.performance && analytics.performance.ttft && analytics.performance.ttft.avgMs != null ? analytics.performance.ttft.avgMs + ' ms' : '—')),
+              React.createElement('div', { className: 'dsub-stat-lbl' }, t('ttftMetric') + (analytics && analytics.performance && analytics.performance.ttft && analytics.performance.ttft.p95Ms != null ? ' · p95 ' + analytics.performance.ttft.p95Ms + ' ms' : '')),
+            ),
+            React.createElement('div', { className: 'dsub-stat-box' },
+              React.createElement('div', { className: 'dsub-stat-val' }, (analytics && analytics.performance && analytics.performance.tps && analytics.performance.tps.avg != null ? analytics.performance.tps.avg + ' tok/s' : '—')),
+              React.createElement('div', { className: 'dsub-stat-lbl' }, t('speedMetric') + (analytics && analytics.performance && analytics.performance.tps && analytics.performance.tps.p95 != null ? ' · p95 ' + analytics.performance.tps.p95 : '')),
+            ),
+            React.createElement('div', { className: 'dsub-stat-box' },
+              React.createElement('div', { className: 'dsub-stat-val' }, (queueStats ? queueStats.totalActive : 0) + ' / ' + (queueStats ? queueStats.totalQueued : 0)),
+              React.createElement('div', { className: 'dsub-stat-lbl' }, t('queueActive') + ' / ' + t('queueWaiting') + (queueStats && queueStats.metrics && queueStats.metrics.totalOverflowed ? ' · ' + queueStats.metrics.totalOverflowed + ' ' + t('queueRejected') : '')),
+            ),
+          ),
+          analytics && Array.isArray(analytics.hourly) && analytics.hourly.length ? (function() {
+            var maxReq = Math.max.apply(Math, [1].concat(analytics.hourly.map(function(b) { return b.requests || 0 })))
+            return React.createElement('div', { style: { marginTop: '12px' } },
+              React.createElement('div', { style: { fontSize: '11.5px', fontWeight: 600, color: 'var(--dsw-alias-label-secondary)' } }, t('activity24h')),
+              React.createElement('div', { className: 'dsub-chart-wrap' },
+                analytics.hourly.map(function(b, idx) {
+                  var pct = Math.max(4, Math.round(((b.requests || 0) / maxReq) * 100))
+                  var title = b.label + ': ' + b.requests + ' req (' + b.cacheReadTokens + ' cached tok, ' + b.errorCount + ' err)'
+                  return React.createElement('div', {
+                    key: idx,
+                    className: 'dsub-chart-bar',
+                    style: {
+                      height: pct + '%',
+                      backgroundColor: b.errorCount > 0 && b.requests === b.errorCount
+                        ? 'var(--dsw-alias-state-error-primary)'
+                        : (b.cacheReadTokens > 0 ? 'var(--dsw-alias-brand-primary)' : 'var(--dsw-alias-state-success-primary)'),
+                    },
+                    title: title,
+                  })
+                })
+              ),
+              React.createElement('div', { className: 'dsub-chart-labels' },
+                React.createElement('span', null, '-24h'),
+                React.createElement('span', null, '-18h'),
+                React.createElement('span', null, '-12h'),
+                React.createElement('span', null, '-6h'),
+                React.createElement('span', null, 'Now'),
+              ),
+            )
+          })() : null,
+          analytics && Array.isArray(analytics.forecast) && analytics.forecast.some(function(f) { return f.willExhaustBeforeReset || (f.burnRateTokensPerHour > 0 && f.hoursToExhaustion != null && f.hoursToExhaustion < 72) }) ? React.createElement('div', { style: { marginTop: '12px' } },
+            React.createElement('div', { style: { fontSize: '11.5px', fontWeight: 600, color: 'var(--dsw-alias-state-warn-primary)', marginBottom: '6px' } }, '⚠️ ' + t('forecastTitle')),
+            analytics.forecast.filter(function(f) { return f.willExhaustBeforeReset || (f.burnRateTokensPerHour > 0 && f.hoursToExhaustion != null && f.hoursToExhaustion < 72) }).map(function(f, idx) {
+              return React.createElement('div', { key: idx, className: 'dsub-alert-bad', style: { marginBottom: '6px' } },
+                (f.provider ? f.provider.toUpperCase() : 'LLM') + ' (' + (f.label || f.ref) + '): ' +
+                (f.willExhaustBeforeReset ? t('forecastExhaustWarning') : (t('forecastRunway') + ': ~' + f.hoursToExhaustion + 'h')) +
+                ' · ' + t('forecastBurnRate') + ': ' + f.burnRateTokensPerHour.toLocaleString() + ' tok/h'
+              )
+            })
+          ) : null,
+        ) : null,
         telemetry && Array.isArray(telemetry.recentDecisions) && telemetry.recentDecisions.length ? React.createElement('details', { className: 'dsub-group', style: { marginBottom: '14px' } },
           React.createElement('summary', { className: 'dsub-groupHead' }, '🧭 ' + t('rotationDecisionsTitle')),
           React.createElement('div', { className: 'dsub-sub', style: { marginTop: '4px' } }, t('rotationDecisionsDesc')),
@@ -1640,6 +1758,57 @@ const cssId = 'dsh-subscriptions/settings.module.css'
           React.createElement('div', { className: 'dsub-sub' },
             t('expiryNotifyDaysHint')),
           ),
+          React.createElement('details', { className: 'dsub-group', open: true },
+            React.createElement('summary', { className: 'dsub-groupHead' }, '🚦 ' + t('groupQueue')),
+            React.createElement('label', { className: 'dsub-row' },
+              React.createElement('input', {
+                type: 'checkbox',
+                checked: draft.enableQueue !== false,
+                onChange: function(e) { setDraft(function(d) { return Object.assign({}, d, { enableQueue: e.target.checked }) }) },
+              }),
+              React.createElement('span', null, t('enableQueue')),
+            ),
+            React.createElement('div', { className: 'dsub-sub' }, t('enableQueueHint')),
+            React.createElement('div', { className: 'dsub-row' },
+              React.createElement('span', { className: 'dsub-h' }, t('accountMaxConcurrency')),
+              React.createElement('input', {
+                type: 'number',
+                className: 'dsub-inp',
+                style: { width: '80px', minWidth: '80px' },
+                min: 1,
+                max: 20,
+                value: draft.accountMaxConcurrency != null ? draft.accountMaxConcurrency : 2,
+                onChange: function(e) { setDraft(function(d) { return Object.assign({}, d, { accountMaxConcurrency: Math.max(1, Number(e.target.value) || 2) }) }) },
+              }),
+            ),
+            React.createElement('div', { className: 'dsub-sub' }, t('accountMaxConcurrencyHint')),
+            React.createElement('div', { className: 'dsub-row' },
+              React.createElement('span', { className: 'dsub-h' }, t('maxQueueSize')),
+              React.createElement('input', {
+                type: 'number',
+                className: 'dsub-inp',
+                style: { width: '80px', minWidth: '80px' },
+                min: 1,
+                max: 100,
+                value: draft.maxQueueSize != null ? draft.maxQueueSize : 20,
+                onChange: function(e) { setDraft(function(d) { return Object.assign({}, d, { maxQueueSize: Math.max(1, Number(e.target.value) || 20) }) }) },
+              }),
+            ),
+            React.createElement('div', { className: 'dsub-sub' }, t('maxQueueSizeHint')),
+            React.createElement('div', { className: 'dsub-row' },
+              React.createElement('span', { className: 'dsub-h' }, t('queueTimeoutSec')),
+              React.createElement('input', {
+                type: 'number',
+                className: 'dsub-inp',
+                style: { width: '80px', minWidth: '80px' },
+                min: 1,
+                max: 120,
+                value: Math.round((draft.queueTimeoutMs != null ? draft.queueTimeoutMs : 30000) / 1000),
+                onChange: function(e) { setDraft(function(d) { return Object.assign({}, d, { queueTimeoutMs: Math.max(1, Number(e.target.value) || 30) * 1000 }) }) },
+              }),
+            ),
+            React.createElement('div', { className: 'dsub-sub' }, t('queueTimeoutSecHint')),
+          ),
           React.createElement('details', { className: 'dsub-group', open: true },
             React.createElement('summary', { className: 'dsub-groupHead' }, t('groupProvider')),
           React.createElement('label', { className: 'dsub-row' },

package/lib/concurrency-queue.js

@@ -0,0 +1,222 @@
+// Concurrency limiting, bounded queue, and cooperative cancellation per account/provider.
+// Standardized error codes: QUEUE_OVERFLOW, QUEUE_TIMEOUT, ABORT_ERR, QUEUE_DISPOSED.
+
+/**
+ * @param {string} message
+ * @param {string} code
+ * @param {number} [status]
+ * @returns {Error & { code: string, status?: number }}
+ */
+function createQueueError(message, code, status) {
+  const err = /** @type {Error & { code: string, status?: number }} */ (new Error(message))
+  err.code = code
+  if (status !== undefined) err.status = status
+  return err
+}
+
+export class ConcurrencyQueue {
+  constructor(options = {}) {
+    this.maxConcurrency = options.maxConcurrency !== undefined ? Number(options.maxConcurrency) : 2
+    this.maxQueueSize = options.maxQueueSize !== undefined ? Number(options.maxQueueSize) : 20
+    this.timeoutMs = options.timeoutMs !== undefined ? Number(options.timeoutMs) : 30000
+    this.enabled = options.enabled !== undefined ? Boolean(options.enabled) : true
+
+    /** @type {Map<string, number>} */
+    this._active = new Map()
+    /** @type {Map<string, Array<{ id: string, resolve: Function, reject: Function, timer: any, signal: any, abortHandler: Function | null, enqueuedAt: number }>>} */
+    this._waiting = new Map()
+
+    this._stats = {
+      totalAcquired: 0,
+      totalReleased: 0,
+      totalQueued: 0,
+      totalTimedOut: 0,
+      totalOverflowed: 0,
+      totalAborted: 0,
+    }
+  }
+
+  configure(options = {}) {
+    if (options.maxConcurrency !== undefined) this.maxConcurrency = Number(options.maxConcurrency)
+    if (options.maxQueueSize !== undefined) this.maxQueueSize = Number(options.maxQueueSize)
+    if (options.timeoutMs !== undefined) this.timeoutMs = Number(options.timeoutMs)
+    if (options.enabled !== undefined) this.enabled = Boolean(options.enabled)
+  }
+
+  async acquire(key = 'default', options = {}) {
+    if (!this.enabled) {
+      return () => {}
+    }
+
+    const signal = options.signal
+    if (signal && signal.aborted) {
+      const err = createQueueError('Request aborted before acquiring queue slot', 'ABORT_ERR')
+      err.name = 'AbortError'
+      this._stats.totalAborted++
+      throw err
+    }
+
+    const k = String(key || 'default')
+    const active = this._active.get(k) || 0
+    const limit = options.maxConcurrency !== undefined ? Number(options.maxConcurrency) : this.maxConcurrency
+
+    if (active < limit) {
+      this._active.set(k, active + 1)
+      this._stats.totalAcquired++
+      return this._createRelease(k)
+    }
+
+    // Queue is required
+    const queueList = this._waiting.get(k) || []
+    const maxQ = options.maxQueueSize !== undefined ? Number(options.maxQueueSize) : this.maxQueueSize
+
+    if (queueList.length >= maxQ) {
+      this._stats.totalOverflowed++
+      const err = createQueueError(`Concurrency queue overflow for ${k} (max queue size: ${maxQ})`, 'QUEUE_OVERFLOW', 429)
+      throw err
+    }
+
+    const timeoutDuration = options.timeoutMs !== undefined ? Number(options.timeoutMs) : this.timeoutMs
+    this._stats.totalQueued++
+
+    return new Promise((resolve, reject) => {
+      let timer = null
+      let abortHandler = null
+      const id = Math.random().toString(36).slice(2)
+
+      const cleanup = () => {
+        if (timer) clearTimeout(timer)
+        if (signal && abortHandler && typeof signal.removeEventListener === 'function') {
+          signal.removeEventListener('abort', abortHandler)
+        }
+      }
+
+      if (timeoutDuration > 0) {
+        timer = setTimeout(() => {
+          cleanup()
+          this._removeFromWaiting(k, id)
+          this._stats.totalTimedOut++
+          const err = createQueueError(`Concurrency queue wait timeout for ${k} after ${timeoutDuration}ms`, 'QUEUE_TIMEOUT', 504)
+          reject(err)
+        }, timeoutDuration)
+      }
+
+      if (signal) {
+        abortHandler = () => {
+          cleanup()
+          this._removeFromWaiting(k, id)
+          this._stats.totalAborted++
+          const err = createQueueError('Request aborted while waiting in concurrency queue', 'ABORT_ERR')
+          err.name = 'AbortError'
+          reject(err)
+        }
+        signal.addEventListener('abort', abortHandler, { once: true })
+      }
+
+      const item = {
+        id,
+        resolve: () => {
+          cleanup()
+          this._stats.totalAcquired++
+          resolve(this._createRelease(k))
+        },
+        reject: (err) => {
+          cleanup()
+          reject(err)
+        },
+        timer,
+        signal,
+        abortHandler,
+        enqueuedAt: Date.now(),
+      }
+
+      if (!this._waiting.has(k)) {
+        this._waiting.set(k, [])
+      }
+      this._waiting.get(k).push(item)
+    })
+  }
+
+  _createRelease(k) {
+    let released = false
+    return () => {
+      if (released) return
+      released = true
+      this._release(k)
+    }
+  }
+
+  _release(k) {
+    this._stats.totalReleased++
+    const waiting = this._waiting.get(k)
+    if (waiting && waiting.length > 0) {
+      const next = waiting.shift()
+      if (waiting.length === 0) this._waiting.delete(k)
+      // Hand over slot directly to next queued consumer
+      next.resolve()
+    } else {
+      const active = this._active.get(k) || 0
+      if (active <= 1) {
+        this._active.delete(k)
+      } else {
+        this._active.set(k, active - 1)
+      }
+    }
+  }
+
+  _removeFromWaiting(k, id) {
+    const list = this._waiting.get(k)
+    if (!list) return
+    const idx = list.findIndex((item) => item.id === id)
+    if (idx !== -1) {
+      list.splice(idx, 1)
+      if (list.length === 0) this._waiting.delete(k)
+    }
+  }
+
+  stats() {
+    let totalActive = 0
+    let totalQueued = 0
+    const byKey = {}
+
+    for (const [k, count] of this._active) {
+      totalActive += count
+      if (!byKey[k]) byKey[k] = { active: 0, queued: 0 }
+      byKey[k].active = count
+    }
+
+    for (const [k, list] of this._waiting) {
+      totalQueued += list.length
+      if (!byKey[k]) byKey[k] = { active: 0, queued: 0 }
+      byKey[k].queued = list.length
+    }
+
+    return {
+      enabled: this.enabled,
+      maxConcurrency: this.maxConcurrency,
+      maxQueueSize: this.maxQueueSize,
+      timeoutMs: this.timeoutMs,
+      totalActive,
+      totalQueued,
+      byKey,
+      metrics: { ...this._stats },
+    }
+  }
+
+  dispose() {
+    for (const [, list] of this._waiting) {
+      for (const item of list) {
+        if (item.timer) clearTimeout(item.timer)
+        if (item.signal && item.abortHandler && typeof item.signal.removeEventListener === 'function') {
+          item.signal.removeEventListener('abort', item.abortHandler)
+        }
+        const err = createQueueError('Concurrency queue was disposed', 'QUEUE_DISPOSED')
+        item.reject(err)
+      }
+    }
+    this._waiting.clear()
+    this._active.clear()
+  }
+}
+
+export const defaultConcurrencyQueue = new ConcurrencyQueue()

package/lib/config-schema.js

@@ -118,6 +118,14 @@ export const Config = z.object({
     .description('#485 Prioritize accounts with closest reset window to burn expiring quota first.'),
   drainSafetyPercent: z.number().volatile().default(5)
     .description('#485 Safety margin percent: avoid draining accounts below this threshold when alternatives exist.'),
+  enableQueue: z.boolean().volatile().default(true)
+    .description('#518 Bounded concurrency queue to prevent bursts of 429 errors.'),
+  accountMaxConcurrency: z.number().volatile().default(2)
+    .description('#518 Max concurrent requests per account before queuing.'),
+  maxQueueSize: z.number().volatile().default(20)
+    .description('#518 Max requests waiting in queue before reject.'),
+  queueTimeoutMs: z.number().volatile().default(30000)
+    .description('#518 Max queue wait time in ms before timeout.'),
   customVendors: z.array(z.any()).volatile().default([])
     .description('Declarative OpenAI-Responses-compatible providers. See README.'),
 })

package/lib/diagnostics.js

@@ -1,3 +1,5 @@
+import { defaultConcurrencyQueue } from './concurrency-queue.js'
+import { calculateCacheMetrics } from './analytics.js'
 import { maskText } from './mask.js'
 import { normalizeSlots } from './accounts.js'
 import { PROVIDERS } from './refs.js'
@@ -46,6 +48,8 @@ export async function createDiagnosticsReport({ live, store, history, NS, pkgVer
     runtime: { node: process.version, platform: process.platform, arch: process.arch, uptimeSec: Math.round(process.uptime()) },
     providers,
     requests: { total: rows.length, byStatus, lastErrors },
+    cache: calculateCacheMetrics(rows),
+    queue: defaultConcurrencyQueue.stats(),
     decisions: {
       recent: rows.filter((r) => r && r.decisionTrace).slice(0, 10).map((r) => ({
         ts: r.ts,

package/lib/history.js

@@ -1,3 +1,4 @@
+import { calculateAnalytics } from './analytics.js'
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
@@ -298,4 +299,8 @@ export class HistoryStore {
       recentDecisions,
     }
   }
+
+  getAnalytics(accounts = [], nowMs = Date.now()) {
+    return calculateAnalytics(this.rows, accounts, nowMs)
+  }
 }

package/lib/routes/status.js

@@ -1,3 +1,5 @@
+import { defaultConcurrencyQueue } from '../concurrency-queue.js'
+import { calculateAnalytics } from '../analytics.js'
 import { buildEnrichedCatalog } from '../models-catalog.js'
 // #374: Sensitive GET routes protected by same-origin check
 import { readFileSync } from 'node:fs'
@@ -49,6 +51,7 @@ export function registerStatusRoutes(ctx, state) {
         liveConfig: live(),
         hideDeprecated: !!live().hideDeprecatedModels,
       }),
+      queue: defaultConcurrencyQueue.stats(),
     }
   }
 
@@ -538,4 +541,43 @@ export function registerStatusRoutes(ctx, state) {
     }),
   }), 'dsh-subscriptions: /alerts')
 
+
+  // #511: Detailed cache and subscription analytics endpoint
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/analytics',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req, ctx)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const accounts = await accountsView()
+      const analytics = typeof history.getAnalytics === 'function'
+        ? history.getAnalytics(accounts)
+        : calculateAnalytics(history.all(), accounts)
+      writeJson(res, 200, { ok: true, analytics })
+    }),
+  }), 'dsh-subscriptions: /analytics')
+
+  // #518: Concurrency and request queue status
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/queue',
+    handler: safeJsonHandler(async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req, ctx)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const queueStats = defaultConcurrencyQueue.stats()
+      writeJson(res, 200, { ok: true, queue: queueStats })
+    }),
+  }), 'dsh-subscriptions: /queue')
 }

package/lib/stream-rotate.js

@@ -1,3 +1,4 @@
+import { defaultConcurrencyQueue } from './concurrency-queue.js'
 import { pickAccountWithTrace, markCooldown, isSwitchableError, isRegionError, modelFamily } from './rotate.js'
 import { putInQuarantine, REASON_RATE_LIMIT, REASON_HARD_LIMIT, REASON_REVOKED } from './quarantine.js'
 import { notifySessionExpired, notifyQuarantineEntered } from './alerts.js'
@@ -16,6 +17,7 @@ export async function* streamWithRotation({
   offlineFallback, // #174: optional fallback generator if all accounts exhausted
   webhookUrl,
   fetchImpl = fetch,
+  concurrencyQueue = defaultConcurrencyQueue,
 }) {
   const pool = (accounts || []).map((account) => ({ ...account }))
   let lastError = null
@@ -100,10 +102,36 @@ export async function* streamWithRotation({
 
     tried.add(account.ref || account.id)
 
+    const queueKey = account.ref || account.id || 'default'
+    const queueConfig = {
+      signal: options && options.signal,
+      timeoutMs: options && (options.queueTimeoutMs !== undefined ? options.queueTimeoutMs : (options.config && options.config.queueTimeoutMs)),
+      maxConcurrency: options && (options.accountMaxConcurrency !== undefined ? options.accountMaxConcurrency : (options.config && options.config.accountMaxConcurrency)),
+      maxQueueSize: options && (options.maxQueueSize !== undefined ? options.maxQueueSize : (options.config && options.config.maxQueueSize)),
+      enabled: options && (options.enableQueue !== undefined ? options.enableQueue : (options.config && options.config.enableQueue !== undefined ? options.config.enableQueue : true)),
+    }
+
+    let releaseSlot = null
+    try {
+      releaseSlot = await concurrencyQueue.acquire(queueKey, queueConfig)
+    } catch (queueErr) {
+      if (queueErr && (queueErr.code === 'ABORT_ERR' || queueErr.name === 'AbortError')) {
+        currentAttempt.status = 'aborted'
+        currentAttempt.error = queueErr.message
+        syncTrace('aborted')
+        throw queueErr
+      }
+      currentAttempt.status = queueErr && queueErr.code === 'QUEUE_OVERFLOW' ? 'queue_overflow' : 'queue_timeout'
+      currentAttempt.error = queueErr ? queueErr.message : String(queueErr)
+      lastError = queueErr
+      continue
+    }
+
     let firstChunkDelivered = false
     let regionRetries = 0
 
-    while (true) {
+    try {
+      while (true) {
       try {
         const runawayState = options && options._runawayState ? options._runawayState : { tripped: false, reason: null }
         const runawayOpts = {
@@ -207,5 +235,10 @@ export async function* streamWithRotation({
         break
       }
     }
+    } finally {
+      if (typeof releaseSlot === 'function') {
+        releaseSlot()
+      }
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.61",
+  "version": "0.6.62",
   "description": "Use ChatGPT Codex, Claude, Grok, Antigravity, Kimi, GLM, Cursor, Kiro, Copilot, Qwen, ERNIE, Spark, JetBrains, Perplexity, Replit, and Cody subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",