dsh-reminding 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 liuchaoxu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,204 @@
-# Temporary Holding Version
+<p align="center">
+  <img src="https://raw.githubusercontent.com/liuchaoxu/dsh-reminding/main/icon.svg" width="76" height="76" alt="dsh-reminding icon">
+</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<h1 align="center">dsh-reminding</h1>
+
+<p align="center">
+  DeepSeek Harness 的系统提醒插件：需要你授权、模型提问或回合结束时弹出系统通知，<br>
+  点一下通知，直接回到对应对话。
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/dsh-reminding"><img src="https://img.shields.io/npm/v/dsh-reminding.svg" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/dsh-reminding"><img src="https://img.shields.io/npm/dm/dsh-reminding.svg" alt="npm downloads"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT license"></a>
+  <img src="https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey" alt="Windows, macOS, Linux">
+  <img src="https://img.shields.io/badge/dsh-%3E%3D0.2.1--rc.2-4B32C3" alt="DSH version">
+</p>
+
+---
+
+## 为什么需要它
+
+在 DeepSeek Harness 里，模型经常会停下来等你：一次敏感操作需要你点“允许”，一个问题需要你选择，或者一个回合已经跑完。你切到别的窗口以后，这些时刻很容易被错过。
+
+`dsh-reminding` 把这三类时刻变成**操作系统的系统通知**（Windows 通知中心 / macOS 通知中心 / Linux libnotify），并把「点击通知」接回 Harness：**直接打开产生这条提醒的那个对话**，不需要在侧栏里翻。
+
+- 零依赖：纯 ESM + 浏览器原生 Notification API，没有 npm 运行依赖；
+- 零遥测：不联网、不上报、不写会话日志，提醒只在内存里流转；
+- 零配置即可用：装好就有默认行为，设置页只提供一个总开关、权限状态和测试按钮。
+
+## 提醒时机
+
+插件只读已提交的会话日志（`session/event`），不改变模型行为，也不写任何会话事件：
+
+| 会话事件 | 通知标题 | 说明 |
+| --- | --- | --- |
+| `approval/asked` | 需要你的授权 | 工具调用在等待你允许（沙箱升级、敏感操作等）；400ms 内被机器应答的请求不会误弹 |
+| `ask_user_question` 工具调用 | 模型在等你回答 | 模型提问，或提交计划审阅 |
+| `turn/end` → `completed` | 对话已完成 | 这一轮回复结束；1.2 秒内紧接的后续轮次会自动合并，不会连续轰炸 |
+| `turn/end` → `error` | 生成失败 | 这一轮因错误中断 |
+| `turn/end` → `max-tokens` | 输出被截断 | 达到输出 token 上限 |
+
+- 授权 / 提问被处理（`approval/decided`、对应工具返回结果）后，已经弹出的那条通知会自动关闭；
+- 子代理（subagent）会话不会提醒，避免一次任务被拆成几十条通知；
+- 页面有焦点、且当前地址已经是这条提醒对应的会话时不会弹（你正看着它）；
+- 页面失焦、最小化、或停留在另一个对话里时都会正常提醒。
+
+## 点击跳转
+
+每条提醒都带着会话 ID。点击通知会：
+
+1. 把 Harness 窗口切到前台；
+2. 调用 Client 的 `uiWorkspace.openSession(sessionId)` 打开对应对话。
+
+测试通知只演示弹框，点击它只会聚焦窗口；只有真实提醒才带会话 ID。
+
+## 安装
+
+插件以 bundle 形式发布，`package.json` 的 `dsh.bundle.patch` 会把它挂进当前 profile。
+
+### 方式一：插件页面（推荐）
+
+1. 打开 Harness 侧栏的 **Plugins** 页面；
+2. 在添加/安装入口输入 `dsh-reminding`；
+3. 选择安装，成功后页面通常即时生效；若没有看到新的设置行，刷新一次页面。
+
+### 方式二：CLI（高级）
+
+```bash
+dsh plugin --profile <profile> add dsh-reminding
+```
+
+这条命令把包装进 profile；随后在侧栏 **Plugins** 页面把 `dsh-reminding` 选为启用（bundle 是否加载由 profile 的 `dsh.profile.bundles` 决定，单纯 `pnpm add` 不会自动选中）。
+
+> `desktop` 应用管理的 profile 不允许 CLI 直接改写，请使用插件页面。
+
+### 方式三：本地目录（开发）
+
+使用 agent 的 `plugin_manager` `install_bundle`，target 指向本目录的绝对路径。等效的 CLI 写法是 `dsh plugin --profile <profile> add link:/absolute/path/to/dsh-reminding`，安装后同样需要在 **Plugins** 页面启用。
+
+## 设置
+
+**设置 → 通用 → 系统提醒** 一行：
+
+- **总开关**：关闭后不再弹任何系统通知（保存在浏览器 `localStorage`，按浏览器/设备区分）；
+- **权限状态**：已允许 / 未授权 / 已被阻止 / 不支持；
+- **测试**：发一条测试通知，同时也是浏览器要求的用户手势授权入口。
+
+安装后首次加载会尝试自动授权；桌面端通常直接允许，普通浏览器若要求手势，点一次「测试」即可。
+
+## 平台
+
+### Windows
+
+通知出现在右下角通知中心。Windows 会**按应用**单独拦截通知，且拦截发生在插件之外，插件无从感知。收不到弹框时按顺序检查：
+
+1. **设置 → 系统 → 通知 → DeepSeek Harness**：确认「允许通知」和「显示通知横幅」都打开；
+2. 确认「专注助手 / 勿扰」没有开启；
+3. 回到 设置 → 通用 → 系统提醒，点一次「测试」。
+
+也可以直接看注册表（应用级开关关闭时 `Enabled = 0`，通知会被系统静默丢弃）：
+
+```powershell
+Get-ItemProperty 'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Notifications\Settings\electron.app.DeepSeek Harness'
+```
+
+### macOS
+
+通知出现在通知中心。首次可能需要在 **系统设置 → 通知 → DeepSeek Harness** 里允许；如果之前选过“不允许”，需要在那里重新打开。
+
+### Linux
+
+依赖桌面环境的通知守护进程（libnotify / dunst / GNOME Shell 等）。没有通知服务的精简桌面不会显示弹框。
+
+浏览器访问 `dsh web` 时同样可用，但受浏览器通知权限与站点设置约束。
+
+## 隐私与安全
+
+- **不联网**：插件不发起任何外部请求，也不采集遥测；
+- **只读**：只订阅已提交的 `session/event`，不追加事件、不改会话；
+- **不落盘**：提醒只存在于 Host 进程内存与页面内存，刷新后从当前序号重建基线，不回放旧提醒；
+- **本机路由**：浏览器半边通过 `/reminding/poll` 长轮询取提醒，路由先经过 `ctx.connection.requestRejection` 的浏览器信任栅栏；
+- 通知正文只在本机展示，包含会话标题、工具名或问题文本，不会离开设备。
+
+## 兼容性
+
+| 项 | 要求 |
+| --- | --- |
+| DeepSeek Harness | `>= 0.2.1-rc.2`（`engines.dsh`，插件管理器会在安装前校验） |
+| Node.js | `>= 18` |
+| 运行形态 | DSH 桌面应用、`dsh web` 浏览器访问均可 |
+| 操作系统 | Windows、macOS、Linux |
+
+DSH 版本兼容声明同时写在 `package.json` 的 `dsh.compatibility.dshReleases` 里。
+
+## 开发
+
+仓库没有构建步骤：`index.js` 是 Host 半边，`client.js` 是浏览器半边，都是可直接加载的 ESM / 纯 JS。
+
+```bash
+git clone https://github.com/liuchaoxu/dsh-reminding.git
+cd dsh-reminding
+
+npm run check        # 清单、导出、locale、图标、patch 的一致性检查
+npm test             # Host 事件流 + Client 通知/跳转的功能测试（无需 DSH 进程）
+npm run pack:check   # 查看 npm 实际发布的文件列表
+```
+
+两段测试都使用 Node 内置能力，不联网、不写盘：
+
+- `scripts/test-host.mjs`：模拟 Cordis 上下文，覆盖授权、提问、完成、失败、去抖取消、子代理过滤与长轮询释放；
+- `scripts/test-client.mjs`：加载真实的 `client.js` 工厂，脚本化 Host 响应，断言通知标题/正文与点击后的 `openSession`。
+
+目录：
+
+```text
+.
+├── index.js              # Host 半边：session/event → 提醒流 → /reminding/poll
+├── client.js             # 浏览器半边：长轮询 → 系统通知 → 打开会话
+├── cordis.patch.yml      # bundle patch：插入 dsh-reminding 行
+├── locale/{zh,en}.json   # 插件管理页的标题与描述
+├── icon.svg              # 插件图标
+├── scripts/              # check + 两段功能测试
+└── .github/              # CI、发布工作流、issue 模板
+```
+
+### 发布
+
+1. 更新 `package.json` 的 `version` 与 `CHANGELOG.md`；
+2. 打 tag 并创建 GitHub Release，`Publish to npm` 工作流会用 `NPM_TOKEN` 执行 `npm publish --provenance --access public`（provenance 需要 CI 的 OIDC，因此由工作流完成）；
+3. 也可以在本地执行 `npm publish --access public`（先 `npm login`），但本地产物不带 provenance 证明。
+
+## 常见问题
+
+**设置里没有「系统提醒」这一行？** 安装后刷新一次页面；如果仍未出现，检查 设置 → 插件 里 `dsh-reminding` 是否启用。
+
+**和 dsh-pet 的通知重复？** 两者都提供系统通知。关掉任意一个即可：本插件在 设置 → 通用 → 系统提醒，dsh-pet 在它自己的设置页。
+
+**点击测试通知没有跳转？** 这是预期行为：测试通知没有会话 ID，只会聚焦窗口；真实提醒会打开对应对话。
+
+**窗口关掉后还会提醒吗？** 不会。通知逻辑在页面内，这是“点击跳转”的前提；请保持 Harness 窗口（可以最小化）运行。
+
+## License
+
+[MIT](LICENSE) © 2026 liuchaoxu
+
+---
+
+## English
+
+**System reminders for DeepSeek Harness.** When a tool call is waiting for your approval, the model asks a question (including plan review), or a turn finishes / fails / hits the output limit, the plugin raises an OS notification. Clicking it focuses Harness and opens the exact conversation.
+
+- Cross-platform OS notifications via the standard Notification API (Windows toast, macOS Notification Center, Linux libnotify);
+- Approval and question notifications close themselves once the decision is made;
+- Subagent sessions are ignored; completion is debounced so goal rounds do not spam you;
+- Notifications are suppressed only while you are focused on that very conversation;
+- No dependencies, no network calls, no telemetry, no session-log writes; reminders live in memory only.
+
+Install from the Harness **Plugins** page by entering `dsh-reminding`, or run `dsh plugin --profile <profile> add dsh-reminding` and then enable the bundle on that page. Then find **Settings → General → System reminders** for the master switch, permission state, and a test button.
+
+On Windows, if nothing appears, check **Settings → System → Notifications → DeepSeek Harness** — the OS can disable notifications per app, silently and outside the plugin's control.
+
+Requires DeepSeek Harness `>= 0.2.1-rc.2` and Node.js `>= 18`. MIT licensed.

