@linxin666/dsh-usage 0.3.22 → 0.3.24

package/lib/types/client/sidebar-entry-core.d.ts

@@ -0,0 +1,87 @@
+/**
+ * One trailing action button seated at the entry row's right edge (e.g. a
+ * refresh command or a collapse chevron). Rows with actions switch from the
+ * classic single-button structure to a container with a main button plus the
+ * action buttons (nested interactive elements are invalid HTML); rows without
+ * actions keep the classic structure untouched.
+ */
+export interface SidebarEntryAction {
+    /** Stable id stamped as data-dsh-entry-action="<id>" (CSS hooks and tests). */
+    id: string;
+    /** Inline icon markup while the row is active (always, when inactiveIcon is unset). */
+    icon: string;
+    /**
+     * Optional icon while the row is inactive. Setting it makes the action a
+     * state mirror (a collapse chevron): the core swaps the icon and stamps
+     * aria-expanded on every active-state change. Requires the active bridge.
+     */
+    inactiveIcon?: string;
+    /** Localized accessible label (aria-label + title); receives the active state. */
+    label(active: boolean): string;
+    /**
+     * Click handler; receives the button so the caller can drive transient
+     * affordances (a refresh cooldown) without a re-render.
+     */
+    onClick(button: HTMLButtonElement): void;
+}
+/** Per-package configuration for one sidebar entry row. */
+export interface SidebarEntryOptions {
+    /** Full attribute name identifying the injected row (idempotency key), e.g. 'data-dsh-ssh-entry'. */
+    rowAttribute: string;
+    /** CSS selector matching the injected row, e.g. '[data-dsh-ssh-entry]'. */
+    rowSelector: string;
+    /**
+     * L2 semantic-attribute plugin id (issue #506, enum table:
+     * skins/skin-center/contracts/semantic-attrs-v1.md). When set, the row also
+     * outputs data-dsh-plugin="<id>" and data-dsh-part="sidebar-entry"; unset
+     * leaves the row without semantic attributes.
+     */
+    plugin?: string;
+    /** Inline icon markup (matches the shell's 16px nav-icon look). */
+    icon: string;
+    /** CSS module class names for the row and its two spans (entry / entryIcon / entryLabel). */
+    css: Record<string, string>;
+    /** Localized row label (aria-label + visible text). */
+    label(): string;
+    /** Optional localized tooltip (title attribute). */
+    tooltip?(): string;
+    /**
+     * Optional locale-change subscription: re-applies label / aria-label /
+     * tooltip whenever the active locale changes. Plain-DOM rows would
+     * otherwise keep the label captured at mount; pass the SDK locale runtime
+     * subscription (ctx.locale.subscribe) so the row follows the language
+     * switch without a reload.
+     */
+    refresh?: {
+        subscribe(listener: () => void): () => void;
+    };
+    /** Click action (open/toggle the owning panel). */
+    onToggle(): void;
+    /**
+     * Optional trailing action buttons at the row's right edge. Requires the
+     * package CSS to seat entryMain / entryAction; empty keeps the classic
+     * single-button row.
+     */
+    actions?: readonly SidebarEntryAction[];
+    /** Family-block position: 'before' inserts ahead of sibling plugin rows, 'after' behind them. */
+    position: 'before' | 'after';
+    /**
+     * Selectors of the sibling plugin entry rows this package orders against
+     * (its own row included — the placement guard excludes a row that is
+     * already inside the root). Each package passes the same list it used
+     * before the consolidation so the rendered order stays stable.
+     */
+    familySelectors: readonly string[];
+    /** Optional active-state bridge; highlights the row while the panel is open. */
+    active?: {
+        subscribe(listener: () => void): () => void;
+        isOpen(): boolean;
+    };
+}
+/**
+ * Mount the sidebar entry, waiting for the shell to render and self-healing
+ * on later React re-renders.
+ * @param options - the row's attribute/icon/copy/action/ordering configuration.
+ * @returns disposer removing the entry and its observers.
+ */
+export declare function mountSidebarEntry(options: SidebarEntryOptions): () => void;

