@jxgame2020/dsh-token-quota 0.1.24 → 0.1.27

package/lib/client.js

@@ -39,7 +39,8 @@ window.__ModuleLoader__.load({
 					dimWhenIdle: false,
 					musicEnabled: false,
 					musicVolume: .5,
-					musicStyle: "major",
+					musicStyle: "pentatonic",
+					musicOnlyCurrentSession: true,
 					upgrade: null,
 					upgradeDismissed: false,
 					checkingUpdates: false,
@@ -90,8 +91,11 @@ window.__ModuleLoader__.load({
 					setMusicStyle: (d, style) => {
 						d.musicStyle = style;
 					},
+					setMusicOnlyCurrentSession: (d, only) => {
+						d.musicOnlyCurrentSession = only;
+					},
 					setUpgrade: (d, upgrade) => {
-						const normalized = upgrade !== null && upgrade.latestVersion !== "" && upgrade.latestVersion !== "0.1.24" ? 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;
 					},
@@ -197,92 +201,92 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var TokenQuotaPanel_module_css_default = {
-			"dialogBtn": "NPLLIq_dialogBtn",
-			"currentBadge": "NPLLIq_currentBadge",
-			"panelDim": "NPLLIq_panelDim",
-			"row": "NPLLIq_row",
-			"controls": "NPLLIq_controls",
-			"logSearch": "NPLLIq_logSearch",
-			"logPagerControls": "NPLLIq_logPagerControls",
-			"logModelCol": "NPLLIq_logModelCol",
-			"logUsedCol": "NPLLIq_logUsedCol",
+			"bar": "NPLLIq_bar",
+			"tab": "NPLLIq_tab",
+			"rowHeader": "NPLLIq_rowHeader",
 			"logTable": "NPLLIq_logTable",
-			"checkUpdatesRow": "NPLLIq_checkUpdatesRow",
-			"resetRow": "NPLLIq_resetRow",
+			"logPagerInfo": "NPLLIq_logPagerInfo",
+			"copyBtn": "NPLLIq_copyBtn",
+			"dialogBody": "NPLLIq_dialogBody",
+			"logClearDialog": "NPLLIq_logClearDialog",
+			"input": "NPLLIq_input",
+			"monitorHint": "NPLLIq_monitorHint",
 			"monitorName": "NPLLIq_monitorName",
-			"resetSelect": "NPLLIq_resetSelect",
-			"settingsBtnActive": "NPLLIq_settingsBtnActive",
-			"upgradeBannerText": "NPLLIq_upgradeBannerText",
-			"upgradeClose": "NPLLIq_upgradeClose",
-			"fullNotice": "NPLLIq_fullNotice",
-			"radioRow": "NPLLIq_radioRow",
-			"dialogHint": "NPLLIq_dialogHint",
-			"rowHeader": "NPLLIq_rowHeader",
-			"dialogClose": "NPLLIq_dialogClose",
-			"selectBtn": "NPLLIq_selectBtn",
-			"upgradeCommands": "NPLLIq_upgradeCommands",
+			"checkErrorHint": "NPLLIq_checkErrorHint",
 			"fillWarn": "NPLLIq_fillWarn",
-			"upgradeCommand": "NPLLIq_upgradeCommand",
-			"checkBtn": "NPLLIq_checkBtn",
-			"dialog": "NPLLIq_dialog",
-			"logDayCol": "NPLLIq_logDayCol",
-			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
-			"logPager": "NPLLIq_logPager",
-			"dialogOverlay": "NPLLIq_dialogOverlay",
-			"dialogSection": "NPLLIq_dialogSection",
-			"logClearDialog": "NPLLIq_logClearDialog",
-			"headerText": "NPLLIq_headerText",
-			"notice": "NPLLIq_notice",
-			"tabLabel": "NPLLIq_tabLabel",
-			"dialogActions": "NPLLIq_dialogActions",
+			"dialogBtn": "NPLLIq_dialogBtn",
+			"logModelCol": "NPLLIq_logModelCol",
+			"fullNotice": "NPLLIq_fullNotice",
+			"logPagerPages": "NPLLIq_logPagerPages",
 			"subtitle": "NPLLIq_subtitle",
+			"upgradeClose": "NPLLIq_upgradeClose",
 			"logClearDate": "NPLLIq_logClearDate",
-			"headerActions": "NPLLIq_headerActions",
-			"dialogTitle": "NPLLIq_dialogTitle",
-			"logClearBtn": "NPLLIq_logClearBtn",
-			"dialogBody": "NPLLIq_dialogBody",
-			"title": "NPLLIq_title",
-			"upgradeHint": "NPLLIq_upgradeHint",
-			"version": "NPLLIq_version",
-			"body": "NPLLIq_body",
-			"logPagerPages": "NPLLIq_logPagerPages",
-			"monitorList": "NPLLIq_monitorList",
+			"row": "NPLLIq_row",
 			"logHeader": "NPLLIq_logHeader",
-			"copyBtnDone": "NPLLIq_copyBtnDone",
-			"tab": "NPLLIq_tab",
-			"monitorHint": "NPLLIq_monitorHint",
-			"settingsBtn": "NPLLIq_settingsBtn",
-			"panelDimStrong": "NPLLIq_panelDimStrong",
-			"logToolbar": "NPLLIq_logToolbar",
-			"logPagerInfo": "NPLLIq_logPagerInfo",
-			"logScroll": "NPLLIq_logScroll",
-			"checkErrorHint": "NPLLIq_checkErrorHint",
+			"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",
-			"logPageSizeSelect": "NPLLIq_logPageSizeSelect",
-			"bar": "NPLLIq_bar",
-			"input": "NPLLIq_input",
+			"logClearBtn": "NPLLIq_logClearBtn",
+			"noticeError": "NPLLIq_noticeError",
+			"logUsedCol": "NPLLIq_logUsedCol",
+			"panelDim": "NPLLIq_panelDim",
+			"body": "NPLLIq_body",
+			"dialogClose": "NPLLIq_dialogClose",
+			"selectBtn": "NPLLIq_selectBtn",
+			"dialogOverlay": "NPLLIq_dialogOverlay",
+			"header": "NPLLIq_header",
+			"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",
-			"tabIcon": "NPLLIq_tabIcon",
-			"upgradeBanner": "NPLLIq_upgradeBanner",
-			"noticeError": "NPLLIq_noticeError",
+			"logPageSizeSelect": "NPLLIq_logPageSizeSelect",
+			"dialogHint": "NPLLIq_dialogHint",
+			"versionNew": "NPLLIq_versionNew",
+			"save": "NPLLIq_save",
 			"upgradeBannerFlash": "NPLLIq_upgradeBannerFlash",
-			"copyBtn": "NPLLIq_copyBtn",
 			"switch": "NPLLIq_switch",
-			"collapse": "NPLLIq_collapse",
+			"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",
 			"monitorRow": "NPLLIq_monitorRow",
-			"dialogLabel": "NPLLIq_dialogLabel",
-			"fillOver": "NPLLIq_fillOver",
-			"versionNew": "NPLLIq_versionNew",
+			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
+			"upgradeCommands": "NPLLIq_upgradeCommands",
+			"checkUpdatesRow": "NPLLIq_checkUpdatesRow",
+			"logPager": "NPLLIq_logPager",
+			"logPagerControls": "NPLLIq_logPagerControls",
+			"logDialog": "NPLLIq_logDialog",
 			"rowName": "NPLLIq_rowName",
-			"save": "NPLLIq_save",
-			"upgradeCommandRow": "NPLLIq_upgradeCommandRow",
+			"monitorList": "NPLLIq_monitorList",
+			"resetRow": "NPLLIq_resetRow",
+			"title": "NPLLIq_title",
+			"version": "NPLLIq_version",
+			"tabLabel": "NPLLIq_tabLabel",
+			"notice": "NPLLIq_notice",
+			"upgradeCommand": "NPLLIq_upgradeCommand",
 			"fillIdle": "NPLLIq_fillIdle",
-			"dialogHeader": "NPLLIq_dialogHeader",
-			"logDialog": "NPLLIq_logDialog",
-			"checkUpdatesLabel": "NPLLIq_checkUpdatesLabel",
-			"header": "NPLLIq_header"
+			"controls": "NPLLIq_controls"
 		};
 		//#endregion
 		//#region lib/types/client/TokenQuotaPanel.js
@@ -369,7 +373,7 @@ window.__ModuleLoader__.load({
 		* @param props - composed slot props.
 		* @returns the panel element tree.
 		*/
-		function TokenQuotaPanel({ t, load, setLimit, selectModel, setMonitored, setOnFull, setReset, setCheckUpdates, checkUpdatesNow, clearLogBefore, setDimWhenIdle, setMusicEnabled, setMusicVolume, setMusicStyle, useStore, actions, useSessions }) {
+		function TokenQuotaPanel({ t, load, setLimit, selectModel, setMonitored, setOnFull, setReset, setCheckUpdates, checkUpdatesNow, clearLogBefore, setDimWhenIdle, setMusicEnabled, setMusicVolume, setMusicStyle, setMusicOnlyCurrentSession, useStore, actions, useSessions }) {
 			const [collapsed, setCollapsed] = (0, react.useState)(false);
 			const [drafts, setDrafts] = (0, react.useState)({});
 			const [editingKey, setEditingKey] = (0, react.useState)(null);
@@ -403,6 +407,7 @@ window.__ModuleLoader__.load({
 			const musicEnabled = useStore((s) => s.musicEnabled);
 			const musicVolume = useStore((s) => s.musicVolume);
 			const musicStyle = useStore((s) => s.musicStyle);
+			const musicOnlyCurrentSession = useStore((s) => s.musicOnlyCurrentSession);
 			const upgrade = useStore((s) => s.upgrade);
 			const upgradeDismissed = useStore((s) => s.upgradeDismissed);
 			const checkingUpdates = useStore((s) => s.checkingUpdates);
@@ -587,13 +592,13 @@ window.__ModuleLoader__.load({
 									title: t("upgradeAvailableHint"),
 									children: [
 										"v",
-										"0.1.24",
+										"0.1.27",
 										" → v",
 										upgrade.latestVersion
 									]
 								}) : (0, react_jsx_runtime.jsxs)("span", {
 									className: TokenQuotaPanel_module_css_default.version,
-									children: ["v", "0.1.24"]
+									children: ["v", "0.1.27"]
 								})]
 							}), (0, react_jsx_runtime.jsx)("div", {
 								className: TokenQuotaPanel_module_css_default.subtitle,
@@ -956,41 +961,58 @@ window.__ModuleLoader__.load({
 										className: TokenQuotaPanel_module_css_default.dialogHint,
 										children: t("musicHint")
 									}),
-									musicEnabled && (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [(0, react_jsx_runtime.jsxs)("label", {
-										className: TokenQuotaPanel_module_css_default.checkUpdatesLabel,
-										children: [(0, react_jsx_runtime.jsx)("span", { children: t("musicVolume") }), (0, react_jsx_runtime.jsx)("input", {
-											type: "range",
-											min: 0,
-											max: 1,
-											step: .05,
-											value: musicVolume,
-											onChange: (event) => {
-												setMusicVolume(Number(event.target.value));
-											}
-										})]
-									}), (0, react_jsx_runtime.jsxs)("label", {
-										className: TokenQuotaPanel_module_css_default.checkUpdatesLabel,
-										children: [(0, react_jsx_runtime.jsx)("span", { children: t("musicStyle") }), (0, react_jsx_runtime.jsxs)("select", {
-											value: musicStyle,
-											onChange: (event) => {
-												setMusicStyle(event.target.value);
-											},
-											children: [
-												(0, react_jsx_runtime.jsx)("option", {
-													value: "major",
-													children: t("musicStyleMajor")
-												}),
-												(0, react_jsx_runtime.jsx)("option", {
-													value: "minor",
-													children: t("musicStyleMinor")
-												}),
-												(0, react_jsx_runtime.jsx)("option", {
-													value: "pentatonic",
-													children: t("musicStylePentatonic")
-												})
-											]
-										})]
-									})] })
+									musicEnabled && (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+										(0, react_jsx_runtime.jsxs)("label", {
+											className: TokenQuotaPanel_module_css_default.checkUpdatesLabel,
+											children: [(0, react_jsx_runtime.jsx)("span", { children: t("musicVolume") }), (0, react_jsx_runtime.jsx)("input", {
+												type: "range",
+												min: 0,
+												max: 1,
+												step: .05,
+												value: musicVolume,
+												onChange: (event) => {
+													setMusicVolume(Number(event.target.value));
+												}
+											})]
+										}),
+										(0, react_jsx_runtime.jsxs)("label", {
+											className: TokenQuotaPanel_module_css_default.checkUpdatesLabel,
+											children: [(0, react_jsx_runtime.jsx)("span", { children: t("musicStyle") }), (0, react_jsx_runtime.jsxs)("select", {
+												value: musicStyle,
+												onChange: (event) => {
+													setMusicStyle(event.target.value);
+												},
+												children: [
+													(0, react_jsx_runtime.jsx)("option", {
+														value: "major",
+														children: t("musicStyleMajor")
+													}),
+													(0, react_jsx_runtime.jsx)("option", {
+														value: "minor",
+														children: t("musicStyleMinor")
+													}),
+													(0, react_jsx_runtime.jsx)("option", {
+														value: "pentatonic",
+														children: t("musicStylePentatonic")
+													})
+												]
+											})]
+										}),
+										(0, react_jsx_runtime.jsxs)("label", {
+											className: TokenQuotaPanel_module_css_default.checkUpdatesLabel,
+											children: [(0, react_jsx_runtime.jsx)("input", {
+												type: "checkbox",
+												checked: musicOnlyCurrentSession,
+												onChange: (event) => {
+													setMusicOnlyCurrentSession(event.target.checked);
+												}
+											}), (0, react_jsx_runtime.jsx)("span", { children: t("musicOnlyCurrentSessionLabel") })]
+										}),
+										(0, react_jsx_runtime.jsx)("div", {
+											className: TokenQuotaPanel_module_css_default.dialogHint,
+											children: t("musicOnlyCurrentSessionHint")
+										})
+									] })
 								]
 							}),
 							(0, react_jsx_runtime.jsxs)("div", {
@@ -1210,20 +1232,28 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region lib/types/client/music.js
 		/**
-		* 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).
+		* 古风 live-composed soundtrack driven by host actions.
 		*
-		* 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.
+		* 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.
+		*
+		* 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,
@@ -1252,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,
@@ -1264,80 +1295,221 @@ 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
+				}
 			]
-		};
-		/**
-		* Turn a MIDI note number into a frequency (Hz) using equal temperament at
-		* A4 = 440 Hz.
-		*/
+		];
+		/** 过门 — 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);
 		}
-		/** Live-composed music engine driven by host actions. */
+		/** General-MIDI program closest to a guzheng: 108 Koto (0-indexed 106). */
+		const GM_PROGRAM_KOTO = 106;
+		/**
+		* 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;
 			midiOutput = null;
 			midiDetected = false;
 			enabled = false;
 			volume = .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;
-			/**
-			* Progress layer: while a request is in flight (thinking + streaming) the
-			* engine ticks a quiet scale-walking background note every tick so the wait
-			* is audible. Cleared on assistant/message, assistant/attempt or turn/end.
-			*/
-			progressTimer;
-			/** Direction of the progress walk: +1 up the scale, -1 down. */
-			progressDir = 1;
-			/** Scale degree of the next progress note. */
-			progressDegree = 0;
-			/** Base MIDI note of the current 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;
-			/** Tick interval of the progress layer (ms). */
-			static PROGRESS_TICK_MS = 750;
+			/** 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;
@@ -1357,15 +1529,24 @@ 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) {
 				this.enabled = value;
-				if (!value) this.stopProgress();
+				if (!value) this.stopAll();
 			}
 			setVolume(value) {
 				this.volume = Math.max(0, Math.min(1, value));
@@ -1373,164 +1554,324 @@ window.__ModuleLoader__.load({
 			setStyle(value) {
 				this.style = value;
 			}
-			/** Start the quiet in-flight background loop (idempotent). */
-			startProgress() {
-				if (!this.audio || !this.enabled) return;
-				if (this.progressTimer !== void 0) return;
-				this.progressDegree = 0;
-				this.progressDir = 1;
-				const tick = () => {
-					if (!this.audio || !this.enabled) return;
-					const scale = SCALES[this.style];
-					const degree = this.progressDegree % scale.length;
-					const note = TokenQuotaMusic.BASE_MIDI + 12 + (scale[degree] ?? 0);
-					this.playNote(note, .18, .22);
-					const next = this.progressDegree + this.progressDir;
-					if (next >= scale.length) {
-						this.progressDir = -1;
-						this.progressDegree = scale.length - 2;
-					} else if (next < 0) {
-						this.progressDir = 1;
-						this.progressDegree = 0;
-					} else this.progressDegree = next;
-				};
-				tick();
-				this.progressTimer = setInterval(tick, TokenQuotaMusic.PROGRESS_TICK_MS);
+			/** Feed the engine one SSE activity timestamp (action or heartbeat). */
+			markStreamActivity() {
+				this.lastStreamActivity = Date.now();
 			}
-			/** Stop the in-flight background loop. */
-			stopProgress() {
-				if (this.progressTimer !== void 0) {
-					clearInterval(this.progressTimer);
-					this.progressTimer = void 0;
-				}
-			}
-			/** Handle one incoming host action and turn it into sound. */
+			/** 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.stopProgress();
-						this.chordIndex = 0;
-						this.stepCount = 0;
-						this.toolCount = 0;
-						this.playChord(base, this.currentChordQuality(), 1.6, .55);
+						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;
-						this.playNote(this.currentChordRoot(base) - 12, 1.2, .35);
-						const root = this.currentChordRoot(base);
-						const [d1, d2, d3] = this.arpeggioDegrees();
-						setTimeout(() => this.playNote(root + d1, .2, .4), 0);
-						setTimeout(() => this.playNote(root + d2, .2, .4), 80);
-						setTimeout(() => this.playNote(root + d3, .35, .4), 160);
+					case "request/header":
+						if (!this.playing) this.startPiece();
+						else this.pluck(base + 24, .3);
 						break;
-					}
-					case "request/header": {
-						this.startProgress();
-						const degree = (this.stepCount * 2 + this.toolCount) % SCALES[this.style].length;
-						const note = base + 12 + SCALES[this.style][degree];
-						this.playNote(note, .18, .35);
+					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, .25);
+						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, .3);
-							setTimeout(() => this.playNote(base + 11, .22, .3), 70);
+							this.pluck(base + 9, .35, .6);
+							setTimeout(() => this.pluck(base + 11, .35, .9), 70);
 						}
 						break;
 					case "assistant/attempt":
-						this.stopProgress();
-						this.playNote(base + 8, .18, .4);
-						setTimeout(() => this.playNote(base + 7, .2, .4), 100);
-						setTimeout(() => this.playNote(base + 5, .25, .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.stopProgress();
-						if (action.interrupted) this.playChord(base + 7, "dim", .9, .5);
-						else this.playChord(this.currentChordRoot(base), this.currentChordQuality(), 1.1, .55);
+						this.stopMelody();
+						this.breath(action.interrupted ? base + 6 : base + 12, 1.6);
 						break;
 					case "turn/end":
-						this.stopProgress();
-						this.playChord(base, this.style === "minor" ? "minor" : "major", 2.2, .65);
-						this.chordIndex = 0;
+						this.stopPiece(true);
 						break;
 				}
 			}
-			currentChordRoot(base) {
-				const prog = CHORD_PROGRESSIONS[this.style];
-				return base + prog[this.chordIndex % prog.length];
+			/** 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);
 			}
-			currentChordQuality() {
-				const q = CHORD_QUALITIES[this.style];
-				return q[this.chordIndex % q.length] ?? "major";
+			/** Insert a 过门 fill: pause the chain, play the run, resume after. */
+			insertFill(root) {
+				if (!this.audio) 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);
 			}
-			/** 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
-				];
+			/** 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);
+				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;
 			}
-			/** Play one note: Web Audio + MIDI simultaneously when available. */
-			playNote(midi, durationSec, velocity) {
+			/**
+			* 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 peak = this.volume * velocity * .5;
+				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);
+			}
+			/** Dizi-like breath note: sine with vibrato and a soft envelope. */
+			breath(midi, durationSec) {
+				if (!this.audio) return;
+				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 third = quality === "major" ? 4 : 3;
-				const fifth = quality === "dim" ? 6 : 7;
-				this.playNote(rootMidi, durationSec, velocity * .45);
-				this.playNote(rootMidi + third, durationSec, velocity * .35);
-				this.playNote(rootMidi + fifth, durationSec, velocity * .35);
-				this.playNote(rootMidi - 12, durationSec * 1.15, velocity * .45);
+			/** 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
@@ -1609,7 +1950,9 @@ window.__ModuleLoader__.load({
 			musicStyle: "风格",
 			musicStyleMajor: "大调",
 			musicStyleMinor: "小调",
-			musicStylePentatonic: "五声",
+			musicStylePentatonic: "古风",
+			musicOnlyCurrentSessionLabel: "只播当前会话",
+			musicOnlyCurrentSessionHint: "开启后仅当前窗口的会话有音乐，后台子任务静音；关闭则所有会话都参与作曲",
 			checkUpdatesNow: "立即检查",
 			checkingUpdates: "检查中…",
 			checkUpToDate: "已是最新",
@@ -1683,7 +2026,9 @@ 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",
 			checkingUpdates: "Checking…",
 			checkUpToDate: "Up to date",
@@ -1728,8 +2073,15 @@ window.__ModuleLoader__.load({
 			let lastMonitored = null;
 			let lastOnFull = "stop";
 			let lastReset = null;
+			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 {
@@ -1737,12 +2089,19 @@ window.__ModuleLoader__.load({
 				} catch {
 					return;
 				}
-				if (lastSessionId !== void 0 && action.sessionId !== String(lastSessionId)) return;
+				if (lastOnlyCurrentSession && lastSessionId !== void 0 && action.sessionId !== String(lastSessionId)) return;
 				music.onAction(action);
 			});
 			ctx.effect(() => () => {
 				sse.close();
 			}, "token-quota-ui: music SSE");
+			/** Build a writable music-settings clone with defaults applied. */
+			const musicDefaults = (raw) => ({
+				enabled: raw?.enabled ?? false,
+				volume: raw?.volume ?? .5,
+				style: raw?.style ?? "pentatonic",
+				onlyCurrentSession: raw?.onlyCurrentSession ?? true
+			});
 			const keyOf = (selection) => {
 				if (selection === null) return void 0;
 				return `${selection.provider}/${selection.model}`;
@@ -1852,18 +2211,15 @@ window.__ModuleLoader__.load({
 				bound?.setCheckUpdates(doc?.checkUpdates ?? true);
 				bound?.setDimWhenIdle(doc?.dimWhenIdle ?? false);
 				bound?.setReset(lastReset);
-				const musicSettings = {
-					enabled: false,
-					volume: .5,
-					style: "major",
-					...doc?.music ?? {}
-				};
+				const musicSettings = musicDefaults(doc?.music);
+				lastOnlyCurrentSession = musicSettings.onlyCurrentSession;
 				music.setEnabled(musicSettings.enabled);
 				music.setVolume(musicSettings.volume);
 				music.setStyle(musicSettings.style);
 				bound?.setMusicEnabled(musicSettings.enabled);
 				bound?.setMusicVolume(musicSettings.volume);
 				bound?.setMusicStyle(musicSettings.style);
+				bound?.setMusicOnlyCurrentSession(musicSettings.onlyCurrentSession);
 				fetch("/token-quota", { headers: { accept: "application/json" } }).then((response) => {
 					if (!response.ok) {
 						bound?.setError(`quota route: ${String(response.status)}`);
@@ -1934,36 +2290,30 @@ window.__ModuleLoader__.load({
 				scope.set("dimWhenIdle", enabled);
 			};
 			const setMusicEnabled = (enabled) => {
-				const current = {
-					enabled: false,
-					volume: .5,
-					style: "major",
-					...scope.getSnapshot().value?.music ?? {}
-				};
+				const doc = scope.getSnapshot().value;
+				const current = musicDefaults(doc?.music);
 				current.enabled = enabled;
 				scope.set("music", current);
 				if (enabled) music.ensureStarted();
 			};
 			const setMusicVolume = (volume) => {
-				const current = {
-					enabled: false,
-					volume: .5,
-					style: "major",
-					...scope.getSnapshot().value?.music ?? {}
-				};
+				const doc = scope.getSnapshot().value;
+				const current = musicDefaults(doc?.music);
 				current.volume = Math.max(0, Math.min(1, volume));
 				scope.set("music", current);
 			};
 			const setMusicStyle = (style) => {
-				const current = {
-					enabled: false,
-					volume: .5,
-					style: "major",
-					...scope.getSnapshot().value?.music ?? {}
-				};
+				const doc = scope.getSnapshot().value;
+				const current = musicDefaults(doc?.music);
 				current.style = style;
 				scope.set("music", current);
 			};
+			const setMusicOnlyCurrentSession = (only) => {
+				const doc = scope.getSnapshot().value;
+				const current = musicDefaults(doc?.music);
+				current.onlyCurrentSession = only;
+				scope.set("music", current);
+			};
 			/** Ask the Host to check the registry right now, then refresh the snapshot. */
 			const checkUpdatesNow = () => {
 				bound?.setCheckingUpdates(true);
@@ -2050,7 +2400,8 @@ window.__ModuleLoader__.load({
 					setDimWhenIdle,
 					setMusicEnabled,
 					setMusicVolume,
-					setMusicStyle
+					setMusicStyle,
+					setMusicOnlyCurrentSession
 				};
 			};
 			ctx.slots.inject("shell.overlay", () => ctx.slots.register({