@goodandready/dsh-subscriptions 0.6.72 → 0.6.83

package/README.md

@@ -305,6 +305,14 @@ dsh-subscriptions:
 
 ---
 
+### Custom Providers and Host Trust
+
+- `customVendors.authUrl`, `tokenUrl` and `baseUrl` must use `https://`. Plain `http://` is accepted only for loopback hosts (`localhost`, `127.0.0.1`, `::1`).
+- Grok `baseUrl` overrides must point to `api.x.ai`, `grok.com` / `*.grok.com`, or a loopback host; other hosts are rejected with `GROK_UNTRUSTED_HOST` so bearer tokens never leave trusted xAI infrastructure.
+- Antigravity CLI imports must configure `antigravityClientSecret`; the embedded default was removed.
+- The error buffer and diagnostics reports redact bearer tokens, API keys, JWTs and `key=value` credentials before storing or returning them.
+
+
 ## 🧠 Claude Adaptive Thinking & Effort (Added in v0.6.7)
 
 Supports Anthropic's adaptive thinking (`thinking: { type: "adaptive" }`) and reasoning effort steering (`output_config: { effort }`):

package/README.ru.md

@@ -278,6 +278,14 @@ dsh-subscriptions:
 
 ---
 
+### Кастомные провайдеры и доверие хостам
+
+- `customVendors.authUrl`, `tokenUrl` и `baseUrl` обязаны использовать `https://`. Открытый `http://` допускается только для loopback-хостов (`localhost`, `127.0.0.1`, `::1`).
+- Переопределение Grok `baseUrl` должно указывать на `api.x.ai`, `grok.com` / `*.grok.com` или loopback-хост; остальные хосты отклоняются с `GROK_UNTRUSTED_HOST`, чтобы bearer-токен не покидал доверенную инфраструктуру xAI.
+- Импорт Antigravity CLI требует явного `antigravityClientSecret`; встроенный default удалён.
+- Error buffer и диагностические отчёты редактируют bearer-токены, API-ключи, JWT и `key=value`-credentials до сохранения и выдачи.
+
+
 ## 🧠 Адаптивное мышление Claude и уровни усилия (Добавлено в v0.6.7)
 
 Поддержка адаптивного мышления Anthropic (`thinking: { type: "adaptive" }`) и управления глубиной рассуждений (`output_config: { effort }`):

package/README.zh.md

@@ -184,6 +184,14 @@ dsh plugin --profile web add @goodandready/dsh-subscriptions
 
 ---
 
+### 自定义供应商与主机信任
+
+- `customVendors.authUrl`、`tokenUrl` 和 `baseUrl` 必须使用 `https://`。明文 `http://` 仅允许用于回环主机（`localhost`、`127.0.0.1`、`::1`）。
+- Grok `baseUrl` 覆盖只能指向 `api.x.ai`、`grok.com` / `*.grok.com` 或回环主机；其他主机会以 `GROK_UNTRUSTED_HOST` 拒绝，避免 bearer 令牌离开可信的 xAI 基础设施。
+- Antigravity CLI 导入必须配置 `antigravityClientSecret`；内置默认值已移除。
+- 错误缓冲区和诊断报告会在存储或返回前脱敏 bearer 令牌、API 密钥、JWT 和 `key=value` 凭据。
+
+
 ## 🧠 Claude 自适应思考与推理深度控制 (v0.6.7 新增)
 
 支持 Anthropic 自适应思考 (`thinking: { type: "adaptive" }`) 及推理深度调节 (`output_config: { effort }`):

package/lib/accounts-view.js

@@ -1,9 +1,20 @@
+import { inspectAccountCapabilities } from './capabilities.js'
+import { extractBillingInfo } from './billing.js'
+import { calculatePacingRunway } from './forecast.js'
+import { calculateValueDelivered } from './pricing.js'
+import { notifyBillingAlert } from './alerts.js'
+import { defaultConcurrencyQueue } from './concurrency-queue.js'
 import { normalizeSlots } from './accounts.js'
 import {
   inspectGoogleAccount,
   antigravityMetadata,
   antigravityIdentityHeaders,
 } from './code-assist.js'