package/client.js

@@ -0,0 +1,540 @@
+/**
+ * dsh-reminding — browser half.
+ *
+ * Long-polls the Host's `/reminding/poll` feed and turns each item into an OS
+ * notification through the standard Notification API, which is what makes the
+ * same code work on Windows (toast), macOS (Notification Center) and Linux
+ * (libnotify) — the desktop shell and every Chromium-based browser implement
+ * it. Clicking a notification focuses the window and opens the exact
+ * conversation through `ctx.uiWorkspace.openSession(sessionId)`.
+ *
+ * The Settings → General row is the one piece of visible UI: a master switch,
+ * the live permission state, and a test button (the user gesture browsers
+ * require before granting notification permission).
+ *
+ * Notifications are suppressed when the page has focus AND the URL already
+ * shows that conversation, so looking at the answer never produces a redundant
+ * toast; being anywhere else (another conversation, another app) does.
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-reminding',
+  factory(require) {
+    const module = { exports: {} }
+    const exports = module.exports
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+
+    const React = require('react')
+    const h = React.createElement
+
+    /** Locale namespace of every user-visible string in this plugin. */
+    const NS = 'dsh-reminding'
+    /** Host route, document-relative so a directory-mounted GUI still works. */
+    const ROUTE_POLL = 'reminding/poll'
+    /** Where the master switch lives; localStorage keeps it per browser. */
+    const STORAGE_KEY = 'dsh-reminding:settings'
+    /** Longest body line sent to the OS; toasts truncate anyway. */
+    const MAX_BODY = 140
+
+    const zh = {
+      'meta.title': '系统提醒',
+      'settings.title': '系统提醒',
+      'settings.description': '对话需要授权、模型提问或回复完成时弹出系统通知；点击通知直接回到对应对话。',
+      'settings.toggle': '系统通知开关',
+      'settings.test': '测试',
+      'settings.permission.granted': '通知权限：已允许',
+      'settings.permission.default': '通知权限：未授权，点击「测试」完成授权',
+      'settings.permission.denied': '通知权限：已被阻止，请在系统或浏览器设置中允许后刷新',
+      'settings.permission.unsupported': '当前环境不支持系统通知',
+      'settings.testSent': '测试通知已发送，请查看系统通知中心。',
+      'settings.testBlocked': '无法发送：通知权限未授予。',
+      'settings.testFailed': '发送失败：{error}',
+      'notify.approval.title': '需要你的授权',
+      'notify.approval.body': '工具「{tool}」正在等待你的授权',
+      'notify.approval.fallback': '有一步操作正在等待你的授权',
+      'notify.approval.reason': '原因：{reason}',
+      'notify.question.title': '模型在等你回答',
+      'notify.question.body': '模型提出了一个问题，点击回到对话处理。',
+      'notify.question.planReview': '模型提交了计划，等待你的审阅。',
+      'notify.completed.title': '对话已完成',
+      'notify.completed.body': '这一轮回复已经结束，点击回到对话查看。',
+      'notify.error.title': '生成失败',
+      'notify.error.body': '这一轮回复因错误中断。',
+      'notify.maxTokens.title': '输出被截断',
+      'notify.maxTokens.body': '已达到输出 token 上限。',
+      'notify.test.title': '测试通知',
+      'notify.test.body': '通知已开启，点击这条消息可回到对话。',
+      'notify.sessionFallback': '对话',
+    }
+
+    const en = {
+      'meta.title': 'System Reminders',
+      'settings.title': 'System reminders',
+      'settings.description': 'OS notifications when a step needs your approval, the model asks a question, or a turn finishes; click a toast to jump back to that conversation.',
+      'settings.toggle': 'System notification switch',
+      'settings.test': 'Test',
+      'settings.permission.granted': 'Notification permission: allowed',
+      'settings.permission.default': 'Notification permission: not granted yet — press “Test” to allow',
+      'settings.permission.denied': 'Notification permission: blocked — allow it in the system or browser settings, then refresh',
+      'settings.permission.unsupported': 'System notifications are unavailable in this environment',
+      'settings.testSent': 'Test notification sent — check your system notification center.',
+      'settings.testBlocked': 'Cannot send: notification permission is not granted.',
+      'settings.testFailed': 'Send failed: {error}',
+      'notify.approval.title': 'Approval needed',
+      'notify.approval.body': 'Tool “{tool}” is waiting for your approval',
+      'notify.approval.fallback': 'An operation is waiting for your approval',
+      'notify.approval.reason': 'Reason: {reason}',
+      'notify.question.title': 'The model is waiting for you',
+      'notify.question.body': 'The model asked a question — click to open the conversation.',
+      'notify.question.planReview': 'The model submitted a plan for your review.',
+      'notify.completed.title': 'Turn finished',
+      'notify.completed.body': 'This reply is finished — click to open the conversation.',
+      'notify.error.title': 'Generation failed',
+      'notify.error.body': 'This turn stopped with an error.',
+      'notify.maxTokens.title': 'Output truncated',
+      'notify.maxTokens.body': 'The output token limit was reached.',
+      'notify.test.title': 'Test notification',
+      'notify.test.body': 'Notifications are on. Click this message to return to the conversation.',
+      'notify.sessionFallback': 'Conversation',
+    }
+
+    /** Substitute `{name}` placeholders without depending on a translate API. */
+    function fill(template, params) {
+      return String(template).replace(/\{(\w+)\}/g, (match, name) => (
+        params !== undefined && params[name] !== undefined ? String(params[name]) : match
+      ))
+    }
+
+    /** Fallback translator used when the Client locale service is absent. */
+    function fallbackT(key, params) {
+      const template = zh[key] ?? key
+      return params === undefined ? template : fill(template, params)
+    }
+
+    // -----------------------------------------------------------------------
+    // Master switch. Module-level so the polling loop, the settings row and a
+    // plugin reload in the same page all observe one value.
+    let enabled = true
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY)
+      if (raw !== null) {
+        const parsed = JSON.parse(raw)
+        if (parsed !== null && typeof parsed === 'object' && parsed.enabled === false) enabled = false
+      }
+    } catch {
+      enabled = true
+    }
+
+    function persistEnabled(next) {
+      enabled = next
+      try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify({ enabled: next }))
+      } catch {
+        // Private mode or a full quota keeps the in-memory value for this page.
+      }
+    }
+
+    /** The context of the active activation, used by toast click handlers. */
+    let activeContext = null
+
+    // -----------------------------------------------------------------------
+    // Notification plumbing.
+
+    /** Current permission, normalized across browsers and the desktop shell. */
+    function permissionState() {
+      try {
+        if (typeof Notification === 'undefined') return 'unsupported'
+        return Notification.permission
+      } catch {
+        return 'unsupported'
+      }
+    }
+
+    /**
+     * Ask for notification permission. Call from a user gesture when possible;
+     * the desktop shell usually answers without showing a prompt.
+     * @returns the resulting permission state.
+     */
+    async function requestPermission() {
+      const current = permissionState()
+      if (current !== 'default') return current
+      try {
+        return await Notification.requestPermission()
+      } catch {
+        return 'error'
+      }
+    }
+
+    /** Whether the page is visible and holds keyboard focus. */
+    function pageFocused() {
+      try {
+        return document.hasFocus() && document.visibilityState === 'visible'
+      } catch {
+        return false
+      }
+    }
+
+    /** Whether the current URL already shows that conversation. */
+    function viewingSession(sessionId) {
+      if (typeof sessionId !== 'string' || sessionId === '') return false
+      try {
+        return window.location.href.includes(sessionId)
+      } catch {
+        return false
+      }
+    }
+
+    /** Open the conversation that produced one reminder. */
+    function openConversation(sessionId) {
+      try {
+        window.focus()
+      } catch {
+        // A denied focus is cosmetic: the navigation below still happens.
+      }
+      if (typeof sessionId !== 'string' || sessionId === '') return
+      try {
+        activeContext?.get?.('uiWorkspace')?.openSession?.(sessionId)
+      } catch (err) {
+        console.warn('[dsh-reminding] could not open the conversation:', err)
+      }
+    }
+
+    /** Look up one session's title with a defensive read of the Client store. */
+    function sessionTitle(sessionId) {
+      try {
+        const snapshot = activeContext?.get?.('sessions')?.list?.getSnapshot?.()
+        if (snapshot === null || snapshot === undefined) return ''
+        const summary = snapshot.byId?.[sessionId]
+        const direct = summary?.title ?? summary?.name
+        if (typeof direct === 'string' && direct.trim() !== '') return direct.trim()
+        const values = snapshot.projectionsBySession?.[sessionId]?.values
+        const projected = values?.title
+        if (typeof projected === 'string' && projected.trim() !== '') return projected.trim()
+        if (projected !== null && typeof projected === 'object' && typeof projected.title === 'string') {
+          return projected.title.trim()
+        }
+      } catch {
+        // A cold or malformed store only costs the title, never the toast.
+      }
+      return ''
+    }
+
+    /** Trim one body line for the OS notification. */
+    function clip(text) {
+      const value = typeof text === 'string' ? text.trim() : ''
+      return value.length > MAX_BODY ? `${value.slice(0, MAX_BODY)}…` : value
+    }
+
+    /**
+     * Compose the localized title and body of one reminder.
+     * @param t - translate function bound to this plugin's namespace.
+     * @param item - one Host feed item.
+     * @returns `{ title, body }`.
+     */
+    function describe(t, item) {
+      const kind = typeof item?.kind === 'string' ? item.kind : ''
+      const title = sessionTitle(item?.sessionId)
+      const prefix = title === '' ? '' : `【${title}】`
+      const withSession = (text) => `${prefix}${clip(text)}`
+      if (kind === 'approval') {
+        const tool = typeof item.toolName === 'string' ? item.toolName : ''
+        const base = tool === ''
+          ? t('notify.approval.fallback')
+          : fill(t('notify.approval.body'), { tool })
+        const reason = typeof item.reason === 'string' ? item.reason : ''
+        return {
+          title: t('notify.approval.title'),
+          body: withSession(base + (reason === '' ? '' : ` · ${fill(t('notify.approval.reason'), { reason })}`)),
+        }
+      }
+      if (kind === 'question') {
+        const question = typeof item.question === 'string' ? item.question : ''
+        if (question !== '') {
+          return { title: t('notify.question.title'), body: withSession(question) }
+        }
+        return {
+          title: t('notify.question.title'),
+          body: withSession(t(item.planReview === true ? 'notify.question.planReview' : 'notify.question.body')),
+        }
+      }
+      if (kind === 'completed') {
+        return { title: t('notify.completed.title'), body: withSession(t('notify.completed.body')) }
+      }
+      if (kind === 'error') {
+        const message = typeof item.message === 'string' ? item.message : ''
+        return {
+          title: t('notify.error.title'),
+          body: withSession(message === '' ? t('notify.error.body') : message),
+        }
+      }
+      if (kind === 'max-tokens') {
+        return { title: t('notify.maxTokens.title'), body: withSession(t('notify.maxTokens.body')) }
+      }
+      if (kind === 'test') {
+        return { title: t('notify.test.title'), body: t('notify.test.body') }
+      }
+      return null
+    }
+
+    /** Live toasts by feed key, so a resolved approval/question can close its own toast. */
+    const liveToasts = new Map()
+
+    /** Close one toast by its feed key. */
+    function closeToast(key) {
+      const entry = liveToasts.get(key)
+      if (entry === undefined) return
+      liveToasts.delete(key)
+      try {
+        entry.close()
+      } catch {
+        // Already dismissed by the OS: nothing to do.
+      }
+    }
+
+    /**
+     * Show one reminder as an OS notification.
+     * @param t - translate function.
+     * @param item - feed item.
+     * @param options - `force` bypasses the master switch and the focus gate.
+     * @returns true when a notification was actually created.
+     */
+    function showReminder(t, item, options = {}) {
+      if (options.force !== true) {
+        if (!enabled) return false
+        if (pageFocused() && viewingSession(item?.sessionId)) return false
+      }
+      if (permissionState() !== 'granted') return false
+      const copy = describe(t, item)
+      if (copy === null) return false
+      try {
+        const notification = new Notification(copy.title, {
+          body: copy.body,
+          tag: typeof item.key === 'string' ? item.key : undefined,
+        })
+        const key = typeof item.key === 'string' ? item.key : ''
+        if (key !== '') {
+          closeToast(key)
+          liveToasts.set(key, notification)
+        }
+        notification.onclick = () => {
+          openConversation(item?.sessionId)
+          try {
+            notification.close()
+          } catch {
+            // Closing an already dismissed toast is a no-op.
+          }
+          if (key !== '') liveToasts.delete(key)
+        }
+        notification.onclose = () => {
+          if (key !== '') liveToasts.delete(key)
+        }
+        notification.onerror = () => {
+          if (key !== '') liveToasts.delete(key)
+        }
+        return true
+      } catch (err) {
+        console.warn('[dsh-reminding] could not show the notification:', err)
+        return false
+      }
+    }
+
+    /** Sleep helper for reconnect backoff (never used on the fast path). */
+    function delay(ms) {
+      return new Promise((resolve) => {
+        setTimeout(resolve, ms)
+      })
+    }
+
+    /**
+     * Long-poll the Host feed until the plugin is disposed. The next request
+     * starts from the network callback rather than a timer, so a background or
+     * minimized window keeps receiving reminders instead of being throttled.
+     * @param getT - current translate function.
+     * @returns disposal function.
+     */
+    function startFeed(getT) {
+      let stopped = false
+      let controller = null
+      let since = -1
+      let retries = 0
+
+      const handle = (item) => {
+        if (item === null || typeof item !== 'object') return
+        if (item.kind === 'resolved') {
+          closeToast(typeof item.key === 'string' ? item.key : '')
+          return
+        }
+        showReminder(getT(), item)
+      }
+
+      const run = async () => {
+        while (!stopped) {
+          controller = typeof AbortController === 'function' ? new AbortController() : null
+          try {
+            const response = await fetch(`${ROUTE_POLL}?since=${since}&wait=1`, {
+              cache: 'no-store',
+              ...(controller === null ? {} : { signal: controller.signal }),
+            })
+            if (!response.ok) throw new Error(`HTTP ${response.status}`)
+            const payload = await response.json()
+            retries = 0
+            const hostSeq = Number(payload?.seq)
+            if (Number.isFinite(hostSeq) && (since < 0 || hostSeq < since)) since = hostSeq
+            const events = Array.isArray(payload?.events) ? payload.events : []
+            for (const item of events) {
+              const itemSeq = Number(item?.seq)
+              if (Number.isFinite(itemSeq)) since = Math.max(since, itemSeq)
+              handle(item)
+            }
+          } catch (err) {
+            if (stopped) return
+            retries += 1
+            await delay(Math.min(10_000, 750 * retries))
+          }
+        }
+      }
+
+      run()
+      return () => {
+        stopped = true
+        if (controller !== null) controller.abort()
+      }
+    }
+
+    // -----------------------------------------------------------------------
+    // Settings row (Settings → General). The owner passes no props, so the row
+    // draws its own label, state and controls from the injected face.
+
+    const STYLES = [
+      '.dsh-reminding-row { display: flex; align-items: center; justify-content: space-between; gap: 16px; width: 100%; padding: 10px 0; box-sizing: border-box; }',
+      '.dsh-reminding-copy { display: flex; flex-direction: column; gap: 2px; min-width: 0; flex: 1 1 auto; }',
+      '.dsh-reminding-title { font-size: 14px; font-weight: 500; line-height: 22px; color: var(--dsw-alias-label-primary); }',
+      '.dsh-reminding-desc { font-size: 12px; line-height: 18px; color: var(--dsw-alias-label-secondary); }',
+      '.dsh-reminding-note { font-size: 12px; line-height: 18px; color: var(--dsw-alias-label-secondary); }',
+      '.dsh-reminding-message { font-size: 12px; line-height: 18px; color: var(--dsw-alias-state-success-primary); }',
+      '.dsh-reminding-message-error { color: var(--dsw-alias-state-error-primary); }',
+      '.dsh-reminding-controls { display: inline-flex; align-items: center; gap: 10px; flex: 0 0 auto; }',
+      '.dsh-reminding-switch { position: relative; width: 36px; height: 20px; padding: 0; border: 1px solid var(--dsw-alias-border-l2); border-radius: 10px; background: var(--dsw-alias-bg-layer-2); cursor: pointer; transition: background 120ms ease, border-color 120ms ease; }',
+      '.dsh-reminding-switch.is-on { background: var(--dsw-alias-brand-primary); border-color: var(--dsw-alias-brand-primary); }',
+      '.dsh-reminding-knob { position: absolute; top: 1px; left: 1px; width: 16px; height: 16px; border-radius: 50%; background: var(--dsw-alias-bg-base); transition: transform 120ms ease; }',
+      '.dsh-reminding-switch.is-on .dsh-reminding-knob { transform: translateX(16px); }',
+      '.dsh-reminding-switch:focus-visible, .dsh-reminding-test:focus-visible { outline: 2px solid var(--dsw-alias-brand-primary); outline-offset: 2px; }',
+      '.dsh-reminding-test { height: 28px; padding: 0 12px; border: 1px solid var(--dsw-alias-border-l2); border-radius: 8px; background: transparent; color: var(--dsw-alias-label-primary); font-size: 12px; line-height: 18px; cursor: pointer; }',
+      '.dsh-reminding-test:hover { background: var(--dsw-alias-bg-layer-2); }',
+    ].join('\n')
+
+    /** Settings → General → one row: master switch, permission state, test. */
+    function RemindingSettings(props) {
+      const t = typeof props?.t === 'function' ? props.t : fallbackT
+      const [isEnabled, setIsEnabled] = React.useState(enabled)
+      const [permission, setPermission] = React.useState(permissionState)
+      const [message, setMessage] = React.useState('')
+
+      React.useEffect(() => {
+        const refresh = () => setPermission(permissionState())
+        window.addEventListener('focus', refresh)
+        document.addEventListener('visibilitychange', refresh)
+        return () => {
+          window.removeEventListener('focus', refresh)
+          document.removeEventListener('visibilitychange', refresh)
+        }
+      }, [])
+
+      const toggle = async () => {
+        const next = !isEnabled
+        setIsEnabled(next)
+        persistEnabled(next)
+        setMessage('')
+        if (next) setPermission(await requestPermission())
+      }
+
+      const test = async () => {
+        setMessage('')
+        const granted = await requestPermission()
+        setPermission(granted)
+        if (granted !== 'granted') {
+          setMessage(t(granted === 'unsupported' ? 'settings.permission.unsupported' : 'settings.testBlocked'))
+          return
+        }
+        if (!enabled) {
+          persistEnabled(true)
+          setIsEnabled(true)
+        }
+        const sent = showReminder(t, { kind: 'test', key: `test:${Date.now()}`, sessionId: '' }, { force: true })
+        setMessage(sent ? t('settings.testSent') : t('settings.testFailed', { error: 'Notification' }))
+      }
+
+      const permissionText = permission === 'granted'
+        ? t('settings.permission.granted')
+        : permission === 'denied'
+          ? t('settings.permission.denied')
+          : permission === 'unsupported'
+            ? t('settings.permission.unsupported')
+            : t('settings.permission.default')
+
+      return h('div', { className: 'dsh-reminding-row' },
+        h('style', { 'data-plugin-css': 'dsh-reminding/styles', dangerouslySetInnerHTML: { __html: STYLES } }),
+        h('div', { className: 'dsh-reminding-copy' },
+          h('div', { className: 'dsh-reminding-title' }, t('settings.title')),
+          h('div', { className: 'dsh-reminding-desc' }, t('settings.description')),
+          h('div', { className: 'dsh-reminding-note' }, permissionText),
+          message === '' ? null : h('div', {
+            className: `dsh-reminding-message${permission === 'granted' ? '' : ' dsh-reminding-message-error'}`,
+          }, message),
+        ),
+        h('div', { className: 'dsh-reminding-controls' },
+          h('button', {
+            type: 'button',
+            role: 'switch',
+            'aria-checked': isEnabled,
+            'aria-label': t('settings.toggle'),
+            title: t('settings.toggle'),
+            className: `dsh-reminding-switch${isEnabled ? ' is-on' : ''}`,
+            onClick: () => { void toggle() },
+          }, h('span', { className: 'dsh-reminding-knob' })),
+          h('button', {
+            type: 'button',
+            className: 'dsh-reminding-test',
+            onClick: () => { void test() },
+          }, t('settings.test')),
+        ),
+      )
+    }
+
+    /**
+     * Activate the browser half.
+     * @param ctx - Client plugin context.
+     */
+    function apply(ctx) {
+      activeContext = ctx
+
+      const locale = typeof ctx.get === 'function' ? ctx.get('locale') : undefined
+      let t = fallbackT
+      if (locale !== undefined && typeof locale.register === 'function' && typeof locale.bind === 'function') {
+        ctx.effect(() => locale.register(NS, { zh, en }), 'dsh-reminding: dictionaries')
+        t = locale.bind(NS)
+      }
+
+      // Keep the feed alive for the whole page lifetime, independent of the
+      // Settings panel: reminders must arrive with the panel closed.
+      ctx.effect(() => startFeed(() => t), 'dsh-reminding: notification feed')
+
+      // Grant once at boot when the environment answers without a prompt; a
+      // browser that requires a gesture will grant from the Test button.
+      if (enabled && permissionState() === 'default') {
+        void requestPermission()
+      }
+
+      ctx.slots.inject('settings.general.item', () => ctx.slots.register({
+        name: 'settings.general.item',
+        id: 'dsh-reminding',
+        order: 25,
+        locale: NS,
+        inject: () => ({ t }),
+      }, RemindingSettings))
+    }
+
+    exports.apply = apply
+    exports.inject = ['slots']
+    return module.exports
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,14 @@
+# dsh-reminding bundle patch.
+#
+# The Host half follows the Session log (approval asks, user questions and turn
+# ends) and serves them to the browser half over a loopback Web route; the
+# browser half turns them into OS notifications and opens the matching
+# conversation when a toast is clicked. The browser half is discovered from
+# this row's `dsh.client` declaration in package.json.
+#
+# No Config schema is declared, so the row stays trivially overridable from a
+# user patch layer.
+- insert:
+    - id: dsh-reminding
+      name: 'dsh-reminding'
+      config: {}

