@goodandready/dsh-subscriptions 0.4.17 → 0.4.18

package/README.md

@@ -152,6 +152,30 @@ const res = await ctx.subscriptions.request('codex', '/backend-api/codex/images/
 
 ---
 
+### 12. 🧯 Safe Reset Credits (`v0.4.18`)
+* **Reset Card Visibility**: The Codex account card shows how many ChatGPT quota reset cards are available and when the earliest one expires.
+* **Deliberate Confirmation Flow**: Consuming a card requires an explicit checkbox ("I understand one attempt will be consumed") plus a mandatory 5-second cooldown before the Reset button activates.
+* **Double-Click Proof**: A host-side single-flight gate (synchronous pending lock before the first network await) makes it impossible for a double click or a concurrent call to consume two cards. Uncertain network results return the challenge to "prepared" for a safe retry of the same request.
+* **Honest Results**: Server verdicts are shown verbatim: `reset` / `nothing to reset` (nothing consumed) / `no usable credit` / `already redeemed`.
+
+### 13. 📊 Composer Quota Indicator & Runway Forecast (`v0.4.18`)
+* **Placement**: Renders in the input area next to the model switcher (`conversation.input.right` slot).
+* **Four display modes (`composerQuota` setting)**: `off` / `percent` (`85%`) / `bar` (40px mini bar, green>30 / amber 10-30 / red <10) / `forecast`.
+* **Runway Forecast**: A sliding 24h window of remaining-percent samples (up to 192 points) feeds a recency-weighted least-squares burn rate; below 30 min of observation or <1% consumed it stays `calibrating…`, with no consumption it says `no usage`. Ready state shows `~4.5h` / `~12m`.
+* **Auto-Hide**: No indicator for local Ollama or when nothing is active.
+
+### 14. 🧑‍💻 SUBS Pill & Session Console (`v0.4.18`)
+* **Pill in the Session Header**: `SUBS (N)` in the session header actions area with a pool-health LED: green <50% max usage, amber 50-90%, red ≥90%, gray when nothing is connected.
+* **Modal Console**: Clicking the pill opens an in-session modal listing every account (provider #index, connected/not, cooldown, quota %) and a shortcut to the settings card. Closes on outside click, ✕ or Escape.
+
+### 15. 🫧 Draggable HUD Widget (`v0.4.18`)
+* **Floating Bubble** on `shell.overlay`: a 64px circle with an SVG ring gauge of the active subscription balance, mounted via `createPortal`.
+* **Drag & Dock**: Drag anywhere; it snaps to any screen edge within 24px (peek-style half-hidden until hovered) and remembers its position in `localStorage`.
+* **Frosted Panel**: Hovering reveals a `backdrop-filter: blur(28px)` panel listing every account with usage bars. Clicking the bubble refreshes quota data; data also refreshes every 60 s.
+* **Settings Card Polish (`v0.4.18`)**: Chevron switched to the core `IconChevronDownOutline14` primitive; explicit settings snapshot states (loading / unavailable + Retry) guard against phantom input.
+
+---
+
 ## 📦 Quick Installation
 
 ```bash
@@ -177,6 +201,7 @@ dsh-subscriptions:
   hideDeprecatedModels: false # v0.4.17: filter test/preview/beta/legacy model ids
   codexVerbosity: ''        # v0.4.17: low | medium | high (text.verbosity)
   codexFastMode: false      # v0.4.17: service_tier priority (1.5x speed tier)
+  composerQuota: 'off'      # v0.4.18: composer indicator: off | percent | bar | forecast
   # Per-slot fields (v0.4.9): expiresAt (ms epoch), proxyUrl (http/https/socks5://)
   accounts:
     codex:

package/README.ru.md

@@ -174,6 +174,7 @@ dsh-subscriptions:
   hideDeprecatedModels: false # v0.4.17: фильтровать test/preview/beta/legacy id моделей
   codexVerbosity: ''        # v0.4.17: low | medium | high (text.verbosity)
   codexFastMode: false      # v0.4.17: service_tier priority (скоростной тир 1.5x)
+  composerQuota: 'off'      # v0.4.18: индикатор в строке ввода: off | percent | bar | forecast
   # Поля слота (v0.4.9): expiresAt (ms), proxyUrl (http/https/socks5://)
   accounts:
     codex:

package/lib/client.js

@@ -4,6 +4,9 @@ window.__ModuleLoader__.load({
     var module = { exports: {} }
     var exports = module.exports
     const React = require('react')
+    const createPortal = (function () {
+      try { return require('react-dom').createPortal } catch { return null }
+    })()
 
     // Модульный переводчик: доступен всем подпискам компонентов и хелперам.
     let t = (key) => key
@@ -60,7 +63,48 @@ window.__ModuleLoader__.load({
     '.dsub-barRow{display:flex;align-items:center;gap:8px;font-size:12px;color:var(--dsw-alias-label-secondary)}' +
     '.dsub-manual{display:flex;flex-direction:column;gap:6px;margin-top:4px;padding-top:10px;border-top:1px solid var(--dsw-alias-border-l2)}' +
     '.dsub-verify{font-size:12px;color:var(--dsw-alias-state-warning-primary)}' +
-    '.dsub-verify a{color:var(--dsw-alias-brand-primary)}'
+    '.dsub-verify a{color:var(--dsw-alias-brand-primary)}' +
+    '.dsub-hud{pointer-events:auto;position:fixed;z-index:10010;width:64px;height:64px;transition:left .2s,top .2s}' +
+    '.dsub-hud[data-dragging=true]{transition:none}' +
+    '.dsub-hudBtn{position:relative;width:64px;height:64px;padding:0;border:0;border-radius:50%;cursor:grab;display:grid;place-items:center;user-select:none;touch-action:none;' +
+    'background:var(--dsw-alias-bg-layer-3);box-shadow:0 0 0 1px var(--dsw-alias-border-l2),0 8px 24px rgba(0,0,0,.25);backdrop-filter:blur(18px)}' +
+    '.dsub-hudBtn:hover{transform:scale(1.05)}' +
+    '.dsub-hudBtn:active{cursor:grabbing}' +
+    '.dsub-hudRing{position:absolute;inset:4px;width:56px;height:56px;transform:rotate(-90deg)}' +
+    '.dsub-hudTrack{fill:none;stroke:var(--dsw-alias-border-l2);stroke-width:4}' +
+    '.dsub-hudVal{fill:none;stroke:var(--dsub-tone,var(--dsw-alias-state-success-primary));stroke-width:4;stroke-linecap:round;transition:stroke-dashoffset .4s}' +
+    '.dsub-hudCore{position:relative;z-index:2;font-size:14px;font-weight:700;font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-primary)}' +
+    '.dsub-hud[data-collapsed=true] .dsub-hudBtn{opacity:.45}' +
+    '.dsub-hud[data-collapsed=true]:hover .dsub-hudBtn{opacity:1}' +
+    '.dsub-hudPanel{pointer-events:none;position:absolute;width:280px;padding:12px;border-radius:14px;background:var(--dsw-alias-bg-layer-3);border:1px solid var(--dsw-alias-border-l2);box-shadow:0 18px 48px rgba(0,0,0,.35);backdrop-filter:blur(28px);opacity:0;transform:translateY(6px);transition:opacity .16s,transform .16s}' +
+    '.dsub-hud:hover .dsub-hudPanel{opacity:1;transform:none}' +
+    '.dsub-hud[data-dragging=true] .dsub-hudPanel{opacity:0}' +
+    '.dsub-hudRow{display:flex;align-items:center;gap:8px;margin-top:8px;font-size:11.5px}' +
+    '.dsub-hudRow .dsub-bar{min-width:70px}' +
+    '.dsub-hudName{font-weight:600;min-width:52px}' +
+    '.dsub-hudPct{margin-left:auto;font-variant-numeric:tabular-nums}' +
+    '.dsub-hudHead{font-size:12px;font-weight:600;color:var(--dsw-alias-label-primary)}' +
+    '.dsub-hudHint{margin-top:10px;font-size:10.5px;color:var(--dsw-alias-label-tertiary)}' +
+    '.dsub-pill{display:inline-flex;align-items:center;gap:6px;height:26px;padding:0 10px;border:1px solid var(--dsw-alias-border-l2);border-radius:999px;background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-primary);font-size:11.5px;font-weight:600;cursor:pointer;letter-spacing:.06em}' +
+    '.dsub-pill:hover{border-color:var(--dsw-alias-label-dimmed)}' +
+    '.dsub-led{width:7px;height:7px;border-radius:50%;flex:none}' +
+    '.dsub-ledOk{background:var(--dsw-alias-state-success-primary);box-shadow:0 0 6px var(--dsw-alias-state-success-primary)}' +
+    '.dsub-ledWarn{background:var(--dsw-alias-state-warning-primary);box-shadow:0 0 6px var(--dsw-alias-state-warning-primary)}' +
+    '.dsub-ledBad{background:var(--dsw-alias-state-error-primary);box-shadow:0 0 6px var(--dsw-alias-state-error-primary)}' +
+    '.dsub-ledOff{background:var(--dsw-alias-label-tertiary)}' +
+    '.dsub-modalWrap{position:fixed;inset:0;z-index:10020;display:grid;place-items:center;background:color-mix(in srgb,#000 45%,transparent)}' +
+    '.dsub-modal{width:min(560px,92vw);max-height:min(70vh,640px);overflow:auto;border:1px solid var(--dsw-alias-border-l1);border-radius:14px;background:var(--dsw-alias-bg-layer-3);color:var(--dsw-alias-label-primary);box-shadow:0 24px 64px rgba(0,0,0,.4);padding:16px}' +
+    '.dsub-modalHead{display:flex;align-items:center;justify-content:space-between;gap:10px;margin-bottom:12px}' +
+    '.dsub-modalRow{display:flex;align-items:center;gap:10px;padding:9px 10px;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;margin-top:8px;background:var(--dsw-alias-bg-layer-2)}' +
+    '.dsub-modalName{font-weight:600;font-size:13px}' +
+    '.dsub-modalSub{font-size:11.5px;color:var(--dsw-alias-label-secondary)}' +
+    '.dsub-cq{display:inline-flex;align-items:center;gap:6px;font-size:12px;color:var(--dsw-alias-label-secondary);padding:0 6px}' +
+    '.dsub-cqBar{position:relative;width:40px;height:5px;border-radius:3px;background:var(--dsw-alias-bg-layer-1);overflow:hidden}' +
+    '.dsub-cqBarFill{height:100%;border-radius:3px;background:var(--dsw-alias-state-success-primary)}' +
+    '.dsub-cqBarWarn .dsub-cqBarFill{background:var(--dsw-alias-state-warning-primary)}' +
+    '.dsub-cqBarFull .dsub-cqBarFill{background:var(--dsw-alias-state-error-primary)}' +
+    '.dsub-cqB{font-variant-numeric:tabular-nums;font-weight:600;color:var(--dsw-alias-label-primary)}' +
+    '.dsub-diag{font:11px/1.5 ui-monospace,SFMono-Regular,monospace;max-height:260px;overflow:auto;white-space:pre-wrap;word-break:break-word;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:10px;background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-secondary)}'
 
 const cssId = 'dsh-subscriptions/settings.module.css'
     if (typeof document !== 'undefined' && !document.querySelector('style[data-plugin-css="' + cssId + '"]')) {
@@ -90,6 +134,39 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       'useOriginHint': 'Leave off unless you registered your own OAuth client for this origin. Vendor CLI clients usually require their published redirect URI plus the paste step.',
       'privacyMask': 'Mask emails and account identifiers',
       'privacyMaskHint': 'For demos and screen sharing: emails show as j***n@example.com.',
+      'resetCredits': 'Reset credits',
+      'resetCreditsHint': 'ChatGPT reset cards: shows how many are available. Consuming one is a deliberate action with a 5s confirmation.',
+      'resetAvailable': 'Reset attempts available',
+      'resetExpires': 'earliest expires',
+      'resetAck': 'I understand one attempt will be consumed',
+      'resetWait': 'confirm enabled in',
+      'resetReady': 'ready',
+      'resetGo': 'Reset now',
+      'resetBusy': 'resetting…',
+      'resetDone': 'quota reset',
+      'resetNothing': 'server says nothing needs a reset (no attempt consumed)',
+      'resetNoCredit': 'no usable credit (not consumed)',
+      'resetRedeemed': 'already redeemed earlier',
+      'diagGenerate': 'Generate diagnostics report',
+      'diagCopy': 'Copy report',
+      'diagIssues': 'Open issue tracker',
+      'diagHint': 'The report has no tokens, emails, proxy addresses or personal data.',
+      'subsPill': 'SUBS',
+      'subsModalTitle': 'Subscription console',
+      'subsModalClose': 'Close',
+      'subsLogged': 'connected',
+      'subsNotLogged': 'not connected',
+      'subsCooldown': 'cooldown',
+      'subsOpenSettings': 'Open settings',
+      'hudTitle': 'Subscription balance',
+      'settingsLoading': 'Loading settings…',
+      'settingsUnavailable': 'Settings are unavailable',
+      'settingsRetry': 'Retry',
+      'hudHint': 'drag · edge docks · click refresh',
+      'fcCalibrating': 'calibrating…',
+      'fcIdle': 'no usage',
+      'fcHours': 'h',
+      'fcMinutes': 'm',
       'reconnect': 'Reconnect',
       'connect': 'Connect',
       'disconnect': 'Disconnect',
@@ -157,6 +234,39 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       'useOriginHint': 'Включайте, только если зарегистрировали собственного клиента OAuth на этот адрес. Штатным консольным клиентам провайдеров нужен их опубликованный адрес возврата и вставка кода вручную.',
       'privacyMask': 'Маскировать email и учётные записи',
       'privacyMaskHint': 'Для демонстрации экрана: email отображается как j***n@example.com.',
+      'resetCredits': 'Карты сброса',
+      'resetCreditsHint': 'Карты сброса квоты ChatGPT: показывает, сколько доступно. Списание одной карты — осознанное действие с 5-секундным подтверждением.',
+      'resetAvailable': 'Доступно попыток сброса',
+      'resetExpires': 'ближайшая истекает',
+      'resetAck': 'Я понимаю, что будет списана 1 попытка',
+      'resetWait': 'кнопка активна через',
+      'resetReady': 'готово',
+      'resetGo': 'Сбросить',
+      'resetBusy': 'сбрасываю…',
+      'resetDone': 'квота сброшена',
+      'resetNothing': 'сервер сообщает: сброс не нужен (попытка не списана)',
+      'resetNoCredit': 'нет пригодной карты (не списано)',
+      'resetRedeemed': 'эта карта уже использована ранее',
+      'diagGenerate': 'Сгенерировать диагностический отчёт',
+      'diagCopy': 'Скопировать отчёт',
+      'diagIssues': 'Открыть трекер задач',
+      'diagHint': 'В отчёте нет токенов, email, адресов прокси и персональных данных.',
+      'subsPill': 'SUBS',
+      'subsModalTitle': 'Консоль подписок',
+      'subsModalClose': 'Закрыть',
+      'subsLogged': 'подключен',
+      'subsNotLogged': 'не подключен',
+      'subsCooldown': 'кулдаун',
+      'subsOpenSettings': 'Открыть настройки',
+      'hudTitle': 'Остаток подписки',
+      'settingsLoading': 'Загрузка настроек…',
+      'settingsUnavailable': 'Настройки недоступны',
+      'settingsRetry': 'Повторить',
+      'hudHint': 'перетащи · прилипает к краям · клик — обновить',
+      'fcCalibrating': 'калибровка…',
+      'fcIdle': 'нет расхода',
+      'fcHours': 'ч',
+      'fcMinutes': 'мин',
       'reconnect': 'Переподключить',
       'connect': 'Подключить',
       'disconnect': 'Отключить',
@@ -263,6 +373,69 @@ function PluginCard(props) {
       const [paste, setPaste] = React.useState({})
       const [device, setDevice] = React.useState({})  // #90 key -> {state,userCode,authUrl,intervalMs,status}
       const [proxyRes, setProxyRes] = React.useState({})  // #88 key -> {ok,latencyMs,error}
+      const [diag, setDiag] = React.useState('')
+      const [reset, setReset] = React.useState({})  // #85 key -> challenge state
+      const [, setResetTick] = React.useState(0)
+      React.useEffect(() => {
+        const anyPending = Object.values(reset).some((r) => r && r.phase === 'confirm' && !r.result)
+        if (!anyPending) return undefined
+        const id = setInterval(() => setResetTick((n) => n + 1), 1000)
+        return () => clearInterval(id)
+      }, [reset])
+
+      // #85: reset credits challenge flow (prepare -> 5s cooldown + ack -> consume).
+      const resetPrepare = async (provider, index, key) => {
+        setReset((m) => Object.assign({}, m, { [key]: { phase: 'loading' } }))
+        try {
+          const res = await fetch('/dsh-subscriptions/reset-credits/prepare', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ provider, index }),
+          })
+          const d = await res.json()
+          if (!d || !d.ok) throw new Error((d && d.error && d.error.message) || 'prepare failed')
+          setReset((m) => Object.assign({}, m, { [key]: {
+            phase: 'confirm',
+            challengeId: d.challengeId,
+            availableCount: d.availableCount,
+            readyAt: d.readyAt,
+            expiresAt: d.expiresAt,
+            creditExpiresAt: d.creditExpiresAt || null,
+          } }))
+        } catch (e) {
+          setReset((m) => Object.assign({}, m, { [key]: { phase: 'idle', error: String(e && e.message || e) } }))
+        }
+      }
+      const resetConsume = async (key) => {
+        const st = reset[key]
+        if (!st || st.phase !== 'confirm' || !st.ack || Date.now() < st.readyAt || st.busy) return
+        setReset((m) => Object.assign({}, m, { [key]: Object.assign({}, st, { busy: true }) }))
+        try {
+          const res = await fetch('/dsh-subscriptions/reset-credits/consume', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ challengeId: st.challengeId, acknowledged: true }),
+          })
+          const d = await res.json()
+          if (!d || !d.ok) throw new Error((d && d.error && d.error.message) || 'consume failed')
+          const code = d.result && d.result.code
+          setReset((m) => Object.assign({}, m, { [key]: Object.assign({}, st, { busy: false, result: code, windowsReset: (d.result && d.result.windowsReset) || [] }) }))
+          reload().catch(() => {})
+        } catch (e) {
+          setReset((m) => Object.assign({}, m, { [key]: Object.assign({}, st, { busy: false, error: String(e && e.message || e) }) }))
+        }
+      }
+      // #99: one click - fetch the anonymized report and copy it to the clipboard.
+      const genDiag = () => {
+        fetch('/dsh-subscriptions/diagnostics', { cache: 'no-store' })
+          .then((r) => r.json())
+          .then((d) => {
+            const txt = d && d.ok ? JSON.stringify(d.report, null, 2) : ('error: ' + ((d && d.error && d.error.message) || 'unknown'))
+            setDiag(txt)
+            try { navigator.clipboard.writeText(txt) } catch {}
+          })
+          .catch((e) => setDiag('error: ' + String(e && e.message || e)))
+      }
       const [checkRes, setCheckRes] = React.useState({})
       const [checking, setChecking] = React.useState({})
       const [saved, setSaved] = React.useState(false)
@@ -295,7 +468,20 @@ function PluginCard(props) {
         return () => timers.forEach(clearInterval)
       })
 
-      if (!draft) return React.createElement('div', { className: 'dsub-wrap' }, t('loading'))
+      // #81: settings snapshot status - never render phantom inputs before the
+      // config snapshot arrives, and offer a retry when the store is unavailable.
+      if (!draft) {
+        return React.createElement('div', { className: 'dsub-wrap' },
+          React.createElement('div', { className: 'dsub-row' },
+            React.createElement('span', { className: 'dsub-sub' }, err ? t('settingsUnavailable') : t('settingsLoading')),
+            err ? React.createElement('button', {
+              type: 'button', className: 'dsub-mini',
+              onClick: () => { setErr(''); reload().catch((e) => setErr(String(e && e.message || e))) },
+            }, t('settingsRetry')) : null,
+          ),
+          err ? React.createElement('div', { className: 'dsub-bad' }, err) : null,
+        )
+      }
 
       const slots = Array.isArray(draft.slots) ? draft.slots : []
       const setSlots = (next) => setDraft((d) => Object.assign({}, d, { slots: next }))
@@ -480,6 +666,20 @@ function PluginCard(props) {
           React.createElement('div', { className: 'dsub-sub' },
             t('privacyMaskHint')),
         ),
+        React.createElement('div', { className: 'dsub-block' },
+          React.createElement('div', { className: 'dsub-row' },
+            React.createElement('button', { type: 'button', className: 'dsub-mini', onClick: genDiag }, t('diagGenerate')),
+            React.createElement('a', { href: 'https://github.com/GooDAnDReaDY/dsh-subscriptions/issues', target: '_blank', rel: 'noopener noreferrer', className: 'dsub-mini' }, t('diagIssues')),
+          ),
+          React.createElement('div', { className: 'dsub-sub' }, t('diagHint')),
+          diag ? React.createElement('div', { className: 'dsub-row' },
+            React.createElement('button', {
+              type: 'button', className: 'dsub-mini',
+              onClick: () => { try { navigator.clipboard.writeText(diag) } catch {} },
+            }, t('diagCopy')),
+            React.createElement('pre', { className: 'dsub-diag' }, diag),
+          ) : null,
+        ),
         names.map((prov) => {
           const rows = slots
             .map((slot, i) => ({ slot: slot, i: i }))
@@ -601,6 +801,53 @@ function PluginCard(props) {
                     ) : null,
                   )
                 })(),
+                (row.slot.provider === 'codex' && on ? (function resetPanel(){
+                  var st = reset[key] || { phase: 'idle' }
+                  var now = Date.now()
+                  function resultText(code) {
+                    if (code === 'reset') return t('resetDone')
+                    if (code === 'nothing_to_reset') return t('resetNothing')
+                    if (code === 'no_credit') return t('resetNoCredit')
+                    if (code === 'already_redeemed') return t('resetRedeemed')
+                    return code
+                  }
+                  if (st.phase !== 'confirm') {
+                    return React.createElement('div', { className: 'dsub-row' },
+                      React.createElement('button', {
+                        type: 'button', className: 'dsub-mini',
+                        onClick: () => resetPrepare(row.slot.provider, row.slot.index, key).catch((e) => setErr(String(e && e.message || e))),
+                      }, st.phase === 'loading' ? '\u2026' : t('resetCredits')),
+                      React.createElement('div', { className: 'dsub-sub' }, t('resetCreditsHint')),
+                    )
+                  }
+                  var ready = now >= st.readyAt
+                  var secs = Math.max(0, Math.ceil((st.readyAt - now) / 1000))
+                  return React.createElement('div', { className: 'dsub-verify' },
+                    React.createElement('div', null,
+                      t('resetAvailable') + ': ' + st.availableCount +
+                      (st.creditExpiresAt ? (' · ' + t('resetExpires') + ' ' + new Date(st.creditExpiresAt).toLocaleString()) : '')
+                    ),
+                    React.createElement('label', { className: 'dsub-row' },
+                      React.createElement('input', {
+                        type: 'checkbox',
+                        checked: !!st.ack,
+                        onChange: (e) => setReset((m) => Object.assign({}, m, { [key]: Object.assign({}, st, { ack: e.target.checked }) })),
+                      }),
+                      React.createElement('span', null, t('resetAck')),
+                    ),
+                    React.createElement('div', { className: 'dsub-row' },
+                      React.createElement('button', {
+                        type: 'button', className: 'dsub-mini',
+                        disabled: !st.ack || !ready || !!st.busy,
+                        onClick: () => resetConsume(key).catch((e) => setErr(String(e && e.message || e))),
+                      }, st.busy ? t('resetBusy') : (ready ? t('resetGo') : (t('resetWait') + ' ' + secs + 's'))),
+                      !ready && !st.busy ? React.createElement('span', { className: 'dsub-sub' }, t('resetWait') + ' ' + secs + 's') : null,
+                      st.ack && ready ? React.createElement('span', { className: 'dsub-ok' }, t('resetReady')) : null,
+                    ),
+                    st.result ? React.createElement('div', { className: 'dsub-ok' }, resultText(st.result)) : null,
+                    st.error ? React.createElement('div', { className: 'dsub-bad' }, st.error) : null,
+                  )
+                })() : null),
                 account.accountNotice ? React.createElement('div', { className: 'dsub-verify' }, account.accountNotice) : null,
                 account.refreshError ? React.createElement('div', { className: 'dsub-bad' }, t('reconnectRequired') + ': ' + account.refreshError) : null,
                 (function(){ var r=checkRes[key]; if(!r) return null; var txt=r.ok ? ('ok ' + (r.email||'')) : ('fail ' + (r.error && r.error.message || '')); var cls=r.ok ? 'dsub-ok' : 'dsub-bad'; var q=r.quota; if(q && q.remaining!=null) txt += ' quota:'+q.remaining+(q.limit!=null?'/'+q.limit:''); return React.createElement('div', {className: cls}, txt) })(),
@@ -696,15 +943,7 @@ function PluginCard(props) {
             React.createElement('div', { className: 'dsub-name' }, t('title')),
             React.createElement('div', { className: 'dsub-description' }, t('cardIntro')),
           ),
-          React.createElement('svg', {
-            className: 'dsub-chev' + (open ? ' dsub-chevOpen' : ''),
-            width: 16, height: 16, viewBox: '0 0 16 16', fill: 'none',
-          },
-            React.createElement('path', {
-              d: 'M4 6l4 4 4-4', stroke: 'currentColor', 'stroke-width': 1.5,
-              'stroke-linecap': 'round', 'stroke-linejoin': 'round',
-            }),
-          ),
+          React.createElement(Chevron, { className: 'dsub-chev' + (open ? ' dsub-chevOpen' : '') }),
         ),
         open ? React.createElement('div', { className: 'dsub-body' },
           React.createElement(SubsSection, props),
@@ -786,9 +1025,370 @@ function PluginCard(props) {
           expiresAt: (data && data.expiresAt) || {},
           labels: (data && data.labels) || {},
           expiryNotifyDays: (data && data.expiryNotifyDays) || 7,
+          composerQuota: (data && data.composerQuota) || 'off',
           active: (data && data.active) || null,
         }
-      } catch { return { logged: [], usage: 0, expiresAt: {}, labels: {}, expiryNotifyDays: 7, fastMode: false, active: null } }
+      } catch { return { logged: [], usage: 0, expiresAt: {}, labels: {}, expiryNotifyDays: 7, fastMode: false, composerQuota: 'off', active: null } }
+    }
+
+    // #84: компактный индикатор квоты активной подписки в области ввода.
+    // Прогноз (runway) считается по скользящему окну сэмплов /status.
+    const fcSamples = { windows: {} }
+
+    function fcObserve(key, remaining, now) {
+      const windows = fcSamples.windows
+      const prev = windows[key]
+      const samples = (prev && prev.samples) || []
+      const last = samples[samples.length - 1]
+      if (!last || (now > last.at && (Math.abs(remaining - last.pct) >= 0.1 || now - last.at >= 15 * 60 * 1000))) {
+        samples.push({ at: now, pct: remaining })
+      }
+      windows[key] = { samples: samples.filter((x) => x.at >= now - 24 * 60 * 60 * 1000).slice(-192) }
+    }
+
+    function fcEstimate(key, remaining, now) {
+      const rec = fcSamples.windows[key]
+      if (!rec) return { status: 'calibrating' }
+      const samples = rec.samples
+      if (samples.length < 3) return { status: 'calibrating' }
+      const first = samples[0]
+      const last = samples[samples.length - 1]
+      const span = last.at - first.at
+      const consumed = first.pct - last.pct
+      if (span < 30 * 60 * 1000 || consumed < 1) return { status: 'calibrating' }
+      const t0 = first.at
+      let sw = 0, sx = 0, sy = 0, sxx = 0, sxy = 0
+      for (const x of samples) {
+        const wx = (x.at - t0) / 3600000
+        const wy = first.pct - x.pct
+        const w = Math.exp((x.at - last.at) / (6 * 3600000))
+        sw += w; sx += w * wx; sy += w * wy; sxx += w * wx * wx; sxy += w * wx * wy
+      }
+      const den = sw * sxx - sx * sx
+      const pace = den > 0 ? (sw * sxy - sx * sy) / den : 0
+      if (!Number.isFinite(pace) || pace < 0.02) return { status: 'idle' }
+      return { status: 'ready', runwaySeconds: Math.round((remaining / pace) * 3600) }
+    }
+
+    function ComposerQuota(props) {
+      const t = (props && props.t) || ((k) => k)
+      const [state, setState] = React.useState({ mode: 'off', active: null })
+      React.useEffect(() => {
+        let alive = true
+        const pull = () => {
+          refreshLoggedIn().then((r) => {
+            if (!alive) return
+            const mode = r.composerQuota || 'off'
+            const a = r.active
+            if (mode !== 'off' && a && a.provider && a.provider !== 'ollama' && a.usagePercent != null) {
+              const remaining = Math.max(0, 100 - a.usagePercent)
+              const key = 'subs:' + a.provider
+              fcObserve(key, remaining, Date.now())
+              const est = fcEstimate(key, remaining, Date.now())
+              setState({ mode, active: a, remaining, est })
+            } else {
+              setState({ mode, active: a, remaining: null, est: null })
+            }
+          }).catch(() => {})
+        }
+        pull()
+        const id = setInterval(pull, 60 * 1000)
+        return () => { alive = false; clearInterval(id) }
+      }, [])
+      if (state.mode === 'off' || !state.active || state.remaining == null) return null
+      const cls = state.remaining <= 10 ? ' dsub-cqBarFull' : (state.remaining <= 30 ? ' dsub-cqBarWarn' : '')
+      var value = null
+      if (state.mode === 'percent') {
+        value = React.createElement('span', { className: 'dsub-cqB' }, Math.round(state.remaining) + '%')
+      } else if (state.mode === 'bar') {
+        value = React.createElement('span', { className: 'dsub-cqBar' + cls },
+          React.createElement('span', { className: 'dsub-cqBarFill', style: { width: Math.min(100, Math.max(0, state.remaining)) + '%' } }))
+      } else if (state.mode === 'forecast') {
+        var est = state.est
+        if (!est || est.status === 'calibrating') value = React.createElement('span', { className: 'dsub-cqB' }, t('fcCalibrating'))
+        else if (est.status === 'idle') value = React.createElement('span', { className: 'dsub-cqB' }, t('fcIdle'))
+        else {
+          var secs = est.runwaySeconds || 0
+          var txt = secs >= 3600 ? ('~' + (Math.round((secs / 3600) * 10) / 10) + t('fcHours')) : ('~' + Math.max(1, Math.round(secs / 60)) + t('fcMinutes'))
+          value = React.createElement('span', { className: 'dsub-cqB' }, txt)
+        }
+      } else return null
+      return React.createElement('span', { className: 'dsub-cq', title: t('forecast') + ' · ' + state.active.provider }, value)
+    }
+
+    // #83: пилл SUBS(N) в шапке сессии со светодиодом здоровья пула и
+    // модальной консолью аккаунтов (закрытие: крестик, Escape, клик мимо).
+    function SubsPill(props) {
+      const t = (props && props.t) || ((k) => k)
+      const [state, setState] = React.useState({ logged: [], usage: 0, accounts: [], open: false })
+      React.useEffect(() => {
+        let alive = true
+        const pull = () => {
+          refreshLoggedIn().then((r) => {
+            if (!alive) return
+            const logged = r.logged || []
+            fetch('/dsh-subscriptions/config', { cache: 'no-store' })
+              .then((res) => res.json())
+              .then((cfg) => {
+                if (!alive) return
+                setState({ logged, usage: r.usage, accounts: (cfg && cfg.accounts) || [], open: false })
+              })
+              .catch(() => { if (alive) setState({ logged, usage: r.usage, accounts: [], open: false }) })
+          }).catch(() => {})
+        }
+        pull()
+        const id = setInterval(pull, 60 * 1000)
+        return () => { alive = false; clearInterval(id) }
+      }, [])
+      React.useEffect(() => {
+        if (!state.open) return undefined
+        const onKey = (e) => { if (e.key === 'Escape') setState((s) => Object.assign({}, s, { open: false })) }
+        document.addEventListener('keydown', onKey)
+        return () => document.removeEventListener('keydown', onKey)
+      }, [state.open])
+      const n = state.logged.length
+      const led = n === 0 ? 'dsub-ledOff' : (state.usage >= 90 ? 'dsub-ledBad' : (state.usage >= 50 ? 'dsub-ledWarn' : 'dsub-ledOk'))
+      const now = Date.now()
+      const rows = state.accounts.map((a, i) => {
+        const isLogged = state.logged.includes(a.provider)
+        const cooled = a.cooldownUntil && a.cooldownUntil > now
+        const pct = a.usagePercent != null ? Math.round(a.usagePercent) : null
+        return React.createElement('div', { className: 'dsub-modalRow', key: i },
+          React.createElement('span', { className: 'dsub-led ' + (pct == null ? 'dsub-ledOff' : (pct >= 90 ? 'dsub-ledBad' : (pct >= 50 ? 'dsub-ledWarn' : 'dsub-ledOk'))) }),
+          React.createElement('span', { className: 'dsub-modalName' }, a.provider + (a.index ? ' #' + a.index : '')),
+          React.createElement('span', { style: { flex: 1 } }),
+          React.createElement('span', { className: 'dsub-modalSub' },
+            (isLogged ? t('subsLogged') : t('subsNotLogged')) +
+            (cooled ? ' · ' + t('subsCooldown') : '') +
+            (pct != null ? ' · ' + pct + '%' : '')
+          ),
+        )
+      })
+      return React.createElement(React.Fragment, null,
+        React.createElement('button', {
+          type: 'button', className: 'dsub-pill', 'aria-expanded': state.open ? 'true' : 'false',
+          onClick: () => setState((s) => Object.assign({}, s, { open: !s.open })),
+        },
+          React.createElement('span', { className: 'dsub-led ' + led }),
+          t('subsPill') + ' (' + n + ')',
+        ),
+        state.open ? React.createElement('div', {
+          className: 'dsub-modalWrap',
+          onClick: (e) => { if (e.target === e.currentTarget) setState((s) => Object.assign({}, s, { open: false })) },
+        },
+          React.createElement('div', { className: 'dsub-modal', role: 'dialog', 'aria-label': t('subsModalTitle') },
+            React.createElement('div', { className: 'dsub-modalHead' },
+              React.createElement('span', { className: 'dsub-h' }, t('subsModalTitle')),
+              React.createElement('button', {
+                type: 'button', className: 'dsub-mini',
+                onClick: () => setState((s) => Object.assign({}, s, { open: false })),
+              }, t('subsModalClose') + ' \u00d7'),
+            ),
+            rows.length ? rows : React.createElement('div', { className: 'dsub-sub' }, t('subsNotLogged')),
+            React.createElement('div', { className: 'dsub-row', style: { marginTop: 12 } },
+              React.createElement('a', {
+                className: 'dsub-mini', href: '#', onClick: (e) => {
+                  e.preventDefault()
+                  setState((s) => Object.assign({}, s, { open: false }))
+                  try { document.querySelector('[data-slot-key=\"settings.plugin.item\"],[data-dsub-open]') } catch {}
+                  try {
+                    const btn = Array.from(document.querySelectorAll('button')).find((b) => (b.textContent || '').includes(t('title')))
+                    if (btn) btn.click()
+                  } catch {}
+                },
+              }, t('subsOpenSettings')),
+            ),
+          ),
+        ) : null,
+      )
+    }
+
+    // #82: перетаскиваемый HUD-бабл (shell.overlay) с кольцевой шкалой
+    // остатка активной подписки, прилипанием к краям и frosted-панелью.
+    const HUD_KEY = 'dsh-subscriptions.hud'
+    const HUD_SIZE = 64
+
+    function hudClamp(pos) {
+      const w = window.innerWidth, h = window.innerHeight
+      return {
+        left: Math.min(Math.max(8, pos.left), Math.max(8, w - HUD_SIZE - 8)),
+        top: Math.min(Math.max(8, pos.top), Math.max(8, h - HUD_SIZE - 8)),
+      }
+    }
+
+    function hudLoad() {
+      try {
+        const raw = JSON.parse(localStorage.getItem(HUD_KEY) || 'null')
+        if (raw && typeof raw.left === 'number' && typeof raw.top === 'number') return hudClamp(raw)
+      } catch {}
+      return hudClamp({ left: window.innerWidth - HUD_SIZE - 24, top: window.innerHeight - HUD_SIZE - 120 })
+    }
+
+    function hudDock(pos) {
+      const w = window.innerWidth, h = window.innerHeight
+      const dist = { left: pos.left, right: w - (pos.left + HUD_SIZE), top: pos.top, bottom: h - (pos.top + HUD_SIZE) }
+      const TH = 24
+      let side = null, best = Infinity
+      for (const k of ['left', 'right', 'top', 'bottom']) {
+        if (dist[k] <= TH && dist[k] < best) { best = dist[k]; side = k }
+      }
+      if (!side) return pos
+      const next = { left: pos.left, top: pos.top }
+      if (side === 'left') next.left = 0
+      if (side === 'right') next.left = Math.max(0, w - HUD_SIZE)
+      if (side === 'top') next.top = 0
+      if (side === 'bottom') next.top = Math.max(0, h - HUD_SIZE)
+      return next
+    }
+
+    function UsageBubble(props) {
+      const t = (props && props.t) || ((k) => k)
+      const [pos, setPos] = React.useState(() => (typeof window === 'undefined' ? { left: 0, top: 0 } : hudLoad()))
+      const [accounts, setAccounts] = React.useState([])
+      const [active, setActive] = React.useState(null)
+      const [dragging, setDragging] = React.useState(false)
+      const [busy, setBusy] = React.useState(false)
+      const drag = React.useRef(null)
+      React.useEffect(() => {
+        let alive = true
+        const pull = () => {
+          refreshLoggedIn().then((r) => {
+            if (!alive) return
+            setActive(r.active)
+            fetch('/dsh-subscriptions/config', { cache: 'no-store' })
+              .then((res) => res.json())
+              .then((cfg) => { if (alive) setAccounts((cfg && cfg.accounts) || []) })
+              .catch(() => {})
+          }).catch(() => {})
+        }
+        pull()
+        const id = setInterval(pull, 60 * 1000)
+        return () => { alive = false; clearInterval(id) }
+      }, [])
+      const onPointerDown = (e) => {
+        if (e.button !== 0) return
+        e.preventDefault()
+        e.currentTarget.setPointerCapture(e.pointerId)
+        drag.current = { id: e.pointerId, sx: e.clientX, sy: e.clientY, left: pos.left, top: pos.top, moved: false }
+      }
+      const onPointerMove = (e) => {
+        const d = drag.current
+        if (!d || e.pointerId !== d.id) return
+        if (Math.abs(e.clientX - d.sx) > 3 || Math.abs(e.clientY - d.sy) > 3) { d.moved = true; setDragging(true) }
+        if (!d.moved) return
+        setPos(hudClamp({ left: d.left + (e.clientX - d.sx), top: d.top + (e.clientY - d.sy) }))
+      }
+      const onPointerUp = (e) => {
+        const d = drag.current
+        if (!d || e.pointerId !== d.id) return
+        drag.current = null
+        setDragging(false)
+        setPos((cur) => {
+          const next = d.moved ? hudDock(hudClamp(cur)) : cur
+          try { localStorage.setItem(HUD_KEY, JSON.stringify(next)) } catch {}
+          return next
+        })
+        if (!d.moved) {
+          setBusy(true)
+          refreshLoggedIn().then((r) => {
+            setActive(r.active)
+            return fetch('/dsh-subscriptions/config', { cache: 'no-store' }).then((res) => res.json())
+          }).then((cfg) => setAccounts((cfg && cfg.accounts) || [])).catch(() => {}).finally(() => setBusy(false))
+        }
+      }
+      // Остаток активной подписки: 100 - usagePercent.
+      const remaining = active && active.usagePercent != null ? Math.max(0, 100 - active.usagePercent) : null
+      const tone = remaining == null ? 'var(--dsw-alias-label-tertiary)'
+        : (remaining < 10 ? 'var(--dsw-alias-state-error-primary)'
+          : (remaining < 30 ? 'var(--dsw-alias-state-warning-primary)' : 'var(--dsw-alias-state-success-primary)'))
+      const R = 26
+      const CIRC = 2 * Math.PI * R
+      const offset = CIRC * (1 - (remaining == null ? 0 : Math.min(100, remaining)) / 100)
+      const rows = accounts.map((a, i) => {
+        const pct = a.usagePercent != null ? Math.round(a.usagePercent) : null
+        return React.createElement('div', { className: 'dsub-hudRow', key: i },
+          React.createElement('span', { className: 'dsub-hudName' }, a.provider + (a.index ? ' #' + a.index : '')),
+          React.createElement('span', { className: 'dsub-bar' },
+            React.createElement('span', { className: 'dsub-barFill', style: { width: (pct == null ? 0 : Math.min(100, pct)) + '%' } })),
+          React.createElement('span', { className: 'dsub-hudPct' }, pct == null ? '—' : pct + '%'),
+        )
+      })
+      if (!createPortal) return null
+      return createPortal(React.createElement('div', {
+        className: 'dsub-hud',
+        'data-dragging': dragging ? 'true' : undefined,
+        style: { left: pos.left + 'px', top: pos.top + 'px' },
+      },
+        React.createElement('button', {
+          type: 'button', className: 'dsub-hudBtn', 'aria-label': t('hudTitle'),
+          style: { '--dsub-tone': tone },
+          onPointerDown, onPointerMove, onPointerUp, onPointerCancel: onPointerUp,
+        },
+          React.createElement('svg', { className: 'dsub-hudRing', viewBox: '0 0 56 56', 'aria-hidden': 'true' },
+            React.createElement('circle', { className: 'dsub-hudTrack', cx: 28, cy: 28, r: R }),
+            React.createElement('circle', {
+              className: 'dsub-hudVal', cx: 28, cy: 28, r: R,
+              strokeDasharray: String(CIRC), strokeDashoffset: String(offset),
+            }),
+          ),
+          React.createElement('span', { className: 'dsub-hudCore' },
+            remaining == null ? '—' : (busy ? '\u2026' : Math.round(remaining) + '%'),
+          ),
+        ),
+        React.createElement('div', { className: 'dsub-hudPanel' },
+          React.createElement('div', { className: 'dsub-hudHead' }, t('hudTitle')),
+          rows.length ? rows : React.createElement('div', { className: 'dsub-sub' }, '\u2014'),
+          React.createElement('div', { className: 'dsub-hudHint' }, t('hudHint')),
+        ),
+      ), document.body)
+    }
+
+    function registerUsageBubble(ctx) {
+      ctx.effect(() => {
+        ctx.slots.inject('shell.overlay', () =>
+          ctx.slots.register(
+            {
+              name: 'shell.overlay',
+              id: 'dsh-subscriptions-usage-bubble',
+              order: 40,
+              locale: NS,
+            },
+            (props) => React.createElement(UsageBubble, { t }),
+          ),
+        )
+      }, 'dsh-subscriptions: usage bubble')
+    }
+
+    function registerSubsPill(ctx) {
+      ctx.effect(() => {
+        ctx.slots.inject('conversation.session.header.actions', () =>
+          ctx.slots.register(
+            {
+              name: 'conversation.session.header.actions',
+              id: 'dsh-subscriptions-subs-pill',
+              order: 15,
+              locale: NS,
+            },
+            (props) => React.createElement(SubsPill, { t }),
+          ),
+        )
+      }, 'dsh-subscriptions: subs pill')
+    }
+
+    function registerComposerQuota(ctx) {
+      ctx.effect(() => {
+        ctx.slots.inject('conversation.input.right', () =>
+          ctx.slots.register(
+            {
+              name: 'conversation.input.right',
+              id: 'dsh-subscriptions-composer-quota',
+              order: 5,
+              locale: NS,
+            },
+            (props) => React.createElement(ComposerQuota, { t }),
+          ),
+        )
+      }, 'dsh-subscriptions: composer quota')
     }
 
     // #52: компактный чип в шапке сессии со статусом подключённых подписок.
@@ -995,6 +1595,9 @@ function PluginCard(props) {
     exports.apply = function apply(ctx) {
       setT(ctx.locale.bind(NS))
       registerSettings(ctx)
+      registerUsageBubble(ctx)
+      registerSubsPill(ctx)
+      registerComposerQuota(ctx)
       registerHeaderChip(ctx)
       registerComposerSwitch(ctx)
       registerSlashCommands(ctx)

package/lib/forecast.js

@@ -0,0 +1,71 @@
+// #84: predictive runway forecast from a sliding window of usage samples.
+// Port of the reference approach (WSL043 quota-forecast): track remaining
+// percent samples per window key, estimate pace with a recency-weighted
+// least-squares slope, convert to a runway estimate.
+
+const HOUR_MS = 60 * 60 * 1000
+const HISTORY_MS = 24 * HOUR_MS
+const MIN_SPAN_MS = 30 * 60 * 1000
+const MIN_CONSUMED = 1
+const MAX_SAMPLES = 192
+
+const finite = (v) => Number.isFinite(Number(v))
+
+export function observeForecast(state, key, remainingPercent, resetsAt, now) {
+  const windows = Object.assign({}, (state && state.windows) || {})
+  const pct = Math.max(0, Math.min(100, Number(remainingPercent)))
+  const reset = finite(resetsAt) ? Number(resetsAt) : null
+  const prev = windows[key]
+  const resetChanged = prev !== undefined && (
+    (prev.resetsAt === null) !== (reset === null) ||
+    (prev.resetsAt !== null && reset !== null && Math.abs(prev.resetsAt - reset) > 300)
+  )
+  const last = prev && prev.samples && prev.samples[prev.samples.length - 1]
+  const increased = last !== undefined && pct > last.pct + 0.5
+  const samples = resetChanged || increased ? [] : ((prev && prev.samples) || []).slice()
+  if (!samples.length || now > samples[samples.length - 1].at && (
+    Math.abs(pct - samples[samples.length - 1].pct) >= 0.1 || now - samples[samples.length - 1].at >= 15 * 60 * 1000
+  )) {
+    samples.push({ at: now, pct })
+  }
+  const kept = samples.filter((s) => s.at >= now - HISTORY_MS).slice(-MAX_SAMPLES)
+  windows[key] = { resetsAt: reset, samples: kept }
+  return { windows }
+}
+
+export function estimateForecast(state, key, remainingPercent, resetsAt, now) {
+  if (!finite(remainingPercent)) return { status: 'idle' }
+  const rec = state && state.windows && state.windows[key]
+  if (!rec) return { status: 'calibrating' }
+  const reset = finite(resetsAt) ? Number(resetsAt) : null
+  if ((rec.resetsAt === null) !== (reset === null) ||
+      (rec.resetsAt !== null && reset !== null && Math.abs(rec.resetsAt - reset) > 300)) return { status: 'calibrating' }
+  const samples = rec.samples.filter((s) => s.at >= now - HISTORY_MS)
+  if (samples.length < 3) return { status: 'calibrating', sampleCount: samples.length }
+  const first = samples[0]
+  const last = samples[samples.length - 1]
+  const spanMs = last.at - first.at
+  const consumed = Math.max(0, first.pct - last.pct)
+  if (spanMs < MIN_SPAN_MS || consumed < MIN_CONSUMED) return { status: 'calibrating', sampleCount: samples.length }
+  const t0 = first.at
+  let sw = 0, sx = 0, sy = 0, sxx = 0, sxy = 0
+  for (const s of samples) {
+    const x = (s.at - t0) / HOUR_MS
+    const y = first.pct - s.pct
+    const w = Math.exp((s.at - last.at) / (6 * HOUR_MS))
+    sw += w; sx += w * x; sy += w * y; sxx += w * x * x; sxy += w * x * y
+  }
+  const den = sw * sxx - sx * sx
+  const pace = den > 0 ? (sw * sxy - sx * sy) / den : 0
+  if (!Number.isFinite(pace) || pace < 0.02) return { status: 'idle', pacePerHour: 0 }
+  const runwayHours = Math.max(0, Math.min(100, Number(remainingPercent))) / pace
+  const resetSec = reset === null ? null : Math.max(0, Math.round((reset - now) / 1000))
+  return {
+    status: 'ready',
+    pacePerHour: pace,
+    runwayHours,
+    runwaySeconds: Math.round(runwayHours * 3600),
+    survivesReset: resetSec !== null && runwayHours * 3600 >= resetSec,
+    sampleCount: samples.length,
+  }
+}

package/lib/index.js

@@ -16,6 +16,7 @@ import { quotaSnapshot } from './ratelimit.js'
 import { createAccountStore, normalizeSlots, vendorConfig } from './accounts.js'
 import { startLoopback } from './loopback.js'
 import { OllamaAdapter, ollamaAlive, ollamaModels, ollamaBase } from './ollama.js'
+import { createResetCreditService } from './reset-credits.js'
 import { maskEmail, maskLabel, maskText } from './mask.js'
 import { proxyFetch, pickFetch } from './proxy.js'
 import { HistoryStore } from './history.js'
@@ -85,6 +86,8 @@ export const Config = z.object({
     .description('#93 Response verbosity for Codex reasoning models: low, medium or high. Empty = protocol default.'),
   codexFastMode: z.boolean().default(false)
     .description('#92 Fast Mode for Codex: sends service_tier priority (1.5x speed billing tier) with every request.'),
+  composerQuota: z.string().default('off')
+    .description('#84 Composer quota indicator mode: off, percent, bar or forecast (predictive runway from a sliding window).'),
   codexRedirectUri: z.string().default(''),
   codexBaseUrl: z.string().default(''),
   claudeClientId: z.string().default(''),
@@ -178,6 +181,13 @@ export function apply(ctx, config) {
   const history = new HistoryStore()
   const recordHistory = (entry) => history.add(entry)
 
+  // #85: host-only reset credit service for Codex accounts.
+  const resetCredits = createResetCreditService({ loadBlob: (ref) => store.loadBlob(ref) })
+  function refForSlot(provider, index) {
+    const slot = normalizeSlots(live().slots).find((s) => s.provider === provider && s.index === index)
+    return slot ? slot.ref : null
+  }
+
   // #91: local Ollama - native provider + seamless fallback when the whole
   // pool is exhausted and nothing has been streamed yet.
   const ollamaAdapter = new OllamaAdapter({
@@ -731,11 +741,85 @@ export function apply(ctx, config) {
         labels,
         expiryNotifyDays: live().expiryNotifyDays,
         fastMode: !!live().codexFastMode,
+        composerQuota: String(live().composerQuota || 'off'),
         active,
       })
     },
   }), 'dsh-subscriptions: /status')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/reset-credits',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      const q = queryOf(req)
+      const ref = refForSlot(String(q.provider || ''), Number(q.index) || 1)
+      if (!ref) { writeJson(res, 404, { ok: false, error: { code: 'slot', message: 'slot not found' } }); return }
+      try {
+        writeJson(res, 200, { ok: true, ...(await resetCredits.inspect(ref)) })
+      } catch (e) {
+        writeJson(res, 200, { ok: false, error: { code: 'reset', message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-subscriptions: /reset-credits')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/reset-credits/prepare',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let payload
+      try { payload = JSON.parse((await readBody(req, 4096)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const ref = refForSlot(String(payload.provider || ''), Number(payload.index) || 1)
+      if (!ref) { writeJson(res, 404, { ok: false, error: { code: 'slot', message: 'slot not found' } }); return }
+      try {
+        writeJson(res, 200, { ok: true, ...(await resetCredits.prepare(ref)) })
+      } catch (e) {
+        writeJson(res, 200, { ok: false, error: { code: 'reset', message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-subscriptions: /reset-credits/prepare')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/reset-credits/consume',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let payload
+      try { payload = JSON.parse((await readBody(req, 4096)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      try {
+        const result = await resetCredits.consume({ challengeId: payload.challengeId, acknowledged: payload.acknowledged })
+        writeJson(res, 200, { ok: true, result })
+        refreshModels().catch(() => {})
+      } catch (e) {
+        writeJson(res, 200, { ok: false, error: { code: 'reset', message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-subscriptions: /reset-credits/consume')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-subscriptions/diagnostics',

package/lib/reset-credits.js

@@ -0,0 +1,193 @@
+import { randomUUID } from 'node:crypto'
+
+// #85: safe Codex quota reset credits. Host-only: the browser never sees
+// account ids, bearer tokens, credit ids or idempotency keys. A single-flight
+// challenge carries a 5s cooldown plus an explicit acknowledgement, so a
+// double click or concurrent call can never consume two credits.
+
+const RESET_URL = 'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits'
+const CONSUME_URL = RESET_URL + '/consume'
+const CONFIRM_DELAY_MS = 5000
+const CHALLENGE_TTL_MS = 60000
+const TIMEOUT_MS = 15000
+const UNCERTAIN = 'reset result is uncertain; re-run the confirmation to check the same request'
+
+function record(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v)
+}
+
+function expirationOf(v) {
+  if (v == null) return undefined
+  if (Number.isSafeInteger(v) && v > 0) return v * 1000
+  if (typeof v === 'string' && v.length > 0 && v.length <= 64) {
+    const p = Date.parse(v)
+    if (Number.isFinite(p) && p > 0) return p
+  }
+  throw new Error('malformed reset expiry')
+}
+
+export function parseDetails(raw, now) {
+  if (!record(raw) || !Number.isSafeInteger(raw.available_count) || raw.available_count < 0 || !Array.isArray(raw.credits)) {
+    throw new Error('malformed reset details')
+  }
+  if (raw.available_count === 0) throw new Error('no reset available')
+  const nowMs = Number(now) || 0
+  const available = raw.credits
+    .filter((c) => record(c) && typeof c.id === 'string' && c.id.length > 0 && c.id.length <= 256 && String(c.status || '').toLowerCase() === 'available')
+    .map((c) => ({ c, expiresAt: expirationOf(c.expires_at) }))
+    .filter((row) => row.expiresAt === undefined || row.expiresAt > nowMs)
+    .sort((a, b) => (a.expiresAt === undefined ? Number.MAX_SAFE_INTEGER : a.expiresAt) - (b.expiresAt === undefined ? Number.MAX_SAFE_INTEGER : b.expiresAt))
+  if (!available.length) throw new Error('no usable reset credit')
+  const first = available[0]
+  return {
+    availableCount: raw.available_count,
+    creditId: first.c.id,
+    title: typeof first.c.title === 'string' ? first.c.title.slice(0, 240) : undefined,
+    description: typeof first.c.description === 'string' ? first.c.description.slice(0, 240) : undefined,
+    creditExpiresAt: first.expiresAt,
+  }
+}
+
+export function parseConsumeResult(raw) {
+  if (!record(raw) || !['reset', 'nothing_to_reset', 'no_credit', 'already_redeemed'].includes(raw.code)) {
+    throw new Error('unreadable reset response')
+  }
+  const windowsReset = Array.isArray(raw.windows_reset)
+    ? raw.windows_reset.filter((x) => typeof x === 'string').slice(0, 16)
+    : []
+  const count = Number.isSafeInteger(raw.windows_reset) && raw.windows_reset >= 0 && raw.windows_reset <= 16
+    ? raw.windows_reset
+    : undefined
+  return { code: raw.code, windowsReset, ...(count === undefined ? {} : { windowsResetCount: count }) }
+}
+
+export function createResetCreditService({ loadBlob, fetchImpl, now = Date.now, randomId = randomUUID }) {
+  const challenges = new Map()
+
+  async function readDetails(ref) {
+    const blob = await loadBlob(ref)
+    const access = blob && blob.accessToken
+    const accountId = blob && blob.accountId
+    if (!access || !accountId) throw new Error('codex account is not signed in')
+    const res = await (fetchImpl || fetch)(RESET_URL, {
+      method: 'GET',
+      headers: {
+        Authorization: 'Bearer ' + access,
+        'chatgpt-account-id': accountId,
+        Accept: 'application/json',
+        'cache-control': 'no-store',
+      },
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    })
+    if (!res.ok) {
+      throw new Error(res.status === 401 || res.status === 403
+        ? 'codex sign-in needs renewal'
+        : 'reset request failed (HTTP ' + res.status + ')')
+    }
+    let raw
+    try { raw = await res.json() } catch { throw new Error('unreadable reset details') }
+    return { accountId, details: parseDetails(raw, now()) }
+  }
+
+  return {
+    async inspect(ref) {
+      const { details } = await readDetails(ref)
+      return {
+        availableCount: details.availableCount,
+        ...(details.creditExpiresAt === undefined ? {} : { nextExpiresAt: details.creditExpiresAt }),
+      }
+    },
+
+    async prepare(ref) {
+      const { accountId, details } = await readDetails(ref)
+      const preparedAt = now()
+      const readyAt = preparedAt + CONFIRM_DELAY_MS
+      const expiresAt = Math.min(preparedAt + CHALLENGE_TTL_MS, details.creditExpiresAt === undefined ? Number.MAX_SAFE_INTEGER : details.creditExpiresAt)
+      if (expiresAt <= readyAt) throw new Error('the available reset expires too soon')
+      const challengeId = randomId()
+      challenges.set(challengeId, {
+        state: 'prepared',
+        ref,
+        accountId,
+        creditId: details.creditId,
+        redeemRequestId: randomId(),
+        readyAt,
+        expiresAt,
+        availableCount: details.availableCount,
+        creditExpiresAt: details.creditExpiresAt,
+        title: details.title,
+        description: details.description,
+        uncertain: false,
+      })
+      return {
+        challengeId,
+        availableCount: details.availableCount,
+        readyAt,
+        expiresAt,
+        ...(details.creditExpiresAt === undefined ? {} : { creditExpiresAt: details.creditExpiresAt }),
+        ...(details.title ? { title: details.title } : {}),
+        ...(details.description ? { description: details.description } : {}),
+      }
+    },
+
+    async consume({ challengeId, acknowledged } = {}) {
+      const challenge = typeof challengeId === 'string' ? challenges.get(challengeId) : undefined
+      if (!challenge) throw new Error('this reset confirmation is no longer valid')
+      if (challenge.state === 'pending') throw new Error('this reset is already in progress')
+      if (now() < challenge.readyAt) throw new Error('wait before confirming this reset')
+      if (now() > challenge.expiresAt) {
+        challenges.delete(challengeId)
+        throw new Error('this reset confirmation is no longer valid')
+      }
+      if (acknowledged !== true) throw new Error('acknowledge that one reset attempt will be consumed')
+      // Synchronous gate before the first await: rapid clicks and concurrent
+      // calls can never create more than one provider POST.
+      challenge.state = 'pending'
+      let retryable = challenge.uncertain === true
+      try {
+        const blob = await loadBlob(challenge.ref)
+        const access = blob && blob.accessToken
+        const accountId = blob && blob.accountId
+        if (!access || !accountId) { retryable = false; throw new Error('codex account is not signed in') }
+        if (accountId !== challenge.accountId) { retryable = false; throw new Error('the signed-in account changed') }
+        let res
+        try {
+          res = await (fetchImpl || fetch)(CONSUME_URL, {
+            method: 'POST',
+            headers: {
+              Authorization: 'Bearer ' + access,
+              'chatgpt-account-id': accountId,
+              Accept: 'application/json',
+              'content-type': 'application/json',
+              'cache-control': 'no-store',
+            },
+            body: JSON.stringify({
+              redeem_request_id: challenge.redeemRequestId,
+              credit_id: challenge.creditId,
+            }),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+          })
+        } catch { retryable = true; throw new Error(UNCERTAIN) }
+        if (!res.ok) {
+          if (res.status >= 500) { retryable = true; throw new Error(UNCERTAIN) }
+          throw new Error(res.status === 401 || res.status === 403
+            ? 'codex sign-in needs renewal'
+            : 'reset request failed (HTTP ' + res.status + ')')
+        }
+        let raw
+        try { raw = await res.json() } catch { retryable = true; throw new Error(UNCERTAIN) }
+        let result
+        try { result = parseConsumeResult(raw) } catch { retryable = true; throw new Error(UNCERTAIN) }
+        retryable = false
+        return result
+      } finally {
+        if (retryable && now() <= challenge.expiresAt) {
+          challenge.state = 'prepared'
+          challenge.uncertain = true
+        } else {
+          challenges.delete(challengeId)
+        }
+      }
+    },
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.4.17",
+  "version": "0.4.18",
   "description": "Use ChatGPT Codex, Claude, Grok, and Antigravity subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",