+import {
+  computeEffectiveResetAt,
+  formatRollingCountdown,
+  VENDOR_WINDOW_MS,
+} from './reset-clock.js'
 
 async function enrichAntigravityAccount(slot, info, store, fetch) {
   if (!info.configured || slot.provider !== 'antigravity') return info
@@ -15,6 +26,7 @@ async function enrichAntigravityAccount(slot, info, store, fetch) {
       validationUrl: blob.validationUrl,
       validationMessage: blob.validationMessage || info.validationMessage || '',
       paidTierName: blob.paidTierName || info.paidTierName || '',
+      plan: blob.plan || info.plan || blob.paidTierName || info.paidTierName || '',
     }
   }
   try {
@@ -37,28 +49,96 @@ async function enrichAntigravityAccount(slot, info, store, fetch) {
         validationUrl: next.validationUrl,
         validationMessage: next.validationMessage,
         paidTierName: next.paidTierName || '',
+        plan: info.plan || next.paidTierName || '',
       }
     }
     if (probe.notice?.message) {
       next.accountNotice = probe.notice.message
       await store.saveBlob(slot.ref, next)
-      return { ...info, accountNotice: next.accountNotice, paidTierName: next.paidTierName || '' }
+      return {
+        ...info,
+        accountNotice: next.accountNotice,
+        paidTierName: next.paidTierName || '',
+        plan: info.plan || next.paidTierName || '',
+      }
     }
     if (probe.projectId || probe.paidTierId) await store.saveBlob(slot.ref, next)
-    return { ...info, paidTierName: next.paidTierName || info.paidTierName || '' }
+    return {
+      ...info,
+      paidTierName: next.paidTierName || info.paidTierName || '',
+      plan: info.plan || next.paidTierName || '',
+    }
   } catch { /* keep settings responsive */ }
   return info
 }
 
