@mrrisega/dsh-remote 0.8.0 → 0.8.1-beta.1

package/packages/dsh-remote-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.8.0",
+  "version": "0.8.1-beta.1",
   "description": "公网远程控制 DeepSeek Harness（dsh web）：安装即得专属加密地址，人在外面也能用手机访问电脑上的 dsh——无需同一局域网/WiFi、无需公网 IP 与内网穿透，全程加密；手机端 100% 还原电脑体验（对话/工具/审批/设置）。技术用户可选自建服务，流量走自己的服务器。Remote control DeepSeek Harness (dsh web) from anywhere over the public internet — install, get an encrypted URL, use it from your phone on any network (dual-half cordis plugin: Settings panel + same-origin /dsh-remote routes). (2026-09 由 dsh-remote-ui 更名 / renamed from dsh-remote-ui; dsh-remote 的 dsh web 插件半，不是纯 UI/皮肤插件)",
   "type": "module",
   "main": "lib/index.js",

package/packages/dsh-remote-web/runtime/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/packages/dsh-remote-web/runtime/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/packages/dsh-remote-web/runtime/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/packages/dsh-remote-web/runtime/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/packages/dsh-remote-web/runtime/clients/dsh-remote/wecom-bot.mjs

@@ -52,7 +52,12 @@ import WebSocket from "ws";
 
 import { createEventSubscriber, NODE_KINDS } from "./dsh-events.mjs";
 // 通道感知格式化（2026-11-08：企微/钉钉 markdown 不支持表格，发前统一适配；飞书/微信各有分支）
-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";
@@ -2053,102 +2058,42 @@ export function createWecomBot(options = {}) {
   }
 
   /**
-   * 这个 turn/end 是不是「我们刚转发进去的那次对话」的收尾？
+   * 任务通知（完成/出错/被拦/停止）：**一条**消息 = 标题行 + 总结正文。
    *
-   * 判据（宁可不回传，也不要瞎回传）：
-   *   · 必须**实时** turn/end（`fromSnapshot` = 重连时补报的旧 turn，绝不能拿旧回答当新回答）；
-   *   · 会话必须是最近一次入站转发成功的那个；
-   *   · 距那次入站 < TTL（默认 10 分钟）—— 超时就当另一次对话，走原来的标题通知；
-   *   · 事件时间不能早于入站时间（给 5s 时钟/批处理余量）。
+   * 正文优先订阅器 `lastAssistantText({sessionId})`（turn/end 瞬间可能还没落库 → 沿用旧短重试），
+   * 取不到再用事件字段、再取不到降级"仅标题"；正文按企业微信通道渲染并限制 1500 字。
+   * **日志只打长度/来源，绝不打印正文**（可能有代码/密钥/隐私）。
    */
