dsh-notify-me 1.3.1 → 1.5.0

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 All notable changes to **dsh-notify-me** are documented here.
 
+## [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
+
+### 新增
+- **子代理会话不提醒**（设置页新开关「子代理会话不提醒」，默认开启）：DSH 把每个子代理（subagent）子会话列成独立会话行（`origin: 'subagent'` 加 `parentId`），于是这些子会话的「需要你」与「回复完成」都会照常弹通知——可它们是所属主对话那一轮里的步骤，提醒只是噪音。现在默认静音**后台**子代理会话：列表行评估与 `sessionStatus` 等待通道都跳过「带 `origin: 'subagent'` 且不是当前会话」的行；你正打开着的那个子代理会话不算静音对象，照常提醒（走当前对话的常规规则：页面可见时默认只留标题标记、转后台补发）。主对话自己的提醒不受影响。
+- 判定认 `origin` 加「不是当前会话」两条：只有 `parentId`、没有 `origin` 的分支（fork）会话仍是你自己的对话，照常提醒；静音随你打开的会话实时变化——切进某个后台子代理会话，它积压的等待按当前对话的规则补上，切走后重新回到静音范围（标题标记与排队中的通知一并撤下）。静音开关读的是实时配置，切换后下一条事件即生效，不需要重载页面。
+- `window.__dshNotifyMe` 配置新增 `ignoreSubagent`（默认 `true`，可用 `setConfig` / `resetConfig` 调整），`debug()` 新增同名字段便于核对。
+
+### 变更
+- 版本号 1.3.1 → 1.4.0；`window.__dshNotifyMe.version` 同步。
+- README（中英）补上设置页新开关、提醒时机说明、控制台配置示例与工作原理里的子代理口径。
+- README（中英）新增「致谢与贡献须知 / Credits & how contributions land」：外部 PR 的署名口径与贡献者名单；「只静音后台子代理、当前打开的照常提醒」这一口径来自 [@d0ublecl1ck](https://github.com/d0ublecl1ck) 在 [#8](https://github.com/chromoany/dsh-notify-me/pull/8) 讨论里的建议（收编进 main 的原版是整条静音），本次按该口径改准并由维护者落地。
+
+### 测试
+- `smoke/smoke-test.cjs` 新增子代理用例：`ignoreSubagent` 默认值与 `debug()` 字段、后台子代理完成不提醒而普通后台会话照常、后台子代理等待不提醒也不打标题标记、分支（fork）会话仍提醒、关掉开关后子代理的等待与完成重新提醒，以及「当前打开的子代理会话照常提醒」——等待与完成都提醒；后台积压的等待在切进去时按当前对话的规则排队补发，切走则连标题标记与排队通知一起撤下。
+
 ## [1.3.1] — 2026-10-03
 
 ### 文档

package/README.en.md

@@ -43,7 +43,9 @@ 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.
 
 ## Configure it from DSH Settings
 
@@ -53,6 +55,7 @@ Open **Settings → Notify me** (refresh the page once after installing):
 - **System notifications / Sound / Volume** — toast toggle, WebAudio beep toggle and a volume slider;
 - **"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;
 - **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;
@@ -64,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).
 
@@ -85,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.
 
