dsh-subscriptions 0.1.2 → 0.1.3

package/README.md

@@ -68,13 +68,15 @@ and tool settings.
 
 ### Quota while you work
 
-The composer's stats row gains a **subscription usage** pill showing the
+The composer's stats row gains a **provider usage** pill showing the
 used percentage and reset window for the provider of the session's current
 model. It shows at most one provider; switching to a non-subscription model
 keeps the most recent subscription selected in the mounted conversation
-view, or stays hidden if there is none.
+view, or stays hidden if there is none. **Always show** instead rotates
+through the providers that report usage every 10 seconds while the current
+model has no quota source, so the pill never disappears.
 
-![Subscription usage pill in the stats row](docs/images/usage-pill.png)
+![Provider usage pill in the stats row](docs/images/usage-pill.png)
 
 Click the pill to expand every provider and account that reports usage —
 the default account is starred, and the current provider is listed first.
@@ -83,7 +85,17 @@ neither do accounts without a usage window. Antigravity previews only the
 current model's windows; the other model windows stay in a closed
 disclosure.
 
-![Subscription usage pill expanded](docs/images/usage-badge.png)
+Quota bars include a dark elapsed-time cursor whenever the provider's
+timing places the window in time, including at 0% used and for stale or old
+readings. Compare the colored fill (quota used) with the cursor (time
+elapsed); hover for the percentages and reset countdown. Standard coloring
+turns the fill orange when a fresh reading leads elapsed time by 10 points,
+and Relaxed uses 15; 90% used turns it red and takes priority. Windows
+without known timing omit the cursor, and a stale or old reading keeps its
+cursor without a pace warning. Choose Standard, Relaxed, or Remaining colors
+in **Settings → Subscriptions**.
+
+![Usage dialog with elapsed-time cursors](docs/images/usage-badge.png)
 
 ## Install
 
@@ -183,7 +195,7 @@ Every preset shows reported usage of 90% or more in red, before considering pace
 
 A vertical marker shows elapsed time only for an explicit valid start/end interval or a provider-verified fixed duration. A session/weekly label alone does not establish a fixed window; rolling or unknown intervals have no marker. Claude's recognized five-hour/seven-day buckets and Codex's reported quota durations supply fixed-window metadata. Unknown timing falls back to green below 90%, without a marker or yellow warning.
 
-Expired, failed-refresh or more-than-five-minute-old readings retain the last reported green/red color, without pace warnings or markers. Cached numbers remain visible, with an accessible stale label; refresh to confirm them. Invalid percentages show an unavailable state without a fabricated fill. Tooltips explain remaining quota, time progress and reset countdown where available. See the [decision record](.agents/notes/implemented/architecture/2026-10-01-usage-pace-colors.md) for rationale and verification limits.
+The marker depends on the window's timing alone, not on the reading: it stays at 0% used, for an invalid percentage, and when a refresh failed or the reading is more than five minutes old. Such a reading is not set against the current time, so it gets no yellow pace warning and its tooltip omits the ahead/behind comparison. It retains the last reported green/red color with an accessible stale label; refresh to confirm it. Once the reset time has passed the window has no position and the marker disappears. Invalid percentages show an unavailable state without a fabricated fill. Tooltips explain remaining quota, time progress and reset countdown where available. See the [decision record](.agents/notes/implemented/architecture/2026-10-01-usage-pace-colors.md) and the [cursor note](.agents/notes/implemented/architecture/2026-10-06-usage-cursor-timing-only.md) for rationale and verification limits.
 
 ### MiniMax subscription usage
 
@@ -193,11 +205,17 @@ The plugin reuses those credential references; no separate subscription ref is
 required. Quota reads require subscription keys, not `sk-api-*` pay-as-you-go keys. The plugin reads the
 region's `/v1/token_plan/remains` endpoint and displays finite per-model quotas
 with API-provided start/end times. It does not add model routing or OAuth login.
-Unlimited, boosted-above-100% and unsupported quotas are omitted; if none remain,
-the card reports unavailable rather than inventing a percentage. Explicit
-remaining percentages take priority; older responses follow the official CLI's
-remaining-count compatibility convention. No live-account response was used in
-verification.
+Rows are labelled with the model name, and the plugin shows the windows the API
+returns for each model. MiniMax documents a five-hour and a weekly window for
+non-video models and only a weekly one for video. Standard (non-video) models
+on time-based plans report an explicit remaining percentage beside zero counts,
+and that percentage is enough for a row. Unlimited, boosted-above-100% and
+unsupported quotas are omitted (a status-3 row also covers a model the plan
+does not include); if none remain, the card reports unavailable rather than
+inventing a percentage. Explicit remaining percentages take priority; older
+responses follow the official CLI's remaining-count compatibility convention. No
+live-account response was used in verification, so a missing model may still
+come from the account or the plan rather than from this plugin.
 
 ## Development
 

