dsh-notify-me 1.4.0 → 1.5.1

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to **dsh-notify-me** are documented here.
 
+## [1.5.1] — 2026-10-04
+
+### 修复
+- **「点击通知回到对应对话」在带按钮的审批通知上补齐窗口调度**：这类通知由 Service Worker 弹出，此前 worker 只把点击转告页面，窗口能不能到前台全押在页面消息回调里的 `window.focus()` 上——那段代码不在用户点击的手势上下文里，Windows 前台抢占规则下窗口可能根本抬不起来。现在 worker 在 `notificationclick` 里按规范用 `client.focus()` 调起窗口。
+- **多标签页不再互相抢焦点、一起乱切对话**：worker 的点击转信此前广播给所有同源 DSH 标签页，每个开着的标签页都会聚焦自己并各自切对话。现在一次点击只挑一个窗口（优先当前可见的）调起并切对话，其余窗口只收「不导航」的副本、留在原地；「同意 / 拒绝」按钮照旧只裁决、不调窗口。
+- 「点击通知回到对应对话」关掉后的承诺在持久通知上也成立：show 时把该设置记进通知 `data`，worker 据此不调任何窗口；旧版本弹出的遗留通知没有该字段，维持此前行为。
+
+### 变更
+- 版本号 1.5.0 → 1.5.1；`window.__dshNotifyMe.version` 同步。
+- README（中英）同步：「点击通知回到对应对话」补多窗口口径，「工作原理」补 worker 侧的窗口调度说明。
+
+### 测试
+- `smoke/smoke-test.cjs` 快捷裁决桥用例补两个 window client 的点击路由断言：点正文只调起可见窗口并只让它切对话（其余客户端收 `navigate: false` 不动）、点正文不裁决；点按钮不调任何窗口也不切对话；`autoFocus` 关掉时通知 `data.focus` 记 `false`、点击既不调窗口也不切对话。
+
+## [1.5.0] — 2026-10-03
+
+### 新增
+- **「完成未读」标题标记**：后台会话的回复跑完、你还没打开看的期间，标签页标题前出现 `✅ 回复完成 · …` / `✅ Reply finished · …`，打开该会话（宿主此时清掉未读）或它再次开跑即消失——离开屏幕再回来，一眼看到哪些跑完了。与「需要你」标记可同时出现（「需要你」在前），宿主改写标题后标记基于新标题重建。未读事实取自宿主：`≥ 0.1.6` 用 `sessionStatus` 行的 `completionUnread`（后台会话完成即点亮，打开 / 再次开跑 / 会话消失即清零），旧宿主用列表行的 `completed` 提醒位（选中会话即清零）。静音中的后台子代理会话照旧不标记；「页面打开时也提醒『回复完成』」开关只管通知，不影响标记。
+- **「回复完成」通道接上宿主的完成未读标志**：此前只靠 `running` 快照边沿，页面没看见的完成（插件热重载中途、快照把 true→false 合并成一跳、完成发生在绑定之前）就永远漏掉。现在 `sessionStatus` 的 `completionUnread` 级别标志（0.1.6+）负责补漏——每条未读实例只报一次，绑定时已存在的未读也补报一声；边沿与级别标志是同一次完成的两个视角、同刻到达时按短时间窗合并成一声。边沿路径保持不变：当前会话的正文仍带回复摘要，旧宿主照旧。
+- 「等你操作」不算完成：一轮带着 plan-review / 提问结束时只走「需要你」提醒，答完也不补「回复完成」马后炮；宿主仍标未读时，标题标记照常挂到你打开会话为止。后台子代理会话的未读照旧静音，解除静音后补报一次。
+- `window.__dshNotifyMe.debug()` 新增 `doneUnreadMarked`（当前挂着「完成未读」标记的会话列表）。
+
+### 变更
+- 版本号 1.4.0 → 1.5.0；`window.__dshNotifyMe.version` 同步。
+- README（中英）同步：「提醒时机」表、「提醒方式」的标题标记说明、「工作原理」的完成未读级别标志两代取源与合并口径。
+
+### 测试
+- `smoke/smoke-test.cjs` 新增 completionUnread 用例段：漏报补发、同刻双视角只响一声、绑定前已有的未读只报一次、等输入的停顿不算完成（答完不补马后炮、标记照旧）、当前会话不走未读通道、后台子代理静音与解除静音、页面可见时只留标记不弹通知、双标记叠加与宿主改标题后的重建；legacy 用例补 `completed` 提醒位的标记出现与「选中会话即撤」。
+- `smoke/cordis-host-test.mjs` 在真 cordis `sessionStatus` 宿主上补一条走真 store 的完成未读用例：报告一次、标记、不重复、打开即撤。
+
 ## [1.4.0] — 2026-10-03
 
 ### 新增

package/README.en.md

@@ -43,7 +43,7 @@ dsh-notify-me decouples **supervision** from **sitting in front of the screen**:
 | When | What you get | Default |
 | --- | --- | --- |
 | 🔔 **The agent needs your input** — sandbox approval / plan review / a question (`ask_user_question`) | Toast + sound + `🔔 Action needed ·` title marker; approval toasts also carry Approve / Reject buttons | Alerts even while the page is visible (the conversation on screen is the exception: tab marker only by default) |
