@goodandready/dsh-key-rotation 0.8.67 → 0.8.69

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.8.69 - 2026-10-19
+
+### Features
+- **Automated Clone Route Lifecycle & Settings Synchronization (#502)**:
+  - Added `lib/clone-lifecycle.js` orchestrating automatic configuration, key pools, and parameter synchronization for auxiliary clone routes.
+  - Cloned worker routes dynamically inherit primary model, temperature, top-p, context window limits, and token buckets while isolating per-key rotation states.
+  - Supported graceful route drain via `key-drain.js` (`getInFlight` & `getActive`), ensuring active in-flight requests finish cleanly before clone route teardown.
+
+### Bug Fixes
+- **Prompt Cache Periodic Maintenance Sweep (#511)**:
+  - Wired `compactPromptCache(pool, 30, now)` into the plugin's periodic maintenance sweep alongside `compactUsage`.
+  - Automatically purges prompt cache telemetry entries older than 30 days to prevent unbound memory growth during continuous production uptime.
+
+### Refactoring & Code Quality
+- **Core File Modularization (< 600 Lines Standard) (#512)**:
+  - Decomposed oversized monolithic modules to comply with `dsh-plugin-authoring` and `dsh-plugin-preflight` standards.
+  - Extracted key selection algorithms and sticky session routing from `lib/pool.js` into `lib/pool-selection.js` (bringing `pool.js` down from 654 to 521 lines).
+  - Extracted streaming success telemetry and proactive limit detection from `lib/rotate.js` into `lib/stream-metrics.js` and deduplicated cascade fallbacks (bringing `rotate.js` down from 716 to 595 lines).
+  - Decomposed monolithic UI card component `lib/client-src/50-card-main.js` (2,141 lines) into modular fragments: `50-card-main.js` (550 lines), `51-card-pool-mutators.js` (501 lines), `52-card-pool-rows.js` (590 lines), and `53-card-dialogs-and-render.js` (500 lines), ensuring 100% deterministic compilation and <600 lines for every source fragment.
+
+## 0.8.68 - 2026-10-19
+
+### Features
+- **24h Error Breakdown & Load Distribution Analytics (#505)**:
+  - Rolling 24-hour analytics engine (`lib/ops-analytics.js`): tracks sliding 24-hour request outcomes, key load distribution percentages, failovers, and cascade occurrences without memory leaks via bounded ring buffers.
+  - Multi-category failure classification: categorizes upstream errors into `429 Rate Limit`, `5xx Server`, `Timeout`, `Quota`, `Auth`, and `Other`.
+  - Health Index indicator: calculates the percentage of requests served clean on first attempt without failovers or retries (`cleanRequests / totalRequests * 100%`).
+  - Cooldown recovery telemetry: computes the average recovery time (`avgCooldownRecoveryMs`) from recent failure and recovery events.
+  - Settings Card UI: renders interactive Health Index badges (`🛡️ Health Index: 98% (clean)`), 24h error breakdown pills (`429: 2`, `5xx: 1`, `Timeout: 0`), cascade counters (`🔀 Cascades: X`), and average recovery time pills.
+- **Prompt Cache Savings Dashboard & Calculator (#497)**:
+  - Multi-provider prompt cache parser (`lib/prompt-cache.js`): extracts prefix cache hit and miss tokens across streaming and non-streaming responses from DeepSeek (`prompt_cache_hit_tokens`), Anthropic (`cache_read_input_tokens`), and OpenAI (`prompt_tokens_details.cached_tokens`).
+  - Financial savings engine: computes real-time USD cost savings based on provider-specific token discount tariffs (~90% discount on cache hits).
+  - Multi-window rolling aggregation: aggregates cached tokens, total input tokens, hit ratio (%), and dollar savings across 24h (`d1`), 7d (`d7`), and 30d (`d30`) sliding windows, plus per-model and per-key breakdowns.
+  - Settings Card Widget: compact «⚡ Prompt Cache Savings» card displaying 24h, 7d, and 30d cache hit tokens, effective cache hit ratio (%), and cumulative dollar savings.
+  - Telemetry & reporting: exposes prompt cache summaries and 24h analytics in `/dsh-key-rotation/status` and `/dsh-key-rotation/usage`.
+
 ## 0.8.67 - 2026-10-19
 
 ### Features

package/lib/client.js

@@ -283,6 +283,15 @@ window.__ModuleLoader__.load({
       passphrasePlaceholder: 'Enter master passphrase for encryption/decryption',
       jsonConfigPlaceholder: 'Paste JSON configuration here or choose a file...',
       previewSummary: 'Diff: {created} new providers, {updated} updated providers, {keys} keys ({added} new).',
+      promptCacheTitle: 'Prompt Cache Savings',
+      promptCacheDesc: 'Tokens served from prefix cache across sessions and estimated cost savings.',
+      promptCacheHitRatio: 'Hit Ratio',
+      promptCacheSaved: 'saved',
+      analytics24hTitle: '24h Pool Health & Load Balance',
+      healthIndex: 'Health Index',
+      cleanRequests: 'clean',
+      errorBreakdown: '24h Errors',
+      avgRecovery: 'Avg Recovery',
     };
 
     const zh = {
@@ -516,6 +525,15 @@ window.__ModuleLoader__.load({
       passphrasePlaceholder: '输入用于加密/解密的主密码',
       jsonConfigPlaceholder: '在此粘贴 JSON 配置或选择文件...',
       previewSummary: '差异: 新增 {created} 个提供商, 更新 {updated} 个提供商, 包含 {keys} 个密钥 (新增 {added} 个)。',
+      promptCacheTitle: 'Prompt 缓存节省',
+      promptCacheDesc: '会话间前缀缓存命中 Token 及预估节省成本。',
+      promptCacheHitRatio: '缓存命中率',
+      promptCacheSaved: '已节省',
+      analytics24hTitle: '24小时池健康度与负载分布',
+      healthIndex: '健康指数',
+      cleanRequests: '无重试',
+      errorBreakdown: '24小时错误',
+      avgRecovery: '平均恢复',
     };
 
     // Codes worth switching on. Host list is DEFAULT_SWITCH_CODES; config may
@@ -2482,7 +2500,55 @@ window.__ModuleLoader__.load({
             total > 0 && keyUsages.length > 1 ? h('div', { style: { marginTop: '8px', display: 'flex', alignItems: 'center', gap: '8px' } },
               h('span', { style: { fontSize: '11px', color: 'var(--dsw-alias-label-secondary)' } }, '📈 ' + t('sparklineTraffic') + ':'),
               h(Sparkline, { points: keyUsages.map(x => x.usage), width: 140, height: 20 })
-            ) : null
+            ) : null,
+            (() => {
+              const an = ps && ps.analytics24h ? ps.analytics24h : null;
+              if (!an || an.totalRequests === 0) return null;
+              const hColor = an.healthIndexPct >= 80 ? 'var(--dsw-alias-state-success-primary)' : an.healthIndexPct >= 50 ? 'var(--dsw-alias-state-warn-primary)' : 'var(--dsw-alias-state-error-primary)';
+              return h('div', { style: { marginTop: '8px', display: 'flex', flexWrap: 'wrap', alignItems: 'center', gap: '6px' } },
+                h('span', { className: 'krot-badge', style: { color: hColor, fontWeight: 700 } }, '🛡️ ' + t('healthIndex') + ': ' + an.healthIndexPct + '% (' + an.firstAttemptSuccesses + '/' + an.totalRequests + ' ' + t('cleanRequests') + ')'),
+                an.errorBreakdown.rateLimit > 0 ? h('span', { className: 'krot-badge krot-badge-warn' }, '429: ' + an.errorBreakdown.rateLimit) : null,
+                an.errorBreakdown.server > 0 ? h('span', { className: 'krot-badge krot-badge-warn' }, '5xx: ' + an.errorBreakdown.server) : null,
+                an.errorBreakdown.timeout > 0 ? h('span', { className: 'krot-badge krot-badge-warn' }, 'Timeout: ' + an.errorBreakdown.timeout) : null,
+                an.errorBreakdown.quota > 0 ? h('span', { className: 'krot-badge krot-badge-warn' }, 'Quota: ' + an.errorBreakdown.quota) : null,
+                an.cascades > 0 ? h('span', { className: 'krot-badge' }, '🔀 Cascades: ' + an.cascades) : null,
+                an.avgCooldownRecoveryMs > 0 ? h('span', { className: 'krot-badge' }, '⏱️ ' + t('avgRecovery') + ': ' + Math.round(an.avgCooldownRecoveryMs / 1000) + 's') : null
+              );
+            })()
+          );
+        })();
+
+        const promptCacheWidget = (() => {
+          const ps = status[entry.provider];
+          const pc = ps && ps.promptCache ? ps.promptCache : null;
+          if (!pc || (!pc.d30?.cachedTokens && !pc.allTime?.cachedTokens)) return null;
+          const d1 = pc.d1 || { cachedTokens: 0, savingsUsd: 0, hitRatioPct: 0 };
+          const d7 = pc.d7 || { cachedTokens: 0, savingsUsd: 0, hitRatioPct: 0 };
+          const d30 = pc.d30 || { cachedTokens: 0, savingsUsd: 0, hitRatioPct: 0 };
+          const savedStr = d30.savingsUsd > 0 ? '$' + d30.savingsUsd.toFixed(2) : '$0.00';
+          return h('div', {
+            className: 'krot-prompt-cache-card',
+            style: {
+              marginTop: '6px',
+              marginBottom: '6px',
+              padding: '8px 10px',
+              background: 'var(--dsw-alias-bg-layer-2)',
+              borderRadius: '6px',
+              border: '1px solid var(--dsw-alias-border-subtle)',
+              display: 'flex',
+              flexDirection: 'column',
+              gap: '4px'
+            }
+          },
+            h('div', { style: { display: 'flex', alignItems: 'center', justifyContent: 'space-between' } },
+              h('span', { style: { fontWeight: 600, fontSize: '12px' } }, '⚡ ' + t('promptCacheTitle')),
+              h('span', { className: 'krot-badge krot-badge-ok', style: { fontSize: '11px', fontWeight: 600 } }, savedStr + ' ' + t('promptCacheSaved'))
+            ),
+            h('div', { style: { display: 'flex', flexWrap: 'wrap', gap: '10px', fontSize: '11px', color: 'var(--dsw-alias-label-secondary)' } },
+              h('span', null, h('strong', { style: { color: 'var(--dsw-alias-label-primary)' } }, '24h: '), (d1.cachedTokens || 0).toLocaleString() + ' tok (' + d1.hitRatioPct + '%)'),
+              h('span', null, h('strong', { style: { color: 'var(--dsw-alias-label-primary)' } }, '7d: '), (d7.cachedTokens || 0).toLocaleString() + ' tok (' + d7.hitRatioPct + '%)'),
+              h('span', null, h('strong', { style: { color: 'var(--dsw-alias-label-primary)' } }, '30d: '), (d30.cachedTokens || 0).toLocaleString() + ' tok (' + d30.hitRatioPct + '%)')
+            )
           );
         })();
 
@@ -2646,6 +2712,7 @@ window.__ModuleLoader__.load({
           ),
           filterBar,
           loadChart,
+          promptCacheWidget,
           h('div', { className: 'krot-keys' }, keyRows),
           modelPools,
       h('div', { className: 'krot-foot' },

package/lib/clone-lifecycle.js

@@ -0,0 +1,199 @@
+// lib/clone-lifecycle.js — automated clone route lifecycle and settings synchronization (#502).
+// Ensures virtual clone providers (provider-2, provider-3) automatically copy and sync
+// baseUrl, headers, timeout, and models from the base provider, and graceful draining
+// on key reduction before deregistering routes.
+
+import { markKeyDraining, cancelKeyDrain, getDrainingStatus, isKeyDraining } from './key-drain.js';
+
+export const CLONE_SYNC_FIELDS = [
+  'baseUrl',
+  'baseURL',
+  'headers',
+  'timeout',
+  'systemPrompt',
+  'customHeaders',
+  'models',
+  'protocol',
+  'apiType',
+];
+
+/**
+ * Extracts syncable configuration from a base provider profile.
+ * @param {object} baseProfile
+ * @returns {object}
+ */
+export function extractSyncableConfig(baseProfile) {
+  if (!baseProfile || typeof baseProfile !== 'object') return {};
+  const syncable = {};
+  for (const field of CLONE_SYNC_FIELDS) {
+    if (baseProfile[field] !== undefined) {
+      syncable[field] = structuredClone(baseProfile[field]);
+    }
+  }
+  return syncable;
+}
+
+/**
+ * Copies base provider configuration onto each clone profile.
+ * @param {object} baseProfile
+ * @param {object} cloneProfile
+ * @returns {object} merged clone profile
+ */
+export function syncCloneProfile(baseProfile, cloneProfile = {}) {
+  const syncable = extractSyncableConfig(baseProfile);
+  const out = {
+    ...cloneProfile,
+    ...syncable,
+    isClone: true,
+  };
+  return out;
+}
+
+/**
+ * Synchronizes clone providers with their base provider settings.
+ * @param {object} opts
+ * @param {string} opts.baseProvider
+ * @param {Set<string>|string[]} opts.cloneIds
+ * @param {object} opts.profiles live provider profiles map from settings
+ * @param {Function} [opts.onUpdate] callback when clone is updated
+ * @returns {{ updated: string[], cloned: Record<string, object> }}
+ */
+export function synchronizeClones({ baseProvider, cloneIds, profiles, onUpdate }) {
+  if (!baseProvider || !profiles || typeof profiles !== 'object') {
+    return { updated: [], cloned: {} };
+  }
+
+  const baseProfile = profiles[baseProvider];
+  if (!baseProfile) {
+    return { updated: [], cloned: {} };
+  }
+
+  const updated = [];
+  const cloned = {};
+  const ids = cloneIds instanceof Set ? [...cloneIds] : (Array.isArray(cloneIds) ? cloneIds : []);
+
+  for (const cloneId of ids) {
+    if (!cloneId.startsWith(`${baseProvider}-`)) continue;
+    const existing = profiles[cloneId] || {};
+    const synced = syncCloneProfile(baseProfile, existing);
+    cloned[cloneId] = synced;
+    updated.push(cloneId);
+    if (typeof onUpdate === 'function') {
+      onUpdate(cloneId, synced);
+    }
+  }
+
+  return { updated, cloned };
+}
+
+/**
+ * Manages clone draining lifecycle when key count is reduced.
+ * Clones whose keys are removed are marked as draining, allowed to complete
+ * active in-flight streams, and safely deregistered only once in-flight reaches zero.
+ */
+export class CloneLifecycleManager {
+  /**
+   * @param {object} opts
+   * @param {object} opts.concurrencyTracker
+   * @param {object} [opts.logger]
+   */
+  constructor({ concurrencyTracker, logger } = {}) {
+    this.concurrencyTracker = concurrencyTracker;
+    this.logger = logger || console;
+    this.drainingClones = new Map(); // cloneId -> { provider, ref, startedAt, timer }
+  }
+
+  /**
+   * Evaluates previous vs current expected clones for a provider.
+   * If a clone was removed, marks it draining instead of instantly destroying it.
+   * @param {string} provider
+   * @param {Set<string>|string[]} prevClones
+   * @param {Set<string>|string[]} currentClones
+   * @param {Function} onDeregister callback when draining completes and route is safe to remove
+   */
+  reconcileClones(provider, prevClones, currentClones, onDeregister) {
+    const prevSet = prevClones instanceof Set ? prevClones : new Set(prevClones || []);
+    const currSet = currentClones instanceof Set ? currentClones : new Set(currentClones || []);
+
+    for (const cloneId of prevSet) {
+      if (!currSet.has(cloneId)) {
+        this.startDrain(cloneId, provider, onDeregister);
+      }
+    }
+
+    for (const cloneId of currSet) {
+      if (this.drainingClones.has(cloneId)) {
+        this.cancelDrain(cloneId);
+      }
+    }
+  }
+
+  startDrain(cloneId, provider, onDeregister) {
+    if (this.drainingClones.has(cloneId)) return;
+
+    markKeyDraining(cloneId, provider);
+    const entry = {
+      cloneId,
+      provider,
+      startedAt: Date.now(),
+      onDeregister,
+    };
+    this.drainingClones.set(cloneId, entry);
+
+    if (this.logger?.info) {
+      this.logger.info(`[dsh-key-rotation] clone ${cloneId} (${provider}) marked draining; awaiting in-flight stream completion`);
+    }
+
+    this._checkDrainCompletion(cloneId);
+  }
+
+  _checkDrainCompletion(cloneId) {
+    const entry = this.drainingClones.get(cloneId);
+    if (!entry) return;
+
+    const inFlight = this.concurrencyTracker && typeof this.concurrencyTracker.getActive === 'function'
+      ? this.concurrencyTracker.getActive(cloneId)
+      : (this.concurrencyTracker && typeof this.concurrencyTracker.getInFlight === 'function'
+        ? this.concurrencyTracker.getInFlight(cloneId)
+        : 0);
+
+    if (inFlight === 0) {
+      this.drainingClones.delete(cloneId);
+      cancelKeyDrain(cloneId);
+      if (this.logger?.info) {
+        this.logger.info(`[dsh-key-rotation] clone ${cloneId} (${entry.provider}) drained cleanly; safe to deregister`);
+      }
+      if (typeof entry.onDeregister === 'function') {
+        entry.onDeregister(cloneId, entry.provider);
+      }
+    } else {
+      // Re-check after 500ms
+      setTimeout(() => this._checkDrainCompletion(cloneId), 500).unref?.();
+    }
+  }
+
+  cancelDrain(cloneId) {
+    this.drainingClones.delete(cloneId);
+    cancelKeyDrain(cloneId);
+  }
+
+  isDraining(cloneId) {
+    return this.drainingClones.has(cloneId) || isKeyDraining(cloneId);
+  }
+
+  getDrainingList() {
+    return Array.from(this.drainingClones.entries()).map(([cloneId, data]) => ({
+      cloneId,
+      provider: data.provider,
+      startedAt: data.startedAt,
+      elapsedMs: Date.now() - data.startedAt,
+    }));
+  }
+
+  destroy() {
+    for (const cloneId of this.drainingClones.keys()) {
+      cancelKeyDrain(cloneId);
+    }
+    this.drainingClones.clear();
+  }
+}

package/lib/index.js

@@ -22,6 +22,8 @@ import { ConcurrencyTracker } from './concurrency.js';
 import { QuotaStore } from './quota.js';
 import { WebhookSender, AlertDebouncer } from './webhook.js';
 import { compactUsage } from './usage-report.js';
+import { compactPromptCache } from './prompt-cache.js';
+import { CloneLifecycleManager, synchronizeClones } from './clone-lifecycle.js';
 import { json, handleConfigBridge } from './http-bridge.js';
 import { createRotate } from './rotate.js';
 import { initializePoolState } from './pool-state.js';
@@ -200,6 +202,8 @@ export function apply(ctx, config = {}) {
   const alertDebouncer = new AlertDebouncer({ sender: webhookSender, debounceMs: 2000 });
   const moduleNotifyQueue = new NotifyQueue({ send: (url, payload) => alertDebouncer.enqueue(url, payload) });
   const trafficSmoother = new TrafficSmoother({ maxQueueWaitMs: 800 });
+  const cloneLifecycle = new CloneLifecycleManager({ concurrencyTracker, logger });
+  ctx.effect(() => () => { cloneLifecycle.destroy(); }, 'dsh-key-rotation: clone lifecycle cleanup');
 
   const sandboxService = createSandboxService({ getRuntime: () => buildRuntime() });
   const { ensureSandboxRunner, probeRef, lastTestCache } = sandboxService;
@@ -243,6 +247,7 @@ export function apply(ctx, config = {}) {
       if (n > 0) logger.warn(`[dsh-key-rotation] sweep: cleared ${n} expired cooldown(s)`);
       for (const pool of (runtime.pools ?? runtime.poolByRef.values())) {
         compactUsage(pool, 30, now);
+        compactPromptCache(pool, 30, now);
       }
       checkBudgetAndHealthAlerts({
         runtime,
@@ -342,6 +347,7 @@ export function apply(ctx, config = {}) {
       moduleBreaker,
       lowHealthNotifiedAt,
       budgetNotifiedAt,
+      cloneLifecycle,
     });
 
     concurrencyTracker.configure({ limit: concurrencyLimit });

package/lib/key-drain.js

@@ -1,4 +1,4 @@
-// lib/key-drain.js — Managed key draining and graceful replacement (#463).
+// lib/key-drain.js — Managed key draining and graceful replacement (#463, #502).
 // Allows draining an old key ref (no new dispatches assigned) while letting
 // in-flight active streams complete cleanly before permanent removal.
 
@@ -27,9 +27,11 @@ export function cancelKeyDrain(ref) {
 export function getDrainingStatus(ref, concurrencyTracker) {
   if (!ref || !drainingKeys.has(ref)) return null;
   const entry = drainingKeys.get(ref);
-  const inFlight = concurrencyTracker && typeof concurrencyTracker.getInFlight === 'function'
-    ? concurrencyTracker.getInFlight(ref)
-    : 0;
+  const inFlight = concurrencyTracker && typeof concurrencyTracker.getActive === 'function'
+    ? concurrencyTracker.getActive(ref)
+    : (concurrencyTracker && typeof concurrencyTracker.getInFlight === 'function'
+      ? concurrencyTracker.getInFlight(ref)
+      : 0);
 
   return {
     ref,

package/lib/ops-analytics.js

@@ -0,0 +1,162 @@
+// lib/ops-analytics.js — 24h error breakdown, load distribution, and health index analytics (#505).
+// Pure helpers with zero dependencies.
+
+const DAY_MS = 86400000;
+const MAX_RING_BUFFER = 200;
+
+/**
+ * Classifies an error code or message into canonical categories:
+ * 'rateLimit' | 'server' | 'timeout' | 'quota' | 'auth' | 'other'
+ */
+export function classifyErrorCategory(code, message = '') {
+  const c = String(code ?? '').toUpperCase();
+  const m = String(message ?? '').toLowerCase();
+
+  if (c === '429' || c.includes('RATE_LIMIT') || m.includes('rate limit') || m.includes('too many requests')) {
+    return 'rateLimit';
+  }
+  if (/^5\d\d$/.test(c) || c === 'SERVER' || c === 'BAD_GATEWAY' || c === 'SERVICE_UNAVAILABLE' || m.includes('internal server error')) {
+    return 'server';
+  }
+  if (c.includes('TIMEOUT') || c === 'ETIMEDOUT' || c === 'ESOCKETTIMEDOUT' || m.includes('timeout') || m.includes('timed out')) {
+    return 'timeout';
+  }
+  if (c === 'QUOTA' || c === '402' || c.includes('QUOTA') || m.includes('quota') || m.includes('credit') || m.includes('insufficient_quota')) {
+    return 'quota';
+  }
+  if (c === 'AUTH' || c === '401' || c === '403' || m.includes('unauthorized') || m.includes('invalid_api_key') || m.includes('forbidden')) {
+    return 'auth';
+  }
+  return 'other';
+}
+
+function initPoolAnalytics(pool) {
+  if (!pool.state.analytics24h) {
+    pool.state.analytics24h = {
+      requests: [], // Ring buffer of { at, ref, success, attempts, failovers, cascaded }
+      errorEvents: [], // Ring buffer of { at, category, code, ref }
+    };
+  }
+  return pool.state.analytics24h;
+}
+
+/**
+ * Records a failover error encountered during key rotation.
+ */
+export function recordFailureCategory(pool, code, message = '', ref = '', now = Date.now()) {
+  if (!pool?.state) return;
+  const a = initPoolAnalytics(pool);
+  const category = classifyErrorCategory(code, message);
+  a.errorEvents.push({
+    at: now,
+    category,
+    code: String(code ?? 'UNKNOWN'),
+    ref: ref || pool.state.lastUsed || '',
+  });
+  if (a.errorEvents.length > MAX_RING_BUFFER) {
+    a.errorEvents.shift();
+  }
+}
+
+/**
+ * Records a completed request outcome in the pool's 24h analytics buffer.
+ */
+export function recordRequestOutcome(pool, outcome, now = Date.now()) {
+  if (!pool?.state) return;
+  const a = initPoolAnalytics(pool);
+
+  const entry = {
+    at: now,
+    ref: outcome.ref || pool.state.lastUsed || '',
+    success: outcome.success !== false,
+    attempts: Number(outcome.attempts) || 1,
+    failovers: Number(outcome.failovers) || 0,
+    cascaded: Boolean(outcome.cascaded),
+  };
+
+  a.requests.push(entry);
+  if (a.requests.length > MAX_RING_BUFFER) {
+    a.requests.shift();
+  }
+}
+
+/**
+ * Computes 24h analytics snapshot for the pool.
+ */
+export function compute24hAnalytics(pool, now = Date.now()) {
+  const cutoff = now - DAY_MS;
+  const a = pool?.state?.analytics24h;
+  const requests = a?.requests?.filter(r => r.at >= cutoff) ?? [];
+  const errorEvents = a?.errorEvents?.filter(e => e.at >= cutoff) ?? [];
+
+  const totalRequests = requests.length;
+  let firstAttemptSuccesses = 0;
+  let cascades = 0;
+  const keyCounts = new Map();
+  const errors = {
+    rateLimit: 0,
+    server: 0,
+    timeout: 0,
+    quota: 0,
+    auth: 0,
+    other: 0,
+  };
+
+  for (const r of requests) {
+    if (r.ref) {
+      keyCounts.set(r.ref, (keyCounts.get(r.ref) ?? 0) + 1);
+    }
+    if (r.success && r.attempts <= 1 && r.failovers === 0) {
+      firstAttemptSuccesses++;
+    }
+    if (r.cascaded) {
+      cascades++;
+    }
+  }
+
+  for (const ev of errorEvents) {
+    if (ev.category && errors[ev.category] != null) {
+      errors[ev.category]++;
+    }
+  }
+
+  // Calculate load distribution across pool refs
+  const refs = pool?.refs ?? [...keyCounts.keys()];
+  const loadDistribution = refs.map(ref => {
+    const count = keyCounts.get(ref) ?? 0;
+    const pct = totalRequests > 0 ? Math.round((count / totalRequests) * 100) : 0;
+    return { ref, count, pct };
+  });
+
+  const totalErrors = Object.values(errors).reduce((sum, n) => sum + n, 0);
+
+  // Compute average cooldown recovery time from pool.state.events
+  let cooldownTotalMs = 0;
+  let cooldownCount = 0;
+  const events = pool?.state?.events ?? [];
+  for (const ev of events) {
+    if (ev.at >= cutoff && ev.type === 'fail' && Number.isFinite(ev.cooldownMs) && ev.cooldownMs > 0) {
+      cooldownTotalMs += ev.cooldownMs;
+      cooldownCount++;
+    }
+  }
+  const avgCooldownRecoveryMs = cooldownCount > 0 ? Math.round(cooldownTotalMs / cooldownCount) : 0;
+
+  // Health index: % of requests handled without retries or failover
+  const healthIndexPct = totalRequests > 0
+    ? Math.round((firstAttemptSuccesses / totalRequests) * 100)
+    : 100;
+
+  return {
+    totalRequests,
+    firstAttemptSuccesses,
+    healthIndexPct,
+    loadDistribution,
+    errorBreakdown: {
+      ...errors,
+      total: totalErrors,
+    },
+    cascades: Math.max(cascades, pool?.state?.cascadeCount ?? 0),
+    avgCooldownRecoveryMs,
+  };
+}

package/lib/ops-config-io.js

@@ -1,5 +1,12 @@
 // lib/ops-config-io.js — full configuration export and import (#504).
 import crypto from 'node:crypto';
+import { readFileSync } from 'node:fs';
+
+let PLUGIN_VERSION = '0.8.68';
+try {
+  const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+  if (pkg.version) PLUGIN_VERSION = pkg.version;
+} catch (_) { /* fallback */ }
 import { json, readJson, isTrustedBridgeRequest, NS } from './http-bridge.js';
 import { CONFIG_EXPORT_PATH, CONFIG_IMPORT_PATH, IMPORT_PATH } from './ops-paths.js';
 import { keyTail } from './pool.js';
@@ -172,7 +179,7 @@ export function registerConfigIoRoutes(ctx, deps) {
         const encryptedPayload = encryptConfig(JSON.stringify(exportData), passphrase);
         json(res, 200, {
           ok: true,
-          version: '0.8.67',
+          version: PLUGIN_VERSION,
           exportedAt: new Date().toISOString(),
           masked,
           encrypted: true,
@@ -183,7 +190,7 @@ export function registerConfigIoRoutes(ctx, deps) {
 
       json(res, 200, {
         ok: true,
-        version: '0.8.67',
+        version: PLUGIN_VERSION,
         exportedAt: new Date().toISOString(),
         masked,
         encrypted: false,

package/lib/ops-status.js

@@ -17,6 +17,8 @@ import {
 import { bucketInfo, tpmInfo } from './bucket.js';
 import { isBlockedUntilReset } from './quota-window.js';
 import { sanitizeSnapshot } from './sanitize-snapshot.js';
+import { compute24hAnalytics } from './ops-analytics.js';
+import { getPromptCacheSummary } from './prompt-cache.js';
 import {
   STATUS_PATH,
   HEALTH_PATH,
@@ -177,6 +179,8 @@ ctx.effect(() => ctx.webServer.register({
         routingStrategy: pool.routingStrategy ?? runtime.routingStrategy ?? 'round-robin',
         proactiveRateLimitGuard: pool.proactiveRateLimitGuard ?? runtime.proactiveRateLimitGuard ?? true,
         smoothedRequests: pool.state.smoothedRequests ?? 0,
+        promptCache: getPromptCacheSummary(pool, now),
+        analytics24h: compute24hAnalytics(pool, now),
       });
       } catch (e) {
         (ctx?.logger ? ctx.logger('dsh-key-rotation') : null)?.warn?.(`[dsh-key-rotation] status: pool ${pool.base} failed: ${String(e?.message ?? e)} ${e?.stack ?? ''}`);

package/lib/ops-telemetry.js

@@ -21,6 +21,8 @@ import { simulateRouting } from './simulator.js';
 import { getSelectionTraces, clearSelectionTraces } from './selection-trace.js';
 import { findSecrets } from './keycheck.js';
 import { mutateSettings, sectionOps } from './settings-write.js';
+import { compute24hAnalytics } from './ops-analytics.js';
+import { getPromptCacheSummary } from './prompt-cache.js';
 
 /**
  * @param {object} ctx cordis context
@@ -68,7 +70,12 @@ ctx.effect(() => ctx.webServer.register({
       if (seen.has(pool.base)) continue;
       seen.add(pool.base);
       if (provider && pool.base !== provider && pool.provider !== provider) continue;
-      report.push({ provider: pool.base, rows: usageRows(pool, days, now) });
+      report.push({
+        provider: pool.base,
+        rows: usageRows(pool, days, now),
+        promptCache: getPromptCacheSummary(pool, now),
+        analytics24h: compute24hAnalytics(pool, now),
+      });
     }
     if (csv) {
       res.writeHead(200, { 'content-type': 'text/csv; charset=utf-8', 'content-disposition': 'attachment; filename="dsh-key-rotation-usage.csv"' });

package/lib/pool-builder.js

@@ -248,6 +248,7 @@ export function cleanupRemovedProviders({
   moduleBreaker,
   lowHealthNotifiedAt,
   budgetNotifiedAt,
+  cloneLifecycle,
 }) {
   const live = Array.isArray(pools) ? pools : [...(pools?.values?.() ?? (poolByRef?.values?.() ? [...poolByRef.values()] : []))];
   const liveBases = new Set(live.map((p) => p.base));
@@ -281,4 +282,11 @@ export function cleanupRemovedProviders({
       }
     }
   }
+  if (cloneLifecycle && typeof cloneLifecycle.reconcileClones === 'function') {
+    for (const p of cfg.providers ?? []) {
+      const liveClones = new Set([...expectedClones].filter(c => c.startsWith(`${p.provider}-`)));
+      cloneLifecycle.reconcileClones(p.provider, poolState.get(`${p.provider}:clones`) ?? [], liveClones);
+      poolState.set(`${p.provider}:clones`, liveClones);
+    }
+  }
 }