dsh-notify-me 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 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
 
 ### 新增

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.
 
@@ -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,7 +136,7 @@ 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).

package/README.md

@@ -43,7 +43,7 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 | 时机 | 提醒内容 | 默认 |
 | --- | --- | --- |
 | 🔔 **模型需要你操作** — 审批请求 / 方案待确认（plan review）/ 提问（`ask_user_question`） | 通知 + 提示音 + `🔔 需要你 ·` 标题标记；审批的通知上直接带「同意 / 拒绝」按钮 | 页面可见也提醒（当前对话除外：默认只留标题标记） |
-| ✅ **回复完成** — 一轮回复跑完；后台会话完成也会报 | 通知 + 提示音 | 仅页面隐藏/后台时提醒 |
+| ✅ **回复完成** — 一轮回复跑完；后台会话完成也会报 | 通知 + 提示音；后台会话**完成但还没看**的期间标题带 `✅ 回复完成 ·` 标记，打开该会话即撤 | 仅页面隐藏/后台时提醒（标题标记不受此限） |
 
 > **后台**子代理（subagent）子会话的等待与完成默认**不提醒**：DSH 把每个子代理子会话列成独立会话，但它们是所属主对话那一轮里的步骤，提醒只会是噪音。你当前打开的那个子代理会话不算在内，照常提醒。设置页「子代理会话不提醒」可关掉这个静音。
 
@@ -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,7 +132,7 @@ 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` 时才注册进「设置 → 通知提醒」，缺任一能力时插件自动降级为纯提醒（无设置页），不影响功能。

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
@@ -203,6 +210,7 @@
         doneBody: "回复已完成",
         background: "后台会话",
         marker: "🔔 需要你 · ",
+        doneMarker: "✅ 回复完成 · ",
         sep: "：",
         approve: "同意",
         reject: "拒绝",
@@ -226,6 +234,7 @@
         doneBody: "Reply finished",
         background: "Background session",
         marker: "🔔 Action needed · ",
+        doneMarker: "✅ Reply finished · ",
         sep: ": ",
         approve: "Approve",
         reject: "Reject",
@@ -599,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;
     }
@@ -616,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) {}
@@ -629,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),
@@ -664,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"; }
 
@@ -804,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
@@ -960,7 +1024,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 +1034,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 +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)
@@ -1054,12 +1128,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 +1242,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 +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;
@@ -1218,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;
     }
 
@@ -1235,7 +1359,7 @@
       });
     } catch (e) {}
     // keep in sync with package.json "version" on every release
-    api.version = "1.4.0";
+    api.version = "1.5.0";
     api.setConfig = function (patch) { return setConfigLocal(patch); };
     api.resetConfig = function () {
       try { localStorage.removeItem(LS_CONFIG); } catch (e) {}
@@ -1286,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
       };

package/package.json

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