-| ✅ **A reply finishes** — a turn completes; background sessions finishing are also reported | Toast + sound | Alerts only while the page is hidden / backgrounded |
+| ✅ **A reply finishes** — a turn completes; background sessions finishing are also reported | Toast + sound; while a background session is **finished but unread** the tab title carries a `✅ Reply finished ·` marker, gone once you open that session | Alerts only while the page is hidden / backgrounded (the title marker is not gated by this) |
 
 > **Background** subagent child sessions are **not** alerted about by default: DSH lists each of them as its own session, but they are steps inside the parent conversation's turn, so an alert for them is only noise. The subagent session you have open is not part of this and alerts as usual. Settings → "Ignore subagent sessions" turns the mute off.
 
@@ -56,7 +56,7 @@ Open **Settings → Notify me** (refresh the page once after installing):
 - **"Needs you" alerts while the page is open** (default on) and **"Reply finished" alerts while the page is open** (default off);
 - **Stay quiet for the conversation on screen** (default on): a wait inside the conversation you are looking at keeps only the tab marker — no toast or sound landing on the approval card. Backgrounding the page puts that alert back at once, unless you already handled it. Waits in other background sessions are unaffected;
 - **Ignore subagent sessions** (default on): background subagent child sessions raise neither "needs you" nor "reply finished" — those are steps of the parent conversation's turn, and the parent's own alert already covers them. The subagent session you have open alerts as usual. Turn it off to alert for every session;
