dsh-notify-me 1.2.1 → 1.3.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to **dsh-notify-me** are documented here.
 
+## [1.3.0] — 2026-10-03
+
+### 新增
+- **审批通知上直接裁决**（设置页新开关「审批通知上直接裁决」，默认开启）：权限审批的系统通知带上「同意 / 拒绝」按钮，点一下就完成裁决，不用切回页面。按钮调的是审批卡片自己的 `PendingApproval.answer('allowed-once' | 'rejected')`——「同意」即「允许一次」，只放行这一次，与卡片上的按钮完全同义；点通知正文仍是 1.1.8 的「回到对应对话」。
+- 绕开的是一条浏览器硬限制：`actions` 只属于 Service Worker 弹的持久通知，往 `new Notification()` 里传 `actions` 直接抛 `TypeError`。所以 bundle 一份文件两用：页面里照常注册提醒工厂，同一份字节再注册成 Service Worker，只负责把「点了哪个按钮」（同意 / 拒绝 / 点正文）转告页面（BroadcastChannel 与客户端 postMessage 双通道），裁决本身仍发生在页面里。注册只用本插件自己的单条目 combo URL（`/plugins/??dsh-notify-me/client.js&rev=…`，取自 `__DSH_BOOT__.entries`）——多插件 combo 会在 worker 里执行别家的 factory，注册必挂。
+- 按钮通知按交互 key 记账：一条等待一次只认领一张通知；页面里先答掉、或被新请求顶替之后，残留通知上的按钮再点不裁决任何东西，只把通知关掉。请求消失时残留通知一并关闭；带按钮的通知不设 15 秒自动消失，未裁决的审批留在通知中心等你。
+- `window.__dshNotifyMe` 新增 `decide(key, outcome)`（按钮的程序化同款，`outcome` 取 `"allowed-once"` / `"rejected"`）与 `test("approval")`（设置页新增「测试『审批按钮』」按钮，一条通知端到端验证按钮链路）；`debug()` 新增 `quickActions` / `bridge`（`active` = 按钮可用，否则给出不可用原因）/ `actionKeys`；`onEvent` 新增 `decision` 事件（`{key, outcome, sessionId}`，测试点击另带 `test: true`）。
+
+### 变更
+- 带按钮的审批通知改用 `dsh-notify-me-attention-<key>` 独立标签，多条待审批互不顶掉；提问 / 方案确认沿用原来的 `dsh-notify-me-attention` 标签行为。
+- 不支持 Service Worker 的环境（`http://` 局域网地址等）自动退回 1.2.x 的无按钮通知，其余功能不受影响，`debug().bridge` 显示具体原因。
+- 版本号 1.2.1 → 1.3.0；`window.__dshNotifyMe.version` 同步。
+
+### 测试
+- `smoke/smoke-test.cjs` 新增快捷裁决桥用例，把 bundle 的两半都在同一套件里跑起来（worker 半侧执行在 worker 形状的 vm 上下文，页面半侧走常规桩，两边用同一个 BroadcastChannel 桩对接）：单条目 combo URL 注册、按钮文案与 `data` 携带 key/会话、点「同意」→ `answer('allowed-once')`、点「拒绝」→ `answer('rejected')`、陈旧 key 与未知 key 一律不裁决、页面里先答掉后残留按钮失效、`quickActions` 关闭或无 Service Worker 时退回普通通知且不带 `actions`（构造函数带它会抛 `TypeError`）、测试按钮走完整 worker 链路。
+- `smoke/cordis-host-test.mjs` 在 `sessionStatus` 宿主上补真 cordis 语义的裁决用例：`decide()` 经 `ctx.get("uiSession")` 找到活着的交互并调它的 `answer()`，重复裁决与未知 key 拒绝，标记随之释放。
+
+### 已知限制
+- 按钮要 Service Worker：`http://127.0.0.1`、`https` 可用，`http://192.168.x.x` 这类局域网地址不行；DSH Desktop（Electron）里按钮能否渲染未实测，不渲染时按上述降级走无按钮通知。
+
 ## [1.2.1] — 2026-10-03
 
 ### 修复
@@ -17,11 +37,9 @@ All notable changes to **dsh-notify-me** are documented here.
 - **`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.x 既有逻辑，不是新行为）：同一会话里等待被替换成新 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`。范围对未实测的 `0.2.x` 正式版同样放行，是否兼容以 `dshReleases` 的实测声明为准。
 - 版本号 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` 仍可查。

package/README.en.md

@@ -6,12 +6,12 @@
 [![npm downloads](https://img.shields.io/npm/dm/dsh-notify-me?style=flat-square&label=downloads&color=1F883D)](https://www.npmjs.com/package/dsh-notify-me)
 ![License](https://img.shields.io/badge/license-MIT-blue)
 ![Platform](https://img.shields.io/badge/platform-browser-blue)
-![Size](https://img.shields.io/badge/bundle-%7E37KB-green)
+![Size](https://img.shields.io/badge/bundle-%7E79KB-green)
 [![Awesome DSH Plugin](https://awesome-dsh-plugin.com/badge.svg)](https://awesome-dsh-plugin.com)
 
 ---
 
-**Step away from the DeepSeek Harness web UI — and still know what's going on.** When the agent stops and needs your input, or when a reply finishes in the background while you're in another app, dsh-notify-me alerts you with a Windows desktop notification, a sound, and a tab-title marker. Toggle it and pick the notification language right from **Settings → Notify me**.
+**Step away from the DeepSeek Harness web UI — and still know what's going on.** When the agent stops and needs your input, or when a reply finishes in the background while you're in another app, dsh-notify-me alerts you with a Windows desktop notification, a sound, and a tab-title marker. Approval notifications even carry Approve / Reject buttons, so you can settle the request without switching back. Toggle it and pick the notification language right from **Settings → Notify me**.
 
 ---
 
@@ -42,7 +42,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 | Alerts even while the page is visible |
+| 🔔 **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 |
 | ✅ **A reply finishes** — a turn completes; background sessions finishing are also reported | Toast + sound | Alerts only while the page is hidden / backgrounded |
 
 ## Configure it from DSH Settings
@@ -52,14 +52,15 @@ Open **Settings → Notify me** (refresh the page once after installing):
 - **Enable reminders** — master switch; when off, no toasts, no sounds and the tab title is never touched;
 - **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);
+- **Decide approvals from the toast** (default on): approval notifications carry Approve / Reject buttons, and one click settles the request exactly like the Allow once / Reject buttons on the approval card. Clicking the toast body still takes you back to the conversation;
 - **Notification language** — follow the interface / 简体中文 / English: controls the language of the alert text and the `🔔 …` title marker;
-- **Test buttons** — send one "needs you" or "reply finished" test alert with the current settings (**not** limited by the "while the page is open" toggles; the "needs you" test's title marker clears itself after ~6s).
+- **Test buttons** — send one "needs you", "reply finished" or "approval buttons" test alert with the current settings (**not** limited by the "while the page is open" toggles; the "needs you" test's title marker clears itself after ~6s).
 
 > Notification permission is required: click once on the page → **Allow** (or address-bar lock → Site settings → Notifications → Allow → reload).
 
 ## How it alerts
 
-- **System notification** — native notification-center toast (clicking it brings the DSH window back to front)
+- **System notification** — native notification-center toast (clicking it brings the DSH window back to front; 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 · …` / `🔔 需要你 · …`
 
