@jxgame2020/dsh-token-quota 0.1.21 → 0.1.23

package/lib/types/client/music.js

@@ -0,0 +1,231 @@
+/**
+ * Live-composed soundtrack driven by host actions (turns, steps, tool calls,
+ * etc.). Outputs through Web Audio (built-in synthesis) by default, and also
+ * sends MIDI NoteOn/NoteOff to the first available MIDI output when one is
+ * detected (both play simultaneously when MIDI is present — use the panel
+ * volume for overall level, the MIDI output has its own gain on the receiver).
+ *
+ * The composition is intentionally simple: a fixed chord progression under a
+ * scale-constrained melody, with one short musical gesture per host action.
+ * It is meant as gentle ambience while waiting for LLM responses, not as a
+ * full piece — everything stays in key so you can never hit a wrong note.
+ *
+ * @module @jxgame2020/dsh-token-quota/music
+ */
+/** Scale degrees in semitones from the root. */
+const SCALES = {
+    major: [0, 2, 4, 5, 7, 9, 11],
+    minor: [0, 2, 3, 5, 7, 8, 10],
+    pentatonic: [0, 2, 4, 7, 9],
+};
+/**
+ * Chord progression roots in semitones from the key centre. Loops — every
+ * step advance moves one position forward.
+ */
+const CHORD_PROGRESSIONS = {
+    major: [0, 9, 5, 7], // I - vi - IV - V
+    minor: [0, 9, 4, 11], // i - VI - III - VII
+    pentatonic: [0, 7, 2, 9], // open fifths feel — root + 5th
+};
+const CHORD_QUALITIES = {
+    major: ['major', 'minor', 'major', 'major'],
+    minor: ['minor', 'major', 'major', 'major'],
+    pentatonic: ['major', 'major', 'major', 'major'],
+};
+/**
+ * Turn a MIDI note number into a frequency (Hz) using equal temperament at
+ * A4 = 440 Hz.
+ */
+function midiToFreq(midi) {
+    return 440 * Math.pow(2, (midi - 69) / 12);
+}
+/** Live-composed music engine driven by host actions. */
+export class TokenQuotaMusic {
+    audio = null;
+    midiOutput = null;
+    midiDetected = false;
+    enabled = false;
+    volume = 0.5;
+    style = 'major';
+    /** Current position in the chord progression (advances per step). */
+    chordIndex = 0;
+    /** Step counter — used for melody degree selection. */
+    stepCount = 0;
+    /** Tool counter — used for tool-note pitch. */
+    toolCount = 0;
+    /** Base MIDI note of the current key. C4 = middle C. */
+    static BASE_MIDI = 60;
+    /** True once the audio context has been started (needs a user gesture). */
+    get started() {
+        return this.audio !== null;
+    }
+    /**
+     * Start the audio context and try to find a MIDI output.
+     * Must be called inside a user gesture (the panel switch click) so the
+     * AudioContext can resume. Safe to call multiple times.
+     */
+    async ensureStarted() {
+        if (this.audio !== null)
+            return true;
+        if (typeof window === 'undefined')
+            return false;
+        try {
+            this.audio = new AudioContext();
+            await this.audio.resume();
+        }
+        catch {
+            this.audio = null;
+            return false;
+        }
+        // MIDI: try once; we don't re-probe (browser asks for permission only once).
+        if (!this.midiDetected && 'requestMIDIAccess' in navigator) {
+            this.midiDetected = true;
+            try {
+                const access = await navigator.requestMIDIAccess();
+                for (const output of access.outputs.values()) {
+                    this.midiOutput = output;
+                    break;
+                }
+            }
+            catch {
+                // Permission denied or no MIDI hardware — stick to Web Audio.
+                this.midiOutput = null;
+            }
+        }
+        return true;
+    }
+    setEnabled(value) {
+        this.enabled = value;
+    }
+    setVolume(value) {
+        this.volume = Math.max(0, Math.min(1, value));
+    }
+    setStyle(value) {
+        this.style = value;
+    }
+    /** Handle one incoming host action and turn it into sound. */
+    onAction(action) {
+        if (!this.enabled || this.audio === null)
+            return;
+        const base = TokenQuotaMusic.BASE_MIDI;
+        switch (action.type) {
+            case 'turn/start':
+                this.chordIndex = 0;
+                this.stepCount = 0;
+                this.toolCount = 0;
+                this.playChord(base, this.currentChordQuality(), 1.6, 0.55);
+                break;
+            case 'step/start': {
+                this.chordIndex = (this.chordIndex + 1) % CHORD_PROGRESSIONS[this.style].length;
+                this.stepCount += 1;
+                // bass note of the new chord
+                this.playNote(this.currentChordRoot(base) - 12, 1.2, 0.35);
+                // ascending arpeggio of the chord (3 notes)
+                const root = this.currentChordRoot(base);
+                const [d1, d2, d3] = this.arpeggioDegrees();
+                setTimeout(() => this.playNote(root + d1, 0.2, 0.4), 0);
+                setTimeout(() => this.playNote(root + d2, 0.2, 0.4), 80);
+                setTimeout(() => this.playNote(root + d3, 0.35, 0.4), 160);
+                break;
+            }
+            case 'request/header': {
+                // short melodic flicker — pitch follows step + tool positions
+                const degree = (this.stepCount * 2 + this.toolCount) % SCALES[this.style].length;
+                const note = base + 12 + SCALES[this.style][degree];
+                this.playNote(note, 0.18, 0.35);
+                break;
+            }
+            case 'tool/call':
+                this.toolCount += 1;
+                // high plink + a low percussive tap
+                this.playNote(base + 24 + (this.toolCount % 3) * 2, 0.12, 0.45);
+                this.playNote(base - 12, 0.08, 0.25);
+                break;
+            case 'tool/result': {
+                if (action.error) {
+                    // dissonant downward glint (two half-steps)
+                    this.playNote(base + 13, 0.18, 0.4);
+                    setTimeout(() => this.playNote(base + 12, 0.25, 0.4), 90);
+                }
+                else {
+                    // upward resolution
+                    this.playNote(base + 9, 0.14, 0.3);
+                    setTimeout(() => this.playNote(base + 11, 0.22, 0.3), 70);
+                }
+                break;
+            }
+            case 'assistant/message':
+                if (action.interrupted) {
+                    // interrupted turn: diminished tension chord
+                    this.playChord(base + 7, 'dim', 0.9, 0.5);
+                }
+                else {
+                    // full cadence chord of the current step
+                    this.playChord(this.currentChordRoot(base), this.currentChordQuality(), 1.1, 0.55);
+                }
+                break;
+            case 'turn/end':
+                // final tonic chord, longer release
+                this.playChord(base, this.style === 'minor' ? 'minor' : 'major', 2.2, 0.65);
+                this.chordIndex = 0;
+                break;
+        }
+    }
+    // ── internal helpers ──────────────────────────────────────────────
+    currentChordRoot(base) {
+        const prog = CHORD_PROGRESSIONS[this.style];
+        return base + prog[this.chordIndex % prog.length];
+    }
+    currentChordQuality() {
+        const q = CHORD_QUALITIES[this.style];
+        return q[this.chordIndex % q.length] ?? 'major';
+    }
+    /** Intervals of an ascending arpeggio from the chord root. */
+    arpeggioDegrees() {
+        return this.style === 'pentatonic'
+            ? [0, 7, 12]
+            : this.currentChordQuality() === 'major'
+                ? [0, 4, 7]
+                : [0, 3, 7];
+    }
+    /** Play one note: Web Audio + MIDI simultaneously when available. */
+    playNote(midi, durationSec, velocity) {
+        if (!this.audio)
+            return;
+        const now = this.audio.currentTime;
+        const peak = this.volume * velocity * 0.5;
+        if (peak <= 0)
+            return;
+        // Web Audio: sine oscillator with a quick attack and exponential release.
+        const osc = this.audio.createOscillator();
+        osc.type = 'sine';
+        osc.frequency.value = midiToFreq(midi);
+        const gain = this.audio.createGain();
+        gain.gain.setValueAtTime(0, now);
+        gain.gain.linearRampToValueAtTime(peak, now + 0.008);
+        gain.gain.exponentialRampToValueAtTime(0.001, now + durationSec);
+        osc.connect(gain);
+        gain.connect(this.audio.destination);
+        osc.start(now);
+        osc.stop(now + durationSec + 0.05);
+        // MIDI: same note on the first output, if any. Velocity 1..127.
+        if (this.midiOutput !== null) {
+            const vel = Math.max(1, Math.floor(velocity * 127));
+            this.midiOutput.send([0x90, midi & 0x7F, vel]);
+            setTimeout(() => {
+                this.midiOutput?.send([0x80, midi & 0x7F, 0]);
+            }, durationSec * 1000);
+        }
+    }
+    /** Play a three-note chord plus a bass octave below. */
+    playChord(rootMidi, quality, durationSec, velocity) {
+        const third = quality === 'major' ? 4 : 3;
+        const fifth = quality === 'dim' ? 6 : 7;
+        this.playNote(rootMidi, durationSec, velocity * 0.45);
+        this.playNote(rootMidi + third, durationSec, velocity * 0.35);
+        this.playNote(rootMidi + fifth, durationSec, velocity * 0.35);
+        // bass in the octave below — slightly longer for warmth
+        this.playNote(rootMidi - 12, durationSec * 1.15, velocity * 0.45);
+    }
+}
+//# sourceMappingURL=music.js.map

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