-- **Click a toast to open that conversation** (default on): clicking brings DSH to the front and switches to the conversation the alert came from; when off, clicking a toast does nothing;
+- **Click a toast to open that conversation** (default on): clicking brings DSH to the front and switches to the conversation the alert came from. With several DSH tabs open, one click raises exactly one window (a visible one first) and switches only that one — the others stay put; when off, clicking a toast does nothing;
 - **Decide approvals from the toast** (default on): approval notifications carry Approve / Reject buttons, and one click settles the request exactly like the Allow once / Reject buttons on the approval card. Clicking the toast body still takes you back to the conversation;
 - **Notification language** — follow the interface / 简体中文 / English: controls the language of the alert text and the `🔔 …` title marker;
 - **Test buttons** — send one "needs you", "reply finished" or "approval buttons" test alert with the current settings (**not** limited by the "while the page is open" toggles; the "needs you" test's title marker clears itself after ~6s).
@@ -67,7 +67,7 @@ Open **Settings → Notify me** (refresh the page once after installing):
 
 - **System notification** — a toast through the browser into the Windows action center / macOS Notification Center (clicking it opens the conversation it came from; approval toasts can be decided straight from the buttons)
 - **Sound** — WebAudio beeps (distinct patterns for "needs you" vs "done")
-- **Tab title marker** — while something is waiting on you, the tab title is prefixed with `🔔 Action needed · …` / `🔔 需要你 · …`
+- **Tab title marker** — while something is waiting on you, the tab title is prefixed with `🔔 Action needed · …` / `🔔 需要你 · …`; while a background session is **finished but unread**, with `✅ Reply finished · …` / `✅ 回复完成 · …`, gone once you open that session (or it starts running again). Both kinds can be up together, "needs you" first; a host title change is rebased under the markers
 
 This is a **browser-layer** plugin: the DSH page must stay open (minimized or backgrounded is fine — that's exactly the "away" state it watches for).
 
@@ -88,7 +88,7 @@ Restart `dsh web`, then hard-refresh the page (Ctrl+Shift+R).
 | `0.1.2-alpha.2 .. 0.1.6-alpha.1` | `uiSession.pendingInteractions` | snapshot `current` | `sessions.open()` |
 | `>= 0.1.6-alpha.2` (incl. `0.2.0-rc.2`) | `uiSession.sessionStatus` | `retainedBy.mainView` | `uiWorkspace.openSession()` |
 
-The ranges are illustrative: the plugin picks its source by store shape (whenever `sessionStatus` exists it takes the new path); the version numbers only mark where each shape appeared.
+The ranges are illustrative: the plugin picks its source by store shape (whenever `sessionStatus` exists it takes the new path); the version numbers only mark where each shape appeared. The `peerDependencies` range in `package.json` likewise only shapes npm's install warning — compatibility is declared per release in `dshReleases` after real testing, and untested new versions fall back to shape-driven behaviour.
 
 Verified to actually activate on `0.1.2-rc.1`, `0.1.5-rc.2` and `0.2.0-rc.2` (each booted in its own profile: the Settings → Notifications section registers, i.e. the plugin's `apply` really runs), and previously on `0.1.1-rc.2`. Two traps are worth remembering: a package listed in `dsh.client.inject` that a newer runtime no longer ships parks the client entry at `pending (waiting for services: …)` forever — which is what broke 1.1.3 on `0.1.2-rc.1` and later; and when the host renames a store or a field nothing throws, alerts just go **silent** — `0.2.0-rc.2` moved `pendingInteractions`→`sessionStatus`, `list.current`→`retainedBy.mainView` and `sessions.open()`→`uiWorkspace.openSession()`. So every adaptation must confirm `window.__dshNotifyMe.debug()` reports `bound` and which source answered.
 
@@ -136,14 +136,14 @@ The reminder core picks its interaction source per host generation (see the tabl
 
 - the **selected session's** `SessionSnapshot`: a `running: true → false` edge means a reply finished;
 - **pending interactions**: a new key in `uiSession.sessionStatus` (`>= 0.1.6`, per-session `pendingInteraction`) or in `pendingInteractions` (`0.1.2 .. 0.1.5`) means the agent is waiting on you — approval requests carry the tool name and reason, questions their text; older hosts fall back to the controller snapshot's `pending[]`;
-- **every other listed session's** summary: a `running: true → false` edge (or the legacy `completed` flag) alerts you about background work;
+- **every other listed session's** summary: a `running: true → false` edge (or the legacy `completed` flag) alerts you about background work. The host's completion-unread level flag backs that edge up and owns the title marker: `sessionStatus` rows' `completionUnread` on `>= 0.1.6` (lit when a background session finishes, cleared when it is opened / re-runs / disappears), the list row's `completed` reminder bit on older hosts (cleared on select). It re-reports a completion whose edge this page never saw (a plugin remount mid-turn, coalesced snapshots) exactly once, and when both views of one completion arrive together a short window collapses them into a single alert.
 - **subagent sessions**: **background** rows carrying `origin: 'subagent'` (and a `parentId`) stay muted by default. The subagent session you have open is exempt — its alerts follow the normal current-conversation rules (tab marker only while the page is visible, delivered on background), its outstanding waits are picked up when you switch into it, and switching away mutes them again. A fork has a `parentId` but no `origin`, is your own conversation, and keeps alerting throughout.
 
 The reminder core stays dependency-free and self-contained: notification copy resolves at alert time from the chosen language (follow-interface / Simplified Chinese / English). The Settings page is an **optional** React surface — it only registers into Settings when the web profile provides the `slots` / `locale` services and `react`; without them the plugin degrades gracefully to alerts-only (no Settings page).
 
 ### Quick decisions, and how they reach the agent
 
-Action buttons (`actions`) belong to persistent notifications shown through `ServiceWorkerRegistration.showNotification()`; passing `actions` to the `new Notification()` constructor throws a `TypeError`. That is a browser rule no plugin can route around, so the bundle holds two jobs in the same bytes: the page half registers the reminder factory as it always did, and the very same file is registered as a Service Worker whose only task is relaying which button was clicked back to the page. The decision itself happens in the page, through the same `PendingApproval.answer('allowed-once' | 'rejected')` the approval card uses — which is why "Approve" is exactly "Allow once" and nothing broader.
+Action buttons (`actions`) belong to persistent notifications shown through `ServiceWorkerRegistration.showNotification()`; passing `actions` to the `new Notification()` constructor throws a `TypeError`. That is a browser rule no plugin can route around, so the bundle holds two jobs in the same bytes: the page half registers the reminder factory as it always did, and the very same file is registered as a Service Worker whose only task is relaying which button was clicked back to the page. The decision itself happens in the page, through the same `PendingApproval.answer('allowed-once' | 'rejected')` the approval card uses — which is why "Approve" is exactly "Allow once" and nothing broader. The "raise a window and switch its conversation" part of a body click is scheduled on the worker half too: `client.focus()` raises exactly one window (a visible one first) and routes the conversation switch to that window alone, so several open DSH tabs never fight over focus or all switch at once.
 
 Every button toast is booked against its interaction key, so it can only decide the request it was raised for. Once the page answers that request or a newer one replaces it, clicking the leftover buttons decides nothing and just closes the notification. Button toasts also skip the auto-dismiss timer: an undecided approval stays in the notification center until you settle it.
 

package/README.md

@@ -43,7 +43,7 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 | 时机 | 提醒内容 | 默认 |
 | --- | --- | --- |
 | 🔔 **模型需要你操作** — 审批请求 / 方案待确认（plan review）/ 提问（`ask_user_question`） | 通知 + 提示音 + `🔔 需要你 ·` 标题标记；审批的通知上直接带「同意 / 拒绝」按钮 | 页面可见也提醒（当前对话除外：默认只留标题标记） |
-| ✅ **回复完成** — 一轮回复跑完；后台会话完成也会报 | 通知 + 提示音 | 仅页面隐藏/后台时提醒 |
+| ✅ **回复完成** — 一轮回复跑完；后台会话完成也会报 | 通知 + 提示音；后台会话**完成但还没看**的期间标题带 `✅ 回复完成 ·` 标记，打开该会话即撤 | 仅页面隐藏/后台时提醒（标题标记不受此限） |
 
 > **后台**子代理（subagent）子会话的等待与完成默认**不提醒**：DSH 把每个子代理子会话列成独立会话，但它们是所属主对话那一轮里的步骤，提醒只会是噪音。你当前打开的那个子代理会话不算在内，照常提醒。设置页「子代理会话不提醒」可关掉这个静音。
 
@@ -56,7 +56,7 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 - **页面打开时也提醒「需要你」**（默认开）与 **页面打开时也提醒「回复完成」**（默认关）；
 - **当前对话不弹通知**（默认开）：等待就发生在你正看着的对话里时只留标题标记，不弹通知也不响音（免得盖住审批卡片）；页面切到后台立刻补发，若你已经处理掉就作废。其它后台会话不受影响；
 - **子代理会话不提醒**（默认开）：后台子代理（subagent）子会话的「需要你」与「回复完成」都不提醒——它们是主对话那一轮的步骤，完成由主对话自己的提醒覆盖；你当前打开的那个子代理会话照常提醒；关掉后恢复逐会话提醒；
-- **点击通知回到对应对话**（默认开）：点通知把 DSH 带到前台并切到提醒所属的对话；关掉后点通知不做任何事；
+- **点击通知回到对应对话**（默认开）：点通知把 DSH 带到前台并切到提醒所属的对话；多个 DSH 标签页同时开着时，一次点击只调起一个窗口（优先当前可见的那个）并只切它的对话，其余标签页不动；关掉后点通知不做任何事；
 - **审批通知上直接裁决**（默认开）：权限审批的通知上带「同意 / 拒绝」按钮，点一下就按审批卡片的「允许一次 / 拒绝」直接裁决，不用切回页面；点通知正文仍是原来的「切回对应对话」；
 - **通知语言**：跟随界面 / 简体中文 / English——决定通知文字与 `🔔 …` 标题标记使用的语言；
 - **测试按钮**：用当前设置立即发一条「需要你」「回复完成」或「审批按钮」测试提醒（**不受**上面「页面打开时也提醒」开关限制；「需要你」测试的标题标记约 6 秒后自动消失）。
@@ -67,7 +67,7 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 
 - **系统通知**：经浏览器弹出的系统通知，进 Windows 通知中心或 macOS 通知中心（点击回到提醒所属的对话；审批的通知点按钮直接裁决）
 - **提示音**：WebAudio 合成音（「需要你」与「完成」使用不同音型）
-- **标签页标题标记**：有待处理事项时，标题前出现 `🔔 需要你 · …` / `🔔 Action needed · …`
+- **标签页标题标记**：有待处理事项时，标题前出现 `🔔 需要你 · …` / `🔔 Action needed · …`；后台会话**完成但还没看**时出现 `✅ 回复完成 · …` / `✅ Reply finished · …`，打开对应会话（或它再次开跑）即消失。两种标记可同时出现，「需要你」在前；宿主改写标题后标记基于新标题重建
 
 本插件是**浏览器层**实现：DSH 页面需保持打开（最小化/后台即可——那正是它监听的「离开」状态）。
 
@@ -88,7 +88,7 @@ dsh plugin --profile web add dsh-notify-me
 | `0.1.2-alpha.2 .. 0.1.6-alpha.1` | `uiSession.pendingInteractions` | 快照 `current` | `sessions.open()` |
 | `≥ 0.1.6-alpha.2`（含 `0.2.0-rc.2`） | `uiSession.sessionStatus` | `retainedBy.mainView` | `uiWorkspace.openSession()` |
 
-区间仅作示意：插件按 store 形状自动选源（`sessionStatus` 存在即走新路），版本号只是各形状的出现边界。
+区间仅作示意：插件按 store 形状自动选源（`sessionStatus` 存在即走新路），版本号只是各形状的出现边界。`package.json` 的 `peerDependencies` 范围同理只影响 npm install 的提示文案——兼容与否以 `dshReleases` 的逐版实测声明为准，未实测的新版本由形状驱动兜底。
 
 实测**真正激活**（各自独立 profile 启动：设置里出现「通知提醒」分区，即插件的 `apply` 确实执行）于 `0.1.2-rc.1`、`0.1.5-rc.2` 与 `0.2.0-rc.2`；更早的 `0.1.1-rc.2` 亦验证过。两个坑值得记住：一是 `dsh.client.inject` 里列了新版运行时已不再提供的包，客户端条目会停在 `pending (waiting for services: …)` 而永不执行——1.1.3 在 `0.1.2-rc.1` 及以后正是这样失效的；二是宿主换存储/字段名时**不会报错**，提醒只会静默失效——`0.2.0-rc.2` 上 `pendingInteractions`→`sessionStatus`、`list.current`→`retainedBy.mainView`、`sessions.open()`→`uiWorkspace.openSession()` 都是这一类，所以每次适配都要用 `window.__dshNotifyMe.debug()` 确认真的是 `bound`、以及用的是哪个来源。
 
@@ -132,14 +132,14 @@ window.__dshNotifyMe.decide("approval:3", "allowed-once")  // 程序化裁决：
 
 - **当前会话** `SessionSnapshot`：`running` true→false = 回复完成；
 - **待办交互**：`uiSession` 的 `sessionStatus`（`≥ 0.1.6`，逐会话 `pendingInteraction`）或 `pendingInteractions`（`0.1.2 .. 0.1.5`）出现新 key = 模型在等你，容器里带上审批工具名 / 理由、提问文本；旧宿主回落到控制器快照的 `pending[]`；
-- **其它已列会话**摘要：`running` true→false（或旧宿主的 `completed` 边沿）= 后台工作提醒。
+- **其它已列会话**摘要：`running` true→false（或旧宿主的 `completed` 边沿）= 后台工作提醒。宿主的「完成未读」级别标志负责补漏与标题标记：`≥ 0.1.6` 用 `sessionStatus` 行的 `completionUnread`（后台会话完成即点亮、打开该会话/再次开跑/会话消失即清零），旧宿主用列表行的 `completed` 提醒位（选中会话即清零）；页面没看见的完成边沿（插件热重载中途、快照合并跳变）由此补报一次，边沿与级别标志同来时按短时间窗合并，只响一声。
 - **子代理会话**：列表行带 `origin: 'subagent'`（并有 `parentId`）的**后台**会话默认静音；你正打开着的那个子代理会话不算静音对象，它的提醒走当前对话的常规规则（页面可见时默认只留标题标记、转后台补发），切进来时积压的等待同样补上，切走后重新静音。只有 `parentId`、没有 `origin` 的分支（fork）会话属于你自己的对话，始终照常提醒。
 
 提醒核心仍然零第三方运行时依赖、完全自包含：通知文字按所选语言（跟随界面 / 中文 / English）即时解析。设置页是**可选**的 React 呈现层——当 DSH web profile 提供 `slots` / `locale` / `react` 时才注册进「设置 → 通知提醒」，缺任一能力时插件自动降级为纯提醒（无设置页），不影响功能。
 
 ### 快捷裁决怎么走通的
 
-通知按钮（`actions`）只属于 Service Worker 弹的持久通知，往 `new Notification()` 里传 `actions` 会直接抛 `TypeError`——这是绕不开的浏览器限制。所以 bundle 一份文件干两件事：页面里照常注册提醒工厂，同一份字节再注册成一个只干转信的 Service Worker，把「点了哪个按钮」（同意 / 拒绝 / 点正文）带回页面。真正的裁决发生在页面里，调的是审批卡片自己用的 `PendingApproval.answer('allowed-once' | 'rejected')`，所以「同意」就是「允许一次」，不多放行任何东西。
+通知按钮（`actions`）只属于 Service Worker 弹的持久通知，往 `new Notification()` 里传 `actions` 会直接抛 `TypeError`——这是绕不开的浏览器限制。所以 bundle 一份文件干两件事：页面里照常注册提醒工厂，同一份字节再注册成一个只干转信的 Service Worker，把「点了哪个按钮」（同意 / 拒绝 / 点正文）带回页面。真正的裁决发生在页面里，调的是审批卡片自己用的 `PendingApproval.answer('allowed-once' | 'rejected')`，所以「同意」就是「允许一次」，不多放行任何东西。点正文的「调窗口 + 切对话」同样归 worker 这半侧调度：它用 `client.focus()` 只调起一个窗口（优先当前可见的），并只让那个窗口切对话——多个 DSH 标签页不会互相抢焦点或一起乱切。
 
 每条按钮通知按交互 key 记账，一次只认领一条等待；请求被页面里答掉、或被新请求顶替之后，残留通知上的按钮再点也不会误裁，只是安静地关掉。带按钮的通知不设自动消失——审批没裁决就一直留在通知中心里等你。
 

package/lib/client.js

@@ -28,6 +28,13 @@
 //       * "sessions" -> the selected session's ConversationSnapshot (running)
 //         and the session-list summaries of every other session (running /
 //         completed), which carry the "reply finished" edge on every version.
+//         The host's completion-unread level flag backs that edge up and owns
+//         the "完成未读" title marker: `sessionStatus.completionUnread` on
+//         0.1.6+ (armed when a background session finishes, cleared when it is
+//         opened / re-runs / disappears), the list row's `completed` reminder
+//         bit on older hosts. The edge path stays the reporter for the on-screen
+//         session (its snippet comes from the face snapshot); the two views of
+//         one completion are collapsed by reportDone's short dedupe window.
 //         The selected ("current") session is read from the list snapshot's
 //         `current` field where it exists (<= 0.1.5-rc.3) and otherwise derived
 //         from the mainView retention count (0.1.6+, the way the shipped
@@ -48,7 +55,8 @@
 //     card uses. Action buttons only exist on persistent notifications, so this
 //     file is dual-context: registered as a Service Worker as well, whose
 //     notificationclick relays the chosen button back to this page (broadcast +
-//     client postMessage). Where a worker cannot run (insecure context, no
+//     client postMessage) and, on a body click, raises exactly one window
+//     (client.focus()) and routes the conversation switch to that window alone. Where a worker cannot run (insecure context, no
 //     bundle URL) the plugin degrades to today's plain toast;
 //   - registers a "通知提醒 / Notify me" page into DSH Settings
 //     (settings.section slot) exposing an on/off master switch, per-channel
@@ -96,22 +104,92 @@
           }
         } catch (e) {}
       }
+      // One relayed click; `navigate` says whether the receiving page may
+      // steer its window (raise it + switch to the alerted conversation).
+      function clickMsg(base, navigate) {
+        return {
+          source: base.source,
+          type: base.type,
+          action: base.action,
+          key: base.key,
+          sessionId: base.sessionId,
+          navigate: navigate
+        };
+      }
+      // A body click means "take me there", and both halves of that request are
+      // this handler's job. The window raise belongs here because only a
+      // notificationclick carries the click's user activation — the page-side
+      // window.focus() a plain relay triggers afterwards can lose the OS
+      // foreground race and leave DSH behind other windows. So exactly one
+      // window client is picked (a visible one first), that client alone gets
+      // `navigate: true` plus the focus() call, and every other recipient gets
+      // `navigate: false` and stays put: several open DSH tabs must not fight
+      // over focus or all switch their own conversation at once. Buttons stay
+      // hands-off — deciding from the toast must not drag a window up. The
+      // `data.focus` flag (the autoFocus setting at show time) keeps the
+      // "off = clicking does nothing" promise even though a worker cannot read
+      // the page's config; toasts from older versions carry no flag and keep
+      // the previous best-effort behavior.
+      function deliverClick(base, wantsFocus) {
+        var send = function (list) {
+          list = list || [];
+          var best = null;
+          if (wantsFocus) {
+            for (var i = 0; i < list.length; i++) {
+              var c = list[i];
+              if (!c || typeof c.postMessage !== "function") continue;
+              if (c.visibilityState === "visible") { best = c; break; }
+              if (!best) best = c;
+            }
+          }
+          for (var j = 0; j < list.length; j++) {
+            try { list[j].postMessage(clickMsg(base, wantsFocus && list[j] === best)); } catch (e) {}
+          }
+          try {
+            if (typeof g.BroadcastChannel === "function") {
+              var ch = new g.BroadcastChannel(BRIDGE_CHANNEL);
+              ch.postMessage(clickMsg(base, false));
+              try { ch.close(); } catch (e) {}
+            }
+          } catch (e) {}
+          if (best && typeof best.focus === "function") {
+            try {
+              var fp = best.focus();
+              if (fp && typeof fp.then === "function") fp.then(null, function () {});
+            } catch (e) {}
+          }
+        };
+        try {
+          if (g.clients && typeof g.clients.matchAll === "function") {
+            var p = g.clients.matchAll({ type: "window", includeUncontrolled: true });
+            if (p && typeof p.then === "function") {
+              p.then(send, function () { relay(clickMsg(base, wantsFocus)); });
+              return;
+            }
+          }
+        } catch (e) {}
+        relay(clickMsg(base, wantsFocus));
+      }
       g.addEventListener("notificationclick", function (event) {
         try {
           var n = event.notification;
           var data = (n && n.data) || {};
-          var msg = {
+          var action = event.action || "";
+          var base = {
             source: "dsh-notify-me",
             type: "notification",
-            action: event.action || "",
+            action: action,
             key: data.key || null,
             sessionId: data.sessionId || null
           };
           try { if (n && typeof n.close === "function") n.close(); } catch (e) {}
+          var run = action
+            ? function () { relay(base); }
+            : function () { deliverClick(base, data.focus !== false); };
           if (typeof event.waitUntil === "function") {
-            event.waitUntil(Promise.resolve().then(function () { relay(msg); }));
+            event.waitUntil(Promise.resolve().then(run));
           } else {
-            relay(msg);
+            run();
           }
         } catch (e) {}
       });
@@ -156,7 +234,7 @@
       toast: true,
       sound: true,
       volume: 0.5,
-      autoFocus: true, // clicking the toast focuses the DSH window
+      autoFocus: true, // clicking the toast raises DSH and switches to the alerted conversation
       // Approval toasts carry 同意/拒绝 buttons and settle the request on one
       // click (the same answer('allowed-once' | 'rejected') the in-page
       // approval card sends). Buttons need persistent notifications, served
@@ -203,6 +281,7 @@
         doneBody: "回复已完成",
         background: "后台会话",
         marker: "🔔 需要你 · ",
+        doneMarker: "✅ 回复完成 · ",
         sep: "：",
         approve: "同意",
         reject: "拒绝",
@@ -226,6 +305,7 @@
         doneBody: "Reply finished",
         background: "Background session",
         marker: "🔔 Action needed · ",
+        doneMarker: "✅ Reply finished · ",
         sep: ": ",
         approve: "Approve",
         reject: "Reject",
@@ -406,6 +486,11 @@
       if (!msg || msg.source !== "dsh-notify-me" || msg.type !== "notification") return;
       if (msg.action === "approve") { decidePending(msg.key, "allowed-once"); return; }
       if (msg.action === "reject") { decidePending(msg.key, "rejected"); return; }
+      // The worker picks the one window a click should land on (see the bridge):
+      // its `navigate: false` copies keep every other DSH tab from stealing
+      // focus or switching its own conversation. A message from before that
+      // flag existed carries none and falls back to the old best-effort route.
+      if (msg.navigate === false) return;
       if (config.autoFocus) focusSession(msg.sessionId || null);
     }
     // The live interaction wins over the reference captured at alert time (the
@@ -506,7 +591,7 @@
               // The plugin owns the audio (see showToast's silent note below).
               silent: true,
               icon: (location.origin || "") + "/favicon.svg",
-              data: { key: quick.key, sessionId: sessionId || null, kind: kind, test: !!quick.test },
+              data: { key: quick.key, sessionId: sessionId || null, kind: kind, test: !!quick.test, focus: config.autoFocus !== false },
               actions: [
                 { action: "approve", title: d.approve },
                 { action: "reject", title: d.reject }
@@ -599,16 +684,25 @@
     // title over (or an earlier load leaving a marker behind) can never make us
     // mistake our own marker for the base title.
     var attentionActive = 0;
+    var doneActive = 0; // "完成未读" marks, one per finished-but-unread session
     var hostBase = null; // document.title as the host last left it
     var writtenTitle = null; // exact string this plugin last put into document.title
-    // Our own marker prefix never belongs to the base title — strip a leftover
-    // one (an earlier load that was closed while a wait was pending, or a title
-    // the host tracked while a marker was up) before storing the base.
+    // Our own marker prefixes never belong to the base title — strip leftovers
+    // (an earlier load that was closed while a mark was up, or a title the host
+    // tracked while a marker was up) before storing the base. Both marker kinds
+    // can be up at once and either may lead, so strip repeatedly.
     function cleanBase(t) {
       var d = texts();
-      var prefixes = [d.marker, TXT.zh.marker, TXT.en.marker];
-      for (var i = 0; i < prefixes.length; i++) {
-        while (t.indexOf(prefixes[i]) === 0) t = t.slice(prefixes[i].length);
+      var prefixes = [d.marker, TXT.zh.marker, TXT.en.marker, d.doneMarker, TXT.zh.doneMarker, TXT.en.doneMarker];
+      var stripped = true;
+      while (stripped) {
+        stripped = false;
+        for (var i = 0; i < prefixes.length; i++) {
+          if (prefixes[i] && t.indexOf(prefixes[i]) === 0) {
+            t = t.slice(prefixes[i].length);
+            stripped = true;
+          }
+        }
       }
       return t;
     }
@@ -616,7 +710,15 @@
       try {
         var current = String(document.title || "");
         if (current !== writtenTitle) hostBase = cleanBase(current);
-        var next = (config.enabled && attentionActive > 0) ? texts().marker + hostBase : hostBase;
+        var d = texts();
+        var prefix = "";
+        if (config.enabled) {
+          // "needs you" leads when both kinds are up: it is the one that wants
+          // action, the unread mark only says something finished.
+          if (attentionActive > 0) prefix += d.marker;
+          if (doneActive > 0) prefix += d.doneMarker;
+        }
+        var next = prefix + hostBase;
         writtenTitle = next;
         if (current !== next) document.title = next;
       } catch (e) {}
@@ -629,6 +731,24 @@
       if (attentionActive > 0) attentionActive -= 1;
       applyTitle();
     }
+    // Unread-reply marker: one per session id, held exactly while the host
+    // still calls the completion unread (sessionStatus.completionUnread on
+    // 0.1.6+, the list row's `completed` reminder bit on older hosts) and
+    // dropped the moment the session is opened — the tab then reads "something
+    // finished, waiting for you" until it is read.
+    var doneUnreadMarks = Object.create(null); // sid -> true
+    function markDoneUnread(sid) {
+      if (!sid || doneUnreadMarks[sid]) return;
+      doneUnreadMarks[sid] = true;
+      doneActive += 1;
+      applyTitle();
+    }
+    function unmarkDoneUnread(sid) {
+      if (!sid || !doneUnreadMarks[sid]) return;
+      delete doneUnreadMarks[sid];
+      if (doneActive > 0) doneActive -= 1;
+      applyTitle();
+    }
     // Title marker ownership: on hosts that publish pending interactions
     // (uiSession) that source owns the marker, but whichever source saw the wait
     // first must still mark it (the other one may never report that key at all),
@@ -664,6 +784,14 @@
     // release path deletes it) and is re-delivered once the page is backgrounded.
     var quietedAttention = Object.create(null);
     var lastAttentionAt = 0;
+    // One completion can reach this plugin twice: the running edge from the
+    // controller snapshots and the completionUnread level flag from
+    // sessionStatus are two views of the same host event and land in the same
+    // tick (the host publishes both stores from one manager update). A short
+    // per-session window collapses them; two genuine completions of one session
+    // are never that close — each needs a whole turn in between.
+    var doneFiredAt = Object.create(null); // sid -> last done report timestamp
+    var DONE_DEDUPE_MS = 250;
 
     function hidden() { return document.hidden || document.visibilityState === "hidden"; }
 
@@ -804,6 +932,18 @@
       if (snippet) body = body + "\n" + snippet;
       fire("done", d.doneTitle, body, false, sessionId);
     }
+    // Every "reply finished" report funnels through here, so the edge path and
+    // the completionUnread level flag cannot double-alert one completion. The
+    // timestamp is recorded even when the visibility rules suppress the toast:
+    // the report was handled (the unread marker is what persists), not queued.
+    function reportDone(sessionLabel, snippet, sessionId) {
+      if (sessionId) {
+        var now = Date.now();
+        if (doneFiredAt[sessionId] && now - doneFiredAt[sessionId] < DONE_DEDUPE_MS) return;
+        doneFiredAt[sessionId] = now;
+      }
+      fireDone(sessionLabel, snippet, sessionId);
+    }
     // Test alerts deliberately ignore the visibility rules (attentionHiddenOnly
     // / doneHiddenOnly): the whole point of a test button is to prove the
     // channel works while you are looking at the page. Only the master switch
@@ -960,7 +1100,7 @@
       // 2) a non-selected session finished while we were away (sidebar "done")
       var notified = false;
       if (!muted && !row.face && row.completed && prev && !prev.completed && prev.seeded) {
-        fireDone(sessionLabelText(row), "", row.id);
+        reportDone(sessionLabelText(row), "", row.id);
         notified = true;
       }
 
@@ -970,7 +1110,7 @@
         if (Date.now() - lastAttentionAt < 300) {
           /* answered by an attention alert above */
         } else {
-          fireDone(sessionLabelText(row), row.face ? snippetOfLastAssistant(row.faceSnap) : "", row.id);
+          reportDone(sessionLabelText(row), row.face ? snippetOfLastAssistant(row.faceSnap) : "", row.id);
         }
       }
 
