dsh-notify-me 1.1.8 → 1.2.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to **dsh-notify-me** are documented here.
 
+## [1.2.0] — 2026-09-30
+
+### 修复
+- **`0.1.6-alpha.2` 及以后（含 `0.2.0-rc.2`）宿主上「模型需要你操作」整条通道再次静默失效**：上游把待办交互从 `uiSession.pendingInteractions`（`Map<sessionId, interaction>`）搬进了 `uiSession.sessionStatus`（`Map<sessionId, {running, pendingInteraction, completionUnread}>`），旧 store 在新宿主上根本不存在——插件读不到就静默不提醒（审批卡片出现、模型停下，系统通知/提示音/标题标记全无；而「回复完成」与设置页测试按钮照常，现象与 1.1.5 那次一模一样）。现按宿主代际自动选源：`≥ 0.1.6-alpha.2` 绑定 `sessionStatus`，`0.1.2 .. 0.1.5` 仍用 `pendingInteractions`，`≤ 0.1.1` 仍走控制器快照；`window.__dshNotifyMe.debug()` 新增 `uiSessionSource`，直接显示这条通道绑的是哪个来源。
+- **`0.1.6` 及以后的宿主上认不出「当前会话」**：会话列表快照不再有 `current`（`SessionListState` 只剩 `ids / byId / phase / projectionsBySession`），于是当前会话面（face）订阅从未建立、`onListChanged()` 还把当前会话当成后台会话评估——后果是 1.1.7 的「当前对话不弹通知」规则失效（审批卡片就在屏幕上，Toast 仍会盖上去），标签页标记的归属也随之错位。现在按宿主自己的口径推导：有 `current` 用它，没有就取 `retainedBy.mainView > 0` 的那一行（与内置 `DocumentTitle` / `ui-workspace` / `ui-session` 的判定一致）。
+- **`0.1.6` 及以后点通知切不回对应会话**：`sessions.open(id)` 已被移除，导航改由 `uiWorkspace.openSession(id)` 承担；插件现在两个都试（`open` 优先，旧宿主行为不变），会话已不在列表时依旧不调用。`debug()` 新增 `currentSession` 便于核对。
+
+### 新增
+- `sessionStatus` 适配完整：同一会话里等待被替换成新 key 时旧的标题标记随之释放，等待消失（`pendingInteraction` 变 `null`）时按 key 释放标记，重复通知不重复提醒。
+
+### 变更
+- `peerDependencies` 放宽为 `^0.1.0-rc.6 || ^0.1.1-rc.2 || ^0.1.2-rc.1 || ^0.1.5-rc.1 || >=0.1.6-alpha.2 <0.2.0-0 || >=0.2.0-rc.1 <0.3.0-0`：原范围在 `0.2.0-rc.2` 上被 `evaluatePluginCompatibility` 判为不兼容，`dsh plugin add` 会拒绝并回滚安装（`0.3` 线仍被拒）。`dsh.compatibility.dshReleases` 增加 `0.2.0-rc.2: compatible`。
+- 版本号 1.1.8 → 1.2.0（新宿主代际）；`window.__dshNotifyMe.version` 同步。
+- 设置页字典注册改为把 `locale.register()` 返回的 disposer 交给 `ctx.effect`（与官方 `ui-approval` 写法一致），客户端插件 HMR 重载时不会因「同名 namespace 已注册」而丢掉设置页。
+- `uiSession` 绑定的诊断降噪：真实 `0.2.0-rc.2` 页面上每次加载都会出现的那条 `uiSession is provided but not reachable` 警告其实是**启动竞态**（本插件的客户端条目常早于 `ui-session` 条目激活，此时 `ctx.get()` 按 cordis 的严格语义拿不到尚未激活的服务），并非缺陷。现在只有**能拿到服务实例、但它既没有 `sessionStatus` 也没有 `pendingInteractions`** 时才打一条警告（并提示附上 `debug()` 输出）；「还没可见」保持安静，由 1.5s 重试定时器接管，`debug().uiSessionNote` 仍可查。
+
+### 测试
+- `smoke/smoke-test.cjs` 增加第三代宿主用例（`uiSession.sessionStatus`、列表无 `current`、无 `sessions.open`）：审批/提问/方案确认文案与详情、去重、等待消失释放标记、挂载前已存在的等待提醒一次、当前对话静默 + 转后台补发、后台会话前台提醒、主开关、`retainedBy.mainView` 推导当前会话、点通知走 `uiWorkspace.openSession`、会话已消失不打开。
+- `smoke/cordis-host-test.mjs` 增加真 cordis 的 `sessionStatus` 宿主（兄弟插件提供 `sessionStatus` 与 `uiWorkspace`，`sessions` 不带 `open`）：断言订阅绑到 `sessionStatus`、审批只提醒一次且正文带工具名 + 理由、标题标记设置与释放、点通知调用 `uiWorkspace.openSession`。原有 `pendingInteractions` 宿主与无 `uiSession` 的旧宿主用例保留。
+- 自检命令补 `DSH_CORDIS_PATH`：源码 checkout 里没有 profile 依赖时，用它把 `cordis-host-test.mjs` 指向 checkout 内的 `vendor/cordis/lib/index.js`（否则该用例按设计跳过）。
+
+### 已知限制
+- `≥ 0.1.6`（含 `0.2.0-rc.2`）的「回复完成」提醒正文不再附带回复摘要：宿主快照不再提供 `nodes`，摘要取不到；提醒本身照常触发。
+
 ## [1.1.8] — 2026-09-24
 
 ### 新增

