@mrrisega/dsh-remote 0.7.12-beta.5 → 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,14 @@ 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 {
   WECHAT_CAPABILITY_TABLE,
   WECHAT_TIER_LIMITS,
@@ -91,6 +98,15 @@ export const TOPIC_CARD_CALLBACK = "/v1.0/card/instances/callback";
 export const DEFAULT_SUBSCRIPTIONS = Object.freeze([{ type: "CALLBACK", topic: TOPIC_ROBOT }]);
 /** ticket 有效期（官方：90s / 一次性）。状态文件只记过期时间，不存 ticket。 */
 export const TICKET_TTL_MS = 90_000;
+/**
+ * 回复通道持久化文件（相对 relayDir；0600）：缓存最近一次入站带来的
+ * `{sessionWebhook, sessionWebhookExpiredTime, senderStaffId, conversationId, conversationType, boundChatId, at}`。
+ * 为什么不写状态文件：sessionWebhook 里带会话令牌，状态文件是给面板/浏览器看的（只放元数据）。
+ * 为什么要落盘：进程重启后「回答回传」仍要能发出去（Lead 实测 bug：只存内存会丢，回传直接发不出）。
+ */
+export const REPLY_FILE = "im-dingtalk-reply.json";
+/** webhook 过期后降级 openapi 时给用户/日志的明确原因（面板据此提示"再发一条消息激活"）。 */
+const NO_REPLY_CHANNEL_HINT = "回复通道不可用：请在钉钉里再发一条消息激活（或配置 robotCode 走 OpenAPI）";
 /** 重连退避：1s 起、翻倍、60s 封顶（+0~1s 抖动，照官方 SDK 行为）。 */
 export const RECONNECT_BASE_MS = 1_000;
 export const RECONNECT_MAX_MS = 60_000;
@@ -189,8 +205,8 @@ export function normalizeBotMessage(data) {
     sessionWebhookExpiredTime: Number(d.sessionWebhookExpiredTime) || 0,
     robotCode: String(d.robotCode || ""),
     createAt: Number(d.createAt) || 0,
-    /** 主动发消息/去重用的目标：群=conversationId，单聊=senderStaffId。 */
-    chatId: conversationId || senderStaffId,
+    /** 主动发消息/去重用的目标：群=conversationId，单聊=senderStaffId（单聊 conversationId 不能当 chatId，否则会被误判成群聊）。 */
+    chatId: (conversationType === "2" ? conversationId : senderStaffId) || conversationId || senderStaffId,
     raw: d
   };
 }