@@ -986,6 +1126,16 @@
       if (!uiPending && prev && prevPendingKeys.length > 0 && pendingNow.length === 0) {
         for (var r = 0; r < prevPendingKeys.length; r++) unmarkAttention(prevPendingKeys[r]);
       }
+
+      // Unread-reply marker on hosts whose reminder bit lives in the list row
+      // (`completed`: armed when a non-selected session finishes, cleared on
+      // select — the manager's completedNotifications). Hosts exposing
+      // sessionStatus get their marker from syncDoneFromStatus instead; the
+      // two never share a row, so the mark counter stays balanced.
+      if (!statusDoneSource()) {
+        if (row.completed && !muted) markDoneUnread(row.id);
+        else unmarkDoneUnread(row.id);
+      }
     }
 
     // face -> row adapter (selected session, rich data)
@@ -1054,12 +1204,18 @@
         bindCurrentFace();
         bindUiSession();
         // The subagent mute keys on "not the session on screen", and switching
-        // sessions only emits on the list store — re-run the interaction pass so
+        // sessions only emits on the list store — re-run the status pass so
         // the decision tracks the switch: opening a muted subagent session
         // announces its outstanding wait (under the current-conversation rules),
         // leaving it puts the next edge back in the muted bucket.
-        evalUiPending();
+        evalUiStatus();
         var byId = (st && st.byId) || {};
