my-opencode-toolkit 0.2.2 → 0.2.4

package/README.md

@@ -1,6 +1,35 @@
 # my-opencode-toolkit
 
-OpenCode 插件：系统通知、持久目标、定时任务与循环、TUI 状态面板。
+[![ci](https://github.com/1cyberlangke1/my-opencode-toolkit/actions/workflows/ci.yml/badge.svg)](https://github.com/1cyberlangke1/my-opencode-toolkit/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/my-opencode-toolkit)](https://www.npmjs.com/package/my-opencode-toolkit)
+
+OpenCode v2 插件：系统通知、持久目标、定时任务与循环、TUI 状态面板。
+
+## 要求
+
+- OpenCode `2.x`
+- Node `>= 20`（OpenCode 自带 Bun 运行时，插件本身也用 Node API）
+- Windows / macOS / Linux
+
+## 安装
+
+在全局或项目级 `opencode.json` 里把包名加进 **`plugins`** 数组（注意是 `plugins`，不是 `plugin`）：
+
+```json
+{
+  "plugins": ["my-opencode-toolkit"]
+}
+```
+
+本地开发时可以直接指向目录：
+
+```json
+{
+  "plugins": ["D:\\Git_Repository\\my-opencode-toolkit"]
+}
+```
+
+重启 OpenCode 后生效。TUI 面板和 `/my-opencode-toolkit` 设置菜单由包内的 `tui` 入口提供，不需要额外配置。
 
 ## 功能
 
@@ -8,15 +37,17 @@ OpenCode 插件：系统通知、持久目标、定时任务与循环、TUI 状
 
 - 会话空闲（任务完成）、权限请求（`permission.asked`）、代理提问（`question` 工具）三种通知
 - 平台：Windows toast（PowerShell）、macOS（osascript）、Linux（notify-send）
-- 标题带会话名，正文按设置语言本地化，长度截断避免 toast 溢出
+- 标题带会话名；正文按设置语言本地化；完成通知附带最后一条用户/助手文本
+- 通知是尽力而为：系统关闭通知、专注助手拦截或缺少对应命令时静默跳过，不影响会话
 
 ### 持久目标（Goal）
 
 - 工具：`create_goal`、`get_goal`、`update_goal`
 - 命令：`/goal <objective>`、`/goal pause|resume|clear|edit`、裸 `/goal` 查看
-- 目标 active 时会话空闲自动注入续作提示；同一原因连续 3 次阻塞才标记 `blocked`
+- 目标 active 时会话空闲自动注入续作提示；同一阻塞原因连续 3 次才标记 `blocked`
 - 记账：每步的输入、输出、缓存读写都计入；达到 token 预算自动转 `budget_limited`
 - 用户打断自动暂停；余额不足暂停并锁死，需显式 `/goal resume`
+- 子代理会话看不到 goal 工具，也不会被注入续作
 
 ### 定时任务与循环
 
@@ -26,88 +57,127 @@ OpenCode 插件：系统通知、持久目标、定时任务与循环、TUI 状
   - `/cron once <expr> <prompt>` 一次性任务
   - `/cron list`、`/cron delete <id>`
   - `/loop [interval] [prompt]` 启动循环，`/loop stop` 停止
-- 5 字段 cron（本地时区），支持 `*`、步进、范围、列表；每会话上限 50；重复任务 7 天过期
+- 5 字段 cron（本地时区）：`分 时 日 月 周`
+  - 支持 `*`、步进 `*/n`、范围 `a-b`、范围步进 `a-b/n`、列表 `a,b`
+  - 周字段 `0` 和 `7` 都表示周日
+  - 下一次触发在四年窗口内搜索，支持 `2 月 29 日`；永远不存在的日期会被拒绝
+- 每会话最多 50 个任务；重复任务 7 天后自动过期
 - durable 任务存插件存储，重启恢复并重新武装 timer；非 durable 只留内存
+- 循环只存在内存，重启后消失；需要跨重启请用 cron
 - 循环：固定间隔或动态（模型用 `schedule_wakeup` 决定下次，60–3600 秒，20 分钟兜底）
-- 裸 `/loop` 使用内置维护提示词；项目根目录有非空 `loop.md` 时优先用它
+- 固定间隔范围 60 秒 – 7 天；裸 `/loop` 使用内置维护提示词，项目根目录有非空 `loop.md` 时优先用它
+
+#### 触发语义
+
+- 任务只在会话空闲时注入；会话忙或末条是用户输入时**顺延重试**，不会静默丢失
+- 功能关闭或目标进行中时任务让路，同样只顺延、不消费；重新开启后一分钟内恢复
+- 重启后已过点的任务会补触发一次，不会把错过的每个时间点都补一遍
+- 重复任务错过的时间点只补一次；一次性任务会一直重试到成功注入或会话被删除
 
 ### TUI 面板
 
 - 侧栏显示目标、缓存命中率、工具使用 Top3、子代理数量、循环与定时任务数量
-- 统计不单独存一份：每个会话第一次打开面板时，从 OpenCode 已存消息（`session.context`）重建一次，
-  之后用事件增量维护；插件重载或进程重启后再重建
-- 设置项可控制显示内容与折叠
-- `/my-opencode-toolkit` 打开设置菜单：启用、语言、通知、Goal、定时任务、侧栏
+- 统计不单独存一份：每个会话第一次打开面板时，从 OpenCode 已存消息（`session.context`）重建
+- 设置菜单：`/my-opencode-toolkit`，可热改语言、通知、Goal、定时任务与侧栏显示项
+- 设置写入失败会回滚本地显示
+
+## 命令与工具
+
+| 命令 | 作用 |
+|---|---|
+| `/my-opencode-toolkit` | 打开设置菜单（TUI） |
+| `/goal <objective>` | 设置/覆盖当前会话的持久目标 |
+| `/goal` | 查看当前目标 |
+| `/goal pause` / `resume` / `clear` / `edit` | 暂停 / 恢复 / 清除 / 编辑目标 |
+| `/cron <expr> <prompt>` | 创建重复任务 |
+| `/cron once <expr> <prompt>` | 创建一次性任务 |
+| `/cron list` | 列出任务 |
+| `/cron delete <id>` | 删除任务 |
+| `/loop [interval] [prompt]` | 启动循环；不带间隔为 dynamic 模式 |
+| `/loop stop` | 停止当前会话全部循环 |
+
+| 工具 | 作用 |
+|---|---|
+| `toolkit_ping` | 返回插件是否启用与当前语言，用于验证加载 |
+| `create_goal` / `get_goal` / `update_goal` | 目标读写与完成/阻塞标记 |
+| `cron_create` / `cron_list` / `cron_delete` | 定时任务管理 |
+| `schedule_wakeup` | dynamic 循环的下次唤醒时间 |
 
-### 子代理隔离
+## 设置
 
-子代理会话里不会出现 goal / scheduling 工具，也不会收到任何续作或定时注入。
-实现方式是在 `context` 钩子里从工具表删除，并在注入前检查 `session.parentID`。
+设置存在 OpenCode 插件存储里，通过 TUI 菜单修改；插件 `options` 只在首次运行时作为初始值。
 
-## 安装
+| 字段 | 默认 | 说明 |
+|---|---|---|
+| `lang` | `auto` | `auto` / `zh` / `en` |
+| `enabled` | `true` | 插件总开关；关闭后隐藏工具、停止注入与通知 |
+| `notification.enabled` | `true` | 通知总开关 |
+| `notification.onComplete` | `true` | 会话完成通知 |
+| `notification.onQuestion` | `true` | 代理提问通知 |
+| `notification.onPermission` | `true` | 权限请求通知 |
+| `notification.onlyMainSession` | `true` | 只通知主会话，忽略子代理 |
+| `goal.enabled` | `true` | 持久目标功能 |
+| `scheduling.enabled` | `true` | 定时任务与循环功能 |
+| `sidebar.enabled` | `true` | 侧栏面板 |
+| `sidebar.showCache` | `true` | 显示缓存命中率 |
+| `sidebar.showTools` | `true` | 显示工具使用 Top3 |
+| `sidebar.showSubagents` | `true` | 显示子代理数量 |
+| `sidebar.collapsed` | `false` | 折叠侧栏内容 |
 
-在 `~/.config/opencode/opencode.json` 的 `plugins` 数组里加包名：
+## 数据与隐私
 
-```jsonc
-{
-  "plugins": ["my-opencode-toolkit"]
-}
-```
+- 目标、任务、设置都写在 OpenCode 的插件存储里，不额外建数据库
+- 通知预览会读取当前会话最后一条用户/助手文本，只用于本地系统通知
+- 不发送任何遥测；不访问网络（通知命令与 OpenCode 自身除外）
+- 删除会话时会清掉该会话的 goal、定时任务、循环、统计与角色缓存
 
-本地开发可以直接指向仓库目录：
+## 已知限制
 
-```jsonc
-{
-  "plugins": ["D:\\Git_Repository\\my-opencode-toolkit"]
-}
-```
+- 侧栏统计是进程内数据：重启后第一次打开面板会从已存消息重建（重建瞬间完成的一步可能漏算）
+- 通知依赖系统命令：Windows 用 PowerShell toast，macOS 用 `osascript`，Linux 用 `notify-send`
+- 定时任务按 OpenCode 进程的本地时区解析；不支持秒级字段与 `L` / `W` / `?` 等扩展语法
+- 夏令时切换当天，本地时间的 cron 可能跳过或重复一次（标准 cron 语义的固有问题）
+- 同一会话不要同时开多个 OpenCode 实例执行目标/定时任务；插件存储没有跨进程锁
+- 目标进行中时 cron/loop 让路，避免和续作抢同一轮对话
+- 子代理会话不提供 goal/scheduling 工具，也不会被注入续作
 
-重启 OpenCode 后生效。
+## 排障
 
-要求 Node 20+；Windows 通知走 PowerShell toast，macOS 走 `osascript`，Linux 走 `notify-send`。
+**插件没加载**
 
-## 设置
+1. 确认 `opencode.json` 用的是 `plugins` 数组，且包名拼写正确
+2. 跑 `opencode plugin list` 看是否列出 `my-opencode-toolkit`
+3. 重启 OpenCode；已存在的会话不会重建工具表，建议新开会话验证
 
-设置存在插件存储里，首次启动用默认值；通过 `/my-opencode-toolkit` 菜单修改，立即生效。
+**TUI 没有侧栏/设置菜单**
 
-| 字段 | 默认 | 说明 |
-|---|---|---|
-| `lang` | `auto` | `auto` / `zh` / `en` |
-| `enabled` | `true` | 插件总开关 |
-| `notification.enabled` | `true` | 通知总开关 |
-| `notification.onComplete` | `true` | 任务完成通知 |
-| `notification.onQuestion` | `true` | 提问通知 |
-| `notification.onPermission` | `true` | 权限通知 |
-| `notification.onlyMainSession` | `true` | 跳过子代理会话 |
-| `goal.enabled` | `true` | Goal 功能 |
-| `scheduling.enabled` | `true` | 定时任务与循环 |
-| `sidebar.enabled` | `true` | 侧栏面板 |
-| `sidebar.showCache` | `true` | 显示缓存命中 |
-| `sidebar.showTools` | `true` | 显示工具统计 |
-| `sidebar.showSubagents` | `true` | 显示子代理数量 |
-| `sidebar.collapsed` | `false` | 折叠侧栏 |
+- TUI 插件只在交互式 TUI 里加载；`opencode run` 不渲染侧栏
+- 确认包内 `tui.ts`（或 npm 包的 `./tui` 导出）存在
+- 重启 TUI；插件热重载不会重放已注册的 slot
 
-## 优先级
+**没有系统通知**
 
-会话空闲时：Goal active > 定时任务 / 循环。Goal 进行中，定时任务到点只重排不注入。
+- 检查系统通知权限与专注助手
+- Windows 确认 `powershell.exe` 在 PATH；macOS 确认 `osascript`；Linux 确认 `notify-send`
+- 用 `toolkit_ping` 确认插件本身已加载
 
-## 已知限制
+**定时任务没触发**
 
-- 侧栏统计是进程内数据：重启后第一次打开面板会从已存消息重建（重建瞬间完成的一步可能漏算）。
-- 通知是尽力而为：系统关闭通知、专注助手拦截或缺少对应命令时静默跳过，不影响会话。
-- 续作与定时注入只在主会话生效；子代理会话既看不到相关工具，也不会被注入。
-- 定时任务按本地时区解析 5 字段 cron，不支持秒级字段。
+- 检查会话是否长期处于目标 active 状态（会主动让路）
+- 检查任务是否已超过 7 天过期
+- 检查时区：cron 按本地时区解析
+- 用 `/cron list` 确认任务还在
 
 ## 开发
 
 ```bash
 pnpm install
-pnpm check        # typecheck + lint + 单测 + TUI 渲染测试
-pnpm test:e2e     # 隔离环境启动真实 opencode，假 provider 驱动工具调用
+pnpm check        # typecheck + lint + 175 单测 + TUI 测试 + 发布包内容校验
+pnpm test:e2e     # 需要本机 opencode 2.x 与 bun，使用隔离的 HOME/DB/config
 ```
 
-要求 Node 20+（OpenCode v2 要求），测试用 vitest + bun。
+e2e 用假 provider 驱动工具调用，不会请求真实模型；它会在临时目录里启动一个隔离的 OpenCode server，不读写日常数据。
 
-## License
+## 许可证
 
-MIT，见 [LICENSE](LICENSE)。
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-opencode-toolkit",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "OpenCode 插件：系统通知、持久目标、定时任务与 TUI 面板",
   "type": "module",
   "license": "MIT",
@@ -45,7 +45,8 @@
   "scripts": {
     "typecheck": "tsc --noEmit",
     "lint": "eslint .",
-    "check": "pnpm typecheck && pnpm lint && pnpm test && pnpm test:tui",
+    "check": "pnpm typecheck && pnpm lint && pnpm test && pnpm test:tui && pnpm check:package",
+    "check:package": "node scripts/check-package.mjs",
     "test": "vitest run",
     "test:tui": "cd tui-test && bun test",
     "test:e2e": "bun scripts/e2e-load.mjs",

package/src/goal/command.ts

@@ -70,8 +70,11 @@ export async function registerGoalCommand(
       description: DESCRIPTION,
       execute: async (input) => {
         const settings = await loadSettings(ctx.storage)
+        const parsed = parseGoalCommand(input.prompt.text)
+        // clear / show 是清理与查看，功能关闭时也允许，避免目标被永久锁在存储里。
+        const readOnly = parsed.kind === "clear" || parsed.kind === "show"
         const text =
-          settings.enabled && settings.goal.enabled
+          (settings.enabled && settings.goal.enabled) || readOnly
             ? await applyGoalCommand(controller, continuation, input.sessionID, input.prompt.text)
             : "Error: the goal feature is disabled in settings."
         // /goal 只关心文本参数；附件不回传，避免把命令附件重复塞进会话。

package/src/goal/continuation.ts

@@ -123,6 +123,8 @@ export function createGoalContinuation(args: {
 
   /** 输入：会话 ID + 错误载荷；输出：无。预期：余额不足/超长锁死，其余只记录。 */
   const handleFailure = async (sessionID: string, error: unknown): Promise<void> => {
+    // 这一轮已经失败，清掉待确认注入，下一次 idle 才能重试。
+    pending.delete(sessionID)
     if (!(await enabled())) return
 
     const state = stateOf(sessionID)
@@ -139,6 +141,8 @@ export function createGoalContinuation(args: {
 
   /** 输入：会话 ID + 打断原因；输出：无。预期：用户打断时暂停目标。 */
   const handleInterrupted = async (sessionID: string, reason: string): Promise<void> => {
+    // 任何打断都意味着这一轮结束，清掉待确认注入。
+    pending.delete(sessionID)
     if (reason !== "user") return
     if (!(await enabled())) return
     const state = stateOf(sessionID)

package/src/goal/controller.ts

@@ -33,8 +33,11 @@ export function createGoalController(store: JsonStore): GoalController {
     async setGoal(sessionID, objective, tokenBudget) {
       await clearGoal(store, sessionID)
       const goal = await createGoal(store, sessionID, objective)
-      if (tokenBudget === undefined) return goal
-      const withBudget: Goal = { ...goal, tokenBudget }
+      // 非法预算（0/负数/NaN）当作没设置，避免第一次记账就直接 budget_limited。
+      const budget =
+        tokenBudget !== undefined && Number.isFinite(tokenBudget) && tokenBudget > 0 ? tokenBudget : undefined
+      if (budget === undefined) return goal
+      const withBudget: Goal = { ...goal, tokenBudget: budget }
       await writeGoal(store, withBudget)
       return withBudget
     },
@@ -87,8 +90,8 @@ export function createGoalController(store: JsonStore): GoalController {
       const goal = await readGoal(store, sessionID)
       if (goal?.status !== "active") return goal
 
-      const tokenDelta = Math.max(0, usage.tokens)
-      const timeDelta = Math.max(0, usage.elapsedSeconds)
+      const tokenDelta = Number.isFinite(usage.tokens) ? Math.max(0, usage.tokens) : 0
+      const timeDelta = Number.isFinite(usage.elapsedSeconds) ? Math.max(0, usage.elapsedSeconds) : 0
       if (tokenDelta === 0 && timeDelta === 0) return goal
 
       const nextTokens = goal.tokensUsed + tokenDelta

package/src/goal/tools.ts

@@ -74,6 +74,17 @@ export async function registerGoalTools(
         const blocked = await unavailable(sessionID)
         if (blocked !== null) return { output: {}, content: blocked }
 
+        const objective = input.objective.trim()
+        if (objective.length === 0) {
+          return { output: {}, content: "Error: objective cannot be empty." }
+        }
+        if (
+          input.token_budget !== undefined &&
+          (!Number.isFinite(input.token_budget) || input.token_budget <= 0)
+        ) {
+          return { output: {}, content: "Error: token_budget must be a positive number." }
+        }
+
         const existing = await controller.getGoal(sessionID)
         if (existing !== null && existing.status !== "complete" && existing.status !== "blocked") {
           return {
@@ -82,7 +93,7 @@ export async function registerGoalTools(
           }
         }
 
-        await controller.setGoal(sessionID, input.objective, input.token_budget)
+        await controller.setGoal(sessionID, objective, input.token_budget)
         return { output: {}, content: formatGoal(await controller.getGoal(sessionID)) }
       },
     })

package/src/notification/index.ts

@@ -4,6 +4,7 @@ import type { SessionRoles } from "../goal/session-role.ts"
 import { resolveMessages, type Messages } from "../i18n/index.ts"
 import { readEventSessionID } from "../shared/events.ts"
 import type { JsonStore } from "../shared/json.ts"
+import { isSyntheticUserMessage } from "../shared/messages.ts"
 import { loadSettings } from "../shared/settings-store.ts"
 import type { Settings } from "../shared/settings.ts"
 import { createSender, type NotificationSender } from "./send.ts"
@@ -77,7 +78,9 @@ export function createNotifier(args: {
     for (let index = history.length - 1; index >= 0; index -= 1) {
       const message = history[index]
       if (message === undefined) continue
-      if (userText === "" && message.type === "user") userText = collapse(message.text)
+      if (userText === "" && message.type === "user" && !isSyntheticUserMessage(message)) {
+        userText = collapse(message.text)
+      }
       if (assistantText === "" && message.type === "assistant") {
         const text = message.content
           .filter((part) => part.type === "text")

package/src/notification/send.ts

@@ -13,22 +13,42 @@ const NOTIFY_SEND = "notify-send"
 const TITLE_MAX = 100
 const MESSAGE_MAX = 800
 
+/** 命令探测超时；发送超时。 */
+const PROBE_TIMEOUT_MS = 3_000
+const SEND_TIMEOUT_MS = 10_000
+
 /** 发送函数。 */
 export type NotificationSender = (title: string, message: string) => Promise<void>
 
+/**
+ * 命令执行器。
+ *
+ * 输入：命令、参数、超时毫秒。
+ * 输出：命令成功退出时 resolve。
+ * 预期：默认实现走 `execFile`；测试可注入假实现，验证各平台的参数与转义。
+ */
+export type CommandRunner = (command: string, args: readonly string[], timeoutMs: number) => Promise<void>
+
+const defaultRunner: CommandRunner = (command, args, timeoutMs) =>
+  execFileAsync(command, [...args], { timeout: timeoutMs, windowsHide: true }).then(() => undefined)
+
 /** 输入：文本 + 上限；输出：截断后的文本。 */
 function truncate(text: string, max: number): string {
   return text.length > max ? `${text.slice(0, max)}...` : text
 }
 
 /**
- * 输入：命令名 + 该命令能快速成功退出的探测参数。
+ * 输入：命令名 + 该命令能快速成功退出的探测参数 + 执行器。
  * 输出：可用时返回命令名，否则 `null`。
  * 预期：结果缓存；探测超时 3 秒，不阻塞通知链路。
  *       探测参数必须按命令区分：把 PowerShell 的 `-Command` 传给 osascript/notify-send 会必然失败，
  *       导致这两个平台的命令被误判为不存在。
  */
-function createCommandFinder(commandName: string, probeArgs: readonly string[]): () => Promise<string | null> {
+function createCommandFinder(
+  commandName: string,
+  probeArgs: readonly string[],
+  runner: CommandRunner,
+): () => Promise<string | null> {
   let cached: string | null | undefined
   let pending: Promise<string | null> | undefined
 
@@ -38,10 +58,7 @@ function createCommandFinder(commandName: string, probeArgs: readonly string[]):
 
     pending = (async () => {
       try {
-        await execFileAsync(commandName, [...probeArgs], {
-          timeout: 3_000,
-          windowsHide: true,
-        })
+        await runner(commandName, probeArgs, PROBE_TIMEOUT_MS)
         cached = commandName
       } catch {
         cached = null
@@ -52,52 +69,59 @@ function createCommandFinder(commandName: string, probeArgs: readonly string[]):
   }
 }
 
-const findPowerShell = createCommandFinder(POWERSHELL, ["-NoProfile", "-Command", "exit 0"])
-const findOsascript = createCommandFinder(OSASCRIPT, ["-e", "return"])
-const findNotifySend = createCommandFinder(NOTIFY_SEND, ["--help"])
-
-/** 输入：命令 + 参数；输出：无。预期：静默执行，失败由调用方忽略。 */
-async function runQuiet(command: string, args: readonly string[]): Promise<void> {
-  await execFileAsync(command, [...args], { timeout: 10_000, windowsHide: true })
-}
-
-/** 输入：标题 + 正文；输出：无。预期：没有 powershell 时静默跳过。 */
-async function sendWindows(title: string, message: string): Promise<void> {
-  const path = await findPowerShell()
-  if (path === null) return
-  const script = buildWindowsToastScript(truncate(title, TITLE_MAX), truncate(message, MESSAGE_MAX))
-  await runQuiet(path, ["-NoProfile", "-NonInteractive", "-Command", script])
+/** 输入：执行器；输出：Windows toast 发送函数。 */
+function windowsSender(runner: CommandRunner): NotificationSender {
+  const find = createCommandFinder(POWERSHELL, ["-NoProfile", "-Command", "exit 0"], runner)
+  return async (title, message) => {
+    const path = await find()
+    if (path === null) return
+    const script = buildWindowsToastScript(truncate(title, TITLE_MAX), truncate(message, MESSAGE_MAX))
+    await runner(path, ["-NoProfile", "-NonInteractive", "-Command", script], SEND_TIMEOUT_MS)
+  }
 }
 
-/** 输入：标题 + 正文；输出：无。预期：没有 osascript 时静默跳过。 */
-async function sendMacos(title: string, message: string): Promise<void> {
-  const path = await findOsascript()
-  if (path === null) return
-  const safeTitle = escapeAppleScriptText(truncate(title, TITLE_MAX))
-  const safeMessage = escapeAppleScriptText(truncate(message, MESSAGE_MAX))
-  await runQuiet(path, ["-e", `display notification "${safeMessage}" with title "${safeTitle}"`])
+/** 输入：执行器；输出：macOS 通知发送函数。 */
+function macosSender(runner: CommandRunner): NotificationSender {
+  const find = createCommandFinder(OSASCRIPT, ["-e", "return"], runner)
+  return async (title, message) => {
+    const path = await find()
+    if (path === null) return
+    const safeTitle = escapeAppleScriptText(truncate(title, TITLE_MAX))
+    const safeMessage = escapeAppleScriptText(truncate(message, MESSAGE_MAX))
+    await runner(
+      path,
+      ["-e", `display notification "${safeMessage}" with title "${safeTitle}"`],
+      SEND_TIMEOUT_MS,
+    )
+  }
 }
 
-/** 输入：标题 + 正文；输出：无。预期：没有 notify-send 时静默跳过。 */
-async function sendLinux(title: string, message: string): Promise<void> {
-  const path = await findNotifySend()
-  if (path === null) return
-  await runQuiet(path, [truncate(title, TITLE_MAX), truncate(message, MESSAGE_MAX)])
+/** 输入：执行器；输出：Linux 通知发送函数。 */
+function linuxSender(runner: CommandRunner): NotificationSender {
+  const find = createCommandFinder(NOTIFY_SEND, ["--help"], runner)
+  return async (title, message) => {
+    const path = await find()
+    if (path === null) return
+    await runner(path, [truncate(title, TITLE_MAX), truncate(message, MESSAGE_MAX)], SEND_TIMEOUT_MS)
+  }
 }
 
 /**
- * 输入：Node 平台字符串。
+ * 输入：Node 平台字符串 + 可选执行器。
  * 输出：该平台的发送函数。
- * 预期：不支持的平台返回空实现，绝不抛错。
+ * 预期：不支持的平台返回空实现，绝不抛错；每个 sender 各自缓存命令探测结果。
  */
-export function createSender(platform: NodeJS.Platform): NotificationSender {
+export function createSender(
+  platform: NodeJS.Platform,
+  runner: CommandRunner = defaultRunner,
+): NotificationSender {
   switch (platform) {
     case "win32":
-      return sendWindows
+      return windowsSender(runner)
     case "darwin":
-      return sendMacos
+      return macosSender(runner)
     case "linux":
-      return sendLinux
+      return linuxSender(runner)
     default:
       return () => Promise.resolve()
   }

package/src/scheduling/command.ts

@@ -106,8 +106,9 @@ export async function registerSchedulingCommands(
       name: "loop",
       description: "Start or stop a recurring prompt loop in this session",
       execute: async (input) => {
-        const blocked = await unavailable(input.sessionID)
         const parsed = parseLoopCommand(input.prompt.text)
+        // stop 即使功能关闭也要能执行，否则用户没法停掉正在跑的循环。
+        const blocked = parsed.kind === "stop" ? null : await unavailable(input.sessionID)
         const text = await (async (): Promise<string> => {
           if (blocked !== null) return blocked
           if (parsed.kind === "stop") {
@@ -128,8 +129,10 @@ export async function registerSchedulingCommands(
       name: "cron",
       description: "Create, list or delete scheduled prompts for this session",
       execute: async (input) => {
-        const blocked = await unavailable(input.sessionID)
         const raw = input.prompt.text.trim()
+        // list / delete 属于清理操作，功能关闭时也允许；只有创建需要开关。
+        const readOnly = raw === "" || raw.toLowerCase() === "list" || /^delete\s+\S+$/i.test(raw)
+        const blocked = readOnly ? null : await unavailable(input.sessionID)
         const text = await (async (): Promise<string> => {
           if (blocked !== null) return blocked
 

package/src/scheduling/continuation.ts

@@ -2,6 +2,7 @@ import type { Plugin } from "@opencode/plugin"
 
 import { readEventData } from "../shared/events.ts"
 import { lastMessageIsUserInput } from "../shared/messages.ts"
+import { capTimerDelay } from "../shared/timer.ts"
 import type { SessionRoles } from "../goal/session-role.ts"
 import type { SchedulingStore } from "./store.ts"
 import { isRecurringTaskAged } from "./store.ts"
@@ -10,6 +11,15 @@ import type { ScheduledJob } from "./types.ts"
 /** 注入消息的 metadata 标记。 */
 const CRON_MARKER = "cronContinuation"
 
+/** 功能关闭时顺延任务的间隔。 */
+const DISABLED_RETRY_MS = 60_000
+
+/** 目标进行中让路后的重试间隔。 */
+const DEFERRED_RETRY_MS = 5 * 60_000
+
+/** 注入失败（会话忙或末条是用户输入）后的重试间隔。 */
+const DELIVERY_RETRY_MS = 60_000
+
 /** 定时任务触发控制器。 */
 export type SchedulingContinuation = {
   /** 输入：会话事件；输出：无。预期：idle 兜底触发，删除会话清任务。 */
@@ -55,6 +65,10 @@ export function createSchedulingContinuation(args: {
   const timers = new Map<string, ReturnType<typeof setTimeout>>()
   const inFlight = new Set<string>()
   const pending = new Set<string>()
+  const lifecycle = { disposed: false }
+
+  /** 输入：无；输出：插件是否已卸载。预期：await 之后用它再确认，避免继续注入或武装。 */
+  const isDisposed = (): boolean => lifecycle.disposed
 
   /** 输入：会话 + 文本；输出：是否注入成功。预期：并发、上一条未完成或末条是用户输入时跳过。 */
   const inject = async (sessionID: string, text: string): Promise<boolean> => {
@@ -75,35 +89,67 @@ export function createSchedulingContinuation(args: {
 
   /** 输入：无；输出：无。预期：每个未来任务一个 timer，已有 timer 的不重复武装。 */
   const armTimers = (): void => {
+    if (isDisposed()) return
     const at = now()
     for (const job of store.listJobs()) {
       if (job.nextRunAt === undefined || timers.has(job.id)) continue
-      const delay = job.nextRunAt - at
-      if (delay <= 0) continue
+      // 已过点的任务也要武装：0 延迟让它在当前 tick 后补跑，而不是干等下一次 idle。
+      // 超过 24 小时的延迟分段等待，避免 32 位溢出导致立即触发。
+      const delay = capTimerDelay(job.nextRunAt - at)
       const handle = setTimeout(() => {
         timers.delete(job.id)
         const fresh = store.getJob(job.id)
-        if (fresh !== undefined) void handleCronFire(fresh)
+        if (fresh === undefined) return
+        // 分段等待提前醒来时还没到点，继续武装剩余时间。
+        if (fresh.nextRunAt !== undefined && fresh.nextRunAt > now()) {
+          armTimers()
+          return
+        }
+        // timer 回调里必须吞掉异常，否则未处理的 rejection 会打断整个进程。
+        void handleCronFire(fresh).catch(() => undefined)
       }, delay)
       handle.unref()
       timers.set(job.id, handle)
     }
   }
 
-  /** 输入：任务；输出：无。预期：先重排/删除，再判断是否注入。 */
+  /** 输入：任务 + 延迟；输出：无。预期：只改运行时 nextRunAt 并重新武装，不消费任务。 */
+  const postpone = (job: ScheduledJob, delayMs: number): void => {
+    job.nextRunAt = now() + delayMs
+    armTimers()
+  }
+
+  /** 输入：任务；输出：无。预期：先确认允许投递，成功后才重排/删除。 */
   const handleCronFire = async (job: ScheduledJob): Promise<void> => {
+    if (isDisposed()) return
     const at = now()
     const aged = isRecurringTaskAged(job, at)
-    if (aged || job.recurring !== true) {
-      await store.removeJobs([job.id])
-    } else {
-      await store.markFired([job.id], at)
+    const recurring = job.recurring === true && !aged
+
+    // 关闭或让路时先不消费任务：否则 one-shot 会在用户重新开启前被静默丢掉。
+    const on = await enabled().catch(() => false)
+    if (!on) {
+      postpone(job, DISABLED_RETRY_MS)
+      return
     }
-    armTimers()
+    const defer = await shouldDefer(job.sessionID).catch(() => false)
+    if (defer) {
+      postpone(job, DEFERRED_RETRY_MS)
+      return
+    }
+    if (isDisposed()) return
 
-    if (!(await enabled())) return
-    if (await shouldDefer(job.sessionID)) return
-    await inject(job.sessionID, buildFirePrompt(job, new Date(at)))
+    const delivered = await inject(job.sessionID, buildFirePrompt(job, new Date(at)))
+    if (isDisposed()) return
+    if (!delivered) {
+      // 会话忙或末条是用户输入：保留任务稍后重试，one-shot 不会因此丢失。
+      postpone(job, DELIVERY_RETRY_MS)
+      return
+    }
+
+    if (recurring) await store.markFired([job.id], at)
+    else await store.removeJobs([job.id])
+    armTimers()
   }
 
   /** 输入：会话 ID；输出：无。预期：处理该会话已到点的任务，否则补武装 timer。 */
@@ -129,6 +175,8 @@ export function createSchedulingContinuation(args: {
       if (typeof sessionID !== "string" || sessionID.length === 0) return
 
       if (event.type === "session.idle") {
+        // idle 表示上一轮已经结束；清掉 pending 让本轮可以继续注入。
+        pending.delete(sessionID)
         await handleIdle(sessionID)
         return
       }
@@ -150,11 +198,16 @@ export function createSchedulingContinuation(args: {
       if (event.type === "session.step.ended" || event.type === "session.usage.updated") {
         pending.delete(sessionID)
       }
+      // 注入后模型失败/被打断时清掉 pending，避免后续任务永远被挡住。
+      if (event.type === "session.execution.failed" || event.type === "session.execution.interrupted") {
+        pending.delete(sessionID)
+      }
     },
 
     armTimers,
 
     dispose() {
+      lifecycle.disposed = true
       for (const timer of timers.values()) clearTimeout(timer)
       timers.clear()
       inFlight.clear()

package/src/scheduling/cron.ts

@@ -95,8 +95,9 @@ export function parseCronExpression(expr: string): CronFields | null {
 
 /**
  * 输入：展开后的字段 + 起点时间。
- * 输出：严格晚于起点、第一个匹配的本地时刻，一年内无匹配返回 `null`。
+ * 输出：严格晚于起点、第一个匹配的本地时刻，四年内无匹配返回 `null`。
  * 预期：dayOfMonth 与 dayOfWeek 都受限时任一匹配即可（OR 语义）。
+ *       窗口取四年而不是一年，保证 `0 0 29 2 *`（闰日）能算出下一次。
  */
 export function computeNextCronRun(fields: CronFields, from: Date): Date | null {
   const minuteSet = new Set(fields.minute)
@@ -112,7 +113,8 @@ export function computeNextCronRun(fields: CronFields, from: Date): Date | null
   t.setSeconds(0, 0)
   t.setMinutes(t.getMinutes() + 1)
 
-  const maxIter = 366 * 24 * 60
+  // 四年覆盖一个完整闰年周期；月份/日期跳过让稀疏表达式远达不到这个上限。
+  const maxIter = 4 * 366 * 24 * 60
   for (let i = 0; i < maxIter; i += 1) {
     if (!monthSet.has(t.getMonth() + 1)) {
       t.setMonth(t.getMonth() + 1, 1)

package/src/scheduling/index.ts

@@ -35,7 +35,13 @@ export async function registerScheduling(
   const jobs = createSchedulingStore(store)
   await jobs.load()
 
-  const scheduler = createLoopScheduler({ ctx, roles, shouldDefer })
+  /** 输入：无；输出：总开关与 scheduling 开关是否都打开。 */
+  const isEnabled = async (): Promise<boolean> => {
+    const settings = await loadSettings(store)
+    return settings.enabled && settings.scheduling.enabled
+  }
+
+  const scheduler = createLoopScheduler({ ctx, roles, shouldDefer, enabled: isEnabled })
   const tools = await registerSchedulingTools(ctx, jobs, scheduler, roles)
   const commands = await registerSchedulingCommands(ctx, jobs, scheduler, roles)
 
@@ -44,10 +50,7 @@ export async function registerScheduling(
     store: jobs,
     roles,
     shouldDefer,
-    enabled: async () => {
-      const settings = await loadSettings(store)
-      return settings.enabled && settings.scheduling.enabled
-    },
+    enabled: isEnabled,
   })
   continuation.armTimers()
 

package/src/scheduling/loops.ts

@@ -4,6 +4,7 @@ import type { Plugin } from "@opencode/plugin"
 
 import { readEventData } from "../shared/events.ts"
 import { lastMessageIsUserInput } from "../shared/messages.ts"
+import { capTimerDelay, MAX_TIMER_DELAY_MS } from "../shared/timer.ts"
 import { DEFAULT_MAX_AGE_DAYS, type Loop } from "./types.ts"
 import type { SessionRoles } from "../goal/session-role.ts"
 
@@ -15,6 +16,9 @@ const FALLBACK_WAKEUP_MS = 20 * 60 * 1000
 const WAKEUP_MIN_S = 60
 const WAKEUP_MAX_S = 3600
 
+/** fixed 循环的最大间隔：与 7 天过期对齐，避免 setTimeout 超出 32 位范围。 */
+const MAX_LOOP_INTERVAL_SECONDS = 7 * 24 * 60 * 60
+
 /** `schedule_wakeup` 的结果。 */
 export type ScheduleWakeupResult =
   | { readonly ok: true; readonly id: string; readonly fireAt: number }
@@ -51,12 +55,16 @@ export function createLoopScheduler(args: {
   readonly ctx: Plugin.Context
   readonly roles: SessionRoles
   readonly shouldDefer: (sessionID: string) => Promise<boolean>
+  /** 输入：无；输出：scheduling 是否启用。缺省视为启用（测试与旧调用兼容）。 */
+  readonly enabled?: () => Promise<boolean>
 }): LoopScheduler {
   const { ctx, roles, shouldDefer } = args
+  const isEnabled = args.enabled ?? ((): Promise<boolean> => Promise.resolve(true))
   const loops = new Map<string, Loop>()
   const timers = new Map<string, ReturnType<typeof setTimeout>>()
   const inFlight = new Set<string>()
   const pending = new Set<string>()
+  const lifecycle = { disposed: false }
 
   /** 输入：会话 + prompt；输出：匹配的循环。预期：同一 prompt 只保留一个。 */
   const findLoop = (sessionID: string, prompt: string): Loop | undefined =>
@@ -85,26 +93,38 @@ export function createLoopScheduler(args: {
       stopLoop(loop.sessionID, loop.id)
       return
     }
-    if (await shouldDefer(loop.sessionID)) return
+    // 功能关闭时循环暂停，但不销毁；重新开启后下一个 timer 继续。
+    if (!(await isEnabled().catch(() => false))) return
+    if (await shouldDefer(loop.sessionID).catch(() => false)) return
     loop.fires += 1
     await inject(loop.sessionID, loop.prompt)
   }
 
   /** 输入：循环 + 延迟毫秒；输出：无。预期：重设 timer，`unref` 不阻止进程退出。 */
   const armLoop = (loop: Loop, delayMs: number): void => {
+    if (lifecycle.disposed) return
     const existing = timers.get(loop.id)
     if (existing !== undefined) clearTimeout(existing)
-    loop.nextFireAt = Date.now() + delayMs
+    const target = Number.isFinite(delayMs) ? Math.max(0, delayMs) : MAX_TIMER_DELAY_MS
+    loop.nextFireAt = Date.now() + target
     const handle = setTimeout(() => {
       timers.delete(loop.id)
-      void handleFire(loop)
-    }, Math.max(0, delayMs))
+      // 24 小时上限导致提前醒来时继续等剩余时间，而不是提前触发。
+      const remaining = (loop.nextFireAt ?? 0) - Date.now()
+      if (remaining > 0) {
+        armLoop(loop, remaining)
+        return
+      }
+      // timer 回调里必须吞掉异常，否则未处理的 rejection 会打断整个进程。
+      void handleFire(loop).catch(() => undefined)
+    }, capTimerDelay(target))
     handle.unref()
     timers.set(loop.id, handle)
   }
 
   /** 输入：循环；输出：无。预期：触发后按模式决定下一次。 */
   const handleFire = async (loop: Loop): Promise<void> => {
+    if (lifecycle.disposed) return
     const hadWakeup = loop.pendingWakeup
     await fireLoop(loop)
     if (!loops.has(loop.id)) return
@@ -129,20 +149,26 @@ export function createLoopScheduler(args: {
     const existing = findLoop(sessionID, prompt)
     if (existing !== undefined) stopLoop(sessionID, existing.id)
 
+    // 非法/非正间隔退化为 dynamic，避免 0 或负数把 setTimeout 变成忙循环。
+    const interval =
+      intervalSeconds !== undefined && Number.isFinite(intervalSeconds) && intervalSeconds > 0
+        ? Math.min(intervalSeconds, MAX_LOOP_INTERVAL_SECONDS)
+        : undefined
+
     const now = Date.now()
     const loop: Loop = {
       id: randomUUID().slice(0, 8),
       sessionID,
       prompt,
-      mode: intervalSeconds === undefined ? "dynamic" : "fixed",
-      ...(intervalSeconds === undefined ? {} : { intervalSeconds }),
+      mode: interval === undefined ? "dynamic" : "fixed",
+      ...(interval === undefined ? {} : { intervalSeconds: interval }),
       createdAt: now,
       expiresAt: now + DEFAULT_MAX_AGE_DAYS * 24 * 60 * 60 * 1000,
       fires: 0,
     }
     loops.set(loop.id, loop)
-    void fireLoop(loop)
-    armLoop(loop, intervalSeconds === undefined ? FALLBACK_WAKEUP_MS : intervalSeconds * 1000)
+    void fireLoop(loop).catch(() => undefined)
+    armLoop(loop, interval === undefined ? FALLBACK_WAKEUP_MS : interval * 1000)
     return loop
   }
 
@@ -186,7 +212,8 @@ export function createLoopScheduler(args: {
         error: "schedule_wakeup is only available inside an active dynamic /loop for this session and prompt.",
       }
     }
-    const clamped = Math.min(Math.max(Math.round(delaySeconds), WAKEUP_MIN_S), WAKEUP_MAX_S)
+    const requested = Number.isFinite(delaySeconds) ? delaySeconds : WAKEUP_MIN_S
+    const clamped = Math.min(Math.max(Math.round(requested), WAKEUP_MIN_S), WAKEUP_MAX_S)
     const now = Date.now()
     const fireAt = Math.ceil((now + clamped * 1000) / 60_000) * 60_000
     loop.pendingWakeup = { fireAt, delaySeconds: clamped, prompt, reason }
@@ -221,10 +248,19 @@ export function createLoopScheduler(args: {
       if (event.type === "session.step.ended" || event.type === "session.usage.updated") {
         pending.delete(sessionID)
       }
+      // 注入后模型失败/被打断/直接 idle 时清掉 pending，否则循环会被永久卡住。
+      if (
+        event.type === "session.execution.failed" ||
+        event.type === "session.execution.interrupted" ||
+        event.type === "session.idle"
+      ) {
+        pending.delete(sessionID)
+      }
       return Promise.resolve()
     },
 
     dispose() {
+      lifecycle.disposed = true
       for (const timer of timers.values()) clearTimeout(timer)
       timers.clear()
       loops.clear()

package/src/scheduling/store.ts

@@ -136,7 +136,9 @@ export function createSchedulingStore(store: ScannableStore): SchedulingStore {
           if (stored === null) continue
           const job: ScheduledJob = { ...stored, durable: true }
           const next = computeNext(job, job.lastFiredAt ?? job.createdAt)
-          if (next !== null) job.nextRunAt = next
+          // 算不出下一次的任务不会再触发，跳过而不是留下一个永远过期的 nextRunAt。
+          if (next === null) continue
+          job.nextRunAt = next
           jobs.set(job.id, job)
         }
         return Promise.resolve()
@@ -149,7 +151,7 @@ export function createSchedulingStore(store: ScannableStore): SchedulingStore {
         return { ok: false, error: `Invalid cron expression '${cron}'. Expected 5 fields: M H DoM Mon DoW.` }
       }
       if (nextCronRunMs(cron, Date.now()) === null) {
-        return { ok: false, error: `Cron expression '${cron}' does not match any calendar date in the next year.` }
+        return { ok: false, error: `Cron expression '${cron}' does not match any calendar date in the next 4 years.` }
       }
       const sessionJobs = [...jobs.values()].filter((job) => job.sessionID === sessionID).length
       if (sessionJobs >= MAX_JOBS) {
@@ -157,8 +159,11 @@ export function createSchedulingStore(store: ScannableStore): SchedulingStore {
       }
 
       const now = Date.now()
+      // 8 位 hex 理论上会碰撞；撞了就换一个，避免静默覆盖已有任务。
+      let id = randomUUID().slice(0, JOB_ID_LENGTH)
+      while (jobs.has(id)) id = randomUUID().slice(0, JOB_ID_LENGTH)
       const job: ScheduledJob = {
-        id: randomUUID().slice(0, JOB_ID_LENGTH),
+        id,
         sessionID,
         cron,
         prompt,
@@ -202,7 +207,12 @@ export function createSchedulingStore(store: ScannableStore): SchedulingStore {
         touched.add(job.sessionID)
         job.lastFiredAt = firedAt
         const next = computeNext(job, firedAt)
-        if (next !== null) job.nextRunAt = next
+        if (next === null) {
+          // 再也没有下一次：删掉任务，避免 nextRunAt 永远停在过去、每次 idle 都重复触发。
+          jobs.delete(id)
+          continue
+        }
+        job.nextRunAt = next
       }
       for (const sessionID of touched) await persist(sessionID)
     },

package/src/shared/messages.ts

@@ -1,5 +1,22 @@
 import type { Plugin } from "@opencode/plugin"
 
+/** 本插件注入的合成用户消息标记。 */
+export const SYNTHETIC_MARKERS = ["goalContinuation", "cronContinuation", "loopContinuation"] as const
+
+/**
+ * 输入：一条消息。
+ * 输出：是否是本插件注入的合成用户消息。
+ * 预期：只看 `type === "user"` 且 metadata 里任一标记为 true；其他消息一律 false。
+ *       通知预览据此跳过续作/定时注入，避免把系统提示当成用户原话。
+ */
+export function isSyntheticUserMessage(message: {
+  readonly type: string
+  readonly metadata?: Record<string, unknown>
+}): boolean {
+  if (message.type !== "user") return false
+  return SYNTHETIC_MARKERS.some((marker) => message.metadata?.[marker] === true)
+}
+
 /**
  * 输入：插件上下文 + 会话 ID + 注入标记。
  * 输出：末条消息是否是真实用户输入（不是本插件注入的）。

package/src/shared/scan.ts

@@ -15,7 +15,8 @@ export async function forEachScannedEntry(
   for (;;) {
     const page = await store.scan({ prefix, limit, ...(after === undefined ? {} : { after }) })
     for (const entry of page.entries) await visit(entry)
-    if (page.next === undefined) return
+    // 游标不前进时立即停下，防止异常存储导致死循环。
+    if (page.next === undefined || page.next === after) return
     after = page.next
   }
 }

package/src/shared/timer.ts

@@ -0,0 +1,16 @@
+/**
+ * `setTimeout` 的安全上限。
+ *
+ * 预期：超过 24 小时的等待拆成多段，避免 Node/Bun 把大于 2^31-1 毫秒的延迟
+ *       当成 1 毫秒立即触发（年抛、闰日等长周期 cron 会踩到）。
+ */
+export const MAX_TIMER_DELAY_MS = 24 * 60 * 60 * 1000
+
+/**
+ * 输入：期望延迟毫秒。
+ * 输出：夹到 `[0, MAX_TIMER_DELAY_MS]` 的延迟；非有限值按上限处理，避免 0 延迟忙循环。
+ */
+export function capTimerDelay(delayMs: number): number {
+  if (!Number.isFinite(delayMs)) return MAX_TIMER_DELAY_MS
+  return Math.min(Math.max(0, delayMs), MAX_TIMER_DELAY_MS)
+}