@goodandready/dsh-subscriptions 0.6.70 → 0.6.71

package/README.md

@@ -207,7 +207,7 @@ const res = await ctx.subscriptions.request('codex', '/backend-api/codex/images/
 * **In-App Toast Alerts (`enableToasts`)**: Lightweight floating toast alerts in the DSH chat interface notifying you when accounts enter quarantine, recover from cooldowns, or exceed quota safety thresholds.
 * **Automated Webhook Integration**: Instant event notifications dispatched via `notifyQuarantineEntered` and `notifyQuarantineReleased`.
 
-### 24. 🛡️ Resilience, Diagnostics & Fallback Enhancements (v0.6.70)
+### 24. 🛡️ Resilience, Diagnostics & Fallback Enhancements (v0.6.71)
 * **Cross-Vendor Cascading Fallback & Provider Priority Ordering (#536)**: Configure fallback ordering across subscription providers with interactive reordering in WebUI.
 * **1-Click Connection Smoke Test & Latency Ping (#536)**: Test individual account connections on the spot with real-time latency badges.
 * **Live Cooldown Countdown & Availability Toasts (#536)**: Exact countdown timer for cooled-down accounts and automated toast alerts upon recovery.

package/README.ru.md

@@ -183,7 +183,7 @@ const res = await ctx.subscriptions.request('codex', '/backend-api/codex/images/
 * **Всплывающие уведомления (Toast Alerts)**: Легковесные всплывающие тосты в веб-интерфейсе DSH при событиях карантина (с отображением причины), восстановлении доступа и критическом расходе квоты. Включение управляется параметром `enableToasts` (по умолчанию `true`).
 * **Интеграция с вебхуками**: Автоматическая отправка уведомлений через `notifyQuarantineEntered` и `notifyQuarantineReleased`.
 
-### 20. 🛡️ Отказоустойчивость, диагностика и порядок фолбэка (v0.6.70)
+### 20. 🛡️ Отказоустойчивость, диагностика и порядок фолбэка (v0.6.71)
 * **Межвендорный каскадный фолбэк с настройкой очередности (#536)**: Настройка порядка переключения провайдеров при исчерпании квот с интерактивным изменением приоритета (▲/▼) в WebUI.
 * **1-Click проверка подключения и пинг задержки (#536)**: Проверка конкретного аккаунта в один клик с отображением задержки (`✓ 240ms`).
 * **Живой таймер кулдауна и уведомления о восстановлении (#536)**: Точный обратный отсчет кулдауна и всплывающие in-app тосты при возвращении аккаунта в строй.

package/README.zh.md

@@ -132,7 +132,7 @@ graph LR
   queueTimeoutMs: 30000     # v0.6.62: 队列最大等待超时时间（毫秒）
 * **自动化 Webhook 告警集成**：通过 `notifyQuarantineEntered` 与 `notifyQuarantineReleased` 自动向外部通知系统派发隔离生命周期事件。
 
-### 🛡️ 弹性容灾、故障诊断与跨服务商回退 (v0.6.70)
+### 🛡️ 弹性容灾、故障诊断与跨服务商回退 (v0.6.71)
 * **跨服务商级联故障转移与优先级排序 (#536)**: 支持自定义跨服务商回退顺序，可在 WebUI 中通过 ▲/▼ 交互调整优先级。
 * **一键链路测试与延迟检测 (#536)**: 在账户列表或状态弹窗中一键发起探活并显示往返延迟。
 * **冷却倒计时与就绪通知 (#536)**: 实时展示受限账户恢复倒计时，解除冷却时自动弹出就绪通知。

package/lib/adapter-manager.js

@@ -45,6 +45,8 @@ export function createAdapterManager({
     drainBeforeReset: () => live().drainBeforeReset,
     drainSafetyPercent: () => live().drainSafetyPercent,
     switchAtRemaining: () => live().switchAtRemaining,
+    rotationStrategy: () => live().rotationStrategy,
+    enableSoftFailureSentinel: () => live().enableSoftFailureSentinel,
     rememberCooldown: (ref, until, families) => store.rememberCooldown(ref, until, families),
     rememberQuarantine: (ref, reason, until, attempts) => store.rememberQuarantine(ref, reason, until, attempts),
     getQuarantine: (ref) => store.getQuarantine(ref),

package/lib/adapter.js

@@ -142,6 +142,12 @@ export class SubscriptionAdapter extends LlmAdapter {
       const effectiveDrainSafetyPercent = options.drainSafetyPercent !== undefined
         ? options.drainSafetyPercent
         : (typeof deps.drainSafetyPercent === 'function' ? deps.drainSafetyPercent() : (deps.drainSafetyPercent ?? 5))
+      const effectiveRotationStrategy = options.rotationStrategy !== undefined
+        ? options.rotationStrategy
+        : (typeof deps.rotationStrategy === 'function' ? deps.rotationStrategy() : (deps.rotationStrategy ?? 'round-robin'))
+      const effectiveSoftFailureSentinel = options.enableSoftFailureSentinel !== undefined
+        ? options.enableSoftFailureSentinel
+        : (typeof deps.enableSoftFailureSentinel === 'function' ? deps.enableSoftFailureSentinel() : (deps.enableSoftFailureSentinel ?? true))
       const sessionId = options.sessionId || options.session_id || options.conversationId
       const effectiveReasoning = resolveEffectiveReasoning(sessionId, options)
       const decisionTrace = {}
@@ -153,6 +159,8 @@ export class SubscriptionAdapter extends LlmAdapter {
         autoPacing: effectiveAutoPacing,
         drainBeforeReset: effectiveDrainBeforeReset,
         drainSafetyPercent: effectiveDrainSafetyPercent,
+        rotationStrategy: effectiveRotationStrategy,
+        enableSoftFailureSentinel: effectiveSoftFailureSentinel,
       }
       for await (const event of streamWithRotation({
         accounts: await deps.listAccounts(provider),

package/lib/client.js

@@ -436,6 +436,13 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "cascadingFallbackHint": "Automatically route queries to alternative providers when all accounts of a primary provider are exhausted.",
       "cascadingFallbackOrder": "Fallback Provider Order",
       "cascadingFallbackOrderHint": "Sequence of alternative providers to try when primary accounts are exhausted.",
+      "rotationStrategy": "Account Balancing Strategy",
+      "rotationStrategyHint": "Method used to distribute requests among available accounts of a provider.",
+      "rotationRoundRobin": "Round-Robin (Balanced rotation)",
+      "rotationLeastLoaded": "Least-Loaded (Fair-share quota)",
+      "rotationPriority": "Priority (Sequential by index/weight)",
+      "softFailureSentinel": "Soft-Failure & Refusal Sentinel",
+      "softFailureSentinelHint": "Detects HTTP 200 capacity apologies and auto-cascades to the next healthy account before streaming.",
       "recentErrors": "Recent Runtime Errors",
       "recentErrorsDesc": "Last 20 runtime failures across model streams and providers (sanitized).",
       "recentErrorsClear": "Clear Log",
@@ -719,6 +726,13 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "cascadingFallbackHint": "当首选服务商所有账户配额耗尽或限流时，自动无缝转接至备选服务商。",
       "cascadingFallbackOrder": "故障转移供应商顺序",
       "cascadingFallbackOrderHint": "首选服务商耗尽时按此顺序依次尝试备选服务商。",
+      "rotationStrategy": "账户负载均衡策略",
+      "rotationStrategyHint": "在同一服务商的多个可用账户之间分发请求的方式。",
+      "rotationRoundRobin": "轮询均衡（标准交替）",
+      "rotationLeastLoaded": "最少负载优先（配额公平共享）",
+      "rotationPriority": "优先级顺序（按序号/权重顺序）",
+      "softFailureSentinel": "软性拒绝与容量哨兵",
+      "softFailureSentinelHint": "自动识别 HTTP 200 状态下的服务商容量道歉并无缝转接至下一个正常账户。",
       "recentErrors": "最近运行错误记录",
       "recentErrorsDesc": "最近 20 条流式传输与 API 调用失败记录（已脱敏）。",
       "recentErrorsClear": "清空记录",
@@ -2158,6 +2172,33 @@ const cssId = 'dsh-subscriptions/settings.module.css'
                 )
               ) : null,
             ),
+            React.createElement('div', { className: 'dsub-row', style: { marginTop: 12 } },
+              React.createElement('label', { style: { display: 'flex', flexDirection: 'column', gap: 4 } },
+                React.createElement('span', { style: { fontWeight: 600 } }, t('rotationStrategy')),
+                React.createElement('span', { className: 'dsub-sub' }, t('rotationStrategyHint')),
+                React.createElement('select', {
+                  className: 'dsub-select',
+                  value: draft.rotationStrategy || 'round-robin',
+                  onChange: (e) => setDraft((d) => Object.assign({}, d, { rotationStrategy: e.target.value })),
+                  style: { maxWidth: 320, marginTop: 4 }
+                },
+                  React.createElement('option', { value: 'round-robin' }, t('rotationRoundRobin')),
+                  React.createElement('option', { value: 'least-loaded' }, t('rotationLeastLoaded')),
+                  React.createElement('option', { value: 'priority' }, t('rotationPriority')),
+                ),
+              ),
+            ),
+            React.createElement('div', { className: 'dsub-row', style: { marginTop: 12 } },
+              React.createElement('label', { style: { display: 'flex', alignItems: 'center', gap: 8, cursor: 'pointer' } },
+                React.createElement('input', {
+                  type: 'checkbox',
+                  checked: draft.enableSoftFailureSentinel !== false,
+                  onChange: (e) => setDraft((d) => Object.assign({}, d, { enableSoftFailureSentinel: e.target.checked })),
+                }),
+                React.createElement('span', null, t('softFailureSentinel')),
+              ),
+              React.createElement('div', { className: 'dsub-sub' }, t('softFailureSentinelHint')),
+            ),
           ),
         ),
         React.createElement('div', { className: 'dsub-block' },

package/lib/config-schema.js

@@ -110,6 +110,10 @@ export const Config = z.object({
     .description('#349 Opt-in cross-vendor fallback when all accounts of a provider are exhausted or rate limited.'),
   cascadingFallbackOrder: z.array(z.string()).volatile().default(PROVIDERS)
     .description('Configurable global priority sequence for cross-vendor fallback.'),
+  rotationStrategy: z.string().volatile().default('round-robin')
+    .description('Load balancing strategy among available accounts: round-robin (balanced), least-loaded (fair-share quota), or priority (sequential).'),
+  enableSoftFailureSentinel: z.boolean().volatile().default(true)
+    .description('Intercept HTTP 200 soft-failure capacity apologies and automatically cascade to next healthy account.'),
   cascadingChain: z.any().volatile().default({})
     .description('#349 Custom cross-vendor fallback chains (e.g. { claude: ["copilot", "cursor"] }).'),
   webhookUrl: z.string().volatile().default('')

package/lib/diagnostics.js

@@ -83,6 +83,8 @@ export async function createDiagnosticsReport({ live, store, history, NS, pkgVer
       proxySlots: slots.filter((s) => s.proxyUrl).length,
       cascadingFallback: !!cfg.cascadingFallback,
       cascadingFallbackOrder: cfg.cascadingFallbackOrder || PROVIDERS,
+      rotationStrategy: cfg.rotationStrategy || 'round-robin',
+      enableSoftFailureSentinel: cfg.enableSoftFailureSentinel !== false,
     },
   })
 }

package/lib/quarantine.js

@@ -3,6 +3,7 @@ export const REASON_RATE_LIMIT = 'RATE_LIMIT'
 export const REASON_HARD_LIMIT = 'HARD_LIMIT'
 export const REASON_REVOKED = 'TOKEN_REVOKED'
 export const REASON_MANUAL_PARK = 'MANUAL_PARK'
+export const REASON_DEGRADED = 'DEGRADED_CAPACITY'
 
 export const STATUS_ACTIVE = 'active'
 export const STATUS_QUARANTINE = 'quarantine'
@@ -16,18 +17,21 @@ export function quarantineDuration(reason) {
       return 7 * 24 * 60 * 60 * 1000 // 7 days (requires re-auth)
     case REASON_MANUAL_PARK:
       return 60 * 60 * 1000 // 1 hour (manual park)
+    case REASON_DEGRADED:
+      return 5 * 60 * 1000 // 5 minutes degraded cooldown
     case REASON_RATE_LIMIT:
     default:
       return 60 * 60 * 1000 // 1 hour
   }
 }
 
-export function putInQuarantine(account, reason, nowMs = Date.now()) {
+export function putInQuarantine(account, reason, nowMs = Date.now(), customUntil = null) {
   const duration = quarantineDuration(reason)
+  const until = (customUntil && Number(customUntil) > Number(nowMs)) ? Number(customUntil) : (Number(nowMs) + duration)
   return {
     ...account,
     quarantineReason: reason,
-    quarantineUntil: nowMs + duration,
+    quarantineUntil: until,
     status: STATUS_QUARANTINE,
   }
 }

package/lib/reset-clock.js

@@ -0,0 +1,87 @@
+import { parseHeaders } from './ratelimit.js'
+
+export const VENDOR_WINDOW_MS = {
+  claude: 5 * 3600 * 1000,
+  codex: 3 * 3600 * 1000,
+  grok: 2 * 3600 * 1000,
+}
+
+export function parseResetFromText(message, nowMs = Date.now()) {
+  if (!message || typeof message !== 'string') return null
+  const s = message.trim()
+
+  const secMatch = s.match(/(?:try again in|retry after|wait|resets? in)\s+(\d+)\s*(?:s|sec|seconds?)/i)
+  if (secMatch) {
+    const sec = Number(secMatch[1])
+    if (Number.isFinite(sec) && sec > 0) return nowMs + sec * 1000
+  }
+
+  const minMatch = s.match(/(?:try again in|retry after|wait|resets? in)\s+(\d+)\s*(?:m|min|minutes?)/i)
+  if (minMatch) {
+    const min = Number(minMatch[1])
+    if (Number.isFinite(min) && min > 0) return nowMs + min * 60 * 1000
+  }
+
+  const hrMatch = s.match(/(?:try again in|retry after|wait|resets? in)\s+(\d+)\s*(?:h|hr|hours?)/i)
+  if (hrMatch) {
+    const hr = Number(hrMatch[1])
+    if (Number.isFinite(hr) && hr > 0) return nowMs + hr * 3600 * 1000
+  }
+
+  return null
+}
+
+export function resolveAccurateReset(err, account, provider, nowMs = Date.now(), safetyBufferMs = 10000) {
+  const now = Number(nowMs) || Date.now()
+  let targetReset = null
+
+  if (err && err.resetAt) {
+    const val = Number(err.resetAt)
+    if (Number.isFinite(val) && val > now) {
+      targetReset = val
+    }
+  }
+
+  if (!targetReset && err) {
+    const headers = err.headers || (err.response && err.response.headers)
+    if (headers) {
+      const parsed = parseHeaders(headers, now)
+      if (parsed && parsed.resetAt && parsed.resetAt > now) {
+        targetReset = parsed.resetAt
+      }
+    }
+  }
+
+  if (!targetReset && err && err.retryAfter) {
+    const n = Number(err.retryAfter)
+    if (Number.isFinite(n) && n > 0) {
+      targetReset = n > 1e9 ? (n > 1e12 ? n : n * 1000) : now + n * 1000
+    }
+  }
+
+  if (!targetReset && err && err.message) {
+    const textReset = parseResetFromText(err.message, now)
+    if (textReset && textReset > now) {
+      targetReset = textReset
+    }
+  }
+
+  if (!targetReset && account && account.quota && account.quota.resetAt) {
+    const qReset = Number(account.quota.resetAt)
+    if (Number.isFinite(qReset) && qReset > now) {
+      targetReset = qReset
+    }
+  }
+
+  if (targetReset && targetReset > now && targetReset <= now + 7 * 86400 * 1000) {
+    return targetReset + (Number(safetyBufferMs) || 0)
+  }
+
+  const p = String(provider || (account && account.provider) || '').toLowerCase()
+  const windowDefault = VENDOR_WINDOW_MS[p]
+  if (windowDefault && err && (err.status === 429 || err.code === 'RATE_LIMIT' || err.code === 'QUOTA')) {
+    return now + windowDefault + (Number(safetyBufferMs) || 0)
+  }
+
+  return null
+}

package/lib/rotate.js

@@ -7,6 +7,7 @@ const SWITCH_CODES = new Set([
   'QUOTA',
   'QUOTA_EXCEEDED',
   'LICENSE_REQUIRED',
+  'SOFT_FAILURE',
 ])
 
 export function isRegionError(err) {
@@ -18,7 +19,7 @@ export function isRegionError(err) {
 
 export function isSwitchableError(err) {
   if (!err || typeof err !== 'object') return false
-  if (err.name === 'TimeoutError' || err.code === 'TIMEOUT' || err.code === 'EMPTY_RESPONSE') return true
+  if (err.name === 'TimeoutError' || err.code === 'TIMEOUT' || err.code === 'EMPTY_RESPONSE' || err.code === 'SOFT_FAILURE' || err.isSoftFailure) return true
   if (err.name === 'AbortError' || err.code === 'ABORT_ERR' || err.code === 'ERR_ABORTED' || (err.message && /aborted/i.test(err.message))) return false
   const code = err.code || (err.failure && err.failure.code)
   if (SWITCH_CODES.has(code)) return true
@@ -263,6 +264,33 @@ export function pickAccountWithTrace(accounts, nowMs, opts) {
           }
         }
 
+        const strategy = (opts && opts.rotationStrategy) || 'round-robin'
+        if (strategy === 'least-loaded') {
+          const aRem = getAccountRemainingPercent(a)
+          const bRem = getAccountRemainingPercent(b)
+          if (aRem != null && bRem != null) {
+            if (Math.abs(aRem - bRem) >= 5) {
+              return bRem - aRem
+            }
+          } else if (aRem != null && bRem == null) {
+            return -1
+          } else if (aRem == null && bRem != null) {
+            return 1
+          }
+          if (a.usagePercent != null && b.usagePercent != null) {
+            if (Math.abs(Number(a.usagePercent) - Number(b.usagePercent)) >= 5) {
+              return Number(a.usagePercent) - Number(b.usagePercent)
+            }
+          }
+        } else if (strategy === 'priority') {
+          const aWeight = a.weight || (a.isPro ? 5 : 1)
+          const bWeight = b.weight || (b.isPro ? 5 : 1)
+          if (aWeight !== bWeight) return bWeight - aWeight
+          const aIdx = list.indexOf(a)
+          const bIdx = list.indexOf(b)
+          if (aIdx !== -1 && bIdx !== -1 && aIdx !== bIdx) return aIdx - bIdx
+        }
+
         // 0. Auto-Pacing: lower pacing risk preferred (#352)
         const aRisk = Number(a.pacingRisk) || 0
         const bRisk = Number(b.pacingRisk) || 0
@@ -333,14 +361,17 @@ export function pickAccount(accounts, nowMs, opts) {
   return res ? res.account : null
 }
 
-export function markCooldown(account, nowMs, cooldownMs, family) {
+export function markCooldown(account, nowMs, cooldownMs, family, customUntil = null) {
   const wait = Number(cooldownMs)
   const ms = Number.isFinite(wait) && wait > 0 ? wait : 30 * 60 * 1000
+  const until = (customUntil && Number(customUntil) > (Number(nowMs) || 0))
+    ? Number(customUntil)
+    : ((Number(nowMs) || 0) + ms)
   const prev = Array.isArray(account.cooldownFamilies) ? account.cooldownFamilies.slice() : []
   const fams = family ? (prev.includes(family) ? prev : prev.concat(family)) : prev
   return {
     ...account,
-    cooldownUntil: (Number(nowMs) || 0) + ms,
+    cooldownUntil: until,
     ...(fams.length ? { cooldownFamilies: fams } : {}),
   }
 }

package/lib/sentinel.js

@@ -0,0 +1,136 @@
+export const SOFT_FAILURE_PATTERNS = [
+  /currently (?:unable to process|unavailable|overloaded)/i,
+  /experiencing (?:exceptionally )?(?:high|heavy) (?:traffic|demand|load)/i,
+  /capacity (?:is )?temporarily (?:unavailable|limited|exceeded)/i,
+  /model is (?:currently )?(?:overloaded|busy)/i,
+  /due to high traffic/i,
+  /usage cap reached, switching to lower/i,
+  /you have reached your (?:current )?usage limit/i,
+  /server is currently under heavy load/i,
+  /i apologize, but (?:i am unable to assist|i cannot fulfill this request due to (?:high demand|capacity|server load))/i,
+  /our systems are experiencing heavy load/i,
+]
+
+const SUSPICIOUS_ROOTS = [
+  'i am',
+  'i apologize',
+  'we are',
+  'capacity',
+  'the model',
+  'due to',
+  'usage cap',
+  'you have reached',
+  'server is',
+  'our systems',
+]
+
+export function extractChunkText(chunk) {
+  if (!chunk) return ''
+  if (typeof chunk === 'string') return chunk
+  if (typeof chunk.delta === 'string') return chunk.delta
+  if (typeof chunk.content === 'string') return chunk.content
+  if (typeof chunk.text === 'string') return chunk.text
+  if (chunk.choices && Array.isArray(chunk.choices) && chunk.choices[0]) {
+    const c0 = chunk.choices[0]
+    if (c0.delta && typeof c0.delta.content === 'string') return c0.delta.content
+    if (typeof c0.text === 'string') return c0.text
+  }
+  if (chunk.candidates && Array.isArray(chunk.candidates) && chunk.candidates[0]) {
+    const cand = chunk.candidates[0]
+    if (cand.content && Array.isArray(cand.content.parts)) {
+      return cand.content.parts.map((p) => (p && typeof p.text === 'string' ? p.text : '')).join('')
+    }
+  }
+  return ''
+}
+
+export function detectSoftFailure(text) {
+  if (!text || typeof text !== 'string') return null
+  const cleaned = text.trim()
+  if (!cleaned) return null
+  for (const pattern of SOFT_FAILURE_PATTERNS) {
+    if (pattern.test(cleaned)) {
+      return pattern.toString()
+    }
+  }
+  return null
+}
+
+export function isCandidatePrefix(text) {
+  if (!text) return true
+  const low = text.toLowerCase().trim()
+  if (low.length < 3) return true
+  for (const root of SUSPICIOUS_ROOTS) {
+    if (root.startsWith(low) || low.startsWith(root)) {
+      return true
+    }
+  }
+  return false
+}
+
+export function createSoftFailureError(pattern, text) {
+  const preview = String(text || '').slice(0, 120).replace(/\s+/g, ' ')
+  const err = new Error(`Soft-failure detected: ${preview}`)
+  return Object.assign(err, {
+    name: 'SoftFailureError',
+    code: 'SOFT_FAILURE',
+    status: 429,
+    isSoftFailure: true,
+    degraded: true,
+    pattern,
+  })
+}
+
+export async function* withSoftFailureSentinel(stream, options = {}) {
+  const enabled = options.enabled !== false
+  if (!enabled || !stream) {
+    if (stream) {
+      for await (const chunk of stream) {
+        yield chunk
+      }
+    }
+    return
+  }
+
+  const bufferLimitChars = Number(options.bufferLimitChars) || 250
+  const maxBufferChunks = Number(options.maxBufferChunks) || 4
+
+  const bufferedChunks = []
+  let accumulatedText = ''
+  let flushed = false
+
+  for await (const chunk of stream) {
+    if (flushed) {
+      yield chunk
+      continue
+    }
+
+    bufferedChunks.push(chunk)
+    accumulatedText += extractChunkText(chunk)
+
+    const matched = detectSoftFailure(accumulatedText)
+    if (matched) {
+      throw createSoftFailureError(matched, accumulatedText)
+    }
+
+    const candidate = isCandidatePrefix(accumulatedText)
+    if (!candidate || accumulatedText.length >= bufferLimitChars || bufferedChunks.length >= maxBufferChunks) {
+      flushed = true
+      for (const b of bufferedChunks) {
+        yield b
+      }
+      bufferedChunks.length = 0
+    }
+  }
+
+  if (!flushed) {
+    const matched = detectSoftFailure(accumulatedText)
+    if (matched) {
+      throw createSoftFailureError(matched, accumulatedText)
+    }
+    for (const b of bufferedChunks) {
+      yield b
+    }
+    bufferedChunks.length = 0
+  }
+}

package/lib/stream-rotate.js

@@ -1,10 +1,12 @@
 import { defaultConcurrencyQueue } from './concurrency-queue.js'
 import { recordSessionCacheUsage } from './session-pin.js'
 import { pickAccountWithTrace, markCooldown, isSwitchableError, isRegionError, modelFamily } from './rotate.js'
-import { putInQuarantine, REASON_RATE_LIMIT, REASON_HARD_LIMIT, REASON_REVOKED } from './quarantine.js'
+import { putInQuarantine, REASON_RATE_LIMIT, REASON_HARD_LIMIT, REASON_REVOKED, REASON_DEGRADED } from './quarantine.js'
 import { notifySessionExpired, notifyQuarantineEntered } from './alerts.js'
 import { withRunawayGuard } from './runaway-guard.js'
 import { defaultErrorBuffer } from './error-buffer.js'
+import { withSoftFailureSentinel } from './sentinel.js'
+import { resolveAccurateReset } from './reset-clock.js'
 
 export async function* streamWithRotation({
   accounts,
@@ -55,6 +57,7 @@ export async function* streamWithRotation({
       autoPacing: options && (options.autoPacing !== undefined ? options.autoPacing : (options.config && options.config.autoPacing)),
       drainBeforeReset: options && (options.drainBeforeReset !== undefined ? options.drainBeforeReset : (options.config && options.config.drainBeforeReset)),
       drainSafetyPercent: options && (options.drainSafetyPercent !== undefined ? options.drainSafetyPercent : (options.config && options.config.drainSafetyPercent)),
+      rotationStrategy: options && (options.rotationStrategy !== undefined ? options.rotationStrategy : (options.config && options.config.rotationStrategy)),
     })
     const account = pickRes.account
 
@@ -147,7 +150,10 @@ export async function* streamWithRotation({
           streamOnce(account, { ...options, _runawayState: runawayState }),
           runawayOpts
         )
-        for await (const chunk of guardedStream) {
+        const sentineledStream = withSoftFailureSentinel(guardedStream, {
+          enabled: (options?.enableSoftFailureSentinel !== false) && (options?.config?.enableSoftFailureSentinel !== false),
+        })
+        for await (const chunk of sentineledStream) {
           firstChunkDelivered = true
           const cachedTokens = Number(
             (chunk && chunk.usage && (chunk.usage.cacheReadTokens || chunk.usage.cachedTokens)) ||
@@ -195,18 +201,24 @@ export async function* streamWithRotation({
         currentAttempt.status = 'switched'
         currentAttempt.switchError = err ? (err.code || err.status || err.message) : 'switchable'
 
-        // Move slot to cooldown and quarantine (#172)
-        const cooled = markCooldown(account, nowMs(), cooldownMs, modelFamily(options && options.provider, options && options.model))
+        const accurateUntil = resolveAccurateReset(err, account, options && options.provider, nowMs())
+        const isSoft = Boolean(err && (err.code === 'SOFT_FAILURE' || err.isSoftFailure))
+
+        // Move slot to cooldown and quarantine (#172, #538)
+        const effectiveCooldownMs = isSoft ? Math.min(cooldownMs, 5 * 60 * 1000) : cooldownMs
+        const cooled = markCooldown(account, nowMs(), effectiveCooldownMs, modelFamily(options && options.provider, options && options.model), accurateUntil)
         account.cooldownUntil = cooled.cooldownUntil
         if (cooled.cooldownFamilies) account.cooldownFamilies = cooled.cooldownFamilies
 
         const status = Number(err && (err.status || err.statusCode) || 0)
         const code = String(err && err.code || '')
-        const reason = (status === 401 || code === 'AUTH' || code === 'TOKEN_REVOKED')
-          ? REASON_REVOKED
-          : (status === 403 || code === 'HARD_LIMIT' || code === 'LICENSE_REQUIRED')
-            ? REASON_HARD_LIMIT
-            : REASON_RATE_LIMIT
+        const reason = isSoft
+          ? REASON_DEGRADED
+          : (status === 401 || code === 'AUTH' || code === 'TOKEN_REVOKED')
+            ? REASON_REVOKED
+            : (status === 403 || code === 'HARD_LIMIT' || code === 'LICENSE_REQUIRED')
+              ? REASON_HARD_LIMIT
+              : REASON_RATE_LIMIT
 
         if (err && err.isWarmupProbeFailure && err.warmupAccount) {
           account.quarantineUntil = err.warmupAccount.quarantineUntil
@@ -214,7 +226,7 @@ export async function* streamWithRotation({
           account.quarantineAttempts = err.warmupAccount.quarantineAttempts
           account.status = err.warmupAccount.status
         } else {
-          const quarantined = putInQuarantine(account, reason, nowMs())
+          const quarantined = putInQuarantine(account, reason, nowMs(), accurateUntil)
           account.quarantineUntil = quarantined.quarantineUntil
           account.quarantineReason = quarantined.quarantineReason
           account.quarantineAttempts = (account.quarantineAttempts || 0) + 1
@@ -222,6 +234,10 @@ export async function* streamWithRotation({
 
         currentAttempt.quarantineReason = account.quarantineReason || reason
         currentAttempt.quarantineUntil = account.quarantineUntil
+        if (accurateUntil) {
+          currentAttempt.accurateReset = true
+          currentAttempt.resetAt = accurateUntil
+        }
 
         try {
           notifyQuarantineEntered({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.70",
+  "version": "0.6.71",
   "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",