@@ -116,6 +119,7 @@ window.__dshNotifyMe.setConfig({
   attentionHiddenOnly: false, // true = don't alert "needs you" while the page is visible
   currentHiddenOnly: true,    // true = waits in the conversation on screen keep only the tab marker (replayed once backgrounded)
   doneHiddenOnly: true,       // false = also alert "reply finished" while visible
+  ignoreSubagent: true,       // true = never alert for background subagent sessions (the open one is exempt)
   toast: true,                // system-notification toggle
   sound: true,                // sound toggle
   volume: 0.5,                // 0..1
@@ -132,7 +136,8 @@ 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).
 
@@ -167,6 +172,15 @@ npm pack --dry-run               # preview the published tarball
 
 `cordis-host-test.mjs` borrows `@deepseek-ai/cordis` from a local DSH installation (it probes the global npm directory, `~/.dsh/profiles/web/node_modules` and the flat fallback `~/.dsh/profiles/node_modules` in turn); in a source checkout with no profile dependencies, point it there with `DSH_CORDIS_PATH=<checkout>/vendor/cordis/lib/index.js`.
 
+## Credits & how contributions land
+
+Contributors (by handle; the linked PR is their change):
+
+- [@AgMahone](https://github.com/AgMahone) — [#7](https://github.com/chromoany/dsh-notify-me/pull/7): the 0.1.6+ / 0.2.0 host-generation support, plus the double-chime and cordis-lookup reports and retesting;
+- [@d0ublecl1ck](https://github.com/d0ublecl1ck) — [#8](https://github.com/chromoany/dsh-notify-me/pull/8): muting subagent sessions (`ignoreSubagent`) with its tests and docs; the 1.4.0 refinement — mute only background subagents, alert as usual for the one you have open — is his suggestion from the #8 discussion, landed by the maintainer.
+
+Attribution policy: external PRs are landed as maintainer commits — the original commit is not reused and no Co-authored-by trailer is added, so GitHub's contributors graph lists the maintainer only and contributors are credited above.
+
 ## License
 
 MIT — see [LICENSE](LICENSE).

package/README.md

@@ -43,7 +43,9 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 | 时机 | 提醒内容 | 默认 |
 | --- | --- | --- |
 | 🔔 **模型需要你操作** — 审批请求 / 方案待确认（plan review）/ 提问（`ask_user_question`） | 通知 + 提示音 + `🔔 需要你 ·` 标题标记；审批的通知上直接带「同意 / 拒绝」按钮 | 页面可见也提醒（当前对话除外：默认只留标题标记） |
-| ✅ **回复完成** — 一轮回复跑完；后台会话完成也会报 | 通知 + 提示音 | 仅页面隐藏/后台时提醒 |
+| ✅ **回复完成** — 一轮回复跑完；后台会话完成也会报 | 通知 + 提示音；后台会话**完成但还没看**的期间标题带 `✅ 回复完成 ·` 标记，打开该会话即撤 | 仅页面隐藏/后台时提醒（标题标记不受此限） |
+
+> **后台**子代理（subagent）子会话的等待与完成默认**不提醒**：DSH 把每个子代理子会话列成独立会话，但它们是所属主对话那一轮里的步骤，提醒只会是噪音。你当前打开的那个子代理会话不算在内，照常提醒。设置页「子代理会话不提醒」可关掉这个静音。
 
 ## 在 DSH 设置里改配置
 
@@ -53,6 +55,7 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 - **系统通知 / 提示音 / 音量**：Toast、WebAudio 提示音与音量滑块；
 - **页面打开时也提醒「需要你」**（默认开）与 **页面打开时也提醒「回复完成」**（默认关）；
 - **当前对话不弹通知**（默认开）：等待就发生在你正看着的对话里时只留标题标记，不弹通知也不响音（免得盖住审批卡片）；页面切到后台立刻补发，若你已经处理掉就作废。其它后台会话不受影响；
+- **子代理会话不提醒**（默认开）：后台子代理（subagent）子会话的「需要你」与「回复完成」都不提醒——它们是主对话那一轮的步骤，完成由主对话自己的提醒覆盖；你当前打开的那个子代理会话照常提醒；关掉后恢复逐会话提醒；
 - **点击通知回到对应对话**（默认开）：点通知把 DSH 带到前台并切到提醒所属的对话；关掉后点通知不做任何事；
 - **审批通知上直接裁决**（默认开）：权限审批的通知上带「同意 / 拒绝」按钮，点一下就按审批卡片的「允许一次 / 拒绝」直接裁决，不用切回页面；点通知正文仍是原来的「切回对应对话」；
 - **通知语言**：跟随界面 / 简体中文 / English——决定通知文字与 `🔔 …` 标题标记使用的语言；
@@ -64,7 +67,7 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 
 - **系统通知**：经浏览器弹出的系统通知，进 Windows 通知中心或 macOS 通知中心（点击回到提醒所属的对话；审批的通知点按钮直接裁决）
 - **提示音**：WebAudio 合成音（「需要你」与「完成」使用不同音型）
-- **标签页标题标记**：有待处理事项时，标题前出现 `🔔 需要你 · …` / `🔔 Action needed · …`
+- **标签页标题标记**：有待处理事项时，标题前出现 `🔔 需要你 · …` / `🔔 Action needed · …`；后台会话**完成但还没看**时出现 `✅ 回复完成 · …` / `✅ Reply finished · …`，打开对应会话（或它再次开跑）即消失。两种标记可同时出现，「需要你」在前；宿主改写标题后标记基于新标题重建
 
 本插件是**浏览器层**实现：DSH 页面需保持打开（最小化/后台即可——那正是它监听的「离开」状态）。
 
@@ -85,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`、以及用的是哪个来源。
 
@@ -112,6 +115,7 @@ window.__dshNotifyMe.setConfig({
   attentionHiddenOnly: false, // true = 页面可见时「需要你」不提醒
   currentHiddenOnly: true,    // true = 当前对话的等待只留标题标记（转后台补发）
   doneHiddenOnly: true,       // false = 页面可见时「完成」也提醒
+  ignoreSubagent: true,       // true = 后台子代理（subagent）会话不提醒（当前打开的照常）
   toast: true,                // 系统通知开关
   sound: true,                // 提示音开关
   volume: 0.5,                // 音量 0~1
@@ -128,7 +132,8 @@ 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` 时才注册进「设置 → 通知提醒」，缺任一能力时插件自动降级为纯提醒（无设置页），不影响功能。
 
@@ -163,6 +168,15 @@ npm pack --dry-run               # 预览发布包
 
 `cordis-host-test.mjs` 会从本机 DSH 安装借 `@deepseek-ai/cordis`（依次探测 npm 全局目录、`~/.dsh/profiles/web/node_modules` 与 `~/.dsh/profiles/node_modules` 平铺回退目录）；源码 checkout 里没有 profile 依赖时，用 `DSH_CORDIS_PATH=<checkout>/vendor/cordis/lib/index.js` 指定即可。
 
+## 致谢与贡献须知
+
+贡献者（按 handle 列出，对应 PR 就是他们提的改动）：
+
+- [@AgMahone](https://github.com/AgMahone) — [#7](https://github.com/chromoany/dsh-notify-me/pull/7)：0.1.6+ / 0.2.0 宿主代际支持，以及通知双响、cordis 查找路径的报障与复测；
+- [@d0ublecl1ck](https://github.com/d0ublecl1ck) — [#8](https://github.com/chromoany/dsh-notify-me/pull/8)：子代理会话静音（`ignoreSubagent`）与配套测试、文档；1.4.0 里「只静音后台子代理、当前打开的照常提醒」的口径同样出自他在 #8 讨论里的建议，落地由维护者完成。
+
+署名口径：本仓库收编外部 PR 时以维护者提交落地——不沿用原 commit、不挂 Co-authored-by，GitHub 的 contributors 图只显示维护者，贡献者以上面的致谢署名。
+
 ## License
 
 MIT — 见 [LICENSE](LICENSE)。

package/lib/client.js

@@ -28,10 +28,23 @@
 //       * "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
 //         DocumentTitle / ui-session pick it);
+//   - mutes background subagent child sessions by default
+//     (config.ignoreSubagent): DSH lists them as ordinary rows carrying
+//     `origin: 'subagent'`, but their waits and finish edges are steps of the
+//     parent conversation's turn. The subagent session the user has open is not
+//     muted — it is on screen like any other conversation and alerts by the
+//     normal rules;
 //   - fires a Windows desktop Notification (+ optional sound) when the agent
 //     needs the user's input — pending interaction kinds 'approval',
 //     'plan-review' or 'question' — and when a reply/turn finishes;
@@ -140,6 +153,13 @@
       // the page brings that alert back (see flushQuieted).
       currentHiddenOnly: true, // the visible session's own waits stay silent
       doneHiddenOnly: true, // reply-finished alerts only when the page is hidden
+      // Background subagent child sessions are steps of another conversation's
+      // turn: DSH lists each of them as its own row (origin: 'subagent'), so
+      // their waits and finish edges would toast noise the user cannot act on.
+      // Muted by default; the list row's own origin field is the only thing this
+      // keys on, plus "not the session on screen" — an open subagent session is
+      // just another conversation to alert for.
+      ignoreSubagent: true,
       toast: true,
       sound: true,
       volume: 0.5,
@@ -190,6 +210,7 @@
         doneBody: "回复已完成",
         background: "后台会话",
         marker: "🔔 需要你 · ",
+        doneMarker: "✅ 回复完成 · ",
         sep: "：",
         approve: "同意",
         reject: "拒绝",
@@ -213,6 +234,7 @@
         doneBody: "Reply finished",
         background: "Background session",
         marker: "🔔 Action needed · ",
+        doneMarker: "✅ Reply finished · ",
         sep: ": ",
         approve: "Approve",
         reject: "Reject",
@@ -586,16 +608,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;
     }
@@ -603,7 +634,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) {}
@@ -616,6 +655,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),
@@ -651,6 +708,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"; }
 
@@ -748,6 +813,28 @@
       } catch (e) {}
       return sid;
     }