@@ -78,10 +79,12 @@ Restart `dsh web`, then hard-refresh the page (Ctrl+Shift+R).
 
 | 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.2-alpha.1` | controller snapshot `pending[]` | snapshot `current` | `sessions.open()` |
+| `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.
+
 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:
@@ -89,6 +92,8 @@ Verified to actually activate on `0.1.2-rc.1`, `0.1.5-rc.2` and `0.2.0-rc.2` (ea
 ```js
 window.__dshNotifyMe.test("done")        // "reply finished" sample
 window.__dshNotifyMe.test("attention")   // "needs your input" sample
+window.__dshNotifyMe.test("approval")    // "approval buttons" sample: try the Approve / Reject buttons on the toast
+window.__dshNotifyMe.debug()             // the bridge field reports the button channel: "active" = buttons work
 ```
 
 Nothing happened? 90% of the time it's one of:
@@ -111,9 +116,11 @@ window.__dshNotifyMe.setConfig({
   toast: true,                // system-notification toggle
   sound: true,                // sound toggle
   volume: 0.5,                // 0..1
-  autoFocus: true             // clicking the toast focuses the DSH window
+  autoFocus: true,            // clicking the toast focuses the DSH window
+  quickActions: true          // Approve / Reject buttons on approval toasts
 })
 window.__dshNotifyMe.resetConfig()                // restore defaults
+window.__dshNotifyMe.decide("approval:3", "allowed-once")  // programmatic decision: "allowed-once" | "rejected"
 ```
 
 ## How it works
@@ -126,12 +133,19 @@ The reminder core picks its interaction source per host generation (see the tabl
 
 The reminder core stays dependency-free and self-contained: notification copy resolves at alert time from the chosen language (follow-interface / Simplified Chinese / English). The Settings page is an **optional** React surface — it only registers into Settings when the web profile provides the `slots` / `locale` services and `react`; without them the plugin degrades gracefully to alerts-only (no Settings page).
 
+### Quick decisions, and how they reach the agent
+
+Action buttons (`actions`) belong to persistent notifications shown through `ServiceWorkerRegistration.showNotification()`; passing `actions` to the `new Notification()` constructor throws a `TypeError`. That is a browser rule no plugin can route around, so the bundle holds two jobs in the same bytes: the page half registers the reminder factory as it always did, and the very same file is registered as a Service Worker whose only task is relaying which button was clicked back to the page. The decision itself happens in the page, through the same `PendingApproval.answer('allowed-once' | 'rejected')` the approval card uses — which is why "Approve" is exactly "Allow once" and nothing broader.
+
+Every button toast is booked against its interaction key, so it can only decide the request it was raised for. Once the page answers that request or a newer one replaces it, clicking the leftover buttons decides nothing and just closes the notification. Button toasts also skip the auto-dismiss timer: an undecided approval stays in the notification center until you settle it.
+
 ## Known limitations
 
 - The page must be open for alerts to fire (background tab / minimized is fine; closing the tab stops it — that's inherent to a browser-layer plugin).
 - Notifications appear through the browser, so the browser needs "show notifications" permission in Windows settings, and notification-center "Do Not Disturb" must not suppress them.
 - 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.
+- Quick-decision buttons need a Service Worker: they work on `http://127.0.0.1` and `https`, not on plain `http://192.168.x.x`-style LAN addresses, and some browsers or desktop hosts never render notification buttons. The `bridge` field of `window.__dshNotifyMe.debug()` says why; toasts then fall back to their buttonless form and everything else keeps working.
 - 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.
@@ -141,7 +155,7 @@ The reminder core stays dependency-free and self-contained: notification copy re
 ```powershell
 node --check lib\client.js
 node --check lib\index.js
-node smoke\smoke-test.cjs        # offline state-machine test: three host generations + master switch + zh/en cases
+node smoke\smoke-test.cjs        # offline state-machine test: three host generations + master switch + zh/en cases + the quick-decision bridge (worker half included)
 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
 ```

package/README.md

@@ -6,12 +6,12 @@
 [![npm downloads](https://img.shields.io/npm/dm/dsh-notify-me?style=flat-square&label=downloads&color=1F883D)](https://www.npmjs.com/package/dsh-notify-me)
 ![License](https://img.shields.io/badge/license-MIT-blue)
 ![Platform](https://img.shields.io/badge/platform-browser-blue)
-![Size](https://img.shields.io/badge/bundle-%7E37KB-green)
+![Size](https://img.shields.io/badge/bundle-%7E79KB-green)
 [![Awesome DSH Plugin](https://awesome-dsh-plugin.com/badge.svg)](https://awesome-dsh-plugin.com)
 
 ---
 
-**离开 DSH 页面也不错过任何动静。** 当模型停下来需要你操作（审批 / 方案待确认 / 提问）、或你在别的软件时回复正好在后台完成，dsh-notify-me 会用系统通知 + 提示音 + 标签页标题标记提醒你——开关和通知语言都直接在 **DSH 设置 → 通知提醒** 里改。
+**离开 DSH 页面也不错过任何动静。** 当模型停下来需要你操作（审批 / 方案待确认 / 提问）、或你在别的软件时回复正好在后台完成，dsh-notify-me 会用系统通知 + 提示音 + 标签页标题标记提醒你——权限审批的通知还带「同意 / 拒绝」按钮，点一下就完成裁决，不用切回页面。开关和通知语言都直接在 **DSH 设置 → 通知提醒** 里改。
 
 ---
 
@@ -42,7 +42,7 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 
 | 时机 | 提醒内容 | 默认 |
 | --- | --- | --- |
-| 🔔 **模型需要你操作** — 审批请求 / 方案待确认（plan review）/ 提问（`ask_user_question`） | 通知 + 提示音 + `🔔 需要你 ·` 标题标记 | 页面可见也提醒 |
+| 🔔 **模型需要你操作** — 审批请求 / 方案待确认（plan review）/ 提问（`ask_user_question`） | 通知 + 提示音 + `🔔 需要你 ·` 标题标记；审批的通知上直接带「同意 / 拒绝」按钮 | 页面可见也提醒 |
 | ✅ **回复完成** — 一轮回复跑完；后台会话完成也会报 | 通知 + 提示音 | 仅页面隐藏/后台时提醒 |
 
 ## 在 DSH 设置里改配置
@@ -52,14 +52,15 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 - **启用提醒** 主开关：关闭后不再弹系统通知、不播放提示音、也不改标签页标题；
 - **系统通知 / 提示音 / 音量**：Toast、WebAudio 提示音与音量滑块；
 - **页面打开时也提醒「需要你」**（默认开）与 **页面打开时也提醒「回复完成」**（默认关）；
+- **审批通知上直接裁决**（默认开）：权限审批的通知上带「同意 / 拒绝」按钮，点一下就按审批卡片的「允许一次 / 拒绝」直接裁决，不用切回页面；点通知正文仍是原来的「切回对应对话」；
 - **通知语言**：跟随界面 / 简体中文 / English——决定通知文字与 `🔔 …` 标题标记使用的语言；
-- **测试按钮**：用当前设置立即发一条「需要你」或「回复完成」测试提醒（**不受**上面「页面打开时也提醒」开关限制；「需要你」测试的标题标记约 6 秒后自动消失）。
+- **测试按钮**：用当前设置立即发一条「需要你」「回复完成」或「审批按钮」测试提醒（**不受**上面「页面打开时也提醒」开关限制；「需要你」测试的标题标记约 6 秒后自动消失）。
 
 > 需要浏览器通知权限：页面上点一下 → 允许；或地址栏锁 → 站点设置 → 通知 → 允许 → 刷新。
 
 ## 提醒方式
 
-- **系统通知**：Windows 通知中心 Toast（点击可把 DSH 窗口切回前台）
+- **系统通知**：Windows 通知中心 Toast（点击可把 DSH 窗口切回前台；审批的通知点按钮直接裁决）
 - **提示音**：WebAudio 合成音（「需要你」与「完成」使用不同音型）
 - **标签页标题标记**：有待处理事项时，标题前出现 `🔔 需要你 · …` / `🔔 Action needed · …`
 
@@ -78,10 +79,12 @@ dsh plugin --profile web add dsh-notify-me
 
 | 宿主代际 | 「需要你」交互来源 | 判断当前会话 | 点通知切会话 |
 | --- | --- | --- | --- |
-| `≤ 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.2-alpha.1` | 控制器快照的 `pending[]` | 快照 `current` | `sessions.open()` |
+| `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` 存在即走新路），版本号只是各形状的出现边界。
+
 实测**真正激活**（各自独立 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 控制台执行：
@@ -89,6 +92,8 @@ dsh plugin --profile web add dsh-notify-me
 ```js
 window.__dshNotifyMe.test("done")        // 「完成」示例
 window.__dshNotifyMe.test("attention")   // 「需要你」示例
+window.__dshNotifyMe.test("approval")    // 「审批按钮」示例：通知上有「同意 / 拒绝」，点着试试
+window.__dshNotifyMe.debug()             // 桥接状态看 bridge 字段，active = 按钮可用
 ```
 
 没反应？九成是：通知权限被拒绝（在页面上点一下 → 选「允许」；或地址栏锁 → 站点设置 → 通知 → 允许 → 刷新）、装完没重启 DSH、系统设置里浏览器通知被关。
@@ -107,9 +112,11 @@ window.__dshNotifyMe.setConfig({
   toast: true,                // 系统通知开关
   sound: true,                // 提示音开关
   volume: 0.5,                // 音量 0~1
-  autoFocus: true             // 点通知切回 DSH 窗口
+  autoFocus: true,            // 点通知切回 DSH 窗口
+  quickActions: true          // 审批通知上的「同意 / 拒绝」按钮
 })
 window.__dshNotifyMe.resetConfig()                // 恢复默认
+window.__dshNotifyMe.decide("approval:3", "allowed-once")  // 程序化裁决："allowed-once" | "rejected"
 ```
 
 ## 工作原理
@@ -122,12 +129,19 @@ window.__dshNotifyMe.resetConfig()                // 恢复默认
 
 提醒核心仍然零第三方运行时依赖、完全自包含：通知文字按所选语言（跟随界面 / 中文 / English）即时解析。设置页是**可选**的 React 呈现层——当 DSH web profile 提供 `slots` / `locale` / `react` 时才注册进「设置 → 通知提醒」，缺任一能力时插件自动降级为纯提醒（无设置页），不影响功能。
 
+### 快捷裁决怎么走通的
+
+通知按钮（`actions`）只属于 Service Worker 弹的持久通知，往 `new Notification()` 里传 `actions` 会直接抛 `TypeError`——这是绕不开的浏览器限制。所以 bundle 一份文件干两件事：页面里照常注册提醒工厂，同一份字节再注册成一个只干转信的 Service Worker，把「点了哪个按钮」（同意 / 拒绝 / 点正文）带回页面。真正的裁决发生在页面里，调的是审批卡片自己用的 `PendingApproval.answer('allowed-once' | 'rejected')`，所以「同意」就是「允许一次」，不多放行任何东西。
+
+每条按钮通知按交互 key 记账，一次只认领一条等待；请求被页面里答掉、或被新请求顶替之后，残留通知上的按钮再点也不会误裁，只是安静地关掉。带按钮的通知不设自动消失——审批没裁决就一直留在通知中心里等你。
+
 ## 已知限制
 
 - 页面必须开着才会提醒（后台标签/最小化可以；关标签页即失效——浏览器层方案固有限制）。
 - 通知经由浏览器弹出，需允许浏览器通知权限，且勿扰模式不能屏蔽它。
 - 每次页面加载后第一次出声/弹通知前，需在页面上点击过一次（浏览器自动播放与权限策略）。
 - 未授权通知权限时只有提示音与标题标记。
+- 快捷裁决按钮要 Service Worker：`http://127.0.0.1`、`https` 可用，`http://192.168.x.x` 这类局域网地址不行；浏览器或桌面宿主不渲染通知按钮时，`window.__dshNotifyMe.debug()` 的 `bridge` 字段会说明原因，通知自动退回无按钮样式，其余功能不受影响。
 - 配置存在浏览器 `localStorage`：换浏览器/设备或清除站点数据后会回到默认值（设置页可一键恢复默认）。
 - `≥ 0.1.6`（含 `0.2.0-rc.2`）的「回复完成」提醒正文只有会话名，不再附带回复摘要——宿主快照已不再提供 `nodes`；提醒本身照常触发。
 - 标题标记由宿主与插件共同写 `document.title`：宿主重算标题时标记可能被覆盖，直到下一次提醒事件重新写成。
@@ -137,7 +151,7 @@ window.__dshNotifyMe.resetConfig()                // 恢复默认
 ```powershell
 node --check lib\client.js
 node --check lib\index.js
-node smoke\smoke-test.cjs        # 离线状态机冒烟测试：三代宿主 + 主开关 + 中英语言用例
+node smoke\smoke-test.cjs        # 离线状态机冒烟测试：三代宿主 + 主开关 + 中英语言用例 + 快捷裁决桥（Service Worker 半侧一并跑）
 node smoke\cordis-host-test.mjs  # 真 cordis 端到端（找不到本机 DSH 时自动跳过）
 npm pack --dry-run               # 预览发布包
 ```

package/lib/client.js

@@ -35,6 +35,15 @@
 //   - 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;
+//   - quick-decides approvals from the toast itself (option, on by default):
+//     approval notifications carry 同意/拒绝 action buttons and one click on a
+//     button settles the request through the interaction's own
+//     answer('allowed-once' | 'rejected') — the exact verb the in-page approval
+//     card uses. Action buttons only exist on persistent notifications, so this
+//     file is dual-context: registered as a Service Worker as well, whose
+//     notificationclick relays the chosen button back to this page (broadcast +
+//     client postMessage). Where a worker cannot run (insecure context, no
+//     bundle URL) the plugin degrades to today's plain toast;
 //   - registers a "通知提醒 / Notify me" page into DSH Settings
 //     (settings.section slot) exposing an on/off master switch, per-channel
 //     toggles, volume and the notification language (follow-interface /
@@ -42,9 +51,71 @@
 //   - preferences persist in localStorage (origin-scoped, like other
 //     third-party client plugins) and are tweakable on window.__dshNotifyMe.
 
-window.__ModuleLoader__.load({
-  id: "dsh-notify-me",
-  factory: (require) => {
+// One file, two jobs. The DSH module loader evaluates this script in the page
+// (registering the factory below), and the very same served bytes are also
+// registered as the plugin's Service Worker — see the bridge at the bottom of
+// this wrapper.
+(function (root) {
+    if (!root) return;
+
+    // ──────────────── service-worker half (notification bridge) ────────────
+    var BRIDGE_CHANNEL = "dsh-notify-me:bridge";
+    // A real Service Worker global is the only context with a registration and
+    // no document; the page (and any test harness) never matches.
+    function isServiceWorkerScope(g) {
+      return !!g && typeof g.registration === "object" && g.registration !== null &&
+        typeof g.addEventListener === "function" && typeof g.document === "undefined";
+    }
+    // The worker never decides anything: it only relays which button was
+    // clicked to the page that owns the pending interaction. Both a
+    // BroadcastChannel and a direct client postMessage are used — the channel
+    // covers every same-origin page, the postMessage covers environments where
+    // the worker cannot open one.
+    function installNotificationBridge(g) {
+      function relay(msg) {
+        try {
+          if (typeof g.BroadcastChannel === "function") {
+            var ch = new g.BroadcastChannel(BRIDGE_CHANNEL);
+            ch.postMessage(msg);
+            try { ch.close(); } catch (e) {}
+          }
+        } catch (e) {}
+        try {
+          if (g.clients && typeof g.clients.matchAll === "function") {
+            g.clients.matchAll({ type: "window", includeUncontrolled: true }).then(function (list) {
+              for (var i = 0; i < list.length; i++) {
+                try { list[i].postMessage(msg); } catch (e) {}
+              }
+            }, function () {});
+          }
+        } catch (e) {}
+      }
+      g.addEventListener("notificationclick", function (event) {
+        try {
+          var n = event.notification;
+          var data = (n && n.data) || {};
+          var msg = {
+            source: "dsh-notify-me",
+            type: "notification",
+            action: event.action || "",
+            key: data.key || null,
+            sessionId: data.sessionId || null
+          };
+          try { if (n && typeof n.close === "function") n.close(); } catch (e) {}
+          if (typeof event.waitUntil === "function") {
+            event.waitUntil(Promise.resolve().then(function () { relay(msg); }));
+          } else {
+            relay(msg);
+          }
+        } catch (e) {}
+      });
+    }
+    if (isServiceWorkerScope(root)) { installNotificationBridge(root); return; }
+    if (!root.__ModuleLoader__ || typeof root.__ModuleLoader__.load !== "function") return;
+
+    root.__ModuleLoader__.load({
+      id: "dsh-notify-me",
+      factory: (require) => {
     var module = { exports: {} };
     var exports = module.exports;
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
@@ -72,7 +143,13 @@ window.__ModuleLoader__.load({
       toast: true,
       sound: true,
       volume: 0.5,
-      autoFocus: true // clicking the toast focuses the DSH window
+      autoFocus: true, // clicking the toast focuses the DSH window
+      // Approval toasts carry 同意/拒绝 buttons and settle the request on one
+      // click (the same answer('allowed-once' | 'rejected') the in-page
+      // approval card sends). Buttons need persistent notifications, served
+      // through the Service Worker half of this same file; where that cannot
+      // run, the toast simply falls back to its plain form.
+      quickActions: true
     };
     function readConfig() {
       var cfg = {};
@@ -114,8 +191,13 @@ window.__ModuleLoader__.load({
         background: "后台会话",
         marker: "🔔 需要你 · ",
         sep: "：",
+        approve: "同意",
+        reject: "拒绝",
         testAttention: "这是一条测试提醒：DSH 需要你的操作",
-        testDone: "测试提醒 · 回复完成示例"
+        testDone: "测试提醒 · 回复完成示例",
+        testApproval: "这是一条测试审批：点通知上的「同意 / 拒绝」按钮试试快捷裁决",
+        testApproved: "测试提醒 · 已模拟「同意」（仅测试，未改动任何会话）",
+        testRejected: "测试提醒 · 已模拟「拒绝」（仅测试，未改动任何会话）"
       },
       en: {
         kind: { approval: "Approval request", "plan-review": "Plan review", question: "Question" },
@@ -132,8 +214,13 @@ window.__ModuleLoader__.load({
         background: "Background session",
         marker: "🔔 Action needed · ",
         sep: ": ",
+        approve: "Approve",
+        reject: "Reject",
         testAttention: "This is a test alert: DSH is waiting for your input",
-        testDone: "Test alert · reply-finished sample"
+        testDone: "Test alert · reply-finished sample",
+        testApproval: "This is a test approval: try quick decisions with the Approve / Reject buttons on the toast",
+        testApproved: "Test alert · simulated \"Approve\" (test only, nothing changed)",
+        testRejected: "Test alert · simulated \"Reject\" (test only, nothing changed)"
       }
     };
     // Locale service handle (registered on the client context by dsh-client-locale).
@@ -200,12 +287,227 @@ window.__ModuleLoader__.load({
         if (ws && typeof ws.openSession === "function") ws.openSession(sessionId);
       } catch (e) {}
     }
-    function showToast(kind, title, body, sessionId) {
+    // ─────────────── approval quick-decision bridge ───────────────
+    // Action buttons exist only on persistent notifications
+    // (ServiceWorkerRegistration.showNotification); the Notification()
+    // constructor throws on an `actions` option. The worker half lives at the
+    // bottom of this file's wrapper and only relays clicks back here, where the
+    // pending interaction's own answer() settles the request.
+    var BRIDGE_CHANNEL = "dsh-notify-me:bridge";
+    var swRegistration = null;
+    var swState = "idle"; // idle | disabled | registering | active | unsupported:* | failed:*
+    var bridgeListening = false;
+    var actionChannel = null;
+    // Keyed by interaction key: every toast that carries buttons has a record
+    // here, so a click can only ever decide the exact request it was raised
+    // for. { sessionId, interaction, tag, test }
+    var pendingActions = Object.create(null);
+    // The single-record combo URL of THIS bundle — the only URL that may be
+    // registered as a worker, since a multi-plugin combo would evaluate every
+    // other plugin's factory in the worker and fail the registration. The boot
+    // graph publishes it per entry ({id, url, rev}).
+    function selfBundleUrl() {
+      try {
+        var boot = window.__DSH_BOOT__;
+        var entries = boot && boot.entries;
+        if (Array.isArray(entries)) {
+          for (var i = 0; i < entries.length; i++) {
+            var e = entries[i];
+            if (e && e.id === "dsh-notify-me" && typeof e.url === "string" && e.url) return e.url;
+          }
+        }
+      } catch (e) {}
+      return null;
+    }
+    function ensureActionBridge() {
+      if (!config.quickActions) { swState = "disabled"; return; }
+      if (swState === "active" || swState === "registering") return;
+      listenBridge();
+      try {
+        if (typeof navigator === "undefined" || !navigator.serviceWorker) {
+          swState = "unsupported: no service worker";
+          return;
+        }
+        if (window.isSecureContext === false) {
+          swState = "unsupported: insecure context";
+          return;
+        }
+        var url = selfBundleUrl();
+        if (!url) {
+          swState = "unsupported: bundle url unknown";
+          return;
+        }
+        swState = "registering";
+        navigator.serviceWorker.register(url).then(function (reg) {
+          try {
+            swRegistration = reg || null;
+            if (!reg) { swState = "failed: no registration"; return; }
+            if (reg.active) { swState = "active"; return; }
+            var w = reg.installing || reg.waiting;
+            if (!w) { swState = "active"; return; }
+            var settle = function () {
+              try {
+                if (reg.active || w.state === "activated") swState = "active";
+                else if (w.state === "redundant") swState = "failed: worker redundant";
+              } catch (e) {}
+            };
+            try { w.addEventListener("statechange", settle); } catch (e) {}
+            settle();
+          } catch (e) {
+            swState = "failed: " + ((e && e.message) || e);
+          }
+        }, function (err) {
+          swState = "failed: " + ((err && err.message) || err);
+        });
+      } catch (e) {
+        swState = "failed: " + ((e && e.message) || e);
+      }
+    }
+    function bridgeActive() {
+      return !!(swRegistration && swState === "active");
+    }
+    // Both relay paths end here; the worker's broadcast goes to every
+    // same-origin page and the postMessage to every window client, so the
+    // handler must be idempotent (decidePending() is a one-shot per key).
+    function listenBridge() {
+      if (bridgeListening) return;
+      bridgeListening = true;
+      try {
+        if (typeof navigator !== "undefined" && navigator.serviceWorker &&
+            typeof navigator.serviceWorker.addEventListener === "function") {
+          navigator.serviceWorker.addEventListener("message", function (ev) {
+            try { onBridgeMessage(ev && ev.data); } catch (e) {}
+          });
+        }
+      } catch (e) {}
+      try {
+        if (typeof BroadcastChannel === "function") {
+          actionChannel = new BroadcastChannel(BRIDGE_CHANNEL);
+          actionChannel.onmessage = function (ev) {
+            try { onBridgeMessage(ev && ev.data); } catch (e) {}
+          };
+        }
+      } catch (e) {}
+    }
+    function onBridgeMessage(msg) {
+      if (!msg || msg.source !== "dsh-notify-me" || msg.type !== "notification") return;
+      if (msg.action === "approve") { decidePending(msg.key, "allowed-once"); return; }
+      if (msg.action === "reject") { decidePending(msg.key, "rejected"); return; }
+      if (config.autoFocus) focusSession(msg.sessionId || null);
+    }
+    // The live interaction wins over the reference captured at alert time (the
+    // wait may have been replaced), and a key with no live record is stale —
+    // the notification outlived its request, so the click must decide nothing.
+    function findPendingByKey(key) {
+      try {
+        var svc = lookupService("uiSession");
+        var found = interactionStore(svc);
+        if (!found) return null;
+        var snap = found.store.getSnapshot();
+        if (!snap || typeof snap.forEach !== "function") return null;
+        var hit = null;
+        snap.forEach(function (value) {
+          if (hit) return;
+          var it = pendingOf(value, found.source);
+          if (it && it.key === key) hit = it;
+        });
+        return hit;
+      } catch (e) { return null; }
+    }
+    function closeNotificationTag(tag) {
+      if (!swRegistration || typeof swRegistration.getNotifications !== "function") return;
+      try {
+        var done = function (list) {
+          for (var i = 0; i < (list || []).length; i++) {
+            try { list[i].close(); } catch (e) {}
+          }
+        };
+        var r = swRegistration.getNotifications({ tag: tag });
+        if (r && typeof r.then === "function") r.then(done, function () {});
+        else done(r);
+      } catch (e) {}
+    }
+    // One toast button press. outcome: 'allowed-once' | 'rejected' — exactly
+    // the two decisions the in-page approval card exposes.
+    function decidePending(key, outcome) {
+      var rec = key ? pendingActions[key] : null;
+      if (!rec) return false; // already answered elsewhere, or a stale toast
+      delete pendingActions[key];
+      if (!rec.test) closeNotificationTag(rec.tag);
+      if (rec.test) {
+        // Test toasts settle nothing real; the feedback toast IS the proof that
+        // the button clicked all the way through the worker bridge.
+        deliver("done", texts().doneTitle, outcome === "allowed-once" ? texts().testApproved : texts().testRejected, null, null);
+        notifyEvent("decision", { key: key, outcome: outcome, sessionId: rec.sessionId || null, test: true });
+        return true;
+      }
+      var target = findPendingByKey(key) || rec.interaction;
+      if (!target || target.key !== key || typeof target.answer !== "function") return false;
+      try {
+        var p = target.answer(outcome);
+        if (p && typeof p.catch === "function") p.catch(function () {});
+      } catch (e) { return false; }
+      unmarkAttention(key);
+      notifyEvent("decision", { key: key, outcome: outcome, sessionId: rec.sessionId || null });
+      return true;
+    }
+    // Attach buttons to one alert. Only real approval interactions qualify:
+    // they are the only kind whose decision is a plain binary, and the only one
+    // whose object answers answer('allowed-once' | 'rejected').
+    function quickFor(key, it, sessionId) {
+      if (!config.quickActions || !config.toast) return null;
+      if (!it || it.kind !== "approval" || typeof it.answer !== "function") return null;
+      var q = {
+        key: key,
+        sessionId: sessionId || null,
+        interaction: it,
+        tag: "dsh-notify-me-attention-" + key,
+        test: false
+      };
+      pendingActions[key] = q;
+      return q;
+    }
+    function quickForTest(key) {
+      var q = {
+        key: key,
+        sessionId: null,
+        interaction: null,
+        tag: "dsh-notify-me-attention-" + key,
+        test: true
+      };
+      pendingActions[key] = q;
+      return q;
+    }
+
+    function showToast(kind, title, body, sessionId, quick) {
       if (!canToast()) return;
       try {
+        var tag = quick ? quick.tag : "dsh-notify-me-" + kind;
+        if (quick && bridgeActive()) {
+          var d = texts();
+          try {
+            swRegistration.showNotification(title, {
+              body: body || "",
+              tag: tag,
+              renotify: true,
+              // The plugin owns the audio (see showToast's silent note below).
+              silent: true,
+              icon: (location.origin || "") + "/favicon.svg",
+              data: { key: quick.key, sessionId: sessionId || null, kind: kind, test: !!quick.test },
+              actions: [
+                { action: "approve", title: d.approve },
+                { action: "reject", title: d.reject }
+              ]
+            });
+            // No auto-close on purpose: an unanswered approval stays clickable
+            // (toast, then Action Center) until the request is settled — the
+            // wait-teardown path closes it through closeNotificationTag().
+            return;
+          } catch (e) { /* worker notifications unavailable -> plain toast */ }
+        }
         var n = new Notification(title, {
           body: body || "",
-          tag: "dsh-notify-me-" + kind,
+          tag: tag,
           renotify: true,
           // The plugin owns the audio: its WebAudio cues already differ per
           // kind (attention vs done) and answer the Sound toggle and volume
@@ -327,6 +629,15 @@ window.__ModuleLoader__.load({
     }
     function unmarkAttention(key) {
       delete quietedAttention[key]; // the wait is over; a queued alert dies with it
+      // A toast that still carries buttons for this wait dies with it too —
+      // otherwise a settled request would leave a clickable (but stale)
+      // approval toast behind. Test toasts are exempt: their click is the
+      // proof, so they outlive the short title mark on purpose.
+      var rec = pendingActions[key];
+      if (rec) {
+        delete pendingActions[key];
+        if (!rec.test) closeNotificationTag(rec.tag);
+      }
       if (!attentionKeysMarked[key]) return;
       delete attentionKeysMarked[key];
       releaseTitleMark();
@@ -347,21 +658,24 @@ window.__ModuleLoader__.load({
     // buttons); respects the master switch and permission state. The title
     // marker is NOT touched here — its ownership belongs to the watchers
     // (markAttention / unmarkAttention), which keeps the counter balanced.
-    function deliver(kind, title, body, sessionId) {
+    function notifyEvent(kind, payload) {
+      try {
+        if (window.__dshNotifyMe && window.__dshNotifyMe.onEvent) {
+          window.__dshNotifyMe.onEvent(kind, payload);
+        }
+      } catch (e) {}
+    }
+    function deliver(kind, title, body, sessionId, quick) {
       if (!config.enabled) return;
-      showToast(kind, title, body, sessionId);
+      showToast(kind, title, body, sessionId, quick);
       if (kind === "attention") {
         playAttentionSound();
       } else {
         playDoneSound();
       }
-      try {
-        if (window.__dshNotifyMe && window.__dshNotifyMe.onEvent) {
-          window.__dshNotifyMe.onEvent(kind, { title: title, body: body, sessionId: sessionId || null });
-        }
-      } catch (e) {}
+      notifyEvent(kind, { title: title, body: body, sessionId: sessionId || null });
     }
-    function fire(kind, title, body, isCurrent, sessionId) {
+    function fire(kind, title, body, isCurrent, sessionId, quick) {
       if (!config.enabled) return false;
       if (kind === "attention" && config.attentionHiddenOnly && !hidden()) return false;
       // The wait belongs to the conversation the user is looking at right now:
@@ -370,7 +684,7 @@ window.__ModuleLoader__.load({
       // flushQuieted() re-delivers the alert the moment the page is backgrounded.
       if (kind === "attention" && quietedByVisibleSession(isCurrent)) return false;
       if (kind === "done" && config.doneHiddenOnly && !hidden()) return false;
-      deliver(kind, title, body, sessionId);
+      deliver(kind, title, body, sessionId, quick);
       return true;
     }
     // True when this alert must stay silent purely because it is about the
@@ -390,7 +704,7 @@ window.__ModuleLoader__.load({
       for (var i = 0; i < keys.length; i++) {
         var copy = quietedAttention[keys[i]];
         delete quietedAttention[keys[i]];
-        fire("attention", copy.title, copy.body, false, copy.sessionId);
+        fire("attention", copy.title, copy.body, false, copy.sessionId, copy.quick || null);
       }
     }
     // A display label for a session row ("current" maps to the localized
@@ -436,16 +750,17 @@ window.__ModuleLoader__.load({
     }
     // 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.
-    function fireAttention(kind, sessionLabel, detail, isCurrent, sessionId) {
+    // copy by interaction key so it can still fire from the background (the
+    // quick-decision payload rides along with the copy).
+    function fireAttention(kind, sessionLabel, detail, isCurrent, sessionId, quick) {
       var d = texts();
       var label = d.kind[kind] || d.kindDefault;
       var content = detail || d.bodyKind[kind] || d.bodyDefault;
       var who = sessionLabel || "";
       var title = "DSH · " + label;
       var body = (who ? who + d.sep : "") + content;
-      if (quietedByVisibleSession(isCurrent)) return { title: title, body: body, sessionId: sessionId || null };
-      fire("attention", title, body, isCurrent, sessionId);
+      if (quietedByVisibleSession(isCurrent)) return { title: title, body: body, sessionId: sessionId || null, quick: quick || null };
+      fire("attention", title, body, isCurrent, sessionId, quick);
       return null;
     }
     function fireDone(sessionLabel, snippet, sessionId) {
@@ -464,6 +779,20 @@ window.__ModuleLoader__.load({
     var TEST_MARK_KEY = "test:attention";
     function testAlert(kind) {
       var d = texts();
+      if (kind === "approval") {
+        // End-to-end proof of the quick-decision path: this toast carries the
+        // same 同意/拒绝 buttons as a real approval one, and clicking them runs
+        // the whole worker-bridge -> decidePending() chain (settling nothing
+        // real — the feedback toast says so).
+        var key = "test:approval:" + String(Date.now());
+        var quick = quickForTest(key);
+        deliver("attention", "DSH · " + d.kind.approval, d.testApproval, null, quick);
+        markAttention(key);
+        // The title mark drops like every other test's, but the toast is NOT
+        // closed with it — its buttons are the very thing being tested.
+        setTimeout(function () { unmarkAttention(key); }, TEST_MARK_RELEASE_MS);
+        return;
+      }
       if (kind === "attention") {
         deliver("attention", "DSH · " + d.kind.question, d.testAttention);
         markAttention(TEST_MARK_KEY);
@@ -578,7 +907,8 @@ window.__ModuleLoader__.load({
       //    the title marker itself (see the uiSession watcher below).
       if (newKeys.length > 0) {
         var it = newKeys[0];
-        var copy = fireAttention(it.kind, sessionLabelText(row), textFromPayload(it.payload), !!row.face, row.id);
+        var quick = quickFor(it.key, it, row.id);
+        var copy = fireAttention(it.kind, sessionLabelText(row), textFromPayload(it.payload), !!row.face, row.id, quick);
         if (copy) queueQuieted(it.key, copy);
         lastAttentionAt = Date.now();
         markAttention(it.key);
@@ -811,7 +1141,8 @@ window.__ModuleLoader__.load({
         if (prev) unmarkAttention(prev.key);
         if (attentionKeysFired[key]) { markAttention(key); return; } // already alerted, still needs its mark
         attentionKeysFired[key] = true;
-        var copy = fireAttention(it.kind, labelForSessionId(sid), textFromPayload(it), currentSessionId() === sid, sid);
+        var quick = quickFor(key, it, sid);
+        var copy = fireAttention(it.kind, labelForSessionId(sid), textFromPayload(it), currentSessionId() === sid, sid, quick);
         if (copy) queueQuieted(key, copy);
         lastAttentionAt = Date.now();
         markAttention(key);
@@ -848,7 +1179,7 @@ window.__ModuleLoader__.load({
       });
     } catch (e) {}
     // keep in sync with package.json "version" on every release
-    api.version = "1.2.1";
+    api.version = "1.3.0";
     api.setConfig = function (patch) { return setConfigLocal(patch); };
     api.resetConfig = function () {
       try { localStorage.removeItem(LS_CONFIG); } catch (e) {}
@@ -858,10 +1189,15 @@ window.__ModuleLoader__.load({
     // manual test; run it after clicking anywhere so permission can be granted.
     // Test alerts fire regardless of the page-open visibility rules.
     api.test = function (kind) {
-      kind = kind === "attention" ? "attention" : "done";
+      kind = (kind === "attention" || kind === "approval") ? kind : "done";
       unlockOnce();
       testAlert(kind);
-      return "sent " + kind + " (lang=" + effectiveLang() + ", permission=" + ("Notification" in window ? Notification.permission : "n/a") + ")";
+      return "sent " + kind + " (lang=" + effectiveLang() + ", permission=" + ("Notification" in window ? Notification.permission : "n/a") + ", bridge=" + swState + ")";
+    };
+    // Programmatic twin of a toast button press: settles the pending approval
+    // behind `key` the same way the 同意/拒绝 buttons do.
+    api.decide = function (key, outcome) {
+      return decidePending(key, outcome === "rejected" ? "rejected" : "allowed-once");
     };
     // Live diagnostics for the "why did nothing pop" case. The needs-input
     // channel has three possible owners on current hosts (uiSession.sessionStatus
@@ -878,6 +1214,11 @@ window.__ModuleLoader__.load({
         doneHiddenOnly: config.doneHiddenOnly,
         toast: config.toast,
         sound: config.sound,
+        quickActions: config.quickActions,
+        // quick-decision bridge: 'active' is the only state in which approval
+        // toasts carry working 同意/拒绝 buttons.
+        bridge: swState,
+        actionKeys: Object.keys(pendingActions),
         permission: ("Notification" in window) ? Notification.permission : "n/a",
         visibility: hidden() ? "hidden" : "visible",
         uiSession: uiPending ? "bound" : "unbound",
@@ -915,6 +1256,11 @@ window.__ModuleLoader__.load({
       doneVisibleHint: "默认关闭：「完成」只在页面隐藏或切到后台时才提醒，避免打扰。",
       autoFocus: "点击通知回到对应对话",
       autoFocusHint: "默认开启：点系统通知会把 DSH 带到前台，并直接切到这条提醒所属的对话；关掉后点击通知不做任何事。",
+      quickActions: "审批通知上直接裁决",
+      quickActionsHint: "默认开启：权限审批的通知上带「同意 / 拒绝」按钮，点一下即按审批卡片的「允许一次 / 拒绝」直接完成裁决，不用切回页面。需要支持 Service Worker 的浏览器（http://127.0.0.1 或 https）；用不了时自动退回普通通知。",
+      quickApprovalNote: "「同意」等价于审批卡片上的「允许一次」，只放行这一次。",
+      bridgeOff: "快捷裁决按钮暂不可用（",
+      bridgeOffTail: "）：审批通知会退回不带按钮的普通样式。",
       volume: "音量",
       language: "通知语言",
       langAuto: "跟随界面",
@@ -926,6 +1272,7 @@ window.__ModuleLoader__.load({
       testHint: "用当前设置各发一条测试提醒（不受上面「页面打开时也提醒」开关限制）。",
       testAttention: "测试「需要你」",
       testDone: "测试「回复完成」",
+      testApprovalBtn: "测试「审批按钮」",
       reset: "恢复默认设置",
       resetDone: "已恢复默认设置。",
       sent: "已发送测试提醒 · 通知语言：",
@@ -949,6 +1296,11 @@ window.__ModuleLoader__.load({
       doneVisibleHint: "Off by default: \"done\" only alerts while the page is hidden or backgrounded, to avoid noise.",
       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",
+      quickActionsHint: "On by default: approval notifications carry Approve / Reject buttons, and one click settles the request exactly like the Allow once / Reject buttons on the approval card. Needs a Service Worker capable browser (http://127.0.0.1 or https); falls back to plain toasts where unavailable.",
+      quickApprovalNote: "\"Approve\" equals \"Allow once\" on the approval card — it allows that one call only.",
+      bridgeOff: "Quick-decision buttons are unavailable right now (",
+      bridgeOffTail: "); approval toasts fall back to their plain form.",
       volume: "Volume",
       language: "Notification language",
       langAuto: "Follow the interface",
@@ -960,6 +1312,7 @@ window.__ModuleLoader__.load({
       testHint: "Send one test alert with the current settings (not limited by the \"while the page is open\" toggles above).",
       testAttention: "Test \"needs you\"",
       testDone: "Test \"reply finished\"",
+      testApprovalBtn: "Test approval buttons",
       reset: "Restore defaults",
       resetDone: "Defaults restored.",
       sent: "Test alert sent · notification language: ",
@@ -1047,7 +1400,9 @@ window.__ModuleLoader__.load({
         // page is open, otherwise the button proves nothing.
         testAlert(kind);
         var langName = effectiveLang() === "en" ? t("langEn") : t("langZh");
-        setFeedback(t("sent") + langName);
+        var msg = t("sent") + langName;
+        if (kind === "approval" && !bridgeActive()) msg += " · " + t("bridgeOff") + swState + t("bridgeOffTail");
+        setFeedback(msg);
       }
       var permOK = ("Notification" in window) ? Notification.permission === "granted" : false;
       var resolvedLang = effectiveLang();
@@ -1067,6 +1422,10 @@ window.__ModuleLoader__.load({
           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("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 });
+            if (v) ensureActionBridge();
+          }),
           h("div", { className: "dnm-row" }, [
             h("div", { className: "dnm-rowText" }, [
               h("div", { className: "dnm-rowLabel" }, t("volume")),
@@ -1106,9 +1465,15 @@ window.__ModuleLoader__.load({
             ]),
             h("div", { className: "dnm-btnRow" }, [
               h("button", { type: "button", className: "dnm-btn", disabled: !cfg.enabled, onClick: function () { runTest("attention"); } }, t("testAttention")),
-              h("button", { type: "button", className: "dnm-btn", disabled: !cfg.enabled, onClick: function () { runTest("done"); } }, t("testDone"))
+              h("button", { type: "button", className: "dnm-btn", disabled: !cfg.enabled, onClick: function () { runTest("done"); } }, t("testDone")),
+              h("button", { type: "button", className: "dnm-btn", disabled: !cfg.enabled || !cfg.quickActions, onClick: function () { runTest("approval"); } }, t("testApprovalBtn"))
             ])
           ]),
+          cfg.quickActions && cfg.toast && !bridgeActive() ? h("div", { className: "dnm-row" }, [
+            h("div", { className: "dnm-rowText" }, [h("div", { className: "dnm-rowHint" }, t("bridgeOff") + swState + t("bridgeOffTail"))])
+          ]) : h("div", { className: "dnm-row" }, [
+            h("div", { className: "dnm-rowText" }, [h("div", { className: "dnm-rowHint" }, t("quickApprovalNote"))])
+          ]),
           h("div", { className: "dnm-row" }, [
             h("div", { className: "dnm-rowText" }, [
               h("div", { className: "dnm-rowLabel" }, t("reset")),
@@ -1197,6 +1562,10 @@ window.__ModuleLoader__.load({
           var onVisibility = function () { try { flushQuieted(); } catch (e) {} };
           try { document.addEventListener("visibilitychange", onVisibility); } catch (e) {}
           unsubs.push(function () { try { document.removeEventListener("visibilitychange", onVisibility); } catch (e) {} });
+          // Quick-decision bridge: register the worker half of this bundle (a
+          // no-op where quickActions is off or a worker cannot run) and start
+          // listening for toast-button relays.
+          try { ensureActionBridge(); } catch (e) {}
           // Interaction source first: it owns the title marker once present, so
           // binding it before the controller scan keeps a single mark per wait.
           bindUiSession();
@@ -1225,5 +1594,6 @@ window.__ModuleLoader__.load({
     exports.inject = inject;
     exports.apply = apply;
     return module.exports;
-  }
-});
+      }
+    });
+})(typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : null);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-notify-me",
-  "version": "1.2.1",
-  "description": "DSH 桌面消息提醒插件：模型需要你操作（审批/方案确认/提问的可操作提醒）或回复在后台完成时，系统通知+提示音+标签页标题提醒你；可在设置页开关并切换通知语言。Desktop notification & message alerts for DeepSeek Harness web — toasts, sounds and a tab-title marker when the agent needs your input (approval / plan review / question) or a reply finishes in the background; toggleable from Settings with zh/en notification language.",
+  "version": "1.3.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",
   "main": "lib/index.js",
@@ -34,10 +34,12 @@
     "message-alert",
     "needs-your-input",
     "approval-alert",
+    "approval-actions",
     "background-alert",
     "桌面通知",
     "消息提醒",
     "可操作提醒",
+    "审批提醒",
     "提醒插件",
     "需要你操作",
     "回复完成提醒",