dsh-notify-me 1.11.0 → 1.12.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to **dsh-notify-me** are documented here.
 
+## [1.12.0] — 2026-10-21
+
+### 新增
+
+- **人走开但窗口没走也算离开**（来自 [#16](https://github.com/chromoany/dsh-notify-me/pull/16)，[@shrekcg](https://github.com/shrekcg)）：`idleMinutes`（默认 3 分钟，`0` 关掉）内没有任何键鼠输入，就把「窗口在前台」按离开处理——「需要你」照常提醒、「回复完成」按离开规则提醒、`autoDismiss: "present"` 也不再撤掉那条通知。此前只认窗口失焦 / 页面隐藏，人坐在桌前离开座位时一切都还是「你在看」。
+- **闲置到期会补发被压下的审批**（维护者补的）：`currentHiddenOnly` 把当前对话的等待只留标题标记时，原先只有失焦 / 页面隐藏事件才会补发；现在闲置定时器到期即补发，人离开但窗口没动也能收到。一次性触发，队列清空后不重复。
+- **「回复完成」提醒时机三选一**（#16）：`donePolicy` —— `"background"`（默认，旧行为）/ `"smart"`（屏幕上那条静默，别的对话完成照常提醒）/ `"always"`（从不静默），设置页「什么时候提醒」里换成下拉。
+- **通知自动消失三选一**（#16）：`autoDismiss` —— `"present"`（默认，只有你在页面时才计时关闭，离开时收到的留在通知中心）/ `"always"`（旧行为）/ `"never"`（普通通知等你点掉）。带「同意 / 拒绝」的审批通知仍按 12 秒走。
+
+### 移除
+
+- **页内审批卡片整条删掉**：1.11.0 删掉「浮层通道」后，桌面端还留着一张兜底卡片（`dsh-app://` 注册不了 Service Worker，审批按钮画在窗口角落）。结果是审批提醒**同时**弹系统通知和页内卡片——与「只留通知」的目标冲突，而且卡片只在窗口前台时看得见，需要提醒的时刻恰恰不在。现在 `drawOverlayCard` / `showFallbackApprovalCard` / `.dnm-ov-*` 样式 / 「审批卡片位置」设置子行 / `overlayCorner` 配置键 / `debug().card` 全部删除。桌面端的审批提醒就是普通系统通知，点通知回到对话里裁决。
+- 老配置里的 `overlayCorner` 在下次读配置时删掉，其余设置不受影响。
+- `window.__dshNotifyMe.debug()` 去掉 `card`；`doneHiddenOnly` 换成 `donePolicy` / `idleMinutes` / `autoDismiss` / `away`（`doneHiddenOnly` 作为读写别名保留，旧脚本仍能写）。
+
+### 迁移
+
+- 旧配置 `doneHiddenOnly: false` → `donePolicy: "always"`，其余 → `"background"`；写回时两者仍互相同步。
+- `idleMinutes` 默认 3；写 `0` 退回只看窗口失焦 / 页面隐藏。
+
+### 测试
+
+- 冒烟删掉 `cardLayer` / `desktopFallbackCard`，新增 `awayWhileFocusedAndIdle`、`idleFlushesQuieted`、`donePolicyScopes`、`autoDismissPolicy`；设置页用例改为断言「审批卡片位置」子行与旧通道选项都已消失、三档下拉落盘正确、旧配置仍能加载。
+
+### 文档
+
+- README 中英：设置清单换成三档下拉、补闲置判定与通知自收、删「副屏与审批卡片」整节、控制台示例同步、致谢加上 [@shrekcg](https://github.com/shrekcg) 与 #16。
+
 ## [1.11.0] — 2026-10-21
 
 ### 移除

package/README.en.md

@@ -24,11 +24,11 @@
 A notification plugin for DSH Web / Desktop, so you can keep full access off without watching the page all day.
 
 - **When input is needed:** approval, plan review, and questions trigger notifications, sound, and a title marker.
-- **When a background reply finishes:** return to the result; click the notification to open its conversation.
+- **When a background reply finishes:** return to the result; click the notification to open its conversation. Pick "background only", "quiet for the open one", or "always".
+- **When you walk off but the window stays in front:** over 3 minutes without input counts as away, and the alert still fires; a toast you have not seen is not closed on a timer before you return.
 - **When you leave your computer:** optionally forward alerts to Discord, Bark, Gotify, or your own webhook.
-- **When you do not watch the primary display:** system notifications only ever appear on the primary display; the Desktop approval card is drawn in the page and follows the DSH window onto whichever screen it is on (see [Secondary displays and the approval card](#secondary-displays-and-the-approval-card)).
 
-> Keep the page or desktop app running; backgrounding / minimizing is fine. System notifications require permission. Approval buttons need a Service Worker: Web (`http://127.0.0.1` or `https`) has one, the Desktop `dsh-app://` pages cannot register one, so their notifications carry no buttons and approvals are decided on a card in the window corner instead.
+> Keep the page or desktop app running; backgrounding / minimizing is fine. System notifications require permission. Approval buttons need a Service Worker: Web (`http://127.0.0.1` or `https`) has one, the Desktop `dsh-app://` pages cannot register one, so their notifications carry no buttons — click the notification to decide in the conversation.
 
 > 🔎 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).
 
@@ -43,7 +43,7 @@ A notification plugin for DSH Web / Desktop, so you can keep full access off wit
 
 ![The Notify me settings page: header, how you get told, when to alert, try it, and the collapsed Advanced block](https://raw.githubusercontent.com/chromoany/dsh-notify-me/main/docs/screenshots/settings-en.png)
 
-Just the plugin panel (the real component, captured before 1.11.0) without the DSH navigation sidebar. Row explanations live in a hover tooltip that appears when the pointer rests on a title, which is why only the titles show here. 1.11.0 removed the "alert type" row at the top; the rest is unchanged.
+Just the plugin panel (the real component, on the same dark theme as the host) without the DSH navigation sidebar. Row explanations live in a hover tooltip that appears when the pointer rests on a title, which is why only the titles show here.
 </details>
 
 ## Installation
@@ -73,14 +73,14 @@ The Electron application manages the `desktop` profile. Do not change the Web co
 2. Open **Settings → Notify me**. Confirm that the section and plugin version at its foot appear, and leave the master switch and sound enabled.
 3. Click **Test "reply finished"** on the settings page. A test notification should appear and sound according to your cue settings. This local test does not forward to external endpoints and ignores the "while the window is in front" toggle.
 
-Web users can also test approval buttons. On Desktop the shell cannot register a Service Worker, so this test draws an in-page card with Approve / Reject in the window corner (since 1.10.4; earlier versions sent a plain notification).
+Web users can also test approval buttons. On Desktop the shell cannot register a Service Worker, so this test sends a plain notification without buttons — click it to open the conversation.
 
 **Optional console check** — in environments with DevTools, you can also run:
 
 ```js
 window.__dshNotifyMe.test("done")        // "reply finished" sample
 window.__dshNotifyMe.test("attention")   // "needs your input" sample
-window.__dshNotifyMe.test("approval")    // Approve / Reject with an active Web bridge; an in-page card on Desktop
+window.__dshNotifyMe.test("approval")    // Approve / Reject with an active Web bridge; a plain notification on Desktop
 window.__dshNotifyMe.debug()             // the bridge field reports the button channel: "active" = buttons work
 ```
 
@@ -102,11 +102,11 @@ dsh-notify-me decouples **supervision** from **sitting in front of the screen**:
 | Event | Default behavior |
 | --- | --- |
 | 🔔 Input needed | Alerts even in the foreground; the conversation on screen keeps only a title marker |
-| ✅ Reply finished | Alerts while the page is hidden / backgrounded |
+| ✅ Reply finished | Alerts while the page is hidden / backgrounded (or "quiet for the open one" / "always") |
 
-**Input needed** covers approval requests, plan review, and questions (`ask_user_question`). Approvals carry Approve / Reject: on Web as a system notification with buttons, on Desktop (which cannot register a Service Worker) as a card drawn in the window corner.
+**Input needed** covers approval requests, plan review, and questions (`ask_user_question`). The Approve / Reject buttons only exist on Web (they need a Service Worker); the Desktop cannot register one, so its notifications carry no buttons — click the notification to decide in the conversation.
 
-**Reply finished** also covers background sessions. A finished but unread session keeps the `✅ Reply finished ·` title marker until opened. Title markers are independent of the "while the window is in front" toggles.
+**Reply finished** also covers background sessions. A finished but unread session keeps the `✅ Reply finished ·` title marker until opened. Title markers are independent of the alert policy.
 
 > **Background** subagent child sessions are **not** alerted about by default: DSH lists each of them as its own session, but they are steps inside the parent conversation's turn, so an alert for them is only noise. The subagent session you have open is not part of this and alerts as usual. Settings → "Ignore subagent sessions" turns the mute off.
 
@@ -118,26 +118,14 @@ Open **Settings → Notify me**. The page runs as how you get told, when to aler
 
 - **Enable reminders**: master switch — off means no toasts, no sounds, and the tab title is left alone;
 - **Sound / Volume**: the switch is direct; the slider folds into that row — click the title (▸ turns into ▾) to reveal it. What it plays comes from Advanced → Alert sound;
-- **Decide approvals from the toast** (on by default): approvals carry Approve / Reject that settle the request in place. On Web that is a system notification with buttons; on Desktop `dsh-app://` cannot register a Service Worker, so the buttons are drawn on a card in the window corner (auto-dismissed after 12 s, one card per approval). Its corner comes from the Corner sub-row underneath — see [Secondary displays and the approval card](#secondary-displays-and-the-approval-card).
-
-### Secondary displays and the approval card
-
-Windows draws system notification banners on the primary display only. There is no setting in Windows and no API in the browser to aim one at another monitor, so with DSH parked on a second screen and the primary display unwatched, a toast is as good as not sent. That part is out of reach — the only thing that can show up on the other screen comes from inside the page.
-
-One thing does: the Desktop approval card. It is drawn in the DSH page, so it appears on whichever display the window sits on, and it carries Approve / Reject (Desktop toasts have no buttons).
-
-- **Position** — the Corner sub-row under "Decide approvals from the toast" shows the current value (bottom right by default); click it open (▸ turns into ▾), then pick top right / bottom right / top left / bottom left. Changes apply immediately;
-- **Approvals only** — plain "needs you" and "reply finished" alerts never draw a card; they are system notifications only;
-- **Lifetime** — an approval card retires after 12 s; clicking the card body opens its conversation. At most 4 cards stack at once;
-- **No notification permission needed** — this path touches no Service Worker and needs no permission.
-
-> 1.11.0 removed the "alert type" choice. The in-page overlay used to work as a standalone channel, but it is only visible while the DSH window is in front — and the moment an alert matters is exactly when the window is in the background. With the overlay chosen, backgrounding left only the sound and the tab marker, which is no alert at all.
+- **Decide approvals from the toast** (on by default): approvals carry Approve / Reject that settle the request in place. On Web that is a system notification with buttons; on Desktop `dsh-app://` cannot register a Service Worker, so the notification carries no buttons — click it to decide in the conversation. The line underneath states whether buttons are possible here.
 
 ### When to alert
 
-- **Also alert "needs you" while the window is in front** (on): turn it off to hear only once the window goes to the background — another app focused, the window covered, or minimized all count;
-- **Stay quiet for the conversation on screen** (on): a wait belonging to the conversation you are looking at keeps only the tab marker so the approval card stays readable; moving the window to the background restores alerts;
-- **Also alert "reply finished" while the window is in front** (off): by default only background finishes alert (a covered Desktop window counts as background since 1.10.5, not only a minimized one);
+- **Also alert "needs you" while the window is in front** (on): turn it off to hear only once the window goes to the background — another app focused, the window covered, or minimized all count. A window left in front while nobody touches it (3 minutes without input by default) also counts as background; `idleMinutes: 0` restores the window-only rule;
+- **Stay quiet for the conversation on screen** (on): a wait belonging to the conversation you are looking at keeps only the tab marker, so it does not interrupt what you are doing; moving the window to the background or going idle restores alerts;
+- **When "reply finished" alerts** (default "background only"): three choices. "Background only" is the old rule — alert when you are not watching the page; "quiet for the open one" stays silent only for the conversation on screen while any other conversation still alerts (useful with several open); "always" never suppresses. An old profile's "also alert reply finished while in front" switch migrates to this setting;
+- **Dismiss the toast automatically** (default "keep while away"): three choices. "Keep while away" only closes a toast a few seconds later while you are at the page, so one that arrived while you were away is still in the notification centre when you come back; "always close" is the old tidy-up; "never close" leaves plain toasts up until you dismiss one. Approvals keep their 12 s rule and are likewise not withdrawn while you are away;
 - **Ignore subagent sessions** (on): skip background sessions spawned by a subagent — the parent conversation covers them; the one you have open still alerts;
 - **Click a toast to open that conversation** (on): the click switches to the conversation that raised it; in a browser it also brings the window forward, while on the Desktop shell it is flaky — sometimes the window comes forward, sometimes only the conversation switches (see [How the Desktop window gets raised](#how-the-desktop-window-gets-raised)); with several tabs open only one is raised, and off means a click does nothing.
 
@@ -193,7 +181,6 @@ The last block inside Advanced. The page protocol is detected automatically to t
 ## How it alerts
 
 - **System notification** — a toast through the browser into the Windows action center / macOS Notification Center (clicking it opens the conversation it came from; supported Web environments offer approval buttons, Desktop does not)
-- **Desktop approval card** — `dsh-app://` cannot put Approve / Reject on a toast, so approval alerts also drop a clickable card in the window corner; see [Secondary displays and the approval card](#secondary-displays-and-the-approval-card)
 - **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
@@ -225,7 +212,7 @@ Two traps are worth remembering: a package listed in `dsh.client.inject` that a
 
 </details>
 
-`1.9.0` neither widens nor narrows that range: the settings page is plain React rendering over the existing CSS variables (every colour carries a fallback) and adds no host API. The overlay, title markers and window raising still go through the 1.7 / 1.8 paths, so **plugin entries stay compatible from 0.1.1-rc.2 through 0.2.1-rc.2**, and stepping back to an older host needs no config change. The only new surface is visual: the bell in the page header is the plugin's own SVG (`docs/brand/`).
+`1.9.0` neither widens nor narrows that range: the settings page is plain React rendering over the existing CSS variables (every colour carries a fallback) and adds no host API. The alerts, title markers and window raising still go through the 1.7 / 1.8 paths, so **plugin entries stay compatible from 0.1.1-rc.2 through 0.2.1-rc.2**, and stepping back to an older host needs no config change. The only new surface is visual: the bell in the page header is the plugin's own SVG (`docs/brand/`).
 
 ## Advanced: console configuration
 
@@ -240,17 +227,17 @@ window.__dshNotifyMe.setConfig({
   enabled: true,           // false = disable all reminders (master switch)
   language: "auto",        // 'auto' follow the UI | 'zh' | 'en'
   attentionHiddenOnly: false, // true = don't alert "needs you" while the page is visible
-  currentHiddenOnly: true,    // true = waits in the conversation on screen keep only the tab marker (replayed once backgrounded)
-  doneHiddenOnly: true,       // false = also alert "reply finished" while visible
+  currentHiddenOnly: true,    // true = waits in the conversation on screen keep only the tab marker (replayed once away)
+  donePolicy: "background",   // "reply finished" policy: 'background' only when away | 'smart' quiet only for the open one | 'always' always alert
+  idleMinutes: 3,             // minutes without pointer/keyboard input before a focused page counts as away (0 = off)
+  autoDismiss: "present",     // toast self-dismiss: 'present' keep while away | 'always' always close | 'never' never close
   ignoreSubagent: true,       // true = never alert for background subagent sessions (the open one is exempt)
-  quickActions: true,         // Approve / Reject on approval alerts
+  quickActions: true,         // Approve / Reject buttons on approval toasts
   sound: true,                // cue toggle (also governs the "system notification sound" mode)
   soundDone: "synth",         // "reply finished" cue source: 'synth' built-in | 'custom' picked file | 'system' OS sound
   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
-  overlayCorner: "bottom-right", // Desktop approval card anchor: 'top-right' | 'bottom-right' | 'top-left' | 'bottom-left'
   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"
@@ -287,7 +274,7 @@ The reminder core stays dependency-free and self-contained: notification copy re
 
 ### 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. The "raise a window and switch its conversation" part of a body click is scheduled on the worker half too: `client.focus()` raises exactly one window (a visible one first) and routes the conversation switch to that window alone, so several open DSH tabs never fight over focus or all switch at once.
+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 conversation's approval prompt uses — which is why "Approve" is exactly "Allow once" and nothing broader. The "raise a window and switch its conversation" part of a body click is scheduled on the worker half too: `client.focus()` raises exactly one window (a visible one first) and routes the conversation switch to that window alone, so several open DSH tabs never fight over focus or all switch at once.
 
 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 stay 12s (plain ones 5s) and retire on their own, so an approval left undecided there still waits for you in the page.
 
@@ -312,7 +299,7 @@ There is no page-side fallback either: the shell preload only exposes `dshDeskto
 - 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.
 - On the Desktop shell (DSH Desktop 0.2.1-rc.2 / Windows) a toast click does not reliably bring the window forward: sometimes it does, sometimes only the conversation switches. The plugin's `dsh://open` deep link on its own failed 3/3 in isolation (see [How the Desktop window gets raised](#how-the-desktop-window-gets-raised)), so when it does come forward it is most likely the OS/Chromium activating the app on the notification click itself ([discussions #10446](https://github.com/deepseek-ai/deepseek-harness/discussions/10446)).
-- System notification banners are drawn on the primary display only: Windows has no setting and Chromium no API to aim one at another monitor, so on a multi-monitor setup the second screen never receives them. The one thing that does reach another display is the Desktop approval card, drawn in the page and carried by the window; for plain alerts across screens, forward them to your phone with external notifications.
+- System notification banners are drawn on the primary display only: Windows has no setting and Chromium no API to aim one at another monitor, so on a multi-monitor setup the second screen never receives them. Forwarding to your phone with external notifications is the only route across screens (since 1.12.0 the page no longer draws an approval card).
 - 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 Desktop (`dsh-app://`) is tested and cannot register a Service Worker**, so buttons never render there and approval toasts fall back to their buttonless form. The `bridge` field of `window.__dshNotifyMe.debug()` says why; everything else keeps working.
 - macOS: in the browser, alerts, sounds, the title marker and toast-click navigation carry no OS assumptions and work as on Windows. Two caveats: DSH Desktop (Electron) notifications require the app to be code-signed — unsigned builds simply emit no notification — and whether the official macOS build satisfies that is untested; and notification buttons on the macOS desktop host are likewise untested (the Windows desktop host is tested and renders none, see the line above), falling back to the buttonless form above.
 - Config lives in browser `localStorage`: switching browsers/devices or clearing site data returns to defaults (one-click restore in the Settings page).
@@ -328,7 +315,7 @@ There is no page-side fallback either: the shell preload only exposes `dshDeskto
 ```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 + the quick-decision bridge (worker half included)
+node smoke\smoke-test.cjs        # offline state-machine test: three host generations + master switch + zh/en cases + the quick-decision bridge (worker half included) + idle detection and toast self-dismiss
 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
 ```
@@ -345,6 +332,7 @@ Contributors (by handle; the link points at the PR / issue they worked on):
 - [@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).
+- [@shrekcg](https://github.com/shrekcg) — [#16](https://github.com/chromoany/dsh-notify-me/pull/16): counting "in front but walked away" as away (`idleMinutes`, 3 minutes by default), deciding "reply finished" alerts by which conversation finished (`donePolicy`, three choices), the three-way toast self-dismiss policy (`autoDismiss`), with matching smoke cases and old-config migration; when it landed in 1.12.0 the maintainer added the idle-expiry replay for suppressed approvals, removed the leftover in-page approval card, and brought docs and version up to date.
 
 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

@@ -24,11 +24,11 @@
 DSH Web / Desktop 的通知插件，让你敢不开完整访问，也不必一直守着页面。
 
 - **需要你操作时**：审批、方案确认、提问，用通知、提示音和标题标记提醒。
-- **后台回复完成时**：及时回来查看结果，点击通知可回到对应对话。
+- **后台回复完成时**：及时回来查看结果，点击通知可回到对应对话；提醒时机可选「仅后台 / 仅当前对话静默 / 总是提醒」。
+- **人走开但窗口没走**：窗口留在最前台、人却离开座位，超过 3 分钟没有输入也算离开，该提醒的照常提醒；收到的那条通知不会在你回来之前自己消失。
 - **离开电脑时**：可选转发到 Discord、Bark、Gotify 或自己的 Webhook。
-- **不看主屏时**：系统通知只会画在主屏，副屏看不到；桌面端的审批卡片画在页面里，跟着 DSH 窗口走到哪块屏（见[副屏与审批卡片](#副屏与审批卡片)）。
 
-> 页面或桌面应用需保持运行，后台 / 最小化可以。系统通知需要通知权限。审批按钮靠 Service Worker 才能进通知：Web 端（`http://127.0.0.1` 或 `https`）有，桌面端 `dsh-app://` 页面注册不了，通知上没有按钮，审批改在窗口角落的卡片上裁决。
+> 页面或桌面应用需保持运行，后台 / 最小化可以。系统通知需要通知权限。审批按钮靠 Service Worker 才能进通知：Web 端（`http://127.0.0.1` 或 `https`）有，桌面端 `dsh-app://` 页面注册不了，通知上没有按钮，点通知回到对话里裁决。
 
 > 🔎 想找这个插件？可以搜：`dsh-notify-me`、**消息提醒**、**可操作提醒**、**桌面通知**、**需要你操作**、**回复完成提醒**、**后台完成提醒**、**外部通知**、**Discord / Bark / Gotify 推送**（npm 关键词已含以上中英文词）。
 
@@ -43,7 +43,7 @@ DSH Web / Desktop 的通知插件，让你敢不开完整访问，也不必一
 
 ![通知提醒设置页：页眉、提醒方式、什么时候提醒、试一试与折叠的高级设置](https://raw.githubusercontent.com/chromoany/dsh-notify-me/main/docs/screenshots/settings-zh.png)
 
-只截插件自己的面板（真实组件，1.11.0 之前的截图），不带 DSH 左侧导航栏；每行说明在鼠标停在标题文字上时才出现，所以这里只看到标题。1.11.0 删掉了最上面的「通知类型」一行，其余行没变。
+只截插件自己的面板（真实组件，与宿主同款深色主题），不带 DSH 左侧导航栏；每行说明在鼠标停在标题文字上时才出现，所以这里只看到标题。
 </details>
 
 ## 安装
@@ -98,11 +98,11 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 | 事件 | 默认行为 |
 | --- | --- |
 | 🔔 需要你操作 | 页面可见也提醒；当前对话只留标题标记 |
-| ✅ 回复完成 | 页面隐藏 / 后台时提醒 |
+| ✅ 回复完成 | 页面隐藏 / 后台时提醒（可选「仅当前对话静默」或「总是提醒」） |
 
-**需要你操作**包括审批请求、方案待确认（plan review）和提问（`ask_user_question`）。审批带「同意 / 拒绝」：Web 走带按钮的系统通知，桌面端（注册不了 Service Worker）改画在窗口角落的卡片上。
+**需要你操作**包括审批请求、方案待确认（plan review）和提问（`ask_user_question`）。审批带「同意 / 拒绝」的按钮只在 Web 端有（需要 Service Worker）；桌面端注册不了，通知上没有按钮，点通知回到对话里裁决。
 
-**回复完成**也覆盖后台会话；完成但还没看时，标题带 `✅ 回复完成 ·` 标记，打开对应会话即撤。标题标记不受「窗口在前台时也提醒」开关限制。
+**回复完成**也覆盖后台会话；完成但还没看时，标题带 `✅ 回复完成 ·` 标记，打开对应会话即撤。标题标记不受提醒策略限制。
 
 > **后台**子代理（subagent）子会话的等待与完成默认**不提醒**：DSH 把每个子代理子会话列成独立会话，但它们是所属主对话那一轮里的步骤，提醒只会是噪音。你当前打开的那个子代理会话不算在内，照常提醒。设置页「子代理会话不提醒」可关掉这个静音。
 
@@ -114,26 +114,14 @@ dsh-notify-me 把「监督」和「守在屏幕前」解耦：只在真的出现
 
 - **启用提醒** 总开关：关闭后不弹通知、不响提示音，也不改标签页标题；
 - **提示音 / 音量**：开关直接切；音量滑块收在该行里，点一下标题（▸ 变成 ▾）展开。具体播什么由「高级设置 → 音效来源」决定；
-- **审批通知上直接裁决**（默认开）：审批带「同意 / 拒绝」，点一下即完成裁决，不用切回页面。Web 走带按钮的系统通知；桌面端 `dsh-app://` 注册不了 Service Worker，于是把按钮画在窗口角落的卡片上（12 秒自动收起，同一条审批不叠第二张卡）。卡片位置由它下面的子行「审批卡片位置」控制，见[副屏与审批卡片](#副屏与审批卡片)。
-
-### 副屏与审批卡片
-
-Windows 的系统通知横幅固定画在主屏上，系统没有设置项、浏览器也没有 API 能把它挪到别的显示器。主屏不看、DSH 停在副屏时，通知就等于没发。这一条改不掉——真要在副屏看见，只能靠页面里的东西。
-
-页面里还剩一种：桌面端的审批卡片。它画在 DSH 页面里，窗口在哪块屏就出现在哪块屏，卡片上能直接「同意 / 拒绝」（桌面端通知带不了按钮）。
-
-- **位置**：「审批通知上直接裁决」下面的「审批卡片位置」子行，行上直接显示当前值（默认右下）；点它（▸ 变 ▾）再选右上 / 右下 / 左上 / 左下，改完立刻生效；
-- **只给审批**：普通提醒与「回复完成」不画卡片，它们只有系统通知；
-- **停留时间**：审批卡片 12 秒自动收起；点卡片正文切回对应对话。最多同时叠 4 张；
-- **不用通知权限**：这条路径不碰 Service Worker，也不依赖通知权限。
-
-> 1.11.0 删掉了「通知类型」二选一。页面浮层曾经能当独立通道用，但它只在 DSH 窗口处于前台时看得见——需要提醒的时刻恰恰是窗口在后台。选浮层、切走之后后台只剩提示音和标题标记，等于没提醒。
+- **审批通知上直接裁决**（默认开）：审批带「同意 / 拒绝」，点一下即完成裁决，不用切回页面。Web 走带按钮的系统通知；桌面端 `dsh-app://` 注册不了 Service Worker，通知上没有按钮，点通知回到对话里裁决。设置页那行下面会如实说明当前环境能不能给按钮。
 
 ### 什么时候提醒
 
-- **窗口在前台时也提醒「需要你」**（默认开）：窗口在前台也提醒；关掉后只有窗口转到后台才提醒——切到别的应用、被别的窗口遮住、最小化都算后台；
-- **当前对话不弹通知**（默认开）：等待就发生在你正看着的对话里时只留标签页标记，免得挡住审批卡片；窗口转到后台后照常提醒，若你已处理掉就作废；
-- **窗口在前台时也提醒「回复完成」**（默认关）：默认只在窗口转到后台时提醒，避免打扰（桌面端窗口被遮住也算后台，1.10.5 起不再要求最小化）；
+- **窗口在前台时也提醒「需要你」**（默认开）：窗口在前台也提醒；关掉后只有窗口转到后台才提醒——切到别的应用、被别的窗口遮住、最小化都算后台。窗口一直留在前台但人离开座位（默认 3 分钟没有任何键鼠输入）同样算后台；`idleMinutes: 0` 退回只看窗口；
+- **当前对话不弹通知**（默认开）：等待就发生在你正看着的对话里时只留标签页标记，免得打断眼前的操作；人离开（窗口转到后台或闲置超时）后照常提醒，若你已处理掉就作废；
+- **「回复完成」什么时候提醒**（默认「仅后台」）：三选一。「仅后台」＝原来的规则，不在看页面才提醒；「仅当前对话静默」＝屏幕上那条静默，别的对话完成照常提醒，多开对话时有用；「总是提醒」＝从不静默。老配置里的「窗口在前台时也提醒『回复完成』」开关自动迁移到这一项；
+- **通知自动消失**（默认「离开时保留」）：三选一。「离开时保留」＝只有你在看页面时才几秒后关闭，人不在时收到的那条留在通知中心等你回来；「总是关闭」＝旧行为；「从不关闭」＝普通通知一直留着，等你点掉。带「同意 / 拒绝」的审批通知仍按 12 秒走，同样不会在人不在时被撤掉；
 - **子代理会话不提醒**（默认开）：跳过后台子代理（subagent）会话——它们是主对话那一轮的步骤，完成由主对话自己的提醒覆盖；你当前打开的那个子代理会话照常提醒；
 - **点击通知回到对应对话**（默认开）：点通知切到提醒所属的对话；浏览器里同时把窗口带到前台；桌面端不稳定——有时窗口会上前，有时只切对话（见[桌面端怎么抬窗的](#桌面端怎么抬窗的)）；多个标签页同时开着时只调起一个（优先当前可见的那个）；关掉后点通知不做任何事。
 
@@ -189,7 +177,6 @@ Windows 的系统通知横幅固定画在主屏上，系统没有设置项、浏
 ## 提醒渠道
 
 - **系统通知**：经浏览器弹出的系统通知，进 Windows 通知中心或 macOS 通知中心（点击回到提醒所属的对话；支持快捷裁决的 Web 环境可点审批按钮直接裁决，桌面端没有按钮）
-- **桌面端审批卡片**：`dsh-app://` 下系统通知带不了「同意 / 拒绝」，审批类提醒额外在窗口角落画一张可点卡片；见[副屏与审批卡片](#副屏与审批卡片)
 - **提示音**：默认是 WebAudio 合成音（「需要你」与「完成」使用不同音型）；可在设置里为两类提醒分别换成自定义音频文件，或改成让操作系统播放它自己的通知音
 - **标签页标题标记**：有待处理事项时，标题前出现 `🔔 需要你 · …` / `🔔 Action needed · …`；后台会话**完成但还没看**时出现 `✅ 回复完成 · …` / `✅ Reply finished · …`，打开对应会话（或它再次开跑）即消失。两种标记可同时出现，「需要你」在前；宿主改写标题后标记基于新标题重建
 - **外部通知**（可选，默认关）：按设置里配的推送目标，把同一条提醒转发到 Discord Webhook / Bark / Gotify / 自定义 Webhook——临时离开电脑时，手机上的推送渠道照样收到
@@ -221,7 +208,7 @@ Windows 的系统通知横幅固定画在主屏上，系统没有设置项、浏
 
 </details>
 
-`1.9.0` 的界面重排没有放宽也没有收紧这个范围：设置页是纯 React 渲染 + 既有 CSS 变量（每个色值都带 fallback），没有引入任何新的宿主 API；浮层、标题标记、抬窗仍走 1.7 / 1.8 那几条路径。**0.1.1-rc.2 到 0.2.1-rc.2 的插件条目照旧兼容**，换回旧宿主也不需要改配置。新增的只有界面元素——设置页页眉的铃铛是插件自己画的 SVG（`docs/brand/`），与宿主无关。
+`1.9.0` 的界面重排没有放宽也没有收紧这个范围：设置页是纯 React 渲染 + 既有 CSS 变量（每个色值都带 fallback），没有引入任何新的宿主 API；提醒、标题标记、抬窗仍走 1.7 / 1.8 那几条路径。**0.1.1-rc.2 到 0.2.1-rc.2 的插件条目照旧兼容**，换回旧宿主也不需要改配置。新增的只有界面元素——设置页页眉的铃铛是插件自己画的 SVG（`docs/brand/`），与宿主无关。
 
 ## 控制台高级配置
 
@@ -236,8 +223,10 @@ window.__dshNotifyMe.setConfig({
   enabled: true,           // false = 关闭所有提醒（主开关）
   language: "auto",        // 'auto' 跟随界面 | 'zh' 简体中文 | 'en' English
   attentionHiddenOnly: false, // true = 页面可见时「需要你」不提醒
-  currentHiddenOnly: true,    // true = 当前对话的等待只留标题标记（转后台补发）
-  doneHiddenOnly: true,       // false = 页面可见时「完成」也提醒
+  currentHiddenOnly: true,    // true = 当前对话的等待只留标题标记（人离开后补发）
+  donePolicy: "background",   // 「回复完成」策略：'background' 仅后台 | 'smart' 仅当前对话静默 | 'always' 总是提醒
+  idleMinutes: 3,             // 超过多少分钟没有键鼠输入算「离开」（0 = 关掉闲置判定）
+  autoDismiss: "present",     // 通知自动消失：'present' 离开时保留 | 'always' 总是关闭 | 'never' 从不关闭
   ignoreSubagent: true,       // true = 后台子代理（subagent）会话不提醒（当前打开的照常）
   sound: true,                // 提示音开关（含「系统通知音」模式）
   soundDone: "synth",         // 「完成」音效来源：'synth' 内置 | 'custom' 自定义文件 | 'system' 系统通知音
@@ -245,7 +234,6 @@ window.__dshNotifyMe.setConfig({
   volume: 0.5,                // 音量 0~1
   autoFocus: true,            // 点通知回到提醒所属的对话
   quickActions: true,         // 审批通知上的「同意 / 拒绝」按钮
-  overlayCorner: "bottom-right", // 桌面端审批卡片位置：'top-right' | 'bottom-right' | 'top-left' | 'bottom-left'
   externalEnabled: false,     // 外部通知转发主开关（默认关：不填端点就什么都不发）
   externalAttention: true,    // 转发「需要你」（触发规则跟本地提醒完全一致）
   externalDone: true,         // 转发「回复完成」
@@ -282,9 +270,9 @@ window.__dshNotifyMe.testExternal()               // 显式外发测试：向有
 
 ### 快捷裁决怎么走通的
 
-通知按钮（`actions`）只属于 Service Worker 弹的持久通知，往 `new Notification()` 里传 `actions` 会直接抛 `TypeError`——这是绕不开的浏览器限制。所以 bundle 一份文件干两件事：页面里照常注册提醒工厂，同一份字节再注册成一个只干转信的 Service Worker，把「点了哪个按钮」（同意 / 拒绝 / 点正文）带回页面。真正的裁决发生在页面里，调的是审批卡片自己用的 `PendingApproval.answer('allowed-once' | 'rejected')`，所以「同意」就是「允许一次」，不多放行任何东西。点正文的「调窗口 + 切对话」同样归 worker 这半侧调度：它用 `client.focus()` 只调起一个窗口（优先当前可见的），并只让那个窗口切对话——多个 DSH 标签页不会互相抢焦点或一起乱切。
+通知按钮（`actions`）只属于 Service Worker 弹的持久通知，往 `new Notification()` 里传 `actions` 会直接抛 `TypeError`——这是绕不开的浏览器限制。所以 bundle 一份文件干两件事：页面里照常注册提醒工厂，同一份字节再注册成一个只干转信的 Service Worker，把「点了哪个按钮」（同意 / 拒绝 / 点正文）带回页面。真正的裁决发生在页面里，调的是对话里审批「允许一次 / 拒绝」用的同一个 `PendingApproval.answer('allowed-once' | 'rejected')`，所以「同意」就是「允许一次」，不多放行任何东西。点正文的「调窗口 + 切对话」同样归 worker 这半侧调度：它用 `client.focus()` 只调起一个窗口（优先当前可见的），并只让那个窗口切对话——多个 DSH 标签页不会互相抢焦点或一起乱切。
 
-每条按钮通知按交互 key 记账，一次只认领一条等待；请求被页面里答掉、或被新请求顶替之后，残留通知上的按钮再点也不会误裁，只是安静地关掉。带按钮的通知停留 12 秒（普通通知 5 秒），到点自动撤；没来得及点就回页面里裁决，卡片一直等着你。
+每条按钮通知按交互 key 记账，一次只认领一条等待；请求被页面里答掉、或被新请求顶替之后，残留通知上的按钮再点也不会误裁，只是安静地关掉。带按钮的通知停留 12 秒（普通通知 5 秒），到点自动撤；没来得及点就回页面里裁决，对话里的审批一直等着你。
 
 ### 桌面端怎么抬窗的
 
@@ -305,7 +293,7 @@ DSH Desktop 是一层 Electron 壳，页面跑在 `dsh-app://app` 下：DOM 的
 - 页面必须开着才会提醒（后台标签/最小化可以；关标签页即失效——浏览器层方案固有限制）。
 - 通知经由浏览器弹出，需允许浏览器通知权限，且勿扰模式不能屏蔽它。
 - 桌面端（DSH Desktop 0.2.1-rc.2 / Windows）点通知后窗口不一定上前台：有时会，有时只切对话。插件发的 `dsh://open` 深链单独复测 3/3 无效（详见[桌面端怎么抬窗的](#桌面端怎么抬窗的)），能抬的时候多半是系统/Chromium 在通知激活时自己把窗口带起来了（[discussions #10446](https://github.com/deepseek-ai/deepseek-harness/discussions/10446)）。
-- 系统通知横幅只画在主屏：Windows 没有设置项、Chromium 没有 API 能把它指到别的显示器（多屏时副屏收不到系统通知）。页面里唯一还会出现在副屏的是桌面端的审批卡片，它跟着 DSH 窗口走；普通提醒要跨屏，只能靠外部推送转到手机。
+- 系统通知横幅只画在主屏：Windows 没有设置项、Chromium 没有 API 能把它指到别的显示器（多屏时副屏收不到系统通知）。要跨屏提醒只能靠外部推送转到手机（1.12.0 起页面里不再画审批卡片）。
 - 每次页面加载后第一次出声/弹通知前，需在页面上点击过一次（浏览器自动播放与权限策略）。
 - 未授权通知权限时只有提示音与标题标记。
 - 快捷裁决按钮要 Service Worker：`http://127.0.0.1`、`https` 可用，`http://192.168.x.x` 这类局域网地址不行；**桌面端（`dsh-app://`）已实测无法注册 Service Worker**，按钮渲染不了，审批通知退回无按钮样式。浏览器或桌面宿主不渲染通知按钮时，`window.__dshNotifyMe.debug()` 的 `bridge` 字段会说明原因，其余功能不受影响。
@@ -323,7 +311,7 @@ DSH Desktop 是一层 Electron 壳，页面跑在 `dsh-app://app` 下：DOM 的
 ```powershell
 node --check lib\client.js
 node --check lib\index.js
-node smoke\smoke-test.cjs        # 离线状态机冒烟测试：三代宿主 + 主开关 + 中英语言用例 + 快捷裁决桥（Service Worker 半侧一并跑）+ 桌面审批卡片
+node smoke\smoke-test.cjs        # 离线状态机冒烟测试：三代宿主 + 主开关 + 中英语言用例 + 快捷裁决桥（Service Worker 半侧一并跑）+ 闲置判定与通知自收
 node smoke\cordis-host-test.mjs  # 真 cordis 端到端（找不到本机 DSH 时自动跳过）
 npm pack --dry-run               # 预览发布包
 ```
@@ -340,6 +328,7 @@ npm pack --dry-run               # 预览发布包
 - [@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）。
+- [@shrekcg](https://github.com/shrekcg) — [#16](https://github.com/chromoany/dsh-notify-me/pull/16)：把「人在前台但离开了」并入离开判定（`idleMinutes`，默认 3 分钟）、「回复完成」按哪个对话完成决定是否提醒（`donePolicy` 三选一）、通知自动消失的三档策略（`autoDismiss`），并带上对应冒烟用例与旧配置迁移；1.12.0 落地时维护者补了闲置到期补发被压下的审批、删掉残留的页内审批卡片、补齐文档与版本。
 
 署名口径：本仓库收编外部 PR 时以维护者提交落地——不沿用原 commit、不挂 Co-authored-by，GitHub 的 contributors 图只显示维护者，贡献者以上面的致谢署名。
 

package/lib/client.js

@@ -226,10 +226,26 @@
       // being hidden is the reliable "away" signal.
       attentionHiddenOnly: false, // needs-input alerts even while the page is visible
       // A wait inside the conversation already on screen needs no toast: the
-      // approval card is right there, and a toast lands on top of it. Leaving
-      // the page brings that alert back (see flushQuieted).
+      // request is right in front of the user. Leaving the page brings that
+      // alert back (see flushQuieted).
       currentHiddenOnly: true, // the visible session's own waits stay silent
-      doneHiddenOnly: true, // reply-finished alerts only when the page is hidden
+      doneHiddenOnly: true, // legacy boolean, kept in sync with donePolicy below
+      // When a finished reply should raise a toast. "background" alerts only
+      // while the page is not being watched; "smart" stays silent only for the
+      // conversation already on screen, so a second conversation finishing
+      // behind the one you are reading still reaches you; "always" never
+      // suppresses. "Watched" is away(), so a window left in front with nobody
+      // at the keyboard still counts as away.
+      donePolicy: "background",
+      // Minutes without pointer/keyboard input before a focused page counts as
+      // away. 0 disables the idle half and restores the focus-only rule.
+      idleMinutes: 3,
+      // Whether a toast goes away on its own. "present" closes it a few
+      // seconds later only while you are at the page, so an alert that arrived
+      // while you were away is still in the notification center when you come
+      // back; "always" is the old tidy-up; "never" leaves plain toasts up until
+      // you dismiss them. Approvals keep their own 12 s rule.
+      autoDismiss: "present",
       // Background subagent child sessions are steps of another conversation's
       // turn: DSH lists each of them as its own row (origin: 'subagent'), so
       // their waits and finish edges would toast noise the user cannot act on.
@@ -249,23 +265,17 @@
       soundAttention: "synth",
       volume: 0.5,
       autoFocus: true, // clicking the toast raises DSH and switches to the alerted conversation
-      // 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.
+      // Approval notifications carry 同意/拒绝 buttons and settle the request on
+      // one click (the same answer('allowed-once' | 'rejected') a manual
+      // decision sends). Buttons need persistent notifications, served through
+      // the Service Worker half of this same file; where that cannot run, the
+      // alert is a plain notification without buttons.
       quickActions: true,
-      // Alerts reach the user through the OS notification center; there is no
-      // second channel. An in-page card would follow the DSH window to whatever
-      // display it sits on, but it is invisible the moment the window is not in
-      // front — which is exactly when a reminder is worth anything — so 1.11.0
-      // removed it as a channel. The card layer survives for the one case that
-      // needs it: the desktop shell cannot put Approve / Reject on a system
-      // notification, so an approval also drops a clickable card in the corner
-      // (see showFallbackApprovalCard).
-      // Which corner of this window that approval card stacks in. The screen
-      // follows the window — the page cannot aim it anywhere else either.
-      overlayCorner: "bottom-right", // bottom-right | bottom-left | top-right | top-left
+      // Alerts reach the user through the OS notification center and nowhere
+      // else. 1.11.0 dropped the in-page overlay (invisible the moment the window
+      // is not in front — exactly when a reminder is worth anything), and 1.12.0
+      // dropped the approval card that outlived it: a second on-page copy next
+      // to the notification is noise.
       // 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
@@ -282,18 +292,37 @@
         var raw = localStorage.getItem(LS_CONFIG);
         if (raw) cfg = JSON.parse(raw);
       } catch (e) { /* corrupt storage -> defaults */ }
-      // The alert channel is gone: 1.11.0 removed the in-page overlay as a
-      // delivery option, so an old config's `channel` / `overlay` / `toast` keys
-      // mean nothing now. Dropped here so the next write stores a clean config.
+      // The in-page delivery options are gone: 1.11.0 removed the overlay as a
+      // channel, 1.12.0 the approval card. An old config's `channel` / `overlay`
+      // / `toast` / `overlayCorner` keys mean nothing now — dropped here so the
+      // next write stores a clean config.
       delete cfg.channel;
       delete cfg.overlay;
       delete cfg.toast;
+      delete cfg.overlayCorner;
+      // Older builds exposed one boolean switch. A profile that had "also
+      // alert while the page is open" turned on maps to "always"; everything
+      // else keeps the background rule. Applied before the defaults fill so a
+      // migrated value is not overwritten.
+      if (typeof cfg.donePolicy !== "string" && cfg.doneHiddenOnly === false) cfg.donePolicy = "always";
       for (var k in DEFAULTS) if (!(k in cfg)) cfg[k] = DEFAULTS[k];
+      // The boolean is now derived, never an input: keeping the two in step
+      // means anything still reading doneHiddenOnly (a script, the 1.x smoke
+      // suite, a downgrade) sees what the policy actually does.
+      cfg.doneHiddenOnly = cfg.donePolicy !== "always";
       return cfg;
     }
     function writeConfig(patch) {
       var cfg = readConfig();
       for (var k in patch) cfg[k] = patch[k];
+      // Legacy alias, live in both directions: patching the old boolean still
+      // selects the policy, so an existing caller keeps its meaning instead of
+      // silently losing the setting to a key nothing reads any more.
+      if (!("donePolicy" in patch) && "doneHiddenOnly" in patch) {
+        cfg.donePolicy = patch.doneHiddenOnly === false ? "always" : "background";
+      }
+      cfg.donePolicy = cfg.donePolicy === "smart" || cfg.donePolicy === "always" ? cfg.donePolicy : "background";
+      cfg.doneHiddenOnly = cfg.donePolicy !== "always";
       try { localStorage.setItem(LS_CONFIG, JSON.stringify(cfg)); } catch (e) {}
       return cfg;
     }
@@ -303,12 +332,6 @@
     function setConfigLocal(patch) {
       config = writeConfig(patch);
       applyTitle();
-      // A new corner moves the approval-card layer without waiting for the next
-      // alert. Cards themselves are left alone: an unrelated patch must not
-      // sweep a pending approval off the screen.
-      try {
-        if (overlayLayer) overlayLayer.className = "dnm-ov-layer dnm-ov-" + overlayCorner();
-      } catch (e) {}
       return config;
     }
 
@@ -663,13 +686,12 @@
       } catch (e) {}
     }
     // One toast button press. outcome: 'allowed-once' | 'rejected' — exactly
-    // the two decisions the in-page approval card exposes.
+    // the two decisions a manual answer in the conversation makes.
     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);
-      closeOverlayForKey(key);
       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.
@@ -691,10 +713,10 @@
     // 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) {
-      // The buttons themselves are a rendering concern: the overlay always
-      // draws them, and a toast needs a live worker bridge for OS actions. The
-      // pending record is kept either way, so a click still settles the same
-      // decision (and debug().actionKeys stays honest about what is waiting).
+      // The buttons are a rendering concern: a notification needs a live worker
+      // bridge for OS actions. The pending record is kept either way, so a click
+      // still settles the same decision (and debug().actionKeys stays honest
+      // about what is waiting).
       if (!config.quickActions) return null;
       if (!it || it.kind !== "approval" || typeof it.answer !== "function") return null;
       var q = {
@@ -784,243 +806,18 @@
         }
         // Longer for an actionable toast so there is time to click it, shorter
         // for a plain one: a notification that just sits there is noise.
-        setTimeout(function () { n.close(); }, quick ? 12000 : 5000);
+        // close() also withdraws the toast from the notification center, so a
+        // timer must not erase an alert the user never got to see. autoDismiss
+        // picks between the three behaviours (see DEFAULTS).
+        var policy = config.autoDismiss === "always" || config.autoDismiss === "never" ? config.autoDismiss : "present";
+        if (quick) {
+          setTimeout(function () { if (policy !== "always" && hidden()) return; n.close(); }, 12000);
+        } else if (policy !== "never") {
+          setTimeout(function () { if (policy !== "always" && hidden()) return; n.close(); }, 5000);
+        }
       } catch (e) {}
     }
 
-    // ─────────────────── page overlay reminders ──────────────────────
-    // Windows draws notification banners on the primary display and exposes no
-    // way to aim them at another monitor; a user who keeps DSH on a second
-    // screen therefore never sees a toast. This overlay draws the same alert
-    // inside the page instead, so it lands on whatever screen the DSH window
-    // occupies. It also needs no notification permission, and — unlike OS
-    // action buttons, which require the Service Worker the desktop shell cannot
-    // run — it can carry the 同意/拒绝 buttons everywhere. Off by default;
-    // independent of the toast switch.
-    var OVERLAY_STYLE_ID = "dsh-notify-me/overlay";
-    var OVERLAY_ID = "dsh-notify-me-overlay";
-    var OVERLAY_MAX_CARDS = 4;
-    // How long a card stays. "needs you" deserves a longer look than a finished
-    // reply; actionable cards get the longest window but still fade, because a
-    // card that never leaves is just clutter once the user has moved on.
-    var OVERLAY_TTL = { attention: 5000, done: 5000, action: 12000 };
-    var OVERLAY_CORNERS = ["bottom-right", "bottom-left", "top-right", "top-left"];
-    var OVERLAY_CSS = "" +
-      ".dnm-ov-layer{position:fixed;z-index:2147483000;display:flex;flex-direction:column;gap:10px;pointer-events:none;max-width:calc(100vw - 24px)}" +
-      ".dnm-ov-bottom-right{right:16px;bottom:16px;align-items:flex-end}" +
-      ".dnm-ov-bottom-left{left:16px;bottom:16px;align-items:flex-start}" +
-      ".dnm-ov-top-right{right:16px;top:16px;align-items:flex-end}" +
-      ".dnm-ov-top-left{left:16px;top:16px;align-items:flex-start}" +
-      ".dnm-ov{pointer-events:auto;width:320px;max-width:calc(100vw - 32px);box-sizing:border-box;border-radius:12px;padding:10px 12px 11px;display:flex;flex-direction:column;gap:7px;font-size:13px;line-height:19px;color:var(--dsw-alias-label-primary,#f3f4f6);background:var(--dsw-alias-bg-layer-3,rgba(30,32,36,.97));border:1px solid var(--dsw-alias-border-l2,rgba(128,128,128,.35));border-left-width:3px;box-shadow:0 12px 32px rgba(0,0,0,.32);cursor:pointer;animation:dnmOvIn .16s ease-out}" +
-      ".dnm-ov-attention{border-left-color:var(--dsw-alias-state-warning-primary,#f59e0b)}" +
-      ".dnm-ov-done{border-left-color:var(--dsw-alias-state-success-primary,#22c55e)}" +
-      ".dnm-ov-head{display:flex;align-items:center;gap:7px}" +
-      ".dnm-ov-dot{flex:none;width:7px;height:7px;border-radius:50%;background:currentColor;opacity:.55}" +
-      ".dnm-ov-attention .dnm-ov-dot{color:var(--dsw-alias-state-warning-primary,#f59e0b);opacity:1}" +
-      ".dnm-ov-done .dnm-ov-dot{color:var(--dsw-alias-state-success-primary,#22c55e);opacity:1}" +
-      ".dnm-ov-title{flex:1;min-width:0;font-weight:600;font-size:13px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}" +
-      ".dnm-ov-x,.dnm-ov-more{flex:none;border:0;background:transparent;color:inherit;opacity:.6;font-size:15px;line-height:15px;padding:0 2px;cursor:pointer;font-family:inherit}" +
-      ".dnm-ov-x:hover,.dnm-ov-more:hover{opacity:1}" +
-      ".dnm-ov-more{font-size:11px;opacity:.8;white-space:nowrap}" +
-      ".dnm-ov-body{color:var(--dsw-alias-label-secondary,rgba(220,222,226,.86));font-size:12px;line-height:18px;display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden;word-break:break-word}" +
-      ".dnm-ov.dnm-ov-open .dnm-ov-body{display:block;-webkit-line-clamp:unset;max-height:40vh;overflow:auto}" +
-      ".dnm-ov-actions{display:flex;gap:8px;margin-top:2px}" +
-      ".dnm-ov-btn{flex:1;border:1px solid var(--dsw-alias-border-l2,rgba(128,128,128,.4));background:var(--dsw-alias-bg-layer-1,rgba(255,255,255,.06));color:inherit;border-radius:8px;padding:5px 10px;font-size:12px;font-family:inherit;cursor:pointer}" +
-      ".dnm-ov-btn:hover{background:var(--dsw-alias-bg-layer-2,rgba(255,255,255,.12))}" +
-      ".dnm-ov-approve{border-color:transparent;background:var(--dsw-alias-state-business-primary,#3b82f6);color:#fff}" +
-      ".dnm-ov-approve:hover{background:var(--dsw-alias-state-business-primary,#3b82f6);filter:brightness(1.06)}" +
-      ".dnm-ov-reject{color:inherit}" +
-      "@keyframes dnmOvIn{from{opacity:0;transform:translateY(6px)}to{opacity:1;transform:none}}";
-    var overlayLayer = null;
-    var overlayCards = Object.create(null); // id -> { card, key, kind, timer }
-    var overlaySeq = 0;
-    function overlayCorner() {
-      return OVERLAY_CORNERS.indexOf(config.overlayCorner) === -1 ? "bottom-right" : config.overlayCorner;
-    }
-    function injectOverlayStyle() {
-      try {
-        if (typeof document === "undefined" || typeof document.createElement !== "function") return;
-        if (!document.head && !document.documentElement) return;
-        var sel = "style[data-plugin-css=" + JSON.stringify(OVERLAY_STYLE_ID) + "]";
-        var seen = false;
-        try { seen = !!(document.querySelector && document.querySelector(sel)); } catch (e) {}
-        if (seen) return;
-        var s = document.createElement("style");
-        s.dataset.plugin = "dsh-notify-me";
-        s.dataset.pluginCss = OVERLAY_STYLE_ID;
-        s.textContent = OVERLAY_CSS;
-        (document.head || document.documentElement).appendChild(s);
-      } catch (e) {}
-    }
-    // The fixed layer lives directly under <body> so no ancestor transform or
-    // stacking context in the host app can drag the cards away from the corner.
-    function ensureOverlayLayer() {
-      try {
-        if (typeof document === "undefined" || typeof document.createElement !== "function" || !document.body) return null;
-        injectOverlayStyle();
-        if (!overlayLayer || !overlayLayer.parentNode) {
-          // A reload of this bundle can leave a previous layer behind; the id is
-          // the only handle an HMR-free page gives us.
-          var old = null;
-          try { old = document.getElementById && document.getElementById(OVERLAY_ID); } catch (e) {}
-          if (old && old.parentNode) old.parentNode.removeChild(old);
-          overlayLayer = document.createElement("div");
-          overlayLayer.id = OVERLAY_ID;
-          overlayLayer.setAttribute("role", "status");
-          overlayLayer.setAttribute("aria-live", "polite");
-          document.body.appendChild(overlayLayer);
-        }
-        overlayLayer.className = "dnm-ov-layer dnm-ov-" + overlayCorner();
-        return overlayLayer;
-      } catch (e) { return null; }
-    }
-    function dismissOverlay(id) {
-      var rec = overlayCards[id];
-      if (!rec) return;
-      delete overlayCards[id];
-      if (rec.timer) { try { clearTimeout(rec.timer); } catch (e) {} }
-      try { if (rec.card && rec.card.parentNode) rec.card.parentNode.removeChild(rec.card); } catch (e) {}
-    }
-    // An approval that gets answered elsewhere (the in-page card, another
-    // toast, a session switch) must not leave a stale overlay behind.
-    function closeOverlayForKey(key) {
-      if (!key) return;
-      var ids = Object.keys(overlayCards);
-      for (var i = 0; i < ids.length; i++) {
-        if (overlayCards[ids[i]].key === key) dismissOverlay(ids[i]);
-      }
-    }
-    function clearOverlays() {
-      var ids = Object.keys(overlayCards);
-      for (var i = 0; i < ids.length; i++) dismissOverlay(ids[i]);
-      if (overlayLayer) {
-        try { if (overlayLayer.parentNode) overlayLayer.parentNode.removeChild(overlayLayer); } catch (e) {}
-        overlayLayer = null;
-      }
-    }
-    function overlayCount() { return Object.keys(overlayCards).length; }
-    // The card builder behind the desktop approval fallback below (the overlay
-    // channel that also used it is gone since 1.11.0). `opts` keeps behaviours
-    // apart: a click must not dismiss an unanswered approval, and a
-    // "详情 / Details" toggle exposes the body that the CSS clamps to 3 lines.
-    function drawOverlayCard(kind, title, body, sessionId, quick, opts) {
-      opts = opts || {};
-      var layer = ensureOverlayLayer();
-      if (!layer) return false;
-      // One card per approval key: a re-delivery (the quieted copy that fires
-      // when the page is backgrounded) must not stack a second card.
-      if (quick && typeof quick.key === "string") {
-        var known = Object.keys(overlayCards);
-        for (var k = 0; k < known.length; k++) {
-          if (overlayCards[known[k]].key === quick.key) return false;
-        }
-      }
-      var d = texts();
-      try {
-        var id = "ov" + (++overlaySeq);
-        var baseClass = "dnm-ov dnm-ov-" + (kind === "attention" ? "attention" : "done");
-        var card = document.createElement("div");
-        card.className = baseClass;
-        card.setAttribute("role", kind === "attention" ? "alert" : "status");
-        var head = document.createElement("div");
-        head.className = "dnm-ov-head";
-        var dot = document.createElement("span");
-        dot.className = "dnm-ov-dot";
-        var label = document.createElement("span");
-        label.className = "dnm-ov-title";
-        label.textContent = String(title == null ? "" : title);
-        var more = null;
-        if (opts.expand && body) {
-          more = document.createElement("button");
-          more.type = "button";
-          more.className = "dnm-ov-more";
-          more.setAttribute("aria-label", d.details);
-          more.setAttribute("aria-expanded", "false");
-          more.textContent = d.details;
-          more.onclick = function (ev) {
-            if (ev && ev.stopPropagation) ev.stopPropagation();
-            var open = card.className.indexOf("dnm-ov-open") !== -1;
-            card.className = baseClass + (open ? "" : " dnm-ov-open");
-            more.textContent = open ? d.details : d.collapse;
-            more.setAttribute("aria-expanded", open ? "false" : "true");
-          };
-        }
-        var close = document.createElement("button");
-        close.type = "button";
-        close.className = "dnm-ov-x";
-        close.setAttribute("aria-label", d.dismiss);
-        close.textContent = "×";
-        close.onclick = function (ev) {
-          if (ev && ev.stopPropagation) ev.stopPropagation();
-          dismissOverlay(id);
-        };
-        head.appendChild(dot);
-        head.appendChild(label);
-        if (more) head.appendChild(more);
-        head.appendChild(close);
-        card.appendChild(head);
-        if (body) {
-          var bodyEl = document.createElement("div");
-          bodyEl.className = "dnm-ov-body";
-          bodyEl.textContent = String(body);
-          card.appendChild(bodyEl);
-        }
-        if (quick && typeof quick.key === "string") {
-          var actions = document.createElement("div");
-          actions.className = "dnm-ov-actions";
-          var actionBtn = function (cls, text, outcome) {
-            var b = document.createElement("button");
-            b.type = "button";
-            b.className = "dnm-ov-btn " + cls;
-            b.textContent = text;
-            b.onclick = function (ev) {
-              if (ev && ev.stopPropagation) ev.stopPropagation();
-              try { decidePending(quick.key, outcome); } catch (e) {}
-              dismissOverlay(id);
-            };
-            return b;
-          };
-          actions.appendChild(actionBtn("dnm-ov-approve", d.approve, "allowed-once"));
-          actions.appendChild(actionBtn("dnm-ov-reject", d.reject, "rejected"));
-          card.appendChild(actions);
-        }
-        // A click on the card body opens the conversation, exactly like a toast
-        // body click — and here it is an ordinary page gesture, so it reaches the
-        // desktop's dsh:// raise path even though a worker click would not. The
-        // overlay channel also takes the card down; the fallback card stays, so
-        // the decision is still one click away after a look at the conversation.
-        card.onclick = function () {
-          if (config.autoFocus) focusSession(sessionId || null);
-          if (opts.dismissOnClick !== false) dismissOverlay(id);
-        };
-        layer.appendChild(card);
-        var rec = { card: card, key: (quick && quick.key) ? quick.key : null, kind: kind, timer: null };
-        overlayCards[id] = rec;
-        var ids = Object.keys(overlayCards);
-        for (var i = 0; i < ids.length - OVERLAY_MAX_CARDS; i++) dismissOverlay(ids[i]);
-        var ttl = (quick && typeof quick.key === "string")
-          ? OVERLAY_TTL.action
-          : OVERLAY_TTL[kind === "attention" ? "attention" : "done"];
-        if (ttl) rec.timer = setTimeout(function () { dismissOverlay(id); }, ttl);
-        return true;
-      } catch (e) { return false; }
-    }
-    // The desktop shell cannot register the Service Worker that OS action
-    // buttons require, so an approval toast on a dsh-app:// page has no button
-    // to click. An approval therefore also drops a card into the in-page layer,
-    // in the configured corner and with the same styling: its buttons call
-    // decidePending(), the exact path a Web toast button takes. Only states that
-    // prove the bridge is unusable qualify — 'idle'/'registering' are
-    // transitional, 'disabled' means the quick-decision switch is off (quickFor()
-    // then returns null, so no card is drawn at all), and the Web path stays
-    // untouched once the worker is up.
-    function showFallbackApprovalCard(kind, title, body, sessionId, quick) {
-      if (kind !== "attention") return false;
-      if (!quick || typeof quick.key !== "string") return false;
-      if (bridgeActive()) return false;
-      if (swState.indexOf("unsupported:") !== 0 && swState.indexOf("failed:") !== 0) return false;
-      return drawOverlayCard(kind, title, body, sessionId, quick, { dismissOnClick: false, expand: true });
-    }
     // Sound: WebAudio beeps (no asset needed). The context only runs after a
     // user gesture; we unlock it on the first pointer/key event.
     var audioCtx = null;
@@ -1331,10 +1128,7 @@
       var rec = pendingActions[key];
       if (rec) {
         delete pendingActions[key];
-        if (!rec.test) {
-          closeNotificationTag(rec.tag);
-          closeOverlayForKey(key);
-        }
+        if (!rec.test) closeNotificationTag(rec.tag);
       }
       if (!attentionKeysMarked[key]) return;
       delete attentionKeysMarked[key];
@@ -1377,7 +1171,62 @@
       // to the conversation on screen; a blur alone never fires visibilitychange.
       try { flushQuieted(); } catch (e) {}
     }
-    function away() { return hidden() || !pageFocused; }
+    // Focus answers "is the window in front", not "is anyone there". A window
+    // left in front while its owner walks off still reports focus forever, so
+    // track real input and treat a page nobody has touched for `idleMinutes` as
+    // away too. Everything that keys on away() benefits without changing shape.
+    var lastActivityAt = Date.now();
+    function noteActivity() {
+      lastActivityAt = Date.now();
+      if (!idleTimer) armIdle();
+    }
+    (function watchActivity() {
+      var events = ["pointerdown", "pointermove", "keydown", "wheel", "touchstart"];
+      for (var ai = 0; ai < events.length; ai++) {
+        try { window.addEventListener(events[ai], noteActivity, { passive: true, capture: true }); } catch (e) {}
+      }
+    })();
+    function idleMinutes() {
+      var m = config && config.idleMinutes;
+      return (typeof m === "number" && isFinite(m) && m > 0) ? m : 0;
+    }
+    function idleExpired() {
+      var m = idleMinutes();
+      return m ? (Date.now() - lastActivityAt) >= m * 60000 : false;
+    }
+    // Going idle is the one "away" transition that fires no event: the quieted
+    // queue is normally flushed by a blur or a visibility change, and neither
+    // comes when the user simply stops touching a window that stays in front.
+    // The wait queued ten seconds before they walked off would then stay silent
+    // until they came back. Re-check exactly when the idle window closes.
+    var idleTimer = null;
+    function onIdleCheck() {
+      idleTimer = null;
+      if (!idleExpired()) { armIdle(); return; }
+      try { flushQuieted(); } catch (e) {}
+    }
+    function armIdle() {
+      var m = idleMinutes();
+      if (!m) return;
+      var left = m * 60000 - (Date.now() - lastActivityAt);
+      if (left < 0) left = 0;
+      try { clearTimeout(idleTimer); } catch (e) {}
+      try { idleTimer = setTimeout(onIdleCheck, left); } catch (e) { idleTimer = null; }
+    }
+    function away() { return hidden() || !pageFocused || idleExpired(); }
+    function donePolicy() {
+      var p = config && config.donePolicy;
+      return p === "smart" || p === "always" ? p : "background";
+    }
+    // True when this completion must stay silent. Only "smart" looks at which
+    // conversation finished: the one on screen is already being read, but one
+    // further down the sidebar is information the user does not have yet.
+    function doneSuppressed(isCurrent) {
+      var p = donePolicy();
+      if (p === "always") return false;
+      if (p === "smart") return !!isCurrent && !away();
+      return !away();
+    }
 
     // Deliver one alert regardless of visibility rules (used by the test
     // buttons); respects the master switch and permission state. The title
@@ -1393,7 +1242,6 @@
     function deliver(kind, title, body, sessionId, quick) {
       if (!config.enabled) return;
       showToast(kind, title, body, sessionId, quick);
-      showFallbackApprovalCard(kind, title, body, sessionId, quick);
       if (kind === "attention") {
         playAttentionSound();
       } else {
@@ -1405,11 +1253,10 @@
       if (!config.enabled) return false;
       if (kind === "attention" && config.attentionHiddenOnly && !away()) return false;
       // The wait belongs to the conversation the user is looking at right now:
-      // the approval card is already on screen, so a toast would only cover the
-      // thing it is asking about. The caller keeps the tab marker, and
-      // flushQuieted() re-delivers the alert the moment the page is backgrounded.
+      // the request is already on screen. The caller keeps the tab marker, and
+      // flushQuieted() re-delivers the alert once the page is away.
       if (kind === "attention" && quietedByVisibleSession(isCurrent)) return false;
-      if (kind === "done" && config.doneHiddenOnly && !away()) return false;
+      if (kind === "done" && doneSuppressed(isCurrent)) 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 —
@@ -1426,7 +1273,10 @@
     // Queued copies of the alerts that rule suppressed. Delivered by key so a
     // wait that got answered while the user was still on the page never fires.
     function queueQuieted(key, copy) {
-      if (key && copy) quietedAttention[key] = copy;
+      if (key && copy) {
+        quietedAttention[key] = copy;
+        armIdle();
+      }
     }
     function flushQuieted() {
       if (!config.enabled || !away()) return;
@@ -1524,7 +1374,7 @@
       var d = texts();
       var body = sessionLabel || d.doneBody;
       if (snippet) body = body + "\n" + snippet;
-      fire("done", d.doneTitle, body, false, sessionId);
+      fire("done", d.doneTitle, body, !!(sessionId && sessionId === currentSessionId()), sessionId);
     }
     // Every "reply finished" report funnels through here, so the edge path and
     // the completionUnread level flag cannot double-alert one completion. The
@@ -2033,7 +1883,7 @@
       });
     } catch (e) {}
     // keep in sync with package.json "version" on every release
-    api.version = "1.11.0";
+    api.version = "1.12.0";
     api.setConfig = function (patch) { return setConfigLocal(patch); };
     api.resetConfig = function () {
       try {
@@ -2092,7 +1942,9 @@
         language: effectiveLang(),
         attentionHiddenOnly: config.attentionHiddenOnly,
         currentHiddenOnly: config.currentHiddenOnly,
-        doneHiddenOnly: config.doneHiddenOnly,
+        donePolicy: donePolicy(),
+        idleMinutes: idleMinutes(),
+        autoDismiss: config.autoDismiss,
         ignoreSubagent: config.ignoreSubagent,
         sound: config.sound,
         soundDone: soundMode("done"),
@@ -2100,14 +1952,6 @@
         customSoundDone: !!readSound("done"),
         customSoundAttention: !!readSound("attention"),
         quickActions: config.quickActions,
-        // The in-page card layer still exists for the desktop approval fallback
-        // (the shell's toasts carry no buttons); `cards` is the live stack and
-        // `corner` the configured anchor.
-        card: {
-          enabled: config.quickActions,
-          corner: overlayCorner(),
-          cards: overlayCount()
-        },
         // external webhook forwarding: counts come from externalStat (tallied
         // on every send), targets is the raw vs validated count.
         external: {
@@ -2170,7 +2014,7 @@
       enable: "启用提醒",
       enableHint: "关闭后不弹通知、不响提示音，也不改标签页标题。",
       hostEnv: "运行环境",
-      hostEnvHint: "默认自动识别：页面协议是 dsh-app:// 即桌面端（DSH Desktop），其余为 Web 端。识别不准时手动指定：桌面端走 dsh:// 深链调窗（效果不稳定），系统通知不带按钮、浮层才带；Web 端走 window.focus() 与 Service Worker 桥。",
+      hostEnvHint: "默认自动识别：页面协议是 dsh-app:// 即桌面端（DSH Desktop），其余为 Web 端。识别不准时手动指定：桌面端走 dsh:// 深链调窗（效果不稳定），系统通知不带「同意 / 拒绝」按钮；Web 端走 window.focus() 与 Service Worker 桥。",
       hostEnvAuto: "自动识别（推荐）",
       hostEnvDesktop: "桌面端（DSH Desktop）",
       hostEnvWeb: "Web 端（浏览器）",
@@ -2237,26 +2081,28 @@
       attentionVisible: "窗口在前台时也提醒「需要你」",
       attentionVisibleHint: "窗口在前台也提醒。关掉后只在窗口转到后台（切走、被遮挡或最小化）时提醒。",
       currentQuiet: "当前对话不弹通知",
-      currentQuietHint: "等待就发生在你正看着的对话里时只留标签页标记，免得挡住审批卡片；窗口转到后台后照常提醒。",
-      doneVisible: "窗口在前台时也提醒「回复完成」",
-      doneVisibleHint: "窗口在前台也提醒。默认只在窗口转到后台时提醒，避免打扰。",
+      currentQuietHint: "等待就发生在你正看着的对话里时只留标签页标记，免得打断眼前的操作；人离开（窗口转到后台或一段时间没动）后照常提醒。",
+      donePolicy: "「回复完成」什么时候提醒",
+      donePolicyHint: "「仅当前对话静默」＝你在看的那条完成了不弹，别的对话完成了照常提醒，多开对话时有用。",
+      dpBackground: "仅后台",
+      dpSmart: "仅当前对话静默",
+      dpAlways: "总是提醒",
+      autoDismiss: "通知自动消失",
+      autoDismissHint: "离开电脑时收到的那条，回来还要能看见。选「离开时保留」时只在你看页面时才关掉。",
+      adPresent: "离开时保留",
+      adAlways: "总是关闭",
+      adNever: "从不关闭",
       subagentQuiet: "子代理会话不提醒",
       subagentQuietHint: "跳过后台子代理会话（结果由所属主对话的提醒覆盖）；你正打开的那个照常提醒。",
       autoFocus: "点击通知回到对应对话",
       autoFocusHint: "点通知会切到这条提醒所属的对话；关掉后点击不做任何事。",
       quickActions: "审批通知上直接裁决",
-      quickActionsHint: "审批通知上带「同意 / 拒绝」，点一下即完成裁决，不用切回页面。需要 Service Worker（http://127.0.0.1 或 https）；用不了时按钮改画在窗口角落的卡片上（桌面端就是这条路）。",
-      quickApprovalNote: "「同意」等价于审批卡片上的「允许一次」，只放行这一次。",
+      quickActionsHint: "审批通知上带「同意 / 拒绝」，点一下即完成裁决，不用切回页面。需要 Service Worker（http://127.0.0.1 或 https）；用不了时（桌面端页面即如此）通知照常弹，只是不带按钮，点通知回到对话里裁决。",
+      quickApprovalNote: "「同意」等价于对话里审批的「允许一次」，只放行这一次。",
       bridgeOff: "快捷裁决按钮暂不可用（",
-      bridgeOffTail: "）：系统通知没有按钮，按钮改画在窗口角落的卡片上。",
-      bridgeOffDesktop: "系统通知本身没有「同意 / 拒绝」按钮：桌面端页面（dsh-app://）注册不了 Service Worker（宿主少给 allowServiceWorkers 特权）。审批类提醒会同时在窗口角落弹一张卡片，按钮就在卡片上。",
-      overlayCorner: "审批卡片位置",
-      overlayCornerHint: "桌面端审批卡片贴在 DSH 窗口的哪个角；窗口在哪块屏，卡片就出现在哪块屏。",
-      overlayPosTR: "右上",
-      overlayPosBR: "右下",
-      overlayPosTL: "左上",
-      overlayPosBL: "左下",
-      testApprovalNoBridge: "已发测试提醒：系统通知没有按钮，快捷裁决按钮画在窗口角落的卡片上。",
+      bridgeOffTail: "）：这条通知不带按钮，点它回到对话里裁决。",
+      bridgeOffDesktop: "桌面端页面（dsh-app://）注册不了 Service Worker（宿主少给 allowServiceWorkers 特权），系统通知本身没有「同意 / 拒绝」按钮：审批提醒照常弹出，点通知回到对话里裁决。",
+      testApprovalNoBridge: "已发测试提醒：桌面端通知不带按钮，点通知回到对话里裁决。",
       testNeedsQuick: "先打开上面的「审批通知上直接裁决」才能测按钮。",
       volume: "音量",
       language: "通知语言",
@@ -2293,7 +2139,7 @@
       enable: "Enable reminders",
       enableHint: "When off: no toasts, no sounds, and the tab title is left alone.",
       hostEnv: "Environment",
-      hostEnvHint: "Auto-detect by default: a dsh-app:// page is the Desktop (DSH Desktop) shell, anything else is the Web. Override it if detection comes out wrong: on the Desktop a toast click fires the dsh:// deep link (the effect is unreliable) and system notifications carry no buttons (the overlay does); on the Web it is window.focus() plus the Service Worker bridge.",
+      hostEnvHint: "Auto-detect by default: a dsh-app:// page is the Desktop (DSH Desktop) shell, anything else is the Web. Override it if detection comes out wrong: on the Desktop a toast click fires the dsh:// deep link (the effect is unreliable) and system notifications carry no Approve / Reject buttons; on the Web it is window.focus() plus the Service Worker bridge.",
       hostEnvAuto: "Auto-detect (recommended)",
       hostEnvDesktop: "Desktop (DSH Desktop)",
       hostEnvWeb: "Web (browser)",
@@ -2360,26 +2206,28 @@
       attentionVisible: "Also alert \"needs you\" while the window is in front",
       attentionVisibleHint: "Alert even while the window has focus. Turn off to hear only once the window goes to the background (another app, covered, or minimised).",
       currentQuiet: "Stay quiet for the conversation on screen",
-      currentQuietHint: "A wait belonging to the conversation on screen keeps only the tab marker, so the approval card stays readable; moving the window to the background restores alerts.",
-      doneVisible: "Also alert \"reply finished\" while the window is in front",
-      doneVisibleHint: "Alert even while the window has focus. By default only finishes in the background alert.",
+      currentQuietHint: "A wait belonging to the conversation on screen keeps only the tab marker, so the page is not covered; moving the window to the background or stepping away from it restores alerts.",
+      donePolicy: "When \"reply finished\" alerts",
+      donePolicyHint: "\"Quiet for the open one\" means the conversation you are reading finishes silently while any other conversation still alerts — useful with several conversations open.",
+      dpBackground: "Background only",
+      dpSmart: "Quiet for the open one",
+      dpAlways: "Always",
+      autoDismiss: "Dismiss the toast automatically",
+      autoDismissHint: "An alert that arrived while you were away should still be there when you return. \"Keep while away\" only tidies up while the page is in front.",
+      adPresent: "Keep while away",
+      adAlways: "Always close",
+      adNever: "Never close",
       subagentQuiet: "Ignore subagent sessions",
       subagentQuietHint: "Skip sessions spawned by a subagent (the parent conversation covers them); the one you have open still alerts.",
       autoFocus: "Click a toast to open that conversation",
       autoFocusHint: "A click switches to the conversation the alert came from; off means a click does nothing.",
       quickActions: "Decide approvals from the toast",
-      quickActionsHint: "Approval notifications carry Approve / Reject; one click settles the request without switching back. Needs a Service Worker browser (http://127.0.0.1 or https); when it is unavailable the buttons land on a card in the window corner (the Desktop shell's route).",
-      quickApprovalNote: "\"Approve\" equals \"Allow once\" on the approval card — it allows that one call only.",
+      quickActionsHint: "Approval notifications carry Approve / Reject; one click settles the request without switching back. Needs a Service Worker browser (http://127.0.0.1 or https); where it cannot run (the Desktop shell) the alert is a plain notification without buttons — clicking it opens the conversation.",
+      quickApprovalNote: "\"Approve\" equals \"Allow once\" in the conversation — it allows that one call only.",
       bridgeOff: "Quick-decision buttons are unavailable right now (",
-      bridgeOffTail: "); system notifications carry no buttons, so they are drawn on a card in the window corner instead.",
-      bridgeOffDesktop: "System notifications carry no Approve / Reject buttons: dsh-app:// pages cannot register a Service Worker (the shell does not grant the allowServiceWorkers privilege). An approval therefore also drops a clickable card in the window corner, buttons and all.",
-      overlayCorner: "Approval card position",
-      overlayCornerHint: "Which corner of the DSH window the Desktop approval card sits in; it follows the window to whatever display it is on.",
-      overlayPosTR: "Top right",
-      overlayPosBR: "Bottom right",
-      overlayPosTL: "Top left",
-      overlayPosBL: "Bottom left",
-      testApprovalNoBridge: "Test alert sent: system notifications carry no buttons, so the quick-decision buttons are drawn on a card in the window corner.",
+      bridgeOffTail: "); this notification carries no buttons — click it to open the conversation and decide.",
+      bridgeOffDesktop: "dsh-app:// pages cannot register a Service Worker (the shell does not grant the allowServiceWorkers privilege), and a system notification carries no Approve / Reject buttons: the approval alert still pops, click it to open the conversation and decide.",
+      testApprovalNoBridge: "Test alert sent: Desktop notifications carry no buttons — click it to open the conversation and decide.",
       testNeedsQuick: "Turn on \"Decide approvals from the toast\" above to test the buttons.",
       volume: "Volume",
       language: "Notification language",
@@ -2529,8 +2377,8 @@
       ".dnm-headTitle{font-size:15px;font-weight:600;line-height:21px;color:var(--dsw-alias-label-primary,rgba(20,20,20,.9))}" +
       ".dnm-headSub{margin:0;font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary,rgba(120,120,120,.9))}" +
       ".dnm-secTitle{margin:2px 0 -6px;padding:0 2px;font-size:12px;font-weight:600;line-height:18px;color:var(--dsw-alias-label-secondary,rgba(90,90,90,.9));letter-spacing:.02em}" +
-      // Sub-rows hang under the row they belong to (corner of the overlay,
-      // volume under Sound) instead of reading as siblings.
+      // Sub-rows hang under the row they belong to (volume under Sound)
+      // instead of reading as siblings.
       ".dnm-rowSub{padding-left:26px;background:var(--dsw-alias-bg-layer-2,rgba(128,128,128,.04))}" +
       ".dnm-rowSub .dnm-rowLabel{font-weight:500}" +
       ".dnm-rowStack{flex-direction:column;align-items:stretch;gap:10px}" +
@@ -2686,6 +2534,22 @@
       try { window.addEventListener("scroll", hideTip, true); } catch (e) {}
     })();
 
+    // A labelled <select> row, for settings that pick one of three behaviours
+    // rather than switching something on.
+    function rowSelect(key, labelText, hintText, current, options, onPick) {
+      return tipRow("dnm-row", hintText, [
+        h("div", { className: "dnm-rowText" }, [
+          h("div", { className: "dnm-rowLabel" }, labelText),
+          srOnly(hintText)
+        ]),
+        h("select", {
+          className: "dnm-select",
+          value: current,
+          "aria-label": labelText,
+          onChange: function (e) { onPick(e.currentTarget.value); }
+        }, options.map(function (o) { return h("option", { value: o.value }, o.label); }))
+      ]);
+    }
     function rowSwitch(key, labelText, hintText, checked, onChange) {
       return tipRow("dnm-row", hintText, [
         h("div", { className: "dnm-rowText" }, [
@@ -3073,34 +2937,23 @@
           rowSwitch("quickActions", t("quickActions"), t("quickActionsHint"), cfg.quickActions, function (v) {
             patch({ quickActions: v });
             if (v) ensureActionBridge();
-          }),
-          // The in-page card only exists to carry Approve / Reject where the OS
-          // toast cannot (the desktop shell), so its corner hangs under the
-          // quick-decision switch rather than a channel picker.
-          cfg.quickActions ? tipRow("dnm-row dnm-rowSub", t("overlayCornerHint"), [
-            h("div", { className: "dnm-rowText" }, [
-              h("div", { className: "dnm-rowLabel" }, t("overlayCorner")),
-              srOnly(t("overlayCornerHint"))
-            ]),
-            h("select", {
-              className: "dnm-select",
-              value: overlayCorner(),
-              "aria-label": t("overlayCorner"),
-              onChange: function (e) { patch({ overlayCorner: e.currentTarget.value }); }
-            }, [
-              h("option", { value: "top-right" }, t("overlayPosTR")),
-              h("option", { value: "bottom-right" }, t("overlayPosBR")),
-              h("option", { value: "top-left" }, t("overlayPosTL")),
-              h("option", { value: "bottom-left" }, t("overlayPosBL"))
-            ])
-          ]) : null
+          })
         ]),
         // 2) Which events are worth interrupting for.
         secTitle(t("secWhen")),
         card([
           rowSwitch("attentionVisible", t("attentionVisible"), t("attentionVisibleHint"), !cfg.attentionHiddenOnly, function (v) { patch({ attentionHiddenOnly: !v }); }),
           rowSwitch("currentQuiet", t("currentQuiet"), t("currentQuietHint"), cfg.currentHiddenOnly, function (v) { patch({ currentHiddenOnly: v }); }),
-          rowSwitch("doneVisible", t("doneVisible"), t("doneVisibleHint"), !cfg.doneHiddenOnly, function (v) { patch({ doneHiddenOnly: !v }); }),
+          rowSelect("donePolicy", t("donePolicy"), t("donePolicyHint"), cfg.donePolicy, [
+            { value: "background", label: t("dpBackground") },
+            { value: "smart", label: t("dpSmart") },
+            { value: "always", label: t("dpAlways") }
+          ], function (v) { patch({ donePolicy: v }); }),
+          rowSelect("autoDismiss", t("autoDismiss"), t("autoDismissHint"), cfg.autoDismiss, [
+            { value: "present", label: t("adPresent") },
+            { value: "always", label: t("adAlways") },
+            { value: "never", label: t("adNever") }
+          ], function (v) { patch({ autoDismiss: v }); }),
           rowSwitch("subagentQuiet", t("subagentQuiet"), t("subagentQuietHint"), cfg.ignoreSubagent, function (v) { patch({ ignoreSubagent: v }); }),
           rowSwitch("autoFocus", t("autoFocus"), t("autoFocusHint"), cfg.autoFocus, function (v) { patch({ autoFocus: v }); })
         ]),
@@ -3349,10 +3202,10 @@
         return function () {
           disposed = true;
           if (retryTimer) clearInterval(retryTimer);
+          if (idleTimer) { try { clearTimeout(idleTimer); } catch (e) {} idleTimer = null; }
           for (var i = 0; i < unsubs.length; i++) { try { unsubs[i](); } catch (e) {} }
           detachFace();
           detachUiSession();
-          clearOverlays();
         };
       }, "dsh-notify-me: watchers");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-notify-me",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "离开 DSH 页面也能收到提醒：需要你操作 / 后台回复完成时发系统通知、标题标记与提示音，支持审批快捷裁决与外部推送，Web 版与桌面版均可用。",
   "license": "MIT",
   "type": "module",
@@ -35,8 +35,8 @@
     "needs-your-input",
     "approval-alert",
     "approval-actions",
-    "multi-monitor",
-    "in-page-overlay",
+    "idle-detection",
+    "auto-dismiss",
     "background-alert",
     "external-notification",
     "webhook",
@@ -55,8 +55,8 @@
     "外部通知",
     "推送提醒",
     "提醒",
-    "副屏提醒",
-    "浮层提醒"
+    "闲置判定",
+    "离开判定"
   ],
   "engines": {
     "node": ">=18"