+    // Should this session's alerts stay muted as a subagent? Every child session
+    // a subagent run created is listed as a row carrying `origin: 'subagent'`
+    // (plus a parentId), including the rows the host synthesizes from its
+    // subagentCatalog. Those alerts describe a step of another conversation's
+    // turn, so the ones running in the background are muted by default
+    // (config.ignoreSubagent); a forked session has a parentId but no origin and
+    // is the user's own conversation, so it keeps alerting. The subagent session
+    // the user has open is not background at all: it is on screen like any other
+    // conversation, so it alerts by the normal rules (including the
+    // current-conversation quiet rule) and is never a mute candidate. Read live
+    // rather than cached, so the settings switch and session switches both take
+    // effect on the next event without rebinding anything.
+    function isSubagentSession(sid) {
+      if (!config.ignoreSubagent || !sid) return false;
+      if (currentSessionId() === sid) return false;
+      try {
+        var st = listStore && listStore.getSnapshot();
+        var sum = st && st.byId && st.byId[sid];
+        if (sum && sum.origin === "subagent") return true;
+      } catch (e) {}
+      return false;
+    }
     // Returns null once the alert went out, or the copy it would have shown
     // when only the visible-session rule held it back — the caller queues that
     // copy by interaction key so it can still fire from the background (the