package/lib/client/ExternalUsageCards.d.ts

@@ -1,6 +1,16 @@
 import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client';
-import type { SubscriptionsSectionInjected } from './SubscriptionsSection.js';
+import type { SubscriptionsSectionInjected, UsageWindow } from './SubscriptionsSection.js';
 type Translate = SubscriptionsSectionInjected['t'];
+/**
+ * Row label of one window on an external usage card. A session or weekly
+ * window appends the model it belongs to when the provider names one (MiniMax
+ * reports a window per model), so two models' weekly rows stay distinguishable.
+ * The monthly pool is a scope on an `other` window, not a model.
+ * @param t - section translate.
+ * @param window - the reported window.
+ * @returns the localized label, e.g. "Weekly · general".
+ */
+export declare function externalUsageWindowLabel(t: Translate, window: UsageWindow): string;
 /** Quota cards for API-key providers already available through DSH itself. */
 export declare function ExternalUsageCards({ rpc, t }: {
     rpc: ConnectionHandle['rpc'];

package/lib/client/ExternalUsageCards.js

@@ -14,6 +14,23 @@ const SOURCES = [
 function errorText(error) {
     return error instanceof Error ? error.message : String(error);
 }
+/**
+ * Row label of one window on an external usage card. A session or weekly
+ * window appends the model it belongs to when the provider names one (MiniMax
+ * reports a window per model), so two models' weekly rows stay distinguishable.
+ * The monthly pool is a scope on an `other` window, not a model.
+ * @param t - section translate.
+ * @param window - the reported window.
+ * @returns the localized label, e.g. "Weekly · general".
+ */
+export function externalUsageWindowLabel(t, window) {
+    const named = window.scope !== undefined && window.scope !== '';
+    if (window.kind === 'other') {
+        return window.scope === 'Monthly' ? t('usageMonthly') : named ? window.scope : t('usageWindow');
+    }
+    const base = window.kind === 'session' ? t('usageSession') : t('usageWeekly');
+    return named ? `${base} · ${window.scope}` : base;
+}
 /** Quota cards for API-key providers already available through DSH itself. */
 export function ExternalUsageCards({ rpc, t }) {
     const [status, setStatus] = useState();
@@ -62,9 +79,7 @@ export function ExternalUsageCards({ rpc, t }) {
                                         ? 'var(--dsw-alias-state-success-primary)' : 'var(--dsw-alias-label-dimmed)' } }), _jsx("span", { style: styles.name, children: name })] }), !(status === undefined && statusError !== undefined) && _jsx("p", { style: styles.status, children: status === undefined ? t('checking')
                             : configured ? t('externalUsageConnected') : t('externalUsageNotConfigured') }), statusError !== undefined && _jsx("p", { style: styles.error, children: t('externalUsageUnavailable', { message: statusError }) }), status !== undefined && !configured && _jsx("p", { style: styles.status, children: t('externalUsageConfigure', { ref }) }), configured && _jsxs("div", { style: styles.account, children: [_jsxs("div", { style: styles.accountHeader, children: [_jsx("span", { style: styles.defaultStar, title: t('defaultBadge'), children: "\u2605" }), _jsx("span", { style: styles.accountName, children: t('externalUsageApiKey') })] }), _jsxs("div", { style: styles.usage, children: [_jsxs("div", { style: styles.usageHeader, children: [_jsx("span", { style: styles.usageTitle, children: t('usageTitle') }), snapshot?.plan !== undefined && _jsx("span", { style: styles.usagePlan, children: t('usagePlan', { plan: snapshot.plan }) }), _jsx("button", { type: "button", style: styles.usageRefresh, disabled: loading[id] === true, onClick: () => { void refresh(id); }, children: t('usageRefresh') })] }), loading[id] === true && snapshot === undefined && _jsx("p", { style: styles.status, children: t('usageLoading') }), errors[id] !== undefined && _jsx("p", { style: styles.error, children: t('usageError', { message: errors[id] }) }), snapshot?.windows?.length === 0 && _jsx("p", { style: styles.status, children: t('usageEmpty') }), snapshot?.windows?.map((window, index) => {
                                         const percent = displayUsedPercent(window.usedPercent);
-                                        const label = window.kind === 'session' ? t('usageSession')
-                                            : window.kind === 'weekly' ? t('usageWeekly')
-                                                : window.scope === 'Monthly' ? t('usageMonthly') : window.scope ?? t('usageWindow');
+                                        const label = externalUsageWindowLabel(t, window);
                                         return _jsxs("div", { style: styles.usageRow, children: [_jsxs("div", { style: styles.usageMeta, children: [_jsx("span", { children: label }), _jsxs("span", { children: [percent === undefined ? t('usageMeterInvalid') : `${percent}%`, window.resetsAt === undefined ? ''
                                                                     : ` · ${t('usageResets', { date: new Date(window.resetsAt).toLocaleString() })}`] })] }), _jsx(UsageMeter, { window: window, t: t, observedAt: observedAt[id], stale: errors[id] !== undefined || snapshot?.stale === true })] }, index);
                                     })] })] }), !configured && _jsx("div", { style: styles.actions, children: _jsx("button", { type: "button", style: styles.button, onClick: () => { void refreshStatus(); }, children: t('usageRefresh') }) })] }, id);