+        // A vanished row drops its unread-reply mark with it: the host forgets
+        // the reminder bit together with the row, and a gone row reports
+        // nothing. (Hosts with sessionStatus sweep this in syncDoneFromStatus.)
+        if (!statusDoneSource()) {
+          for (var mk in doneUnreadMarks) if (!byId[mk]) unmarkDoneUnread(mk);
+        }
         for (var sid in byId) {
           if (sid === cur) continue; // current handled by the face watcher
           var sum = byId[sid];
@@ -1162,16 +1318,22 @@
       uiStore = store;
       uiSource = found.source;
       uiPending = true; // this watcher now owns the title marker
-      uiSub = store.subscribe(function () { try { evalUiPending(); } catch (e) {} });
+      uiSub = store.subscribe(function () { try { evalUiStatus(); } catch (e) {} });
       noteUiBind("bound");
-      evalUiPending(); // seed: a wait that predates this plugin still alerts once
+      evalUiStatus(); // seed: a wait that predates this plugin still alerts once
+    }
+    // True once the sessionStatus store is the live uiSession source (0.1.6+):
+    // its rows then also own the completion-unread level flag and its marker.
+    function statusDoneSource() {
+      return !!(uiPending && uiSource === "sessionStatus");
     }
-    function evalUiPending() {
+    function evalUiStatus() {
       var svc = lookupService("uiSession");
       var found = interactionStore(svc);
       if (!found || typeof found.store.getSnapshot !== "function") return;
       var snap = found.store.getSnapshot(); // Map<sessionId, interaction|status>
       if (!snap || typeof snap.forEach !== "function") return;
+      if (found.source === "sessionStatus") syncDoneFromStatus(snap);
       var seen = Object.create(null);
       snap.forEach(function (value, sid) {
         var it = pendingOf(value, found.source);
@@ -1210,6 +1372,42 @@
         delete uiBaseline[sid2];
       }
     }
+    // The sessionStatus rows also carry the reply-finished channel's level
+    // flag (0.1.6-alpha.2+): `completionUnread` lights when a session that is
+    // not on screen finishes and clears when the session is opened, starts
+    // running again, or disappears. Two jobs live here:
+    //   * the "完成未读" title marker, held exactly while a background session
+    //     is finished-but-unread — open the session and the tab goes quiet;
+    //   * one done alert for completions whose running edge this page never saw
+    //     (coalesced list snapshots, a plugin remount mid-turn, a completion
+    //     that predates this bind). The latch reports each unread instance once;
+    //     reportDone's window collapses the double view when the edge did fire.
+    // The edge path stays the reporter for the on-screen session (its snippet
+    // comes from the face snapshot) and for hosts without this store.
+    var uiDoneBaseline = Object.create(null); // sid -> true once this unread reported
+    function syncDoneFromStatus(snap) {
+      var want = Object.create(null);
+      try {
+        snap.forEach(function (value, sid) {
+          if (!value) return;
+          // A stop that awaits input (plan-review / question end the turn with
+          // a pending interaction) is a wait, not a completion — the same rule
+          // as the edge path's !hasPendingNow guard. The on-screen session is
+          // never "unread" (the host clears the flag for it; its completion is
+          // the face edge's job), and a background subagent step is muted.
+          if (!value.completionUnread || value.pendingInteraction || isSubagentSession(sid) || currentSessionId() === sid) return;
+          want[sid] = true;
+          markDoneUnread(sid);
+          if (uiDoneBaseline[sid]) return; // this unread instance already reported
+          uiDoneBaseline[sid] = true;
+          if (Date.now() - lastAttentionAt < 300) return; // same-tick attention owns the moment
+          reportDone(labelForSessionId(sid), "", sid);
+        });
+      } catch (e) {}
+      // answered / re-run / gone / muted: latch and mark go with the flag
+      for (var s in uiDoneBaseline) if (!want[s]) delete uiDoneBaseline[s];
+      for (var m in doneUnreadMarks) if (!want[m]) unmarkDoneUnread(m);
+    }
     function detachUiSession() {
       if (uiSub) { try { uiSub(); } catch (e) {} uiSub = null; }
       uiStore = null;
@@ -1218,6 +1416,8 @@
       // go back to the controller marker path
       for (var s in uiBaseline) unmarkAttention(uiBaseline[s].key);
       uiBaseline = Object.create(null);
+      for (var dm in doneUnreadMarks) unmarkDoneUnread(dm);
+      uiDoneBaseline = Object.create(null);
       uiPending = false;
     }
 
@@ -1235,7 +1435,7 @@
       });
     } catch (e) {}
     // keep in sync with package.json "version" on every release