@@ -769,6 +856,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
@@ -888,12 +987,20 @@
       var pendingNow = row.pending || [];
       var prevPendingKeys = prev ? prev.pendingKeys : [];
       var wasRunning = prev ? prev.running : false;
+      var muted = isSubagentSession(row.id);
       var newKeys = [];
-      for (var i = 0; i < pendingNow.length; i++) {
-        var pk = pendingNow[i].key;
-        if (prevPendingKeys.indexOf(pk) === -1 && !attentionKeysFired[pk]) {
-          newKeys.push(pendingNow[i]);
-          attentionKeysFired[pk] = true;
+      // A muted row still feeds the baseline below, so lifting the mute
+      // (turning the switch off, or opening that subagent session) resumes
+      // alerting from the next edge on instead of replaying old ones.
+      // Its keys are left out of attentionKeysFired on purpose: a wait that was
+      // never announced must stay announceable once the mute is lifted.
+      if (!muted) {
+        for (var i = 0; i < pendingNow.length; i++) {
+          var pk = pendingNow[i].key;
+          if (prevPendingKeys.indexOf(pk) === -1 && !attentionKeysFired[pk]) {
+            newKeys.push(pendingNow[i]);
+            attentionKeysFired[pk] = true;
+          }
         }
       }
       var hasPendingNow = pendingNow.length > 0;
@@ -905,7 +1012,7 @@
       //    On hosts that expose uiSession this is the fallback path only: the
       //    interaction snapshot there is the authoritative source, and it drives
       //    the title marker itself (see the uiSession watcher below).
-      if (newKeys.length > 0) {
+      if (!muted && newKeys.length > 0) {
         var it = newKeys[0];
         var quick = quickFor(it.key, it, row.id);
         var copy = fireAttention(it.kind, sessionLabelText(row), textFromPayload(it.payload), !!row.face, row.id, quick);
@@ -916,18 +1023,18 @@
 
       // 2) a non-selected session finished while we were away (sidebar "done")
       var notified = false;
-      if (!row.face && row.completed && prev && !prev.completed && prev.seeded) {
-        fireDone(sessionLabelText(row), "", row.id);
+      if (!muted && !row.face && row.completed && prev && !prev.completed && prev.seeded) {
+        reportDone(sessionLabelText(row), "", row.id);
         notified = true;
       }
 
       // 3) running true -> false on a session we were watching: a reply finished
-      if (!notified && prev && prev.seeded && wasRunning && !runningNow && !hasPendingNow) {
+      if (!muted && !notified && prev && prev.seeded && wasRunning && !runningNow && !hasPendingNow) {
         // ignore the edge if it happened in the same tick as an attention alert
         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);
         }
       }
 
@@ -943,6 +1050,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)
@@ -1010,7 +1127,19 @@
         var cur = currentSessionId();
         bindCurrentFace();
         bindUiSession();
+        // The subagent mute keys on "not the session on screen", and switching
+        // 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.
+        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];
@@ -1113,22 +1242,35 @@
       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
     }
-    function evalUiPending() {
+    // 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 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);
         // A session with no pending interaction is not "seen": leaving it out
         // lets the teardown pass below release any mark its answer replaced.
         if (!it) return;
+        // A background subagent wait is muted and deliberately leaves no
+        // baseline: the row is what isSubagentSession reads, and skipping the
+        // record here also lets the teardown pass drop a mark whose wait was
+        // announced before the mute was switched on (or before the user
+        // switched away from that subagent session). Opening the session later
+        // announces the outstanding wait then, like any first sighting.
+        if (isSubagentSession(sid)) return;
         seen[sid] = true;
         var key = it.key || (it.kind + ":" + sid);
         var prev = uiBaseline[sid];
@@ -1154,6 +1296,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;
@@ -1162,6 +1340,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;
     }
 
@@ -1179,7 +1359,7 @@
       });
     } catch (e) {}
     // keep in sync with package.json "version" on every release