-export async function createAccountsView({ live, store, fetch, pmL }) {
+export async function createAccountsView({ live, store, fetch, pmL, pmE, concurrencyQueue = defaultConcurrencyQueue, history = null }) {
   const out = []
+  const qStats = (concurrencyQueue && typeof concurrencyQueue.stats === 'function') ? concurrencyQueue.stats() : null
+  const now = Date.now()
   for (const slot of normalizeSlots(live().slots)) {
-    const info = await enrichAntigravityAccount(slot, await store.describeRef(slot.ref), store, fetch)
+    const rawInfo = await store.describeRef(slot.ref)
+    const info = await enrichAntigravityAccount(slot, rawInfo, store, fetch)
+    const effectiveResetAt = computeEffectiveResetAt(info, slot.provider)
+    const resetCountdown = effectiveResetAt ? formatRollingCountdown(effectiveResetAt, 'en') : ''
+    const slotQ = (qStats && qStats.byKey && qStats.byKey[slot.ref]) || { active: 0, queued: 0 }
+
+    let blob = null
+    try { blob = await store.loadBlob(slot.ref) } catch { /* best effort */ }
+
+    // #556: Capability matrix
+    const capabilities = inspectAccountCapabilities(slot.provider, blob, info)
+
+    // #558: Billing cycle & payment status
+    const billing = extractBillingInfo(blob, slot, now)
+    if (billing.paymentFailed || billing.isOverdue) {
+      try {
+        notifyBillingAlert({
+          ref: slot.ref,
+          provider: slot.provider,
+          status: billing.status,
+          renewsAt: billing.renewsAt,
+          webhookUrl: live()?.webhookUrl,
+          fetchImpl: fetch,
+          nowMs: now,
+        })
+      } catch { /* best-effort alert */ }
+    }
+
+    // #559: Quota pacing runway
+    const remPct = info.quota?.remainingPercent != null
+      ? Number(info.quota.remainingPercent)
+      : (info.usagePercent != null ? Math.max(0, 100 - Number(info.usagePercent)) : null)
+    const runway = calculatePacingRunway(remPct, info.pacePerHour, effectiveResetAt, now)
+
+    // #561: Value delivered & equivalent API cost
+    const accTelem = history && typeof history.accountTelemetry === 'function' ? history.accountTelemetry(slot.ref) : null
+    const valueDelivered = calculateValueDelivered({
+      promptTokens: accTelem?.totalPromptTokens || 0,
+      completionTokens: accTelem?.totalOutputTokens || 0,
+      cacheReadTokens: accTelem?.totalCacheReadTokens || 0,
+      subscriptionCost: slot.monthlyCost || 20.0,
+    })
+
     out.push({
       provider: slot.provider,
       index: slot.index,
       ref: slot.ref,
-      label: pmL(slot.label || info.label),
+      activeStreams: slotQ.active || 0,
+      queuedStreams: slotQ.queued || 0,
+      maxConcurrency: slot.maxConcurrency !== undefined ? slot.maxConcurrency : ((live() && live().accountMaxConcurrency) || 1),
+      label: pmL ? pmL(slot.label || info.label) : (slot.label || info.label),
+      email: typeof pmE === 'function' ? pmE(info.email || '') : String(info.email || ''),
+      plan: info.plan || info.paidTierName || '',
+      avatarUrl: info.avatarUrl || '',
+      scopes: Array.isArray(info.scopes) ? info.scopes : [],
+      scopeWarning: info.scopeWarning || '',
+      selectedOrgId: info.selectedOrgId || '',
+      selectedOrgName: info.selectedOrgName || '',
+      organizations: Array.isArray(info.organizations) ? info.organizations : [],
+      isEncryptedAtRest: Boolean(info.isEncryptedAtRest),
+      isRevoked: Boolean(info.isRevoked),
+      authWarning: info.authWarning || '',
       configured: info.configured,
       writable: info.writable,
       cooldownUntil: info.cooldownUntil,
@@ -72,6 +152,9 @@ export async function createAccountsView({ live, store, fetch, pmL }) {
       usagePercent: info.usagePercent,
       quota: info.quota || null,
       usage: info.usage || null,
+      resetAt: effectiveResetAt || (info.quota && info.quota.resetAt) || null,
+      resetCountdown: resetCountdown || '',
+      resetWindowMs: VENDOR_WINDOW_MS[slot.provider] || 0,
       requests: store.getRequestCount(slot.ref) || null,
       refreshError: info.refreshError || '',
       validationUrl: info.validationUrl || '',
@@ -82,6 +165,15 @@ export async function createAccountsView({ live, store, fetch, pmL }) {
       latencyGrade: info.latencyGrade ?? null,
       lastDoctorVerdict: info.lastDoctorVerdict || null,
       availableModels: info.availableModels || null,
+      capabilities,
+      billing,
+      renewsAt: billing.renewsAt,
+      renewalCountdown: billing.renewalCountdown,
+      billingWarning: billing.warning,
+      runwayMs: runway.runwayMs,
+      runwayText: runway.runwayText,
+      pacingStatus: runway.pacingStatus,
+      valueDelivered,
     })
   }
   return out

package/lib/accounts.js

@@ -45,6 +45,7 @@ import { fetchWithTimeout, isTimeoutError } from "./http.js"
 import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { oauthRef, isProvider } from './refs.js'
 import { parseBlob, serializeBlob } from './blob.js'
+import { encryptWithPassphrase, decryptWithPassphrase } from './crypto.js'
 import { recordSwitch, recordExhaust, recordBroken, computeHealthScore, healthBadge } from './health.js'
 import { executeWithRetry } from './backoff.js'
 import { getVendor } from './vendors/index.js'
@@ -71,6 +72,7 @@ export function normalizeSlots(slots) {
       ref,
       ...(slot.proxyUrl ? { proxyUrl: String(slot.proxyUrl) } : {}),
       ...(slot.expiresAt ? { expiresAt: Number(slot.expiresAt) } : {}),
+      ...(slot.maxConcurrency !== undefined ? { maxConcurrency: Number(slot.maxConcurrency) } : {}),
     })
   }
   return out
@@ -122,15 +124,74 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
   const doctorVerdicts = new Map()
   const dynamicModels = new Map()
   const doFetch = fetchImpl || fetch
+  const clockDrifts = new Map()
+
+  function getClockSkew(provider) {
+    if (!provider) return 0
+    return clockDrifts.get(String(provider).toLowerCase()) || 0
+  }
+
+  function recordClockSkew(provider, vendorDateMsOrHeader) {
+    if (!provider) return
+    const key = String(provider).toLowerCase()
+    if (typeof vendorDateMsOrHeader === 'number') {
+      clockDrifts.set(key, vendorDateMsOrHeader - Date.now())
+    } else if (typeof vendorDateMsOrHeader === 'string') {
+      const parsed = Date.parse(vendorDateMsOrHeader)
+      if (!isNaN(parsed)) {
+        clockDrifts.set(key, parsed - Date.now())
+      }
+    }
+  }
+
   // #88: per-account proxy fetch for token refresh / usage (falls back to doFetch).
   const rawFetchFor = (ref) => (typeof fetchForRef === 'function' && fetchForRef(ref)) || doFetch
-  const fetchFor = (ref, defaultTimeoutMs = 25000) => (url, init, opts) => fetchWithTimeout(rawFetchFor(ref), url, init, { timeoutMs: defaultTimeoutMs, ...(opts || {}) })
+  const fetchFor = (ref, defaultTimeoutMs = 25000, providerHint = null) => async (url, init, opts) => {
+    const res = await fetchWithTimeout(rawFetchFor(ref), url, init, { timeoutMs: defaultTimeoutMs, ...(opts || {}) })
+    try {
+      const dateHeader = res && res.headers && typeof res.headers.get === 'function' ? res.headers.get('date') : null
+      if (dateHeader) {
+        const prov = providerHint || (ref ? String(ref).split('_')[0].toLowerCase() : null)
+        if (prov) recordClockSkew(prov, dateHeader)
+      }
+    } catch { /* best-effort drift extraction */ }
+    return res
+  }
+
+  function resolveMasterKey(passedCfg = null) {
+    const envKey = process.env.DSH_SUBSCRIPTIONS_MASTER_KEY
+    if (typeof envKey === 'string' && envKey.trim()) return envKey.trim()
+    if (passedCfg && typeof passedCfg.masterKey === 'string' && passedCfg.masterKey.trim()) {
+      return passedCfg.masterKey.trim()
+    }
+    return ''
+  }
+
+  function currentMasterKey() {
+    let cfg = null
+    try {
+      cfg = typeof getConfig === 'function' ? getConfig() : null
+    } catch { /* keep env-only fallback */ }
+    return resolveMasterKey(cfg)
+  }
 
   async function resolveRaw(ref) {
     try {
       const resolved = await credentials.resolve(credentialRef(ref))
-      return resolved && resolved.value ? String(resolved.value) : ''
-    } catch {
+      const raw = resolved && resolved.value ? String(resolved.value) : ''
+      if (!raw) return ''
+      if (raw.startsWith('DSHE1:') || raw.startsWith('DSHE2:') || raw.startsWith('DSHE3:')) {
+        const masterKey = currentMasterKey()
+        if (!masterKey) {
+          const err = /** @type {Error & { code?: string }} */ (new Error(`Credentials for ${ref} are encrypted at rest. Configure masterKey in the plugin settings or DSH_SUBSCRIPTIONS_MASTER_KEY to decrypt.`))
+          err.code = 'ENCRYPTED_AT_REST'
+          throw err
+        }
+        return decryptWithPassphrase(raw, masterKey)
+      }
+      return raw
+    } catch (err) {
+      if (err && err.code === 'ENCRYPTED_AT_REST') throw err
       return ''
     }
   }
@@ -158,11 +219,16 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
         return
       }
       try {
-        await credentials.set(credentialRef(ref), serializeBlob(blob))
+        const serialized = serializeBlob(blob)
+        const masterKey = currentMasterKey()
+        const toStore = masterKey ? encryptWithPassphrase(serialized, masterKey) : serialized
+        await credentials.set(credentialRef(ref), toStore)
         if (clearedRefs.has(ref)) {
           try { await credentials.unset(credentialRef(ref)) } catch { /* best-effort */ }
         } else if (credentialVersions.get(ref) > version && latestBlobs.has(ref)) {
-          try { await credentials.set(credentialRef(ref), serializeBlob(latestBlobs.get(ref))) } catch { /* best-effort */ }
+          const nextSerialized = serializeBlob(latestBlobs.get(ref))
+          const nextStore = masterKey ? encryptWithPassphrase(nextSerialized, masterKey) : nextSerialized
+          try { await credentials.set(credentialRef(ref), nextStore) } catch { /* best-effort */ }
         }
       } catch (err) {
         if (clearedRefs.has(ref) || credentialVersions.get(ref) !== version) {
@@ -204,7 +270,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
     windows.delete(ref)
   }
 
-  async function describeRef(ref) {
+  async function describeRef(ref, cfg = null) {
     const base = { ref, configured: false, writable: true, label: '', email: '' }
     try {
       if (typeof credentials.describe === 'function') {
@@ -217,16 +283,34 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
     } catch {
       return base
     }
+    let isEncryptedAtRest = false
+    try {
+      const resolved = await credentials.resolve(credentialRef(ref))
+      const raw = resolved && resolved.value ? String(resolved.value) : ''
+      if (raw.startsWith('DSHE1:') || raw.startsWith('DSHE2:') || raw.startsWith('DSHE3:')) {
+        isEncryptedAtRest = true
+      } else if (Boolean(resolveMasterKey(cfg))) {
+        isEncryptedAtRest = true
+      }
+    } catch { /* best-effort */ }
+
     if (base.configured) {
       try {
         const blob = parseBlob(await resolveRaw(ref))
         base.label = blob.label || blob.email || ''
         base.email = blob.email || ''
+        base.plan = blob.plan || blob.paidTierName || ''
+        base.avatarUrl = blob.avatarUrl || ''
+        base.scopes = Array.isArray(blob.scopes) ? blob.scopes : []
+        base.scopeWarning = blob.scopeWarning || ''
         if (Array.isArray(blob.usage)) { base.usage = blob.usage; base.usageAt = blob.usageAt || 0 }
         if (blob.validationUrl) base.validationUrl = blob.validationUrl
         if (blob.validationMessage) base.validationMessage = blob.validationMessage
         if (blob.accountNotice) base.accountNotice = blob.accountNotice
         if (blob.paidTierName) base.paidTierName = blob.paidTierName
+        base.selectedOrgId = blob.selectedOrgId || blob.accountId || blob.projectId || ''
+        base.selectedOrgName = blob.selectedOrgName || base.selectedOrgId || ''
+        base.organizations = Array.isArray(blob.organizations) ? blob.organizations : []
       } catch { /* ignore parse */ }
     }
     return {
@@ -245,6 +329,24 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
       usagePercent: usage.has(ref) ? usage.get(ref) : null,
       refreshError: refreshFailures.get(ref)?.error || '',
       isTimeout: !!refreshFailures.get(ref)?.isTimeout,
+      plan: base.plan || '',
+      avatarUrl: base.avatarUrl || '',
+      scopes: base.scopes || [],
+      scopeWarning: base.scopeWarning || '',
+      selectedOrgId: base.selectedOrgId || '',
+      selectedOrgName: base.selectedOrgName || '',
+      organizations: base.organizations || [],
+      isEncryptedAtRest,
+      isRevoked: Boolean(
+        (quarantines.get(ref)?.reason === 'REVOKED' || quarantines.get(ref)?.reason === 'SESSION_REVOKED') ||
+        (doctorVerdicts.get(ref)?.code === 'TOKEN_EXPIRED' || doctorVerdicts.get(ref)?.code === 'TOKEN_REVOKED') ||
+        (/invalid_grant|token_revoked|revoked|session expired/i.test(refreshFailures.get(ref)?.error || ''))
+      ),
+      authWarning: (
+        (quarantines.get(ref)?.reason === 'REVOKED' || quarantines.get(ref)?.reason === 'SESSION_REVOKED') ||
+        (doctorVerdicts.get(ref)?.code === 'TOKEN_EXPIRED' || doctorVerdicts.get(ref)?.code === 'TOKEN_REVOKED') ||
+        (/invalid_grant|token_revoked|revoked|session expired/i.test(refreshFailures.get(ref)?.error || ''))
+      ) ? 'Session expired / revoked — re-authorization required' : '',
       validationUrl: base.validationUrl || '',
       validationMessage: base.validationMessage || '',
       accountNotice: base.accountNotice || '',
@@ -261,7 +363,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
     const slots = normalizeSlots(curConfig.slots).filter((s) => s.provider === provider)
     const out = []
     for (const slot of slots) {
-      const info = await describeRef(slot.ref)
+      const info = await describeRef(slot.ref, curConfig)
       const q = quarantines.get(slot.ref)
       out.push({
         ref: slot.ref,
@@ -276,6 +378,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
         quarantineReason: q ? q.reason : null,
         label: slot.label || info.label,
         pacePerHour: info.pacePerHour || 0,
+        maxConcurrency: slot.maxConcurrency !== undefined ? slot.maxConcurrency : (curConfig.accountMaxConcurrency || 1),
       })
     }
     return out
@@ -286,7 +389,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
     const slots = normalizeSlots(curConfig.slots)
     const found = new Set()
     for (const slot of slots) {
-      const info = await describeRef(slot.ref)
+      const info = await describeRef(slot.ref, curConfig)
       if (info.configured) found.add(slot.provider)
     }
     return [...found]
@@ -296,15 +399,34 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
     if (!blob || typeof blob !== 'object') return blob
     if (blob.apiKeyOnly || (blob.apiKey && (!blob.refreshToken || blob.refreshToken === blob.apiKey))) return blob
     if (!blob.refreshToken) return blob
-    if (blob.expiresAt && blob.expiresAt - SKEW_MS > Date.now()) return blob
+
+    const curConfig = getConfig()
+    const safetyMargin = Math.max(SKEW_MS, Number(curConfig?.refreshAheadMs) || (5 * 60 * 1000))
+    const clockSkew = getClockSkew(provider)
+    const adjustedNow = Date.now() + clockSkew
+
+    if (blob.expiresAt && blob.expiresAt - safetyMargin > adjustedNow) return blob
+
+    if (ref && refreshFailures.has(ref)) {
+      const failInfo = refreshFailures.get(ref)
+      const retryMs = Math.min(Number(curConfig?.refreshRetryMs) || 10000, 60000)
+      if (Date.now() - (failInfo.at || 0) < retryMs) {
+        if (blob.expiresAt && blob.expiresAt > adjustedNow && blob.accessToken) {
+          return blob
+        }
+        const err = /** @type {Error & { code?: string }} */ (new Error(`Token refresh in backoff window after failure: ${failInfo.error || 'transient failure'}`))
+        err.code = 'TOKEN'
+        throw err
+      }
+    }
+
     const lockKey = ref || (provider + ":" + (blob.accountId || blob.email || (blob.refreshToken && blob.refreshToken.slice(-16)) || "anon"))
     if (refreshLocks.has(lockKey)) return refreshLocks.get(lockKey)
     const promise = (async () => {
       try {
-        const curConfig = getConfig()
         const cfg = vendorConfig(provider, curConfig)
         const next = await executeWithRetry(
-          () => getVendor(provider).refresh(cfg, blob, fetchFor(ref, 30000)),
+          () => getVendor(provider).refresh(cfg, blob, fetchFor(ref, 30000, provider)),
           {
             maxRetries: 2,
             initialDelayMs: 300,
@@ -446,6 +568,8 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
     resolveRaw,
     ensureFresh,
     refreshUsage,
+    getClockSkew,
+    recordClockSkew,
     // #87: family-scoped cooldowns. families=null blocks the whole account
     // (legacy behavior); a list blocks only those model families.
     rememberCooldown(ref, until, families) {
@@ -486,6 +610,8 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
         quotaSamples.delete(ref)
       }
     },
+    clearRefreshFailure(ref) { if (ref) refreshFailures.delete(ref) },
+    clearCooldown(ref) { if (ref) cooldowns.delete(ref) },
     shouldSkipRefresh(ref, now, retryMs) { const f = refreshFailures.get(ref); if (!f) return false; return (Number(f.at) + Number(retryMs)) > Number(now) },
     getQuota(ref) { return quotas.get(ref) || null },
     rememberUsage(ref, percent) { usage.set(ref, percent) },

package/lib/adapter.js

@@ -180,6 +180,9 @@ export class SubscriptionAdapter extends LlmAdapter {
               deps.rememberQuarantine(account.ref, account.quarantineReason || 'RATE_LIMIT', account.quarantineUntil || account.cooldownUntil, account.quarantineAttempts || 1)
             }
           }
+          if (account.quarantineReason === 'REVOKED' || account.isRevoked) {
+            if (typeof deps.recordBroken === 'function') deps.recordBroken(account.ref)
+          }
           if (typeof deps.recordSwitch === 'function') deps.recordSwitch(account.ref)
         },
         streamOnce: async function* (account, opts) {

package/lib/alerts.js

@@ -209,3 +209,38 @@ export function notifyQuarantineReleased({
   }
   return alert
 }
+
+/**
+ * #558: Fires an alert when a subscription experiences a billing failure or overdue renewal.
+ */
+export function notifyBillingAlert({
+  ref,
+  provider,
+  status,
+  renewsAt,
+  message,
+  webhookUrl = '',
+  fetchImpl = fetch,
+  nowMs = Date.now(),
+}) {
+  const isFailed = status === 'past_due' || status === 'unpaid' || status === 'payment_failed'
+  const severity = isFailed ? 'error' : 'warn'
+  const defaultMsg = isFailed
+    ? `Billing alert: ${provider || 'Account'} (${ref || 'slot'}) has payment issue (${status}).`
+    : `Subscription renewal alert: ${provider || 'Account'} (${ref || 'slot'}) renewal is overdue.`
+
+  const alert = recordAlert({
+    type: 'billing_status',
+    ref,
+    provider,
+    message: message || defaultMsg,
+    severity,
+    details: { status, renewsAt },
+    nowMs,
+  })
+
+  if (alert && webhookUrl) {
+    dispatchWebhookAlert(alert, webhookUrl, fetchImpl).catch(() => {})
+  }
+  return alert
+}

package/lib/analytics.js

@@ -1,3 +1,5 @@
+import { calculateValueDelivered } from './pricing.js'
+import { calculatePacingRunway } from './forecast.js'
 // Subscription and cache analytics, performance aggregates, and quota forecasting.
 // Enforces 0 Cyrillic characters.
 
@@ -240,6 +242,11 @@ export function calculateAccountBreakdown(entries = [], accounts = []) {
       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,
+      valueDelivered: calculateValueDelivered({
+        promptTokens: acc.promptTokens,
+        completionTokens: acc.completionTokens,
+        cacheReadTokens: acc.cacheReadTokens,
+      }),
     }
   }
   return result
@@ -307,18 +314,28 @@ export function calculateQuotaForecast(accounts = [], entries = [], nowMs = Date
       }
     }
 
+    const qPct = quota && typeof quota.percentage === 'number'
+      ? quota.percentage
+      : (acc.usagePercent != null ? Math.max(0, 100 - Number(acc.usagePercent)) : null)
+    const qReset = quota && typeof quota.resetAt === 'number' ? quota.resetAt : (acc.resetAt || null)
+    const runway = calculatePacingRunway(qPct, acc.pacePerHour || 0, qReset, nowMs)
+
     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,
+      quotaPercent: qPct,
+      resetAt: qReset,
       burnRateTokensPerHour,
       requests24h,
       tokens24h,
       hoursToExhaustion,
       willExhaustBeforeReset,
       projectedExhaustionAt,
+      runwayHours: runway.runwayHours,
+      runwayMs: runway.runwayMs,
+      runwayText: runway.runwayText,
+      pacingStatus: runway.pacingStatus,
     })
   }
 
@@ -326,6 +343,17 @@ export function calculateQuotaForecast(accounts = [], entries = [], nowMs = Date
 }
 
 export function calculateAnalytics(entries = [], accounts = [], nowMs = Date.now()) {
+  let totalPrompt = 0, totalCompletion = 0, totalCacheRead = 0
+  for (const r of entries) {
+    totalPrompt += Number(r.inputTokens || (r.tokens && r.tokens.prompt) || 0)
+    totalCompletion += Number(r.outputTokens || (r.tokens && r.tokens.completion) || 0)
+    totalCacheRead += Number(r.cacheReadTokens || (r.tokens && r.tokens.cacheRead) || 0)
+  }
+  const valueDelivered = calculateValueDelivered({
+    promptTokens: totalPrompt,
+    completionTokens: totalCompletion,
+    cacheReadTokens: totalCacheRead,
+  })
   return {
     generatedAt: new Date(nowMs).toISOString(),
     totalRequests: entries.length,
@@ -334,5 +362,6 @@ export function calculateAnalytics(entries = [], accounts = [], nowMs = Date.now
     hourly: calculateHourlyBuckets(entries, nowMs),
     accounts: calculateAccountBreakdown(entries, accounts),
     forecast: calculateQuotaForecast(accounts, entries, nowMs),
+    valueDelivered,
   }
 }