@mrrisega/dsh-remote 0.7.12-beta.6 → 0.8.0

package/clients/dsh-remote/apply-pending-plugin.mjs

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+/**
+ * 手动应用「待安装的插件更新」（桌面端专用）。
+ *
+ * 背景：桌面端应用运行期间**不能**改写它的 profile 目录（会让应用退出/重启）。
+ * 正常路径是：面板点「检查更新」→ 更新被暂存到 ~/.dsh-remote/pending-plugin/ +
+ * 写 `.plugin-update-pending.json` → 桥在**检测到应用退出后**自动替换。
+ *
+ * 但实测（2026-11-10）在部分机器上桥的"应用退出检测"没能触发（应用重启太快 /
+ * 桥被 launchd 重启导致计时清零 / 端口探测误判），于是用户反复重启仍停在旧版。
+ * 这个脚本就是那条链路的**手动、确定性版本**：应用完全退出后跑一次即可。
+ *
+ * 用法：
+ *   node ~/.dsh-remote/clients/dsh-remote/apply-pending-plugin.mjs
+ *   node ... --force        # 跳过"应用是否在运行"的检查（仅在确认已退出时用）
+ *   node ... --dry-run      # 只看会做什么，不动文件
+ *
+ * 安全：先复制到 `<插件目录>.staging-<pid>` → 校验必需文件 → 原子 rename 替换；
+ * 失败保留旧版并回滚。绝不删除用户数据。
+ */
+
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import os from "node:os";
+import { execSync } from "node:child_process";
+
+const RELAY_DIR = process.env.DSH_RELAY_DIR || path.join(os.homedir(), ".dsh-remote");
+const MARKER = path.join(RELAY_DIR, ".plugin-update-pending.json");
+const APPLIED = path.join(RELAY_DIR, ".plugin-update-applied.json");
+const REQUIRED = ["package.json", "lib/index.js", "lib/client.js", "cordis.patch.yml"];
+
+const args = new Set(process.argv.slice(2));
+const force = args.has("--force");
+const dryRun = args.has("--dry-run");
+
+function fail(msg) {
+  console.error(`✖ ${msg}`);
+  process.exit(1);
+}
+function ok(msg) {
+  console.log(`✔ ${msg}`);
+}
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return null; }
+}
+
+/** 桌面应用的 web 上游是否还活着（活=应用没退干净）。 */
+function probePort(port, timeoutMs = 500) {
+  return new Promise((resolve) => {
+    if (!port) return resolve(false);
+    const sock = net.connect({ host: "127.0.0.1", port });
+    let done = false;
+    const fin = (v) => { if (done) return; done = true; try { sock.destroy(); } catch { /* 忽略 */ } resolve(v); };
+    sock.setTimeout(timeoutMs, () => fin(false));
+    sock.once("connect", () => fin(true));
+    sock.once("error", () => fin(false));
+  });
+}
+
+/** 桌面应用进程是否在跑（macOS：DeepSeek Harness；Linux/其它：dsh web / electron）。 */
+function appProcessRunning() {
+  try {
+    const out = execSync("ps -axo pid=,command=", { encoding: "utf8", timeout: 4000 });
+    const self = process.pid;
+    return out
+      .split("\n")
+      .filter(Boolean)
+      .some((line) => {
+        const m = line.trim().match(/^(\d+)\s+(.*)$/);
+        if (!m) return false;
+        if (Number(m[1]) === self) return false;
+        const cmd = m[2];
+        if (/apply-pending-plugin\.mjs/.test(cmd)) return false;
+        return /DeepSeek Harness\.app\/Contents\/MacOS\/DeepSeek Harness/.test(cmd)
+          || /(?:^|\s)dsh(?:\s|$)/.test(cmd) && /web/.test(cmd)
+          || /electron.*dsh/i.test(cmd);
+      });
+  } catch {
+    return false; // 检测不可用 → 不阻塞（有 --force 语义兜底）
+  }
+}
+
+/** 从状态/上次日志里猜上游端口（应用每次启动端口随机）。 */
+function guessUpstreamPort() {
+  const st = readJson(path.join(RELAY_DIR, ".dsh-bridge-state.json")) || {};
+  for (const k of ["upstream", "upstream_url", "UPSTREAM"]) {
+    const v = st[k];
+    if (typeof v === "string" && /:\d+/.test(v)) {
+      try { return Number(new URL(v).port) || 0; } catch { /* 继续 */ }
+    }
+  }
+  return 0;
+}
+
+async function main() {
+  const marker = readJson(MARKER);
+  if (!marker) {
+    console.log("没有待安装的插件更新（marker 不存在）。");
+    console.log("如果面板刚点过「检查更新」，请先回到面板再点一次，然后再运行本命令。");
+    process.exit(0);
+  }
+  const stageDir = String(marker.stageDir || "");
+  const profileDir = String(marker.profileDir || "");
+  const name = String(marker.pluginDirName || "dsh-remote-web-plugin");
+  const version = String(marker.version || "?");
+  if (!stageDir || !profileDir || !fs.existsSync(stageDir)) {
+    fail(`暂存目录不存在：${stageDir || "(空)"}。请回面板重新点一次「检查更新」。`);
+  }
+  console.log(`待安装版本：${version}`);
+  console.log(`暂存目录：${stageDir}`);
+  console.log(`目标插件：${path.join(profileDir, name)}`);
+
+  const missing = REQUIRED.filter((rel) => !fs.existsSync(path.join(stageDir, rel)));
+  if (missing.length) fail(`暂存包不完整，缺少：${missing.join(", ")}。请回面板重新更新。`);
+
+  const port = guessUpstreamPort();
+  const portAlive = port ? await probePort(port) : false;
+  const procAlive = appProcessRunning();
+  const running = portAlive || procAlive;
+  if (running && !force) {
+    fail(
+      `检测到桌面应用仍在运行（${portAlive ? `127.0.0.1:${port} 在监听` : "进程还在"}）。\n` +
+      `   请先 Cmd+Q **完全退出** DeepSeek Harness（不是关窗口），再运行本命令。\n` +
+      `   若你确认已退出仍报这个错：加 --force 跳过检查。`
+    );
+  }
+  if (running && force) console.warn(`⚠️ 应用可能仍在运行（端口 ${port} 在监听），按 --force 继续；若应用崩溃请重开。`);
+
+  const dest = path.join(profileDir, name);
+  const stage = `${dest}.staging-${process.pid}`;
+  const backup = `${dest}.backup-${process.pid}`;
+
+  if (dryRun) {
+    console.log(`[dry-run] 将把 ${stageDir} 原子替换到 ${dest}（当前版本 ${readJson(path.join(dest, "package.json"))?.version || "?"}）`);
+    process.exit(0);
+  }
+
+  try {
+    fs.rmSync(stage, { recursive: true, force: true });
+    fs.cpSync(stageDir, stage, { recursive: true });
+    for (const rel of REQUIRED) {
+      if (!fs.existsSync(path.join(stage, rel))) throw new Error(`暂存包缺少 ${rel}`);
+    }
+    const had = fs.existsSync(dest);
+    if (had) {
+      fs.rmSync(backup, { recursive: true, force: true });
+      fs.renameSync(dest, backup);
+    }
+    try {
+      fs.renameSync(stage, dest);
+    } catch (e) {
+      if (had) { try { fs.renameSync(backup, dest); } catch { /* 忽略 */ } }
+      throw e;
+    }
+    if (had) { try { fs.rmSync(backup, { recursive: true, force: true }); } catch { /* 忽略 */ } }
+    try {
+      fs.writeFileSync(APPLIED, JSON.stringify({ version, appliedAt: Date.now(), profileDir, via: "manual-cli" }, null, 2) + "\n");
+    } catch { /* 忽略 */ }
+    try { fs.rmSync(MARKER, { force: true }); fs.rmSync(stageDir, { recursive: true, force: true }); } catch { /* 忽略 */ }
+    const nowVer = readJson(path.join(dest, "package.json"))?.version || "?";
+    ok(`插件已更新：${version} → 当前 ${nowVer}`);
+    console.log("现在可以重新打开 DeepSeek Harness（打开后版本与更新应显示新版本）。");
+  } catch (e) {
+    try { fs.rmSync(stage, { recursive: true, force: true }); } catch { /* 忽略 */ }
+    fail(`安装失败（已保留旧版）：${e && e.message ? e.message : e}`);
+  }
+}
+
+main();