package/lib/client/SubscriptionUsageBadge.d.ts

@@ -20,7 +20,11 @@ export interface SubscriptionUsageBadgeInjected {
     } | undefined>;
 }
 /** Props delivered by the slot outlet + inject + the locale seat. */
-export type SubscriptionUsageBadgeProps = PropsRuntime<'conversation.composer.dock'> & Partial<SubscriptionUsageBadgeInjected> & Partial<PropsLocale<'settings.subscriptions'>>;
+export type SubscriptionUsageBadgeProps = PropsRuntime<'conversation.composer.dock'> & Partial<SubscriptionUsageBadgeInjected> & Partial<PropsLocale<'settings.subscriptions'>>
+/** Override the rotation cadence (tests only; the slot never passes it). */
+ & {
+    rotationMs?: number;
+};
 /** One logged-in account's usage windows, as listed in the expanded dialog. */
 export interface AccountUsageDisplay {
     /** Account key (the `usage` endpoint's `account` argument). */
@@ -98,6 +102,19 @@ type ModelSelection = {
 export declare function retainSubscriptionSelection(previous: ModelSelection | undefined, current: ModelSelection | undefined): ModelSelection | undefined;
 /** At most one provider; no known selection or no usage means no badge. */
 export declare function collapsedDisplays(displays: readonly ProviderUsageDisplay[], current: string | undefined): readonly ProviderUsageDisplay[];
+/**
+ * `always` mode: the current model's provider while it reports usage,
+ * otherwise the rotation steps through the providers that do, in display
+ * order, wrapping around. The index is taken modulo the current provider
+ * count, so providers appearing or dropping out stay inside range; the
+ * sequence itself may shift when the roster changes. Unlike `recent`, the
+ * retained subscription does not pin the pill — that retention is exactly
+ * what this mode exists to escape.
+ * @param displays - providers with usage, in display order.
+ * @param current - the provider of the session's current model.
+ * @param step - rotation tick; consecutive ticks advance one provider.
+ */
+export declare function rotatingDisplay(displays: readonly ProviderUsageDisplay[], current: string | undefined, step: number): readonly ProviderUsageDisplay[];
 /** Order for the expanded dialog: the current provider first, the rest in poll order. */
 export declare function expandedDisplays(displays: readonly ProviderUsageDisplay[], current: string | undefined): readonly ProviderUsageDisplay[];
 type Translate = (key: SubscriptionsKey, params?: Record<string, unknown>) => string;
@@ -107,7 +124,7 @@ type Translate = (key: SubscriptionsKey, params?: Record<string, unknown>) => st
  * every provider's accounts and their windows. Returns null when no data is
  * available.
  */
-export declare function SubscriptionUsageBadge({ rpc, currentModel, t }: SubscriptionUsageBadgeProps): import("react").JSX.Element;
+export declare function SubscriptionUsageBadge({ rpc, currentModel, t, rotationMs }: SubscriptionUsageBadgeProps): import("react").JSX.Element;
 /** Preview each account independently; all remaining quotas stay accessible. */
 export declare function AccountWindows({ windows, model, provider, translate, observedAt, stale }: {
     windows: readonly UsageWindow[];

package/lib/client/SubscriptionUsageBadge.js

@@ -42,6 +42,8 @@ const UsageBadgeIcon = usageBadgeIcon(primitives);
 const USAGE_POLL_INTERVAL_MS = 15 * 60_000;
 /** How often the badge re-reads the session's current model (model switches arrive only by asking). */
 const MODEL_POLL_INTERVAL_MS = 3000;
+/** How long the rotation holds one provider in `always` mode (a display cadence, not a data poll). */
+const BADGE_ROTATION_INTERVAL_MS = 10_000;
 /** Distance between the trigger's top edge and the dialog's bottom (host stat dialogs use the same). */
 const PANEL_GAP = 8;
 /** Distance kept between the dialog and each viewport edge. */
@@ -236,6 +238,27 @@ export function collapsedDisplays(displays, current) {
     const match = displays.find(d => d.provider === current);
     return match === undefined ? [] : [match];
 }
+/**
+ * `always` mode: the current model's provider while it reports usage,
+ * otherwise the rotation steps through the providers that do, in display
+ * order, wrapping around. The index is taken modulo the current provider
+ * count, so providers appearing or dropping out stay inside range; the
+ * sequence itself may shift when the roster changes. Unlike `recent`, the
+ * retained subscription does not pin the pill — that retention is exactly
+ * what this mode exists to escape.
+ * @param displays - providers with usage, in display order.
+ * @param current - the provider of the session's current model.
+ * @param step - rotation tick; consecutive ticks advance one provider.
+ */
+export function rotatingDisplay(displays, current, step) {
+    if (displays.length === 0)
+        return [];
+    const match = displays.find(d => d.provider === current);
+    if (match !== undefined)
+        return [match];
+    const index = Number.isFinite(step) ? Math.floor(step) : 0;
+    return [displays[((index % displays.length) + displays.length) % displays.length]];
+}
 /** Order for the expanded dialog: the current provider first, the rest in poll order. */
 export function expandedDisplays(displays, current) {
     const match = displays.find(d => d.provider === current);
@@ -271,7 +294,7 @@ function usageWindowLabel(t, window) {
  * every provider's accounts and their windows. Returns null when no data is
  * available.
  */
-export function SubscriptionUsageBadge({ rpc, currentModel, t }) {
+export function SubscriptionUsageBadge({ rpc, currentModel, t, rotationMs }) {
     const translate = t ?? fallbackTranslate;
     const [displays, setDisplays] = useState([]);
     const [selection, setSelection] = useState(undefined);
@@ -281,6 +304,11 @@ export function SubscriptionUsageBadge({ rpc, currentModel, t }) {
     const badgeSelection = retainSubscriptionSelection(lastSubscription, selection);
     const [open, setOpen] = useState(false);
     const [hover, setHover] = useState(false);
+    // Rotation tick for `always` mode; the interval runs only in that mode.
+    const [rotation, setRotation] = useState(0);
+    // The provider the pill showed when the dialog opened; an open dialog
+    // keeps leading with it while the rotation keeps ticking underneath.
+    const [dialogLead, setDialogLead] = useState(undefined);
     const inflightRef = useRef(false);
     const mountedRef = useRef(true);
     const rootRef = useRef(null);
@@ -443,22 +471,49 @@ export function SubscriptionUsageBadge({ rpc, currentModel, t }) {
         if (displayMode === 'hidden')
             setOpen(false);
     }, [displayMode]);
+    // `always` mode advances the rotation on its own cadence; other modes
+    // never advance, so the pill never changes on its own.
+    useEffect(() => {
+        if (displayMode !== 'always')
+            return;
+        const interval = rotationMs !== undefined && Number.isFinite(rotationMs) && rotationMs > 0
+            ? rotationMs
+            : BADGE_ROTATION_INTERVAL_MS;
+        const timer = setInterval(() => { setRotation(step => step + 1); }, interval);
+        return () => { clearInterval(timer); };
+    }, [displayMode, rotationMs]);
     const seat = _jsx("span", { ref: seatRef, style: styles.seat, "aria-hidden": true });
-    const collapsed = collapsedDisplays(displays, badgeSelection?.provider);
+    // `always` follows the live model, not the retained subscription: the
+    // retention pins the pill in `recent`, which is what this mode escapes.
+    const collapsed = displayMode === 'always'
+        ? rotatingDisplay(displays, current, rotation)
+        : collapsedDisplays(displays, badgeSelection?.provider);
     if (displayMode === 'hidden' || collapsed.length === 0)
         return seat;
-    const label = compactSegment(collapsed[0], badgeSelection?.model, translate);
+    // Model scope only while the pill shows the current model's provider;
+    // a rotated provider has no live model, so it reads at account level.
+    const pillModel = displayMode === 'always'
+        ? (current === collapsed[0]?.provider ? selection?.model : undefined)
+        : badgeSelection?.model;
+    const label = compactSegment(collapsed[0], pillModel, translate);
     // The dialog opens from the badge, so it follows the provider and model the
     // badge shows (a retained subscription when the current model is not one).
-    const expanded = expandedDisplays(displays, badgeSelection?.provider);
+    // In `always` mode the pill moves under the cursor, so an open dialog keeps
+    // the provider that was showing when it opened instead of reordering live.
+    const dialogProvider = open && displayMode === 'always' ? dialogLead : badgeSelection?.provider;
+    const dialogModel = open && displayMode === 'always'
+        ? (dialogLead === current ? selection?.model : undefined)
+        : badgeSelection?.model;
+    const expanded = expandedDisplays(displays, dialogProvider);
     const title = translate('usageBadgeTitle');
     const toggle = () => {
         const next = !open;
+        setDialogLead(collapsed[0]?.provider);
         setOpen(next);
         if (next)
             void refresh();
     };
-    const pill = (_jsxs("span", { ref: rootRef, style: styles.anchor, children: [_jsxs("button", { type: "button", style: { ...styles.pill, ...(hover || open ? styles.pillActive : {}) }, "aria-haspopup": "dialog", "aria-expanded": open, "aria-label": `${title} · ${label}`, title: title, onMouseEnter: () => { setHover(true); }, onMouseLeave: () => { setHover(false); }, onClick: toggle, children: [_jsx(UsageBadgeIcon, {}), _jsx("span", { style: styles.label, children: label })] }), open && createPortal(_jsxs("div", { ref: panelRef, role: "dialog", "aria-label": title, style: { ...styles.panel, ...(pos ?? MEASURE_STYLE) }, children: [_jsx("div", { style: styles.title, children: _jsxs("span", { style: styles.titleLabel, children: [_jsx(UsageBadgeIcon, {}), title] }) }), _jsx("div", { style: styles.titleRule, "aria-hidden": true }), expanded.map((d, index) => (_jsxs("section", { style: index === 0 ? undefined : styles.section, children: [_jsxs("div", { style: styles.providerRow, children: [_jsxs("span", { style: styles.providerName, children: [d.name, d.provider === current && _jsx("span", { style: styles.currentTag, children: translate('usageBadgeCurrent') })] }), d.accounts.length === 1 && _jsx(AccountMeta, { account: d.accounts[0], translate: translate })] }), d.accounts.map((account, accountIndex) => (_jsxs("div", { style: accountIndex === 0 ? undefined : styles.accountBlock, children: [d.accounts.length > 1 && (_jsx("div", { style: styles.accountRow, children: _jsx(AccountMeta, { account: account, translate: translate }) })), _jsx(AccountWindows, { windows: account.windows, observedAt: account.observedAt, stale: account.stale, model: d.provider === badgeSelection?.provider ? badgeSelection.model : undefined, provider: d.provider, translate: translate }, `${d.provider}:${badgeSelection?.model ?? ''}`)] }, account.key)))] }, d.provider)))] }), document.body)] }));
+    const pill = (_jsxs("span", { ref: rootRef, style: styles.anchor, children: [_jsxs("button", { type: "button", style: { ...styles.pill, ...(hover || open ? styles.pillActive : {}) }, "aria-haspopup": "dialog", "aria-expanded": open, "aria-label": `${title} · ${label}`, title: title, onMouseEnter: () => { setHover(true); }, onMouseLeave: () => { setHover(false); }, onClick: toggle, children: [_jsx(UsageBadgeIcon, {}), _jsx("span", { style: styles.label, children: label })] }), open && createPortal(_jsxs("div", { ref: panelRef, role: "dialog", "aria-label": title, style: { ...styles.panel, ...(pos ?? MEASURE_STYLE) }, children: [_jsx("div", { style: styles.title, children: _jsxs("span", { style: styles.titleLabel, children: [_jsx(UsageBadgeIcon, {}), title] }) }), _jsx("div", { style: styles.titleRule, "aria-hidden": true }), expanded.map((d, index) => (_jsxs("section", { style: index === 0 ? undefined : styles.section, children: [_jsxs("div", { style: styles.providerRow, children: [_jsxs("span", { style: styles.providerName, children: [d.name, d.provider === current && _jsx("span", { style: styles.currentTag, children: translate('usageBadgeCurrent') })] }), d.accounts.length === 1 && _jsx(AccountMeta, { account: d.accounts[0], translate: translate })] }), d.accounts.map((account, accountIndex) => (_jsxs("div", { style: accountIndex === 0 ? undefined : styles.accountBlock, children: [d.accounts.length > 1 && (_jsx("div", { style: styles.accountRow, children: _jsx(AccountMeta, { account: account, translate: translate }) })), _jsx(AccountWindows, { windows: account.windows, observedAt: account.observedAt, stale: account.stale, model: d.provider === dialogProvider ? dialogModel : undefined, provider: d.provider, translate: translate }, `${d.provider}:${dialogModel ?? ''}`)] }, account.key)))] }, d.provider)))] }), document.body)] }));
     return (_jsxs(_Fragment, { children: [seat, statsRow !== null && statsRow.isConnected ? createPortal(pill, statsRow) : pill] }));
 }
 /**

package/lib/client/UsageBadgeDisplaySetting.js

@@ -9,7 +9,7 @@ export function UsageBadgeDisplaySetting({ t }) {
     const [failed, setFailed] = useState(false);
     return (_jsxs("div", { style: styles.card, children: [_jsxs("label", { style: styles.field, children: [_jsx("span", { children: t('usageBadgeDisplay') }), _jsxs("select", { style: styles.select, "aria-label": t('usageBadgeDisplay'), value: mode, onChange: event => {
                             const value = event.currentTarget.value;
-                            if (value !== 'recent' && value !== 'hidden')
+                            if (value !== 'recent' && value !== 'always' && value !== 'hidden')
                                 return;
                             try {
                                 setUsageBadgeMode(value);
@@ -20,7 +20,7 @@ export function UsageBadgeDisplaySetting({ t }) {
                                     throw error;
                                 setFailed(true);
                             }
-                        }, children: [_jsx("option", { value: "recent", children: t('usageBadgeDisplayRecent') }), _jsx("option", { value: "hidden", children: t('usageBadgeDisplayHidden') })] })] }), _jsx("p", { style: styles.hint, children: t('usageBadgeDisplayHint') }), _jsxs("label", { style: styles.field, children: [_jsx("span", { children: t('usageColorLabel') }), _jsxs("select", { style: styles.select, "aria-label": t('usageColorLabel'), value: preset, onChange: event => {
+                        }, children: [_jsx("option", { value: "recent", children: t('usageBadgeDisplayRecent') }), _jsx("option", { value: "always", children: t('usageBadgeDisplayAlways') }), _jsx("option", { value: "hidden", children: t('usageBadgeDisplayHidden') })] })] }), _jsx("p", { style: styles.hint, children: t('usageBadgeDisplayHint') }), _jsxs("label", { style: styles.field, children: [_jsx("span", { children: t('usageColorLabel') }), _jsxs("select", { style: styles.select, "aria-label": t('usageColorLabel'), value: preset, onChange: event => {
                             const value = event.currentTarget.value;
                             if (!isUsageColorPreset(value))
                                 return;

package/lib/client/UsageMeter.js

@@ -20,17 +20,22 @@ export function UsageMeter({ window: quota, t, style, observedAt, stale }) {
     const valid = validUsage(quota.usedPercent);
     const used = valid ? quota.usedPercent : 0;
     const fresh = isUsageFresh(quota, { observedAt, stale }, current);
-    const elapsed = fresh ? elapsedPercent(quota, current) : undefined;
-    const state = usageColorState(quota.usedPercent, elapsed, preset, fresh);
-    const lead = elapsed === undefined ? 0 : Math.round(used - elapsed);
+    // The cursor is where the window stands in time. It needs only the window's
+    // own timing, so it stays for an unused, stale, aged or unobserved reading.
+    const elapsed = elapsedPercent(quota, current);
+    // Comparing usage with elapsed time is meaningful only while the percentage
+    // is current; an old one is not set against today's clock.
+    const pace = fresh ? elapsed : undefined;
+    const state = usageColorState(quota.usedPercent, pace, preset, fresh);
+    const lead = pace === undefined ? 0 : Math.round(used - pace);
     const label = [
         valid ? t('usageMeterUsed', { used: Math.round(used), remaining: Math.round(100 - used) }) : t('usageMeterInvalid'),
         // An invalid reading already states unavailability; the stale line would repeat it.
         !valid ? '' : !fresh ? t('usageMeterStale') : state === 'red' ? t('usageMeterNearLimit')
-            : elapsed === undefined && preset !== 'remaining' ? t('usageMeterUnknownTime')
+            : pace === undefined && preset !== 'remaining' ? t('usageMeterUnknownTime')
                 : state === 'yellow' ? t('usageMeterAhead') : t('usageMeterNoWarning'),
         elapsed === undefined ? '' : t('usageMeterPace', { elapsed: Math.round(elapsed) }),
-        elapsed === undefined ? '' : lead > 0 ? t('usageMeterPaceAhead', { points: lead })
+        pace === undefined ? '' : lead > 0 ? t('usageMeterPaceAhead', { points: lead })
             : lead < 0 ? t('usageMeterPaceBehind', { points: -lead }) : t('usageMeterPaceEven'),
         quota.resetsAt !== undefined && quota.resetsAt > current ? t('usageMeterReset', {
             duration: resetCountdownParts(quota.resetsAt - current)
@@ -43,7 +48,7 @@ export function UsageMeter({ window: quota, t, style, observedAt, stale }) {
             background: 'var(--dsw-alias-bg-layer-1)', border: '1px solid var(--dsw-alias-border-l2)',
             ...style, position: 'relative',
         }, children: [_jsx("div", { style: { height: '100%', borderRadius: 'inherit', width: `${used}%`,
-                    background: usageBarColor(quota.usedPercent, elapsed, preset, fresh) } }), elapsed !== undefined && _jsx("span", { "aria-hidden": "true", "data-usage-time-marker": true, style: {
+                    background: usageBarColor(quota.usedPercent, pace, preset, fresh) } }), elapsed !== undefined && _jsx("span", { "aria-hidden": "true", "data-usage-time-marker": true, style: {
                     position: 'absolute', left: `clamp(0px, calc(${elapsed}% - 1px), calc(100% - 2px))`,
                     top: 0, bottom: 0, width: 2, background: 'var(--dsw-alias-label-primary)',
                     boxShadow: '0 0 0 1px var(--dsw-alias-bg-layer-1)',

package/lib/client/locales.d.ts

@@ -155,6 +155,7 @@ export declare const en: {
     usageBadgeTitle: string;
     usageBadgeDisplay: string;
     usageBadgeDisplayRecent: string;
+    usageBadgeDisplayAlways: string;
     usageBadgeDisplayHidden: string;
     usageBadgeDisplayHint: string;
     usageBadgeDisplaySaveFailed: string;
@@ -326,6 +327,7 @@ export declare const zh: {
     usageBadgeTitle: string;
     usageBadgeDisplay: string;
     usageBadgeDisplayRecent: string;
+    usageBadgeDisplayAlways: string;
     usageBadgeDisplayHidden: string;
     usageBadgeDisplayHint: string;
     usageBadgeDisplaySaveFailed: string;

package/lib/client/locales.js

@@ -155,8 +155,9 @@ export const en = {
     usageBadgeTitle: 'Provider usage',
     usageBadgeDisplay: 'Status-bar quota display',
     usageBadgeDisplayRecent: 'Current / most recent provider with usage',
+    usageBadgeDisplayAlways: 'Always show one provider, rotating through the rest',
     usageBadgeDisplayHidden: 'Hidden',
-    usageBadgeDisplayHint: 'Saved automatically in this browser. One provider is shown at a time. Models without a quota source keep the most recent provider selected in this view, or show nothing. Hiding does not affect usage details here.',
+    usageBadgeDisplayHint: 'Saved automatically in this browser. One provider is shown at a time. Models without a quota source keep the most recent provider selected in this view, or show nothing. Always show instead rotates through the providers with usage every 10 seconds while the current model has no quota source. Hiding does not affect usage details here.',
     usageBadgeDisplaySaveFailed: 'Could not save the display preference. Check browser storage permissions.',
     usageBadgeCurrent: 'current',
     usageBadgeModelCount: '{count} model quotas',
@@ -326,8 +327,9 @@ export const zh = {
     usageBadgeTitle: '服务商用量',
     usageBadgeDisplay: '状态栏额度显示',
     usageBadgeDisplayRecent: '仅显示当前／最近使用的用量服务商',
+    usageBadgeDisplayAlways: '始终显示一家，其余服务商轮播',
     usageBadgeDisplayHidden: '不显示',
-    usageBadgeDisplayHint: '自动保存到当前浏览器。状态栏一次显示一家服务商；没有额度来源的模型沿用本视图最近选择的服务商，没有记录则隐藏。关闭不影响本页的额度详情。',
+    usageBadgeDisplayHint: '自动保存到当前浏览器。状态栏一次显示一家服务商；没有额度来源的模型沿用本视图最近选择的服务商，没有记录则隐藏。选择“始终显示”时，当前模型没有额度来源，就每 10 秒轮播一家有额度的服务商。关闭不影响本页的额度详情。',
     usageBadgeDisplaySaveFailed: '显示设置保存失败，请检查浏览器存储权限。',
     usageBadgeCurrent: '当前',
     usageBadgeModelCount: '{count} 个模型配额',

package/lib/client/usage-badge-preferences.d.ts

@@ -1,5 +1,10 @@
-/** Display-only preference: no credentials or account history are stored. */
-export type UsageBadgeMode = 'recent' | 'hidden';
+/**
+ * Display-only preference: no credentials or account history are stored.
+ * `recent` pins the current/most-recent provider; `always` keeps a provider
+ * visible at all times, rotating through the others when the current model
+ * has no quota source; `hidden` shows nothing.
+ */
+export type UsageBadgeMode = 'recent' | 'always' | 'hidden';
 export declare const USAGE_BADGE_REFRESH_EVENT = "dsh:subscriptions:usage-refresh";
 /** Read the browser preference; blocked storage retains the default display. */
 export declare function readUsageBadgeMode(): UsageBadgeMode;

package/lib/client/usage-badge-preferences.js

@@ -7,7 +7,8 @@ export function readUsageBadgeMode() {
     if (typeof window === 'undefined')
         return 'recent';
     try {
-        return window.localStorage.getItem(MODE_KEY) === 'hidden' ? 'hidden' : 'recent';
+        const value = window.localStorage.getItem(MODE_KEY);
+        return value === 'hidden' || value === 'always' ? value : 'recent';
     }
     catch (error) {
         if (!(error instanceof DOMException) || error.name !== 'SecurityError')
@@ -17,7 +18,7 @@ export function readUsageBadgeMode() {
 }
 /** Save first, then notify; the settings control reports a rejected write. */
 export function setUsageBadgeMode(mode) {
-    if (mode !== 'recent' && mode !== 'hidden')
+    if (mode !== 'recent' && mode !== 'always' && mode !== 'hidden')
         throw new TypeError('Invalid subscription usage display mode');
     window.localStorage.setItem(MODE_KEY, mode);
     window.dispatchEvent(new Event(MODE_EVENT));

package/lib/client/usage-pace.d.ts

@@ -22,8 +22,21 @@ export interface CountdownPart {
  * window never announces zero remaining time. Always at least one minute.
  */
 export declare function resetCountdownParts(ms: number): CountdownPart[];
+/**
+ * Whether the reported percentage still describes the window now. Only a fresh
+ * reading may be compared with the current time (pace warnings); an old one
+ * keeps its absolute color. This does not decide whether the time cursor is
+ * drawn: where the window stands in time never depends on the reading.
+ */
 export declare function isUsageFresh(window: UsageWindow, observation: UsageObservation, now?: number): boolean;
-/** Only explicit intervals or provider-verified fixed durations support linear pace. */
+/**
+ * How far through its window the clock is, from the window's own timing alone.
+ * It ignores the percentage and how recently it was read, so an unused,
+ * stale, aged or unobserved reading keeps its cursor whenever the timing
+ * places it. Returns undefined when the timing cannot: only an explicit
+ * interval or a provider-verified fixed duration supports linear pace, and no
+ * start is invented from a window's kind or label.
+ */
 export declare function elapsedPercent(window: UsageWindow, now?: number): number | undefined;
 export declare function usageColorState(used: number, elapsed: number | undefined, preset: UsageColorPreset, fresh: boolean): UsageColorState;
 export declare function usageBarColor(used: number, elapsed?: number, preset?: UsageColorPreset, fresh?: boolean): string;

package/lib/client/usage-pace.js

@@ -23,13 +23,26 @@ export function resetCountdownParts(ms) {
     ];
     return parts.filter(part => part.count > 0).slice(0, 2);
 }
+/**
+ * Whether the reported percentage still describes the window now. Only a fresh
+ * reading may be compared with the current time (pace warnings); an old one
+ * keeps its absolute color. This does not decide whether the time cursor is
+ * drawn: where the window stands in time never depends on the reading.
+ */
 export function isUsageFresh(window, observation, now = Date.now()) {
     return validUsage(window.usedPercent) && observation.stale !== true
         && observation.observedAt !== undefined && Number.isFinite(observation.observedAt)
         && observation.observedAt <= now && now - observation.observedAt <= USAGE_FRESHNESS_MS
         && (window.resetsAt === undefined || Number.isFinite(window.resetsAt) && window.resetsAt > now);
 }
-/** Only explicit intervals or provider-verified fixed durations support linear pace. */
+/**
+ * How far through its window the clock is, from the window's own timing alone.
+ * It ignores the percentage and how recently it was read, so an unused,
+ * stale, aged or unobserved reading keeps its cursor whenever the timing
+ * places it. Returns undefined when the timing cannot: only an explicit
+ * interval or a provider-verified fixed duration supports linear pace, and no
+ * start is invented from a window's kind or label.
+ */
 export function elapsedPercent(window, now = Date.now()) {
     const end = window.resetsAt;
     if (end === undefined || !Number.isFinite(end) || end <= now)