-  function shouldRelayAnswer(node) {
-    if (!answerRelayEnabled) return false;
-    if (node.kind !== NODE_KINDS.TURN_END) return false;
-    if (node.fromSnapshot === true) return false;
-    if (!lastInbound.sessionId || node.sessionId !== lastInbound.sessionId) return false;
-    const at = now();
-    if (at - lastInbound.at >= answerRelayTtlMs) return false;
-    if (Number.isFinite(node.at) && node.at > 0 && node.at < lastInbound.at - 5000) return false;
-    return true;
+  async function sendTurnNotice(node, target) {
+    let summary = { text: "", source: "none" };
+    try {
+      summary = await extractTurnSummary({
+        node,
+        subscriber: answerRelayEnabled ? subscriber : null,
+        sessionId: node.sessionId,
+        maxChars: SUMMARY_MAX_CHARS,
+        retryDelays: answerRelayEnabled ? ANSWER_FETCH_RETRY_DELAYS_MS : null
+      });
+    } catch { summary = { text: "", source: "none" }; }
+    if (stopped) return;
+    const text = buildTurnNotification({
+      node,
+      channel: "wecom",
+      summary: summary.text,
+      sessionTitle: titleOfSession(node.sessionId, ""),
+      maxChars: SUMMARY_MAX_CHARS
+    });
+    if (!text) return;
+    log.info(`任务通知 kind=${node.kind} reason=${node.reason || "?"} summary=${summary.source} len=${Array.from(summary.text).length}`);
+    sendMarkdown(target, text);
   }
 
   /**
-   * 回答回传：把 agent 的最终回答正文发回企微（不再发「✅ 任务完成｜标题」那条）。
-   *
-   * 取正文用事件订阅器的 `lastAssistantText({sessionId})`（dsh-events 已有，永不抛）；
-   * 取不到 → **降级退回原来的标题通知**（不丢消息，也不假装有正文）；
-   * 日志只打长度/会话短 id，**绝不打印正文**（回答里可能有代码/密钥/隐私）。
+   * 事件订阅 → 出站通知。
+   * · turn/end、session-error：**一条**消息 = 标题行 + 总结正文（sendTurnNotice；同 turn 已去重）
+   * · 审批/提问/计划：优先可点卡片（**不混入总结**），卡片失败退回文本
+   * · 其它（简报/额度/会员/故障）：沿用 toMarkdownNotification
    */
-  async function relayAnswer(node, sessionId) {
-    const target = state.boundChatId || targetChatId;
-    if (!target) {
-      const at = now();
-      if (at - lastNoTargetLogAt > 10 * 60 * 1000) {
-        lastNoTargetLogAt = at;
-        log.info("有回答要回传，但还没绑定接收方：请先在企业微信里给机器人发一句话（或在配置里填 targetChatId）");
-      }
-      return;
-    }
-    let text = "";
-    let why = "";
-    const sub = subscriber;
-    if (!sub || typeof sub.lastAssistantText !== "function") {
-      why = "no_subscriber";
-    } else {
-      for (const delay of ANSWER_FETCH_RETRY_DELAYS_MS) {
-        if (delay > 0) {
-          await sleepTimer(delay);
-          if (stopped) return; // 等待期间桥已退出：不再发
-        }
-        try {
-          const r = await sub.lastAssistantText({ sessionId });
-          if (r && r.ok && typeof r.text === "string" && r.text.trim()) {
-            text = r.text.trim();
-            break;
-          }
-          why = String((r && (r.code || r.message)) || "empty");
-          // 硬失败（page-failed / session-not-found）重试也没意义；只有「ok 但正文还没落库」才补一次
-          if (!(r && r.ok)) break;
-        } catch (e) {
-          why = truncateText(e && e.message ? e.message : e, 60);
-          break;
-        }
-      }
-    }
-
-    // 降级：拿不到正文 → 退回标题通知（与改动前的行为一致）
-    if (!text) {
-      const fallback = toMarkdownNotification(node, { sessionTitle: options.sessionTitle });
-      if (!fallback) return;
-      if (!notifyRateOk()) {
-        log.warn("通知超过每分钟上限，已丢弃（防止事件风暴刷屏）");
-        return;
-      }
-      state.notified += 1;
-      sendMarkdown(target, fallback);
-      log.info(`取不到回答正文（${truncateText(why || "empty", 60)}），已降级为标题通知`);
-      return;
-    }
-
-    const truncated = text.length > answerMaxChars;
-    let body = truncated ? `${text.slice(0, answerMaxChars)}${ANSWER_TRUNCATED_NOTE}` : text;
-    // 非正常结束（出错/被拦/中止）时保留一句状态行，避免"看到回答却不知道它不完整"
-    const reasonKind = String(node.reason || "");
-    if (reasonKind && reasonKind !== "completed") {
-      const status = toMarkdownNotification(node, { sessionTitle: options.sessionTitle });
-      if (status) body = `${status}\n\n${body}`;
-    }
-    if (!notifyRateOk()) {
-      log.warn("通知超过每分钟上限，已丢弃（防止事件风暴刷屏）");
-      return;
-    }
-    state.notified += 1;
-    state.answers += 1;
-    const sent = sendMarkdown(target, body);
-    // 只打长度与截断标记：正文绝不能进日志
-    log.info(`回答回传 chat=${chatIdHash(target)} len=${body.length}${truncated ? "（已截断）" : ""}${sent && sent.ok ? "" : ` 发送失败=${(sent && sent.reason) || "?"}`}`);
-  }
-
   function onEventNode(node) {
     if (!node || typeof node !== "object") return;
     if (typeof node.sessionId === "string" && node.sessionId) {
@@ -2156,19 +2101,31 @@ export function createWecomBot(options = {}) {
       scheduleSessionRefresh();
     }
     if (stopped || !notifyAllowed || !state.authenticated) return;
-    // ── 回答回传：入站后的同一会话 turn/end → 发回答正文（消费一次）──
-    if (shouldRelayAnswer(node)) {
-      const key = notifyKey(node);
+    const key = notifyKey(node);
+    // ── 任务完成/出错：标题 + 总结正文（一次 turn 只发一条）──
+    if (node.kind === NODE_KINDS.TURN_END || node.kind === NODE_KINDS.SESSION_ERROR) {
       if (key && !rememberNotifyKey(key)) return;
-      const sid = node.sessionId;
+      const target = state.boundChatId || targetChatId;
+      if (!target) {
+        const at = now();
+        if (at - lastNoTargetLogAt > 10 * 60 * 1000) {
+          lastNoTargetLogAt = at;
+          log.info("有任务通知要发，但还没绑定接收方：请先在企业微信里给机器人发一句话（或在配置里填 targetChatId）");
+        }
+        return;
+      }
+      if (!notifyRateOk()) {
+        log.warn("通知超过每分钟上限，已丢弃（防止事件风暴刷屏）");
+        return;
+      }
+      state.notified += 1;
       lastInbound = { sessionId: "", at: 0 }; // 同一次入站只回传一次
-      void relayAnswer(node, sid);
+      void sendTurnNotice(node, target);
       return;
     }
     // ── 审批类事件：优先发**可点按钮的卡片**（允许一次/拒绝），发不出去再退回 markdown ──
     if (node.kind === NODE_KINDS.APPROVAL_REQUEST) {
       const markdown = toMarkdownNotification(node, { sessionTitle: options.sessionTitle });
-      const key = notifyKey(node);
       if (key && !rememberNotifyKey(key)) return;
       const requestId = String(node.eventId || "");
       const target = state.boundChatId || targetChatId;
@@ -2200,11 +2157,9 @@ export function createWecomBot(options = {}) {
     }
     const markdown = toMarkdownNotification(node, { sessionTitle: options.sessionTitle });
     if (!markdown) return;
-    const key = notifyKey(node);
     if (key && !rememberNotifyKey(key)) return;
     const target = state.boundChatId || targetChatId;
     if (!target) {
-      // 首次使用：用户还没给机器人发过话，也没有配 targetChatId → 无处可推（如实记日志，不刷屏）
       const at = now();
       if (at - lastNoTargetLogAt > 10 * 60 * 1000) {
         lastNoTargetLogAt = at;
@@ -2232,7 +2187,6 @@ export function createWecomBot(options = {}) {
 
   function rememberNotifyKey(key) {
     const at = now();
-    // 有界 + TTL：Map 保插入序，超上限丢最旧
     for (const [k, t] of notifiedKeys) {
       if (at - t > 10 * 60 * 1000) notifiedKeys.delete(k);
       else break;

package/packages/dsh-remote-web/runtime/dsh-setup.mjs

@@ -149,7 +149,7 @@ function findDepWs(startDir) {
  * 漏同步就会出现「入口脚本在、依赖不在」的半装运行时（插件半据此判定「运行环境已就绪」，
  * 却永远起不来 bridge —— 2026-09-23 用户反馈的现场）。`src/channel-ref.mjs` 同理（本安装器也 import）。
  */
-const RUNTIME_CLIENT_FILES = ["mobile-adapter.mjs", "dsh-bridge.mjs", "e2ee-shim.mjs", "e2ee-client.mjs", "e2ee-shim-script.js", "mobile-adapter.test.mjs", "wechat-channel.mjs", "dsh-events.mjs", "wechat-runtime.mjs", "wecom-bot.mjs", "im-format.mjs", "dingtalk-bot.mjs", "dingtalk-auth.mjs", "im-commands.mjs", "feishu-bot.mjs", "src/lifecycle.mjs", "src/channel-ref.mjs"];
+const RUNTIME_CLIENT_FILES = ["mobile-adapter.mjs", "dsh-bridge.mjs", "e2ee-shim.mjs", "e2ee-client.mjs", "e2ee-shim-script.js", "mobile-adapter.test.mjs", "wechat-channel.mjs", "dsh-events.mjs", "wechat-runtime.mjs", "wecom-bot.mjs", "im-format.mjs", "dingtalk-bot.mjs", "dingtalk-auth.mjs", "im-commands.mjs", "apply-pending-plugin.mjs", "feishu-bot.mjs", "src/lifecycle.mjs", "src/channel-ref.mjs"];
 
 /**
  * 把"客户端脚本"补齐到配置目录。