package/clients/dsh-remote/dingtalk-bot.mjs

@@ -50,7 +50,12 @@ import { EventEmitter } from "node:events";
 import WebSocket from "ws";
 
 import { createEventSubscriber, NODE_KINDS } from "./dsh-events.mjs";
-import { formatForChannel } from "./im-format.mjs";
+import {
+  SUMMARY_MAX_CHARS,
+  buildTurnNotification,
+  extractTurnSummary,
+  formatForChannel
+} from "./im-format.mjs";
 // 命令层（2026-11-08）：/help /status /stop /ls /use /unbind 在进模型前拦下执行（三家共用）
 import { executeImCommand, writeImBotsSession } from "./im-commands.mjs";
 import {
@@ -1247,27 +1252,49 @@ export function createDingtalkBot(options = {}) {
     }
   }
 
+  /**
+   * 事件订阅 → 出站通知。
+   * · turn/end、session-error：**一条**消息 = 标题行 + 总结正文（同 turn 已去重）
+   * · 其它（审批/提问/简报…）：沿用 toMarkdownNotification（审批卡片由别处处理，不混入总结）
+   */
   function onEventNode(node) {
     if (!node || typeof node !== "object") return;
     if (typeof node.sessionId === "string" && node.sessionId) lastSeenSessionId = node.sessionId;
     if (stopped || !notifyAllowed || !state.authenticated) return;
-    // 回答回传：入站后的同一会话 turn/end → 把 agent 最终回答发回钉钉（与企微同语义）
-    if (shouldRelayAnswer(node)) {
-      const key = notifyKey(node);
+    const key = notifyKey(node);
+    if (node.kind === NODE_KINDS.TURN_END || node.kind === NODE_KINDS.SESSION_ERROR) {
       if (key && !rememberNotifyKey(key)) return;
-      const sid = node.sessionId;
+      if (!notifyRateOk()) { log.warn("通知超过每分钟上限，已丢弃（防止事件风暴刷屏）"); return; }
       lastInbound = { sessionId: "", at: 0 };
-      void relayAnswer(node, sid);
+      void sendTurnNotice(node).catch(() => {});
       return;
     }
     const markdown = toMarkdownNotification(node, { sessionTitle: options.sessionTitle });
     if (!markdown) return;
-    const key = notifyKey(node);
     if (key && !rememberNotifyKey(key)) return;
     if (!notifyRateOk()) { log.warn("通知超过每分钟上限，已丢弃（防止事件风暴刷屏）"); return; }
     void sendMarkdown(markdown).catch(() => {});
   }
 
+  /** 任务完成/出错通知：标题 + 总结正文（优先订阅器 lastAssistantText；取不到降级仅标题）。日志只打长度。 */
+  async function sendTurnNotice(node) {
+    let summary = { text: "", source: "none" };
+    try {
+      summary = await extractTurnSummary({ node, subscriber, sessionId: node.sessionId, maxChars: SUMMARY_MAX_CHARS });
+    } catch { summary = { text: "", source: "none" }; }
+    if (stopped) return;
+    const text = buildTurnNotification({
+      node,
+      channel: "dingtalk",
+      summary: summary.text,
+      sessionTitle: "",
+      maxChars: SUMMARY_MAX_CHARS
+    });
+    if (!text) return;
+    log.info(`任务通知 kind=${node.kind} reason=${node.reason || "?"} summary=${summary.source} len=${Array.from(summary.text).length}`);
+    await sendMarkdown(text);
+  }
+
   const notifiedKeys = new Map();
   const notifyTimes = [];
   function notifyKey(node) {
@@ -1292,30 +1319,6 @@ export function createDingtalkBot(options = {}) {
     notifyTimes.push(at);
     return true;
   }
-  function shouldRelayAnswer(node) {
-    if (node.kind !== NODE_KINDS.TURN_END) return false;
-    if (node.fromSnapshot === true) return false;
-    if (!lastInbound.sessionId || node.sessionId !== lastInbound.sessionId) return false;
-    if (now() - lastInbound.at >= 10 * 60 * 1000) return false;
-    if (Number.isFinite(node.at) && node.at > 0 && node.at < lastInbound.at - 5000) return false;
-    return true;
-  }
-  async function relayAnswer(node, sessionId) {
-    let text = "";
-    const sub = subscriber;
-    if (sub && typeof sub.lastAssistantText === "function") {
-      try {
-        const r = await sub.lastAssistantText({ sessionId });
-        if (r && r.ok && typeof r.text === "string") text = r.text.trim();
-      } catch { /* 忽略 */ }
-    }
-    const markdown = text || toMarkdownNotification(node, { sessionTitle: options.sessionTitle }) || "";
-    if (!markdown) return;
-    if (!notifyRateOk()) { log.warn("通知超过每分钟上限，已丢弃（防止事件风暴刷屏）"); return; }
-    const r = await sendMarkdown(markdown);
-    log.info(`回答回传 chat=${chatIdHash(state.boundChatId) || "?"} len=${markdown.length}${r && r.ok ? "" : ` 发送失败=${(r && r.reason) || "?"}`}`);
-  }
-
   // ---------- 对外 API ----------
 
   function shortSession(sessionId) {

package/clients/dsh-remote/feishu-bot.mjs

@@ -80,7 +80,12 @@ import {
   IM_BOT_STATUS_FILE,
   APPROVAL_CARD_TTL_MS
 } from "./wecom-bot.mjs";
-import { formatForChannel } from "./im-format.mjs";
+import {
+  SUMMARY_MAX_CHARS,
+  buildTurnNotification,
+  extractTurnSummary,
+  formatForChannel
+} from "./im-format.mjs";
 // 命令层（2026-11-08）：/help /status /stop /ls /use /unbind 在进模型前拦下执行（三家共用）
 import { executeImCommand, writeImBotsSession } from "./im-commands.mjs";
 import {
@@ -1544,6 +1549,26 @@ export function createFeishuBotController(options = {}) {
       log.warn("通知超过每分钟上限，已丢弃（防事件风暴）");
       return;
     }
+    // 任务完成/出错：**一条**消息 = 标题行 + 总结正文（同 turn 已去重；审批类不混入总结）
+    if (node.kind === NODE_KINDS.TURN_END || node.kind === NODE_KINDS.SESSION_ERROR) {
+      const key = notifyKey(node);
+      if (key && !rememberNotifyKey(key)) return;
+      let summary = { text: "", source: "none" };
+      try {
+        summary = await extractTurnSummary({ node, subscriber, sessionId: node.sessionId, maxChars: SUMMARY_MAX_CHARS });
+      } catch { summary = { text: "", source: "none" }; }
+      const text = buildTurnNotification({
+        node,
+        channel: "feishu",
+        summary: summary.text,
+        sessionTitle: String((configNow && configNow.sessionTitle) || ""),
+        maxChars: SUMMARY_MAX_CHARS
+      });
+      if (!text) return;
+      log.info(`任务通知 kind=${node.kind} reason=${node.reason || "?"} summary=${summary.source} len=${Array.from(summary.text).length}`);
+      await bot.sendText(target, text);
+      return;
+    }
     // 审批：优先卡片（可点按钮）
     if (node.kind === NODE_KINDS.APPROVAL_REQUEST) {
       const key = notifyKey(node);

package/clients/dsh-remote/im-format.mjs

@@ -35,6 +35,8 @@ export const CHANNEL_CAPS = Object.freeze({
 
 /** 截断提示（与 wecom-bot 的 ANSWER_TRUNCATED_NOTE 同文，便于去重）。 */
 export const TRUNCATED_NOTE = "…(已截断，完整内容看电脑)";
+/** 完成/出错通知里「总结正文」的长度上限（2026-11-10 业主：只有标题没有总结）。 */
+export const SUMMARY_MAX_CHARS = 1500;
 
 /** 各通道默认字节上限（wecom 官方 4096；其它先给宽松值，留 maxBytes 覆盖）。 */
 const DEFAULT_MAX_BYTES = Object.freeze({
@@ -370,3 +372,106 @@ export function formatForChannel(channel, options = {}) {
   }
   return fitted;
 }
+
+
+// ===========================================================================
+// 任务总结（turn_done / turn_error / turn_blocked 通知带正文）
+// ===========================================================================
+
+function charsOf(text) { return Array.from(String(text == null ? "" : text)); }
+
+function truncateChars(text, maxChars) {
+  const chars = charsOf(text);
+  if (!Number.isFinite(maxChars) || maxChars <= 0 || chars.length <= maxChars) return String(text == null ? "" : text);
+  return `${chars.slice(0, Math.max(1, maxChars - 1)).join("")}…`;
+}
+
+/** 截断到 maxChars（含「已截断」提示；与 formatForChannel 的提示同文，避免重复）。 */
+function truncateCharsWithNote(text, maxChars) {
+  let body = String(text == null ? "" : text);
+  const hadNote = body.endsWith(TRUNCATED_NOTE);
+  if (hadNote) body = body.slice(0, -TRUNCATED_NOTE.length).replace(/\s+$/, "");
+  const chars = charsOf(body);
+  if (!Number.isFinite(maxChars) || maxChars <= 0) return hadNote ? `${body}${TRUNCATED_NOTE}` : body;
+  const noteChars = charsOf(TRUNCATED_NOTE).length + 1; // 换行 + 提示一起算进上限
+  if (chars.length + noteChars <= maxChars) return hadNote ? `${body}${TRUNCATED_NOTE}` : body;
+  const budget = Math.max(1, maxChars - noteChars);
+  return `${chars.slice(0, budget).join("").replace(/\s+$/, "")}\n${TRUNCATED_NOTE}`;
+}
+
+/** 事件里能当"摘要"的字段（订阅器取不到正文时的降级来源）。 */
+export function extractSummaryFromNode(node) {
+  if (!node || typeof node !== "object") return "";
+  for (const key of ["summary", "message", "detail", "text"]) {
+    const v = node[key];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return "";
+}
+
+/**
+ * 提取一次 turn 的**总结正文**（优先级：订阅器 lastAssistantText → 事件字段 → 空）。
+ *
+ * · `subscriber.lastAssistantText({sessionId})` 是最准的（agent 最终回答原文）；
+ * · turn/end 瞬间正文可能还没落库 → 支持 `retryDelays`（如 [0,400]）短重试；
+ * · 都取不到 → 返回空 text（调用方降级"仅标题"，不报错）；
+ * · 返回值只含正文；**日志由调用方只打长度**（正文可能有代码/密钥/隐私）。
+ *
+ * @returns {Promise<{text:string, source:"assistant"|"node"|"none"}>}
+ */
+export async function extractTurnSummary({ node, subscriber, sessionId, maxChars = SUMMARY_MAX_CHARS, retryDelays = null } = {}) {
+  const sid = String(sessionId || (node && node.sessionId) || "");
+  const delays = Array.isArray(retryDelays) && retryDelays.length ? retryDelays : [0];
+  let lastEmpty = "";
+  if (subscriber && typeof subscriber.lastAssistantText === "function" && sid) {
+    for (const delay of delays) {
+      if (Number(delay) > 0) {
+        try { await new Promise((r) => setTimeout(r, Math.min(Number(delay) || 0, 5000))); } catch { /* 忽略 */ }
+      }
+      try {
+        const r = await subscriber.lastAssistantText({ sessionId: sid });
+        if (r && r.ok === true && typeof r.text === "string" && r.text.trim()) {
+          return { text: truncateCharsWithNote(r.text.trim(), maxChars), source: "assistant" };
+        }
+        lastEmpty = String((r && (r.code || r.message)) || "empty");
+      } catch { /* 下一次重试 */ }
+    }
+  }
+  const fallback = extractSummaryFromNode(node);
+  if (fallback) return { text: truncateCharsWithNote(fallback, maxChars), source: "node" };
+  return { text: "", source: "none", reason: lastEmpty };
+}
+
+/** 各 reason 的通知首行（与既有通知文案保持一致）。 */
+export function turnHeadline(node) {
+  if (!node || typeof node !== "object") return "";
+  const kind = String(node.kind || "");
+  if (kind === "session-error") return "❌ 出错了";
+  if (kind !== "turn-end") return "";
+  const reason = String(node.reason || "unknown");
+  if (reason === "completed") return "✅ 任务完成";
+  if (reason === "error" || reason === "max-tokens") return "❌ 出错了";
+  if (reason === "blocked") return "⛔ 被拦下了";
+  if (reason === "aborted" || reason === "interrupted") return "⏹ 已停止";
+  return "ℹ️ 任务结束";
+}
+
+/**
+ * 组装「任务完成/出错」通知：`✅ 任务完成｜<标题>\n\n<总结正文>`。
+ *
+ * · 正文为空 → 只返回标题行（降级，不报错）；
+ * · 正文按通道渲染（表格转可读列表、按通道字节上限截断），并限制 **1500 字**；
+ * · 非 turn/session-error 事件返回 null（审批类仍走卡片，不混入总结）。
+ *
+ * @returns {string|null}
+ */
+export function buildTurnNotification({ node, channel = "wecom", summary = "", sessionTitle = "", maxChars = SUMMARY_MAX_CHARS } = {}) {
+  const head = turnHeadline(node);
+  if (!head) return null;
+  const title = truncateChars(String(sessionTitle || "").replace(/\s+/g, " ").trim(), 40);
+  const line = title ? `${head}｜${title}` : head;
+  const raw = String(summary == null ? "" : summary).trim();
+  if (!raw) return line; // 取不到正文 → 保持"仅标题"
+  const formatted = formatForChannel(channel, { text: raw, maxChars });
+  return formatted ? `${line}\n\n${formatted}` : line;
+}

package/clients/dsh-remote/test/dingtalk-bot.test.mjs

@@ -845,3 +845,82 @@ test("★ 命令层：/help 回复、免费档 /ls 被拦（会员文案）、/s
     await waitFor(() => rt.sub.calls.prompt.length === 1, { label: "普通文本转发" });
   } finally { await rt.close(); }
 });
+
+// ─────────────────────── 任务通知带总结（2026-11-10：只有"已完成"没有总结）───────────────────────
+
+test("★ 任务通知带总结（钉钉）：turn_done → 一条「✅ 任务完成 + 正文」（表格转列表）；同 turn 去重；正文不进日志", async () => {
+  const answer = "修复完成：\n\n| 文件 | 改动 |\n|---|---|\n| a.mjs | 修端口 |\n| b.mjs | 加缓存 |";
+  const rt = await setupBot({ subOptions: { answer } });
+  try {
+    await rt.start();
+    await rt.inbound({ text: "给我看改动", msgId: "sum-in-1" });
+    await waitFor(() => rt.sub.calls.prompt.length === 1, { label: "入站转发" });
+    const turn = { kind: "turn-end", sessionId: "session-live", turn: 1, seq: 41, reason: "completed", at: Date.now() };
+    rt.sub.emit("event", { ...turn });
+    const call = await waitFor(() => rt.hook.state.calls.find((c) => c.body.markdown.text.includes("任务完成")), { label: "任务通知" });
+    const text = call.body.markdown.text;
+    assert.match(text, /^✅ 任务完成/, "★ 通知带「任务完成」标题行");
+    assert.match(text, /\n\n修复完成：/, "★ 同一条消息带总结正文");
+    assert.match(text, /• 文件：a\.mjs · 改动：修端口/, "★ 表格转可读列表");
+    assert.ok(!/\|\s*-{2,}/.test(text), "★ 不得有裸表格");
+    // 同 turn 重复事件 → 去重
+    const before = rt.hook.state.calls.filter((c) => c.body.markdown.text.includes("任务完成")).length;
+    rt.sub.emit("event", { ...turn });
+    await sleep(60);
+    assert.equal(rt.hook.state.calls.filter((c) => c.body.markdown.text.includes("任务完成")).length, before, "★ 同 turn 只发一条");
+    // 正文不进日志（只打 len）
+    const logs = rt.logs.join("\n");
+    assert.ok(!logs.includes("修复完成"), "★ 总结正文绝不能进日志");
+    assert.ok(logs.split("\n").some((l) => /任务通知 .*len=\d+/.test(l)), "日志只记长度");
+  } finally { await rt.close(); }
+});
+
+test("★ 任务通知边界（钉钉）：缺正文降级仅标题；超长按 1500 字截断+注明；出错带错误摘要；审批不混入总结", async () => {
+  // ① 缺正文 → 仅标题
+  {
+    const rt = await setupBot({ subOptions: { answer: "" } });
+    try {
+      await rt.start();
+      await rt.inbound({ text: "hi", msgId: "sum-2" });
+      await waitFor(() => rt.sub.calls.prompt.length === 1, { label: "入站" });
+      rt.sub.emit("event", { kind: "turn-end", sessionId: "session-live", turn: 1, seq: 51, reason: "completed", at: Date.now() });
+      const call = await waitFor(() => rt.hook.state.calls.find((c) => c.body.markdown.text.includes("任务完成")), { label: "降级标题" });
+      assert.equal(call.body.markdown.text, "✅ 任务完成", "★ 取不到正文 → 仅标题（不多空段）");
+    } finally { await rt.close(); }
+  }
+  // ② 超长 → 截断 + 注明；出错 → ❌ + 摘要
+  {
+    const rt = await setupBot({ subOptions: { answer: "开头" + "长".repeat(3000) + "SECRET-TAIL" } });
+    try {
+      await rt.start();
+      await rt.inbound({ text: "hi", msgId: "sum-3" });
+      await waitFor(() => rt.sub.calls.prompt.length === 1, { label: "入站" });
+      rt.sub.emit("event", { kind: "turn-end", sessionId: "session-live", turn: 1, seq: 61, reason: "completed", at: Date.now() });
+      const call = await waitFor(() => rt.hook.state.calls.find((c) => c.body.markdown.text.includes("任务完成")), { label: "截断通知" });
+      const text = call.body.markdown.text;
+      assert.ok(text.endsWith("…(已截断，完整内容看电脑)"), "超长正文要带截断提示");
+      const body = text.split("\n\n").slice(1).join("\n\n");
+      assert.ok(Array.from(body).length <= 1500 + 20, "正文不超过 1500 字（+提示）");
+      assert.ok(!text.includes("SECRET-TAIL"));
+      assert.ok(!rt.logs.join("\n").includes("SECRET-TAIL"), "★ 正文不进日志");
+      // 出错：❌ 标题 + 摘要
+      rt.sub.emit("event", { kind: "turn-end", sessionId: "session-live", turn: 2, seq: 62, reason: "error", at: Date.now() });
+      const err = await waitFor(() => rt.hook.state.calls.find((c) => c.body.markdown.text.startsWith("❌ 出错了")), { label: "出错通知" });
+      assert.match(err.body.markdown.text, /\n\n开头/, "出错也要带错误摘要");
+    } finally { await rt.close(); }
+  }
+  // ③ 审批事件不混入总结（走普通通知，不是 ✅ 任务完成）——先入站绑定回复通道
+  {
+    const rt = await setupBot({ subOptions: { answer: "审批不该出现的总结" } });
+    try {
+      await rt.start();
+      await rt.inbound({ text: "准备审批", msgId: "sum-apr-bind" });
+      await waitFor(() => rt.sub.calls.prompt.length === 1, { label: "入站绑定" });
+      const before = rt.hook.state.calls.length;
+      rt.sub.emit("event", { kind: "approval-request", eventId: "apr_sum_1", toolName: "Bash", sessionId: "session-live" });
+      const call = await waitFor(() => rt.hook.state.calls.slice(before).find((c) => c.body.markdown.text.includes("拍板") || c.body.markdown.text.includes("审批")), { label: "审批通知" });
+      assert.ok(!/^✅ 任务完成/.test(call.body.markdown.text), "★ 审批类不得混入任务总结");
+      assert.ok(!call.body.markdown.text.includes("审批不该出现的总结"), "★ 审批通知不带总结正文");
+    } finally { await rt.close(); }
+  }
+});

package/clients/dsh-remote/test/feishu-bot.test.mjs

@@ -150,10 +150,11 @@ function makeFetch({ tokenCode = 0, sendCode = 0, sendMsg = "", patchCode = 0 }
 }
 
 // ── 假事件订阅器 ──────────────────────────────────────────────────────────
-function makeSubscriber() {
+function makeSubscriber({ answer = { ok: true, text: "" } } = {}) {
   const emitter = new EventEmitter();
-  const calls = { sessions: [], prompts: [], cancels: [], started: 0, stopped: 0, listenSessions: 0 };
+  const calls = { sessions: [], prompts: [], cancels: [], assistant: [], started: 0, stopped: 0, listenSessions: 0 };
   return {
+    lastAssistantText: async ({ sessionId } = {}) => { calls.assistant.push({ sessionId }); return answer; },
     calls,
     on: (evt, cb) => emitter.on(evt, cb),
     emit: (evt, arg) => emitter.emit(evt, arg),
@@ -1119,3 +1120,75 @@ test("controller：命令层 — /help 直接回复、免费档 /ls 被拦、/st
   assert.equal(sub.calls.prompts.length, 1);
   await controller.stop();
 });
+
+// ─────────────────────── 任务通知带总结（2026-11-10：只有"已完成"没有总结）───────────────────────
+
+test("controller：任务通知带总结 — turn_end → 一条「✅ 任务完成 + 正文」；同 turn 去重；正文不进日志；缺正文降级", async () => {
+  const relayDir = mkRelayDir("ctl-summary");
+  writeConfig(relayDir, { enabled: true, appId: APP_ID, appSecret: APP_SECRET, receiveId: "ou_owner", receiveIdType: "open_id" });
+  const sub = makeSubscriber({ answer: { ok: true, text: "飞书总结正文" } });
+  const { controller, fetchCalls, logs } = startController(relayDir, { subscriber: sub });
+  await controller.start();
+  const texts = () => fetchCalls.filter((c) => c.url.includes("/im/v1/messages") && JSON.parse(c.body).msg_type === "text");
+  const contentOf = (row) => JSON.parse(JSON.parse(row.body).content).text;
+  const ev = { kind: "turn-end", sessionId: "session-abc", turn: 1, seq: 7, reason: "completed", at: NOW };
+  sub.emit("event", ev);
+  await waitFor(() => texts().some((t) => contentOf(t).includes("任务完成")));
+  const row = texts().find((t) => contentOf(t).includes("任务完成"));
+  const text = contentOf(row);
+  assert.match(text, /^✅ 任务完成/, "★ 通知带「任务完成」标题行");
+  assert.match(text, /\n\n飞书总结正文$/, "★ 同一条消息带总结正文");
+  const count = texts().filter((t) => contentOf(t).includes("任务完成")).length;
+  assert.equal(count, 1, "★ 同一次 turn 只发一条（不拆标题+正文两条）");
+  // 重复 turn/end → 去重
+  sub.emit("event", ev);
+  await new Promise((r) => setTimeout(r, 40));
+  assert.equal(texts().filter((t) => contentOf(t).includes("任务完成")).length, 1, "★ 同 turn 重复事件去重");
+  // 正文绝不进日志
+  assert.ok(!logs.join("\n").includes("飞书总结正文"), "★ 总结正文绝不能进日志");
+  assert.ok(logs.some((l) => /任务通知 .*len=\d+/.test(l)), "日志只记长度");
+  await controller.stop();
+});
+
+test("controller：任务通知 — 缺正文降级仅标题；超长按 1500 字截断；出错带错误摘要；审批仍走卡片不混入总结", async () => {
+  // ① 缺正文 → 仅标题
+  {
+    const relayDir = mkRelayDir("ctl-summary-none");
+    writeConfig(relayDir, { enabled: true, appId: APP_ID, appSecret: APP_SECRET, receiveId: "ou_owner", receiveIdType: "open_id" });
+    const sub = makeSubscriber(); // 默认 answer={ok:true,text:""}
+    const { controller, fetchCalls } = startController(relayDir, { subscriber: sub });
+    await controller.start();
+    const texts = () => fetchCalls.filter((c) => c.url.includes("/im/v1/messages") && JSON.parse(c.body).msg_type === "text");
+    const contentOf = (row) => JSON.parse(JSON.parse(row.body).content).text;
+    sub.emit("event", { kind: "turn-end", sessionId: "session-abc", turn: 1, seq: 8, reason: "completed", at: NOW });
+    await waitFor(() => texts().some((t) => contentOf(t).includes("任务完成")));
+    assert.equal(contentOf(texts().find((t) => contentOf(t).includes("任务完成"))), "✅ 任务完成", "★ 缺正文 → 仅标题");
+    await controller.stop();
+  }
+  // ② 超长 → 截断 + 注明；出错 → ❌ + 摘要
+  {
+    const relayDir = mkRelayDir("ctl-summary-long");
+    writeConfig(relayDir, { enabled: true, appId: APP_ID, appSecret: APP_SECRET, receiveId: "ou_owner", receiveIdType: "open_id" });
+    const sub = makeSubscriber({ answer: { ok: true, text: "开头" + "长".repeat(3000) + "SECRET-TAIL" } });
+    const { controller, fetchCalls, logs } = startController(relayDir, { subscriber: sub });
+    await controller.start();
+    const texts = () => fetchCalls.filter((c) => c.url.includes("/im/v1/messages") && JSON.parse(c.body).msg_type === "text");
+    const contentOf = (row) => JSON.parse(JSON.parse(row.body).content).text;
+    sub.emit("event", { kind: "turn-end", sessionId: "session-abc", turn: 1, seq: 9, reason: "completed", at: NOW });
+    await waitFor(() => texts().some((t) => contentOf(t).includes("任务完成")));
+    const text = contentOf(texts().find((t) => contentOf(t).includes("任务完成")));
+    assert.ok(text.endsWith("…(已截断，完整内容看电脑)"), "超长正文带截断提示");
+    assert.ok(!text.includes("SECRET-TAIL"));
+    assert.ok(!logs.join("\n").includes("SECRET-TAIL"), "★ 正文不进日志");
+    sub.emit("event", { kind: "turn-end", sessionId: "session-abc", turn: 2, seq: 10, reason: "error", at: NOW });
+    await waitFor(() => texts().some((t) => contentOf(t).startsWith("❌ 出错了")));
+    assert.match(contentOf(texts().find((t) => contentOf(t).startsWith("❌ 出错了"))), /^❌ 出错了\n\n开头/);
+    // ③ 审批事件：仍走 interactive 卡片（不混入任务总结）
+    sub.emit("event", { kind: "approval-request", eventId: "apr_sum_feishu", toolName: "Bash", sessionId: "session-abc" });
+    await waitFor(() => fetchCalls.some((c) => c.url.includes("/im/v1/messages") && JSON.parse(c.body).msg_type === "interactive"));
+    const card = fetchCalls.filter((c) => c.url.includes("/im/v1/messages") && JSON.parse(c.body).msg_type === "interactive").pop();
+    assert.ok(card, "★ 审批仍走卡片");
+    assert.ok(!JSON.parse(card.body).content.includes("任务完成"), "★ 卡片不混入总结");
+    await controller.stop();
+  }
+});