@@ -9,7 +9,7 @@
  */
 import { type EngineStoreHandle } from '@deepseek-ai/dsh-client-store';
 import type { ModelProviderGroup, ModelSelection } from '@deepseek-ai/dsh-api-session-controller/types';
-import type { TokenQuotaFullAction, TokenQuotaLog, TokenQuotaReset, TokenQuotaSnapshot, TokenQuotaUpgrade } from '@jxgame2020/dsh-token-quota/types';
+import type { TokenQuotaFullAction, TokenQuotaLog, TokenQuotaMusicStyle, TokenQuotaReset, TokenQuotaSnapshot, TokenQuotaUpgrade } from '@jxgame2020/dsh-token-quota/types';
 /** One rendered model row: directory identity merged with the quota snapshot. */
 export interface ModelQuotaRow {
     /** Stable key `provider/model`. */
@@ -50,6 +50,10 @@ export interface TokenQuotaPanelState {
     checkUpdates: boolean;
     /** Whether the panel dims while the pointer is away / while typing. */
     dimWhenIdle: boolean;
+    /** Live music settings (mirrored from the settings document). */
+    musicEnabled: boolean;
+    musicVolume: number;
+    musicStyle: TokenQuotaMusicStyle;
     /** Latest upgrade availability from the Host; null = up to date or unknown. */
     upgrade: TokenQuotaUpgrade | null;
     /** Whether the one-shot upgrade banner was dismissed for the current latest version. */
@@ -92,6 +96,9 @@ export type TokenQuotaPanelActions = {
     setSettings: (d: TokenQuotaPanelState, monitored: string[] | null, onFull: TokenQuotaFullAction) => void;
     setCheckUpdates: (d: TokenQuotaPanelState, checkUpdates: boolean) => void;
     setDimWhenIdle: (d: TokenQuotaPanelState, dimWhenIdle: boolean) => void;
+    setMusicEnabled: (d: TokenQuotaPanelState, enabled: boolean) => void;
+    setMusicVolume: (d: TokenQuotaPanelState, volume: number) => void;
+    setMusicStyle: (d: TokenQuotaPanelState, style: TokenQuotaMusicStyle) => void;
     setUpgrade: (d: TokenQuotaPanelState, upgrade: TokenQuotaUpgrade | null) => void;
     setUpgradeDismissed: (d: TokenQuotaPanelState, dismissed: boolean) => void;
     setCheckingUpdates: (d: TokenQuotaPanelState, checking: boolean) => void;

package/lib/types/client/store.js

@@ -28,6 +28,9 @@ export function createTokenQuotaPanelStore() {
             onFull: 'stop',
             checkUpdates: true,
             dimWhenIdle: false,
+            musicEnabled: false,
+            musicVolume: 0.5,
+            musicStyle: 'major',
             upgrade: null,
             upgradeDismissed: false,
             checkingUpdates: false,
@@ -53,6 +56,9 @@ export function createTokenQuotaPanelStore() {
             setSettings: (d, monitored, onFull) => { d.monitored = monitored; d.onFull = onFull; },
             setCheckUpdates: (d, checkUpdates) => { d.checkUpdates = checkUpdates; },
             setDimWhenIdle: (d, dimWhenIdle) => { d.dimWhenIdle = dimWhenIdle; },
+            setMusicEnabled: (d, enabled) => { d.musicEnabled = enabled; },
+            setMusicVolume: (d, volume) => { d.musicVolume = volume; },
+            setMusicStyle: (d, style) => { d.musicStyle = style; },
             setUpgrade: (d, upgrade) => {
                 // Guard against host/client version skew (e.g. the host process still
                 // runs an older bundle after an upgrade): when the reported "latest"

package/lib/types/index.d.ts

@@ -81,6 +81,10 @@ export declare class TokenQuotaService extends Service {
     private disposeRouteCheck;
     /** Disposer for the optional clear-log route (`POST /token-quota/clear-log`). */
     private disposeRouteClear;
+    /** Disposer for the optional music-event route (`GET /token-quota/events`, SSE). */
+    private disposeRouteEvents;
+    /** Live SSE subscribers receiving streamed music actions. */
+    private readonly musicClients;
     /** Disposer for the webServer-arrival watcher when the service mounts later. */
     private disposeRouteWatcher;
     /**
@@ -90,6 +94,8 @@ export declare class TokenQuotaService extends Service {
     constructor(ctx: Context, config?: TokenQuotaConfig);
     /** Serve the current snapshot over the plugin-owned HTTP route. */
     private tryMountRoute;
+    /** Broadcast one action to every open SSE music subscriber. */
+    private pushMusicAction;
     /** Query the npm registry and rebuild the cached upgrade info (coalesced). */
     private refreshUpgrade;
     private doRefreshUpgrade;

package/lib/types/index.js

@@ -38,7 +38,7 @@ import z from '@deepseek-ai/schemastery';
 // the service listens to without importing any runtime value.
 import '@deepseek-ai/dsh-agent';
 import { LlmError } from '@deepseek-ai/dsh-llm';
-import { TOKEN_QUOTA_EXCEEDED_CODE, TOKEN_QUOTA_NAMESPACE, tokenQuotaKey, } from "./types.js";
+import { TOKEN_QUOTA_EXCEEDED_CODE, TOKEN_QUOTA_NAMESPACE, tokenQuotaKey, TOKEN_QUOTA_DEFAULT_MUSIC, } from "./types.js";
 import { assertTokenQuotaLimit, splitTokenQuotaKey } from "./invariant.js";
 /** The plugin's package name, used to locate the profile dependency and the registry endpoint. */
 const PACKAGE_NAME = '@jxgame2020/dsh-token-quota';
@@ -206,6 +206,12 @@ const TOKEN_QUOTA_SETTINGS_SCHEMA = z.object({
     // panel writes it and the host validates the shape at runtime. `z.any` with
     // a null default keeps it out of the strict fields above.
     reset: z.any().default(null),
+    // Live music: host persists the document, the browser half plays it.
+    music: z.object({
+        enabled: z.boolean().default(TOKEN_QUOTA_DEFAULT_MUSIC.enabled),
+        volume: z.number().min(0).max(1).default(TOKEN_QUOTA_DEFAULT_MUSIC.volume),
+        style: z.union(['major', 'minor', 'pentatonic']).default(TOKEN_QUOTA_DEFAULT_MUSIC.style),
+    }).default({ ...TOKEN_QUOTA_DEFAULT_MUSIC }),
 });
 /** Two-digit zero-pad helper. */
 function pad2(value) {
@@ -266,7 +272,7 @@ export class TokenQuotaService extends Service {
     history = {};
     limits = {};
     monitored = undefined;
-    settingsSource = () => ({ limits: {}, monitored: [], onFull: 'stop', checkUpdates: true, dimWhenIdle: false });
+    settingsSource = () => ({ limits: {}, monitored: [], onFull: 'stop', checkUpdates: true, dimWhenIdle: false, music: { ...TOKEN_QUOTA_DEFAULT_MUSIC } });
     /** Whether update checks are enabled (mirrors the settings document). */
     checkUpdates = true;
     /** Cached upgrade availability; recomputed by {@link refreshUpgrade}. */
@@ -293,6 +299,10 @@ export class TokenQuotaService extends Service {
     disposeRouteCheck;
     /** Disposer for the optional clear-log route (`POST /token-quota/clear-log`). */
     disposeRouteClear;
+    /** Disposer for the optional music-event route (`GET /token-quota/events`, SSE). */
+    disposeRouteEvents;
+    /** Live SSE subscribers receiving streamed music actions. */
+    musicClients = new Set();
     /** Disposer for the webServer-arrival watcher when the service mounts later. */
     disposeRouteWatcher;
     /**
@@ -327,6 +337,11 @@ export class TokenQuotaService extends Service {
                             checkUpdates: doc.checkUpdates ?? true,
                             dimWhenIdle: doc.dimWhenIdle ?? false,
                             reset: doc.reset ?? undefined,
+                            music: {
+                                enabled: doc.music?.enabled ?? TOKEN_QUOTA_DEFAULT_MUSIC.enabled,
+                                volume: doc.music?.volume ?? TOKEN_QUOTA_DEFAULT_MUSIC.volume,
+                                style: doc.music?.style ?? TOKEN_QUOTA_DEFAULT_MUSIC.style,
+                            },
                         };
                     };
                 },
@@ -463,6 +478,34 @@ export class TokenQuotaService extends Service {
                 });
             },
         });
+        this.disposeRouteEvents = server.register({
+            kind: 'exact',
+            path: '/token-quota/events',
+            handler: (req, res) => {
+                res.writeHead(200, {
+                    'content-type': 'text/event-stream',
+                    'cache-control': 'no-store',
+                    'connection': 'keep-alive',
+                });
+                this.musicClients.add(res);
+                res.write(': token-quota music stream\n\n');
+                req.on('close', () => { this.musicClients.delete(res); });
+            },
+        });
+    }
+    /** Broadcast one action to every open SSE music subscriber. */
+    pushMusicAction(action) {
+        if (this.musicClients.size === 0)
+            return;
+        const data = `event: action\ndata: ${JSON.stringify(action)}\n\n`;
+        for (const res of this.musicClients) {
+            try {
+                res.write(data);
+            }
+            catch {
+                this.musicClients.delete(res);
+            }
+        }
     }
     /** Query the npm registry and rebuild the cached upgrade info (coalesced). */
     refreshUpgrade() {
@@ -624,23 +667,45 @@ export class TokenQuotaService extends Service {
         return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? limit : 0;
     }
     onSessionEvent(session, event) {
-        if (event.type === 'request/header') {
-            const { provider, model } = event.data.header.config;
-            this.headerKeys.set(session, tokenQuotaKey(provider, model));
-            return;
-        }
-        if (event.type === 'assistant/message' && event.data.usage !== undefined) {
-            const key = this.headerKeys.get(session);
-            if (key === undefined)
-                return;
-            if (!this.isMonitored(key))
-                return;
-            const tokens = usageTokens(event.data.usage);
-            if (tokens <= 0)
+        const sessionId = String(session.id);
+        switch (event.type) {
+            case 'turn/start':
+                this.pushMusicAction({ type: 'turn/start', sessionId });
+                break;
+            case 'turn/end':
+                this.pushMusicAction({ type: 'turn/end', sessionId, reason: event.data.reason.kind });
+                break;
+            case 'step/start':
+                this.pushMusicAction({ type: 'step/start', sessionId });
+                break;
+            case 'request/header': {
+                const { provider, model } = event.data.header.config;
+                this.headerKeys.set(session, tokenQuotaKey(provider, model));
+                this.pushMusicAction({ type: 'request/header', sessionId, provider, model });
                 return;
-            this.rollCycleIfNeeded();
-            this.usage[key] = (this.usage[key] ?? 0) + tokens;
-            this.scheduleWrite();
+            }
+            case 'tool/call':
+                this.pushMusicAction({ type: 'tool/call', sessionId, name: event.data.name });
+                break;
+            case 'tool/result':
+                this.pushMusicAction({ type: 'tool/result', sessionId, error: event.data.error !== undefined });
+                break;
+            case 'assistant/message':
+                this.pushMusicAction({ type: 'assistant/message', sessionId, interrupted: event.data.interrupted === true });
+                if (event.data.usage !== undefined) {
+                    const key = this.headerKeys.get(session);
+                    if (key === undefined)
+                        return;
+                    if (!this.isMonitored(key))
+                        return;
+                    const tokens = usageTokens(event.data.usage);
+                    if (tokens <= 0)
+                        return;
+                    this.rollCycleIfNeeded();
+                    this.usage[key] = (this.usage[key] ?? 0) + tokens;
+                    this.scheduleWrite();
+                }
+                break;
         }
     }
     /**
@@ -849,6 +914,15 @@ export class TokenQuotaService extends Service {
             this.disposeRouteCheck();
         if (this.disposeRouteClear !== undefined)
             this.disposeRouteClear();
+        if (this.disposeRouteEvents !== undefined)
+            this.disposeRouteEvents();
+        for (const res of this.musicClients) {
+            try {
+                res.end();
+            }
+            catch { /* ignore */ }
+        }
+        this.musicClients.clear();
         this.flush();
     }
     safeSplit(key) {

package/lib/types/types.d.ts

@@ -38,6 +38,54 @@ export interface TokenQuotaReset {
 }
 /** Default reset: machine-local midnight (offset = host timezone, 00:00). */
 export declare const TOKEN_QUOTA_DEFAULT_RESET: TokenQuotaReset;
+/** Harmonic palette of the live-composed soundtrack. */
+export declare const TOKEN_QUOTA_MUSIC_STYLES: readonly ["major", "minor", "pentatonic"];
+/** One of the {@link TOKEN_QUOTA_MUSIC_STYLES} values. */
+export type TokenQuotaMusicStyle = typeof TOKEN_QUOTA_MUSIC_STYLES[number];
+/** Music playback settings (host-persisted; the browser half plays). */
+export interface TokenQuotaMusicSettings {
+    /** Master switch — off by default so the plugin stays silent until enabled. */
+    enabled: boolean;
+    /** Output volume 0..1. */
+    volume: number;
+    /** Harmonic style of the live composition. */
+    style: TokenQuotaMusicStyle;
+}
+/** Default music settings: silent until the user flips the panel switch. */
+export declare const TOKEN_QUOTA_DEFAULT_MUSIC: TokenQuotaMusicSettings;
+/**
+ * One host action streamed to the browser over the plugin's SSE route
+ * (`GET /token-quota/events`); the panel's music engine turns it into a note.
+ * `sessionId` lets the client filter to the currently-visible session.
+ */
+export type TokenQuotaMusicAction = {
+    type: 'turn/start';
+    sessionId: string;
+} | {
+    type: 'turn/end';
+    sessionId: string;
+    reason: string;
+} | {
+    type: 'step/start';
+    sessionId: string;
+} | {
+    type: 'request/header';
+    sessionId: string;
+    provider: string;
+    model: string;
+} | {
+    type: 'tool/call';
+    sessionId: string;
+    name: string;
+} | {
+    type: 'tool/result';
+    sessionId: string;
+    error: boolean;
+} | {
+    type: 'assistant/message';
+    sessionId: string;
+    interrupted: boolean;
+};
 /**
  * Per-model daily-limit settings document shape. Keys are `provider/model`
  * and a value of `0` (or an absent key) means unlimited for that model.
@@ -79,6 +127,12 @@ export interface TokenQuotaSettings {
      * midnight (the historical behaviour).
      */
     reset?: TokenQuotaReset;
+    /**
+     * Live music output settings: a soundtrack composed from host actions
+     * (request starts, tool calls, turn ends) and played through Web Audio or
+     * an attached MIDI output. Off by default.
+     */
+    music: TokenQuotaMusicSettings;
 }
 /** Token-quota plugin configuration. */
 export interface TokenQuotaConfig {

package/lib/types/types.js

@@ -22,6 +22,14 @@ export const TOKEN_QUOTA_EXCEEDED_CODE = 'TOKEN_QUOTA_EXCEEDED';
 export const TOKEN_QUOTA_FULL_ACTIONS = ['stop', 'switchQuota', 'switchAll'];
 /** Default reset: machine-local midnight (offset = host timezone, 00:00). */
 export const TOKEN_QUOTA_DEFAULT_RESET = { offsetHours: 0, hour: 0, minute: 0 };
+/** Harmonic palette of the live-composed soundtrack. */
+export const TOKEN_QUOTA_MUSIC_STYLES = ['major', 'minor', 'pentatonic'];
+/** Default music settings: silent until the user flips the panel switch. */
+export const TOKEN_QUOTA_DEFAULT_MUSIC = {
+    enabled: false,
+    volume: 0.5,
+    style: 'major',
+};
 /** Build the stable per-model key shared by the counter, settings, and snapshot. */
 export function tokenQuotaKey(provider, model) {
     return `${provider}/${model}`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jxgame2020/dsh-token-quota",
   "description": "Daily per-model token quota accounting, enforcement, and a floating quota panel for the DeepSeek Harness — a fully self-contained plugin (no core-Harness wiring, no generated RPC contract)",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "publishConfig": {
     "access": "public"
   },