dsh-dock 0.9.9 → 0.10.1

package/features/animation/host.js

@@ -1,17 +1,17 @@
-// dsh-dock · 功能模块【任务动画】· 宿主半部（v0.5.0，参照 @wycto/dsh-task-pulse lib/index.js 会话级追踪，同作者 MIT）
+// dsh-dock · 功能模块【任务动画】· 宿主半部
 //
-// 职责：会话级任务追踪（开始/结束/回合/步骤/工具/Token/结束原因）+ RPC + 配置持久化。
-// 不做动画（那是浏览器半部的事），也不做钉钉推送（dock 版走浏览器通知，见 view.jsx）。
+// 职责：动画配置持久化（动效开关 / 模式 / 桌面伙伴大小）+ 状态路由。
+// 会话级任务追踪在 src/task-track.js（与【任务通知】【运行状态】共用一份数据）；
+// 通知在 features/notify/、运行状态在 features/runstate/，三个功能各自独立启停。
 //
 // RPC（webServer HTTP 路由，前缀 /dsh-dock/animation/）：
-//   POST /status —— 活跃任务 + 最近完成 + 配置（客户端据此渲染动画/通知）
-//   POST /config —— 增量更新配置字段并持久化到 settings（dsh-dock 命名空间 animation 段）
+//   POST /status —— 活跃任务 + 最近完成 + 动画配置（客户端据此渲染动效）
+//   POST /config —— 增量更新动画配置字段并持久化到 settings（dsh-dock 命名空间 animation 段）
 //
 // 配置模型（schemastery schema 见 src/host-core.js DockConfig.animation）：
-//   animationEnabled / effectMode / notifyEnabled / notifyOnComplete /
-//   notifyOnError / notifyOnConfirm / notifyStayMs / systemNotify
-// 动画与通知是两个独立开关，可只开其一；全部经 settings 持久化，重启后恢复。
-import { DOCK_NS, ANIMATION_MODES, SOUND_EFFECTS, sendJson, readBody } from '../../src/host-core.js'
+//   animationEnabled / effectMode / robotScale
+import { DOCK_NS, ANIMATION_MODES, sendJson, readBody } from '../../src/host-core.js'
+import { acquireTaskTracker } from '../../src/task-track.js'
 
 // 默认配置（schema 默认值一致；settings.get 未挂载时的兜底）
 function defaultConfig() {
@@ -19,18 +19,6 @@ function defaultConfig() {
     animationEnabled: true,
     effectMode: 'flow',
     robotScale: 1.35,
-    notifyEnabled: true,
-    notifyOnComplete: true,
-    notifyOnError: true,
-    notifyOnConfirm: true,
-    notifyStayMs: 8000,
-    systemNotify: false,
-    soundNotify: true,
-    soundEffect: 'chime',
-    dingtalkEnabled: false,
-    dingtalkWebhook: '',
-    feishuEnabled: false,
-    feishuWebhook: '',
   }
 }
 
@@ -46,7 +34,6 @@ function readConfig(ctx) {
         if (a[key] !== undefined) cfg[key] = a[key]
       }
       if (!ANIMATION_MODES.includes(cfg.effectMode)) cfg.effectMode = 'flow'
-      if (!SOUND_EFFECTS.includes(cfg.soundEffect)) cfg.soundEffect = 'chime'
     }
   } catch { /* settings 未挂载，用默认 */ }
   return cfg