package/README.en.md

@@ -74,7 +74,15 @@ dsh plugin --profile web add dsh-notify-me
 
 Restart `dsh web`, then hard-refresh the page (Ctrl+Shift+R).
 
-**Compatibility** — verified to actually activate on `0.1.2-rc.1` and `0.1.5-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`. Per-release declarations live in `package.json` under `dsh.compatibility.dshReleases`. If a plugin's client entry lists a package that a newer runtime no longer ships in `dsh.client.inject`, the entry parks at `pending (waiting for services: …)` and never runs — which is what broke 1.1.3 on `0.1.2-rc.1` and later.
+**Compatibility** — the plugin picks its interaction source per host generation; per-release declarations live in `package.json` under `dsh.compatibility.dshReleases`:
+
+| Host generation | "Needs you" interaction source | Current session | Toast-click navigation |
+| --- | --- | --- | --- |
+| `<= 0.1.1-rc.2` | controller snapshot `pending[]` | snapshot `current` | `sessions.open()` |
+| `0.1.2-alpha.2 .. 0.1.5-rc.3` | `uiSession.pendingInteractions` | snapshot `current` | `sessions.open()` |
+| `>= 0.1.6-alpha.2` (incl. `0.2.0-rc.2`) | `uiSession.sessionStatus` | `retainedBy.mainView` | `uiWorkspace.openSession()` |
+
+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.
 
 **Verify** — open the DevTools console and run:
 
@@ -110,10 +118,11 @@ window.__dshNotifyMe.resetConfig()                // restore defaults
 
 ## How it works
 
-The browser half subscribes to the client `sessions` service — the same source the UI itself renders from:
+The reminder core picks its interaction source per host generation (see the table above); the current session always comes from the client `sessions` service:
 
-- the **selected session's** `ConversationSnapshot`: a `running: true → false` edge means a reply finished; a new entry in `pending[]` of kind `approval` / `plan-review` / `question` means the agent is waiting on you (payload text is shown in the alert when available);
-- **every other listed session's** summary: a new `pendingInteraction`, or the `completed` edge (finished while not selected), alerts you about background work.
+- 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.
 
 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).
 