package/lib/types/client/sidebar-entry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Sidebar entry injection for the usage panel (issue #1592) — wiring over the
+ * shared core. Unlike the panel-takeover family (task board / SSH / skill
+ * center) this row does not participate in the family block, so it is placed
+ * directly under the New Session row and ordered after those entries. The row
+ * seats the panel's controls as trailing actions: a refresh command and a
+ * collapse chevron mirroring the open state, so the panel below renders only
+ * its content.
+ * @module @linxin666/dsh-usage/client/sidebar-entry
+ */
+/** Stable data attribute identifying the injected entry row. */
+export declare const ENTRY_SELECTOR = "[data-dsh-usage-entry]";
+/** Locale-change subscription the shared core asks for (ctx.locale.subscribe shape). */
+export interface LocaleRefreshSource {
+    subscribe(listener: () => void): () => void;
+}
+/** Panel-facing callbacks and state the entry row's controls drive. */
+export interface UsageSidebarEntryHandlers {
+    /** Toggles the panel (the row's main area and the collapse chevron). */
+    onToggle(): void;
+    /** Forces one host probe cycle (the refresh action). */
+    onRefresh(): void;
+    /** Reads the panel's expanded state (row highlight and chevron direction). */
+    isOpen(): boolean;
+    /** Subscribes to expanded-state changes (the chevron mirrors them live). */
+    subscribeOpen(listener: () => void): () => void;
+}
+/**
+ * Mount the usage sidebar entry.
+ * @param handlers - the panel's toggle/refresh callbacks and open-state face.
+ * @param locale - locale-change source; when given, re-applies the label on a
+ *   language switch (the plain-DOM row otherwise keeps the mount-time copy).
+ * @returns disposer removing the entry and its observers.
+ */
+export declare function mountSidebarEntry(handlers: UsageSidebarEntryHandlers, locale?: LocaleRefreshSource): () => void;

package/lib/types/client/sidebar-panel-mount.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Sidebar usage panel mounting (issue #1592).
+ *
+ * The panel is a plain DOM row inserted into the sidebar right below the
+ * usage entry row, carrying its own React root. Placement self-heals with the
+ * same page-wide body-mutation hub the entry row uses; the entry row stays the
+ * anchor, so the sidebar order never depends on this module's timing.
+ *
+ * The mount owns the panel's single open state: initialized from localStorage,
+ * flipped by the entry row's toggle controls, and mirrored to the React body
+ * through the subscribe/isOpen face (the same face the entry row's chevron
+ * and highlight read).
+ * @module @linxin666/dsh-usage/client/sidebar-panel-mount
+ */
+import type { UsageStoreInstance } from './usage-store.ts';
+/** localStorage key holding the collapsed flag ('1' = collapsed). */
+export declare const COLLAPSED_STORAGE_KEY = "dsh-usage.sidebar.collapsed";
+/** Panel inputs the mount forwards into the React tree. */
+export interface UsagePanelMountProps {
+    store: UsageStoreInstance;
+    /** Fetch one overview now. */
+    poll: () => void;
+}
+/** Mounted panel controller: the entry row drives the toggle and mirrors the state. */
+export interface UsagePanelMount {
+    /** Whether the panel body is currently expanded. */
+    isOpen(): boolean;
+    /** Subscribe to open/collapse changes (the entry row's chevron and highlight). */
+    subscribe(listener: () => void): () => void;
+    /** Flip the open state, persist it, and notify subscribers. */
+    toggle(): void;
+    /** Unmount the panel and remove its container. */
+    dispose(): void;
+}
+/**
+ * Mount the sidebar usage panel below its entry row.
+ * @param props - the store and poll callback of the apply body.
+ * @returns the panel controller.
+ */
+export declare function mountUsagePanel(props: UsagePanelMountProps): UsagePanelMount;

package/lib/types/client/voucher.d.ts

@@ -21,8 +21,8 @@ export interface VoucherData {
     from: string;
     to: string;
 }
-/** Anti-inflation exchange rate: 1000 tokens mint one whale yuan. */
-export declare const TOKENS_PER_WHALE_YUAN = 1000;
+/** Anti-inflation exchange rate: 1,000,000 tokens mint one whale yuan. */
+export declare const TOKENS_PER_WHALE_YUAN = 1000000;
 /** The note's face value in whale yuan; the smallest denomination is 1. */
 export declare function faceValue(tokens: number): number;
 /** Local calendar day (`YYYY-MM-DD`) for an epoch ms timestamp. */

package/lib/types/core/provider-routes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Alias folding for the enumerated provider routes. Kept in core because the
+ * rule is pure — the host enumerates routes and this decides which of two
+ * routes serving one adapter family survives.
+ * @module @linxin666/dsh-usage/core/provider-routes
+ */
+/** The facts alias folding needs about one enumerated provider route. */
+export interface FoldableRoute {
+    /** Provider route key (`deepseek`, `deepseek-official`, custom routes, ...). */
+    id: string;
+    /** Whether the LLM runtime serves requests on this route; a catalog-only entry is dormant. */
+    live: boolean;
+}
+/**
+ * Drop dormant catalog aliases that shadow a live route of the same adapter
+ * family. The pi-ai catalog ships route keys the runtime serves nothing on
+ * until a profile declares them: for DeepSeek the catalog entry `deepseek`
+ * sits beside the llm-deepseek runtime route `deepseek-official`, and both
+ * resolve the same credential (the family's `apiKeyEnv` fallback), so probing
+ * and rendering both turns one account into two identical balance rows.
+ *
+ * A family keeps every live route it has — two configured profiles are two
+ * real accounts, not aliases. A route with no adapter, or one whose family
+ * has no live route at all, is returned untouched.
+ */
+export declare function foldAliasRoutes<T extends FoldableRoute>(routes: readonly T[]): T[];

package/lib/types/core/types.d.ts

@@ -118,12 +118,25 @@ export interface ProviderSnapshotView {
 export interface UsageOverviewView {
     updatedAt: number;
     providers: ProviderSnapshotView[];
-    /** The provider the pet bubble and the header highlight; `source` says how it was picked. */
+    /** The provider the collapsed sidebar strip and the header highlight; `source` says how it was picked. */
     current: {
         provider?: string;
         model?: string;
         /** `live` — last request seen this boot; `default` — the agent default model. */
         source: 'live' | 'default';
+        /**
+         * Resolved display name (snapshot first, route-derived otherwise), so the
+         * strip needs no name-resolution of its own. Optional so an older host
+         * document still renders.
+         */
+        displayName?: string;
+        /**
+         * Today's ledger totals for the provider's adapter family (the route
+         * itself when adapter-less), carrying tokens, calls, and the priced cost.
+         * Absent on a day without usage; optional for the same older-host
+         * tolerance as displayName.
+         */
+        today?: UsageTokenTotals;
     };
     usage: {
         today: {

package/lib/types/host/access.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Usage trust fence (issue #1592): loopback (the desktop) always passes, and a
+ * live paired-device cookie is an additional allow path when remote-web-ui is
+ * loaded — the same family fence the skill center uses. Without that service
+ * the fence stays loopback-only, so an unpaired LAN browser keeps its 403.
+ * The decision logic lives in the generated pair-access.ts copy (shared by
+ * git-graph / pet / skill-explorer).
+ */
+import type { IncomingMessage } from 'node:http';
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Whether this request may read the usage overview or trigger a refresh.
+ * @param ctx - host context; may expose remoteWebUiPairing.
+ * @param request - the incoming HTTP request.
+ * @returns true for loopback, or a live paired-device cookie.
+ */
+export declare function isUsageAllowed(ctx: Context, request: IncomingMessage): boolean;

package/lib/types/host/pair-access.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pairing trust fence shared by plugins that expose host routes: loopback
+ * (the desktop) always passes; a live paired-device cookie is an additional
+ * allow path when remote-web-ui is loaded. The consuming plugin never
+ * depends on that plugin — without the service the fence stays
+ * loopback-only.
+ *
+ * Per-package wrappers (access.ts) call this with their own name so each
+ * plugin keeps a self-describing export; the security decision lives only
+ * here.
+ */
+import type { IncomingMessage } from 'node:http';
+/** Structural pairing lookup (no package dependency on remote-web-ui). */
+interface PairingAccess {
+    isPairedDevice(request: IncomingMessage): boolean;
+}
+/**
+ * Structural host-context shape: shared sources carry no @deepseek-ai
+ * dependency (the shared package must typecheck standalone), so the fence
+ * reads only the two members it needs; cordis Context satisfies this.
+ * ctx.get is optional on the test harness; production Context always has it.
+ */
+interface LookupCtx {
+    get?(name: string, strict?: boolean): unknown;
+    remoteWebUiPairing?: PairingAccess;
+}
+/**
+ * Whether this request may enter the plugin's host routes.
+ * @param ctx - host context; may expose remoteWebUiPairing.
+ * @param request - the incoming HTTP request.
+ * @returns true for loopback, or a live paired-device cookie.
+ */
+export declare function isPairedOrLoopbackAllowed(ctx: LookupCtx, request: IncomingMessage): boolean;
+export {};

package/lib/types/host/routes.d.ts

@@ -1,14 +1,23 @@
+import type { Context } from '@deepseek-ai/cordis';
 import type { WebRoute } from '@deepseek-ai/dsh-host-webserver';
 import type { UsageService } from './usage-service.ts';
 export declare const USAGE_API_PREFIX = "/api/dsh-usage";
 /**
- * Loopback-fenced overview route: provider balances, plan quotas, and token
- * usage totals. Personal account data, so the loopback fence mirrors
- * dsh-perf's stats surface; the browser runs on the same machine.
+ * Overview route: provider balances, plan quotas, and token usage totals.
+ * Personal account data behind the family trust fence — loopback always
+ * passes, and a live paired-device cookie passes too when remote-web-ui is
+ * loaded (issue #1592: the sidebar usage panel reads this from a paired LAN
+ * browser); every unpaired LAN request keeps its 403.
+ * @param ctx - host context; may expose remoteWebUiPairing.
+ * @param service - the usage service.
+ * @returns the route.
  */
-export declare function makeUsageOverviewRoute(service: UsageService): WebRoute;
+export declare function makeUsageOverviewRoute(ctx: Context, service: UsageService): WebRoute;
 /**
- * Loopback-fenced manual refresh: forces one probe cycle now and answers
- * with the fresh overview.
+ * Manual refresh: forces one probe cycle now and answers with the fresh
+ * overview. Same trust fence as the overview route.
+ * @param ctx - host context; may expose remoteWebUiPairing.
+ * @param service - the usage service.
+ * @returns the route.
  */
-export declare function makeUsageRefreshRoute(service: UsageService): WebRoute;
+export declare function makeUsageRefreshRoute(ctx: Context, service: UsageService): WebRoute;

package/lib/types/host/usage-service.d.ts

@@ -1,15 +1,13 @@
 /**
  * The dsh-usage host service: folds live session usage into the persistent
  * ledger, probes each configured provider's balance/coding-plan endpoint on
- * a poll cycle, and announces the current provider's status to the pet
- * bubble. Secrets stay in the host process; the browser only ever sees the
- * overview document.
+ * a poll cycle, and serves the current provider's strip-ready view inside
+ * the overview document. Secrets stay in the host process; the browser only
+ * ever sees the overview document.
  * @module @linxin666/dsh-usage/host/usage-service
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { ProviderSnapshotView, UsageOverviewView, UsageTokenTotals } from '../core/types.ts';
-/** Source tag the plugin stamps onto pet announcements. */
-export declare const USAGE_ANNOUNCE_SOURCE = "dsh-usage";
+import type { UsageOverviewView } from '../core/types.ts';
 /**
  * Persisted accrual state for the official DeepSeek family's real spend:
  * consecutive observations of the official CNY balance, decreases counted
@@ -25,54 +23,11 @@ export interface SpendWatch {
     /** The balance the previous observation ended on, when one exists. */
     lastBalanceCny?: number;
 }
-/** Poll-loop and announce options; re-applied live on settings change. */
+/** Poll-loop options; re-applied live on settings change. */
 export interface UsageServiceOptions {
     pollIntervalSec: number;
-    bubbleMode: 'always' | 'change' | 'off';
     retainDays: number;
 }
-/** Format a balance for display: symbol prefix when known, code suffix otherwise. */
-export declare function formatMoney(currency: string, totalBalance: string): string;
-/** Map a used percent to the announcement tone. */
-export declare function planTone(percent: number): 'ok' | 'warn' | 'low';
-/** Announcement context the service computes per poll: today's family spend and the DeepSeek period. */
-export interface AnnounceContext {
-    /** Today's ledger spend for the announced provider's family (CNY; 0 = unpriced). */
-    todayCost?: number;
-    /** Whether DeepSeek peak pricing is in effect right now. */
-    peak?: boolean;
-}
-/**
- * Build the raw pet announce payload for one provider snapshot, or
- * undefined when nothing worth announcing exists. Pure: every payload this
- * returns satisfies the pet's `parseAnnouncement` contract — plan
- * announcements require a numeric percent, so percent-less windows never
- * announce (the pet validator would silently drop them). A priced family
- * (DeepSeek) with spend today announces a cost bubble first; balance-only
- * families announce the balance; plan families announce their tightest
- * percent window.
- */
-export declare function buildAnnouncement(snapshot: Pick<ProviderSnapshotView, 'displayName' | 'balance' | 'plan'>, context?: AnnounceContext): Record<string, unknown> | undefined;
-/**
- * Compact token-count display for the usage fallback bubble: `9805`,
- * `8.7万`, `1.2亿`. The host-authored bubble copy is zh (like every other
- * line this service speaks), so the magnitudes follow the zh convention.
- */
-export declare function formatTokens(count: number): string;
-/**
- * The usage fallback for the session's provider: today's token consumption
- * and call count, the one fact the ledger owns for every provider. Providers
- * without a readable balance/plan endpoint (relay stations, local runtimes,
- * token-plan vendors — and probeable providers whose probes are failing)
- * would otherwise leave the pet bubble permanently silent even while their
- * sessions run. Undefined when the provider has no usage today: a bubble
- * about nothing is noise, not information. Pure; the payload satisfies the
- * pet's `parseAnnouncement` contract.
- */
-export declare function buildLedgerAnnouncement(input: {
-    displayName: string;
-    totals: UsageTokenTotals;
-}): Record<string, unknown> | undefined;
 export declare class UsageService {
     private readonly ctx;
     private options;
@@ -85,7 +40,7 @@ export declare class UsageService {
     private spendWatch;
     /** Per-live-session route attribution (WeakMap: disposed sessions age out). */
     private readonly sessionRoutes;
-    /** The most recent route seen this boot; the pet bubble follows it. */
+    /** The most recent route seen this boot; the sidebar strip and the header highlight follow it. */
     private current;
     private sessionListenerDisposer;
     private pollTimer;
@@ -98,7 +53,6 @@ export declare class UsageService {
     /** True once loadPersisted finished; nothing may overwrite the files before that. */
     private loaded;
     private disposed;
-    private lastSignature;
     /** Last prune guard: once per local day, and whenever retention shrinks. */
     private lastPrune;
     constructor(ctx: Context, options: UsageServiceOptions);
@@ -116,12 +70,22 @@ export declare class UsageService {
     refresh(): Promise<void>;
     /** Assemble the overview document the browser section renders. */
     overview(): UsageOverviewView;
+    /**
+     * The strip-ready current-provider view: the resolved display name plus
+     * today's ledger totals for the provider's adapter family (the route
+     * itself when adapter-less). `today` is absent on a day without usage —
+     * a strip about nothing is noise, not information.
+     */
+    private currentView;
     /** One local day aggregated per provider. */
     private daySummary;
-    /** Today's ledger spend for one provider's adapter family (0 when unpriced). */
-    private familyCostToday;
-    /** Today's ledger totals for one provider route (the exact id, not the family). */
-    private providerUsageToday;
+    /**
+     * Today's ledger totals for one provider's adapter family — the exact
+     * route when adapter-less, the merged family otherwise, so aliased routes
+     * of one account (the deepseek catalog id and its runtime alias) fold
+     * together.
+     */
+    private familyUsageToday;
     /**
      * Accrue the official DeepSeek family's real spend from observed CNY
      * balance decreases; a balance rise is a top-up and never counts. The
@@ -134,7 +98,7 @@ export declare class UsageService {
     /**
      * The display name for a route key: the LLM runtime's first, then the
      * adapter's, then the id itself — the snapshot may not exist for
-     * adapter-less routes, yet the bubble still needs a legible title.
+     * adapter-less routes, yet the sidebar strip still needs a legible title.
      */
     private routeDisplayName;
     private onSessionEvent;
@@ -162,11 +126,17 @@ export declare class UsageService {
     private persistSnapshots;
     private rearmPoll;
     /**
-     * One poll cycle: enumerate routes, resolve credentials, probe, announce.
+     * One poll cycle: enumerate routes, resolve credentials, probe.
      * A call while a cycle is already running joins that cycle instead of
      * returning immediately, so a manual refresh always waits for real probes.
      */
     pollNow(): Promise<void>;
+    /**
+     * Every route the service probes and renders: the runtime's live providers
+     * plus the configurable directory's catalog entries, then alias-folded so a
+     * dormant catalog entry cannot shadow the live route of the same adapter
+     * family (see foldAliasRoutes).
+     */
     private listProviderRoutes;
     private probeRoute;
     /**
@@ -182,19 +152,4 @@ export declare class UsageService {
     private piAiProfile;
     /** The DeepSeek official adapter's credential reference name. */
     private deepseekApiKeyEnv;
-    /**
-     * Announce the current provider's spend, balance, or plan usage to the pet.
-     * In `change` mode only meaningful value changes re-announce; `off` skips.
-     * The TTL rides the poll interval (bubble_mode `always` re-announces every
-     * cycle, so a TTL of two cycles + margin keeps the bubble continuous
-     * across polls; the pet contract caps the ceiling). A route id the
-     * catalogs spell differently than the snapshot keys falls back to its
-     * adapter family's snapshot. When the provider has no announceable probe
-     * fact (no adapter, failing probes, percent-less windows) the bubble falls
-     * back to the provider's today ledger usage, and with neither fact nor
-     * usage it stays silent. Fully guarded: a malformed snapshot or a failing
-     * pet service must never break the poll loop, and a disposed service never
-     * announces.
-     */
-    private announceCurrent;
 }

package/lib/types/index.d.ts

@@ -9,8 +9,6 @@ export interface Config {
     enabled?: boolean;
     /** Provider probe cycle in seconds; 30-3600. */
     pollIntervalSec?: number;
-    /** Pet bubble mode: always (refreshes each poll), change (only on value change), off. */
-    bubbleMode?: string;
     /** Ledger retention in local days. */
     retainDays?: number;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-usage",
-  "description": "Usage statistics plugin for the dsh web GUI: per-provider balance and coding-plan quota detection plus a live token usage ledger, with a dedicated pet bubble for the current provider",
-  "version": "0.3.22",
+  "description": "Usage statistics plugin for the dsh web GUI: per-provider balance and coding-plan quota detection plus a live token usage ledger, with the current session provider's today usage on the sidebar entry",
+  "version": "0.3.24",
   "type": "module",
   "engines": {
     "node": "^22.19.0 || >=24.0.0"
@@ -66,11 +66,12 @@
     "@deepseek-ai/dsh-llm": "^0.1.5-rc.1",
     "@deepseek-ai/dsh-session": "^0.1.5-rc.1",
     "@deepseek-ai/dsh-settings": "^0.1.5-rc.1",
-    "@linxin666/dsh-pet": "0.3.22",
+    "@linxin666/dsh-pet": "0.3.24",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.2",
     "@types/node": "^22.20.0",
     "@types/react": "~18.3.1",
+    "@types/react-dom": "^18.3.5",
     "jsdom": "29.1.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",

package/src/client/UsageSectionCard.tsx

@@ -22,7 +22,6 @@ import type { ObservedSpendView, ProviderSnapshotView, UsageOverviewView, UsageP
 export interface UsageSettings {
   enabled?: boolean
   pollIntervalSec?: number
-  bubbleMode?: string
 }
 
 /** The registration-side face the section's slot entry injects. */
@@ -401,7 +400,7 @@ function totalOf(totals: UsageTokenTotals): number {
 
 /**
  * The Token 银行 card: the DeepSeek official family's retained-ledger usage
- * minted onto the whale-yuan note at 1000 tokens per whale yuan. The window
+ * minted onto the whale-yuan note at 1,000,000 tokens per whale yuan. The window
  * prefers the host's whole-ledger aggregate and falls back to the 30-day
  * trend when an older host serves no `all`; the spend line prefers the
  * official balance watch and falls back to the fold-time estimate; the
@@ -541,7 +540,6 @@ function SettingsRow(props: {
 }): ReactNode {
   const { settings, snapshot, value } = props
   const disabled = snapshot === undefined || !snapshot.writable
-  const bubbleMode = typeof value.bubbleMode === 'string' && ['always', 'change', 'off'].includes(value.bubbleMode) ? value.bubbleMode : 'always'
   return (
     <div className={styles.card} data-dsh-part="settings-row">
       <span className={styles.cardTitle}>{t('usage.config.title')}</span>
@@ -569,18 +567,6 @@ function SettingsRow(props: {
             }}
           />
         </label>
-        <label className={styles.settingItem}>
-          {t('usage.config.bubbleMode')}
-          <select
-            value={bubbleMode}
-            disabled={disabled}
-            onChange={(event) => { void settings.set('bubbleMode', event.target.value) }}
-          >
-            <option value="always">{t('usage.config.bubbleMode.always')}</option>
-            <option value="change">{t('usage.config.bubbleMode.change')}</option>
-            <option value="off">{t('usage.config.bubbleMode.off')}</option>
-          </select>
-        </label>
       </div>
     </div>
   )