@@ -55,7 +42,7 @@ function readConfig(ctx) {
 export const feature = {
   id: 'animation',
   name: '任务动画',
-  description: '任务运行动画与完成通知（动画/通知独立开关，配置持久化）',
+  description: '19 种任务运行动画（速度随任务活动联动，配置持久化；通知见「任务通知」，任务状态见「运行状态」）',
   defaultEnabled: false,
   setup(ctx) {
     const disposers = []
@@ -66,428 +53,10 @@ export const feature = {
       }
     }
 
-    // ===== 会话级任务追踪（agent/status 驱动开始/结束，session/event 补统计） =====
-    const activeSessions = new Map() // sessionId -> 追踪记录
-    const completedSessions = [] // 最近完成（新→旧）
-    const MAX_COMPLETED = 30
-
-    function num(v) { return typeof v === 'number' && Number.isFinite(v) ? v : 0 }
-
-    function extractText(content) {
-      if (!Array.isArray(content)) return ''
-      const parts = []
-      for (const block of content) {
-        if (block && block.type === 'text' && typeof block.text === 'string') parts.push(block.text)
-      }
-      return parts.join(' ').replace(/\s+/g, ' ').trim()
-    }
-
-    function truncate(str, max = 160) {
-      if (!str) return ''
-      return String(str).length > max ? String(str).slice(0, max) + '…' : str
-    }
-
-    // ===== 任务阶段追踪（供桌面机器人等动效感知当前在干嘛） =====
-    // 流级实时同步（assistant/chunk，每 token 一条）：
-    //   reasoning-delta = 思考流 → think；text-delta = 正文输出流 → write
-    // 事件级：step/start = 思考；tool/call 按工具名分类：检索类 = search，其余 = code。
-    function phaseOfToolName(name) {
-      const n = String(name || '').toLowerCase()
-      if (/web|search|fetch|grep|glob|find|read|ls$|^ls|tree|locate/.test(n)) return 'search'
-      return 'code'
-    }
-
-    // 会话标题：官方标题服务，取不到回退首条用户输入（firstPrompt）
-    async function getSessionTitle(sessionId, sessionQuery) {
-      try {
-        if (!sessionQuery) return ''
-        if (typeof sessionQuery.readTitle === 'function') {
-          const snap = await sessionQuery.readTitle(sessionId)
-          if (snap && snap.title) return snap.title
-        }
-        if (typeof sessionQuery.readSession === 'function') {
-          const snap = await sessionQuery.readSession(sessionId)
-          if (snap && snap.header && snap.header.title) return snap.header.title
-        }
-      } catch { /* 标题取不到就用 firstPrompt 兜底 */ }
-      return ''
-    }
-
-    function addActiveSession(sid, sessionQuery, extra = {}) {
-      if (activeSessions.has(sid)) return activeSessions.get(sid)
-      console.log('[dsh-dock] animation: task started', sid.substring(0, 8))
-      const record = {
-        startTime: Date.now(),
-        title: '',
-        turns: 0,
-        steps: 0,
-        toolCalls: 0,
-        models: new Set(),
-        provider: '',
-        inputTokens: 0,
-        outputTokens: 0,
-        totalTokens: 0,
-        reasoningTokens: 0,
-        cacheReadTokens: 0,
-        endReason: '',
-        errorMessage: '',
-        lastText: '',
-        firstPrompt: '',
-        // 工具等待用户确认（dsh 会话流 approval/asked）：浏览器侧据此弹"需确认"通知
-        approvals: new Map(), // approvalId -> { toolName, reason, askedAt }
-        phase: 'think',
-        phaseAt: Date.now(),
-        lastActivityAt: Date.now(),
-        // assistant/chunk 是实时流；用轻量活动计数给浏览器侧映射动作速度，
-        // 不等最终 usage 落盘，避免任务正在输出时机器人仍慢速。
-        motionTicks: 0,
-        lastMotionAt: Date.now(),
-        ...extra,
-      }
-      activeSessions.set(sid, record)
-      getSessionTitle(sid, sessionQuery).then((title) => {
-        const s = activeSessions.get(sid)
-        if (s) s.title = title
-      })
-      return record
-    }
-
-    // 任务结束：归档 + 供客户端通知（通知由浏览器侧 diff 触发，这里只出数据）
-    function finishSession(sid) {
-      const session = activeSessions.get(sid)
-      if (!session) return
-      activeSessions.delete(sid)
-      const endTime = Date.now()
-      const duration = endTime - session.startTime
-      console.log('[dsh-dock] animation: task finished', {
-        sid: sid.substring(0, 8),
-        duration,
-        endReason: session.endReason || 'completed',
-      })
-      const record = {
-        sessionId: sid,
-        title: session.title || truncate(session.firstPrompt, 60) || '(无标题)',
-        duration,
-        turns: session.turns,
-        steps: session.steps,
-        toolCalls: session.toolCalls,
-        models: [...session.models],
-        provider: session.provider,
-        inputTokens: session.inputTokens,
-        outputTokens: session.outputTokens,
-        totalTokens: session.totalTokens,
-        reasoningTokens: session.reasoningTokens,
-        cacheReadTokens: session.cacheReadTokens,
-        endReason: session.endReason,
-        errorMessage: session.errorMessage,
-        lastText: session.lastText,
-        startTime: session.startTime,
-        endTime,
-      }
-      completedSessions.unshift(record)
-      if (completedSessions.length > MAX_COMPLETED) completedSessions.pop()
-      // 钉钉/飞书群机器人推送（宿主侧直发，异步不阻塞；事件筛选跟随 notifyOnComplete/notifyOnError）
-      pushDingtalkIfNeeded(record)
-      pushFeishuIfNeeded(record)
-    }
-
-    // ===== 钉钉群机器人推送（参照 @wycto/dsh-task-pulse 同款 markdown 消息） =====
-    const END_REASON_LABELS = {
-      completed: '✅ 完成',
-      aborted: '⛔ 已中止',
-      blocked: '🚧 受阻',
-      error: '❌ 出错',
-      'max-tokens': '⏹ 达到输出上限',
-      interrupted: '⚡ 中断',
-    }
-
-    function fmtDurCn(ms) {
-      const s = Math.max(0, Math.round((ms || 0) / 1000))
-      const h = Math.floor(s / 3600), m = Math.floor((s % 3600) / 60), sec = s % 60
-      if (h > 0) return `${h}小时${m}分${sec}秒`
-      if (m > 0) return `${m}分${sec}秒`
-      return `${sec}秒`
-    }
-    function pad2(n) { return String(n).padStart(2, '0') }
-    function fmtClockOf(ts) {
-      const d = new Date(ts)
-      return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`
-    }
-    function fmtDateClockOf(ts) {
-      const d = new Date(ts)
-      return `${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${fmtClockOf(ts)}`
-    }
-
-    // 钉钉与飞书共用的消息正文（各端再按各自 markdown 方言拼接）
-    function buildMessageLines(t) {
-      const success = !t.endReason || t.endReason === 'completed'
-      const reasonLabel = END_REASON_LABELS[t.endReason] || '✅ 完成'
-      const models = t.models.length > 0 ? t.models.join(', ') : '未知'
-      const lines = []
-      lines.push(`### ${success ? '✅' : '📢'} dsh 任务${success ? '完成' : '结束'}`)
-      lines.push(`**任务**: ${t.title}`)
-      lines.push(`**模型**: ${models}${t.provider ? `（${t.provider}）` : ''}`)
-      lines.push(`**耗时**: ${fmtDurCn(t.duration)}（${fmtClockOf(t.startTime)} → ${fmtClockOf(t.endTime)}）`)
-      lines.push(`**回合**: ${t.turns} · 步骤 ${t.steps}${t.toolCalls ? ` · 工具 ${t.toolCalls} 次` : ''}`)
-      lines.push(`**Token**: 输入 ${t.inputTokens.toLocaleString()} / 输出 ${t.outputTokens.toLocaleString()} / 总计 ${t.totalTokens.toLocaleString()}`)
-      lines.push(`**结果**: ${reasonLabel}${t.errorMessage ? `：${truncate(t.errorMessage, 120)}` : ''}`)
-      if (t.lastText) {
-        lines.push(`> ${truncate(t.lastText, 200)}`)
-      }
-      lines.push('---')
-      lines.push(`*由 dsh-dock 任务动画发送 · ${fmtDateClockOf(t.endTime)}*`)
-      return {
-        title: `dsh 任务${success ? '完成' : '结束'}：${truncate(t.title, 40)}`,
-        success,
-        lines,
-      }
-    }
-
-    function buildDingtalkMessage(t) {
-      const { title, lines } = buildMessageLines(t)
-      return {
-        title,
-        // 钉钉 markdown 不渲染单个 \n，行之间必须用空行分隔才能换行
-        text: lines.join('\n\n'),
-      }
-    }
-
-    // 飞书 interactive 卡片：标题进 header，正文走 lark_md（支持 **加粗** 与 \n 换行，不支持 ### 标题）
-    function buildFeishuMessage(t) {
-      const { title, success, lines } = buildMessageLines(t)
-      const body = lines.filter((l) => !l.startsWith('### ')).join('\n')
-      return {
-        title,
-        card: {
-          config: { wide_screen_mode: true },
-          header: {
-            template: success ? 'green' : 'orange',
-            title: { tag: 'plain_text', content: title },
-          },
-          elements: [
-            { tag: 'div', text: { tag: 'lark_md', content: body } },
-          ],
-        },
-      }
-    }
-
-    // 发送飞书 interactive 卡片；成功 = HTTP 200 且业务码 code/StatusCode === 0
-    async function sendFeishu(webhook, title, card) {
-      try {
-        const res = await fetch(webhook, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ msg_type: 'interactive', card }),
-        })
-        const raw = await res.text()
-        let data = null
-        try { data = JSON.parse(raw) } catch { /* 非 JSON 响应体 */ }
-        if (!res.ok) return { ok: false, error: `HTTP ${res.status} ${truncate(raw, 120)}` }
-        // 新版返回 { code, msg }，旧版返回 { StatusCode, StatusMessage }
-        const code = data && typeof data === 'object'
-          ? (typeof data.code === 'number' ? data.code : data.StatusCode)
-          : undefined
-        if (typeof code === 'number' && code !== 0) {
-          return { ok: false, error: `飞书 code ${code}：${data.msg || data.StatusMessage || ''}` }
-        }
-        return { ok: true }
-      } catch (e) {
-        return { ok: false, error: (e && e.message) || String(e) }
-      }
-    }
-
-    // 发送钉钉 markdown 消息；成功 = HTTP 200 且业务码 errcode === 0
-    async function sendDingtalk(webhook, title, text) {
-      try {
-        const res = await fetch(webhook, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ msgtype: 'markdown', markdown: { title, text } }),
-        })
-        const raw = await res.text()
-        let data = null
-        try { data = JSON.parse(raw) } catch { /* 非 JSON 响应体 */ }
-        if (!res.ok) return { ok: false, error: `HTTP ${res.status} ${truncate(raw, 120)}` }
-        if (data && typeof data.errcode === 'number' && data.errcode !== 0) {
-          return { ok: false, error: `钉钉 errcode ${data.errcode}：${data.errmsg || ''}` }
-        }
-        return { ok: true }
-      } catch (e) {
-        return { ok: false, error: (e && e.message) || String(e) }
-      }
-    }
-
-    async function pushDingtalkIfNeeded(record) {
-      try {
-        const cfg = readConfig(ctx)
-        if (!cfg.dingtalkEnabled || !cfg.dingtalkWebhook) return
-        const success = !record.endReason || record.endReason === 'completed'
-        if (success ? !cfg.notifyOnComplete : !cfg.notifyOnError) return
-        const { title, text } = buildDingtalkMessage(record)
-        const r = await sendDingtalk(cfg.dingtalkWebhook, title, text)
-        if (r.ok) console.log('[dsh-dock] animation dingtalk pushed:', title)
-        else console.error('[dsh-dock] animation dingtalk push failed:', r.error)
-      } catch (e) {
-        console.error('[dsh-dock] animation dingtalk push error:', e && e.message)
-      }
-    }
-
-    async function pushFeishuIfNeeded(record) {
-      try {
-        const cfg = readConfig(ctx)
-        if (!cfg.feishuEnabled || !cfg.feishuWebhook) return
-        const success = !record.endReason || record.endReason === 'completed'
-        if (success ? !cfg.notifyOnComplete : !cfg.notifyOnError) return
-        const { title, card } = buildFeishuMessage(record)
-        const r = await sendFeishu(cfg.feishuWebhook, title, card)
-        if (r.ok) console.log('[dsh-dock] animation feishu pushed:', title)
-        else console.error('[dsh-dock] animation feishu push failed:', r.error)
-      } catch (e) {
-        console.error('[dsh-dock] animation feishu push error:', e && e.message)
-      }
-    }
-
-    function handleSessionEvent(sessionQuery, session, event) {
-      const sid = typeof session === 'object' && session ? (session.id || '') : String(session || '')
-      if (!sid || !event || !event.type) return
-
-      if (event.type === 'step/start') {
-        const s = addActiveSession(sid, sessionQuery, { startTime: event.time || Date.now() })
-        s.steps++
-        s.phase = 'think' // 新步骤：模型正在推理下一步
-        s.phaseAt = event.time || Date.now()
-        s.lastActivityAt = s.phaseAt
-        s.motionTicks += 2
-        s.lastMotionAt = s.phaseAt
-        if (event.data && event.data.turn !== undefined) {
-          s.turns = Math.max(s.turns, num(event.data.turn) + 1)
-        }
-        return
-      }
-      const s = activeSessions.get(sid)
-      if (!s) return
-      const now = event.time || Date.now()
-      // 流级阶段：chunk 高频到达（每 token 一条），只做最廉价的阶段切换
-      if (event.type === 'assistant/chunk') {
-        const chunk = event.data && event.data.chunk
-        const ctype = chunk && chunk.type
-        if (ctype === 'reasoning-delta') {
-          s.phase = 'think'
-          s.phaseAt = now
-        } else if (ctype === 'text-delta') {
-          s.phase = 'write'
-          s.phaseAt = now
-        }
-        // 不同适配器的 delta 字段名并不完全一致。按可见文本量估算，
-        // 无文本时每个 chunk 也记一个脉冲，保证推理流同样有动作反馈。
-        if (ctype === 'reasoning-delta' || ctype === 'text-delta') {
-          const delta = chunk && (chunk.text || chunk.delta || chunk.content)
-          const units = typeof delta === 'string' ? Math.max(1, Math.ceil(delta.length / 24)) : 1
-          s.motionTicks += units
-          s.lastMotionAt = now
-        }
-        s.lastActivityAt = now
-        return
-      }
-      if (event.type === 'turn/end' && event.data && event.data.reason) {
-        const reason = event.data.reason
-        s.endReason = (reason.kind || 'completed')
-        if (reason.kind === 'error' && reason.error) {
-          const msg = (reason.error && (reason.error.message || reason.error.code)) || ''
-          s.errorMessage = typeof msg === 'string' ? msg : String(msg)
-        }
-      } else if (event.type === 'approval/asked' && event.data) {
-        // 工具等待用户确认/批准：挂在会话记录上，/status 下发给浏览器弹"需确认"通知
-        const id = typeof event.data.id === 'string' ? event.data.id : ''
-        if (id) {
-          s.approvals.set(id, {
-            toolName: typeof event.data.toolName === 'string' ? event.data.toolName : '',
-            reason: typeof event.data.reason === 'string' ? truncate(event.data.reason, 200) : '',
-            askedAt: event.time || Date.now(),
-          })
-        }
-        s.lastActivityAt = now
-      } else if (event.type === 'approval/decided' && event.data) {
-        s.approvals.delete(typeof event.data.id === 'string' ? event.data.id : '')
-      } else if (event.type === 'tool/call') {
-        s.toolCalls++
-        s.phase = phaseOfToolName(event.data && event.data.name)
-        s.phaseAt = now
-        // 工具启动是稀疏事件，给一个更明显的短促动作，检索/写文件也不会显得停住。
-        s.motionTicks += s.phase === 'search' ? 7 : 9
-        s.lastMotionAt = now
-      } else if (event.type === 'user/message') {
-        if (!s.firstPrompt && event.data && event.data.content) {
-          const text = extractText(event.data.content)
-          if (text) s.firstPrompt = text
-        }
-      } else if (event.type === 'assistant/message' && event.data) {
-        const usage = event.data.usage
-        if (usage) {
-          s.inputTokens += num(usage.inputTokens)
-          s.outputTokens += num(usage.outputTokens)
-          s.totalTokens += num(usage.inputTokens) + num(usage.outputTokens)
-          s.reasoningTokens += num(usage.reasoningTokens)
-          s.cacheReadTokens += num(usage.cacheReadTokens)
-        }
-        if (event.data.message && event.data.message.content) {
-          const text = extractText(event.data.message.content)
-          if (text) s.lastText = text
-        }
-        // 完整消息落盘后不改阶段：下一步要么 tool/call（code/search）要么收尾，
-        // 维持 chunk 推导出的最后状态，避免"输完还显示思考中"的回跳
-      } else if (event.type === 'request/context' && event.data) {
-        if (event.data.provider) s.provider = event.data.provider
-        if (event.data.model) s.models.add(event.data.model)
-      } else if (event.type === 'request/header' && event.data && event.data.header && event.data.header.config) {
-        const c = event.data.header.config
-        if (c.provider) s.provider = c.provider
-        if (c.model) s.models.add(c.model)
-      }
-      if (event.type !== 'request/header' && event.type !== 'request/context') s.lastActivityAt = now
-    }
-
-    function handleAgentStatus(sessionQuery, agent, status) {
-      const sid = agent && agent.id ? String(agent.id) : ''
-      if (!sid) return
-      if (status === 'running') {
-        const record = addActiveSession(sid, sessionQuery)
-        if (agent.options) {
-          if (agent.options.model) record.models.add(agent.options.model)
-          if (agent.options.provider) record.provider = agent.options.provider
-        }
-      } else if (status === 'idle') {
-        finishSession(sid)
-      }
-    }
-
-    // 不能在 setup 时软获取 sessionQuery（可能早于服务激活，见 tokenlog 模块同款注释），用 inject 等就绪
-    disposers.push(ctx.inject(['sessionQuery'], (sqCtx) => {
-      const sessionQuery = sqCtx.sessionQuery
-      disposers.push(sqCtx.on('session/event', (session, event) => {
-        try {
-          handleSessionEvent(sessionQuery, session, event)
-        } catch (err) {
-          console.error('[dsh-dock] animation handle event error', err)
-        }
-      }))
-      disposers.push(sqCtx.on('agent/status', (payload) => {
-        try {
-          handleAgentStatus(sessionQuery, payload && payload.agent, payload && payload.status)
-        } catch (err) {
-          console.error('[dsh-dock] animation handle agent/status error', err)
-        }
-      }))
-      // agent 销毁兜底归档（会话直接关闭时也产出完成记录）
-      disposers.push(sqCtx.on('agent/disposed', (payload) => {
-        try {
-          const sid = payload && payload.agent && payload.agent.id ? String(payload.agent.id) : ''
-          if (sid) finishSession(sid)
-        } catch (err) {
-          console.error('[dsh-dock] animation handle agent/disposed error', err)
-        }
-      }))
-    }))
+    // 会话级任务追踪（与【任务通知】共享一份；两个功能都停用后自动退订会话事件）
+    const lease = acquireTaskTracker(ctx)
+    disposers.push(() => lease.release())
+    const tracker = lease.tracker
 
     // ===== RPC 路由 =====
     disposers.push(ctx.inject(['webServer'], (wsCtx) => {
@@ -501,38 +70,9 @@ export const feature = {
             const payload = await readBody(req)
 
             if (method === 'status') {
-              const now = Date.now()
-              const active = []
-              for (const [sid, s] of activeSessions) {
-                active.push({
-                  sessionId: sid,
-                  title: s.title || truncate(s.firstPrompt, 60) || '(无标题)',
-                  startTime: s.startTime,
-                  elapsed: now - s.startTime,
-                  turns: s.turns,
-                  steps: s.steps,
-                  toolCalls: s.toolCalls,
-                  models: [...s.models],
-                  provider: s.provider,
-                  inputTokens: s.inputTokens,
-                  outputTokens: s.outputTokens,
-                  totalTokens: s.totalTokens,
-                  phase: s.phase,
-                  phaseAt: s.phaseAt,
-                  lastActivityAt: s.lastActivityAt,
-                  motionTicks: s.motionTicks,
-                  lastMotionAt: s.lastMotionAt,
-                  approvals: [...s.approvals.entries()].map(([id, v]) => ({ id, ...v })),
-                })
-              }
               return sendJson(res, 200, {
                 ok: true,
-                data: {
-                  now,
-                  active,
-                  recent: completedSessions.slice(0, 20),
-                  config: readConfig(ctx),
-                },
+                data: Object.assign({}, tracker.snapshot(Date.now()), { config: readConfig(ctx) }),
               })
             }
 
@@ -545,36 +85,6 @@ export const feature = {
               if (typeof p.robotScale === 'number' && Number.isFinite(p.robotScale)) {
                 cfg.robotScale = Math.max(0.85, Math.min(2.2, Math.round(p.robotScale * 100) / 100))
               }
-              if (typeof p.notifyEnabled === 'boolean') cfg.notifyEnabled = p.notifyEnabled
-              if (typeof p.notifyOnComplete === 'boolean') cfg.notifyOnComplete = p.notifyOnComplete
-              if (typeof p.notifyOnError === 'boolean') cfg.notifyOnError = p.notifyOnError
-              if (typeof p.notifyOnConfirm === 'boolean') cfg.notifyOnConfirm = p.notifyOnConfirm
-              if (typeof p.notifyStayMs === 'number' && Number.isFinite(p.notifyStayMs)) {
-                cfg.notifyStayMs = Math.max(0, Math.min(600000, Math.round(p.notifyStayMs)))
-              }
-              if (typeof p.systemNotify === 'boolean') cfg.systemNotify = p.systemNotify
-              if (typeof p.soundNotify === 'boolean') cfg.soundNotify = p.soundNotify
-              if (typeof p.soundEffect === 'string' && SOUND_EFFECTS.includes(p.soundEffect)) cfg.soundEffect = p.soundEffect
-              if (typeof p.dingtalkEnabled === 'boolean') cfg.dingtalkEnabled = p.dingtalkEnabled
-              if (typeof p.dingtalkWebhook === 'string') {
-                const hook = p.dingtalkWebhook.trim()
-                if (hook && !/^https?:\/\//i.test(hook)) {
-                  const err = new Error('钉钉 Webhook 地址需以 http(s):// 开头')
-                  err.statusCode = 400
-                  throw err
-                }
-                cfg.dingtalkWebhook = hook
-              }
-              if (typeof p.feishuEnabled === 'boolean') cfg.feishuEnabled = p.feishuEnabled
-              if (typeof p.feishuWebhook === 'string') {
-                const hook = p.feishuWebhook.trim()
-                if (hook && !/^https?:\/\//i.test(hook)) {
-                  const err = new Error('飞书 Webhook 地址需以 http(s):// 开头')
-                  err.statusCode = 400
-                  throw err
-                }
-                cfg.feishuWebhook = hook
-              }
 
               const settings = ctx.get('settings')
               if (!settings || typeof settings.mutate !== 'function') {
@@ -587,61 +97,10 @@ export const feature = {
                 err.statusCode = 400
                 throw err
               }
-              console.log('[dsh-dock] animation config saved:', cfg.effectMode, 'anim=' + cfg.animationEnabled, 'notify=' + cfg.notifyEnabled)
+              console.log('[dsh-dock] animation config saved:', cfg.effectMode, 'anim=' + cfg.animationEnabled)
               return sendJson(res, 200, { ok: true, data: { config: cfg, savedAt: Date.now() } })
             }
 
-            // 机器人连通性测试：payload.target 指定 'dingtalk'（默认）或 'feishu'，用当前已保存的 Webhook 发一条测试消息
-            if (method === 'test') {
-              const target = (payload && payload.target) === 'feishu' ? 'feishu' : 'dingtalk'
-              const cfgNow = readConfig(ctx)
-              const webhook = target === 'feishu' ? cfgNow.feishuWebhook : cfgNow.dingtalkWebhook
-              if (!webhook) {
-                const err = new Error(`请先填写并保存${target === 'feishu' ? '飞书' : '钉钉'} Webhook 地址`)
-                err.statusCode = 400
-                throw err
-              }
-              const nameCn = target === 'feishu' ? '飞书' : '钉钉'
-              let r
-              if (target === 'feishu') {
-                const text = [
-                  '**这是一条来自 dsh-dock 任务动画的测试消息。**',
-                  '',
-                  `**时间**: ${fmtDateClockOf(Date.now())}`,
-                  '',
-                  '看到这条消息说明飞书 Webhook 配置正确。',
-                  '',
-                  '---',
-                  '*由 dsh-dock 任务动画发送*',
-                ].join('\n')
-                const card = {
-                  config: { wide_screen_mode: true },
-                  header: {
-                    template: 'blue',
-                    title: { tag: 'plain_text', content: '🧪 dsh 任务动画测试' },
-                  },
-                  elements: [{ tag: 'div', text: { tag: 'lark_md', content: text } }],
-                }
-                r = await sendFeishu(webhook, 'dsh 任务动画测试', card)
-              } else {
-                const text = [
-                  '### 🧪 dsh 任务动画测试',
-                  '',
-                  '这是一条来自 dsh-dock 任务动画的测试消息。',
-                  '',
-                  `**时间**: ${fmtDateClockOf(Date.now())}`,
-                  '',
-                  '> 看到这条消息说明钉钉 Webhook 配置正确。',
-                  '',
-                  '---',
-                  '*由 dsh-dock 任务动画发送*',
-                ].join('\n')
-                r = await sendDingtalk(webhook, 'dsh 任务动画测试', text)
-              }
-              if (!r.ok) console.error(`[dsh-dock] animation ${target} test failed:`, r.error)
-              return sendJson(res, 200, { ok: true, data: { sent: r.ok, error: r.ok ? '' : r.error } })
-            }
-
             return sendJson(res, 404, { ok: false, error: { code: 'method-not-found', message: 'unknown method: ' + method } })
           } catch (e) {
             const status = e && e.statusCode ? e.statusCode : 500