@@ -124,16 +133,21 @@ The reminder core stays dependency-free and self-contained: notification copy re
 - The first sound/toast of each page load needs one user click on the page first (browser autoplay + permission policy).
 - Toasts are only produced once the notification permission is granted; declining means sound + title marker only.
 - Config lives in browser `localStorage`: switching browsers/devices or clearing site data returns to defaults (one-click restore in the Settings page).
+- On `>= 0.1.6` (including `0.2.0-rc.2`) the "reply finished" toast body carries only the session label, no assistant snippet: host snapshots no longer expose `nodes`. The alert itself still fires.
+- The title marker is written into `document.title` alongside the host: when the host recomputes the title it can overwrite the marker until the next alert event rewrites it.
 
 ## Development
 
 ```powershell
 node --check lib\client.js
 node --check lib\index.js
-node smoke\smoke-test.cjs     # offline state-machine smoke test (master switch + zh/en language cases)
-npm pack --dry-run            # preview the published tarball
+node smoke\smoke-test.cjs        # offline state-machine test: three host generations + master switch + zh/en cases
+node smoke\cordis-host-test.mjs  # real-cordis end-to-end (skips when no local DSH installation is found)
+npm pack --dry-run               # preview the published tarball
 ```
 
+`cordis-host-test.mjs` borrows `@deepseek-ai/cordis` from a local DSH installation; in a source checkout with no profile dependencies, point it there with `DSH_CORDIS_PATH=<checkout>/vendor/cordis/lib/index.js`.
+
 ## License
 
 MIT — see [LICENSE](LICENSE).

package/README.md

@@ -74,7 +74,15 @@ dsh plugin --profile web add dsh-notify-me
 
 重启 `dsh web` 后硬刷新页面（Ctrl+Shift+R）。
 
-**兼容性** — 实测**真正激活**（各自独立 profile 启动：设置里出现「通知提醒」分区，即插件的 `apply` 确实执行）于 `0.1.2-rc.1` 与 `0.1.5-rc.2`；更早的 `0.1.1-rc.2` 亦验证过。逐版本声明见 `package.json` 的 `dsh.compatibility.dshReleases`。注意一个坑：若 `dsh.client.inject` 里列了新版运行时已不再提供的包，客户端条目会停在 `pending (waiting for services: …)` 而永不执行——1.1.3 在 `0.1.2-rc.1` 及以后正是这样失效的。
+**兼容性** — 插件按宿主代际自动选源，逐版本声明见 `package.json` 的 `dsh.compatibility.dshReleases`：
+
+| 宿主代际 | 「需要你」交互来源 | 判断当前会话 | 点通知切会话 |
+| --- | --- | --- | --- |
+| `≤ 0.1.1-rc.2` | 控制器快照的 `pending[]` | 快照 `current` | `sessions.open()` |
+| `0.1.2-alpha.2 .. 0.1.5-rc.3` | `uiSession.pendingInteractions` | 快照 `current` | `sessions.open()` |
+| `≥ 0.1.6-alpha.2`（含 `0.2.0-rc.2`） | `uiSession.sessionStatus` | `retainedBy.mainView` | `uiWorkspace.openSession()` |
+
+实测**真正激活**（各自独立 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`、以及用的是哪个来源。
 
 **验证** — F12 控制台执行：
 
@@ -106,10 +114,11 @@ window.__dshNotifyMe.resetConfig()                // 恢复默认
 
 ## 工作原理
 
-浏览器半身订阅客户端 `sessions` 服务（与 UI 同一数据源）：
+提醒核心按宿主代际取源（见上表），当前会话一律来自客户端 `sessions` 服务：
 
-- **当前会话** `ConversationSnapshot`：`running` true→false = 回复完成；`pending[]` 新增 `approval` / `plan-review` / `question` = 模型在等你（可行时在提醒里展示提问/审批内容）；
-- **其它已列会话**摘要：出现新 `pendingInteraction`，或 `completed` 边沿（非选中状态下跑完）→ 后台工作提醒。
+- **当前会话** `SessionSnapshot`：`running` true→false = 回复完成；
+- **待办交互**：`uiSession` 的 `sessionStatus`（`≥ 0.1.6`，逐会话 `pendingInteraction`）或 `pendingInteractions`（`0.1.2 .. 0.1.5`）出现新 key = 模型在等你，容器里带上审批工具名 / 理由、提问文本；旧宿主回落到控制器快照的 `pending[]`；
+- **其它已列会话**摘要：`running` true→false（或旧宿主的 `completed` 边沿）= 后台工作提醒。
 
 提醒核心仍然零第三方运行时依赖、完全自包含：通知文字按所选语言（跟随界面 / 中文 / English）即时解析。设置页是**可选**的 React 呈现层——当 DSH web profile 提供 `slots` / `locale` / `react` 时才注册进「设置 → 通知提醒」，缺任一能力时插件自动降级为纯提醒（无设置页），不影响功能。
 
@@ -120,16 +129,21 @@ window.__dshNotifyMe.resetConfig()                // 恢复默认
 - 每次页面加载后第一次出声/弹通知前，需在页面上点击过一次（浏览器自动播放与权限策略）。
 - 未授权通知权限时只有提示音与标题标记。
 - 配置存在浏览器 `localStorage`：换浏览器/设备或清除站点数据后会回到默认值（设置页可一键恢复默认）。
+- `≥ 0.1.6`（含 `0.2.0-rc.2`）的「回复完成」提醒正文只有会话名，不再附带回复摘要——宿主快照已不再提供 `nodes`；提醒本身照常触发。
+- 标题标记由宿主与插件共同写 `document.title`：宿主重算标题时标记可能被覆盖，直到下一次提醒事件重新写成。
 
 ## 开发自检
 
 ```powershell
 node --check lib\client.js
 node --check lib\index.js
