dsh-notify-me 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 All notable changes to **dsh-notify-me** are documented here.
 
+## [1.7.0] — 2026-10-16
+
+### 新增
+- **外部通知转发**（issue #12）：把「需要你」「回复完成」提醒同时转发到你自己的推送端点，临时离开电脑时手机上的推送渠道照样收到。支持 **Discord Webhook** / **Bark** / **Gotify** / **自定义 Webhook** 四类目标，可配多个、各选类型填地址；负载形状：Discord 走 `{"username":"DSH","content":…}`（正文超长截 1900 字符），Bark 走 `{title, body, group}`，Gotify 走 `{title, message, priority}`（「需要你」priority 8、「回复完成」5），自定义端点收一条 POST JSON `{source, event, title, body, sessionId, time}`。
+- 新配置项（默认保守，不填端点就什么都不发）：`externalEnabled`（转发主开关，默认 `false`）、`externalAttention` / `externalDone`（两类提醒各自可关，默认开）、`externalTargets`（推送目标列表）。
+- 设置页新增「外部通知」卡片：主开关、「转发「需要你」」「转发「回复完成」」、目标列表（类型下拉 + 地址 + 删除）、添加目标、隐私提示（提醒正文会原样外发，只填自己信任的端点）、「发送测试通知」。
+- `window.__dshNotifyMe.testExternal()`：向所有目标发一条测试消息（不受两类提醒开关限制，也不会冒充真提醒），返回 `{sent, unverified, failed, statuses}`；`window.__dshNotifyMe.debug()` 新增 `external` 块（开关状态、目标数/有效目标数、成功/不可确认/失败计数与最后状态）。
+
+### 变更
+- 转发挂在 `fire()` 里、本地提醒决定要发之后触发：**跟本地提醒完全同一套触发规则**（「当前对话不弹通知」「页面打开时也提醒」等开关同样管它）；设置页的「测试提醒」按钮与快捷裁决反馈走 `deliver()`，不会误发 webhook。
+- 跨域（CORS）口径：先走能读回响应的 CORS POST JSON；被拒（CORS/网络错误）时降级 no-cors + `text/plain` 送出，如实标为「已送出不可确认」（响应对页面不可见是浏览器规则，读不回就没法确认）；Bark 另有经典 GET（`<地址>/<标题>/<正文>`）兜底；HTTP 错误如实记失败、不盲重试。
+- 版本号 1.6.1 → 1.7.0；`window.__dshNotifyMe.version` 与 `package.json` 同步；npm 关键词新增 external-notification / webhook / discord / bark / gotify / push-notification / 外部通知 / 推送提醒。
+- README（中英）同步：搜索词、设置清单、提醒方式、控制台配置块（四个新键 + `testExternal()`）、已知限制的 CORS 说明；致谢名单新增 [@RiZhiZhaoYi](https://github.com/RiZhiZhaoYi)（issue #12 的功能建议）。
+
+### 测试
+- `smoke/smoke-test.cjs` 新增两段：① 转发链路（默认零外发、toast 测试不触发转发、四类负载形状、真实提醒镜像与两类开关、主开关、no-cors 降级、HTTP 500 单次不重试、Bark GET 兜底、非法 URL 剔除与未知类型归为 custom）；② 设置页「外部通知」卡片（渲染与空状态、目标增删改落配置、测试按钮反馈文案、两种静默原因的提示语）。
+- 修掉测试脚手架一处坑：假 React 里 onChange 事件之间不重渲染的话，下一个处理器闭包里的 `cfg` 还是旧的、会把前一次编辑悄悄覆盖（真 React 每个事件之间都会重渲染，产品代码不受影响）。为此把 `settingsBoot` 提升到模块级并补 `renderNow()` / `find` / `findAll` / `configNow()`；`rowSwitch` 开关按钮补 `aria-label`——可及性修正，同时让测试能按名按到。
+- `npm test` 两套件均通过（含 `smoke/cordis-host-test.mjs` 真 cordis 腿）。
+
+## [1.6.1] — 2026-10-16
+
+### 修复
+- **列表变化里「当前会话」只推导一次，消掉 O(行数 × 会话数)**（性能，issue #13）：`isSubagentSession()` 现在接收调用方已经推导好的当前会话 id。此前它对**每一行**都要重新调 `currentSessionId()`，而 `0.1.6+`（含 `0.2.0-rc.2`）的列表快照已无 `current`，只能 `for (var id in byId)` 扫完整份会话表——一次列表变化因此是「行数 × 会话数」。实测（DSH `0.2.0-rc.2`、**482 个会话**、页面空闲时用 CDP 采 25s 与 38s 两轮 CPU profile）：`currentSessionId()` 自身耗时占 **5.9%~6.5%**，是该页面最热的 JS 函数；修复后同轮 profile 里它退到噪声水平。第二窗口/后台窗口下所有行 `mainView` 为 0 时，旧实现每次都要扫满全表再返回 `null`，这一档同样消失。
+- `evalUiStatus()` / `syncDoneFromStatus()` 两个「每个会话一条」的循环同样改为每次 pass 只推导一次。
+
+### 测试
+- `smoke/smoke-test.cjs` 新增断言「一次列表变化的 `byId` 枚举次数不随行数增长」（40 行与 4 行必须相等，不写死魔数）。本版基线上改动前该断言报 `9 vs 45`（PR 在 1.5.3 基线测得 `7 vs 43`），修复后为 `5 vs 5`（先写失败断言、先红后绿）。
+
+### 变更
+- 版本号 1.6.0 → 1.6.1；`window.__dshNotifyMe.version` 同步。
+- README（中英）致谢名单新增 [@yanzhaohui1999](https://github.com/yanzhaohui1999)（issue #13 的性能报告与 PR #14 的修复及回归断言）。
+
 ## [1.6.0] — 2026-10-15
 
 ### 新增

package/README.en.md

@@ -28,7 +28,7 @@ dsh-notify-me decouples **supervision** from **sitting in front of the screen**:
 
 ---
 
-> 🔎 Looking for it? Search `dsh-notify-me`, **message alerts**, **notification**, **desktop notification**, **reminder**, **approval alert** or **可操作提醒 / 消息提醒 / 桌面通知 / 需要你操作** (npm keywords include both English and Chinese terms).
+> 🔎 Looking for it? Search `dsh-notify-me`, **message alerts**, **notification**, **desktop notification**, **reminder**, **approval alert**, **external notifications**, **Discord / Bark / Gotify push** or **可操作提醒 / 消息提醒 / 桌面通知 / 需要你操作** (npm keywords include both English and Chinese terms).
 
 ## UI Preview
 
@@ -55,6 +55,7 @@ Open **Settings → Notify me** (refresh the page once after installing):
 - **Environment** (auto-detect by default) — identifies Web vs Desktop (DSH Desktop, `dsh-app://`) from the page protocol, with a manual override for hosts where detection comes out wrong: on the Desktop a toast click rides the `dsh://` deep link to raise the window and quick-decision buttons are unavailable; on the Web it is `window.focus()` plus the Service Worker bridge. Whenever the override disagrees with detection, the settings page says what detection saw;
 - **System notifications / Sound / Volume** — toast toggle, cue toggle and a volume slider;
 - **Alert sound** (picked separately for "needs you" and "reply finished") — built-in cue (default) / custom audio file / system notification sound. "Custom audio file" takes one local audio file in the settings page (1 MiB limit, stored in the browser, with preview and remove); "system notification sound" plays no plugin cue at all — the toast still appears and the operating system supplies the sound, so its timbre follows your system notification settings; in that mode "Preview" sends a test alert instead, because the sound only exists as part of a toast and that is the sound you hear. Any source that has no file, cannot be read, or does not fit falls back to the built-in cue, so an alert never goes silent;
+- **External notifications** (default off) — forward each alert to your own push endpoints as well, so it reaches you away from the machine: **Discord Webhook** / **Bark** / **Gotify** / **custom webhook**, any number of targets, each with a type and URL (Discord takes the webhook URL; Bark `https://api.day.app/<device key>`; Gotify `https://<server>/message?token=<app token>`; a custom endpoint receives one POST of JSON: `{source, event, title, body, sessionId, time}`). "Forward 'needs you'" and "Forward 'reply finished'" switch independently; **Send test notification** sends one test message to every target (not limited by those two switches, and never pretending to be a real alert). Forwarding follows exactly the same trigger rules as local alerts ("stay quiet for the conversation on screen" and friends apply to it too); the alert text is sent as-is to the addresses you fill in, so **only use endpoints you trust**;
 - **"Needs you" alerts while the page is open** (default on) and **"Reply finished" alerts while the page is open** (default off);
 - **Stay quiet for the conversation on screen** (default on): a wait inside the conversation you are looking at keeps only the tab marker — no toast or sound landing on the approval card. Backgrounding the page puts that alert back at once, unless you already handled it. Waits in other background sessions are unaffected;
 - **Ignore subagent sessions** (default on): background subagent child sessions raise neither "needs you" nor "reply finished" — those are steps of the parent conversation's turn, and the parent's own alert already covers them. The subagent session you have open alerts as usual. Turn it off to alert for every session;
@@ -71,6 +72,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 by default (distinct patterns for "needs you" vs "done"); each kind can instead play a picked audio file, or hand the sound over to the operating system's own notification sound
 - **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
+- **External notifications** (optional, default off) — the same alert is also forwarded to the push targets you configure: Discord Webhook / Bark / Gotify / custom webhook — so the push channel on your phone picks it up while you step away from the machine
 
 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).
 
@@ -129,10 +131,15 @@ window.__dshNotifyMe.setConfig({
   soundAttention: "synth",    // "needs you" cue source, same values
   volume: 0.5,                // 0..1
   autoFocus: true,            // clicking a toast opens the conversation it came from
-  quickActions: true          // Approve / Reject buttons on approval toasts
+  quickActions: true,         // Approve / Reject buttons on approval toasts
+  externalEnabled: false,     // external-notification forwarding master switch (default off: no endpoint, nothing is sent)
+  externalAttention: true,    // forward "needs you" (exactly the same trigger rules as local alerts)
+  externalDone: true,         // forward "reply finished"
+  externalTargets: []         // push targets: [{id, type:'discord'|'bark'|'gotify'|'custom', url}]
 })
 window.__dshNotifyMe.resetConfig()                // restore defaults (also drops any picked audio files)
 window.__dshNotifyMe.decide("approval:3", "allowed-once")  // programmatic decision: "allowed-once" | "rejected"
+window.__dshNotifyMe.testExternal()               // send one test notification to every push target, resolves {sent, unverified, failed, statuses}
 ```
 
 > Picked audio files do not live in `dshNotifyMe.config`: each kind gets its own key (`dshNotifyMe.sound.done` / `dshNotifyMe.sound.attention`, holding `{name, size, data}` with a data URL), because a file inflates by ~1.37x once base64-encoded and would slow down every config read. `resetConfig()` clears both keys along with the config.
@@ -174,6 +181,7 @@ Verified on the real shell (DSH Desktop 0.2.0-rc.2, three rounds of retesting in
 - 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.
 - "Stay quiet for the conversation on screen" is judged by `document.hidden`: a window fully covered by other apps still counts as visible, so waits in the current conversation stay quiet there too.
+- External notification forwarding is subject to browser CORS rules: an endpoint that does not allow cross-origin requests falls back to a "sent but unverifiable" delivery (no-cors) and is reported honestly as such; Discord webhooks do allow cross-origin, so delivery to them is confirmed. HTTP errors are recorded as failures and never blindly retried. Forwarding runs only after the local alert has decided to fire, so anything the rules silence is never sent out.
 
 ## Development
 
@@ -195,6 +203,8 @@ Contributors (by handle; the link points at the PR / issue they worked on):
 - [@d0ublecl1ck](https://github.com/d0ublecl1ck) — [#8](https://github.com/chromoany/dsh-notify-me/pull/8): muting subagent sessions (`ignoreSubagent`) with its tests and docs; the 1.4.0 refinement — mute only background subagents, alert as usual for the one you have open — is his suggestion from the #8 discussion, landed by the maintainer;
 - [@EliteOtaku](https://github.com/EliteOtaku) — [#9](https://github.com/chromoany/dsh-notify-me/issues/9): the layer-by-layer investigation and three rounds of real-shell retesting of the desktop raise path (1.5.2) — confirming that a toast click raises the window and switches conversations reliably, and pinning down the reproduction difference ("gesture-less scripted injection is silently dropped by Chromium"), which corrected the initial "the sandbox blocks it" reading;
 - [@Wh1stle05](https://github.com/Wh1stle05) — [#10](https://github.com/chromoany/dsh-notify-me/pull/10): the per-kind alert sound source (built-in synth / picked audio file / system notification sound, chosen independently for "needs you" and "reply done"), with its settings UI, fallback chain, tests and docs; the two refinements — a "system" preview sending a real test notification instead of doing nothing, and the fake React holding hook state by index across renders — come from the same PR.
+- [@yanzhaohui1999](https://github.com/yanzhaohui1999) — [#13](https://github.com/chromoany/dsh-notify-me/issues/13) / [#14](https://github.com/chromoany/dsh-notify-me/pull/14): the 482-session idle-page CPU report (pinning `currentSessionId()` rescanning the whole table per row, 5.9%~6.5% of CPU) and the fix (derive the on-screen session once per list change), with a red-then-green regression assertion — a 4-row and a 40-row list change must cost the same (upstream reported 7 vs 43, 5 vs 5 after).
+- [@RiZhiZhaoYi](https://github.com/RiZhiZhaoYi) — [#12](https://github.com/chromoany/dsh-notify-me/issues/12): the external-notification forwarding suggestion (Discord Webhook / Bark / Gotify / custom webhook) and its use case (1.7.0).
 
 Attribution policy: external PRs are landed as maintainer commits — the original commit is not reused and no Co-authored-by trailer is added, so GitHub's contributors graph lists the maintainer only and contributors are credited above.
 

package/README.md

@@ -28,7 +28,7 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 
 ---
 
-> 🔎 想找这个插件？可以搜：`dsh-notify-me`、**消息提醒**、**可操作提醒**、**桌面通知**、**需要你操作**、**回复完成提醒**、**后台完成提醒**（npm 关键词已含以上中英文词）。
+> 🔎 想找这个插件？可以搜：`dsh-notify-me`、**消息提醒**、**可操作提醒**、**桌面通知**、**需要你操作**、**回复完成提醒**、**后台完成提醒**、**外部通知**、**Discord / Bark / Gotify 推送**（npm 关键词已含以上中英文词）。
 
 ## 效果预览
 
@@ -55,6 +55,7 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 - **运行环境**（默认自动识别）：按页面协议识别 Web 端 / 桌面端（DSH Desktop，`dsh-app://`），识别不准时可手动指定——桌面端点通知走 `dsh://` 深链抬窗、快捷裁决按钮不可用；Web 端走 `window.focus()` 与 Service Worker 桥。手动覆盖与自动识别不一致时，设置页会明示检测结果；
 - **系统通知 / 提示音 / 音量**：Toast、提示音开关与音量滑块；
 - **音效来源**（「需要你」与「回复完成」各自独立选）：内置合成音（默认）/ 自定义音频文件 / 系统通知音。选「自定义音频文件」可在设置页挑一个本地音频（上限 1 MiB，存在浏览器本地，可试听与移除）；选「系统通知音」则完全不播插件音效，通知照发，声音交给操作系统（音色跟着系统通知设置走），此时「试听」会改发一条测试通知——该模式没有插件可播的音，你听到的就是它。任一来源缺文件、读不出来或存不下时自动回落到内置合成音，提醒不会因此变成哑的；
+- **外部通知**（默认关）：把提醒同时转发到你自己的推送端点，人不在电脑前也能收到——支持 **Discord Webhook** / **Bark** / **Gotify** / **自定义 Webhook**，可加多个目标，每个选类型填地址（Discord 填 Webhook 地址；Bark 填 `https://api.day.app/<设备密钥>`；Gotify 填 `https://<服务器>/message?token=<应用令牌>`；自定义端点收一条 POST JSON：`{source, event, title, body, sessionId, time}`）；「转发「需要你」」「转发「回复完成」」各自独立开关；**发送测试通知**往所有目标发一条测试消息（不受这两类开关限制，也不会冒充真提醒）。转发跟本地提醒走同一套触发规则（「当前对话不弹通知」等开关同样管它）；提醒正文会原样发往你填的地址，**只填你自己信任的端点**；
 - **页面打开时也提醒「需要你」**（默认开）与 **页面打开时也提醒「回复完成」**（默认关）；
 - **当前对话不弹通知**（默认开）：等待就发生在你正看着的对话里时只留标题标记，不弹通知也不响音（免得盖住审批卡片）；页面切到后台立刻补发，若你已经处理掉就作废。其它后台会话不受影响；
 - **子代理会话不提醒**（默认开）：后台子代理（subagent）子会话的「需要你」与「回复完成」都不提醒——它们是主对话那一轮的步骤，完成由主对话自己的提醒覆盖；你当前打开的那个子代理会话照常提醒；关掉后恢复逐会话提醒；
@@ -71,6 +72,7 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 - **系统通知**：经浏览器弹出的系统通知，进 Windows 通知中心或 macOS 通知中心（点击回到提醒所属的对话；审批的通知点按钮直接裁决）
 - **提示音**：默认是 WebAudio 合成音（「需要你」与「完成」使用不同音型）；可在设置里为两类提醒分别换成自定义音频文件，或改成让操作系统播放它自己的通知音
 - **标签页标题标记**：有待处理事项时，标题前出现 `🔔 需要你 · …` / `🔔 Action needed · …`；后台会话**完成但还没看**时出现 `✅ 回复完成 · …` / `✅ Reply finished · …`，打开对应会话（或它再次开跑）即消失。两种标记可同时出现，「需要你」在前；宿主改写标题后标记基于新标题重建
+- **外部通知**（可选，默认关）：按设置里配的推送目标，把同一条提醒转发到 Discord Webhook / Bark / Gotify / 自定义 Webhook——临时离开电脑时，手机上的推送渠道照样收到
 
 本插件是**浏览器层**实现：DSH 页面需保持打开（最小化/后台即可——那正是它监听的「离开」状态）。
 
@@ -125,10 +127,15 @@ window.__dshNotifyMe.setConfig({
   soundAttention: "synth",    // 「需要你」音效来源，取值同上
   volume: 0.5,                // 音量 0~1
   autoFocus: true,            // 点通知回到提醒所属的对话
-  quickActions: true          // 审批通知上的「同意 / 拒绝」按钮
+  quickActions: true,         // 审批通知上的「同意 / 拒绝」按钮
+  externalEnabled: false,     // 外部通知转发主开关（默认关：不填端点就什么都不发）
+  externalAttention: true,    // 转发「需要你」（触发规则跟本地提醒完全一致）
+  externalDone: true,         // 转发「回复完成」
+  externalTargets: []         // 推送目标：[{id, type:'discord'|'bark'|'gotify'|'custom', url}]
 })
 window.__dshNotifyMe.resetConfig()                // 恢复默认（同时清掉已选的自定义音效文件）
 window.__dshNotifyMe.decide("approval:3", "allowed-once")  // 程序化裁决："allowed-once" | "rejected"
+window.__dshNotifyMe.testExternal()               // 向所有推送目标发一条测试通知，返回 {sent, unverified, failed, statuses}
 ```
 
 > 自定义音效文件不在 `dshNotifyMe.config` 里，而是按类别各存一个键（`dshNotifyMe.sound.done` / `dshNotifyMe.sound.attention`，内容是 `{name, size, data}` 的 data URL）——一个文件转成 data URL 会膨胀约 1.37 倍，塞进配置会拖慢每次读取。`resetConfig()` 会连这两个键一起清掉。
@@ -170,6 +177,7 @@ DSH Desktop 是一层 Electron 壳，页面跑在 `dsh-app://app` 下：DOM 的
 - `≥ 0.1.6`（含 `0.2.0-rc.2`）的「回复完成」提醒正文只有会话名，不再附带回复摘要——宿主快照已不再提供 `nodes`；提醒本身照常触发。
 - 标题标记由宿主与插件共同写 `document.title`：宿主重算标题时标记可能被覆盖，直到下一次提醒事件重新写成。
 - 「当前对话不弹通知」按 `document.hidden` 判定：窗口被别的应用完全盖住时仍算「页面可见」，此时当前对话的等待照样静默。
+- 外部通知转发受浏览器跨域（CORS）限制：端点不放行时自动降级为「送出但不可确认」（no-cors），如实标为「已送出不可确认」；Discord Webhook 官方放行跨域，可直接确认送达。HTTP 错误如实记失败、不重试。转发在本地提醒决定要发之后才触发，所以被「当前对话不弹通知」等规则静音的提醒也不会外发。
 
 ## 开发自检
 
@@ -191,6 +199,8 @@ npm pack --dry-run               # 预览发布包
 - [@d0ublecl1ck](https://github.com/d0ublecl1ck) — [#8](https://github.com/chromoany/dsh-notify-me/pull/8)：子代理会话静音（`ignoreSubagent`）与配套测试、文档；1.4.0 里「只静音后台子代理、当前打开的照常提醒」的口径同样出自他在 #8 讨论里的建议，落地由维护者完成；
 - [@EliteOtaku](https://github.com/EliteOtaku) — [#9](https://github.com/chromoany/dsh-notify-me/issues/9)：桌面端抬窗链路（1.5.2）的逐层排查与真实壳三轮复测——确认点通知抬窗 + 切会话稳定生效，并定位出「无用户手势的脚本化注入被 Chromium 静默丢弃」这一复现差异，纠正了最初「沙箱拦死」的判断；
 - [@Wh1stle05](https://github.com/Wh1stle05) — [#10](https://github.com/chromoany/dsh-notify-me/pull/10)：「音效来源」功能（内置合成音 / 自定义音频文件 / 系统通知音，「需要你」与「回复完成」各自独立选），含设置页交互、回落链与测试、文档；「系统通知音」试听改发测试通知、假 React 按索引跨渲染保持 hook 状态这两处修正同样出自该 PR。
+- [@yanzhaohui1999](https://github.com/yanzhaohui1999) — [#13](https://github.com/chromoany/dsh-notify-me/issues/13) / [#14](https://github.com/chromoany/dsh-notify-me/pull/14)：482 个会话下空闲页面烧 CPU 的性能报告（定位到 `currentSessionId()` 每行重扫全表，实测占 CPU 5.9%~6.5%）与修复（一次列表变化只推导一次「当前会话」），并带先红后绿的回归断言——4 行与 40 行的列表变化代价必须相等（上游报 7 vs 43，修后 5 vs 5）。
+- [@RiZhiZhaoYi](https://github.com/RiZhiZhaoYi) — [#12](https://github.com/chromoany/dsh-notify-me/issues/12)：外部通知转发（Discord Webhook / Bark / Gotify / 自定义 Webhook）的功能建议与使用场景（1.7.0）。
 
 署名口径：本仓库收编外部 PR 时以维护者提交落地——不沿用原 commit、不挂 Co-authored-by，GitHub 的 contributors 图只显示维护者，贡献者以上面的致谢署名。
 

package/lib/client.js

@@ -255,7 +255,16 @@
       // 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
+      quickActions: true,
+      // External forwarding: mirror every alert the plugin actually delivers to
+      // webhook endpoints (Discord / Bark / Gotify / custom), so a phone or
+      // another box can tell the user to come back. Off by default — nothing
+      // leaves the browser until the user fills in an endpoint of their own.
+      externalEnabled: false,
+      externalAttention: true, // forward the "needs you" alerts
+      externalDone: true, // forward the "reply finished" alerts
+      // [{ id: string, type: 'discord' | 'bark' | 'gotify' | 'custom', url: string }]
+      externalTargets: []
     };
     function readConfig() {
       var cfg = {};
@@ -336,7 +345,9 @@
         testDone: "测试提醒 · 回复完成示例",
         testApproval: "这是一条测试审批：点通知上的「同意 / 拒绝」按钮试试快捷裁决",
         testApproved: "测试提醒 · 已模拟「同意」（仅测试，未改动任何会话）",
-        testRejected: "测试提醒 · 已模拟「拒绝」（仅测试，未改动任何会话）"
+        testRejected: "测试提醒 · 已模拟「拒绝」（仅测试，未改动任何会话）",
+        testExternalTitle: "外部通知测试",
+        testExternalBody: "这是一条测试消息：外部通知通道工作正常"
       },
       en: {
         kind: { approval: "Approval request", "plan-review": "Plan review", question: "Question" },
@@ -360,7 +371,9 @@
         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)"
+        testRejected: "Test alert · simulated \"Reject\" (test only, nothing changed)",
+        testExternalTitle: "External notification test",
+        testExternalBody: "Test message: the external notification channel works"
       }
     };
     // Locale service handle (registered on the client context by dsh-client-locale).
@@ -809,6 +822,136 @@
     window.addEventListener("pointerdown", onFirstGesture, true);
     window.addEventListener("keydown", onFirstGesture, true);
 
+    // ───────────────────── external webhook forwarding ─────────────────────
+    // Every alert fire() actually delivers is mirrored to the user's webhook
+    // targets (Discord / Bark / Gotify / custom), so being away from the
+    // machine does not mean missing the "come back" cue. Off by default:
+    // nothing leaves the browser until the user fills in an endpoint.
+    //
+    // CORS reality: a page can only read a response the endpoint allows it to
+    // read. Discord webhooks answer with Access-Control-Allow-Origin: * and
+    // work directly; a self-hosted endpoint may not. So each send tries a
+    // plain CORS POST first and, only when the browser itself refuses the
+    // exchange (a rejection from fetch — not an HTTP error status, which means
+    // the server did see the request), retries as a no-cors POST with a
+    // text/plain content type: the request is still delivered, only the reply
+    // is unreadable ("unverified"). Bark gets a third chance in the classic
+    // GET shape `url/<title>/<body>`, which needs no CORS at all. Real HTTP
+    // errors are reported as failures and never retried blindly.
+    var externalStat = { sent: 0, unverified: 0, failed: 0, lastAt: null, lastStatus: null };
+    // Valid, enabled targets only. A stale entry (bad URL, unknown type) is
+    // skipped rather than breaking the others; the settings page only ever
+    // writes well-formed entries.
+    function externalTargets() {
+      var out = [];
+      var list = config.externalTargets;
+      if (!Array.isArray(list)) return out;
+      for (var i = 0; i < list.length; i++) {
+        var t = list[i];
+        if (!t || typeof t !== "object" || t.enabled === false) continue;
+        var url = typeof t.url === "string" ? t.url.trim() : "";
+        if (!/^https?:\/\//i.test(url)) continue;
+        var type = t.type;
+        if (type !== "discord" && type !== "bark" && type !== "gotify") type = "custom";
+        out.push({ id: typeof t.id === "string" ? t.id : "", type: type, url: url });
+      }
+      return out;
+    }
+    // Per-endpoint JSON body, each shaped by that service's own convention;
+    // the custom type gets the full generic event so any JSON endpoint works.
+    function externalBody(type, ev) {
+      if (type === "discord") {
+        var content = ev.title + "\n" + ev.body;
+        if (content.length > 1900) content = content.slice(0, 1900) + "…";
+        return JSON.stringify({ username: "DSH", content: content });
+      }
+      if (type === "bark") {
+        return JSON.stringify({ title: ev.title, body: ev.body, group: "dsh-notify-me" });
+      }
+      if (type === "gotify") {
+        return JSON.stringify({ title: ev.title, message: ev.body, priority: ev.kind === "attention" ? 8 : 5 });
+      }
+      return JSON.stringify({
+        source: "dsh-notify-me",
+        version: api.version,
+        event: ev.kind,
+        title: ev.title,
+        body: ev.body,
+        sessionId: ev.sessionId || null,
+        time: ev.time
+      });
+    }
+    // Resolves to 'sent' | 'unverified' | 'failed (…)'; never rejects.
+    function postOnce(url, bodyStr, plain) {
+      return fetch(url, {
+        method: "POST",
+        mode: plain ? "no-cors" : "cors",
+        cache: "no-store",
+        headers: { "Content-Type": plain ? "text/plain;charset=UTF-8" : "application/json" },
+        body: bodyStr
+      }).then(function (res) {
+        if (plain) return "unverified"; // opaque: delivered, reply unreadable
+        if (res && res.ok) return "sent";
+        return "failed (HTTP " + (res ? res.status : "?") + ")";
+      });
+    }
+    // Bark's path form: url/<title>/<body>. A plain GET first (readable), then
+    // a no-cors GET — which the browser always hands back, so treat it as
+    // unverified rather than guaranteed.
+    function barkGet(url, ev) {
+      var u = url.replace(/\/+$/, "") + "/" + encodeURIComponent(ev.title || "DSH") + "/" + encodeURIComponent(ev.body || "");
+      return fetch(u, { method: "GET", cache: "no-store" }).then(function (res) {
+        return res && res.ok ? "sent" : Promise.reject(new Error("HTTP " + (res ? res.status : "?")));
+      }).catch(function () {
+        return fetch(u, { method: "GET", mode: "no-cors", cache: "no-store" }).then(function () { return "unverified"; });
+      });
+    }
+    function postExternal(target, ev) {
+      if (typeof fetch !== "function") return Promise.resolve("failed (no fetch)");
+      var bodyStr = externalBody(target.type, ev);
+      return postOnce(target.url, bodyStr, false).catch(function (err) {
+        var msg = "failed (" + (err && err.message ? err.message : String(err)) + ")";
+        return postOnce(target.url, bodyStr, true).then(null, function () {
+          if (target.type !== "bark") return msg;
+          return barkGet(target.url, ev).then(null, function () { return msg; });
+        });
+      }).then(function (status) {
+        if (status === "sent") externalStat.sent++;
+        else if (status === "unverified") externalStat.unverified++;
+        else externalStat.failed++;
+        externalStat.lastAt = new Date().toISOString();
+        externalStat.lastStatus = status;
+        return status;
+      });
+    }
+    // Mirror one delivered alert to every enabled target. The alert path is
+    // fire-and-forget — the toast must never wait on the network; `onDone`
+    // exists for the settings test button, which wants the verdict.
+    // The per-kind toggles gate real alerts only; the test button posts
+    // regardless (that is the point of a channel test).
+    function dispatchExternal(kind, title, body, sessionId, onDone) {
+      if (!config.externalEnabled) return;
+      if (kind === "attention" && !config.externalAttention) return;
+      if (kind === "done" && !config.externalDone) return;
+      sendExternalToAll(kind, title, body, sessionId, onDone);
+    }
+    function sendExternalToAll(kind, title, body, sessionId, onDone) {
+      var targets = externalTargets();
+      if (!targets.length) { if (typeof onDone === "function") onDone([]); return; }
+      var ev = {
+        kind: kind,
+        title: title,
+        body: body || "",
+        sessionId: sessionId || null,
+        time: new Date().toISOString()
+      };
+      var ps = [];
+      for (var i = 0; i < targets.length; i++) {
+        try { ps.push(postExternal(targets[i], ev)); } catch (e) { ps.push(Promise.resolve("failed (dispatch)")); }
+      }
+      if (typeof onDone === "function") Promise.all(ps).then(onDone, function () {});
+    }
+
     // ────────────────────────── title marker ─────────────────────────
     // The host owns document.title (it tracks the session/workspace name), so
     // the base title is re-read on every apply instead of being frozen once —
@@ -958,6 +1101,10 @@
       if (kind === "attention" && quietedByVisibleSession(isCurrent)) return false;
       if (kind === "done" && config.doneHiddenOnly && !hidden()) return false;
       deliver(kind, title, body, sessionId, quick);
+      // The alert reached the user locally (or would have, had the tab a
+      // voice): mirror the same copy to the outside world. Fire-and-forget —
+      // a slow endpoint must never delay or break the local alert.
+      try { dispatchExternal(kind, title, body, sessionId); } catch (e) {}
       return true;
     }
     // True when this alert must stay silent purely because it is about the
@@ -1033,9 +1180,14 @@
     // current-conversation quiet rule) and is never a mute candidate. Read live
     // rather than cached, so the settings switch and session switches both take
     // effect on the next event without rebinding anything.
-    function isSubagentSession(sid) {
+    function isSubagentSession(sid, currentId) {
       if (!config.ignoreSubagent || !sid) return false;
-      if (currentSessionId() === sid) return false;
+      // Reuse the caller's derivation when it has one. Every row walk already
+      // knows the on-screen session (onListChanged derives it once and then
+      // calls this per row), and deriving it again inside the row rescans the
+      // whole list: O(rows x sessions) on 0.1.6+ hosts, where the list snapshot
+      // has no `current` and the on-screen row has to be found by walking byId.
+      if ((currentId === undefined ? currentSessionId() : currentId) === sid) return false;
       try {
         var st = listStore && listStore.getSnapshot();
         var sum = st && st.byId && st.byId[sid];
@@ -1188,14 +1340,14 @@
       } catch (e) {}
       return "";
     }
-    // Evaluate one row/face observation. row: {id, running, pending:[{key,kind,payload}], completed, label, face:bool}
+    // Evaluate one row/face observation. row: {id, running, pending:[{key,kind,payload}], completed, label, face:bool, currentId?}
     function evaluateRow(row) {
       var prev = prevById[row.id];
       var runningNow = !!row.running;
       var pendingNow = row.pending || [];
       var prevPendingKeys = prev ? prev.pendingKeys : [];
       var wasRunning = prev ? prev.running : false;
-      var muted = isSubagentSession(row.id);
+      var muted = isSubagentSession(row.id, row.currentId);
       var newKeys = [];
       // A muted row still feeds the baseline below, so lifting the mute
       // (turning the switch off, or opening that subagent session) resumes
@@ -1283,6 +1435,7 @@
         completed: false,
         face: true,
         faceSnap: snap,
+        currentId: sessionId,
         label: "current"
       });
     }
@@ -1294,6 +1447,7 @@
         pending: sum.pendingInteraction ? [{ key: "list:" + sid + ":" + sum.pendingInteraction, kind: sum.pendingInteraction, payload: null }] : [],
         completed: !!sum.completed,
         face: false,
+        currentId: currentId,
         label: sum.displayTitle || sum.title || sid
       });
     }