@@ -277,8 +293,8 @@ export function createDingtalkBot(options = {}) {
   const relayDir = options.relayDir ? String(options.relayDir) : "";
   const allowFrom = normalizeAllowList(options.allowFrom);
   const targetChatId = String(options.targetChatId || "").trim();
-  const configuredSessionId = String(options.configuredSessionId || "").trim();
-  const configuredSessionTitle = truncateText(options.configuredSessionTitle || "", 60);
+  let configuredSessionId = String(options.configuredSessionId || "").trim();
+  let configuredSessionTitle = truncateText(options.configuredSessionTitle || "", 60);
   const now = typeof options.clock === "function" ? options.clock : () => Date.now();
   const doFetch = typeof options.fetchImpl === "function" ? options.fetchImpl : globalThis.fetch;
   const wsFactory = typeof options.wsFactory === "function" ? options.wsFactory : (url) => new WebSocket(url);
@@ -322,7 +338,9 @@ export function createDingtalkBot(options = {}) {
     boundSessionWebhook: "",
     boundSessionWebhookExpiredAt: 0,
     messages: 0,
-    gated: 0
+    gated: 0,
+    /** 最近一次回复失败原因（人话；写状态 replyChannel.lastError，不覆盖连接错误）。 */
+    replyChannelError: ""
   };
   const membership = { tier: "", entitlements: null, checkedAt: 0, usage: { month: "", count: 0 } };
 
@@ -355,6 +373,19 @@ export function createDingtalkBot(options = {}) {
   // 配置里持久化的 sessionWebhook（插件/上次运行留下的）：首次入站前也能主动发；
   // ⚠️ webhook 里带会话令牌，**绝不写状态文件**，只在内存里用。
   if (options.sessionWebhook) state.boundSessionWebhook = String(options.sessionWebhook || "");
+  // 上次入站缓存的回复通道（跨重启可用）：im-dingtalk-reply.json（0600）
+  if (relayDir) {
+    try {
+      const saved = readJsonFile(path.join(relayDir, REPLY_FILE));
+      if (saved && typeof saved === "object") {
+        if (typeof saved.sessionWebhook === "string" && saved.sessionWebhook) state.boundSessionWebhook = saved.sessionWebhook;
+        if (Number.isFinite(Number(saved.sessionWebhookExpiredTime))) state.boundSessionWebhookExpiredAt = Number(saved.sessionWebhookExpiredTime);
+        if (typeof saved.senderStaffId === "string" && saved.senderStaffId) state.boundUserId = saved.senderStaffId;
+        if (typeof saved.conversationId === "string" && saved.conversationId) state.boundConversationId = saved.conversationId;
+        if (typeof saved.boundChatId === "string" && saved.boundChatId) state.boundChatId = saved.boundChatId;
+      }
+    } catch { /* 忽略坏文件 */ }
+  }
   if (targetChatId && !state.boundChatId) state.boundChatId = targetChatId;
 
   // 重启恢复：用量 / 绑定目标 / 档位快照（均不含凭据）
@@ -502,6 +533,8 @@ export function createDingtalkBot(options = {}) {
       credentialSource,
       robotCodeConfigured: Boolean(robotCode),
       capabilities: capabilitiesNow(),
+      // 回复通道三层降级（面板显示「可用/需重新发一条消息激活」；不含 webhook 原值）
+      replyChannel: replyChannelStatus(),
       // 会员 + 用量（与企微对齐）
       tier: tierNow(),
       caps: capsNow().slice(),
@@ -760,7 +793,30 @@ export function createDingtalkBot(options = {}) {
     }
   }
 
-  /** 更新「回复目标」：sessionWebhook 优先（即时回复），同时记住 openapi 需要的 conversation/user。 */
+  /** 写回复通道缓存到磁盘（0600；含会话令牌，绝不进状态/日志）。 */
+  function persistReplyChannel() {
+    if (!relayDir) return;
+    try {
+      atomicWriteJson(path.join(relayDir, REPLY_FILE), {
+        version: 1,
+        sessionWebhook: state.boundSessionWebhook || "",
+        sessionWebhookExpiredTime: Number(state.boundSessionWebhookExpiredAt) || 0,
+        senderStaffId: state.boundUserId || "",
+        conversationId: state.boundConversationId || "",
+        boundChatId: state.boundChatId || "",
+        at: now()
+      }, { onWarn: (m) => log.warn(m) });
+    } catch (e) {
+      log.warn(`回复通道缓存写入失败（忽略）：${truncateText(e && e.message ? e.message : e, 100)}`);
+    }
+  }
+
+  /** 日志/状态里只用 webhook 的 host（整条 URL 含会话令牌，绝不外泄）。 */
+  function webhookHost(url) {
+    try { return new URL(String(url)).host; } catch { return chatIdHash(String(url)) || "?"; }
+  }
+
+  /** 更新「回复目标」：缓存 sessionWebhook（被动回复）+ senderStaffId/conversationId（openapi 降级用）。 */
   function bindTarget(info) {
     if (info.conversationId) state.boundConversationId = info.conversationId;
     if (info.senderStaffId) state.boundUserId = info.senderStaffId;
@@ -769,9 +825,13 @@ export function createDingtalkBot(options = {}) {
       log.info(`已绑定推送会话 chat=${chatIdHash(info.chatId)}${info.isGroup ? "（群）" : "（单聊）"}`);
     }
     if (info.sessionWebhook) {
+      const changed = info.sessionWebhook !== state.boundSessionWebhook;
       state.boundSessionWebhook = info.sessionWebhook;
       state.boundSessionWebhookExpiredAt = info.sessionWebhookExpiredTime || 0;
+      state.replyChannelError = "";
+      if (changed) log.info(`已缓存回复通道 sessionWebhook（host=${webhookHost(info.sessionWebhook)}，过期=${state.boundSessionWebhookExpiredAt ? new Date(state.boundSessionWebhookExpiredAt).toISOString() : "未知"}）`);
     }
+    persistReplyChannel();
     writeStatus();
   }
 
@@ -803,9 +863,95 @@ export function createDingtalkBot(options = {}) {
     void dispatchInbound(info).catch((e) => log.warn(`入站转发失败（已忽略）：${truncateText(e && e.message ? e.message : e, 120)}`));
   }
 
-  /** 入站 → 会员闸 → 转发到 DSH 会话（尽力、可降级）。 */
+  /** 命令层：命中已回复返回 true（不转模型、不计额度；回复走三层回复通道）。 */
+  async function handleCommand(info) {
+    const text = String((info && info.text) || "");
+    if (!/^\s*\//.test(text)) return false;
+    const cmd = await executeImCommand({
+      text,
+      ctx: {
+        caps: capsNow(),
+        tier: tierNow(),
+        appUrl: String(options.appUrl || ""),
+        channelLabel: "钉钉",
+        sessions: async () => {
+          const sub = subscriber;
+          if (!sub) return [];
+          let rows = [];
+          try {
+            if (typeof sub.listSessions === "function") {
+              const r = await sub.listSessions();
+              rows = Array.isArray(r) ? r : (r && r.ok && Array.isArray(r.sessions) ? r.sessions : []);
+            }
+          } catch { rows = []; }
+          if ((!Array.isArray(rows) || rows.length === 0) && typeof sub.sessions === "function") {
+            try { rows = (sub.sessions() || []).map((id) => ({ sessionId: String(id) })); } catch { rows = []; }
+          }
+          return (Array.isArray(rows) ? rows : []).map((x) => ({
+            sessionId: String(x.sessionId || x.id || ""),
+            title: String(x.title || ""),
+            updatedAt: Number(x.updatedAt) || 0,
+            running: x.running === true
+          })).filter((x) => x.sessionId);
+        },
+        currentSessionId: () => {
+          const known = boundSessionId || lastSeenSessionId || "";
+          if (known) return known;
+          if (configuredSessionId && canCap("sessions")) return configuredSessionId;
+          const sub = subscriber;
+          try {
+            if (sub && typeof sub.sessions === "function") {
+              const ids = sub.sessions();
+              if (Array.isArray(ids) && ids.length) return String(ids[0]);
+            }
+          } catch { /* 忽略 */ }
+          return "";
+        },
+        currentSessionTitle: () => "",
+        cancelSession: async ({ sessionId }) => {
+          const sub = subscriber;
+          if (!sub || typeof sub.cancelSession !== "function") return { ok: false, message: "订阅器未就绪" };
+          try {
+            const r = await sub.cancelSession({ sessionId });
+            return r && typeof r === "object" ? r : { ok: Boolean(r) };
+          } catch (e) { return { ok: false, message: e && e.message ? e.message : String(e) }; }
+        },
+        switchSession: async ({ sessionId, title }) => {
+          const r = writeImBotsSession(relayDir, "dingtalk", { sessionId, sessionTitle: title });
+          if (r.ok) {
+            configuredSessionId = sessionId;
+            configuredSessionTitle = truncateText(title || "", 60);
+            boundSessionId = sessionId;
+            writeStatus();
+          }
+          return r;
+        },
+        unbind: async () => { clearReplyChannel(); return { ok: true }; },
+        statusSnapshot: async () => ({
+          connected: state.connected === true,
+          authenticated: state.authenticated === true,
+          state: state.phase,
+          lastError: state.lastError || "",
+          tier: tierNow(),
+          usage: { month: monthKey(), messages: usageThisMonth() },
+          messagesPerMonth: messageLimitNow(),
+          remainingMessages: messageLimitNow() ? Math.max(0, messageLimitNow() - usageThisMonth()) : null,
+          currentSessionId: boundSessionId || lastSeenSessionId || "",
+          currentSessionTitle: ""
+        })
+      }
+    });
+    if (!cmd || !cmd.handled) return false;
+    reply(info, cmd.text);
+    emitter.emit("command", { ...info, command: cmd.command, ok: cmd.ok === true, gated: cmd.gated === true });
+    log.info(`命令 ${cmd.command}${cmd.gated ? "（会员闸拦截）" : ""} 已回复（不转模型）`);
+    return true;
+  }
+
+  /** 入站 → 命令层 → 会员闸 → 转发到 DSH 会话（尽力、可降级）。 */
   async function dispatchInbound(info) {
     const sub = subscriber;
+    if (await handleCommand(info)) return;
     const gated = await membershipGate(info);
     if (gated) return;
     const sessionId = await resolveSessionId(sub);
@@ -947,42 +1093,114 @@ export function createDingtalkBot(options = {}) {
   }
 
   /**
-   * 发一条 markdown（通知/回答回传/确认文案统一入口）。
-   * 目标选择：① 最近一次入站的 sessionWebhook（未过期，最快、无需 token）
-   *           ② replyMode=openapi（或 webhook 不可用）且有 robotCode → OpenAPI
-   *           ③ 都没有 → 记日志跳过（不抛错）
+   * 当前可用的回复通道（**三层降级**）：
+   *   ① 缓存 sessionWebhook（未过期；被动回复，最快、不需要 token）
+   *   ② openapi（robotCode + senderStaffId/conversationId 都有）
+   *   ③ none（明确原因，面板提示"再发一条消息激活"）
    */
-  async function sendMarkdown(text, opts = {}) {
+  function replyChannelNow() {
+    const expiresAt = Number(state.boundSessionWebhookExpiredAt) || 0;
+    const webhookUsable = Boolean(state.boundSessionWebhook) && (!expiresAt || now() < expiresAt);
+    if (webhookUsable) return { kind: "sessionWebhook", webhook: state.boundSessionWebhook, expiresAt, reason: "" };
+    if (robotCode && (state.boundUserId || state.boundConversationId)) {
+      return {
+        kind: "openapi",
+        webhook: "",
+        expiresAt: 0,
+        reason: state.boundSessionWebhook ? "sessionWebhook_expired" : "no_webhook"
+      };
+    }
+    return {
+      kind: "none",
+      webhook: "",
+      expiresAt,
+      reason: state.boundSessionWebhook ? "sessionWebhook_expired" : (robotCode ? "no_target_user" : "no_robot_code"),
+      lastError: NO_REPLY_CHANNEL_HINT
+    };
+  }
+
+  /** 状态文件里的 replyChannel 元数据（**绝不含 webhook 原值**）。 */
+  function replyChannelStatus() {
+    const ch = replyChannelNow();
+    return {
+      kind: ch.kind,
+      expiresAt: Number(ch.expiresAt) || 0,
+      lastError: truncateText(maskSecrets(state.replyChannelError || "", [clientSecret]), 160),
+      hasWebhook: Boolean(state.boundSessionWebhook)
+    };
+  }
+
+  function markReplyChannelError(detail) {
+    state.replyChannelError = truncateText(String(detail || ""), 160);
+    writeStatus();
+  }
+
+  /**
+   * 统一回复入口（回答回传/通知/命令回复都走这里）。
+   * ① 缓存 sessionWebhook → ② 失败/过期降级 openapi → ③ 都不可用：**明确日志 + 状态人话，绝不静默**。
+   */
+  async function sendViaReplyChannel(text, opts = {}) {
     const title = opts.title || "";
-    const webhook = state.boundSessionWebhook;
-    const webhookOk = Boolean(webhook) && (!state.boundSessionWebhookExpiredAt || now() < state.boundSessionWebhookExpiredAt);
-    if (replyMode !== "openapi" && webhookOk) {
+    const preferredWebhook = String(opts.webhook || "").trim();
+    const channel = replyChannelNow();
+    const webhook = preferredWebhook || (channel.kind === "sessionWebhook" ? channel.webhook : "");
+    if (webhook) {
       const r = await replySessionWebhook(webhook, { title, text });
-      if (r.ok) return r;
-      log.warn(`sessionWebhook 回复失败（${r.reason}），尝试 OpenAPI 兜底`);
+      if (r.ok) {
+        if (state.replyChannelError) { state.replyChannelError = ""; writeStatus(); }
+        return { ...r, kind: "sessionWebhook" };
+      }
+      // JSDoc: 只记 host + 错误原因（整条 URL 带会话令牌，绝不外泄）
+      log.warn(`sessionWebhook 回复失败（host=${webhookHost(webhook)}，${truncateText(r.reason, 60)}）→ 尝试 OpenAPI 兜底`);
+      markReplyChannelError(`sessionWebhook 回复失败：${truncateText(r.reason, 80)}；${NO_REPLY_CHANNEL_HINT}`);
+    }
+    if (robotCode && (state.boundUserId || state.boundConversationId)) {
+      const fb = await sendOpenapi(text, { title });
+      if (fb.ok) return { ...fb, kind: "openapi" };
+      log.warn(`OpenAPI 兜底也失败：${truncateText(fb.reason, 80)}`);
+      markReplyChannelError(`OpenAPI 回复失败：${truncateText(fb.reason, 80)}；${NO_REPLY_CHANNEL_HINT}`);
+      return { ok: false, kind: "none", reason: "no_reply_channel", detail: fb.reason || "" };
+    }
+    // 缺 robotCode：给更具体的可操作错误（与能力降级口径一致，不是笼统的"没通道"）
+    if (!robotCode) {
+      const detail = "未配置 robotCode：openapi 主动发送不可用（接收消息与 sessionWebhook 回复不受影响）。"
+        + "请在插件「钉钉机器人」里补 robotCode。";
+      log.warn(`no_robot_code：${detail}`);
+      markReplyChannelError(`no_robot_code：${detail}`);
+      return { ok: false, kind: "none", reason: "no_robot_code", detail, capabilities: capabilitiesNow() };
     }
-    const fallback = await sendOpenapi(text, { title });
-    if (fallback.ok) return fallback;
     const at = now();
-    if (at - lastNoTargetLogAt > 10 * 60 * 1000) {
+    if (at - lastNoTargetLogAt > 60_000) {
       lastNoTargetLogAt = at;
-      log.info(`没有可用的回复通道（sessionWebhook 未就绪 / openapi 未配置）：${truncateText(fallback.reason || "?", 60)}`);
+      log.warn(`no_reply_channel：${NO_REPLY_CHANNEL_HINT}（detail=${truncateText(channel.reason, 40)}，webhook=${state.boundSessionWebhook ? "expired" : "none"}，robotCode=${robotCode ? "有" : "无"}，userId=${state.boundUserId ? "有" : "无"}）`);
     }
-    return fallback;
+    markReplyChannelError(`no_reply_channel：${NO_REPLY_CHANNEL_HINT}`);
+    return { ok: false, kind: "none", reason: "no_reply_channel", detail: NO_REPLY_CHANNEL_HINT };
   }
 
-  /** 回复一句人话：优先 sessionWebhook（即时），失败/缺失时退回主动发。 */
+  /** 兼容旧入口：通知/回答回传/命令回复统一走三层回复通道。 */
+  async function sendMarkdown(text, opts = {}) {
+    return sendViaReplyChannel(text, opts);
+  }
+
+  /** 回复一句人话：优先本次入站的 webhook，再走三层降级；失败不抛。 */
   function reply(info, text) {
-    const webhook = info && info.sessionWebhook ? info.sessionWebhook : state.boundSessionWebhook;
-    if (webhook) {
-      void replySessionWebhook(webhook, { text }).then((r) => {
-        if (r.ok) return;
-        log.warn(`回复失败（${r.reason}），尝试主动发兜底`);
-        void sendMarkdown(text).catch(() => {});
-      }).catch(() => {});
-      return;
+    const webhook = info && info.sessionWebhook ? info.sessionWebhook : "";
+    void sendViaReplyChannel(text, { webhook }).catch(() => {});
+  }
+
+  /** 解绑推送（/unbind 命令用）：清内存 + 删持久化回复通道 + 清状态绑定字段。 */
+  function clearReplyChannel() {
+    state.boundSessionWebhook = "";
+    state.boundSessionWebhookExpiredAt = 0;
+    state.boundUserId = "";
+    state.boundConversationId = "";
+    state.boundChatId = "";
+    state.replyChannelError = "";
+    if (relayDir) {
+      try { fs.rmSync(path.join(relayDir, REPLY_FILE), { force: true }); } catch { /* 忽略 */ }
     }
-    void sendMarkdown(text).catch(() => {});
+    writeStatus();
   }
 
   // ---------- DSH 事件订阅（通知 + 回答回传 + 活跃会话） ----------
@@ -1034,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) {
@@ -1079,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) {
@@ -1131,6 +1347,8 @@ export function createDingtalkBot(options = {}) {
       credentialSource,
       robotCodeConfigured: Boolean(robotCode),
       capabilities: capabilitiesNow(),
+      // 回复通道三层降级（面板显示「可用/需重新发一条消息激活」；不含 webhook 原值）
+      replyChannel: replyChannelStatus(),
       subscriptions: subscriptions.map((s) => String(s.topic || "")).filter(Boolean),
       messages: state.messages,
       gated: state.gated,
@@ -1192,6 +1410,8 @@ export function createDingtalkBot(options = {}) {
     status,
     replySessionWebhook,
     sendMarkdown,
+    sendViaReplyChannel,
+    clearReplyChannel,
     getAccessToken,
     on(event, listener) { emitter.on(event, listener); return () => emitter.off(event, listener); },
     once(event, listener) { emitter.once(event, listener); return () => emitter.off(event, listener); },