-    api.version = "1.4.0";
+    api.version = "1.5.1";
     api.setConfig = function (patch) { return setConfigLocal(patch); };
     api.resetConfig = function () {
       try { localStorage.removeItem(LS_CONFIG); } catch (e) {}
@@ -1286,6 +1486,7 @@
         pendingBaselines: Object.keys(uiBaseline).length,
         firedKeys: Object.keys(attentionKeysFired),
         markedKeys: Object.keys(attentionKeysMarked),
+        doneUnreadMarked: Object.keys(doneUnreadMarks),
         quietedKeys: Object.keys(quietedAttention),
         lastAttentionAt: lastAttentionAt ? new Date(lastAttentionAt).toISOString() : null
       };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-notify-me",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "DSH 桌面消息提醒插件：模型需要你操作（审批/方案确认/提问的可操作提醒）或回复在后台完成时，系统通知+提示音+标签页标题提醒你；权限审批的通知上可直接点「同意/拒绝」完成裁决；可在设置页开关并切换通知语言。Desktop notification & message alerts for DeepSeek Harness web — toasts, sounds and a tab-title marker when the agent needs your input (approval / plan review / question) or a reply finishes in the background, Approve/Reject buttons on approval toasts to decide right from the notification; toggleable from Settings with zh/en notification language.",
   "license": "MIT",
   "type": "module",