@jxgame2020/dsh-token-quota 0.1.27 → 0.1.28

package/lib/client.js

@@ -95,7 +95,7 @@ window.__ModuleLoader__.load({
 						d.musicOnlyCurrentSession = only;
 					},
 					setUpgrade: (d, upgrade) => {
-						const normalized = upgrade !== null && upgrade.latestVersion !== "" && upgrade.latestVersion !== "0.1.27" ? upgrade : null;
+						const normalized = upgrade !== null && upgrade.latestVersion !== "" && upgrade.latestVersion !== "0.1.28" ? upgrade : null;
 						if (d.upgrade === null || d.upgrade.latestVersion !== normalized?.latestVersion) d.upgradeDismissed = false;
 						d.upgrade = normalized;
 					},
@@ -201,92 +201,92 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var TokenQuotaPanel_module_css_default = {
-			"bar": "NPLLIq_bar",
-			"tab": "NPLLIq_tab",
-			"rowHeader": "NPLLIq_rowHeader",
-			"logTable": "NPLLIq_logTable",
-			"logPagerInfo": "NPLLIq_logPagerInfo",
-			"copyBtn": "NPLLIq_copyBtn",
-			"dialogBody": "NPLLIq_dialogBody",
-			"logClearDialog": "NPLLIq_logClearDialog",
-			"input": "NPLLIq_input",
+			"gearBtn": "NPLLIq_gearBtn",
+			"title": "NPLLIq_title",
+			"checkErrorHint": "NPLLIq_checkErrorHint",
+			"collapse": "NPLLIq_collapse",
+			"dialogTitle": "NPLLIq_dialogTitle",
+			"logDayCol": "NPLLIq_logDayCol",
+			"upgradeBannerText": "NPLLIq_upgradeBannerText",
+			"fillOver": "NPLLIq_fillOver",
 			"monitorHint": "NPLLIq_monitorHint",
+			"logClearDialog": "NPLLIq_logClearDialog",
+			"dialogClose": "NPLLIq_dialogClose",
 			"monitorName": "NPLLIq_monitorName",
-			"checkErrorHint": "NPLLIq_checkErrorHint",
-			"fillWarn": "NPLLIq_fillWarn",
-			"dialogBtn": "NPLLIq_dialogBtn",
-			"logModelCol": "NPLLIq_logModelCol",
-			"fullNotice": "NPLLIq_fullNotice",
-			"logPagerPages": "NPLLIq_logPagerPages",
-			"subtitle": "NPLLIq_subtitle",
-			"upgradeClose": "NPLLIq_upgradeClose",
-			"logClearDate": "NPLLIq_logClearDate",
-			"row": "NPLLIq_row",
-			"logHeader": "NPLLIq_logHeader",
-			"upgradeCommandRow": "NPLLIq_upgradeCommandRow",
 			"dialog": "NPLLIq_dialog",
-			"upgradeHint": "NPLLIq_upgradeHint",
-			"dialogHeader": "NPLLIq_dialogHeader",
-			"rowMeta": "NPLLIq_rowMeta",
-			"upgradeBannerText": "NPLLIq_upgradeBannerText",
-			"checkUpdatesLabel": "NPLLIq_checkUpdatesLabel",
-			"dialogLabel": "NPLLIq_dialogLabel",
-			"logPagerBtn": "NPLLIq_logPagerBtn",
 			"logClearBtn": "NPLLIq_logClearBtn",
-			"noticeError": "NPLLIq_noticeError",
-			"logUsedCol": "NPLLIq_logUsedCol",
-			"panelDim": "NPLLIq_panelDim",
-			"body": "NPLLIq_body",
-			"dialogClose": "NPLLIq_dialogClose",
+			"rowMeta": "NPLLIq_rowMeta",
+			"logSearch": "NPLLIq_logSearch",
 			"selectBtn": "NPLLIq_selectBtn",
-			"dialogOverlay": "NPLLIq_dialogOverlay",
-			"header": "NPLLIq_header",
+			"panelDim": "NPLLIq_panelDim",
+			"upgradeBanner": "NPLLIq_upgradeBanner",
+			"rowHeader": "NPLLIq_rowHeader",
+			"checkBtn": "NPLLIq_checkBtn",
+			"dialogHint": "NPLLIq_dialogHint",
+			"logPagerInfo": "NPLLIq_logPagerInfo",
+			"logModelCol": "NPLLIq_logModelCol",
+			"upgradeClose": "NPLLIq_upgradeClose",
+			"resetRow": "NPLLIq_resetRow",
 			"dialogActions": "NPLLIq_dialogActions",
-			"logDayCol": "NPLLIq_logDayCol",
-			"dialogTitle": "NPLLIq_dialogTitle",
-			"headerText": "NPLLIq_headerText",
-			"collapse": "NPLLIq_collapse",
+			"upgradeCommandRow": "NPLLIq_upgradeCommandRow",
 			"currentBadge": "NPLLIq_currentBadge",
-			"panel": "NPLLIq_panel",
-			"fillOver": "NPLLIq_fillOver",
-			"settingsBtn": "NPLLIq_settingsBtn",
-			"gearBtn": "NPLLIq_gearBtn",
-			"logPageSizeSelect": "NPLLIq_logPageSizeSelect",
-			"dialogHint": "NPLLIq_dialogHint",
+			"upgradeHint": "NPLLIq_upgradeHint",
+			"dialogHeader": "NPLLIq_dialogHeader",
+			"logScroll": "NPLLIq_logScroll",
 			"versionNew": "NPLLIq_versionNew",
-			"save": "NPLLIq_save",
-			"upgradeBannerFlash": "NPLLIq_upgradeBannerFlash",
-			"switch": "NPLLIq_switch",
+			"header": "NPLLIq_header",
 			"logToolbar": "NPLLIq_logToolbar",
-			"tabIcon": "NPLLIq_tabIcon",
-			"radioRow": "NPLLIq_radioRow",
-			"settingsBtnActive": "NPLLIq_settingsBtnActive",
-			"copyBtnDone": "NPLLIq_copyBtnDone",
-			"headerActions": "NPLLIq_headerActions",
-			"dialogSection": "NPLLIq_dialogSection",
-			"upgradeBanner": "NPLLIq_upgradeBanner",
-			"logScroll": "NPLLIq_logScroll",
-			"resetSelect": "NPLLIq_resetSelect",
-			"logSearch": "NPLLIq_logSearch",
-			"checkBtn": "NPLLIq_checkBtn",
-			"panelDimStrong": "NPLLIq_panelDimStrong",
+			"logPageSizeSelect": "NPLLIq_logPageSizeSelect",
 			"monitorRow": "NPLLIq_monitorRow",
+			"dialogSection": "NPLLIq_dialogSection",
+			"logUsedCol": "NPLLIq_logUsedCol",
+			"subtitle": "NPLLIq_subtitle",
+			"tabLabel": "NPLLIq_tabLabel",
+			"dialogLabel": "NPLLIq_dialogLabel",
+			"row": "NPLLIq_row",
+			"dialogBtn": "NPLLIq_dialogBtn",
+			"dialogBody": "NPLLIq_dialogBody",
+			"version": "NPLLIq_version",
+			"checkUpdatesLabel": "NPLLIq_checkUpdatesLabel",
+			"copyBtnDone": "NPLLIq_copyBtnDone",
+			"logHeader": "NPLLIq_logHeader",
+			"headerText": "NPLLIq_headerText",
+			"fillWarn": "NPLLIq_fillWarn",
+			"upgradeBannerFlash": "NPLLIq_upgradeBannerFlash",
+			"fullNotice": "NPLLIq_fullNotice",
+			"upgradeCommand": "NPLLIq_upgradeCommand",
 			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
+			"logPagerPages": "NPLLIq_logPagerPages",
 			"upgradeCommands": "NPLLIq_upgradeCommands",
-			"checkUpdatesRow": "NPLLIq_checkUpdatesRow",
+			"save": "NPLLIq_save",
+			"logClearDate": "NPLLIq_logClearDate",
+			"settingsBtn": "NPLLIq_settingsBtn",
 			"logPager": "NPLLIq_logPager",
-			"logPagerControls": "NPLLIq_logPagerControls",
+			"dialogOverlay": "NPLLIq_dialogOverlay",
 			"logDialog": "NPLLIq_logDialog",
-			"rowName": "NPLLIq_rowName",
+			"headerActions": "NPLLIq_headerActions",
 			"monitorList": "NPLLIq_monitorList",
-			"resetRow": "NPLLIq_resetRow",
-			"title": "NPLLIq_title",
-			"version": "NPLLIq_version",
-			"tabLabel": "NPLLIq_tabLabel",
-			"notice": "NPLLIq_notice",
-			"upgradeCommand": "NPLLIq_upgradeCommand",
+			"bar": "NPLLIq_bar",
+			"input": "NPLLIq_input",
+			"noticeError": "NPLLIq_noticeError",
 			"fillIdle": "NPLLIq_fillIdle",
-			"controls": "NPLLIq_controls"
+			"copyBtn": "NPLLIq_copyBtn",
+			"logPagerControls": "NPLLIq_logPagerControls",
+			"logPagerBtn": "NPLLIq_logPagerBtn",
+			"radioRow": "NPLLIq_radioRow",
+			"rowName": "NPLLIq_rowName",
+			"controls": "NPLLIq_controls",
+			"resetSelect": "NPLLIq_resetSelect",
+			"tab": "NPLLIq_tab",
+			"notice": "NPLLIq_notice",
+			"body": "NPLLIq_body",
+			"tabIcon": "NPLLIq_tabIcon",
+			"panelDimStrong": "NPLLIq_panelDimStrong",
+			"switch": "NPLLIq_switch",
+			"settingsBtnActive": "NPLLIq_settingsBtnActive",
+			"panel": "NPLLIq_panel",
+			"checkUpdatesRow": "NPLLIq_checkUpdatesRow",
+			"logTable": "NPLLIq_logTable"
 		};
 		//#endregion
 		//#region lib/types/client/TokenQuotaPanel.js
@@ -592,13 +592,13 @@ window.__ModuleLoader__.load({
 									title: t("upgradeAvailableHint"),
 									children: [
 										"v",
-										"0.1.27",
+										"0.1.28",
 										" → v",
 										upgrade.latestVersion
 									]
 								}) : (0, react_jsx_runtime.jsxs)("span", {
 									className: TokenQuotaPanel_module_css_default.version,
-									children: ["v", "0.1.27"]
+									children: ["v", "0.1.28"]
 								})]
 							}), (0, react_jsx_runtime.jsx)("div", {
 								className: TokenQuotaPanel_module_css_default.subtitle,
@@ -1235,21 +1235,25 @@ window.__ModuleLoader__.load({
 		* 古风 live-composed soundtrack driven by host actions.
 		*
 		* Design: when a request starts the engine composes a *piece* — a guzheng-like
-		* plucked-string voice over a soft open-fifth drone (Web Audio synthesis; the
-		* MIDI output is switched to the Koto program so hardware synths match). The
-		* piece plays phrase after phrase so it never goes quiet while the model
-		* thinks or streams. Incoming events steer the piece instead of interrupting
-		* it: a step change glides the drone to the next mode centre and inserts a
-		* fast 过门 (fill); tool calls get a high plink; the ending gets a flute-like
-		* breath note and a descending glissando.
+		* plucked-string voice (Web Audio synthesis; the MIDI output is switched to
+		* the Koto program so hardware synths match). The piece plays phrase after
+		* phrase so it stays alive while the model thinks or streams; incoming events
+		* steer the piece instead of interrupting it: a step change rotates the mode
+		* centre and inserts a fast 过门 (fill); tool calls get a high plink; the
+		* ending gets a dizi-like breath note and a descending glissando.
+		*
+		* **No sustained tones by design.** Every voice is a decaying pluck (≤1.6s)
+		* or a fixed-duration breath note — there is no drone/pad oscillator that
+		* depends on a later stop event. A lost SSE event can at worst leave the
+		* phrase chain running, and the stream watchdog below stops that too, so a
+		* hanging "呜呜" hum is physically impossible.
 		*
-		* Anti-runaway guards (the "endless drone" / hanging-MIDI-note problem):
+		* Anti-runaway guards:
 		*  - the host sends an SSE heartbeat every 5s; if it stops arriving the whole
-		*    engine fades out (a dead stream means no stop event will ever come),
-		*  - every MIDI NoteOn is registered and swept; `stopAll` also sends
+		*    engine stops (a dead stream means no stop event will ever come),
+		*  - every MIDI NoteOn is registered and swept; stops also send
 		*    All Notes Off (CC 123),
-		*  - Web Audio ramps never target zero exponentially and every oscillator is
-		*    explicitly stopped.
+		*  - every Web Audio oscillator is explicitly stopped at envelope end.
 		*
 		* @module @jxgame2020/dsh-token-quota/music
 		*/
@@ -1489,11 +1493,9 @@ window.__ModuleLoader__.load({
 			playing = false;
 			tonicIndex = 0;
 			phraseIndex = 0;
+			/** True when the next piece start should play the full intro glissando. */
+			introPending = true;
 			phraseTimer;
-			droneOscs = [];
-			droneGain = null;
-			droneFilter = null;
-			droneActive = false;
 			lastStreamActivity = 0;
 			watchdogTimer;
 			activeMidiNotes = /* @__PURE__ */ new Set();
@@ -1567,6 +1569,7 @@ window.__ModuleLoader__.load({
 						this.stopPiece(false);
 						this.tonicIndex = 0;
 						this.phraseIndex = 0;
+						this.introPending = true;
 						break;
 					case "request/header":
 						if (!this.playing) this.startPiece();
@@ -1575,9 +1578,10 @@ window.__ModuleLoader__.load({
 					case "step/start": {
 						const prog = PROGRESSION[this.style];
 						this.tonicIndex = (this.tonicIndex + 1) % prog.length;
-						const newRoot = base + (prog[this.tonicIndex] ?? 0);
-						this.glideDrone(newRoot);
-						if (this.playing) this.insertFill(newRoot);
+						if (this.playing) {
+							const newRoot = base + (prog[this.tonicIndex] ?? 0);
+							this.insertFill(newRoot);
+						}
 						break;
 					}
 					case "tool/call":
@@ -1600,6 +1604,7 @@ window.__ModuleLoader__.load({
 						break;
 					case "assistant/message":
 						this.stopMelody();
+						this.playing = false;
 						this.breath(action.interrupted ? base + 6 : base + 12, 1.6);
 						break;
 					case "turn/end":
@@ -1607,29 +1612,36 @@ window.__ModuleLoader__.load({
 						break;
 				}
 			}
-			/** Start a new piece: drone + ascending glissando + phrase chain. */
+			/** Start a new piece: intro run, then the phrase chain. */
 			startPiece() {
 				if (!this.audio || this.playing) return;
 				this.playing = true;
-				this.tonicIndex = 0;
-				this.phraseIndex = 0;
-				const root = TokenQuotaMusic.BASE_MIDI + (PROGRESSION[this.style][0] ?? 0);
-				this.startDrone(root);
+				const root = TokenQuotaMusic.BASE_MIDI + (PROGRESSION[this.style][this.tonicIndex] ?? 0);
 				const scale = SCALES[this.style];
-				let t = 0;
-				for (let i = 0; i < 8; i++) {
-					const deg = i % scale.length;
-					const note = root + 12 * Math.floor(i / scale.length) + (scale[deg] ?? 0);
-					setTimeout(() => this.pluck(note, .3), t);
-					t += 150;
+				if (this.introPending) {
+					this.introPending = false;
+					let t = 0;
+					for (let i = 0; i < 8; i++) {
+						const note = root + 12 * Math.floor(i / scale.length) + (scale[i % scale.length] ?? 0);
+						setTimeout(() => {
+							if (this.playing) this.pluck(note, .3);
+						}, t);
+						t += 150;
+					}
+					this.phraseTimer = setTimeout(() => this.playPhrase(), t + 100);
+				} else {
+					for (let i = 0; i < 3; i++) setTimeout(() => {
+						if (this.playing) this.pluck(root + 12 + (scale[i] ?? 0), .3);
+					}, i * 140);
+					this.phraseTimer = setTimeout(() => this.playPhrase(), 480);
 				}
-				this.phraseTimer = setTimeout(() => this.playPhrase(), t + 100);
 			}
 			/** Play one phrase, then chain into the next after a one-beat rest. */
 			playPhrase() {
 				if (!this.playing || !this.audio) return;
 				const root = TokenQuotaMusic.BASE_MIDI + (PROGRESSION[this.style][this.tonicIndex] ?? 0);
 				const scale = SCALES[this.style];
+				this.pluck(root - 12, .28, 1.6);
 				const phrase = PHRASES[this.phraseIndex % PHRASES.length];
 				this.phraseIndex += 1;
 				let t = 0;
@@ -1657,7 +1669,7 @@ window.__ModuleLoader__.load({
 				}
 				this.phraseTimer = setTimeout(() => this.playPhrase(), t + 60);
 			}
-			/** Stop the melody chain (drone keeps fading naturally). */
+			/** Stop the phrase chain. */
 			stopMelody() {
 				if (this.phraseTimer !== void 0) {
 					clearTimeout(this.phraseTimer);
@@ -1673,8 +1685,7 @@ window.__ModuleLoader__.load({
 					const scale = SCALES[this.style];
 					let t = 0;
 					for (let i = 7; i >= 0; i--) {
-						const deg = i % scale.length;
-						const note = base + 12 * Math.floor(i / scale.length) + (scale[deg] ?? 0);
+						const note = base + 12 * Math.floor(i / scale.length) + (scale[i % scale.length] ?? 0);
 						setTimeout(() => this.pluck(note, .3), t);
 						t += 120;
 					}
@@ -1685,86 +1696,16 @@ window.__ModuleLoader__.load({
 						this.pluck(base - 12, .5);
 					}, t + 150);
 				}
-				this.fadeDrone(final ? 1.2 : .8);
 				this.allMidiOff();
 			}
 			/** Hard stop everything (master switch off / teardown). */
 			stopAll() {
 				this.stopPiece(false);
 			}
-			/** Start the sustained open fifth (root + fifth below octave root). */
-			startDrone(root) {
-				if (!this.audio || this.droneActive) return;
-				const now = this.audio.currentTime;
-				const gain = this.audio.createGain();
-				gain.gain.setValueAtTime(0, now);
-				const filter = this.audio.createBiquadFilter();
-				filter.type = "lowpass";
-				filter.frequency.value = 620;
-				filter.Q.value = .4;
-				gain.connect(filter);
-				filter.connect(this.audio.destination);
-				const oscs = [];
-				for (const interval of [-12, -5]) {
-					const osc = this.audio.createOscillator();
-					osc.type = "sine";
-					osc.frequency.value = midiToFreq(root + interval);
-					osc.connect(gain);
-					osc.start(now);
-					oscs.push(osc);
-				}
-				this.droneOscs = oscs;
-				this.droneGain = gain;
-				this.droneFilter = filter;
-				this.droneActive = true;
-				gain.gain.linearRampToValueAtTime(this.volume * .07, now + 1.4);
-			}
-			/** Glide the drone to a new tonic (mode rotation). */
-			glideDrone(root) {
-				if (!this.audio || !this.droneActive) return;
-				const now = this.audio.currentTime;
-				const targets = [root - 12, root - 5];
-				this.droneOscs.forEach((osc, i) => {
-					const target = targets[i] ?? root;
-					osc.frequency.setValueAtTime(osc.frequency.value, now);
-					osc.frequency.exponentialRampToValueAtTime(midiToFreq(target), now + .9);
-				});
-			}
-			/** Fade the drone out and stop its oscillators. */
-			fadeDrone(seconds) {
-				if (!this.audio || !this.droneActive || this.droneGain === null) return;
-				const now = this.audio.currentTime;
-				const gain = this.droneGain;
-				gain.gain.cancelScheduledValues(now);
-				gain.gain.setValueAtTime(Math.max(gain.gain.value, 1e-4), now);
-				gain.gain.exponentialRampToValueAtTime(1e-4, now + seconds);
-				const oscs = this.droneOscs;
-				const filter = this.droneFilter;
-				setTimeout(() => {
-					for (const osc of oscs) {
-						try {
-							osc.stop();
-						} catch {}
-						try {
-							osc.disconnect();
-						} catch {}
-					}
-					try {
-						filter?.disconnect();
-					} catch {}
-					try {
-						gain.disconnect();
-					} catch {}
-				}, seconds * 1e3 + 120);
-				this.droneActive = false;
-				this.droneOscs = [];
-				this.droneGain = null;
-				this.droneFilter = null;
-			}
 			/**
-			* Guzheng-like pluck: two slightly detuned oscillators through a sweeping
-			* lowpass, fast attack and a long exponential decay (notes overlap, which
-			* keeps the piece continuous instead of choppy).
+			* Guzheng-like pluck: a triangle voice plus a soft octave partial through a
+			* sweeping lowpass, fast attack and a long exponential decay (notes
+			* overlap, which keeps the piece continuous instead of choppy).
 			*/
 			pluck(midi, velocity, decaySec = 1.3) {
 				if (!this.audio) return;
@@ -1788,9 +1729,9 @@ window.__ModuleLoader__.load({
 				osc1.frequency.value = freq;
 				const osc2 = this.audio.createOscillator();
 				osc2.type = "sine";
-				osc2.frequency.value = freq * 2.001;
+				osc2.frequency.value = freq * 2;
 				const octGain = this.audio.createGain();
-				octGain.gain.value = .35;
+				octGain.gain.value = .25;
 				osc1.connect(filter);
 				osc2.connect(octGain);
 				octGain.connect(filter);

package/lib/index.js

@@ -515,7 +515,7 @@ var TokenQuotaService = class TokenQuotaService extends Service {
 		return this.upgradeCheck;
 	}
 	async doRefreshUpgrade() {
-		const current = "0.1.27";
+		const current = "0.1.28";
 		let latest;
 		try {
 			const response = await fetch(REGISTRY_LATEST_URL, {

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

@@ -2,21 +2,25 @@
  * 古风 live-composed soundtrack driven by host actions.
  *
  * Design: when a request starts the engine composes a *piece* — a guzheng-like
- * plucked-string voice over a soft open-fifth drone (Web Audio synthesis; the
- * MIDI output is switched to the Koto program so hardware synths match). The
- * piece plays phrase after phrase so it never goes quiet while the model
- * thinks or streams. Incoming events steer the piece instead of interrupting
- * it: a step change glides the drone to the next mode centre and inserts a
- * fast 过门 (fill); tool calls get a high plink; the ending gets a flute-like
- * breath note and a descending glissando.
+ * plucked-string voice (Web Audio synthesis; the MIDI output is switched to
+ * the Koto program so hardware synths match). The piece plays phrase after
+ * phrase so it stays alive while the model thinks or streams; incoming events
+ * steer the piece instead of interrupting it: a step change rotates the mode
+ * centre and inserts a fast 过门 (fill); tool calls get a high plink; the
+ * ending gets a dizi-like breath note and a descending glissando.
  *
- * Anti-runaway guards (the "endless drone" / hanging-MIDI-note problem):
+ * **No sustained tones by design.** Every voice is a decaying pluck (≤1.6s)
+ * or a fixed-duration breath note — there is no drone/pad oscillator that
+ * depends on a later stop event. A lost SSE event can at worst leave the
+ * phrase chain running, and the stream watchdog below stops that too, so a
+ * hanging "呜呜" hum is physically impossible.
+ *
+ * Anti-runaway guards:
  *  - the host sends an SSE heartbeat every 5s; if it stops arriving the whole
- *    engine fades out (a dead stream means no stop event will ever come),
- *  - every MIDI NoteOn is registered and swept; `stopAll` also sends
+ *    engine stops (a dead stream means no stop event will ever come),
+ *  - every MIDI NoteOn is registered and swept; stops also send
  *    All Notes Off (CC 123),
- *  - Web Audio ramps never target zero exponentially and every oscillator is
- *    explicitly stopped.
+ *  - every Web Audio oscillator is explicitly stopped at envelope end.
  *
  * @module @jxgame2020/dsh-token-quota/music
  */
@@ -36,11 +40,9 @@ export declare class TokenQuotaMusic {
     private playing;
     private tonicIndex;
     private phraseIndex;
+    /** True when the next piece start should play the full intro glissando. */
+    private introPending;
     private phraseTimer;
-    private droneOscs;
-    private droneGain;
-    private droneFilter;
-    private droneActive;
     private lastStreamActivity;
     private watchdogTimer;
     private readonly activeMidiNotes;
@@ -64,28 +66,22 @@ export declare class TokenQuotaMusic {
     markStreamActivity(): void;
     /** Handle one incoming host action and steer the piece. */
     onAction(action: TokenQuotaMusicAction): void;
-    /** Start a new piece: drone + ascending glissando + phrase chain. */
+    /** Start a new piece: intro run, then the phrase chain. */
     private startPiece;
     /** Play one phrase, then chain into the next after a one-beat rest. */
     private playPhrase;
     /** Insert a 过门 fill: pause the chain, play the run, resume after. */
     private insertFill;
-    /** Stop the melody chain (drone keeps fading naturally). */
+    /** Stop the phrase chain. */
     private stopMelody;
     /** Stop the whole piece; `final` adds the closing cadence gestures. */
     private stopPiece;
     /** Hard stop everything (master switch off / teardown). */
     private stopAll;
-    /** Start the sustained open fifth (root + fifth below octave root). */
-    private startDrone;
-    /** Glide the drone to a new tonic (mode rotation). */
-    private glideDrone;
-    /** Fade the drone out and stop its oscillators. */
-    private fadeDrone;
     /**
-     * Guzheng-like pluck: two slightly detuned oscillators through a sweeping
-     * lowpass, fast attack and a long exponential decay (notes overlap, which
-     * keeps the piece continuous instead of choppy).
+     * Guzheng-like pluck: a triangle voice plus a soft octave partial through a
+     * sweeping lowpass, fast attack and a long exponential decay (notes
+     * overlap, which keeps the piece continuous instead of choppy).
      */
     private pluck;
     /** Dizi-like breath note: sine with vibrato and a soft envelope. */

package/lib/types/client/music.js

@@ -2,21 +2,25 @@
  * 古风 live-composed soundtrack driven by host actions.
  *
  * Design: when a request starts the engine composes a *piece* — a guzheng-like
- * plucked-string voice over a soft open-fifth drone (Web Audio synthesis; the
- * MIDI output is switched to the Koto program so hardware synths match). The
- * piece plays phrase after phrase so it never goes quiet while the model
- * thinks or streams. Incoming events steer the piece instead of interrupting
- * it: a step change glides the drone to the next mode centre and inserts a
- * fast 过门 (fill); tool calls get a high plink; the ending gets a flute-like
- * breath note and a descending glissando.
+ * plucked-string voice (Web Audio synthesis; the MIDI output is switched to
+ * the Koto program so hardware synths match). The piece plays phrase after
+ * phrase so it stays alive while the model thinks or streams; incoming events
+ * steer the piece instead of interrupting it: a step change rotates the mode
+ * centre and inserts a fast 过门 (fill); tool calls get a high plink; the
+ * ending gets a dizi-like breath note and a descending glissando.
  *
- * Anti-runaway guards (the "endless drone" / hanging-MIDI-note problem):
+ * **No sustained tones by design.** Every voice is a decaying pluck (≤1.6s)
+ * or a fixed-duration breath note — there is no drone/pad oscillator that
+ * depends on a later stop event. A lost SSE event can at worst leave the
+ * phrase chain running, and the stream watchdog below stops that too, so a
+ * hanging "呜呜" hum is physically impossible.
+ *
+ * Anti-runaway guards:
  *  - the host sends an SSE heartbeat every 5s; if it stops arriving the whole
- *    engine fades out (a dead stream means no stop event will ever come),
- *  - every MIDI NoteOn is registered and swept; `stopAll` also sends
+ *    engine stops (a dead stream means no stop event will ever come),
+ *  - every MIDI NoteOn is registered and swept; stops also send
  *    All Notes Off (CC 123),
- *  - Web Audio ramps never target zero exponentially and every oscillator is
- *    explicitly stopped.
+ *  - every Web Audio oscillator is explicitly stopped at envelope end.
  *
  * @module @jxgame2020/dsh-token-quota/music
  */
@@ -74,12 +78,9 @@ export class TokenQuotaMusic {
     playing = false;
     tonicIndex = 0;
     phraseIndex = 0;
+    /** True when the next piece start should play the full intro glissando. */
+    introPending = true;
     phraseTimer;
-    // Drone layer (sustained open fifth under the plucks)
-    droneOscs = [];
-    droneGain = null;
-    droneFilter = null;
-    droneActive = false;
     // Watchdog: host heartbeat freshness (ms timestamp)
     lastStreamActivity = 0;
     watchdogTimer;
@@ -138,7 +139,7 @@ export class TokenQuotaMusic {
             this.lastStreamActivity = Date.now();
             this.watchdogTimer = setInterval(() => {
                 if (this.playing && Date.now() - this.lastStreamActivity > TokenQuotaMusic.STREAM_TIMEOUT_MS) {
-                    // Dead stream: no stop event will ever arrive — fade out.
+                    // Dead stream: no stop event will ever arrive — stop the piece.
                     this.stopPiece(false);
                 }
             }, 4_000);
@@ -170,6 +171,7 @@ export class TokenQuotaMusic {
                 this.stopPiece(false);
                 this.tonicIndex = 0;
                 this.phraseIndex = 0;
+                this.introPending = true;
                 break;
             case 'request/header': {
                 if (!this.playing)
@@ -179,13 +181,13 @@ export class TokenQuotaMusic {
                 break;
             }
             case 'step/start': {
-                // New phase: rotate the tonic, glide the drone, insert a 过门 fill.
+                // New phase: rotate the mode centre and insert a 过门 fill.
                 const prog = PROGRESSION[this.style];
                 this.tonicIndex = (this.tonicIndex + 1) % prog.length;
-                const newRoot = base + (prog[this.tonicIndex] ?? 0);
-                this.glideDrone(newRoot);
-                if (this.playing)
+                if (this.playing) {
+                    const newRoot = base + (prog[this.tonicIndex] ?? 0);
                     this.insertFill(newRoot);
+                }
                 break;
             }
             case 'tool/call':
@@ -211,9 +213,10 @@ export class TokenQuotaMusic {
                 setTimeout(() => this.pluck(base + 5, 0.4, 0.8), 220);
                 break;
             case 'assistant/message':
-                // Phrase ends; the turn may continue (more steps) — keep the drone
-                // breathing but stop the melody, ending with a breath note.
+                // Sentence end: stop the phrase chain and breathe. The next
+                // request/header (next step or next turn) starts a fresh phrase.
                 this.stopMelody();
+                this.playing = false;
                 this.breath(action.interrupted ? base + 6 : base + 12, 1.6);
                 break;
             case 'turn/end':
@@ -222,27 +225,37 @@ export class TokenQuotaMusic {
         }
     }
     // ── piece lifecycle ───────────────────────────────────────────────────
-    /** Start a new piece: drone + ascending glissando + phrase chain. */
+    /** Start a new piece: intro run, then the phrase chain. */
     startPiece() {
         if (!this.audio || this.playing)
             return;
         this.playing = true;
-        this.tonicIndex = 0;
-        this.phraseIndex = 0;
-        const root = TokenQuotaMusic.BASE_MIDI + (PROGRESSION[this.style][0] ?? 0);
-        this.startDrone(root);
-        // Intro glissando — the guzheng sweep that announces the piece.
+        const root = TokenQuotaMusic.BASE_MIDI + (PROGRESSION[this.style][this.tonicIndex] ?? 0);
         const scale = SCALES[this.style];
-        let t = 0;
-        for (let i = 0; i < 8; i++) {
-            const deg = i % scale.length;
-            const oct = Math.floor(i / scale.length);
-            const note = root + 12 * oct + (scale[deg] ?? 0);
-            setTimeout(() => this.pluck(note, 0.3), t);
-            t += 150;
+        if (this.introPending) {
+            // Full intro: the ascending guzheng glissando that announces the piece.
+            this.introPending = false;
+            let t = 0;
+            for (let i = 0; i < 8; i++) {
+                const note = root + 12 * Math.floor(i / scale.length) + (scale[i % scale.length] ?? 0);
+                setTimeout(() => {
+                    if (this.playing)
+                        this.pluck(note, 0.3);
+                }, t);
+                t += 150;
+            }
+            this.phraseTimer = setTimeout(() => this.playPhrase(), t + 100);
+        }
+        else {
+            // Restart within the same turn: a short three-note pickup, no glissando.
+            for (let i = 0; i < 3; i++) {
+                setTimeout(() => {
+                    if (this.playing)
+                        this.pluck(root + 12 + (scale[i] ?? 0), 0.3);
+                }, i * 140);
+            }
+            this.phraseTimer = setTimeout(() => this.playPhrase(), 480);
         }
-        // First phrase starts right after the glissando.
-        this.phraseTimer = setTimeout(() => this.playPhrase(), t + 100);
     }
     /** Play one phrase, then chain into the next after a one-beat rest. */
     playPhrase() {
@@ -250,6 +263,9 @@ export class TokenQuotaMusic {
             return;
         const root = TokenQuotaMusic.BASE_MIDI + (PROGRESSION[this.style][this.tonicIndex] ?? 0);
         const scale = SCALES[this.style];
+        // Soft low root pluck under each phrase — a foundation that decays away
+        // instead of a sustained drone (nothing here can hang).
+        this.pluck(root - 12, 0.28, 1.6);
         const phrase = PHRASES[this.phraseIndex % PHRASES.length];
         this.phraseIndex += 1;
         let t = 0;
@@ -282,7 +298,7 @@ export class TokenQuotaMusic {
         }
         this.phraseTimer = setTimeout(() => this.playPhrase(), t + 60);
     }
-    /** Stop the melody chain (drone keeps fading naturally). */
+    /** Stop the phrase chain. */
     stopMelody() {
         if (this.phraseTimer !== undefined) {
             clearTimeout(this.phraseTimer);
@@ -299,9 +315,7 @@ export class TokenQuotaMusic {
             const scale = SCALES[this.style];
             let t = 0;
             for (let i = 7; i >= 0; i--) {
-                const deg = i % scale.length;
-                const oct = Math.floor(i / scale.length);
-                const note = base + 12 * oct + (scale[deg] ?? 0);
+                const note = base + 12 * Math.floor(i / scale.length) + (scale[i % scale.length] ?? 0);
                 setTimeout(() => this.pluck(note, 0.3), t);
                 t += 120;
             }
@@ -312,95 +326,17 @@ export class TokenQuotaMusic {
                 this.pluck(base - 12, 0.5);
             }, t + 150);
         }
-        this.fadeDrone(final ? 1.2 : 0.8);
         this.allMidiOff();
     }
     /** Hard stop everything (master switch off / teardown). */
     stopAll() {
         this.stopPiece(false);
     }
-    // ── drone layer ───────────────────────────────────────────────────────
-    /** Start the sustained open fifth (root + fifth below octave root). */
-    startDrone(root) {
-        if (!this.audio || this.droneActive)
-            return;
-        const now = this.audio.currentTime;
-        const gain = this.audio.createGain();
-        gain.gain.setValueAtTime(0, now);
-        const filter = this.audio.createBiquadFilter();
-        filter.type = 'lowpass';
-        filter.frequency.value = 620;
-        filter.Q.value = 0.4;
-        gain.connect(filter);
-        filter.connect(this.audio.destination);
-        const oscs = [];
-        for (const interval of [-12, -5]) {
-            const osc = this.audio.createOscillator();
-            osc.type = 'sine';
-            osc.frequency.value = midiToFreq(root + interval);
-            osc.connect(gain);
-            osc.start(now);
-            oscs.push(osc);
-        }
-        this.droneOscs = oscs;
-        this.droneGain = gain;
-        this.droneFilter = filter;
-        this.droneActive = true;
-        gain.gain.linearRampToValueAtTime(this.volume * 0.07, now + 1.4);
-    }
-    /** Glide the drone to a new tonic (mode rotation). */
-    glideDrone(root) {
-        if (!this.audio || !this.droneActive)
-            return;
-        const now = this.audio.currentTime;
-        const targets = [root - 12, root - 5];
-        this.droneOscs.forEach((osc, i) => {
-            const target = targets[i] ?? root;
-            osc.frequency.setValueAtTime(osc.frequency.value, now);
-            osc.frequency.exponentialRampToValueAtTime(midiToFreq(target), now + 0.9);
-        });
-    }
-    /** Fade the drone out and stop its oscillators. */
-    fadeDrone(seconds) {
-        if (!this.audio || !this.droneActive || this.droneGain === null)
-            return;
-        const now = this.audio.currentTime;
-        const gain = this.droneGain;
-        gain.gain.cancelScheduledValues(now);
-        gain.gain.setValueAtTime(Math.max(gain.gain.value, 0.0001), now);
-        gain.gain.exponentialRampToValueAtTime(0.0001, now + seconds);
-        const oscs = this.droneOscs;
-        const filter = this.droneFilter;
-        setTimeout(() => {
-            for (const osc of oscs) {
-                try {
-                    osc.stop();
-                }
-                catch { /* ignore */ }
-                try {
-                    osc.disconnect();
-                }
-                catch { /* ignore */ }
-            }
-            try {
-                filter?.disconnect();
-            }
-            catch { /* ignore */ }
-            try {
-                gain.disconnect();
-            }
-            catch { /* ignore */ }
-        }, seconds * 1000 + 120);
-        this.droneActive = false;
-        this.droneOscs = [];
-        this.droneGain = null;
-        this.droneFilter = null;
-    }
     // ── voices ────────────────────────────────────────────────────────────
     /**
-     * Guzheng-like pluck: two slightly detuned oscillators through a sweeping
-     * lowpass, fast attack and a long exponential decay (notes overlap, which
-     * keeps the piece continuous instead of choppy).
+     * Guzheng-like pluck: a triangle voice plus a soft octave partial through a
+     * sweeping lowpass, fast attack and a long exponential decay (notes
+     * overlap, which keeps the piece continuous instead of choppy).
      */
     pluck(midi, velocity, decaySec = 1.3) {
         if (!this.audio)
@@ -426,9 +362,9 @@ export class TokenQuotaMusic {
         osc1.frequency.value = freq;
         const osc2 = this.audio.createOscillator();
         osc2.type = 'sine';
-        osc2.frequency.value = freq * 2.001; // shimmering octave partial
+        osc2.frequency.value = freq * 2; // octave partial (no detune beating)
         const octGain = this.audio.createGain();
-        octGain.gain.value = 0.35;
+        octGain.gain.value = 0.25;
         osc1.connect(filter);
         osc2.connect(octGain);
         octGain.connect(filter);

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.27",
+  "version": "0.1.28",
   "publishConfig": {
     "access": "public"
   },