package/icon.svg

@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Reminder bell">
+  <defs>
+    <linearGradient id="bell" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0" stop-color="#63a8ff"/>
+      <stop offset="1" stop-color="#2563eb"/>
+    </linearGradient>
+  </defs>
+  <rect x="3" y="3" width="58" height="58" rx="15" fill="#eef4ff"/>
+  <path d="M32 13c-7.2 0-12.4 5.3-12.4 12.4v7.4l-4.2 6.3c-.6.9 0 2.1 1.1 2.1h31c1.1 0 1.7-1.2 1.1-2.1l-4.2-6.3v-7.4C44.4 18.3 39.2 13 32 13Z" fill="url(#bell)"/>
+  <path d="M32 53.5c2.9 0 5.1-1.9 5.5-4.6H26.5c.4 2.7 2.6 4.6 5.5 4.6Z" fill="#1d4ed8"/>
+  <circle cx="46.5" cy="17.5" r="6.5" fill="#ef4444"/>
+  <circle cx="46.5" cy="17.5" r="2.6" fill="#fef2f2"/>
+</svg>

package/index.js

@@ -0,0 +1,356 @@
+/**
+ * dsh-reminding — Host half.
+ *
+ * Watches the committed Session log and republishes the three moments a user
+ * may be away for:
+ *
+ * - `approval/asked` — a sensitive tool call is waiting for a permission
+ *   decision (`approval/decided` closes it again),
+ * - an `ask_user_question` tool call — the model asked a structured question
+ *   (or a plan review) and is waiting for the answer (`tool/result` closes it),
+ * - `turn/end` with `completed` / `error` / `max-tokens` — the reply settled.
+ *   Completion is debounced briefly so a goal round or an immediately
+ *   following turn does not produce one toast per turn.
+ *
+ * Subagent sessions are ignored: they belong to their parent, and notifying
+ * for every delegated step would bury the user in toasts.
+ *
+ * Delivery is a loopback Web route the browser half long-polls. Every item
+ * carries its `sessionId`, which is what makes a toast click open the exact
+ * conversation. The route applies the composition's own browser-trust fence
+ * through `ctx.connection.requestRejection`, like the shipped browser-facing
+ * routes, so a request from an unaccepted authority gets the same 401/403.
+ *
+ * Everything is derived from the log; nothing is persisted. A page reload
+ * starts a fresh baseline and never replays old reminders.
+ */
+
+export const inject = ['webServer']
+
+/** Loopback route the browser half long-polls. */
+const ROUTE_POLL = '/reminding/poll'
+/** How many feed items stay available for a briefly disconnected page. */
+const MAX_FEED = 80
+/** How long one poll is held open before an empty answer releases it. */
+const MAX_WAIT_MS = 25_000
+/** Completion debounce: a follow-up turn inside this window cancels the toast. */
+const COMPLETION_DEBOUNCE_MS = 1_200
+/**
+ * Approval confirmation delay: an ask closed by a machine answerer or an
+ * immediate cancellation is no longer a human decision worth a toast.
+ */
+const APPROVAL_NOTIFY_DELAY_MS = 400
+/** The tool whose call means "the model is waiting for the user's answer". */
+const USER_QUESTION_TOOL = 'ask_user_question'
+
+/**
+ * Whether one session should produce reminders. A delegated child session is
+ * filtered out so its steps do not notify on behalf of the same conversation.
+ * @param session - the session whose log grew.
+ * @returns true for a user-facing (root) session.
+ */
+function shouldNotifySession(session) {
+  const header = session?.header
+  if (header === null || typeof header !== 'object') return true
+  if (header.origin === 'subagent') return false
+  const depth = header.delegationDepth
+  if (typeof depth === 'number' && Number.isFinite(depth) && depth > 0) return false
+  return true
+}
+
+/**
+ * Parse the `questions` array of one `ask_user_question` call.
+ * @param raw - the tool call's JSON argument string.
+ * @returns the declared questions, or an empty array when unreadable.
+ */
+function parseQuestions(raw) {
+  if (typeof raw !== 'string' || raw === '') return []
+  try {
+    const parsed = JSON.parse(raw)
+    const questions = parsed?.questions
+    return Array.isArray(questions) ? questions : []
+  } catch {
+    return []
+  }
+}
+
+/** Write one JSON response with no caching. */
+function writeJson(res, value) {
+  res.writeHead(200, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+  })
+  res.end(JSON.stringify(value))
+}
+
+/**
+ * Apply the composition's browser-trust fence to one request. `node:http`
+ * routes are unauthenticated by construction, so every route owner decides;
+ * this mirrors the shipped browser-facing routes and answers 401/403 itself.
+ * @param ctx - host context, with the optional `connection` service.
+ * @param req - incoming request.
+ * @param res - response to answer on when rejected.
+ * @returns true when the request was already answered and the handler must stop.
+ */
+function rejected(ctx, req, res) {
+  let rejection
+  try {
+    rejection = ctx.get?.('connection')?.requestRejection?.(req)
+  } catch {
+    rejection = undefined
+  }
+  if (rejection === undefined) return false
+  res.statusCode = rejection
+  res.end()
+  return true
+}
+
+/**
+ * Mount the reminder feed.
+ * @param ctx - host context with `webServer`.
+ */
+export function apply(ctx) {
+  let seq = 0
+  let disposed = false
+  /** Published feed items, oldest first. */
+  const feed = []
+  /** Long-poll waiters: `{ since, flush(), cancel() }`. */
+  const waiters = new Set()
+  /** Per-session pending completion timers. */
+  const completionTimers = new Map()
+  /** Pending approval toasts, keyed by approval request id. */
+  const approvalTimers = new Map()
+
+  /**
+   * Append one item to the feed and release every waiter that now has news.
+   * @param item - event payload; `kind`, `sessionId` and `key` are the contract.
+   */
+  function publish(item) {
+    if (disposed) return
+    seq += 1
+    const entry = { seq, at: Date.now(), ...item }
+    feed.push(entry)
+    if (feed.length > MAX_FEED) feed.splice(0, feed.length - MAX_FEED)
+    for (const waiter of [...waiters]) {
+      try {
+        waiter.flush()
+      } catch (err) {
+        // A waiter whose socket vanished must not break the event fold.
+        console.error('[dsh-reminding] failed to release a poll waiter:', err)
+        waiter.cancel()
+      }
+    }
+  }
+
+  /**
+   * Hold one poll open until there is something newer than `since`.
+   * @param req - waiting request (its close cancels the wait).
+   * @param res - response to answer on.
+   * @param since - last sequence the page has already processed.
+   */
+  function hold(req, res, since) {
+    let settled = false
+    const waiter = {}
+    const finish = (events) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      waiters.delete(waiter)
+      try {
+        writeJson(res, { seq, events })
+      } catch {
+        // The page navigated away while the answer was in flight.
+      }
+    }
+    const timer = setTimeout(() => finish([]), MAX_WAIT_MS)
+    if (typeof timer.unref === 'function') timer.unref()
+    waiter.flush = () => {
+      const events = feed.filter((entry) => entry.seq > since)
+      if (events.length > 0) finish(events)
+    }
+    waiter.cancel = () => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      waiters.delete(waiter)
+    }
+    waiters.add(waiter)
+    req.once('close', waiter.cancel)
+    res.once('close', waiter.cancel)
+  }
+
+  /** Cancel a scheduled completion toast for one session. */
+  function cancelCompletion(sessionId) {
+    const timer = completionTimers.get(sessionId)
+    if (timer === undefined) return
+    clearTimeout(timer)
+    completionTimers.delete(sessionId)
+  }
+
+  /**
+   * Schedule the completion reminder for one settled turn; a new turn or a new
+   * user message inside the debounce window cancels it.
+   * @param sessionId - the settled conversation.
+   * @param turn - the turn that ended.
+   */
+  function scheduleCompletion(sessionId, turn) {
+    cancelCompletion(sessionId)
+    const timer = setTimeout(() => {
+      completionTimers.delete(sessionId)
+      publish({ kind: 'completed', key: `turn:${sessionId}:${turn}`, sessionId, turn })
+    }, COMPLETION_DEBOUNCE_MS)
+    if (typeof timer.unref === 'function') timer.unref()
+    completionTimers.set(sessionId, timer)
+  }
+
+  /**
+   * Fold one committed session event into feed items. Everything here reads
+   * only documented event payloads; an unexpected shape is contained so a
+   * reminder can never break the session append that produced it.
+   * @param session - the session whose log grew.
+   * @param event - the committed event.
+   */
+  function onSessionEvent(session, event) {
+    try {
+      if (disposed) return
+      if (!shouldNotifySession(session)) return
+      const sessionId = String(session?.header?.id ?? session?.id ?? '')
+      if (sessionId === '') return
+      const data = event?.data ?? {}
+      switch (event?.type) {
+        case 'approval/asked': {
+          const approvalId = String(data.id ?? '')
+          if (approvalId === '') break
+          const timer = setTimeout(() => {
+            approvalTimers.delete(approvalId)
+            publish({
+              kind: 'approval',
+              key: `approval:${approvalId}`,
+              sessionId,
+              toolName: typeof data.toolName === 'string' ? data.toolName : '',
+              reason: typeof data.reason === 'string' ? data.reason : '',
+            })
+          }, APPROVAL_NOTIFY_DELAY_MS)
+          if (typeof timer.unref === 'function') timer.unref()
+          approvalTimers.set(approvalId, timer)
+          break
+        }
+        case 'approval/decided': {
+          const approvalId = String(data.id ?? '')
+          const timer = approvalTimers.get(approvalId)
+          if (timer !== undefined) {
+            clearTimeout(timer)
+            approvalTimers.delete(approvalId)
+          }
+          publish({
+            kind: 'resolved',
+            key: `approval:${approvalId}`,
+            sessionId,
+            outcome: typeof data.outcome === 'string' ? data.outcome : '',
+          })
+          break
+        }
+        case 'tool/call': {
+          if (data.name !== USER_QUESTION_TOOL) return
+          const questions = parseQuestions(data.arguments)
+          if (questions.length === 0) return
+          const first = questions[0] ?? {}
+          const callId = String(data.callId ?? '')
+          if (callId === '') return
+          publish({
+            kind: 'question',
+            key: `question:${callId}`,
+            sessionId,
+            callId,
+            question: typeof first.question === 'string' ? first.question : '',
+            header: typeof first.header === 'string' ? first.header : '',
+            count: questions.length,
+            planReview: first?.intent?.kind === 'plan-review',
+          })
+          break
+        }
+        case 'tool/result': {
+          const callId = String(data?.message?.toolCallId ?? '')
+          if (callId === '') return
+          publish({ kind: 'resolved', key: `question:${callId}`, sessionId })
+          break
+        }
+        case 'turn/start':
+        case 'user/message': {
+          cancelCompletion(sessionId)
+          break
+        }
+        case 'turn/end': {
+          const reason = data.reason ?? {}
+          if (reason.kind === 'completed') {
+            scheduleCompletion(sessionId, data.turn)
+          } else if (reason.kind === 'error') {
+            publish({
+              kind: 'error',
+              key: `turn:${sessionId}:${String(data.turn ?? '')}:error`,
+              sessionId,
+              message: typeof reason?.error?.message === 'string' ? reason.error.message : '',
+            })
+          } else if (reason.kind === 'max-tokens') {
+            publish({
+              kind: 'max-tokens',
+              key: `turn:${sessionId}:${String(data.turn ?? '')}:max`,
+              sessionId,
+            })
+          }
+          break
+        }
+        default:
+          break
+      }
+    } catch (err) {
+      console.error('[dsh-reminding] failed to fold a session event:', err)
+    }
+  }
+
+  ctx.on('session/event', onSessionEvent)
+  ctx.on('agent/disposed', (payload) => {
+    const id = payload?.agent?.id
+    if (id !== undefined) cancelCompletion(String(id))
+  })
+
+  ctx.effect(() => {
+    disposed = false
+    return () => {
+      disposed = true
+      for (const timer of completionTimers.values()) clearTimeout(timer)
+      completionTimers.clear()
+      for (const timer of approvalTimers.values()) clearTimeout(timer)
+      approvalTimers.clear()
+      for (const waiter of [...waiters]) waiter.cancel()
+      waiters.clear()
+    }
+  }, 'dsh-reminding: lifecycle')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: ROUTE_POLL,
+    handler: (req, res) => {
+      if (rejected(ctx, req, res)) return
+      let since = -1
+      let wait = true
+      try {
+        const url = new URL(req.url ?? '/', 'http://127.0.0.1')
+        const raw = Number(url.searchParams.get('since'))
+        if (Number.isFinite(raw)) since = Math.trunc(raw)
+        wait = url.searchParams.get('wait') !== '0'
+      } catch {
+        since = -1
+      }
+      // A negative `since` is the initial handshake: report the current
+      // sequence without replaying anything a freshly loaded page never saw.
+      // `wait=0` is a non-blocking snapshot, used by diagnostics and tests.
+      const backlog = since < 0 ? [] : feed.filter((entry) => entry.seq > since)
+      if (since < 0 || backlog.length > 0 || since > seq || !wait) {
+        writeJson(res, { seq, events: backlog })
+        return
+      }
+      hold(req, res, since)
+    },
+  }), 'dsh-reminding: /reminding/poll')
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "System Reminders",
+    "description": "OS notifications when a step needs your approval, the model asks a question, or a turn finishes; click a toast to jump back to that conversation. Works on Windows, macOS and Linux."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "系统提醒",
+    "description": "对话需要授权、模型提问或回复完成时弹出系统通知；点击通知直接回到对应对话。支持 Windows / macOS / Linux。"
+  }
+}

