@goodandready/dsh-subscriptions 0.6.21 → 0.6.23

package/lib/index.js

@@ -1,96 +1,76 @@
+import { readFileSync } from 'node:fs'
 import { bestEffort } from './utils.js'
 export { Config, publicConfig, Slot, defaultSlots } from './config-schema.js'
-import { Config, publicConfig } from './config-schema.js'
+import { Config } from './config-schema.js'
 import { registerRoutes } from './routes.js'
-import { analyzeSessionEvents } from './analyze-session.js'
-import { discoverLocalCliSessions, loadLocalCliBlob } from './import-auth.js'
-import { readFileSync } from 'node:fs'
-import z from '@deepseek-ai/schemastery'
-import { PROVIDERS, oauthRef, parseOauthRef, isProvider, displayName, droppedCredentialRefs } from './refs.js'
-import { createPkce } from './pkce.js'
-import { parseCallbackInput, requestOrigin, webCallbackUri } from './oauth.js'
-import { writeJson, writeHtml, readBody, isTrustedSettingsRequest, queryOf } from './http.js'
+import { oauthRef, parseOauthRef, isProvider, displayName } from './refs.js'
+import { webCallbackUri } from './oauth.js'
 import { getVendor, registerCustomVendor, clearCustomVendors } from './vendors/index.js'
-import { SubscriptionAdapter } from './adapter.js'
 import { generateOnce, SIZES as IMAGE_SIZES } from './images.js'
 import { parseBlob } from './blob.js'
 import { createVendorFromProfile, validateProfile } from './vendor-factory.js'
 import { registerCustomProviderIds, registerDisplayName } from './refs.js'
 import { createSubscriptionsService } from './subscriptions.js'
-import { encryptWithPassphrase, decryptWithPassphrase } from './crypto.js'
-import { quotaSnapshot } from './ratelimit.js'
 import { createAccountStore, normalizeSlots, vendorConfig } from './accounts.js'
-import { credentialRef } from '@deepseek-ai/dsh-credentials'
-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 { maskEmail, maskLabel } from './mask.js'
+import { proxyFetch } from './proxy.js'
 import { HistoryStore, DEFAULT_HISTORY_DIR } from './history.js'
+import { createDiagnosticsReport } from './diagnostics.js'
+import { createAccountsView } from './accounts-view.js'
+import { createAdapterManager } from './adapter-manager.js'
+
 export { observeForecast, estimateForecast } from './forecast.js'
 export { formatRelativeReset } from './relative-time.js'
-import {
-  inspectGoogleAccount,
-  antigravityMetadata,
-  antigravityIdentityHeaders,
-} from './code-assist.js'
-
-import { resolveFallbackVendor, mapFallbackModel, DEFAULT_CASCADE_CHAINS } from './cascade.js'
-import { exportVault, importVault } from './vault.js'
-import { recordAlert, getRecentAlerts, checkQuotaThresholds, notifySessionExpired } from './alerts.js'
-import { calculateBurnRatePerHour, computePacingRisk } from './forecast.js'
-import { needsWarmupProbe, enterProbing, resolveWarmupSuccess, resolveWarmupFailure } from './quarantine.js'
 export { resolveFallbackVendor, mapFallbackModel, DEFAULT_CASCADE_CHAINS } from './cascade.js'
 export { exportVault, importVault } from './vault.js'
 export { recordAlert, getRecentAlerts, checkQuotaThresholds, notifySessionExpired } from './alerts.js'
 export { calculateBurnRatePerHour, computePacingRisk } from './forecast.js'
 export { needsWarmupProbe, enterProbing, resolveWarmupSuccess, resolveWarmupFailure } from './quarantine.js'
+
 export const name = '@goodandready/dsh-subscriptions'
 export const inject = ['llm', 'credentials', 'webServer', 'settings']
 
 const NS = 'dsh-subscriptions'
 
 let pkgVersion = ''
-try { pkgVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version || '' } catch (err) { /* ignore package read errors at startup */ }
+try { pkgVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version || '' } catch { /* ignore package read errors at startup */ }
 const PENDING_TTL_MS = 15 * 60 * 1000
 