-node smoke\smoke-test.cjs     # 离线状态机冒烟测试（含主开关与中英语言用例）
-npm pack --dry-run            # 预览发布包
+node smoke\smoke-test.cjs        # 离线状态机冒烟测试：三代宿主 + 主开关 + 中英语言用例
+node smoke\cordis-host-test.mjs  # 真 cordis 端到端（找不到本机 DSH 时自动跳过）
+npm pack --dry-run               # 预览发布包
 ```
 
+`cordis-host-test.mjs` 会从本机 DSH 安装借 `@deepseek-ai/cordis`；源码 checkout 里没有 profile 依赖时，用 `DSH_CORDIS_PATH=<checkout>/vendor/cordis/lib/index.js` 指定即可。
+
 ## License
 
 MIT — 见 [LICENSE](LICENSE)。

package/lib/client.js

@@ -12,16 +12,26 @@
 // What this plugin does (all client-side, no settings transport needed):
 //   - watches two services, because pending interactions and the running bit
 //     have different owners on current hosts:
-//       * "uiSession" -> pendingInteractions (a Map<sessionId, interaction>
-//         snapshot whose values carry kind 'approval' | 'plan-review' |
-//         'question'). Present since DSH 0.1.2-alpha.2; the controller
-//         snapshots stopped carrying `pending` in the same release, so this is
-//         the only live source of "the agent is waiting on you" on 0.1.2+.
-//         It is resolved through ctx.get() — cordis throws on a plain
+//       * "uiSession" -> the pending-interaction source, whose *store* changed
+//         shape once and is therefore read through one adapter:
+//           - DSH 0.1.2-alpha.2 .. 0.1.5-rc.3: `pendingInteractions`, a
+//             Map<sessionId, interaction> whose values carry kind
+//             'approval' | 'plan-review' | 'question' (the controller snapshots
+//             stopped carrying `pending` in 0.1.2-alpha.2, so that store was the
+//             only live source back then);
+//           - DSH 0.1.6-alpha.2 and later (including 0.2.0-rc.2):
+//             `sessionStatus`, a Map<sessionId, {running, pendingInteraction,
+//             completionUnread}>; the old store is gone, so this is the only
+//             live source on those hosts.
+//         Both are resolved through ctx.get() — cordis throws on a plain
 //         ctx.uiSession read for any name absent from the plugin's inject map;
 //       * "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;
+//         completed), which carry the "reply finished" edge on every version.
+//         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);
 //   - 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;
@@ -172,18 +182,22 @@ window.__ModuleLoader__.load({
     }
     // Bring the window forward and make the alerted session the current one,
     // so a click on the toast lands on the conversation that needs the user
-    // instead of just the app. Every failure here is non-fatal: a session that
-    // left the list, an older host without `open()`, or a cordis service that
-    // cannot be resolved must still leave a usable window in front.
+    // instead of just the app. Navigation moved with the host API: `sessions`
+    // exposed open(id) through 0.1.5-rc.3, and 0.1.6+ routes the same action
+    // through `uiWorkspace.openSession(id)`. Every failure here is non-fatal: a
+    // session that left the list, an older host without either verb, or a
+    // cordis service that cannot be resolved must still leave a usable window
+    // in front.
     function focusSession(sessionId) {
       try { window.focus(); } catch (e) {}
       if (!sessionId) return;
       try {
-        var svc = lookupService("sessions");
-        if (!svc || typeof svc.open !== "function") return;
         var st = listStore && listStore.getSnapshot();
-        if (st && st.byId && !st.byId[sessionId] && st.current !== sessionId) return;
-        svc.open(sessionId);
+        if (st && st.byId && !st.byId[sessionId] && currentSessionId() !== sessionId) return;
+        var svc = lookupService("sessions");
+        if (svc && typeof svc.open === "function") { svc.open(sessionId); return; }
+        var ws = lookupService("uiWorkspace");
+        if (ws && typeof ws.openSession === "function") ws.openSession(sessionId);
       } catch (e) {}
     }
     function showToast(kind, title, body, sessionId) {
@@ -382,11 +396,24 @@ window.__ModuleLoader__.load({
       return raw;
     }
     // The session the user is looking at, or null while the list is not ready.
+    // Two host generations own this fact differently:
+    //   * <= 0.1.5-rc.3: the list snapshot carried `current`;
+    //   * 0.1.6+ (incl. 0.2.0-rc.2): `current` is gone and the main view's
+    //     retention count marks the on-screen session — the shipped
+    //     DocumentTitle, ui-workspace browser and ui-session isMain() all
+    //     derive it exactly this way.
     function currentSessionId() {
       try {
         var st = listStore && listStore.getSnapshot();
-        return (st && st.current) || null;
-      } catch (e) { return null; }
+        if (!st) return null;
+        if (typeof st.current === "string" && st.current) return st.current;
+        var byId = st.byId || {};
+        for (var id in byId) {
+          var row = byId[id];
+          if (row && row.retainedBy && (row.retainedBy.mainView || 0) > 0) return id;
+        }
+      } catch (e) {}
+      return null;
     }
     // Display label for a session id we only know from the interaction map:
     // the list row's title, the localized "current" placeholder for the selected
@@ -397,7 +424,7 @@ window.__ModuleLoader__.load({
         if (st) {
           var sum = st.byId && st.byId[sid];
           if (sum) return sessionLabelText({ label: sum.displayTitle || sum.title || "" });
-          if (st.current === sid) return texts().current;
+          if (currentSessionId() === sid) return texts().current;
         }
       } catch (e) {}
       return sid;
@@ -453,6 +480,7 @@ window.__ModuleLoader__.load({
     var uiPending = false; // true once the interaction snapshot is readable
     var uiSub = null;
     var uiStore = null; // the interaction store we hold a subscription on
+    var uiSource = null; // 'sessionStatus' (0.1.6+) | 'pendingInteractions' (0.1.2-0.1.5)
     var uiBindNote = "not attempted"; // last lookup outcome, read by __dshNotifyMe.debug()
     var uiWarned = false; // one unreachable-service warning per page load
     var uiBaseline = Object.create(null); // sessionId -> { key: string }
@@ -614,8 +642,7 @@ window.__ModuleLoader__.load({
     function bindCurrentFace() {
       if (!listStore) return;
       try {
-        var st = listStore.getSnapshot();
-        var cur = st && st.current;
+        var cur = currentSessionId();
         if (!cur) { detachFace(); return; }
         if (cur === currentFaceId && faceSub) return;
         detachFace();
@@ -645,7 +672,7 @@ window.__ModuleLoader__.load({
       if (!listStore) return;
       try {
         var st = listStore.getSnapshot();
-        var cur = st && st.current;
+        var cur = currentSessionId();
         bindCurrentFace();
         bindUiSession();
         var byId = (st && st.byId) || {};
@@ -661,10 +688,17 @@ window.__ModuleLoader__.load({
 
     // ─────────────── uiSession pending-interaction watcher ───────────
     // DSH >= 0.1.2-alpha.2 moved pending interactions out of the Controller
-    // snapshots into their own store (uiSession.pendingInteractions), a
-    // Map<sessionId, interaction> whose values carry kind + key + sessionId and
-    // the domain's own detail fields. It is the only live "the agent is waiting
-    // on you" source on those hosts.
+    // snapshots into their own uiSession store, and that store changed shape
+    // once, so both readings share one adapter:
+    //   * 0.1.2-alpha.2 .. 0.1.5-rc.3: `pendingInteractions`, a
+    //     Map<sessionId, interaction> whose values carry kind + key + sessionId
+    //     and the domain's own detail fields;
+    //   * 0.1.6-alpha.2 and later (incl. 0.2.0-rc.2): `sessionStatus`, a
+    //     Map<sessionId, {running, pendingInteraction, completionUnread}>; the
+    //     old store no longer exists, so reading it is what made this channel
+    //     dead on every 0.1.6+/0.2 host.
+    // Either store is the only live "the agent is waiting on you" source on its
+    // host generation.
     //
     // The service is looked up lazily rather than declared in `inject`:
     // a cordis `inject` entry is a hard gate (the entry never activates while
@@ -695,37 +729,54 @@ window.__ModuleLoader__.load({
       try { if (rootCtx && name in rootCtx) svc = rootCtx[name] || null; } catch (e) { svc = null; }
       return svc;
     }
-    // Did some entry on this host ever provide the service? Separates the
-    // normal "older host has no interaction store" case (stay silent, the
-    // controller path still works there) from "provided but unreachable",
-    // which is a real defect and deserves one console warning.
-    function serviceWasProvided(name) {
-      try {
-        var props = rootCtx && rootCtx.reflect && rootCtx.reflect.props;
-        return !!(props && props[name]);
-      } catch (e) { return false; }
+    // Is this an observable snapshot store (getSnapshot + subscribe)?
+    function isStore(s) {
+      return !!s && typeof s.getSnapshot === "function" && typeof s.subscribe === "function";
+    }
+    // Pick the host's pending-interaction store: sessionStatus wherever it
+    // exists (0.1.6+), else the legacy pendingInteractions map (0.1.2-0.1.5).
+    function interactionStore(svc) {
+      if (svc && isStore(svc.sessionStatus)) return { store: svc.sessionStatus, source: "sessionStatus" };
+      if (svc && isStore(svc.pendingInteractions)) return { store: svc.pendingInteractions, source: "pendingInteractions" };
+      return null;
+    }
+    // One pending interaction out of one store value; null when this session
+    // currently has none.
+    function pendingOf(value, source) {
+      if (!value) return null;
+      if (source === "sessionStatus") return value.pendingInteraction || null;
+      return value;
     }
+    // Record the last lookup outcome for debug() and warn once on the only
+    // outcome that is a defect rather than a host generation.
     function noteUiBind(note) {
       if (uiBindNote === note) return;
       uiBindNote = note;
-      if (note === "bound" || uiWarned || !serviceWasProvided("uiSession")) return;
+      // Two notes are normal and stay silent: "not visible" is either a
+      // pre-0.1.2 host or the ordinary boot race (this entry may apply before
+      // the uiSession entry activates; the 1.5s retry timer binds it a moment
+      // later), and "bound" is success. A service instance we can hold but
+      // whose shape we do not recognize is the case worth one warning.
+      if (note === "bound" || uiWarned || note === "uiSession not visible") return;
       uiWarned = true;
       try {
-        console.warn("[dsh-notify-me] uiSession is provided but not reachable (" + note + ") — approval alerts fall back to the legacy controller path, which stopped reporting pending interactions in DSH 0.1.2+");
+        console.warn("[dsh-notify-me] uiSession is reachable but exposes no pending-interaction source (" + note + ") — approval alerts are silent; please report this against DSH with window.__dshNotifyMe.debug()");
       } catch (e) {}
     }
     function bindUiSession() {
       var svc = lookupService("uiSession");
-      var store = svc && svc.pendingInteractions;
-      if (!store || typeof store.getSnapshot !== "function" || typeof store.subscribe !== "function") {
-        noteUiBind(svc ? "uiSession has no pendingInteractions store" : "uiSession not visible");
+      var found = interactionStore(svc);
+      if (!found) {
+        noteUiBind(svc ? "uiSession has neither sessionStatus nor pendingInteractions" : "uiSession not visible");
         return;
       }
+      var store = found.store;
       if (uiSub && uiStore === store) { noteUiBind("bound"); return; }
-      // the service instance was swapped (plugin HMR): drop the stale
-      // subscription and its marks, then bind the live store
+      // the service instance (or its store) was swapped (plugin HMR): drop the
+      // stale subscription and its marks, then bind the live store
       if (uiSub) detachUiSession();
       uiStore = store;
+      uiSource = found.source;
       uiPending = true; // this watcher now owns the title marker
       uiSub = store.subscribe(function () { try { evalUiPending(); } catch (e) {} });
       noteUiBind("bound");
@@ -733,12 +784,15 @@ window.__ModuleLoader__.load({
     }
     function evalUiPending() {
       var svc = lookupService("uiSession");
-      var store = svc && svc.pendingInteractions;
-      if (!store || typeof store.getSnapshot !== "function") return;
-      var snap = store.getSnapshot(); // Map<sessionId, interaction>
+      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;
       var seen = Object.create(null);
-      snap.forEach(function (it, sid) {
+      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;
         seen[sid] = true;
         var key = it.key || (it.kind + ":" + sid);
@@ -767,6 +821,7 @@ window.__ModuleLoader__.load({
     function detachUiSession() {
       if (uiSub) { try { uiSub(); } catch (e) {} uiSub = null; }
       uiStore = null;
+      uiSource = null;
       // drop every mark this watcher holds; hosts without the interaction store
       // go back to the controller marker path
       for (var s in uiBaseline) unmarkAttention(uiBaseline[s].key);
@@ -788,7 +843,7 @@ window.__ModuleLoader__.load({
       });
     } catch (e) {}
     // keep in sync with package.json "version" on every release
-    api.version = "1.1.8";
+    api.version = "1.2.0";
     api.setConfig = function (patch) { return setConfigLocal(patch); };
     api.resetConfig = function () {
       try { localStorage.removeItem(LS_CONFIG); } catch (e) {}
@@ -804,9 +859,10 @@ window.__ModuleLoader__.load({
       return "sent " + kind + " (lang=" + effectiveLang() + ", permission=" + ("Notification" in window ? Notification.permission : "n/a") + ")";
     };
     // Live diagnostics for the "why did nothing pop" case. The needs-input
-    // channel has two possible owners on current hosts (uiSession on 0.1.2+,
-    // the controller snapshots before that) and both used to fail silently, so
-    // the binding state has to be readable from the page itself.
+    // channel has three possible owners on current hosts (uiSession.sessionStatus
+    // on 0.1.6+, uiSession.pendingInteractions on 0.1.2-0.1.5, the controller
+    // snapshots before that) and each one failed silently in turn, so both the
+    // binding state and which store answered have to be readable from the page.
     api.debug = function () {
       return {
         version: api.version,
@@ -821,6 +877,8 @@ window.__ModuleLoader__.load({
         visibility: hidden() ? "hidden" : "visible",
         uiSession: uiPending ? "bound" : "unbound",
         uiSessionNote: uiBindNote,
+        uiSessionSource: uiSource,
+        currentSession: currentSessionId(),
         sessionBaselines: Object.keys(prevById).length,
         pendingBaselines: Object.keys(uiBaseline).length,
         firedKeys: Object.keys(attentionKeysFired),
@@ -1072,9 +1130,10 @@ window.__ModuleLoader__.load({
     // a cordis inject entry is a hard gate (the entry stays pending while the
     // service is missing, and the web boot audit fails on entries that never
     // activate), while hosts older than 0.1.2-alpha.2 have no uiSession at all.
-    // It is therefore looked up lazily in bindUiSession(), with the controller
-    // path above as the fallback. The bundle entry
-    // "@deepseek-ai/dsh-client-ui-session" stays in package.json's
+    // It is therefore looked up lazily in bindUiSession() — as are `uiWorkspace`
+    // (toast-click navigation on 0.1.6+) and `sessions.open` (its pre-0.1.6
+    // predecessor) — with the controller path above as the fallback. The bundle
+    // entry "@deepseek-ai/dsh-client-ui-session" stays in package.json's
     // dsh.client.inject so the load order keeps the bundle in the graph.
     var inject = ["sessions", "locale", "slots"];
 
@@ -1093,8 +1152,11 @@ window.__ModuleLoader__.load({
       // is present. The reminder core above never depends on this.
       try {
         if (React && React.createElement && ctx.slots && ctx.locale && typeof ctx.locale.register === "function" && typeof ctx.slots.inject === "function") {
+          // The effect returns register()'s own disposer, so a client-plugin
+          // reload (HMR) unregisters the dictionaries before re-registering
+          // them; locale.register throws when a namespace already has a locale.
           ctx.effect(function () {
-            ctx.locale.register(NS, { zh: UI_zh, en: UI_en });
+            return ctx.locale.register(NS, { zh: UI_zh, en: UI_en });
           }, "dsh-notify-me: settings dictionaries");
           var t = ctx.locale.bind(NS);
           ctx.slots.inject("settings.section", function () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-notify-me",
-  "version": "1.1.8",
+  "version": "1.2.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; toggleable from Settings with zh/en notification language.",
   "license": "MIT",
   "type": "module",
@@ -80,12 +80,13 @@
         "0.1.1-rc.2": "compatible",
         "0.1.2-rc.1": "compatible",
         "0.1.5-rc.1": "compatible",
-        "0.1.5-rc.2": "compatible"
+        "0.1.5-rc.2": "compatible",
+        "0.2.0-rc.2": "compatible"
       }
     }
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6 || ^0.1.1-rc.2 || ^0.1.2-rc.1 || ^0.1.5-rc.1"
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6 || ^0.1.1-rc.2 || ^0.1.2-rc.1 || ^0.1.5-rc.1 || >=0.1.6-alpha.2 <0.2.0-0 || >=0.2.0-rc.1 <0.3.0-0"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-client-locale": {