-    api.version = "1.3.1";
+    api.version = "1.5.0";
     api.setConfig = function (patch) { return setConfigLocal(patch); };
     api.resetConfig = function () {
       try { localStorage.removeItem(LS_CONFIG); } catch (e) {}
@@ -1212,6 +1392,7 @@
         attentionHiddenOnly: config.attentionHiddenOnly,
         currentHiddenOnly: config.currentHiddenOnly,
         doneHiddenOnly: config.doneHiddenOnly,
+        ignoreSubagent: config.ignoreSubagent,
         toast: config.toast,
         sound: config.sound,
         quickActions: config.quickActions,
@@ -1229,6 +1410,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
       };
@@ -1254,6 +1436,8 @@
       currentQuietHint: "默认开启：等待就发生在你正看着的这个对话里时，只留标签页标记，不弹系统通知、不响提示音，免得挡住审批卡片；页面切到后台后照常提醒。",
       doneVisible: "页面打开时也提醒「回复完成」",
       doneVisibleHint: "默认关闭：「完成」只在页面隐藏或切到后台时才提醒，避免打扰。",
+      subagentQuiet: "子代理会话不提醒",
+      subagentQuietHint: "默认开启：后台子代理（subagent）会话的「需要你」与「回复完成」都不提醒——它们是另一个对话的步骤，完成由所属主对话自己的提醒覆盖；你当前打开的那个子代理会话照常提醒。关掉后恢复逐会话提醒。",
       autoFocus: "点击通知回到对应对话",
       autoFocusHint: "默认开启：点系统通知会把 DSH 带到前台，并直接切到这条提醒所属的对话；关掉后点击通知不做任何事。",
       quickActions: "审批通知上直接裁决",
@@ -1294,6 +1478,8 @@
       currentQuietHint: "On by default: 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 the alert back.",
       doneVisible: "Also alert \"reply finished\" while the page is open",
       doneVisibleHint: "Off by default: \"done\" only alerts while the page is hidden or backgrounded, to avoid noise.",
+      subagentQuiet: "Ignore subagent sessions",
+      subagentQuietHint: "On by default: background sessions spawned by a subagent raise neither \"needs you\" nor \"reply finished\" alerts — they are steps of another conversation, already covered by that conversation's own alert. The subagent session you have open alerts as usual. Turn off to alert for every session.",
       autoFocus: "Click a toast to open that conversation",
       autoFocusHint: "On by default: clicking a toast brings DSH forward and switches to the conversation the alert came from. When off, clicking a toast does nothing.",
       quickActions: "Decide approvals from the toast",
@@ -1421,6 +1607,7 @@
           rowSwitch("attentionVisible", t("attentionVisible"), t("attentionVisibleHint"), !cfg.attentionHiddenOnly, function (v) { patch({ attentionHiddenOnly: !v }); }),
           rowSwitch("currentQuiet", t("currentQuiet"), t("currentQuietHint"), cfg.currentHiddenOnly, function (v) { patch({ currentHiddenOnly: v }); }),
           rowSwitch("doneVisible", t("doneVisible"), t("doneVisibleHint"), !cfg.doneHiddenOnly, function (v) { patch({ doneHiddenOnly: !v }); }),
+          rowSwitch("subagentQuiet", t("subagentQuiet"), t("subagentQuietHint"), cfg.ignoreSubagent, function (v) { patch({ ignoreSubagent: v }); }),
           rowSwitch("autoFocus", t("autoFocus"), t("autoFocusHint"), cfg.autoFocus, function (v) { patch({ autoFocus: v }); }),
           rowSwitch("quickActions", t("quickActions"), t("quickActionsHint"), cfg.quickActions, function (v) {
             patch({ quickActions: v });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-notify-me",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "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",