-function redirectFor(provider, cfg, origin) {
-  const overlay = vendorConfig(provider, cfg)
-  if (cfg.useWebCallback) return webCallbackUri(origin)
-  return overlay.redirectUri || webCallbackUri(origin)
-}
-
-const OK_HTML = '<!doctype html><meta charset="utf-8"><title>Subscriptions</title><p>Signed in. You can close this tab and return to Settings.</p>'
-
-export function apply(ctx, config) {
-  const logger = ctx.logger ? ctx.logger('subscriptions') : console
+const OK_HTML = `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>dsh-subscriptions - connected</title>
+    <style>
+      body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+             background: #0d1117; color: #c9d1d9; display: flex; align-items: center;
+             justify-content: center; height: 100vh; margin: 0; }
+      .card { background: #161b22; border: 1px solid #30363d; border-radius: 8px;
+              padding: 24px 32px; text-align: center; max-width: 360px; }
+      h1 { font-size: 18px; margin: 0 0 8px; color: #58a6ff; }
+      p { font-size: 13px; line-height: 1.5; margin: 0 0 16px; color: #8b949e; }
+      .btn { display: inline-block; background: #238636; color: #fff; padding: 6px 14px;
+             border-radius: 6px; text-decoration: none; font-size: 13px; font-weight: 500; }
+    </style>
+  </head>
+  <body>
+    <div class="card">
+      <h1>Account connected</h1>
+      <p>Authentication token was saved. You can close this tab and return to DeepSeek Harness.</p>
+      <a class="btn" href="javascript:window.close()">Close window</a>
+    </div>
+  </body>
+</html>`
+
+export function apply(ctx, rawConfig) {
+  const logger = ctx.logger ? ctx.logger('subscriptions') : undefined
   let settingsApi
-  // #367: maintain a single immutable config snapshot without structuredClone on hot path
-  let cachedConfig = Config(config ?? {}) ?? config
-
-  function syncSnapshot(raw) {
-    if (raw !== undefined && raw !== null) {
-      try {
-        cachedConfig = Config(raw ?? {}) ?? config
-      } catch {
-        cachedConfig = config
-      }
-    } else if (settingsApi && typeof settingsApi.get === 'function') {
-      try {
-        const rawSettings = settingsApi.get()
-        cachedConfig = Config(rawSettings ?? {}) ?? config
-      } catch {
-        cachedConfig = config
-      }
-    }
-    syncCustomVendors()
-    return cachedConfig
-  }
 
+  let cachedConfig = Config(rawConfig || {})
   const live = () => cachedConfig
 
-  // Registering custom vendors from Config. Runs at startup and on
-  // every config change (replace) - the registry is rebuilt from scratch.
   function syncCustomVendors() {
     let profiles
     try {
@@ -111,60 +91,70 @@ export function apply(ctx, config) {
       }
     }
   }
-
   syncCustomVendors()
 
-  ctx.inject(['settings'], (sctx) => {
-    const scope = sctx.settings.register(NS, Config, { base: config })
-    settingsApi = {
-      ...scope,
-      get: () => (typeof scope.get === 'function' ? scope.get() : cachedConfig),
-      async replace(next) {
-        syncSnapshot(next)
-        if (typeof scope.replace === 'function') {
-          return await scope.replace(next)
-        }
-      },
-    }
+  const syncSnapshot = (next) => {
+    try {
+      const fresh = next !== undefined ? next : (typeof settingsApi?.get === 'function' ? settingsApi.get() : cachedConfig)
+      cachedConfig = Config(fresh || {})
+      syncCustomVendors()
+      syncAdapter().catch(() => {})
+      syncOllama().catch(() => {})
+    } catch { /* keep existing snapshot on error */ }
+  }
 
-    if (typeof scope.get === 'function') {
-      syncSnapshot(scope.get())
-    }
+  if (typeof ctx.inject === 'function') {
+    ctx.inject(['settings'], (sctx) => {
+      const scope = sctx.settings.register(NS, Config, { base: rawConfig })
+      settingsApi = {
+        ...scope,
+        get: () => (typeof scope.get === 'function' ? scope.get() : cachedConfig),
+        async replace(next) {
+          syncSnapshot(next)
+          if (typeof scope.replace === 'function') {
+            return await scope.replace(next)
+          }
+        },
+      }
 
-    if (typeof scope.watch === 'function') {
-      try {
-        const unwatch = scope.watch((next) => syncSnapshot(next))
-        if (typeof unwatch === 'function') {
-          sctx.effect(() => unwatch)
-        }
-      } catch { /* ignore watch error */ }
-    }
+      if (typeof scope.get === 'function') {
+        syncSnapshot(scope.get())
+      }
 
-    Promise.resolve().then(() => {
-      reconcileSlots().catch((err) => {
-        if (logger && logger.warn) logger.warn('[dsh-subscriptions] reconcileSlots initial error: ' + (err && err.message || err))
+      if (typeof scope.watch === 'function') {
+        try {
+          const unwatch = scope.watch((next) => syncSnapshot(next))
+          if (typeof unwatch === 'function') {
+            sctx.effect(() => unwatch)
+          }
+        } catch { /* ignore watch error */ }
+      }
+
+      Promise.resolve().then(() => {
+        reconcileSlots().catch((err) => {
+          if (logger && logger.warn) logger.warn('[dsh-subscriptions] reconcileSlots initial error: ' + (err && err.message || err))
+        })
       })
-    })
 
-    const onDocUpdated = (ns) => {
-      if (!ns || ns === NS) {
-        syncSnapshot()
+      const onDocUpdated = (ns) => {
+        if (!ns || ns === NS) {
+          syncSnapshot()
+        }
+      }
+      if (typeof sctx.on === 'function') {
+        sctx.on('settings/document-updated', onDocUpdated)
+      } else if (typeof ctx.on === 'function') {
+        ctx.on('settings/document-updated', onDocUpdated)
       }
-    }
-    if (typeof sctx.on === 'function') {
-      sctx.on('settings/document-updated', onDocUpdated)
-    } else if (typeof ctx.on === 'function') {
-      ctx.on('settings/document-updated', onDocUpdated)
-    }
 
-    sctx.effect(() => () => {
-      settingsApi = undefined
-      cachedConfig = Config(config ?? {}) ?? config
-      syncCustomVendors()
+      sctx.effect(() => () => {
+        settingsApi = undefined
+        cachedConfig = Config(rawConfig || {})
+        syncCustomVendors()
+      })
     })
-  })
+  }
 
-  // #88: fetch bound to the per-account proxy (slot.proxyUrl), or null for direct.
   const fetchForRef = (ref) => {
     const parsed = parseOauthRef(ref)
     if (!parsed) return null
@@ -173,6 +163,16 @@ export function apply(ctx, config) {
     return proxyFetch(slot.proxyUrl)
   }
 
+  function redirectFor(ref, provider) {
+    if (live().useWebCallback) {
+      const origin = (ctx.webServer && typeof ctx.webServer.url === 'string')
+        ? ctx.webServer.url
+        : ''
+      return webCallbackUri(origin, ref)
+    }
+    return getVendor(provider).redirectUri(vendorConfig(provider, live()))
+  }
+
   const store = createAccountStore({
     credentials: ctx.credentials,
     getConfig: live,
@@ -186,6 +186,9 @@ export function apply(ctx, config) {
     },
   })
   const history = new HistoryStore(DEFAULT_HISTORY_DIR, 7 * 24 * 60 * 60 * 1000, 1000)
+  if (typeof ctx?.on === 'function') {
+    ctx.on('dispose', () => history.dispose())
+  }
   const recordHistory = (entry) => history.add(entry)
 
   // #85: host-only reset credit service for Codex accounts.
@@ -195,8 +198,11 @@ export function apply(ctx, config) {
     return slot ? slot.ref : null
   }
 
-  // #91: local Ollama - native provider + seamless fallback when the whole
-  // pool is exhausted and nothing has been streamed yet.
+  function stripLegacySlots(slots) {
+    return (slots || []).filter((slot) => isProvider(slot.provider))
+  }
+
+  // Local Ollama adapter and fallback
   const ollamaAdapter = new OllamaAdapter({
     baseUrl: () => ollamaBase(live()),
     fallbackModel: () => live().ollamaFallbackModel || '',
@@ -212,6 +218,7 @@ export function apply(ctx, config) {
       ollamaHandle = undefined
     }
   }
+
   async function* ollamaFallbackStream({ options, provider, err }) {
     const cfg = live()
     const models = await ollamaModels(ollamaBase(cfg), fetch).catch(() => [])
@@ -229,10 +236,27 @@ export function apply(ctx, config) {
         status: 200,
         kind: 'fallback',
       })
-    } catch (err) { if (logger && logger.debug) logger.debug('[history] fallback record failed: ' + (err && err.message || err)) }
+    } catch { /* best-effort */ }
     yield* ollamaAdapter.stream({ ...options, provider: 'ollama', model })
   }
 
+  // LLM Adapter lifecycle manager
+  const adapterManager = createAdapterManager({
+    ctx,
+    live,
+    store,
+    logger,
+    fetch,
+    fetchForRef,
+    recordHistory,
+    getSettingsApi: () => settingsApi,
+    syncCustomVendors,
+    syncOllama,
+    stripLegacySlots,
+  })
+  const { syncAdapter, reconcileSlots, refreshModels, cascadeFallbackStream } = adapterManager
+  adapterManager.registerAdapterLifecycle()
+
   const subscriptions = createSubscriptionsService({
     listAccounts: (provider) => store.listAccounts(provider),
     loadBlob: (ref) => store.loadBlob(ref),
@@ -259,24 +283,13 @@ export function apply(ctx, config) {
     hideDeprecatedModels: () => !!live().hideDeprecatedModels,
   })
 
-  // Subscription-backed image generation service.
-  //
-  // An action is exposed, not a token: a network route would hand a live
-  // access key to anyone reaching the harness, while the service lives inside
-  // the process and is visible only to sibling plugins. Token refresh stays
-  // with a single owner - this plugin.
   ctx.effect(() => ctx.provide('subscriptions', subscriptions), 'dsh-subscriptions: subscriptions service')
   ctx.effect(() => ctx.provide('subscriptionImages', {
-    /** Providers with an active session right now. */
     async available() {
       const logged = await store.loggedInProviders()
       return ['codex', 'grok'].filter((name) => logged && logged[name])
     },
     sizes: IMAGE_SIZES,
-    /**
-     * @param request {{provider, prompt, size, quality, signal}}
-     * @returns [{ b64_json, revisedPrompt? }]
-     */
     async generate(request) {
       const provider = request && request.provider
       if (provider !== 'codex' && provider !== 'grok') {
@@ -299,209 +312,12 @@ export function apply(ctx, config) {
       })
     },
   }), 'dsh-subscriptions: image generation service')
-  const pending = new Map()
-    async function* cascadeFallbackStream({ options, provider, err, visited = new Set() }) {
-    const cfg = live()
-    if (!cfg.cascadingFallback) throw err
-    const logged = await store.loggedInProviders()
-    const available = Object.keys(logged || {}).filter((p) => logged[p] && p !== provider)
-    visited.add(provider)
-    const nextVendor = resolveFallbackVendor(provider, available, cfg.cascadingChain, visited)
-    if (!nextVendor) throw err
-    visited.add(nextVendor)
-    const targetModel = mapFallbackModel(provider, options && options.model, nextVendor)
-    if (logger && logger.warn) {
-      logger.warn('[dsh-subscriptions] ' + provider + ': all accounts exhausted, cascading fallback to ' + nextVendor + '/' + targetModel)
-    }
-    yield* adapter.stream({ ...options, provider: nextVendor, model: targetModel }, visited)
-    try {
-      recordHistory({
-        provider: nextVendor,
-        ref: String(nextVendor).toUpperCase() + '_CASCADE_FALLBACK',
-        model: targetModel,
-        path: '/v1/chat/completions',
-        method: 'POST',
-        status: 200,
-        kind: 'cascade',
-      })
-    } catch (e) { /* ignore cascade history recording error */ }
-  }
-
-  const adapter = new SubscriptionAdapter({
-    listAccounts: (provider) => store.listAccounts(provider),
-    loadBlob: (ref) => store.loadBlob(ref),
-    ensureFresh: (provider, blob, ref) => store.ensureFresh(provider, blob, ref),
-    vendorConfig: (provider) => vendorConfig(provider, live()),
-    cooldownMs: () => live().cooldownMs,
-    switchAtRemaining: () => live().switchAtRemaining,
-    rememberCooldown: (ref, until, families) => store.rememberCooldown(ref, until, families),
-    rememberQuarantine: (ref, reason, until) => store.rememberQuarantine(ref, reason, until),
-    rememberQuota: (ref, snap) => store.rememberQuota(ref, snap),
-    getQuota: (ref) => store.getQuota(ref),
-    refreshUsage: (provider) => store.refreshUsage(provider),
-    saveBlob: (ref, blob) => store.saveBlob(ref, blob),
-    recordHistory,
-    fetchImpl: fetch,
-    fetchForRef,
-  })
-
-  let handle
-  let adapterDisposed = false
-  let registeredByUs = new Set()
-  function disposeAdapterHandle(h) {
-    if (!h) return
-    try {
-      if (typeof h === 'function') h()
-      else if (typeof h.dispose === 'function') h.dispose()
-    } catch (err) {
-      if (logger && logger.debug) logger.debug('[dsh-subscriptions] dispose handle error: ' + (err && err.message || err))
-    }
-  }
-
-  async function syncAdapter() {
-    if (adapterDisposed) return
-    const desired = await store.loggedInProviders()
-    const globalProviders = ctx.llm && typeof ctx.llm.listProviders === 'function'
-      ? ctx.llm.listProviders().map((p) => p.id)
-      : []
-    const globalSet = new Set(globalProviders)
-
-    const claimable = desired.filter((p) => !globalSet.has(p) || registeredByUs.has(p))
-    const skipped = desired.filter((p) => globalSet.has(p) && !registeredByUs.has(p))
 
-    if (skipped.length && logger && logger.info) {
-      logger.info(`[dsh-subscriptions] syncAdapter skipping already-bound providers: ${skipped.join(', ')}`)
-    }
-
-    if (!handle && claimable.length) {
-      handle = ctx.llm.registerAdapter(claimable, adapter)
-      registeredByUs = new Set(claimable)
-      return
-    }
-    if (!handle) {
-      registeredByUs.clear()
-      return
-    }
-    if (!claimable.length) {
-      disposeAdapterHandle(handle)
-      handle = undefined
-      registeredByUs.clear()
-      return
-    }
-    if (typeof handle.replace === 'function') {
-      try {
-        handle.replace(claimable)
-        registeredByUs = new Set(claimable)
-        return
-      } catch (err) {
-        if (logger && logger.warn) logger.warn('[dsh-subscriptions] handle.replace failed: ' + (err && err.message || err))
-        disposeAdapterHandle(handle)
-        handle = undefined
-        registeredByUs.clear()
-      }
-    } else {
-      disposeAdapterHandle(handle)
-      handle = undefined
-      registeredByUs.clear()
-    }
-
-    const currentGlobal = new Set((ctx.llm && typeof ctx.llm.listProviders === 'function' ? ctx.llm.listProviders() : []).map((p) => p.id))
-    const reClaimable = desired.filter((p) => !currentGlobal.has(p))
-    if (reClaimable.length) {
-      handle = ctx.llm.registerAdapter(reClaimable, adapter)
-      registeredByUs = new Set(reClaimable)
-    }
-  }
-
-  async function reconcileSlots() {
-    const api = settingsApi
-    if (!api || typeof api.replace !== 'function') return
-    const creds = ctx.credentials
-    if (!creds || typeof creds.describe !== 'function') return
-
-    try {
-      const existing = normalizeSlots(live().slots)
-      const existingRefs = new Set(existing.map((s) => s.ref))
-      const candidateProviders = PROVIDERS.filter((p) => isProvider(p))
-      const candidates = []
-      for (const provider of candidateProviders) {
-        for (let index = 1; index <= 10; index++) {
-          const ref = oauthRef(provider, index)
-          if (!existingRefs.has(ref)) {
-            candidates.push({ provider, index, ref })
-          }
-        }
-      }
-
-      const additionResults = await Promise.all(
-        candidates.map(async ({ provider, index, ref }) => {
-          let d
-          try {
-            d = await creds.describe(credentialRef(ref))
-          } catch (err) {
-            if (logger && logger.debug) logger.debug(`[dsh-subscriptions reconcile] describe ${ref} error: ` + (err && err.message || err))
-            return null
-          }
-          if (d && d.configured) {
-            let label = d.label || ''
-            try {
-              const blob = await store.loadBlob(ref).catch(() => null)
-              if (blob && (blob.email || blob.label)) {
-                label = blob.email || blob.label || label
-              }
-            } catch (loadErr) {
-              if (logger && logger.debug) logger.debug(`[dsh-subscriptions reconcile] loadBlob ${ref} error: ` + (loadErr && loadErr.message || loadErr))
-            }
-            return { provider, index, label }
-          }
-          return null
-        })
-      )
-      const additions = additionResults.filter(Boolean)
-
-      if (!additions.length) return
-      if (logger && logger.info) {
-        logger.info(`[dsh-subscriptions reconcile] restoring orphaned vault slots: ${additions.map((a) => `${a.provider}#${a.index}`).join(', ')}`)
-      }
-      const currentSlots = Array.isArray(live().slots) ? live().slots : []
-      const newSlots = [...currentSlots, ...additions]
-      const parsed = Config({ ...live(), slots: stripLegacySlots(newSlots) })
-      await api.replace(parsed)
-      syncCustomVendors()
-      await syncAdapter()
-      refreshModels().catch((err) => {
-        if (logger && logger.debug) logger.debug('[dsh-subscriptions reconcile] refreshModels error: ' + (err && err.message || err))
-      })
-    } catch (e) {
-      if (logger && logger.warn) {
-        logger.warn('[dsh-subscriptions reconcile] failed: ' + (e && e.message || e))
-      }
-    }
-  }
-
-  // #46: after a login lands, eagerly refresh the live model catalog so the
-  // model picker shows the new provider within ~1 min instead of waiting.
-  let lastModelRefresh = 0
-  async function refreshModels() {
-    if (Date.now() - lastModelRefresh < 60 * 1000) return
-    lastModelRefresh = Date.now()
-    const providers = await store.loggedInProviders()
-    for (const provider of providers) {
-      try {
-        const slot = normalizeSlots(live().slots).find((x) => x.provider === provider)
-        if (!slot) continue
-        const blob = await store.loadBlob(slot.ref).catch(() => null)
-        if (!blob) continue
-        const fresh = await store.ensureFresh(provider, blob, slot.ref)
-        const cfg = vendorConfig(provider, live())
-        await getVendor(provider).listModels(fresh, cfg, fetch).catch(() => {})
-      } catch (err) { /* best-effort */ }
-    }
-  }
+  const pending = new Map()
 
   function sweepPending(now) {
-    for (const [state, row] of pending) {
-      if (now - row.createdAt > PENDING_TTL_MS) pending.delete(state)
+    for (const [stateKey, row] of pending) {
+      if (now - row.createdAt > PENDING_TTL_MS) pending.delete(stateKey)
     }
   }
 
@@ -534,226 +350,15 @@ export function apply(ctx, config) {
     return { ref, label: pmL(blob.label || blob.email) || displayName(provider) }
   }
 
-  async function enrichAntigravityAccount(slot, info) {
-    if (!info.configured || slot.provider !== 'antigravity') return info
-    let blob
-    try { blob = await store.loadBlob(slot.ref) } catch { return info }
-    if (blob.validationUrl) {
-      return {
-        ...info,
-        validationUrl: blob.validationUrl,
-        validationMessage: blob.validationMessage || info.validationMessage || '',
-        paidTierName: blob.paidTierName || info.paidTierName || '',
-      }
-    }
-    try {
-      const fresh = await store.ensureFresh(slot.provider, blob, slot.ref)
-      const probe = await inspectGoogleAccount(fetch, fresh.accessToken, {
-        metadata: antigravityMetadata(fresh.projectId || ''),
-        extraHeaders: antigravityIdentityHeaders(fresh.projectId || ''),
-        projectId: fresh.projectId,
-      })
-      const next = { ...fresh }
-      if (probe.projectId && probe.projectId !== fresh.projectId) next.projectId = probe.projectId
-      if (probe.paidTierId) next.paidTierId = probe.paidTierId
-      if (probe.paidTierName) next.paidTierName = probe.paidTierName
-      if (probe.validation?.validationUrl) {
-        next.validationUrl = probe.validation.validationUrl
-        next.validationMessage = probe.validation.message || ''
-        await store.saveBlob(slot.ref, next)
-        return {
-          ...info,
-          validationUrl: next.validationUrl,
-          validationMessage: next.validationMessage,
-          paidTierName: 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 || '' }
-      }
-      if (probe.projectId || probe.paidTierId) await store.saveBlob(slot.ref, next)
-      return { ...info, paidTierName: next.paidTierName || info.paidTierName || '' }
-    } catch { /* keep settings responsive */ }
-    return info
-  }
-
-  function stripLegacySlots(slots) {
-    return (slots || []).filter((slot) => isProvider(slot.provider))
-  }
-
-  // #98: privacy masking. pmE for raw emails, pmL for display labels (only email-looking ones masked).
+  // Privacy masking
   const privacyOn = () => !!live().privacyMask
   const pmE = (s) => privacyOn() ? maskEmail(s) : String(s || '')
   const pmL = (s) => privacyOn() ? maskLabel(s) : String(s || '')
 
-  // #99: anonymized diagnostics report. No tokens, emails, refs, proxy URLs.
-  function scrubReport(v) {
-    if (typeof v === 'string') return maskText(v)
-    if (Array.isArray(v)) return v.map(scrubReport)
-    if (v && typeof v === 'object') {
-      const o = {}
-      for (const k of Object.keys(v)) o[k] = scrubReport(v[k])
-      return o
-    }
-    return v
-  }
-
-  async function diagnosticsReport() {
-    const cfg = live()
-    const slots = normalizeSlots(cfg.slots)
-    const mk = () => ({ loggedIn: false, slots: 0, configured: 0, cooldown: 0, proxy: 0, maxUsagePercent: null })
-    const providers = {}
-    for (const p of PROVIDERS) providers[p] = mk()
-    const logged = await store.loggedInProviders()
-    for (const slot of slots) {
-      const pv = providers[slot.provider] || (providers[slot.provider] = mk())
-      pv.slots++
-      if (slot.proxyUrl) pv.proxy++
-      try {
-        const info = await store.describeRef(slot.ref)
-        if (info.configured) pv.configured++
-        if (info.cooldownUntil && info.cooldownUntil > Date.now()) pv.cooldown++
-        if (info.usagePercent != null) pv.maxUsagePercent = Math.max(pv.maxUsagePercent || 0, Math.round(info.usagePercent))
-      } catch (err) { /* best-effort */ }
-    }
-    for (const p of Object.keys(providers)) providers[p].loggedIn = logged.includes(p)
-    const rows = history.all()
-    const byStatus = {}
-    for (const r of rows) {
-      const k = (r.provider || '?') + ':' + (r.status || '?')
-      byStatus[k] = (byStatus[k] || 0) + 1
-    }
-    const lastErrors = rows.filter((r) => r.status && r.status >= 400).slice(0, 10)
-      .map((r) => ({ ts: r.ts, provider: r.provider, status: r.status, kind: r.kind || 'request', ms: r.ms || null }))
-    return scrubReport({
-      generatedAt: new Date().toISOString(),
-      plugin: NS + (pkgVersion ? ' v' + pkgVersion : ''),
-      runtime: { node: process.version, platform: process.platform, arch: process.arch, uptimeSec: Math.round(process.uptime()) },
-      providers,
-      requests: { total: rows.length, byStatus, lastErrors },
-      settings: {
-        cooldownMs: cfg.cooldownMs,
-        switchAtRemaining: cfg.switchAtRemaining,
-        probeIntervalMin: cfg.probeIntervalMin,
-        useWebCallback: !!cfg.useWebCallback,
-        autoLoopback: !!cfg.autoLoopback,
-        privacyMask: !!cfg.privacyMask,
-        customVendors: Array.isArray(cfg.customVendors) ? cfg.customVendors.length : 0,
-        proxySlots: slots.filter((s) => s.proxyUrl).length,
-      },
-    })
-  }
-
-  async function accountsView() {
-    const out = []
-    for (const slot of normalizeSlots(live().slots)) {
-      const info = await enrichAntigravityAccount(slot, await store.describeRef(slot.ref))
-      out.push({
-        provider: slot.provider,
-        index: slot.index,
-        ref: slot.ref,
-        label: pmL(slot.label || info.label),
-        configured: info.configured,
-        writable: info.writable,
-        cooldownUntil: info.cooldownUntil,
-        // #303: expose the cooldown scope and quarantine so the card can
-        // explain why only some models are blocked.
-        cooldownFamilies: info.cooldownFamilies || null,
-        quarantineUntil: info.quarantineUntil || 0,
-        quarantineReason: info.quarantineReason || null,
-        usagePercent: info.usagePercent,
-        quota: info.quota || null,
-        usage: info.usage || null,
-        requests: store.getRequestCount(slot.ref) || null,
-        refreshError: info.refreshError || '',
-        validationUrl: info.validationUrl || '',
-        validationMessage: info.validationMessage || '',
-        accountNotice: info.accountNotice || '',
-        paidTierName: info.paidTierName || '',
-      })
-    }
-    return out
-  }
-
-  async function configResponse() {
-    return {
-      ok: true,
-      config: publicConfig(live()),
-      accounts: await accountsView(),
-      providers: PROVIDERS.map((id) => ({ id, name: displayName(id) })),
-    }
-  }
-
-  ctx.effect(() => {
-    syncAdapter().catch((err) => {
-      if (logger && logger.debug) logger.debug('[dsh-subscriptions] syncAdapter initial error: ' + (err && err.message || err))
-    })
-    syncOllama().catch((err) => {
-      if (logger && logger.debug) logger.debug('[dsh-subscriptions] syncOllama initial error: ' + (err && err.message || err))
-    })
-    reconcileSlots().catch((err) => {
-      if (logger && logger.debug) logger.debug('[dsh-subscriptions] reconcileSlots effect error: ' + (err && err.message || err))
-    })
-
-    let retries = 0
-    let retryTimer
-    const scheduleRetry = () => {
-      if (adapterDisposed || retries >= 30) return
-      retryTimer = setTimeout(retrySync, 1000)
-      if (retryTimer && typeof retryTimer.unref === 'function') retryTimer.unref()
-    }
-    const retrySync = async () => {
-      if (adapterDisposed) return
-      try {
-        const loggedIn = await store.loggedInProviders()
-        if (!loggedIn.length) return
-        const registered = ctx.llm && typeof ctx.llm.listProviders === 'function'
-          ? ctx.llm.listProviders().map((p) => p.id)
-          : []
-        const regSet = new Set(registered)
-        const pending = loggedIn.filter((p) => !regSet.has(p))
-        if (pending.length === 0) return
-        retries += 1
-        await syncAdapter()
-        if (retries < 30) {
-          scheduleRetry()
-        }
-      } catch (err) {
-        if (logger && logger.debug) logger.debug('[dsh-subscriptions] retrySync error: ' + (err && err.message || err))
-        if (retries < 30) {
-          scheduleRetry()
-        }
-      }
-    }
-    scheduleRetry()
+  const diagnosticsReport = () => createDiagnosticsReport({ live, store, history, NS, pkgVersion })
+  const accountsView = () => createAccountsView({ live, store, fetch, pmL })
 
-    // #75: eager usage refresh at startup so the windows (5h/7d) land in the blob immediately
-    // and the active subscription chip shows 5h/7d/... right away instead of waiting for probeInterval.
-    const eager = async () => {
-      try {
-        for (const slot of normalizeSlots(live().slots)) {
-          store.refreshUsage(slot.provider).catch((err) => {
-            if (logger && logger.debug) logger.debug('[dsh-subscriptions] eager usage error: ' + (err && err.message || err))
-          })
-        }
-      } catch (err) {
-        if (logger && logger.debug) logger.debug('[dsh-subscriptions] eager refresh error: ' + (err && err.message || err))
-      }
-    }
-    eager()
-    return () => {
-      adapterDisposed = true
-      if (retryTimer) clearTimeout(retryTimer)
-      if (handle) {
-        disposeAdapterHandle(handle)
-        handle = undefined
-        registeredByUs.clear()
-      }
-    }
-  }, 'dsh-subscriptions: llm adapter')
-  // ponytail: background refresh ahead of expiry, single timer, per-account lock + retry backoff
+  // Ponytail: background refresh ahead of expiry, single timer
   ctx.effect(() => {
     const tick = async () => {
       const cfg = live()
@@ -774,9 +379,9 @@ export function apply(ctx, config) {
           if (blob.expiresAt - now > ahead) continue
           if (typeof store.shouldSkipRefresh === 'function' && store.shouldSkipRefresh(ref, now, retryMs)) continue
           await store.ensureFresh(slot.provider, blob, ref).catch((e) => {
-            if (logger && logger.warn) logger.warn("[dsh-subscriptions] background refresh failed for " + ref + ": " + String(e && e.message || e))
+            if (logger && logger.warn) logger.warn('[dsh-subscriptions] background refresh failed for ' + ref + ': ' + String(e && e.message || e))
           })
-        } catch (err) { /* best-effort */ }
+        } catch { /* best-effort */ }
       }
     }
     tick().catch(() => {})
@@ -786,15 +391,12 @@ export function apply(ctx, config) {
     return () => clear(id)
   }, 'dsh-subscriptions: refresh ahead')
 
-  // Background health-check: every N minutes runs a cheap check across all
-  // connected accounts. Dead ones are flagged via describeRef, no cooldown
-  // is set (same as /check).
+  // Background health-check probe loop
   ctx.effect(() => {
     const tick = async () => {
       const cfg = live()
       const mins = Number(cfg.probeIntervalMin)
       if (!Number.isFinite(mins) || mins <= 0) return
-      const now = Date.now()
       for (const slot of normalizeSlots(cfg.slots)) {
         const ref = slot.ref
         try {
@@ -811,9 +413,9 @@ export function apply(ctx, config) {
           const cfg2 = vendorConfig(slot.provider, live())
           const probeFetch = async (u, i) => ((typeof fetchForRef === 'function' && fetchForRef(ref)) || fetch)(u, i)
           await vendor.check(fresh, cfg2, probeFetch).catch((e) => {
-            if (logger && logger.warn) logger.warn("[dsh-subscriptions] probe " + ref + ": " + String(e && e.message || e).slice(0, 200))
+            if (logger && logger.warn) logger.warn('[dsh-subscriptions] probe ' + ref + ': ' + String(e && e.message || e).slice(0, 200))
           })
-        } catch (err) { /* best-effort */ }
+        } catch { /* best-effort */ }
       }
     }
     let lastProbeAt = 0
@@ -830,8 +432,6 @@ export function apply(ctx, config) {
     return () => clearInterval(timer)
   }, 'dsh-subscriptions: probe loop')
 
-
-
   registerRoutes(ctx, {
     NS,
     live,