@freely01/opencode-notify 0.4.0 → 0.4.2

package/cli.ts

@@ -105,7 +105,7 @@ function cmdCheck() {
   let hasError = false
 
   for (const [name, ch] of Object.entries(channels)) {
-    if (!ch || !ch.enabled) continue
+    if (!ch || !ch.mode || ch.mode === "none") continue
 
     switch (name) {
       case "system":
@@ -177,23 +177,25 @@ async function cmdTest(channel?: string) {
     allChannels.push([name, enabled, sender])
   }
 
-  add("system_message", !!(channels.system_message?.enabled), async () => {
+  const modeOk = (m: string | undefined): boolean => m !== undefined && m !== "none"
+
+  add("system_message", modeOk(channels.system_message?.mode), async () => {
     await new SystemSender().send(SAMPLE_MSG)
   })
 
-  if (channels.custom_webhook?.enabled && channels.custom_webhook.url) {
+  if (modeOk(channels.custom_webhook?.mode) && channels.custom_webhook?.url) {
     add("custom_webhook", true, async () => {
       await new CustomWebhookSender(channels.custom_webhook!).send(SAMPLE_MSG)
     })
   }
 
-  if (channels.wechat_work?.enabled && channels.wechat_work.webhook_url) {
+  if (modeOk(channels.wechat_work?.mode) && channels.wechat_work?.webhook_url) {
     add("wechat_work", true, async () => {
       await new WechatWorkSender(channels.wechat_work!).send(SAMPLE_MSG)
     })
   }
 
-  if (channels.feishu?.enabled && channels.feishu.webhook_url) {
+  if (modeOk(channels.feishu?.mode) && channels.feishu?.webhook_url) {
     add("feishu", true, async () => {
       await new FeishuSender(channels.feishu!).send(SAMPLE_MSG)
     })
@@ -303,13 +305,13 @@ function cmdInfo() {
     console.log(`\n  🔔 通知渠道:`)
     const channelNames: [string, any, string][] = [
       ["系统消息", ch.system_message, ""],
-      ["屏幕跑马灯", ch.screen_flash, ch.screen_flash?.enabled ? `强度${ch.screen_flash.intensity ?? 0.9}` : ""],
+      ["屏幕跑马灯", ch.screen_flash, ch.screen_flash?.mode !== "none" ? `强度${ch.screen_flash?.intensity ?? 0.9}` : ""],
       ["自定义 Webhook", ch.custom_webhook, ch.custom_webhook?.url ?? ""],
       ["企业微信", ch.wechat_work, ch.wechat_work?.webhook_url ? `${ch.wechat_work.webhook_url.slice(0, 40)}...` : ""],
       ["飞书", ch.feishu, ch.feishu?.webhook_url ? `${ch.feishu.webhook_url.slice(0, 40)}...` : ""],
     ]
     for (const [label, config, url] of channelNames) {
-      if (config?.enabled) {
+      if (config?.mode !== "none") {
         const urlInfo = url ? ` ${url}` : ""
         console.log(`     ✅ ${label}${urlInfo}`)
       } else {

package/config.ts

@@ -1,6 +1,14 @@
+/**
+ * 渠道模式
+ * - "all"         → 即时通知 + 延迟推送都启用
+ * - "delay_only"  → 仅用于延迟推送（不弹即时通知）
+ * - "none"        → 禁用
+ */
+export type ChannelMode = "all" | "delay_only" | "none"
+
 /** 通知渠道配置 */
 export interface ChannelConfig {
-  enabled: boolean
+  mode: ChannelMode
   /**
    * 渠道级事件过滤 — 仅这些事件触发本渠道通知
    * 不填或留空则继承全局 events
@@ -67,6 +75,7 @@ export interface PluginConfig {
    *   input_required       - Agent 等待用户输入
    *   run_completed        - 任务执行完成（技术预留，暂未实现）
    *   run_failed           - 任务执行失败
+   *   run_cancelled        - 用户主动中断任务
    */
   events?: string[]
   /** 去重时间窗口（秒），默认 60 */
@@ -171,9 +180,17 @@ channels:
   #   Linux  - 使用 notify-send (需 libnotify 包，桌面版通常预装)
   #   Windows - 使用 PowerShell New-BurntToastNotification
   #             (需额外安装 BurntToast 模块)
+  #
+  # mode 可选值:
+  #   all         → 启用即时通知（是否延迟推送由下方 remote_delay_channels 独立控制）
+  #   delay_only  → 仅用于远程延迟推送，不弹即时通知
+  #   none        → 禁用
+  #
+  # 纯即时通知（不延迟推送）：mode: all 且不要加入 remote_delay_channels 即可。
+  # 纯延迟推送（不即时通知）：mode: delay_only 并加入 remote_delay_channels。
   # ---------------------------------------------------------------------------
   system_message:
-    enabled: true                    # true=启用, false=禁用
+    mode: all                        # all | delay_only | none
 
   # ---------------------------------------------------------------------------
   # 屏幕跑马灯 (Linux X11 专用)
@@ -184,7 +201,7 @@ channels:
   # 取消下方注释启用：
   # ---------------------------------------------------------------------------
   # screen_flash:
-  #   enabled: true
+  #   mode: all                      # all | delay_only | none
   #   duration: 3.5                  # 持续秒数
   #   speed: 5.0                     # 移动速度因子
   #   intensity: 0.85                # 不透明度 0.0~1.0
@@ -198,7 +215,7 @@ channels:
   # 取消下方注释并填入 webhook_url 启用：
   # ---------------------------------------------------------------------------
   # wechat_work:
-  #   enabled: true
+  #   mode: all                      # all | delay_only | none
   #   webhook_url: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx"
 
   # ---------------------------------------------------------------------------
@@ -210,7 +227,7 @@ channels:
   # 取消下方注释并填入 webhook_url 启用：
   # ---------------------------------------------------------------------------
   # feishu:
-  #   enabled: true
+  #   mode: all                      # all | delay_only | none
   #   webhook_url: "https://open.feishu.cn/open-apis/bot/v2/hook/xxx"
 
   # ---------------------------------------------------------------------------
@@ -231,7 +248,7 @@ channels:
   # 取消下方注释并配置 url 启用：
   # ---------------------------------------------------------------------------
   # custom_webhook:
-  #   enabled: true
+  #   mode: all                      # all | delay_only | none
   #   url: ""
   #   method: "POST"                  # 请求方法: "POST" | "GET"
   #   headers: {}                     # 自定义请求头
@@ -243,7 +260,12 @@ channels:
 # =============================================================================
 # 只订阅你关心的事件类型，减少不必要通知。
 #
-# 可选事件（各渠道也可单独配置 events 覆盖此全局列表）:
+# ⚠️ 全局 events 是主闸门：只有在此列表中的事件才会生成通知消息。
+#    渠道级 events（channels.xxx.events）只能从全局列表中进一步收窄，
+#    无法新增全局列表之外的事件。例如全局无 run_cancelled 时，
+#    即使渠道配了 run_cancelled 也不会收到。
+#
+# 可选事件（各渠道也可单独配置 events，从全局列表中进一步筛选）:
 #   permission_required  - Agent 需要用户授权（如执行命令、读写文件）
 #                          触发: permission.asked / question.asked
 #   input_required       - Agent 等待用户输入
@@ -251,11 +273,14 @@ channels:
 #   run_completed        - 任务执行完成（技术预留，暂未实现）
 #   run_failed           - 任务执行失败
 #                          触发: session.error
+#   run_cancelled        - 用户主动中断任务（Ctrl+C 或点击中断按钮）
+#                          触发: session.error (MessageAbortedError)
 # ---------------------------------------------------------------------------
 events:
   - permission_required               # 权限请求通知（推荐开启）
   - input_required                    # 等待输入通知（推荐开启）
   - run_failed                        # 任务失败通知
+  - run_cancelled                     # 用户取消通知（推荐开启）
 
 
 # =============================================================================
@@ -284,7 +309,7 @@ dedupe_seconds: 60                   # 去重时间窗口（秒），0 或负数
 #
 # 抑制规则:
 #   permission_required / input_required: 活跃时抑制（屏上可见）
-#   run_failed / run_completed: 始终通知（异步结果，人可能走开）
+#   run_failed / run_completed / run_cancelled: 始终通知（异步结果，人可能走开）
 # ---------------------------------------------------------------------------
 suppress_when_active: true           # true=开启会话感知抑制, false=不抑制
 activity_timeout_ms: 15000           # 会话操作超时（毫秒）
@@ -293,7 +318,7 @@ activity_timeout_ms: 15000           # 会话操作超时（毫秒）
 suppress_events_when_active:         # 活跃时抑制哪些事件（不填继承默认）
   - permission_required
   - input_required
-  # run_failed / run_completed 不在列表中 → 始终通知
+  # run_failed / run_completed / run_cancelled 不在列表中 → 始终通知
 session_stale_timeout_ms: 600000     # 超时会话自动淘汰（毫秒）
                                      # 10 分钟无任何活动的会话从追踪 Map 移除
                                      # 防止长期运行导致内存泄漏
@@ -305,6 +330,12 @@ session_stale_timeout_ms: 600000     # 超时会话自动淘汰（毫秒）
 # 正常通知发出后，如果用户长时间未操作，针对指定渠道额外再推送一次。
 # 用户回到 opencode TUI 操作 → 自动取消所有待发延迟通知。
 #
+# 只影响此列表中的渠道，不在列表中的渠道为"纯即时通知"。
+# 结合 mode 使用：
+#   mode: all         + 在此列表中 → 即时 + 延迟
+#   mode: all         + 不在列表中 → 纯即时（不延迟推送）
+#   mode: delay_only  + 在此列表中 → 纯延迟（不弹即时通知）
+#
 # 适用场景：用户离开电脑后，系统通知可能一闪而过没看到，
 # 延迟推送在用户仍未回来时再次尝试发出。
 #
@@ -383,17 +414,18 @@ export function mergeConfig(base: PluginConfig, overrides: PluginConfig): Plugin
 /** 默认配置 */
 const DEFAULT_CONFIG: Required<Pick<PluginConfig, "suppress_when_active" | "activity_timeout_ms" | "suppress_events_when_active" | "session_stale_timeout_ms" | "remote_delay_seconds" | "remote_delay_max_count">> & PluginConfig = {
   channels: {
-    system_message: { enabled: true },
-    screen_flash: { enabled: false },
-    wechat_work: { enabled: false },
-    feishu: { enabled: false },
-    custom_webhook: { enabled: false },
+    system_message: { mode: "all" },
+    screen_flash: { mode: "none" },
+    wechat_work: { mode: "none" },
+    feishu: { mode: "none" },
+    custom_webhook: { mode: "none" },
   },
   events: [
     "permission_required",
     "input_required",
     "run_completed",
     "run_failed",
+    "run_cancelled",
   ],
   dedupe_seconds: 60,
   suppress_when_active: true,
@@ -421,39 +453,39 @@ export function resolveConfig(options: PluginConfig): PluginConfig {
   return {
     channels: {
       system_message: {
-        enabled:
-          options.channels?.system_message?.enabled ??
-          DEFAULT_CONFIG.channels!.system_message!.enabled,
+        mode:
+          options.channels?.system_message?.mode ??
+          DEFAULT_CONFIG.channels!.system_message!.mode,
         events: chEvents(options.channels?.system_message),
       },
       screen_flash: {
-        enabled:
-          options.channels?.screen_flash?.enabled ??
-          DEFAULT_CONFIG.channels!.screen_flash!.enabled,
+        mode:
+          options.channels?.screen_flash?.mode ??
+          DEFAULT_CONFIG.channels!.screen_flash!.mode,
         duration: options.channels?.screen_flash?.duration,
         speed: options.channels?.screen_flash?.speed,
         intensity: options.channels?.screen_flash?.intensity,
         events: chEvents(options.channels?.screen_flash),
       },
       wechat_work: {
-        enabled:
-          options.channels?.wechat_work?.enabled ??
-          DEFAULT_CONFIG.channels!.wechat_work!.enabled,
+        mode:
+          options.channels?.wechat_work?.mode ??
+          DEFAULT_CONFIG.channels!.wechat_work!.mode,
         webhook_url: options.channels?.wechat_work?.webhook_url || undefined,
         events: chEvents(options.channels?.wechat_work),
       },
       feishu: {
-        enabled:
-          options.channels?.feishu?.enabled ??
-          DEFAULT_CONFIG.channels!.feishu!.enabled,
+        mode:
+          options.channels?.feishu?.mode ??
+          DEFAULT_CONFIG.channels!.feishu!.mode,
         webhook_url: options.channels?.feishu?.webhook_url || undefined,
         events: chEvents(options.channels?.feishu),
       },
       custom_webhook: {
-        enabled:
-          options.channels?.custom_webhook?.enabled ??
-          DEFAULT_CONFIG.channels?.custom_webhook?.enabled ??
-          false,
+        mode:
+          options.channels?.custom_webhook?.mode ??
+          DEFAULT_CONFIG.channels?.custom_webhook?.mode ??
+          "none",
         url: options.channels?.custom_webhook?.url || undefined,
         method: options.channels?.custom_webhook?.method ?? "POST",
         headers: options.channels?.custom_webhook?.headers,

package/delayed-dispatcher.ts

@@ -1,6 +1,7 @@
 import type { Message } from "./message.js"
 import type { Sender } from "./senders/types.js"
 import { error, warn, info, debug } from "./log.js"
+import { isTerminalOccluded } from "./terminator-detect.js"
 
 /**
  * 远程延迟通知调度器
@@ -96,6 +97,48 @@ export class DelayedDispatcher {
     }
   }
 
+  /**
+   * 将毫秒转换为人类可读的间隔描述
+   * 例: 30_000 → "30秒", 120_000 → "2分钟", 3_600_000 → "60分钟"
+   */
+  private formatInterval(ms: number): string {
+    const sec = Math.round(ms / 1000)
+    if (sec < 60) return `${sec}秒`
+    const min = Math.round(sec / 60)
+    return `${min}分钟`
+  }
+
+  /**
+   * 在通知正文追加或替换延迟推送标记
+   *
+   * 清除正文末尾已有的旧标记行，追加最新标记。
+   * 标记格式：
+   *   ─────────────────
+   *   ⚠️ 延迟 第2/3次（下次约 15:31:00 / 2分钟后）
+   */
+  private markDelayBody(body: string, current: number, total: number, nextDelayMs: number): string {
+    // 移除旧标记（从末尾 ─── 分隔线到最后）
+    const clean = body.replace(/\n─{3,}[\s\S]*$/, "")
+    if (current < total) {
+      const next = new Date(Date.now() + nextDelayMs)
+      const t = `${String(next.getHours()).padStart(2, "0")}:${String(next.getMinutes()).padStart(2, "0")}:${String(next.getSeconds()).padStart(2, "0")}`
+      return `${clean}\n─────────────────\n⚠️ 延迟 第${current}/${total}次（下次约 ${t} / ${this.formatInterval(nextDelayMs)}后）`
+    }
+    // 最后一次推送，不显示下次时间
+    return `${clean}\n─────────────────\n⚠️ 延迟 第${current}/${total}次（最终）`
+  }
+
+  /**
+   * 根据已发送次数计算本次延迟
+   *
+   * 指数退避：base × 2^count，上限 10 分钟
+   * count=0 → base, count=1 → base×2, count=2 → base×4, ...
+   */
+  private getDelayMs(count: number): number {
+    const max = 600_000  // 10 分钟上限
+    return Math.min(this.delayMs * Math.pow(2, count), max)
+  }
+
   /**
    * 调度单次延迟发送
    */
@@ -105,9 +148,23 @@ export class DelayedDispatcher {
     const entry = chMap.get(ch)
     if (!entry) return
 
+    const currentDelay = this.getDelayMs(entry.count)
+
     entry.timeoutId = setTimeout(() => {
       entry.timeoutId = null
 
+      // 发送前检查：如果终端子屏可见（用户已回到电脑前），取消本会话的所有待发延迟
+      if (isTerminalOccluded() === false) {
+        info(`远程延迟: 用户已回到终端，取消会话=${sid} 的延迟推送`)
+        this.cancelForSession(sid)
+        return
+      }
+
+      // 在正文追加延迟标记（第几次 / 共几次 / 下次时间）
+      const sendCount = entry.count + 1  // 1-based
+      const nextDelay = this.getDelayMs(entry.count + 1)
+      msg.body = this.markDelayBody(msg.body, sendCount, this.maxCount, nextDelay)
+
       // 发送延迟通知
       const sender = this.senders.get(ch)
       if (sender) {
@@ -121,7 +178,7 @@ export class DelayedDispatcher {
       entry.count++
       if (entry.count < this.maxCount) {
         this.scheduleOne(sid, ch, msg)
-        debug(`远程延迟: 重试 ${entry.count}/${this.maxCount} 会话=${sid} 渠道=${ch}`)
+        debug(`远程延迟: 重试 ${entry.count}/${this.maxCount} 会话=${sid} 渠道=${ch} 下次延迟=${this.getDelayMs(entry.count)}ms`)
       } else {
         // 达到最大次数，清理
         chMap.delete(ch)
@@ -130,6 +187,6 @@ export class DelayedDispatcher {
         }
         info(`远程延迟: 已完成 会话=${sid} 渠道=${ch} (推送${entry.count}次)`)
       }
-    }, this.delayMs)
+    }, currentDelay)
   }
 }

package/events.ts

@@ -71,14 +71,33 @@ export function route(
     )
   }
 
-  // 会话错误 → run_failed
-  if (type === "session.error" && enabled.has("run_failed")) {
+  // 会话错误 → run_cancelled / run_failed
+  // MessageAbortedError = 用户主动中断（Ctrl+C 或点击中断按钮）
+  // 其他错误类型 = 真实失败
+  if (type === "session.error") {
     const err = properties.error
-    const errMsg = err?.message ?? err?.name ?? defaultBody("run_failed")
-    return makeMsg(
-      "run_failed",
-      `错误: ${truncate(String(errMsg), 200)}`,
-    )
+
+    // 用户主动中断
+    if (err?.name === "MessageAbortedError") {
+      if (enabled.has("run_cancelled")) {
+        const msg = err?.data?.message ?? ""
+        return makeMsg(
+          "run_cancelled",
+          msg ? `用户中断: ${truncate(msg, 200)}` : defaultBody("run_cancelled"),
+        )
+      }
+      // run_cancelled 未启用 → 跳过，不降级为 run_failed
+      return null
+    }
+
+    // 真实失败
+    if (enabled.has("run_failed")) {
+      const errMsg = err?.data?.message ?? err?.name ?? defaultBody("run_failed")
+      return makeMsg(
+        "run_failed",
+        `错误: ${truncate(String(errMsg), 200)}`,
+      )
+    }
   }
 
   // 会话空闲 → input_required

package/index.ts

@@ -2,6 +2,7 @@ import type { Plugin } from "@opencode-ai/plugin"
 import type { PluginConfig } from "./config.js"
 import { resolveConfig, loadYamlConfig, mergeConfig, ensureConfigFile } from "./config.js"
 import { route } from "./events.js"
+import { enrich } from "./message.js"
 import { Dispatcher } from "./dispatcher.js"
 import { FileStore } from "./store.js"
 import { SystemSender } from "./senders/system/index.js"
@@ -85,8 +86,14 @@ const plugin: Plugin = async (_input, options) => {
 
       // 会话生命周期事件
       if (type === "session.created") {
-        tracker.register(sessionID)
-        debug(`→ 会话已创建, 会话=${sessionID}`)
+        const userPrompt = properties.info?.title
+        tracker.register(sessionID, userPrompt)
+        debug(`→ 会话已创建, 会话=${sessionID}${userPrompt ? ` userPrompt="${userPrompt}"` : ""}`)
+      }
+      if (type === "session.updated") {
+        const topic = properties.info?.title
+        tracker.updateTopic(sessionID, topic)
+        debug(`→ 会话已更新, 会话=${sessionID}${topic ? ` topic="${topic}"` : ""}`)
       }
       if (type === "session.deleted") {
         tracker.remove(sessionID)
@@ -102,7 +109,12 @@ const plugin: Plugin = async (_input, options) => {
       const msg = route(event, cfg.events)
       if (!msg) return  // 不关心的事件
 
-      debug(`→ 匹配通知: ${msg.event}`)
+      // 注入会话主题和任务描述，增强通知内容
+      const userPrompt = tracker.getUserPrompt(sessionID)
+      const sessionTopic = tracker.getSessionTopic(sessionID)
+      enrich(msg, userPrompt, sessionTopic)
+
+      debug(`→ 匹配通知: ${msg.event} sessionTopic="${sessionTopic ?? ""}" userPrompt="${userPrompt ?? ""}"`)
 
       // 会话感知抑制判定
       let shouldSuppress = cfg.suppress_when_active && suppressEvents.includes(msg.event)
@@ -121,7 +133,10 @@ const plugin: Plugin = async (_input, options) => {
       }
 
       if (shouldSuppress) {
-        info(`→ 会话 ${sessionID} 活跃中，跳过通知 (${msg.event})`)
+        info(`→ 会话 ${sessionID} 活跃中，跳过即时通知 (${msg.event})`)
+        // 仍调度延迟推送：用户可能在电脑前屏上可见所以抑制，
+        // 但万一用户已离开电脑，延迟推送能在用户未回来时再次提醒
+        delayedDispatcher?.schedule(msg)
         return
       }
 
@@ -140,50 +155,57 @@ interface BuildSendersResult {
   senderMap: Map<string, import("./senders/types.js").Sender>
 }
 
-function addSender(
-  senders: import("./senders/types.js").Sender[],
-  sender: import("./senders/types.js").Sender,
-  events: string[],
-  label: string,
-  extra?: string,
-): import("./senders/types.js").Sender {
-  const filtered = new FilteredSender(sender, events)
-  senders.push(filtered)
-  const evt = events.length < 6 ? `events=${JSON.stringify(events)}` : `events=${events.length}个`
-  info(`${label}已启用 (${evt})${extra ? `, ${extra}` : ""}`)
-  return filtered
-}
-
 function buildSenders(cfg: PluginConfig): BuildSendersResult {
   const senders: import("./senders/types.js").Sender[] = []
   const senderMap = new Map<string, import("./senders/types.js").Sender>()
   const globalEvents = cfg.events ?? []
 
-  if (cfg.channels?.system_message?.enabled) {
-    const events = cfg.channels.system_message.events ?? globalEvents
-    const s = addSender(senders, new SystemSender(), events, "系统通知")
-    senderMap.set("system_message", s)
-  }
-  if (cfg.channels?.screen_flash?.enabled) {
-    const events = cfg.channels.screen_flash.events ?? globalEvents
-    const s = addSender(senders, new ScreenFlashSender(cfg.channels.screen_flash), events, "屏幕跑马灯")
-    senderMap.set("screen_flash", s)
-  }
-  if (cfg.channels?.custom_webhook?.enabled && cfg.channels.custom_webhook.url) {
-    const events = cfg.channels.custom_webhook.events ?? globalEvents
-    const s = addSender(senders, new CustomWebhookSender(cfg.channels.custom_webhook), events, "自定义 Webhook")
-    senderMap.set("custom_webhook", s)
-  }
-  if (cfg.channels?.wechat_work?.enabled && cfg.channels.wechat_work.webhook_url) {
-    const events = cfg.channels.wechat_work.events ?? globalEvents
-    const s = addSender(senders, new WechatWorkSender(cfg.channels.wechat_work), events, "企业微信")
-    senderMap.set("wechat_work", s)
-  }
-  if (cfg.channels?.feishu?.enabled && cfg.channels.feishu.webhook_url) {
-    const events = cfg.channels.feishu.events ?? globalEvents
-    const s = addSender(senders, new FeishuSender(cfg.channels.feishu), events, "飞书")
-    senderMap.set("feishu", s)
+  /**
+   * 注册渠道发送器
+   * @param key      渠道键名
+   * @param mode     渠道模式
+   * @param chEvents 渠道级事件过滤
+   * @param create   创建原始 Sender 的回调
+   * @param label    日志标签
+   */
+  function register(
+    key: string,
+    mode: string | undefined,
+    chEvents: string[] | undefined,
+    create: () => import("./senders/types.js").Sender,
+    label: string,
+  ): void {
+    if (mode === "none" || !mode) return  // 禁用
+
+    const evts = chEvents ?? globalEvents
+    const raw = create()
+    const filtered = new FilteredSender(raw, evts)
+
+    if (mode === "delay_only") {
+      // 仅延迟推送：不进 senders[]，只入 senderMap
+      senderMap.set(key, filtered)
+      info(`${label}已启用 (delay_only, 仅延迟推送)`)
+    } else {
+      // all：即时通知 + 延迟推送
+      senders.push(filtered)
+      senderMap.set(key, filtered)
+      const evtStr = evts.length < 6 ? `events=${JSON.stringify(evts)}` : `events=${evts.length}个`
+      info(`${label}已启用 (${evtStr})`)
+    }
   }
+
+  const ch = cfg.channels
+  register("system_message", ch?.system_message?.mode, ch?.system_message?.events,
+    () => new SystemSender(), "系统通知")
+  register("screen_flash", ch?.screen_flash?.mode, ch?.screen_flash?.events,
+    () => new ScreenFlashSender(ch?.screen_flash!), "屏幕跑马灯")
+  register("custom_webhook", ch?.custom_webhook?.mode, ch?.custom_webhook?.events,
+    () => new CustomWebhookSender(ch?.custom_webhook!), "自定义 Webhook")
+  register("wechat_work", ch?.wechat_work?.mode, ch?.wechat_work?.events,
+    () => new WechatWorkSender(ch?.wechat_work!), "企业微信")
+  register("feishu", ch?.feishu?.mode, ch?.feishu?.events,
+    () => new FeishuSender(ch?.feishu!), "飞书")
+
   return { senders, senderMap }
 }
 

package/message.ts

@@ -20,6 +20,7 @@ const EVENT_LABELS: Record<string, string> = {
   input_required: "等待输入",
   run_completed: "任务完成",
   run_failed: "任务失败",
+  run_cancelled: "用户取消",
   session_idle: "会话空闲",
 }
 
@@ -28,9 +29,7 @@ const EVENT_LABELS: Record<string, string> = {
  */
 function shortSession(sessionID: string): string {
   if (!sessionID || sessionID === "unknown") return "未知"
-  return sessionID.length > 11
-    ? sessionID.slice(0, 11) + "…"
-    : sessionID
+  return sessionID
 }
 
 /**
@@ -38,12 +37,9 @@ function shortSession(sessionID: string): string {
  * @param event 事件类型
  * @param sessionID 会话 ID（可选，传入后在标题前加会话标签）
  */
-export function formatTitle(event: string, sessionID?: string): string {
+export function formatTitle(event: string, _sessionID?: string): string {
   const label = EVENT_LABELS[event] ?? event
-  const prefix = sessionID && sessionID !== "unknown"
-    ? `[${shortSession(sessionID)}] `
-    : ""
-  return `${prefix}opencode - ${label}`
+  return `opencode - ${label}`
 }
 
 /**
@@ -59,6 +55,8 @@ export function defaultBody(event: string): string {
       return "任务执行完成"
     case "run_failed":
       return "任务执行失败"
+    case "run_cancelled":
+      return "用户主动中断了任务"
     default:
       return `事件: ${event}`
   }
@@ -85,3 +83,37 @@ export function formatBody(msg: Message): string {
     `时间：${time}`,
   ].join("\n")
 }
+
+/** 截断标题到指定长度 */
+function shortTitle(title: string, maxLen = 20): string {
+  if (title.length <= maxLen) return title
+  return title.slice(0, maxLen - 1) + "…"
+}
+
+/**
+ * 增强通知消息：注入会话上下文
+ *
+ * - 标题：`[主题] 事件标签`（替换 `opencode - 事件标签`）
+ * - 正文：用 `主题` / `任务` 行替换 `详情` 行
+ *
+ * @param msg 原始通知消息
+ * @param userPrompt 用户输入的问题/任务描述（创建时捕获）
+ * @param sessionTopic opencode 自动生成的会话主题
+ * @returns 增强后的消息（原地修改并返回）
+ */
+export function enrich(msg: Message, userPrompt?: string, sessionTopic?: string): Message {
+  if (!userPrompt && !sessionTopic) return msg
+
+  // 标题优先用主题（更简洁），无主题则用用户提示词
+  const title = sessionTopic ?? userPrompt
+  const label = EVENT_LABELS[msg.event] ?? msg.event
+  msg.title = `[${shortTitle(title!)}] ${label}`
+
+  // 替换"详情"行，按可用字段生成上下文行
+  const lines: string[] = []
+  if (sessionTopic) lines.push(`主题：${sessionTopic}`)
+  if (userPrompt) lines.push(`任务：${userPrompt}`)
+  // 如果两者都为空（前面 return 了）不可能到这里
+  msg.body = msg.body.replace(/^详情：.*$/m, lines.join("\n"))
+  return msg
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freely01/opencode-notify",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "opencode 通知插件 - 监听会话事件并通过多渠道推送通知",
   "type": "module",
   "main": "index.ts",

package/senders/feishu.ts

@@ -47,18 +47,6 @@ export class FeishuSender implements Sender {
             tag: "markdown",
             content: msg.body,
           },
-          {
-            tag: "hr",
-          },
-          {
-            tag: "note",
-            elements: [
-              {
-                tag: "plain_text",
-                content: `会话: ${msg.sessionID}`,
-              },
-            ],
-          },
         ],
       },
     })

package/senders/wechat-work.ts

@@ -33,12 +33,11 @@ export class WechatWorkSender implements Sender {
       throw new Error("wechat_work: webhook_url not configured")
     }
 
-    // 构造 markdown 内容
+    // 构造 markdown 内容（msg.body 已包含事件/会话/详情/时间/延迟标记）
     const content = [
       `**${msg.title}**`,
       "",
       msg.body,
-      `> 会话: ${msg.sessionID}`,
     ].join("\n")
 
     const body = JSON.stringify({

package/session-tracker.ts

@@ -20,6 +20,10 @@ export interface SessionInfo {
   lastActivity: number
   /** 会话创建时间 */
   createdAt: number
+  /** 用户输入的问题/任务描述（创建时捕获） */
+  userPrompt?: string
+  /** opencode 自动生成的会话主题（session.updated 时更新） */
+  sessionTopic?: string
 }
 
 const CLEANUP_INTERVAL_MS = 5 * 60 * 1000  // 5 分钟
@@ -69,17 +73,47 @@ export class SessionTracker {
   }
 
   /** 注册新会话 */
-  register(sessionID: string): void {
+  register(sessionID: string, userPrompt?: string): void {
     if (sessionID === "unknown") return
-    if (!this.sessions.has(sessionID)) {
+    const existing = this.sessions.get(sessionID)
+    if (existing) {
+      if (userPrompt) existing.userPrompt = userPrompt
+    } else {
+      this.sessions.set(sessionID, {
+        sessionID,
+        lastActivity: Date.now(),
+        createdAt: Date.now(),
+        userPrompt,
+      })
+    }
+  }
+
+  /** 更新会话主题（opencode 自动生成，来自 session.updated） */
+  updateTopic(sessionID: string, topic: string): void {
+    if (sessionID === "unknown" || !topic) return
+    const existing = this.sessions.get(sessionID)
+    if (existing) {
+      existing.sessionTopic = topic
+    } else {
       this.sessions.set(sessionID, {
         sessionID,
         lastActivity: Date.now(),
         createdAt: Date.now(),
+        sessionTopic: topic,
       })
     }
   }
 
+  /** 获取用户提示词 */
+  getUserPrompt(sessionID: string): string | undefined {
+    return this.sessions.get(sessionID)?.userPrompt
+  }
+
+  /** 获取会话主题 */
+  getSessionTopic(sessionID: string): string | undefined {
+    return this.sessions.get(sessionID)?.sessionTopic
+  }
+
   /** 移除会话 */
   remove(sessionID: string): void {
     this.sessions.delete(sessionID)