@jxgame2020/dsh-token-quota 0.1.26 → 0.1.27

package/lib/client.js

@@ -39,7 +39,7 @@ window.__ModuleLoader__.load({
 					dimWhenIdle: false,
 					musicEnabled: false,
 					musicVolume: .5,
-					musicStyle: "major",
+					musicStyle: "pentatonic",
 					musicOnlyCurrentSession: true,
 					upgrade: null,
 					upgradeDismissed: false,
@@ -95,7 +95,7 @@ window.__ModuleLoader__.load({
 						d.musicOnlyCurrentSession = only;
 					},
 					setUpgrade: (d, upgrade) => {
-						const normalized = upgrade !== null && upgrade.latestVersion !== "" && upgrade.latestVersion !== "0.1.26" ? upgrade : null;
+						const normalized = upgrade !== null && upgrade.latestVersion !== "" && upgrade.latestVersion !== "0.1.27" ? 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 = {
-			"checkBtn": "NPLLIq_checkBtn",
-			"body": "NPLLIq_body",
-			"dialogLabel": "NPLLIq_dialogLabel",
-			"upgradeBanner": "NPLLIq_upgradeBanner",
-			"dialogActions": "NPLLIq_dialogActions",
-			"currentBadge": "NPLLIq_currentBadge",
-			"dialogBody": "NPLLIq_dialogBody",
-			"notice": "NPLLIq_notice",
-			"rowMeta": "NPLLIq_rowMeta",
-			"title": "NPLLIq_title",
-			"logPagerInfo": "NPLLIq_logPagerInfo",
-			"headerText": "NPLLIq_headerText",
 			"bar": "NPLLIq_bar",
-			"noticeError": "NPLLIq_noticeError",
 			"tab": "NPLLIq_tab",
-			"logScroll": "NPLLIq_logScroll",
-			"dialogTitle": "NPLLIq_dialogTitle",
-			"selectBtn": "NPLLIq_selectBtn",
-			"monitorList": "NPLLIq_monitorList",
-			"switch": "NPLLIq_switch",
-			"monitorRow": "NPLLIq_monitorRow",
-			"resetSelect": "NPLLIq_resetSelect",
-			"dialogBtn": "NPLLIq_dialogBtn",
-			"logHeader": "NPLLIq_logHeader",
-			"panelDim": "NPLLIq_panelDim",
-			"logToolbar": "NPLLIq_logToolbar",
-			"upgradeCommands": "NPLLIq_upgradeCommands",
-			"upgradeHint": "NPLLIq_upgradeHint",
-			"logDayCol": "NPLLIq_logDayCol",
-			"settingsBtn": "NPLLIq_settingsBtn",
-			"tabLabel": "NPLLIq_tabLabel",
-			"dialogClose": "NPLLIq_dialogClose",
-			"fillOver": "NPLLIq_fillOver",
 			"rowHeader": "NPLLIq_rowHeader",
-			"upgradeBannerFlash": "NPLLIq_upgradeBannerFlash",
+			"logTable": "NPLLIq_logTable",
+			"logPagerInfo": "NPLLIq_logPagerInfo",
 			"copyBtn": "NPLLIq_copyBtn",
-			"upgradeClose": "NPLLIq_upgradeClose",
+			"dialogBody": "NPLLIq_dialogBody",
+			"logClearDialog": "NPLLIq_logClearDialog",
+			"input": "NPLLIq_input",
+			"monitorHint": "NPLLIq_monitorHint",
+			"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",
-			"logPagerBtn": "NPLLIq_logPagerBtn",
+			"dialog": "NPLLIq_dialog",
+			"upgradeHint": "NPLLIq_upgradeHint",
+			"dialogHeader": "NPLLIq_dialogHeader",
+			"rowMeta": "NPLLIq_rowMeta",
 			"upgradeBannerText": "NPLLIq_upgradeBannerText",
 			"checkUpdatesLabel": "NPLLIq_checkUpdatesLabel",
-			"fillWarn": "NPLLIq_fillWarn",
-			"headerActions": "NPLLIq_headerActions",
-			"save": "NPLLIq_save",
-			"checkUpdatesRow": "NPLLIq_checkUpdatesRow",
-			"settingsBtnActive": "NPLLIq_settingsBtnActive",
-			"radioRow": "NPLLIq_radioRow",
+			"dialogLabel": "NPLLIq_dialogLabel",
+			"logPagerBtn": "NPLLIq_logPagerBtn",
 			"logClearBtn": "NPLLIq_logClearBtn",
-			"logPageSizeSelect": "NPLLIq_logPageSizeSelect",
-			"dialogHint": "NPLLIq_dialogHint",
-			"logClearDialog": "NPLLIq_logClearDialog",
-			"monitorName": "NPLLIq_monitorName",
-			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
-			"logPager": "NPLLIq_logPager",
-			"logClearDate": "NPLLIq_logClearDate",
-			"rowName": "NPLLIq_rowName",
-			"logDialog": "NPLLIq_logDialog",
-			"dialogOverlay": "NPLLIq_dialogOverlay",
+			"noticeError": "NPLLIq_noticeError",
 			"logUsedCol": "NPLLIq_logUsedCol",
-			"input": "NPLLIq_input",
-			"gearBtn": "NPLLIq_gearBtn",
-			"row": "NPLLIq_row",
-			"monitorHint": "NPLLIq_monitorHint",
+			"panelDim": "NPLLIq_panelDim",
+			"body": "NPLLIq_body",
+			"dialogClose": "NPLLIq_dialogClose",
+			"selectBtn": "NPLLIq_selectBtn",
+			"dialogOverlay": "NPLLIq_dialogOverlay",
 			"header": "NPLLIq_header",
-			"logPagerPages": "NPLLIq_logPagerPages",
+			"dialogActions": "NPLLIq_dialogActions",
+			"logDayCol": "NPLLIq_logDayCol",
+			"dialogTitle": "NPLLIq_dialogTitle",
+			"headerText": "NPLLIq_headerText",
+			"collapse": "NPLLIq_collapse",
+			"currentBadge": "NPLLIq_currentBadge",
+			"panel": "NPLLIq_panel",
+			"fillOver": "NPLLIq_fillOver",
+			"settingsBtn": "NPLLIq_settingsBtn",
+			"gearBtn": "NPLLIq_gearBtn",
+			"logPageSizeSelect": "NPLLIq_logPageSizeSelect",
+			"dialogHint": "NPLLIq_dialogHint",
 			"versionNew": "NPLLIq_versionNew",
-			"subtitle": "NPLLIq_subtitle",
-			"version": "NPLLIq_version",
-			"fullNotice": "NPLLIq_fullNotice",
-			"resetRow": "NPLLIq_resetRow",
-			"logTable": "NPLLIq_logTable",
-			"fillIdle": "NPLLIq_fillIdle",
-			"checkErrorHint": "NPLLIq_checkErrorHint",
+			"save": "NPLLIq_save",
+			"upgradeBannerFlash": "NPLLIq_upgradeBannerFlash",
+			"switch": "NPLLIq_switch",
+			"logToolbar": "NPLLIq_logToolbar",
 			"tabIcon": "NPLLIq_tabIcon",
-			"logPagerControls": "NPLLIq_logPagerControls",
-			"collapse": "NPLLIq_collapse",
-			"upgradeCommand": "NPLLIq_upgradeCommand",
+			"radioRow": "NPLLIq_radioRow",
+			"settingsBtnActive": "NPLLIq_settingsBtnActive",
 			"copyBtnDone": "NPLLIq_copyBtnDone",
+			"headerActions": "NPLLIq_headerActions",
 			"dialogSection": "NPLLIq_dialogSection",
-			"controls": "NPLLIq_controls",
-			"panel": "NPLLIq_panel",
-			"panelDimStrong": "NPLLIq_panelDimStrong",
+			"upgradeBanner": "NPLLIq_upgradeBanner",
+			"logScroll": "NPLLIq_logScroll",
+			"resetSelect": "NPLLIq_resetSelect",
 			"logSearch": "NPLLIq_logSearch",
-			"dialogHeader": "NPLLIq_dialogHeader",
-			"dialog": "NPLLIq_dialog"
+			"checkBtn": "NPLLIq_checkBtn",
+			"panelDimStrong": "NPLLIq_panelDimStrong",
+			"monitorRow": "NPLLIq_monitorRow",
+			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
+			"upgradeCommands": "NPLLIq_upgradeCommands",
+			"checkUpdatesRow": "NPLLIq_checkUpdatesRow",
+			"logPager": "NPLLIq_logPager",
+			"logPagerControls": "NPLLIq_logPagerControls",
+			"logDialog": "NPLLIq_logDialog",
+			"rowName": "NPLLIq_rowName",
+			"monitorList": "NPLLIq_monitorList",
+			"resetRow": "NPLLIq_resetRow",
+			"title": "NPLLIq_title",
+			"version": "NPLLIq_version",
+			"tabLabel": "NPLLIq_tabLabel",
+			"notice": "NPLLIq_notice",
+			"upgradeCommand": "NPLLIq_upgradeCommand",
+			"fillIdle": "NPLLIq_fillIdle",
+			"controls": "NPLLIq_controls"
 		};
 		//#endregion
 		//#region lib/types/client/TokenQuotaPanel.js
@@ -592,13 +592,13 @@ window.__ModuleLoader__.load({
 									title: t("upgradeAvailableHint"),
 									children: [
 										"v",
-										"0.1.26",
+										"0.1.27",
 										" → v",
 										upgrade.latestVersion
 									]
 								}) : (0, react_jsx_runtime.jsxs)("span", {
 									className: TokenQuotaPanel_module_css_default.version,
-									children: ["v", "0.1.26"]
+									children: ["v", "0.1.27"]
 								})]
 							}), (0, react_jsx_runtime.jsx)("div", {
 								className: TokenQuotaPanel_module_css_default.subtitle,
@@ -1232,23 +1232,28 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region lib/types/client/music.js
 		/**
-		* Live-composed ambient soundtrack driven by host actions (turns, steps,
-		* tool calls, etc.). Three layers:
+		* 古风 live-composed soundtrack driven by host actions.
 		*
-		*  - **Pad**: a sustained three-note chord (triangle waves) that fades in when
-		*    a request starts and crossfades to the next chord on every step.
-		*  - **Bass**: one long root note per beat (lower octave), keeps the pulse.
-		*  - **Melody**: an eighth-note scale line that dances inside the current
-		*    chord — always in key, never a wrong note.
+		* 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.
 		*
-		* 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).
+		* Anti-runaway guards (the "endless drone" / hanging-MIDI-note problem):
+		*  - 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
+		*    All Notes Off (CC 123),
+		*  - Web Audio ramps never target zero exponentially and every oscillator is
+		*    explicitly stopped.
 		*
 		* @module @jxgame2020/dsh-token-quota/music
 		*/
-		/** Scale degrees in semitones from the root. */
+		/** Scale degrees in semitones from the (current) tonic. */
 		const SCALES = {
 			major: [
 				0,
@@ -1277,10 +1282,11 @@ window.__ModuleLoader__.load({
 			]
 		};
 		/**
-		* Chord progression roots in semitones from the key centre. Loops — every
-		* step advance moves one position forward.
+		* Tonic offsets for the progression — the piece rotates its mode centre on
+		* every step advance. For pentatonic this is 宫 → 羽 → 徵 → 商 (mode
+		* rotation on one scale), which is the classic gufeng colour.
 		*/
-		const CHORD_PROGRESSIONS = {
+		const PROGRESSION = {
 			major: [
 				0,
 				9,
@@ -1289,56 +1295,189 @@ window.__ModuleLoader__.load({
 			],
 			minor: [
 				0,
-				9,
-				4,
-				11
+				8,
+				3,
+				10
 			],
 			pentatonic: [
 				0,
+				9,
 				7,
-				2,
-				9
+				5
 			]
 		};
-		const CHORD_QUALITIES = {
-			major: [
-				"major",
-				"minor",
-				"major",
-				"major"
+		/**
+		* Phrase bank — pentatonic-degree melodies that also read fine on 7-note
+		* scales. Degrees index the current scale (values ≥ scale length wrap up an
+		* octave).
+		*/
+		const PHRASES = [
+			[
+				{
+					deg: 0,
+					beats: 2
+				},
+				{
+					deg: 1,
+					beats: 1
+				},
+				{
+					deg: 2,
+					beats: 1
+				},
+				{
+					deg: 3,
+					beats: 2
+				},
+				{
+					deg: 2,
+					beats: 1
+				},
+				{
+					deg: 1,
+					beats: 1
+				},
+				{
+					deg: 0,
+					beats: 3
+				}
 			],
-			minor: [
-				"minor",
-				"major",
-				"major",
-				"major"
+			[
+				{
+					deg: 5,
+					beats: 1
+				},
+				{
+					deg: 4,
+					beats: 1
+				},
+				{
+					deg: 3,
+					beats: 2
+				},
+				{
+					deg: 2,
+					beats: 1
+				},
+				{
+					deg: 1,
+					beats: 2
+				},
+				{
+					deg: 0,
+					beats: 3
+				}
 			],
-			pentatonic: [
-				"major",
-				"major",
-				"major",
-				"major"
+			[
+				{
+					deg: 2,
+					beats: 1
+				},
+				{
+					deg: 3,
+					beats: 1
+				},
+				{
+					deg: 4,
+					beats: 2
+				},
+				{
+					deg: 5,
+					beats: 1
+				},
+				{
+					deg: 4,
+					beats: 1
+				},
+				{
+					deg: 3,
+					beats: 2
+				},
+				{
+					deg: 1,
+					beats: 2
+				},
+				{
+					deg: 0,
+					beats: 2
+				}
+			],
+			[
+				{
+					deg: 4,
+					beats: 2
+				},
+				{
+					deg: 3,
+					beats: 1
+				},
+				{
+					deg: 2,
+					beats: 1
+				},
+				{
+					deg: 3,
+					beats: 2
+				},
+				{
+					deg: 1,
+					beats: 1
+				},
+				{
+					deg: 2,
+					beats: 1
+				},
+				{
+					deg: 0,
+					beats: 4
+				}
 			]
-		};
+		];
+		/** 过门 — a fast run played when a step (new phase) starts. */
+		const FILL = [
+			{
+				deg: 0,
+				beats: .5
+			},
+			{
+				deg: 1,
+				beats: .5
+			},
+			{
+				deg: 2,
+				beats: .5
+			},
+			{
+				deg: 3,
+				beats: .5
+			},
+			{
+				deg: 4,
+				beats: .5
+			},
+			{
+				deg: 5,
+				beats: .5
+			},
+			{
+				deg: 4,
+				beats: .5
+			},
+			{
+				deg: 3,
+				beats: .5
+			}
+		];
 		/** Turn a MIDI note number into a frequency (equal temperament, A4 = 440). */
 		function midiToFreq(midi) {
 			return 440 * Math.pow(2, (midi - 69) / 12);
 		}
-		/** Interval in semitones from the root for each chord-tone. */
-		function chordIntervals(quality) {
-			return [
-				0,
-				quality === "major" ? 4 : quality === "minor" ? 3 : 3,
-				quality === "dim" ? 6 : 7
-			];
-		}
+		/** General-MIDI program closest to a guzheng: 108 Koto (0-indexed 106). */
+		const GM_PROGRAM_KOTO = 106;
 		/**
-		* Live-composed music engine driven by host actions.
-		*
-		* The engine is idle until `ensureStarted()` is called from a user gesture
-		* (the panel switch), and only produces sound while `enabled` is true AND a
-		* request is in flight (pad + bass + melody are gated by `startPad` /
-		* `stopPad`).
+		* Live-composed gufeng engine. Idle until `ensureStarted()` runs inside a
+		* user gesture; silent while `enabled` is false; the piece runs only between
+		* `request/header` (start) and `assistant/message` / `turn/end` (stop).
 		*/
 		var TokenQuotaMusic = class TokenQuotaMusic {
 			audio = null;
@@ -1346,32 +1485,31 @@ window.__ModuleLoader__.load({
 			midiDetected = false;
 			enabled = false;
 			volume = .5;
-			style = "major";
-			chordIndex = 0;
-			stepCount = 0;
-			toolCount = 0;
-			padOscs = [];
-			padGain = null;
-			padTarget = 0;
-			padActive = false;
-			beatTimer;
-			beatIndex = 0;
-			melodyDirection = 1;
-			melodyDegree = 0;
-			currentRoot = 60;
-			currentQuality = "major";
-			/** Base MIDI note of the key. C4 = middle C. */
+			style = "pentatonic";
+			playing = false;
+			tonicIndex = 0;
+			phraseIndex = 0;
+			phraseTimer;
+			droneOscs = [];
+			droneGain = null;
+			droneFilter = null;
+			droneActive = false;
+			lastStreamActivity = 0;
+			watchdogTimer;
+			activeMidiNotes = /* @__PURE__ */ new Set();
+			/** Base MIDI note of the tonic. C4 = middle C. */
 			static BASE_MIDI = 60;
-			/** Beat length in ms — eighth note = beat / 2. */
-			static BEAT_MS = 640;
+			/** Beat length in ms — the phrase rhythm is measured in these. */
+			static BEAT_MS = 480;
+			/** Stop everything if the SSE stream goes silent this long. */
+			static STREAM_TIMEOUT_MS = 12e3;
 			/** 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.
+			* Start the audio context and probe for a MIDI output (once). Must be
+			* called inside a user gesture so the AudioContext can resume.
 			*/
 			async ensureStarted() {
 				if (this.audio !== null) return true;
@@ -1391,10 +1529,19 @@ window.__ModuleLoader__.load({
 							this.midiOutput = output;
 							break;
 						}
+						try {
+							this.midiOutput?.send([192, GM_PROGRAM_KOTO]);
+						} catch {}
 					} catch {
 						this.midiOutput = null;
 					}
 				}
+				if (this.watchdogTimer === void 0) {
+					this.lastStreamActivity = Date.now();
+					this.watchdogTimer = setInterval(() => {
+						if (this.playing && Date.now() - this.lastStreamActivity > TokenQuotaMusic.STREAM_TIMEOUT_MS) this.stopPiece(false);
+					}, 4e3);
+				}
 				return true;
 			}
 			setEnabled(value) {
@@ -1403,121 +1550,196 @@ window.__ModuleLoader__.load({
 			}
 			setVolume(value) {
 				this.volume = Math.max(0, Math.min(1, value));
-				if (this.padGain !== null && this.audio !== null) this.padGain.gain.setValueAtTime(this.volume * this.padTarget, this.audio.currentTime);
 			}
 			setStyle(value) {
 				this.style = value;
-				this.melodyDegree = 0;
-				this.melodyDirection = 1;
 			}
-			/** Handle one incoming host action and turn it into sound. */
+			/** Feed the engine one SSE activity timestamp (action or heartbeat). */
+			markStreamActivity() {
+				this.lastStreamActivity = Date.now();
+			}
+			/** Handle one incoming host action and steer the piece. */
 			onAction(action) {
 				if (!this.enabled || this.audio === null) return;
 				const base = TokenQuotaMusic.BASE_MIDI;
 				switch (action.type) {
 					case "turn/start":
-						this.stopAll();
-						this.chordIndex = 0;
-						this.stepCount = 0;
-						this.toolCount = 0;
-						this.currentRoot = base;
-						this.currentQuality = CHORD_QUALITIES[this.style][0] ?? "major";
-						this.playChord(base, this.currentQuality, 1.6, .6);
+						this.stopPiece(false);
+						this.tonicIndex = 0;
+						this.phraseIndex = 0;
 						break;
-					case "step/start": {
-						this.chordIndex = (this.chordIndex + 1) % CHORD_PROGRESSIONS[this.style].length;
-						this.stepCount += 1;
-						const root = base + (CHORD_PROGRESSIONS[this.style][this.chordIndex] ?? 0);
-						const quality = CHORD_QUALITIES[this.style][this.chordIndex] ?? "major";
-						this.currentRoot = root;
-						this.currentQuality = quality;
-						if (this.padActive) this.crossfadePad(root, quality);
+					case "request/header":
+						if (!this.playing) this.startPiece();
+						else this.pluck(base + 24, .3);
 						break;
-					}
-					case "request/header": {
-						this.startPad(this.currentRoot, this.currentQuality);
-						this.startBeatClock();
-						const degree = (this.stepCount * 2 + this.toolCount) % SCALES[this.style].length;
-						const note = base + 12 + (SCALES[this.style][degree] ?? 0);
-						this.playNote(note, .25, .4);
+					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);
 						break;
 					}
 					case "tool/call":
-						this.toolCount += 1;
-						this.playNote(base + 24 + this.toolCount % 3 * 2, .12, .45);
-						this.playNote(base - 12, .08, .3);
+						this.pluck(base + 26, .45, .5);
+						this.pluck(base - 12, .3, .35);
 						break;
 					case "tool/result":
 						if (action.error) {
-							this.playNote(base + 13, .18, .4);
-							setTimeout(() => this.playNote(base + 12, .25, .4), 90);
+							this.pluck(base + 13, .4, .6);
+							setTimeout(() => this.pluck(base + 12, .4, .9), 90);
 						} else {
-							this.playNote(base + 9, .14, .35);
-							setTimeout(() => this.playNote(base + 11, .22, .35), 70);
+							this.pluck(base + 9, .35, .6);
+							setTimeout(() => this.pluck(base + 11, .35, .9), 70);
 						}
 						break;
 					case "assistant/attempt":
-						this.playNote(base + 8, .18, .4);
-						setTimeout(() => this.playNote(base + 7, .2, .4), 100);
-						setTimeout(() => this.playNote(base + 5, .3, .4), 200);
+						this.pluck(base + 8, .4, .8);
+						setTimeout(() => this.pluck(base + 7, .4, .8), 110);
+						setTimeout(() => this.pluck(base + 5, .4, .8), 220);
 						break;
 					case "assistant/message":
-						this.stopBeatClock();
-						this.stopPad();
-						if (action.interrupted) this.playChord(base + 7, "dim", .9, .55);
-						else this.playChord(this.currentRoot, this.currentQuality, 1.1, .6);
+						this.stopMelody();
+						this.breath(action.interrupted ? base + 6 : base + 12, 1.6);
 						break;
 					case "turn/end":
-						this.stopAll();
-						this.playChord(base, this.style === "minor" ? "minor" : "major", 2.4, .7);
-						this.chordIndex = 0;
+						this.stopPiece(true);
 						break;
 				}
 			}
-			/** Start the pad from silence, fading in to the target level. */
-			startPad(rootMidi, quality) {
+			/** Start a new piece: drone + ascending glissando + 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 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;
+				}
+				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];
+				const phrase = PHRASES[this.phraseIndex % PHRASES.length];
+				this.phraseIndex += 1;
+				let t = 0;
+				for (const step of phrase) {
+					const note = root + (scale[step.deg % scale.length] ?? 0) + 12 * Math.floor(step.deg / scale.length);
+					setTimeout(() => {
+						if (this.playing) this.pluck(note, .34);
+					}, t);
+					t += step.beats * TokenQuotaMusic.BEAT_MS;
+				}
+				this.phraseTimer = setTimeout(() => this.playPhrase(), t + TokenQuotaMusic.BEAT_MS);
+			}
+			/** Insert a 过门 fill: pause the chain, play the run, resume after. */
+			insertFill(root) {
 				if (!this.audio) return;
-				if (this.padActive) return;
+				this.stopMelody();
+				const scale = SCALES[this.style];
+				let t = 0;
+				for (const step of FILL) {
+					const note = root + (scale[step.deg % scale.length] ?? 0) + 12 * Math.floor(step.deg / scale.length);
+					setTimeout(() => {
+						if (this.playing) this.pluck(note, .32, .7);
+					}, t);
+					t += step.beats * TokenQuotaMusic.BEAT_MS;
+				}
+				this.phraseTimer = setTimeout(() => this.playPhrase(), t + 60);
+			}
+			/** Stop the melody chain (drone keeps fading naturally). */
+			stopMelody() {
+				if (this.phraseTimer !== void 0) {
+					clearTimeout(this.phraseTimer);
+					this.phraseTimer = void 0;
+				}
+			}
+			/** Stop the whole piece; `final` adds the closing cadence gestures. */
+			stopPiece(final) {
+				this.stopMelody();
+				this.playing = false;
+				if (final && this.audio) {
+					const base = TokenQuotaMusic.BASE_MIDI;
+					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);
+						setTimeout(() => this.pluck(note, .3), t);
+						t += 120;
+					}
+					setTimeout(() => {
+						this.pluck(base, .5);
+						this.pluck(base + 7, .45);
+						this.pluck(base + 12, .4);
+						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);
-				gain.connect(this.audio.destination);
-				const intervals = chordIntervals(quality);
+				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 intervals) {
+				for (const interval of [-12, -5]) {
 					const osc = this.audio.createOscillator();
-					osc.type = "triangle";
-					osc.frequency.value = midiToFreq(rootMidi + interval);
+					osc.type = "sine";
+					osc.frequency.value = midiToFreq(root + interval);
 					osc.connect(gain);
 					osc.start(now);
 					oscs.push(osc);
 				}
-				this.padOscs = oscs;
-				this.padGain = gain;
-				this.padTarget = .18;
-				gain.gain.linearRampToValueAtTime(this.volume * this.padTarget, now + .6);
-				this.padActive = true;
+				this.droneOscs = oscs;
+				this.droneGain = gain;
+				this.droneFilter = filter;
+				this.droneActive = true;
+				gain.gain.linearRampToValueAtTime(this.volume * .07, now + 1.4);
 			}
-			/** Smoothly morph the pad to a new root + quality. */
-			crossfadePad(rootMidi, quality) {
-				if (!this.audio || !this.padActive || this.padGain === null) return;
+			/** Glide the drone to a new tonic (mode rotation). */
+			glideDrone(root) {
+				if (!this.audio || !this.droneActive) return;
 				const now = this.audio.currentTime;
-				const intervals = chordIntervals(quality);
-				this.padOscs.forEach((osc, i) => {
-					const interval = intervals[i] ?? 0;
+				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(rootMidi + interval), now + .5);
+					osc.frequency.exponentialRampToValueAtTime(midiToFreq(target), now + .9);
 				});
 			}
-			/** Fade the pad to silence, then stop the oscillators. */
-			stopPad() {
-				if (!this.audio || !this.padActive || this.padGain === null) return;
+			/** 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.padGain;
+				const gain = this.droneGain;
 				gain.gain.cancelScheduledValues(now);
-				gain.gain.setValueAtTime(gain.gain.value, now);
-				gain.gain.linearRampToValueAtTime(0, now + .8);
-				const oscs = this.padOscs;
+				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 {
@@ -1527,98 +1749,129 @@ window.__ModuleLoader__.load({
 							osc.disconnect();
 						} catch {}
 					}
+					try {
+						filter?.disconnect();
+					} catch {}
 					try {
 						gain.disconnect();
 					} catch {}
-				}, 850);
-				this.padActive = false;
-				this.padOscs = [];
-				this.padGain = null;
-			}
-			/** Start the per-beat clock that drives bass and melody. */
-			startBeatClock() {
-				if (this.beatTimer !== void 0) return;
-				this.beatIndex = 0;
-				this.melodyDegree = 0;
-				this.melodyDirection = 1;
-				const tick = () => {
-					if (!this.audio || !this.enabled) return;
-					if (this.beatIndex % 2 === 0) this.playNote(this.currentRoot - 12, .45, .3);
-					const scale = SCALES[this.style];
-					const chordTones = new Set(chordIntervals(this.currentQuality));
-					let degree = this.melodyDegree;
-					let next = degree + this.melodyDirection;
-					if (next >= scale.length) {
-						this.melodyDirection = -1;
-						next = scale.length - 2;
-					} else if (next < 0) {
-						this.melodyDirection = 1;
-						next = 0;
-					}
-					this.melodyDegree = next;
-					degree = next;
-					if (this.beatIndex % 2 === 0) {
-						const rootRel = (scale[degree] ?? 0) % 12;
-						if (!chordTones.has(rootRel)) {
-							this.melodyDegree += this.melodyDirection;
-							degree = this.melodyDegree;
-						}
-					}
-					const note = this.currentRoot + 12 + (scale[degree] ?? 0);
-					this.playNote(note, .22, .28);
-					this.beatIndex = (this.beatIndex + 1) % 4;
-				};
-				tick();
-				this.beatTimer = setInterval(tick, TokenQuotaMusic.BEAT_MS);
+				}, seconds * 1e3 + 120);
+				this.droneActive = false;
+				this.droneOscs = [];
+				this.droneGain = null;
+				this.droneFilter = null;
 			}
-			stopBeatClock() {
-				if (this.beatTimer !== void 0) {
-					clearInterval(this.beatTimer);
-					this.beatTimer = void 0;
-				}
-			}
-			stopAll() {
-				this.stopBeatClock();
-				this.stopPad();
+			/**
+			* 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).
+			*/
+			pluck(midi, velocity, decaySec = 1.3) {
+				if (!this.audio) return;
+				const peak = this.volume * velocity * .4;
+				if (peak <= 0) return;
+				const now = this.audio.currentTime;
+				const freq = midiToFreq(midi);
+				const gain = this.audio.createGain();
+				const filter = this.audio.createBiquadFilter();
+				filter.type = "lowpass";
+				filter.frequency.setValueAtTime(2400, now);
+				filter.frequency.exponentialRampToValueAtTime(420, now + decaySec);
+				filter.Q.value = .6;
+				gain.gain.setValueAtTime(1e-4, now);
+				gain.gain.exponentialRampToValueAtTime(peak, now + .006);
+				gain.gain.exponentialRampToValueAtTime(1e-4, now + decaySec);
+				filter.connect(gain);
+				gain.connect(this.audio.destination);
+				const osc1 = this.audio.createOscillator();
+				osc1.type = "triangle";
+				osc1.frequency.value = freq;
+				const osc2 = this.audio.createOscillator();
+				osc2.type = "sine";
+				osc2.frequency.value = freq * 2.001;
+				const octGain = this.audio.createGain();
+				octGain.gain.value = .35;
+				osc1.connect(filter);
+				osc2.connect(octGain);
+				octGain.connect(filter);
+				osc1.start(now);
+				osc1.stop(now + decaySec + .1);
+				osc2.start(now);
+				osc2.stop(now + decaySec + .1);
+				this.midiNote(midi, decaySec, velocity);
 			}
-			/** Play one note: Web Audio + MIDI simultaneously when available. */
-			playNote(midi, durationSec, velocity) {
+			/** Dizi-like breath note: sine with vibrato and a soft envelope. */
+			breath(midi, durationSec) {
 				if (!this.audio) return;
-				const peak = this.volume * velocity * .5;
+				const peak = this.volume * .22;
 				if (peak <= 0) return;
 				const now = this.audio.currentTime;
 				const osc = this.audio.createOscillator();
 				osc.type = "sine";
 				osc.frequency.value = midiToFreq(midi);
+				const lfo = this.audio.createOscillator();
+				lfo.frequency.value = 5.2;
+				const lfoGain = this.audio.createGain();
+				lfoGain.gain.value = 4.5;
+				lfo.connect(lfoGain);
+				lfoGain.connect(osc.frequency);
 				const gain = this.audio.createGain();
 				gain.gain.setValueAtTime(0, now);
-				gain.gain.linearRampToValueAtTime(peak, now + .008);
-				gain.gain.exponentialRampToValueAtTime(.001, now + durationSec);
+				gain.gain.linearRampToValueAtTime(peak, now + .18);
+				gain.gain.setValueAtTime(peak, now + durationSec * .6);
+				gain.gain.linearRampToValueAtTime(1e-4, now + durationSec);
 				osc.connect(gain);
 				gain.connect(this.audio.destination);
 				osc.start(now);
-				osc.stop(now + durationSec + .05);
-				if (this.midiOutput !== null) {
-					const vel = Math.max(1, Math.floor(velocity * 127));
+				lfo.start(now);
+				osc.stop(now + durationSec + .1);
+				lfo.stop(now + durationSec + .1);
+				this.midiNote(midi, durationSec, .5);
+			}
+			/** Send one MIDI note with a registered NoteOff (anti hanging note). */
+			midiNote(midi, durationSec, velocity) {
+				if (this.midiOutput === null) return;
+				const note = midi & 127;
+				const vel = Math.max(1, Math.min(127, Math.floor(velocity * 127)));
+				try {
 					this.midiOutput.send([
 						144,
-						midi & 127,
+						note,
 						vel
 					]);
-					setTimeout(() => {
+				} catch {
+					return;
+				}
+				this.activeMidiNotes.add(note);
+				setTimeout(() => {
+					try {
 						this.midiOutput?.send([
 							128,
-							midi & 127,
+							note,
 							0
 						]);
-					}, durationSec * 1e3);
-				}
+					} catch {}
+					this.activeMidiNotes.delete(note);
+				}, Math.max(80, durationSec * 1e3));
 			}
-			/** Play a three-note chord plus a bass octave below. */
-			playChord(rootMidi, quality, durationSec, velocity) {
-				const intervals = chordIntervals(quality);
-				for (const interval of intervals) this.playNote(rootMidi + interval, durationSec, velocity * .45);
-				this.playNote(rootMidi - 12, durationSec * 1.1, velocity * .5);
+			/** Silence every registered note and send All Notes Off. */
+			allMidiOff() {
+				if (this.midiOutput === null) return;
+				for (const note of this.activeMidiNotes) try {
+					this.midiOutput.send([
+						128,
+						note,
+						0
+					]);
+				} catch {}
+				this.activeMidiNotes.clear();
+				try {
+					this.midiOutput.send([
+						176,
+						123,
+						0
+					]);
+				} catch {}
 			}
 		};
 		//#endregion
@@ -1697,7 +1950,7 @@ window.__ModuleLoader__.load({
 			musicStyle: "风格",
 			musicStyleMajor: "大调",
 			musicStyleMinor: "小调",
-			musicStylePentatonic: "五声",
+			musicStylePentatonic: "古风",
 			musicOnlyCurrentSessionLabel: "只播当前会话",
 			musicOnlyCurrentSessionHint: "开启后仅当前窗口的会话有音乐，后台子任务静音；关闭则所有会话都参与作曲",
 			checkUpdatesNow: "立即检查",
@@ -1773,7 +2026,7 @@ window.__ModuleLoader__.load({
 			musicStyle: "Style",
 			musicStyleMajor: "Major",
 			musicStyleMinor: "Minor",
-			musicStylePentatonic: "Pentatonic",
+			musicStylePentatonic: "Gufeng",
 			musicOnlyCurrentSessionLabel: "Current session only",
 			musicOnlyCurrentSessionHint: "When on, only the visible session drives the soundtrack (background tasks stay silent); when off, every session contributes.",
 			checkUpdatesNow: "Check now",
@@ -1823,6 +2076,12 @@ window.__ModuleLoader__.load({
 			let lastOnlyCurrentSession = true;
 			const music = new TokenQuotaMusic();
 			const sse = new EventSource("/token-quota/events");
+			sse.addEventListener("hb", () => {
+				music.markStreamActivity();
+			});
+			sse.addEventListener("open", () => {
+				music.markStreamActivity();
+			});
 			sse.addEventListener("action", (event) => {
 				let action;
 				try {
@@ -1840,7 +2099,7 @@ window.__ModuleLoader__.load({
 			const musicDefaults = (raw) => ({
 				enabled: raw?.enabled ?? false,
 				volume: raw?.volume ?? .5,
-				style: raw?.style ?? "major",
+				style: raw?.style ?? "pentatonic",
 				onlyCurrentSession: raw?.onlyCurrentSession ?? true
 			});
 			const keyOf = (selection) => {