@@ -1467,6 +1621,7 @@
       if (!snap || typeof snap.forEach !== "function") return;
       if (found.source === "sessionStatus") syncDoneFromStatus(snap);
       var seen = Object.create(null);
+      var cur = currentSessionId();
       snap.forEach(function (value, sid) {
         var it = pendingOf(value, found.source);
         // A session with no pending interaction is not "seen": leaving it out
@@ -1478,7 +1633,7 @@
         // announced before the mute was switched on (or before the user
         // switched away from that subagent session). Opening the session later
         // announces the outstanding wait then, like any first sighting.
-        if (isSubagentSession(sid)) return;
+        if (isSubagentSession(sid, cur)) return;
         seen[sid] = true;
         var key = it.key || (it.kind + ":" + sid);
         var prev = uiBaseline[sid];
@@ -1520,6 +1675,7 @@
     function syncDoneFromStatus(snap) {
       var want = Object.create(null);
       try {
+        var cur = currentSessionId();
         snap.forEach(function (value, sid) {
           if (!value) return;
           // A stop that awaits input (plan-review / question end the turn with
@@ -1527,7 +1683,7 @@
           // 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;
+          if (!value.completionUnread || value.pendingInteraction || isSubagentSession(sid, cur) || cur === sid) return;
           want[sid] = true;
           markDoneUnread(sid);
           if (uiDoneBaseline[sid]) return; // this unread instance already reported
@@ -1567,7 +1723,7 @@
       });
     } catch (e) {}
     // keep in sync with package.json "version" on every release
-    api.version = "1.6.0";
+    api.version = "1.7.0";
     api.setConfig = function (patch) { return setConfigLocal(patch); };
     api.resetConfig = function () {
       try {
@@ -1594,6 +1750,26 @@
     api.decide = function (key, outcome) {
       return decidePending(key, outcome === "rejected" ? "rejected" : "allowed-once");
     };
+    // Channel test for the external webhooks: posts a synthetic event to every
+    // configured target. An explicit console call counts as consent, so it runs
+    // regardless of the master / per-kind toggles (those gate real alerts);
+    // it still only ever talks to endpoints the user filled in themselves.
+    api.testExternal = function () {
+      return new Promise(function (resolve) {
+        var targets = externalTargets();
+        if (!targets.length) { resolve({ sent: 0, unverified: 0, failed: 0, statuses: [] }); return; }
+        var d = texts();
+        sendExternalToAll("attention", d.testExternalTitle, d.testExternalBody, currentSessionId(), function (statuses) {
+          var out = { sent: 0, unverified: 0, failed: 0, statuses: statuses };
+          for (var i = 0; i < statuses.length; i++) {
+            if (statuses[i] === "sent") out.sent++;
+            else if (statuses[i] === "unverified") out.unverified++;
+            else out.failed++;
+          }
+          resolve(out);
+        });
+      });
+    };
     // Live diagnostics for the "why did nothing pop" case. The needs-input
     // 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
@@ -1615,6 +1791,20 @@
         customSoundDone: !!readSound("done"),
         customSoundAttention: !!readSound("attention"),
         quickActions: config.quickActions,
+        // external webhook forwarding: counts come from externalStat (tallied
+        // on every send), targets is the raw vs validated count.
+        external: {
+          enabled: config.externalEnabled,
+          forwardAttention: config.externalAttention,
+          forwardDone: config.externalDone,
+          targets: Array.isArray(config.externalTargets) ? config.externalTargets.length : 0,
+          activeTargets: externalTargets().length,
+          sent: externalStat.sent,
+          unverified: externalStat.unverified,
+          failed: externalStat.failed,
+          lastAt: externalStat.lastAt,
+          lastStatus: externalStat.lastStatus
+        },
         // quick-decision bridge: 'active' is the only state in which approval
         // toasts carry working 同意/拒绝 buttons.
         bridge: swState,
@@ -1685,6 +1875,37 @@
       soundPreviewAttention: "试听「需要你」音效",
       soundOffHint: "「提示音」开关是关的：先打开它才能试听（关掉时提醒本身也确实不出声）。",
       soundPreviewSystem: "「系统通知音」是随通知由系统播放的，插件这边没有可播的音；已发一条测试提醒，声音就是它。",
+      external: "外部通知",
+      externalHint: "把提醒同时推送到 Discord Webhook / Bark / Gotify / 自定义 Webhook，人不在电脑前也能收到「回来一下」。与本地提醒同一套触发规则（上面的可见性开关一并生效）。",
+      externalEnable: "转发外部通知",
+      externalEnableHint: "总开关：关闭后不向任何外部端点发送。",
+      externalAttentionLabel: "转发「需要你」",
+      externalAttentionHint: "审批 / 方案待确认 / 提问时一并推送到外部端点。",
+      externalDoneLabel: "转发「回复完成」",
+      externalDoneHint: "回复跑完时一并推送到外部端点。",
+      externalTargetsLabel: "推送目标",
+      externalTargetsHint: "可加多个。Discord 填 Webhook URL；Bark 填 https://api.day.app/<设备密钥>（自建填 http://<服务器>/<密钥>）；Gotify 填 https://<服务器>/message?token=<应用令牌>；自定义填任意收 JSON 的地址（POST：source / event / title / body / sessionId / time）。",
+      externalPrivacy: "提醒标题与正文（含会话名与摘要）会原样发到你填写的地址——只填你自己信任的端点。",
+      externalTypeDiscord: "Discord Webhook",
+      externalTypeBark: "Bark",
+      externalTypeGotify: "Gotify",
+      externalTypeCustom: "自定义 Webhook",
+      externalUrlPlaceholder: "https://…",
+      externalAdd: "添加目标",
+      externalRemove: "删除这个目标",
+      externalTypeField: "推送类型",
+      externalUrlField: "推送地址",
+      externalEmpty: "还没有推送目标，点「添加目标」加一个。",
+      externalTestLabel: "测一测外部通知",
+      externalTestHint: "向上面所有推送目标各发一条测试消息（不受「转发」分类开关限制）。",
+      externalTestBtn: "发送测试通知",
+      externalSending: "发送中…",
+      externalTestDone: "测试通知：",
+      externalCountSent: "成功 ",
+      externalCountUnverified: "已送出不可确认 ",
+      externalCountFailed: "失败 ",
+      externalNoTargets: "先添加至少一个推送目标。",
+      externalOffHint: "先打开「转发外部通知」。",
       attentionVisible: "页面打开时也提醒「需要你」",
       attentionVisibleHint: "默认开启：模型在等你审批 / 确认方案 / 回答问题（含提问弹窗）时，即使页面在最前也会提醒。",
       currentQuiet: "当前对话不弹通知",
@@ -1762,6 +1983,37 @@
       soundPreviewAttention: "Preview the \"needs you\" sound",
       soundOffHint: "The Sound switch is off: turn it on to preview (with it off the alerts themselves stay silent too).",
       soundPreviewSystem: "The system sound plays with a toast, not from the plugin — a test alert was sent instead; that sound is it.",
+      external: "External notifications",
+      externalHint: "Mirror alerts to a Discord webhook / Bark / Gotify / custom webhook so \"come back\" reaches you away from the machine. Same trigger rules as the local alerts (the visibility toggles above apply too).",
+      externalEnable: "Forward to external targets",
+      externalEnableHint: "Master switch: when off, nothing is sent to any external endpoint.",
+      externalAttentionLabel: "Forward \"needs you\"",
+      externalAttentionHint: "Push approval / plan review / question alerts to the external endpoints too.",
+      externalDoneLabel: "Forward \"reply finished\"",
+      externalDoneHint: "Push reply-finished alerts to the external endpoints too.",
+      externalTargetsLabel: "Push targets",
+      externalTargetsHint: "Add as many as you like. Discord: the webhook URL; Bark: https://api.day.app/<device key> (self-hosted: http://<server>/<key>); Gotify: https://<server>/message?token=<app token>; custom: any endpoint accepting JSON (POST: source / event / title / body / sessionId / time).",
+      externalPrivacy: "The alert title and body (including the session name and snippet) are sent as-is to the address you enter — only use endpoints you trust.",
+      externalTypeDiscord: "Discord webhook",
+      externalTypeBark: "Bark",
+      externalTypeGotify: "Gotify",
+      externalTypeCustom: "Custom webhook",
+      externalUrlPlaceholder: "https://…",
+      externalAdd: "Add target",
+      externalRemove: "Remove this target",
+      externalTypeField: "Target type",
+      externalUrlField: "Endpoint URL",
+      externalEmpty: "No push targets yet — press \"Add target\" to create one.",
+      externalTestLabel: "Test the external channel",
+      externalTestHint: "Send one test message to every push target above (the per-kind forward toggles do not apply to this button).",
+      externalTestBtn: "Send test notification",
+      externalSending: "Sending…",
+      externalTestDone: "Test notification: ",
+      externalCountSent: "ok ",
+      externalCountUnverified: "sent-unverified ",
+      externalCountFailed: "failed ",
+      externalNoTargets: "Add at least one push target first.",
+      externalOffHint: "Turn on \"Forward to external targets\" first.",
       attentionVisible: "Also alert \"needs you\" while the page is open",
       attentionVisibleHint: "On by default: alert even in the foreground when the model waits for approval / plan review / a question.",
       currentQuiet: "Stay quiet for the conversation on screen",
@@ -1826,6 +2078,9 @@
       ".dnm-btn[disabled]{opacity:.45;cursor:default}" +
       ".dnm-btnRow{display:flex;align-items:center;gap:10px;flex-wrap:wrap}" +
       ".dnm-file{font-size:12px;font-family:inherit;color:var(--dsw-alias-label-primary,rgba(20,20,20,.9));max-width:200px}" +
+      ".dnm-targetRow{display:flex;align-items:center;gap:8px;padding:10px 14px;min-height:46px;box-sizing:border-box;flex-wrap:wrap}" +
+      ".dnm-targetRow+.dnm-targetRow{border-top:1px solid var(--dsw-alias-border-l2,rgba(128,128,128,.35))}" +
+      ".dnm-input{flex:1;min-width:180px;border:1px solid var(--dsw-alias-border-l2,rgba(128,128,128,.4));background:var(--dsw-alias-bg-layer-1,rgba(255,255,255,.03));color:var(--dsw-alias-label-primary,rgba(20,20,20,.9));border-radius:8px;padding:5px 8px;font-size:12px;font-family:inherit}" +
       ".dnm-hint{font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary,rgba(120,120,120,.9))}" +
       ".dnm-feedback{font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary,rgba(120,120,120,.9));min-height:18px}";
     (function injectStyle() {
@@ -1851,6 +2106,9 @@
           type: "button",
           role: "switch",
           "aria-checked": checked ? "true" : "false",
+          // the knob span carries no text of its own, so the row label has to
+          // name the button (and the test presser can find it)
+          "aria-label": labelText,
           className: "dnm-switch" + (checked ? " on" : ""),
           onClick: function () { onChange(!checked); }
         }, h("span", { className: "dnm-knob" }))
@@ -2015,6 +2273,88 @@
         }
         setFeedback(msg);
       }
+      // External forwarding rows. Target edits always patch with a fresh array
+      // (readConfig may hand out the DEFAULTS entry itself; in-place mutation
+      // would silently corrupt the defaults for the next reset).
+      function externalRows() {
+        var rows = [];
+        var targets = Array.isArray(cfg.externalTargets) ? cfg.externalTargets : [];
+        for (var i = 0; i < targets.length; i++) {
+          (function (i) {
+            var target = targets[i] || {};
+            rows.push(h("div", { className: "dnm-targetRow" }, [
+              h("select", {
+                className: "dnm-select",
+                value: target.type || "custom",
+                "aria-label": t("externalTypeField"),
+                onChange: function (e) { updateTarget(i, { type: e.currentTarget.value }); }
+              }, [
+                h("option", { value: "discord" }, t("externalTypeDiscord")),
+                h("option", { value: "bark" }, t("externalTypeBark")),
+                h("option", { value: "gotify" }, t("externalTypeGotify")),
+                h("option", { value: "custom" }, t("externalTypeCustom"))
+              ]),
+              h("input", {
+                className: "dnm-input",
+                value: target.url || "",
+                placeholder: t("externalUrlPlaceholder"),
+                "aria-label": t("externalUrlField"),
+                onChange: function (e) { updateTarget(i, { url: e.currentTarget.value }); }
+              }),
+              h("button", {
+                type: "button",
+                className: "dnm-btn",
+                "aria-label": t("externalRemove"),
+                onClick: function () { removeTarget(i); }
+              }, t("externalRemove"))
+            ]));
+          })(i);
+        }
+        return rows;
+      }
+      function updateTarget(i, patchFields) {
+        var list = (Array.isArray(cfg.externalTargets) ? cfg.externalTargets : []).slice();
+        var cur = list[i] || {};
+        var next = {};
+        for (var k in cur) if (Object.prototype.hasOwnProperty.call(cur, k)) next[k] = cur[k];
+        for (var p in patchFields) if (Object.prototype.hasOwnProperty.call(patchFields, p)) next[p] = patchFields[p];
+        list[i] = next;
+        patch({ externalTargets: list });
+      }
+      function removeTarget(i) {
+        var list = (Array.isArray(cfg.externalTargets) ? cfg.externalTargets : []).slice();
+        list.splice(i, 1);
+        patch({ externalTargets: list });
+      }
+      function addTarget() {
+        var list = (Array.isArray(cfg.externalTargets) ? cfg.externalTargets : []).slice();
+        list.push({
+          id: "ext" + Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+          type: "discord",
+          url: ""
+        });
+        patch({ externalTargets: list });
+      }
+      // Explicit channel test: posts a synthetic event to every target even
+      // when the per-kind forward toggles are off (they gate real alerts, not
+      // this button). The button stays pressable whenever the plugin is on, so
+      // the "why did nothing arrive" cases get a hint instead of a dead control.
+      function runExternalTest() {
+        if (!cfg.enabled) { setFeedback(t("offHint")); return; }
+        if (!cfg.externalEnabled) { setFeedback(t("externalOffHint")); return; }
+        if (!externalTargets().length) { setFeedback(t("externalNoTargets")); return; }
+        setFeedback(t("externalSending"));
+        var d = texts();
+        sendExternalToAll("attention", d.testExternalTitle, d.testExternalBody, currentSessionId(), function (statuses) {
+          var s = 0, u = 0, f = 0;
+          for (var i = 0; i < statuses.length; i++) {
+            if (statuses[i] === "sent") s++;
+            else if (statuses[i] === "unverified") u++;
+            else f++;
+          }
+          setFeedback(t("externalTestDone") + t("externalCountSent") + s + " · " + t("externalCountUnverified") + u + " · " + t("externalCountFailed") + f);
+        });
+      }
       var permOK = ("Notification" in window) ? Notification.permission === "granted" : false;
       var resolvedLang = effectiveLang();
       var resolvedLangName = resolvedLang === "en" ? t("langEn") : t("langZh");
@@ -2091,6 +2431,56 @@
           soundRows("done", t("soundDoneLabel")),
           soundRows("attention", t("soundAttentionLabel"))
         )),
+        // External forwarding: the same alerts, mirrored to the user's own
+        // webhook endpoints so "come back" reaches them away from the machine.
+        card([].concat(
+          [h("div", { className: "dnm-row" }, [
+            h("div", { className: "dnm-rowText" }, [
+              h("div", { className: "dnm-rowLabel" }, t("external")),
+              h("div", { className: "dnm-rowHint" }, t("externalHint"))
+            ])
+          ]),
+          rowSwitch("externalEnabled", t("externalEnable"), t("externalEnableHint"), cfg.externalEnabled, function (v) { patch({ externalEnabled: v }); }),
+          rowSwitch("externalAttention", t("externalAttentionLabel"), t("externalAttentionHint"), cfg.externalAttention, function (v) { patch({ externalAttention: v }); }),
+          rowSwitch("externalDone", t("externalDoneLabel"), t("externalDoneHint"), cfg.externalDone, function (v) { patch({ externalDone: v }); }),
+          h("div", { className: "dnm-row" }, [
+            h("div", { className: "dnm-rowText" }, [
+              h("div", { className: "dnm-rowLabel" }, t("externalTargetsLabel")),
+              h("div", { className: "dnm-rowHint" }, t("externalTargetsHint"))
+            ])
+          ])],
+          externalRows(),
+          [(Array.isArray(cfg.externalTargets) && cfg.externalTargets.length) ? h("div", { className: "dnm-row" }, [
+            h("div", { className: "dnm-rowText" }, [h("div", { className: "dnm-hint" }, t("externalPrivacy"))])
+          ]) : h("div", { className: "dnm-row" }, [
+            h("div", { className: "dnm-rowText" }, [h("div", { className: "dnm-hint" }, t("externalEmpty"))])
+          ]),
+          h("div", { className: "dnm-row" }, [
+            h("div", { className: "dnm-btnRow" }, [
+              h("button", {
+                type: "button",
+                className: "dnm-btn",
+                "aria-label": t("externalAdd"),
+                onClick: addTarget
+              }, t("externalAdd"))
+            ])
+          ]),
+          h("div", { className: "dnm-row" }, [
+            h("div", { className: "dnm-rowText" }, [
+              h("div", { className: "dnm-rowLabel" }, t("externalTestLabel")),
+              h("div", { className: "dnm-rowHint" }, t("externalTestHint"))
+            ]),
+            h("div", { className: "dnm-btnRow" }, [
+              h("button", {
+                type: "button",
+                className: "dnm-btn",
+                "aria-label": t("externalTestLabel"),
+                disabled: !cfg.enabled,
+                onClick: runExternalTest
+              }, t("externalTestBtn"))
+            ])
+          ])
+        ])),
         card([
           h("div", { className: "dnm-row" }, [
             h("div", { className: "dnm-rowText" }, [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-notify-me",
-  "version": "1.6.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.",
+  "version": "1.7.0",
+  "description": "DSH 桌面消息提醒插件：模型需要你操作（审批/方案确认/提问的可操作提醒）或回复在后台完成时，系统通知+提示音+标签页标题提醒你；权限审批的通知上可直接点「同意/拒绝」完成裁决；可把提醒转发到 Discord Webhook / Bark / Gotify / 自定义 Webhook 等外部通知；可在设置页开关并切换通知语言。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, forwarding to external webhooks (Discord / Bark / Gotify / custom); toggleable from Settings with zh/en notification language.",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",
@@ -36,6 +36,12 @@
     "approval-alert",
     "approval-actions",
     "background-alert",
+    "external-notification",
+    "webhook",
+    "discord",
+    "bark",
+    "gotify",
+    "push-notification",
     "桌面通知",
     "消息提醒",
     "可操作提醒",
@@ -44,6 +50,8 @@
     "需要你操作",
     "回复完成提醒",
     "后台完成提醒",
+    "外部通知",
+    "推送提醒",
     "提醒"
   ],
   "engines": {