package/package.json

@@ -1,6 +1,89 @@
 {
   "name": "dsh-reminding",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "System reminders for DeepSeek Harness: OS notifications when a step needs your approval, the model asks a question, or a turn finishes; click a toast to jump back to that conversation. Works on Windows, macOS and Linux.",
+  "license": "MIT",
+  "author": "liuchaoxu <ischaoxu@163.com>",
+  "homepage": "https://github.com/liuchaoxu/dsh-reminding#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/liuchaoxu/dsh-reminding.git"
+  },
+  "bugs": {
+    "url": "https://github.com/liuchaoxu/dsh-reminding/issues"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "deepseek",
+    "cordis",
+    "cordis-plugin",
+    "notification",
+    "notifications",
+    "desktop-notification",
+    "system-notification",
+    "toast",
+    "reminder",
+    "approval",
+    "user-question",
+    "turn-completed",
+    "cross-platform",
+    "windows",
+    "macos",
+    "linux"
+  ],
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18",
+    "dsh": ">=0.2.1-rc.2"
+  },
+  "scripts": {
+    "check": "node scripts/check.mjs",
+    "test": "node scripts/test-host.mjs && node scripts/test-client.mjs",
+    "test:host": "node scripts/test-host.mjs",
+    "test:client": "node scripts/test-client.mjs",
+    "pack:check": "npm pack --dry-run",
+    "prepublishOnly": "npm run check && npm test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "manifestVersion": 1,
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "compatibility": {
+      "dshReleases": {
+        "0.2.1-rc.2": "compatible"
+      }
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-locale"
+      ]
+    }
+  }
+}