dsh-plugin-notify-sounds 1.8.0 → 1.8.4

package/README.md

@@ -95,7 +95,7 @@ dsh plugin --profile <your profile> add github:BillCx330/dsh-plugin-notify-sound
 **Release archive** — download the `.tgz` from [Releases](https://github.com/BillCx330/dsh-plugin-notify-sounds/releases) and install it by its **path on disk**:
 
 ```sh
-dsh plugin --profile <your profile> add ./dsh-plugin-notify-sounds-1.8.0.tgz
+dsh plugin --profile <your profile> add ./dsh-plugin-notify-sounds-1.8.4.tgz
 ```
 
 (`dsh plugin add` hands its argument straight to the package manager, so it takes a local file path — a download URL will not work.)
@@ -139,6 +139,10 @@ For anyone hacking on the code (exact details live in the source comments):
 
 ## 📜 Changelog
 
+- **v1.8.4** (2026-10-20) **A click always finds the window.** A trace of a real click showed the native raise giving up with "no window found" while the window existed: a hidden or repainting window can transiently answer with an empty title, and the search had nothing else to match on. The window search now also matches the process that owns the window (the Desktop shell is this Host's parent), and the foreground request is retried three times before the deep-link fallback is paid for.
+- **v1.8.3** (2026-10-20) **Click-to-return works when the window is closed to the tray.** The Win32 raise searched only *visible* windows, so a DSH window hidden to the tray was never found and the click fell back to the slow deep-link route — which reads as "clicked the notification, nothing happened". The search now also remembers an invisible window whose title matches, and the raise shows it (`SW_SHOW`) before restoring and focusing it; the deep link stays as the last resort.
+- **v1.8.2** (2026-10-20) **Actually fixes goal-mode alerting.** The 1.8.1 host route read `stateOf(session, "goal")` but took `current.phase`, while the projection value nests the goal: `current.goal.phase`. Every read therefore came back empty and every round chimed. The route now reads the nested field (with a fallback for a flattened shape), and a Host-side debug trace confirmed `current.goal.phase` is `active` on intermediate rounds and `complete` on the final one.
+- **v1.8.1** (2026-10-20) **Fixes goal-mode alerting.** The 1.8.0 switch read the phase from the browser's own session projection, which only carries sessions that page has opened — for a goal in a session it never opened the read came back empty, which the code treated as "no goal", so every round chimed again. The browser half now asks the Host's new read-only `/notify-sounds/goal` route, whose projection store is authoritative, and re-checks it while the goal is still `active` (the single chime lands when the goal completes, pauses or blocks; a session that starts running again stays silent). A Host that does not answer the route keeps the old behaviour.
 - **v1.8.0** (2026-10-20) **The plugin stops installing itself; the package manager owns upgrades.** Writing files in place never updated the profile's lockfile, so the next plugin install — or a market upgrade — silently restored the version pnpm had recorded: a 1.7.0 install could roll back to 1.6.9 with no warning. DSH 0.2.1 makes a durable self-install impossible from inside a plugin (the manager refuses a package that is already declared, and its remove-then-install step unloads the very code that would finish the install), so the self-installer is gone: the update row checks npm, reports the newer version, and points at the route that installs — Settings → Plugins (remove, then add again), the marketplace, or `dsh plugin add` on a web profile. It also compares the running version with the version the profile's lockfile would restore and **says so when they differ**, turning the silent rollback into a self-service fix. **New: goal-mode alerts wait for the goal to end** (issue #2) — a goal runs several automatic rounds and every round used to chime; the new switch **Only alert on the final goal round** stays silent on intermediate rounds and chimes once when the goal completes, pauses or blocks (ordinary sessions are unaffected; off by default). The release keeps the same seven filenames, so 1.6.9 / 1.7.0 installations still reach it through their own updater — after one reinstall through the package manager the upgrade is permanent.
 - **v1.7.0** (2026-10-16) **The update mechanism turns a corner**: one-click update is no longer limited by a fixed list of seven filenames. It now accepts any regular file inside the package directory, governed by rules instead of an inventory — path traversal, absolute paths, symlinks, non-file entries, reserved names (its own backup/temp names and its record file, `.git`, `node_modules`, `.npmrc`), paths containing `:`, names colliding only by case, and a file that differs from the entry point `package.json` declares only by case are all still refused, with the file count and the decompressed size capped (enforced while inflating). **1.7.0 and later update cleanly into a release that adds or drops any number of files**: a file a later release drops is now actually deleted, based on the `.update-manifest.json` record this updater leaves behind — **only files an update installed are ever deleted**, anything you put in that directory yourself is left alone, and installations older than the first record are never guessed at. **1.6.9 and earlier will fail** (safely — nothing is written, the installed version keeps working) if a newer release adds a file, and the README says to reinstall once. Fixed: turning auto-check off ended the daily check chain for good, even after turning it back on; clicking a notification did nothing when the window title changed between the two Win32 reads; prerelease versions compared as strings (`rc.10` looked older than `rc.9`); **two tabs — or two windows — of the same GUI each rang the sound, raised their own system notification and ran their own repeat reminder** (one page is now elected to speak, via BroadcastChannel plus a shared claim, and the others stay silent until it disappears; per-window title marks are unaffected); and custom-sound normalization now visits **every sample** (taking every 8th frame aliased against content near fs/8 and systematically underestimated the peak). A failed update now gives **stage-appropriate advice** — retry for network failures, and the repository plus the uninstall/reinstall steps when the payload itself could not be applied, naming both versions — `package.json` is written **last** (a crash mid-swap leaves the old version number over the new code, so the next check still offers the update instead of declaring success), and the archive's manifest is verified to be this package at the version the registry named. The custom-sound row moved to sit **directly under the three trigger sounds** it is used by, and the smaller fixes on top: the cooldown table is a real LRU rather than FIFO (the session that fired most often was evicted first), one session-list snapshot per pass instead of per session, the macOS Desktop's window-title switch is now disabled rather than merely re-described, the full-width punctuation that leaked into the English update message is gone, and the README's release-archive instructions now give a command that actually works.
 - **v1.6.9** (2026-10-12) Fixes a README filename compatibility issue in v1.6.8: reverted to `README.md` (English) + `README.zh.md` (Chinese) so the update whitelist in every prior version can recognise them. A new filename would be refused by old users' updates — the whitelist is one-directional because the update runs old code.

package/README.zh.md

@@ -95,7 +95,7 @@ dsh plugin --profile <你的 profile> add github:BillCx330/dsh-plugin-notify-sou
 **Release 压缩包** —— 从 [Releases](https://github.com/BillCx330/dsh-plugin-notify-sounds/releases) 下载 `.tgz`，用它**在磁盘上的路径**安装：
 
 ```sh
-dsh plugin --profile <你的 profile> add ./dsh-plugin-notify-sounds-1.8.0.tgz
+dsh plugin --profile <你的 profile> add ./dsh-plugin-notify-sounds-1.8.4.tgz
 ```
 
 （`dsh plugin add` 把参数原样交给包管理器，所以要给本地文件路径，不能填下载地址。）
@@ -138,6 +138,10 @@ dsh plugin --profile <你的 profile> add ./dsh-plugin-notify-sounds
 
 ## 📜 更新记录
 
+- **v1.8.4**（2026-10-20）**点击通知一定能找到窗口。** 真实点击的日志显示：窗口明明存在，原生唤窗却报 "no window found"——隐藏或正在重绘的窗口可能瞬时返回空标题，而当时的搜索只认标题。现在窗口搜索同时按「拥有窗口的进程」匹配（桌面壳是本宿主进程的父进程），前台请求连续重试三次之后才走深链兜底。
+- **v1.8.3**（2026-10-20）**窗口关到托盘时，点击通知也能回到 DSH 了。** 原先的 Win32 唤窗只搜**可见**窗口，关到托盘的 DSH 窗口永远找不到，只能退到很慢的深链兜底——表现就是「点了通知没反应」。现在会记住标题匹配的不可见窗口，并在置前之前先 `SW_SHOW` 让它显示出来；深链仍作为最后兜底。
+- **v1.8.2**（2026-10-20）**真正修好目标模式的提醒。** 1.8.1 的宿主路由读了 `stateOf(session, "goal")`，却取 `current.phase`，而投影值把 goal 嵌在里面：`current.goal.phase`。于是每次读取都为空、每轮照响。现在改为读嵌套字段（并保留扁平形状的兜底），宿主侧调试记录已确认：中间轮 `current.goal.phase` 是 `active`，最后一轮是 `complete`。
+- **v1.8.1**（2026-10-20）**修复目标模式的提醒。** 1.8.0 的开关从浏览器自己的会话投影读 phase，而那份投影只包含这个页面打开过的会话——目标所在的会话没被打开过时读到空值，代码把它当成「没有目标」，于是每轮又照响。浏览器半现在改问宿主新增的只读路由 `/notify-sounds/goal`（宿主的投影存储才是权威的），并在目标仍为 `active` 时持续复查：目标完成、暂停或受阻时响唯一一次；会话重新开始运行则保持安静。宿主不回答该路由时退回旧行为。
 - **v1.8.0**（2026-10-20）**插件不再自己安装更新，改由包管理器负责。** 原地写文件从不会更新 profile 的 lockfile，于是下一次插件安装（或市场升级）会静默把 pnpm 记录的版本装回来：1.7.0 的安装可能一声不响退回 1.6.9。DSH 0.2.1 让插件无法从内部持久地自安装（管理器拒绝已声明的包，而它的「先移除再安装」会先卸载掉正要完成安装的代码），所以自安装器被移除：更新行只检查 npm、报告新版，并指向真正负责安装的入口——设置 → 插件（卸载后再装）、市场，或 web profile 上的 `dsh plugin add`。它还会把「运行版本」与「lockfile 会恢复的版本」做比较，**不一致时明确提示**，把静默回退变成用户可自助修复的状态。**新增：目标模式下等目标结束再提醒**（issue #2）——目标模式会自动进行多轮，原先每轮结束都会响；新开关「目标模式下只在最终轮提醒」让中间轮保持安静，只在目标完成、暂停或受阻时响一次（普通对话不受影响；默认关闭）。本版保持同样的七个文件名，1.6.9 / 1.7.0 的安装仍可通过它们自带的自更新到达 1.8.0——之后用包管理器重装一次，升级即永久生效。
 - **v1.7.0**（2026-10-16）**更新机制的转折点**：一键更新不再受「固定七个文件名」的白名单约束，改为按规则接受包目录下的任何普通文件——路径穿越、绝对路径、符号链接、非普通文件、保留名字（更新器自己的备份/临时名与记录文件、`.git`、`node_modules`、`.npmrc`）、含 `:` 的路径段，以及只有大小写不同的重名或**与 `package.json` 声明的入口只差大小写**的文件，依然一律拒绝，文件数与解压体积也都有上限（解压时即受 `gunzip` 上限约束）。**1.7.0 及以后可以正常更新到任意增减文件的新版**：某个版本去掉的文件现在会真的被删掉（依据更新器自己留下的 `.update-manifest.json` 记录，**只删它自己装过的文件**，用户放进目录里的东西一律不动；第一条记录之前的安装不做任何猜测）。**1.6.9 及更早**遇到「新增了文件」的新版会更新失败（安全失败：一个字节都不写，已装版本继续正常工作），README 里说明了重装一次的办法。修复：关掉「自动检查更新」会让每日轮询永久停摆（重新打开也不恢复）；窗口标题在两次 Win32 读取之间变短时，点通知唤窗会静默失效；预发布版本号按字符串比较（`rc.10` 被误判为比 `rc.9` 旧）；**同一个 GUI 开多个标签页或多个窗口时提示音、系统通知、重复提醒全部翻倍**（现在由 BroadcastChannel + 本地记录选出一个「发声页」，其余页保持安静，只在发声页消失后接管；窗口标题标记各窗口独立，不受影响）；自定义音效的峰值归一化改为**逐样本**扫描（原先每 8 帧抽样会与接近 fs/8 的高频混叠、系统性低估峰值）。更新失败时给出**按阶段区分的建议**（网络类提示重试；解包/替换类给出手动重装步骤与仓库地址，并列出失败的两个版本号），写入顺序改为**最后写 `package.json`**（中途崩溃时检查仍会提示更新，用户再点一次即可自愈），并会校验归档里的清单确实是本包、确实是 registry 报的那个版本。设置里「自定义音效」移到**三种提示音之后**（它们才是会用到它的三处）；`settings` 相关的小修：冷却表改为真正的 LRU（原先是 FIFO，最常触发的会话反而最先被淘汰）、会话列表每轮只取一次快照、macOS 桌面版的「窗口标题提醒」开关改为**禁用**（原先能打开但标记无处显示）、英文界面更新提示里残留的全角标点修掉、README 的 Release 安装说明改为可照做的本地路径写法。
 - **v1.6.9**（2026-10-12）修正 v1.6.8 的 README 文件名兼容性：改回 `README.md`（英文默认）+ `README.zh.md`（中文），确保旧版本更新白名单能识别。新文件名会让旧用户的更新被拒——白名单是单向兼容的，更新时跑的是旧代码。

package/lib/client.js

@@ -1970,6 +1970,7 @@ window.__ModuleLoader__.load({
 					? `${t("update.available")} ${latest}`
 					: t("update.uptodate");
 			if (state.phase === "checking") status = t("update.checking");
+			if (state.phase === "failed") status = t("update.failed");
 			const detail = payload === undefined ? status : `${t("update.current")} ${formatVersion(payload.current)} · ${status}`;
 			// The install belongs to the package manager now: this plugin only
 			// checks, and every route below installs THROUGH pnpm so the
@@ -2414,89 +2415,81 @@ window.__ModuleLoader__.load({
 					}
 					return false;
 				};
+								/** Route the Host answers a session's goal phase on. */
+				const GOAL_PHASE_PATH = "/notify-sounds/goal";
+				/** How often an active goal's phase is re-read while waiting for its end. */
+				const GOAL_POLL_MS = 2000;
+				/** Longest a goal may stay `active` before its watcher gives up. */
+				const GOAL_SETTLE_TIMEOUT_MS = 30 * 60 * 1000;
 				/**
-				 * The goal projection's phase for one session, when this runtime
-				 * carries the goal packages.
+				 * One goal phase from the Host, or undefined when it cannot be read.
 				 *
-				 * DSH's goal mode drives several rounds inside one session, and
-				 * every round ends with a running→idle edge — so an unguarded
-				 * completion chime fires once per round. The phase is the host's
-				 * own vocabulary: `active` keeps going on its own, `complete`
-				 * finished, and `paused`/`blocked` wait for the user.
-				 *
-				 * Every step is optional: a runtime without the goal projection
-				 * simply answers `undefined`, which reads as "no goal".
+				 * The Host owns the durable projection; this page's own store only
+				 * carries sessions it has opened, and a completion edge can belong to a
+				 * session this page never opened. Undefined keeps the old behaviour
+				 * (alert) for any runtime that does not answer the route.
 				 */
-				const goalPhaseOf = (sessionId) => {
+				const readGoalPhase = async (sessionId) => {
 					try {
-						const sessions = ctx.sessions ?? ctx.uiSession?.sessions;
-						const store = sessions?.get?.(sessionId)?.projections;
-						const snapshot = store?.get?.("goal") ?? store?.faceOf?.("goal")?.getSnapshot?.();
-						const phase = snapshot?.goal?.phase;
-						return typeof phase === "string" ? phase : undefined;
+						const response = await fetch(GOAL_PHASE_PATH + "?session=" + encodeURIComponent(sessionId), { method: "GET" });
+						if (!response.ok) return undefined;
+						const payload = await response.json();
+						return typeof payload?.phase === "string" ? payload.phase : undefined;
 					} catch {
 						return undefined;
 					}
 				};
-				/** Whether the completion edge for a session is worth an alert now. */
-				const completionIsFinal = (sessionId, value) => {
-					if (value?.goalFinalOnly !== true) return true;
-					// A session with no goal, or with one that will not continue on
-					// its own (finished, paused, blocked), ends this edge for the
-					// user; one that is still `active` drives another round.
-					return goalPhaseOf(sessionId) !== "active";
+				/** Deliver the completion alert this edge earns. */
+				const alertCompletion = (sessionId) => {
+					if (!pageIsWatched() && !quietNow()) unreadCompletion = true;
+					notify("completion", undefined, sessionId);
+					refreshFlash();
 				};
-				/** Longest a goal may stay `active` before its watcher gives up. */
-				const GOAL_SETTLE_TIMEOUT_MS = 30 * 60 * 1000;
-				/** Settings whose session already has a watcher waiting for its goal. */
+				/** Sessions whose completion alert is waiting for their goal to end. */
 				const goalWatchers = new Map();
 				/**
-				 * Serve the single completion chime a goal earns when it ends.
+				 * Resolve a running→idle edge against the goal projection.
 				 *
-				 * The edge that armed this watcher was an intermediate round (the
-				 * phase was still `active`). The next round starts at quiescence,
-				 * so the projection is re-read on every change: running again means
-				 * the edge was intermediate and stays silent, while any non-active
-				 * phase means the goal ended and earns the one chime.
+				 * A goal drives several rounds and every round ends with this edge; with
+				 * `goalFinalOnly` on, the edge is only an alert when the goal will not
+				 * continue: no goal, completed, paused or blocked. A goal still `active`
+				 * gets one watcher that re-reads the phase until it ends (the single
+				 * chime) or the session starts running again (silent intermediate round).
 				 */
-				const watchGoalCompletion = (sessionId) => {
+				const handleCompletion = (sessionId, value) => {
+					if (value?.goalFinalOnly !== true) {
+						alertCompletion(sessionId);
+						return;
+					}
 					if (goalWatchers.has(sessionId)) return;
 					let settled = false;
-					let subscriptionOff = () => {};
-					let timer;
-					const settle = (chime) => {
+					let pollTimer;
+					let deadline;
+					const finish = (chime) => {
 						if (settled) return;
 						settled = true;
 						goalWatchers.delete(sessionId);
-						try {
-							subscriptionOff();
-						} catch {}
-						clearTimeout(timer);
-						if (!chime) return;
-						if (!pageIsWatched() && !quietNow()) unreadCompletion = true;
-						notify("completion", undefined, sessionId);
-						refreshFlash();
+						clearTimeout(pollTimer);
+						clearTimeout(deadline);
+						if (chime) alertCompletion(sessionId);
 					};
-					try {
-						const sessions = ctx.sessions ?? ctx.uiSession?.sessions;
-						const face = sessions?.get?.(sessionId)?.projections?.faceOf?.("goal");
-						if (typeof face?.subscribe === "function") {
-							const subscription = face.subscribe(() => {
-								if (source.getSnapshot().get(sessionId)?.running === true) {
-									settle(false);
-									return;
-								}
-								const phase = goalPhaseOf(sessionId);
-								if (phase === undefined || phase !== "active") settle(true);
-							});
-							if (typeof subscription === "function") subscriptionOff = subscription;
+					goalWatchers.set(sessionId, () => finish(false));
+					const poll = async () => {
+						if (source.getSnapshot().get(sessionId)?.running === true) {
+							finish(false);
+							return;
 						}
-					} catch {}
-					// A goal that never resolves must not pin this entry forever;
-					// dropping it silently beats a stray chime minutes later.
-					timer = setTimeout(() => settle(false), GOAL_SETTLE_TIMEOUT_MS);
-					timer?.unref?.();
-					goalWatchers.set(sessionId, () => settle(false));
+						const phase = await readGoalPhase(sessionId);
+						if (settled) return;
+						if (phase !== "active") {
+							finish(true);
+							return;
+						}
+						pollTimer = setTimeout(poll, GOAL_POLL_MS);
+					};
+					deadline = setTimeout(() => finish(true), GOAL_SETTLE_TIMEOUT_MS);
+					deadline?.unref?.();
+					void poll();
 				};
 				/**
 				 * Which alert the title should carry, if any.
@@ -2580,20 +2573,7 @@ window.__ModuleLoader__.load({
 								notify(status.pendingInteraction.kind === "question" ? "question" : "decision", status.pendingInteraction, sessionId);
 							}
 							if (before !== undefined && before.running === true && status.running === false) {
-								const value = form.getSnapshot().value;
-								if (!completionIsFinal(sessionId, value)) {
-									// An intermediate goal round: stay silent and let
-									// the goal's own end deliver the single chime.
-									watchGoalCompletion(sessionId);
-								} else {
-									// A finish that happens while the user is away is
-									// news; one they watch happen is not — and one
-									// that happens during quiet hours is forgotten
-									// rather than kept for later, so nothing about it
-									// shows up when the quiet window ends.
-									if (!pageIsWatched() && !quietNow()) unreadCompletion = true;
-									notify("completion", undefined, sessionId);
-								}
+								handleCompletion(sessionId, form.getSnapshot().value);
 							}
 						}
 					}

package/lib/index.js

@@ -62,9 +62,14 @@ const DESKTOP_APP_TITLE = "DeepSeek Harness";
 
 /** `ShowWindow` command: restore a minimized or maximized window to its prior size. */
 const SW_RESTORE = 9;
+/** `ShowWindow` command: show a window without asking for the foreground. */
+const SW_SHOW = 5;
 
 /** Virtual key and flag for the ALT tap that satisfies the foreground lock. */
 const VK_MENU = 0x12;
+
+/** The shell owns the window: this Host is its child process. */
+const SHELL_PID = process.ppid;
 const KEYEVENTF_KEYUP = 0x2;
 
 //#region native window raise
@@ -164,6 +169,7 @@ function loadNativeRaise() {
 			AllowSetForegroundWindow: user32.func("bool __stdcall AllowSetForegroundWindow(int pid)"),
 			GetForegroundWindow: user32.func("void * __stdcall GetForegroundWindow()"),
 			GetWindowThreadProcessId: user32.func("uint32 __stdcall GetWindowThreadProcessId(void *h, void *pid)"),
+		GetWindowPid: user32.func("uint32 __stdcall GetWindowThreadProcessId(void *h, _Out_ uint32 *pid)"),
 			AttachThreadInput: user32.func("bool __stdcall AttachThreadInput(uint32 attach, uint32 attachTo, bool attachFlag)"),
 			keybd_event: user32.func("void __stdcall keybd_event(uint8 vk, uint8 scan, uint32 flags, uintptr_t extra)"),
 			GetCurrentThreadId: kernel32.func("uint32 __stdcall GetCurrentThreadId()"),
@@ -243,14 +249,36 @@ export function isDesktopTitle(title) {
  * @param native - the bound Win32 calls.
  * @returns the window handle, or undefined.
  */
-function findDesktopWindow(native) {
-	let found;
+export function findDesktopWindow(native) {
+	let byTitleVisible;
+	let byTitleHidden;
+	let byPidVisible;
+	let byPidHidden;
+	const pidBuffer = new Uint32Array(1);
 	const visit = native.koffi.register((handle) => {
 		try {
-			if (!native.IsWindowVisible(handle)) return true;
-			if (!isDesktopTitle(windowTitle(native, handle))) return true;
-			found = handle;
-			return false; // stop at the first match
+			const visible = native.IsWindowVisible(handle);
+			const title = windowTitle(native, handle);
+			if (isDesktopTitle(title)) {
+				if (visible) {
+					byTitleVisible = handle;
+					return false; // stop at the first visible title match
+				}
+				if (byTitleHidden === undefined) byTitleHidden = handle;
+				return true;
+			}
+			// A hidden or repainting window can transiently answer with no
+			// title; the shell process owns the window, so match that too.
+			if (SHELL_PID === undefined || SHELL_PID === 0) return true;
+			if (typeof native.GetWindowPid !== "function") return true;
+			pidBuffer[0] = 0;
+			native.GetWindowPid(handle, pidBuffer);
+			if (pidBuffer[0] !== SHELL_PID) return true;
+			if (visible) {
+				if (byPidVisible === undefined) byPidVisible = handle;
+			} else if (byPidHidden === undefined) {
+				byPidHidden = handle;
+			}
 		} catch {
 			// A window that cannot be inspected simply does not match.
 		}
@@ -265,7 +293,7 @@ function findDesktopWindow(native) {
 			native.koffi.unregister(visit);
 		} catch {}
 	}
-	return found;
+	return byTitleVisible ?? byTitleHidden ?? byPidVisible ?? byPidHidden;
 }
 
 /**
@@ -281,6 +309,9 @@ function raiseDesktopWindowNative() {
 	// Restore first: `ShowWindow(SW_RESTORE)` is not a foreground request, so it
 	// is granted even to a background process. Its return value is the window's
 	// PREVIOUS visibility, not a success flag, so it is deliberately ignored.
+	// SW_SHOW is not a foreground request, so a background process is granted
+	// it; it is what makes a tray-hidden window visible again.
+	if (!native.IsWindowVisible(handle)) native.ShowWindow(handle, SW_SHOW);
 	native.ShowWindow(handle, SW_RESTORE);
 	native.BringWindowToTop(handle);
 	// The foreground request is the part Windows polices: a background process
@@ -435,45 +466,32 @@ const warned = new Set();
  *
  * Every failure mode leaves the click a harmless no-op.
  */
-function focusDesktopWindow() {
+function tryRaiseNative() {
+	try {
+		if (process.platform !== "win32") return false;
+		return raiseDesktopWindowNative();
+	} catch (error) {
+		warn(`native raise failed: ${error?.message ?? error}`);
+		return false;
+	}
+}
+
+/** Raise the window through the app's own deep link; last resort. */
+function focusDesktopWindowDeepLink() {
 	try {
 		if (process.platform === "win32") {
-			let raised = false;
-			try {
-				raised = raiseDesktopWindowNative();
-			} catch (error) {
-				warn(`native raise failed: ${error?.message ?? error}`);
-			}
-			if (raised) {
-				log("window raised");
-			} else {
-				log("native raise did not take the foreground; falling back to the deep link");
-				raiseDesktopWindowDeepLink();
-			}
+			raiseDesktopWindowDeepLink();
 		} else if (process.platform === "darwin") {
-			// Activate the app by bundle id first: it needs no URL scheme to
-			// have been registered, which a packaged .app only gets if its
-			// Info.plist declares CFBundleURLTypes — something this project
-			// cannot verify from source. The deep link stays as the fallback,
-			// and a launch that failed is now named in the log instead of
-			// looking exactly like one that succeeded.
 			log("raising via open -b");
 			launcher("open", ["-b", MACOS_BUNDLE_ID], (ok) => {
-				if (ok) return;
-				log("bundle-id activation did not take; falling back to the deep link");
-				launcher("open", [FOCUS_DEEP_LINK]);
+				if (!ok) launcher("open", [FOCUS_DEEP_LINK]);
 			});
 		} else {
-			// No desktop shell ships for other platforms today — the shell
-			// itself refuses anything but win32/darwin, and a browser click
-			// never reaches this function. `xdg-open` is the correct opener
-			// should a Linux shell ever appear; until then this line is
-			// unreachable rather than misleading.
 			log("raising via xdg-open + deep link");
 			launcher("xdg-open", [FOCUS_DEEP_LINK]);
 		}
 	} catch (error) {
-		warn(`focus failed: ${error?.message ?? error}`);
+		warn(`focus fallback failed: ${error?.message ?? error}`);
 	}
 }
 
@@ -482,6 +500,9 @@ function focusDesktopWindow() {
 /** Route the browser half reads the update check through. */
 export const UPDATE_CHECK_PATH = "/notify-sounds/update/check";
 
+/** Route the browser half reads a session's goal phase through. */
+export const GOAL_PHASE_PATH = "/notify-sounds/goal";
+
 /** The npm package this plugin publishes as — the only name the check ever asks for. */
 const UPDATE_PACKAGE = "dsh-plugin-notify-sounds";
 
@@ -1439,7 +1460,14 @@ export function apply(ctx) {
 				res.end();
 				log(`focus click (fromBrowser=${fromBrowser})`);
 				if (!fromBrowser) {
-					focusDesktopWindow();
+					// Foreground requests can be refused while another app owns
+					// the input queue; retry before paying for a deep-link launch.
+					let raised = false;
+					for (let attempt = 0; attempt < 3 && !raised; attempt += 1) {
+						raised = tryRaiseNative();
+						if (!raised) await new Promise((resolve) => setTimeout(resolve, 180));
+					}
+					if (!raised) focusDesktopWindowDeepLink();
 				}
 			},
 		}), "notify-sounds: focus route");
@@ -1479,4 +1507,46 @@ export function apply(ctx) {
 		}), "notify-sounds: update check route");
 
 	});
+	// The goal phase route (1.8.1): the browser cannot rely on its own
+	// session projections for a session it never opened, so goal mode asks
+	// the Host, whose projection store is authoritative. Read-only, one
+	// session id, fenced like every other route here.
+	ctx.inject(["webServer", "connection", "sessions", "sessionProjections"], (child) => {
+		/** The goal phase for one session, or undefined when there is none. */
+		const phaseOf = (sessionId) => {
+			try {
+				const session = child.sessions.get(sessionId);
+				if (session === undefined) return undefined;
+				const projection = child.sessionProjections.stateOf(session, "goal");
+				if (projection === undefined || projection.failure != null) return undefined;
+				const phase = projection.current?.goal?.phase ?? projection.current?.phase;
+				return typeof phase === "string" ? phase : undefined;
+			} catch {
+				return undefined;
+			}
+		};
+		child.effect(() => child.webServer.register({
+			kind: "exact",
+			path: GOAL_PHASE_PATH,
+			handler: (req, res) => {
+				const rejection = child.connection.requestRejection(req);
+				if (rejection !== undefined) {
+					res.statusCode = rejection;
+					res.end();
+					return;
+				}
+				if (req.method !== "GET") {
+					res.statusCode = 405;
+					res.setHeader("allow", "GET");
+					res.end();
+					return;
+				}
+				const sessionId = new URL(req.url ?? "/", "http://localhost").searchParams.get("session") ?? "";
+				const phase = sessionId === "" ? undefined : phaseOf(sessionId);
+				res.statusCode = 200;
+				res.setHeader("content-type", "application/json");
+				res.end(JSON.stringify({ phase: phase ?? null }));
+			},
+		}), "notify-sounds: goal phase route");
+	});
 }

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "dsh-plugin-notify-sounds",
-  "version": "1.8.0",
-  "description": "Notification sounds for DeepSeek Harness — a soft chime when the agent needs your decision or finishes a task, with a Settings section styled like DSH's own · 需要决策或任务完成时播放提示音，点击系统通知可回到窗口，设置面板可调音量与音效",
-  "type": "module",
-  "main": "lib/index.js",
-  "exports": {
-    ".": {
-      "default": "./lib/index.js"
-    },
-    "./client": {
-      "default": "./lib/client.js"
-    },
-    "./package.json": "./package.json",
-    "./cordis.patch.yml": "./cordis.patch.yml"
-  },
-  "files": [
-    "lib/index.js",
-    "lib/client.js",
-    "cordis.patch.yml",
-    "README.zh.md"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/BillCx330/dsh-plugin-notify-sounds.git"
-  },
-  "bugs": {
-    "url": "https://github.com/BillCx330/dsh-plugin-notify-sounds/issues"
-  },
-  "homepage": "https://github.com/BillCx330/dsh-plugin-notify-sounds#readme",
-  "keywords": [
-    "deepseek",
-    "harness",
-    "dsh",
-    "dsh-plugin",
-    "notification",
-    "sound"
-  ],
-  "peerDependencies": {
-    "@deepseek-ai/schemastery": "^3.18.1"
-  },
-  "devDependencies": {
-    "@deepseek-ai/schemastery": "^3.18.4"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "inject": [
-        "@deepseek-ai/dsh-client-locale",
-        "@deepseek-ai/dsh-api-session-controller",
-        "@deepseek-ai/dsh-client-ui-session",
-        "@deepseek-ai/dsh-client-ui-settings",
-        "@deepseek-ai/dsh-client-ui-settings-general",
-        "@deepseek-ai/dsh-client-ui-primitives"
-      ],
-      "platform": "web"
-    }
-  }
+{
+  "name": "dsh-plugin-notify-sounds",
+  "version": "1.8.4",
+  "description": "Notification sounds for DeepSeek Harness — a soft chime when the agent needs your decision or finishes a task, with a Settings section styled like DSH's own · 需要决策或任务完成时播放提示音，点击系统通知可回到窗口，设置面板可调音量与音效",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json",
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "cordis.patch.yml",
+    "README.zh.md"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BillCx330/dsh-plugin-notify-sounds.git"
+  },
+  "bugs": {
+    "url": "https://github.com/BillCx330/dsh-plugin-notify-sounds/issues"
+  },
+  "homepage": "https://github.com/BillCx330/dsh-plugin-notify-sounds#readme",
+  "keywords": [
+    "deepseek",
+    "harness",
+    "dsh",
+    "dsh-plugin",
+    "notification",
+    "sound"
+  ],
+  "peerDependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/schemastery": "^3.18.4"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-api-session-controller",
+        "@deepseek-ai/dsh-client-ui-session",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-settings-general",
+        "@deepseek-ai/dsh-client-ui-primitives"
+      ],
+      "platform": "web"
+    }
+  }
 }