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

package/clients/dsh-remote/test/im-commands.test.mjs

@@ -0,0 +1,283 @@
+/**
+ * im-commands — 三家 IM 机器人共用命令层单测（2026-11-08）。
+ *
+ * 纯函数 + 注入式执行器，覆盖：解析（大小写/参数/未知）、/help 全命令、未知命令不转发、
+ * 免费档 /ls /use 被拦 + 升级文案、/stop 免费立即生效、/use 越界/缺参、/status 与快照同源、
+ * /unbind 免费、命令回复不含裸表格、写配置 sessionId（保留其它段）。
+ */
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  IM_COMMANDS,
+  commandAllowed,
+  executeImCommand,
+  helpText,
+  lsText,
+  parseImCommand,
+  writeImBotsSession
+} from "../im-commands.mjs";
+import { freeCaps, paidCaps } from "./im-caps-fixture.mjs";
+import { fileMode } from "../wecom-bot.mjs";
+
+function tmpDir() { return fs.mkdtempSync(path.join(os.tmpdir(), "dsh-imcmd-")); }
+
+function sessionsFixture() {
+  const rows = [
+    { sessionId: "session-alpha", title: "重构支付回调链路（很长的标题会被截断到二十四字以内）", updatedAt: Date.UTC(2026, 10, 8, 1, 30), running: true },
+    { sessionId: "session-beta", title: "修端口探测", updatedAt: Date.UTC(2026, 10, 7, 22, 0) },
+    { sessionId: "session-gamma", title: "写测试", updatedAt: 0 }
+  ];
+  return async () => rows;
+}
+
+/** 一个记录调用的 ctx（各用例按需覆盖）。 */
+function makeCtx(over = {}) {
+  const calls = { switch: [], cancel: [], unbind: 0 };
+  const ctx = {
+    caps: freeCaps(),
+    tier: "free",
+    appUrl: "https://app.test/",
+    channelLabel: "钉钉",
+    sessions: sessionsFixture(),
+    currentSessionId: () => "session-alpha",
+    currentSessionTitle: "重构支付回调链路",
+    switchSession: async (arg) => { calls.switch.push(arg); return { ok: true }; },
+    cancelSession: async (arg) => { calls.cancel.push(arg); return { ok: true }; },
+    unbind: async () => { calls.unbind += 1; return { ok: true }; },
+    statusSnapshot: async () => ({
+      connected: true, authenticated: true, state: "connected", lastError: "",
+      tier: "free", usage: { month: "2026-11", messages: 3 }, messagesPerMonth: 20, remainingMessages: 17,
+      currentSessionId: "session-alpha", currentSessionTitle: "重构支付回调链路"
+    }),
+    ...over
+  };
+  return { ctx, calls };
+}
+
+const run = (text, ctx) => executeImCommand({ text, ctx });
+const assertNoRawTable = (text) => {
+  assert.ok(!/\|\s*-{2,}/.test(text), `不得含表格分隔行：${text}`);
+  assert.ok(!/^\s*\|.*\|\s*$/m.test(text), `不得含裸表格行：${text}`);
+};
+
+// ─────────────────────────── 解析 ───────────────────────────
+
+test("parseImCommand：命令/大小写/参数/未知；普通文本返回 null", () => {
+  assert.deepEqual(parseImCommand("/help"), { name: "/help", arg: "", rest: "", unknown: false, raw: "/help" });
+  assert.equal(parseImCommand("/HELP").name, "/help", "大小写不敏感");
+  assert.equal(parseImCommand("  /Status  ").name, "/status");
+  assert.equal(parseImCommand("/use 3").arg, "3");
+  assert.equal(parseImCommand("/use").arg, "");
+  assert.equal(parseImCommand("/use   abc").arg, "abc");
+  assert.equal(parseImCommand("/ls 额外 参数").arg, "额外");
+  assert.equal(parseImCommand("/").unknown, true, "光一个 / 算未知命令");
+  assert.equal(parseImCommand("/wat").unknown, false);
+  assert.equal(parseImCommand("hello"), null, "普通文本不是命令");
+  assert.equal(parseImCommand("ls"), null);
+  assert.equal(parseImCommand("  /help 看下  ").arg, "看下");
+});
+
+// ─────────────────────────── /help / 未知 ───────────────────────────
+
+test("★ /help：列出全部命令（免费/会员标注），免费档看到会员命令标注", async () => {
+  const { ctx } = makeCtx();
+  const r = await run("/help", ctx);
+  assert.equal(r.handled, true);
+  assert.equal(r.ok, true);
+  for (const c of IM_COMMANDS) assert.ok(r.text.includes(c.usage), `/help 必须包含 ${c.usage}`);
+  assert.match(r.text, /命令不会发给模型/);
+  assert.match(r.text, /\/stop/);
+  assert.match(r.text, /\/unbind/);
+  assert.match(r.text, /会员/, "免费档要标注会员命令");
+  assertNoRawTable(r.text);
+});
+
+test("★ 未知命令：不转发给模型（handled=true），回「未知命令 + 帮助」", async () => {
+  let promptCalls = 0;
+  const { ctx } = makeCtx();
+  const r = await run("/deploy now", ctx);
+  assert.equal(r.handled, true, "★ 未知 /xxx 必须被命令层拦下");
+  assert.ok(promptCalls === 0);
+  assert.match(r.text, /未知命令：\/deploy/);
+  assert.match(r.text, /\/help/);
+  assertNoRawTable(r.text);
+  // 非命令文本仍返回 handled:false（照旧进模型）
+  const normal = await run("帮我改一下代码", ctx);
+  assert.deepEqual(normal, { handled: false });
+});
+
+// ─────────────────────────── 能力门禁 ───────────────────────────
+
+test("★ 免费档 /ls、/use 被拦：回会员文案 + /app/promo；命令不进模型", async () => {
+  const { ctx } = makeCtx();
+  const ls = await run("/ls", ctx);
+  assert.equal(ls.handled, true);
+  assert.equal(ls.gated, true);
+  assert.match(ls.text, /会员功能/);
+  assert.match(ls.text, /https:\/\/app\.test\/promo/);
+  assert.match(ls.text, /免费可用/);
+  assertNoRawTable(ls.text);
+  const use = await run("/use 1", ctx);
+  assert.equal(use.gated, true);
+  assert.match(use.text, /\/use 是会员功能/);
+  // 免费命令不受影响
+  for (const cmd of ["/help", "/status", "/stop", "/unbind"]) {
+    const r = await run(cmd, ctx);
+    assert.equal(r.gated, undefined, `${cmd} 必须免费可用`);
+    assert.equal(r.handled, true);
+  }
+});
+
+// ─────────────────────────── /ls ───────────────────────────
+
+test("★ /ls（会员）：≤10 条、标题截断 24、索引 + 当前标记 + 更新时间；不含裸表格", async () => {
+  const many = Array.from({ length: 15 }, (_, i) => ({ sessionId: `session-${i}`, title: `会话 ${i} 号很长的标题需要被截断处理一下`, updatedAt: Date.UTC(2026, 10, 8, 10, i % 60) }));
+  const { ctx } = makeCtx({ caps: paidCaps(), sessions: async () => many, currentSessionId: () => "session-3" });
+  const r = await run("/ls", ctx);
+  assert.equal(r.ok, true);
+  const lines = r.text.split("\n").filter((l) => /^\d+\. /.test(l));
+  assert.equal(lines.length, 10, "最多 10 条");
+  assert.match(r.text, /1\. 会话 0 号/);
+  assert.match(r.text, /4\. 会话 3 号[^\n]*（当前）/, "当前会话要有标记");
+  assert.match(r.text, /· \d{2}-\d{2} \d{2}:\d{2}/, "带更新时间");
+  for (const line of lines) {
+    const titlePart = line.replace(/^\d+\. /, "").split(" ")[0];
+    assert.ok(Array.from(titlePart.replace(/…$/, "")).length <= 24, `标题超过 24 字：${line}`);
+  }
+  assert.match(r.text, /\/use <序号>/);
+  assertNoRawTable(r.text);
+});
+
+test("/ls：没有会话时给可操作提示", async () => {
+  const { ctx } = makeCtx({ caps: paidCaps(), sessions: async () => [] });
+  const r = await run("/ls", ctx);
+  assert.equal(r.ok, true);
+  assert.match(r.text, /最近没有可列出的会话/);
+  assert.match(r.text, /打开\/运行一个会话/);
+});
+
+// ─────────────────────────── /use ───────────────────────────
+
+test("★ /use <N>：合法序号切换（写配置由 ctx.switchSession 完成）+ 回执", async () => {
+  const { ctx, calls } = makeCtx({ caps: paidCaps() });
+  const r = await run("/use 2", ctx);
+  assert.equal(r.ok, true);
+  assert.deepEqual(calls.switch, [{ sessionId: "session-beta", title: "修端口探测" }]);
+  assert.match(r.text, /已切换到 #2 修端口探测/);
+});
+
+test("★ /use 越界 / 缺参 / 无会话：给可操作提示，不崩", async () => {
+  const { ctx, calls } = makeCtx({ caps: paidCaps() });
+  const out = await run("/use 99", ctx);
+  assert.equal(out.ok, true, "越界是提示不是崩溃");
+  assert.match(out.text, /序号超出范围：当前列表是 1-3/);
+  assert.match(out.text, /\/ls/);
+  assert.equal(calls.switch.length, 0);
+  const missing = await run("/use", ctx);
+  assert.match(missing.text, /用法：\/use <序号>/);
+  const none = await run("/use 1", makeCtx({ caps: paidCaps(), sessions: async () => [] }).ctx);
+  assert.match(none.text, /没有可切换的会话/);
+  const failing = await run("/use 1", makeCtx({ caps: paidCaps(), switchSession: async () => ({ ok: false, reason: "写配置失败" }) }).ctx);
+  assert.match(failing.text, /切换失败：写配置失败/);
+});
+
+// ─────────────────────────── /stop / /status / /unbind ───────────────────────────
+
+test("★ /stop：免费可用、立即调 cancelSession、回执明确（没会话给说明）", async () => {
+  const { ctx, calls } = makeCtx();
+  const r = await run("/stop", ctx);
+  assert.equal(r.ok, true);
+  assert.deepEqual(calls.cancel, [{ sessionId: "session-alpha" }]);
+  assert.match(r.text, /已急停：重构支付回调链路/);
+  // 无会话
+  const none = await run("/stop", makeCtx({ currentSessionId: () => "" }).ctx);
+  assert.match(none.text, /没有正在运行的会话/);
+  // 取消失败要给"没收到确认"
+  const fail = await run("/stop", makeCtx({ cancelSession: async () => ({ ok: false, message: "通道断开" }) }).ctx);
+  assert.match(fail.text, /没收到确认：通道断开/);
+});
+
+test("★ /status：连接状态 + 当前会话 + 本月剩余（与状态快照同源；不限量显示不限）", async () => {
+  const { ctx } = makeCtx();
+  const r = await run("/status", ctx);
+  assert.equal(r.ok, true);
+  assert.match(r.text, /连接状态/);
+  assert.match(r.text, /✅ 已连接/);
+  assert.match(r.text, /当前会话：重构支付回调链路/);
+  assert.match(r.text, /本月指令：已用 3\/20/);
+  assert.match(r.text, /剩余：17 条/);
+  assertNoRawTable(r.text);
+  // 付费不限量
+  const pro = await run("/status", makeCtx({
+    caps: paidCaps(), tier: "pro",
+    statusSnapshot: async () => ({ connected: false, state: "reconnecting", tier: "pro", usage: { messages: 0 }, messagesPerMonth: 0, currentSessionId: "" })
+  }).ctx);
+  assert.match(pro.text, /未连接（reconnecting/);
+  assert.match(pro.text, /本月指令：不限（pro）/);
+  assert.match(pro.text, /当前会话：未选择/);
+});
+
+test("★ /unbind：免费可用、任何人可退订（调 unbind + 明确回执）", async () => {
+  const { ctx, calls } = makeCtx();
+  const r = await run("/unbind", ctx);
+  assert.equal(r.ok, true);
+  assert.equal(calls.unbind, 1);
+  assert.match(r.text, /已解绑/);
+  assert.match(r.text, /重新绑定/);
+});
+
+// ─────────────────────────── 执行器健壮性 / 配置写入 ───────────────────────────
+
+test("执行器：ctx 抛错也返回 handled:true（命令层绝不把异常漏给模型）", async () => {
+  const r = await run("/ls", makeCtx({ caps: paidCaps(), sessions: async () => { throw new Error("订阅器挂了"); } }).ctx);
+  assert.equal(r.handled, true);
+  assert.match(r.text, /命令执行失败：订阅器挂了/);
+});
+
+test("★ writeImBotsSession：写对应通道的 sessionId/sessionTitle（保留其它段，0600）", () => {
+  const dir = tmpDir();
+  try {
+    fs.writeFileSync(path.join(dir, "im-bots.json"), JSON.stringify({
+      version: 1,
+      wecom: { enabled: true, botId: "b" },
+      dingtalk: { enabled: true, clientId: "c" },
+      feishu: { enabled: false }
+    }), { mode: 0o600 });
+    const r = writeImBotsSession(dir, "dingtalk", { sessionId: "session-beta", sessionTitle: "修端口探测" });
+    assert.equal(r.ok, true);
+    const disk = JSON.parse(fs.readFileSync(path.join(dir, "im-bots.json"), "utf8"));
+    assert.equal(disk.dingtalk.sessionId, "session-beta");
+    assert.equal(disk.dingtalk.sessionTitle, "修端口探测");
+    assert.equal(disk.dingtalk.clientId, "c", "其它字段保留");
+    assert.equal(disk.wecom.botId, "b", "其它通道段保留");
+    if (process.platform !== "win32") assert.equal(fileMode(path.join(dir, "im-bots.json")) & 0o777, 0o600);
+    // 非法参数
+    assert.equal(writeImBotsSession(dir, "", {}).ok, false);
+    assert.equal(writeImBotsSession(dir, "dingtalk", { sessionId: "" }).ok, false);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test("helpText/commandAllowed：能力表判断与 /help 文案一致（单一真相源）", () => {
+  assert.equal(commandAllowed(IM_COMMANDS.find((c) => c.name === "/stop"), []), true, "急停不需要能力");
+  assert.equal(commandAllowed(IM_COMMANDS.find((c) => c.name === "/ls"), freeCaps()), false);
+  assert.equal(commandAllowed(IM_COMMANDS.find((c) => c.name === "/ls"), paidCaps()), true);
+  const paidHelp = helpText({ caps: paidCaps(), appUrl: "https://a/" });
+  assert.match(paidHelp, /你的档位已包含会话管理/);
+  const freeHelp = helpText({ caps: freeCaps() });
+  assert.ok(!/已包含会话管理/.test(freeHelp));
+});
+
+test("三家接线（源级契约）：wecom/dingtalk/feishu 都在进模型前调用命令层", () => {
+  for (const file of ["wecom-bot.mjs", "dingtalk-bot.mjs", "feishu-bot.mjs"]) {
+    const src = fs.readFileSync(new URL(`../${file}`, import.meta.url), "utf8");
+    assert.ok(/from "\.\/im-commands\.mjs"/.test(src), `${file} 必须 import im-commands.mjs`);
+    assert.ok(/executeImCommand\(/.test(src), `${file} 必须调用 executeImCommand`);
+    const cmdAt = src.indexOf("executeImCommand(");
+    const promptAt = src.indexOf("promptSession(");
+    assert.ok(cmdAt > -1 && (promptAt === -1 || cmdAt < promptAt), `${file} 命令层必须出现在 promptSession 之前（cmdAt=${cmdAt}, promptAt=${promptAt}）`);
+  }
+});

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

@@ -11,7 +11,10 @@ import test from "node:test";
 
 import {
   CHANNEL_CAPS,
+  SUMMARY_MAX_CHARS,
   TRUNCATED_NOTE,
+  buildTurnNotification,
+  extractTurnSummary,
   convertMarkdownTable,
   displayWidth,
   formatForChannel,
@@ -227,3 +230,60 @@ test("wechat 分支：走现有特殊格式（本模块只做 plain 兜底、不
   assert.ok(!unknown.includes("**"));
   assert.equal(unknown, "标题\n\n粗");
 });
+
+// ─────────────────────────── 任务总结（turn_done/turn_error 通知带正文）───────────────────────────
+
+test("★ extractTurnSummary：订阅器正文优先 → 事件字段降级 → 取不到为空（不报错）", async () => {
+  // ① 订阅器有正文
+  const sub = { lastAssistantText: async () => ({ ok: true, text: "订阅器里的总结" }) };
+  const a = await extractTurnSummary({ node: { kind: "turn-end", sessionId: "session-x" }, subscriber: sub, sessionId: "session-x" });
+  assert.deepEqual(a, { text: "订阅器里的总结", source: "assistant" });
+  // ② 订阅器取不到 → 事件字段（summary/message/detail/text）
+  const b = await extractTurnSummary({ node: { kind: "turn-end", sessionId: "session-x", message: "事件里的错误摘要" }, subscriber: { lastAssistantText: async () => ({ ok: false, code: "page-failed" }) }, sessionId: "session-x" });
+  assert.deepEqual(b, { text: "事件里的错误摘要", source: "node" });
+  // ③ 都没有 → 空（调用方降级仅标题）
+  const c = await extractTurnSummary({ node: { kind: "turn-end", sessionId: "session-x" }, subscriber: null });
+  assert.equal(c.text, "");
+  assert.equal(c.source, "none");
+  // ④ 订阅器抛错也不崩，继续降级
+  const d = await extractTurnSummary({ node: { kind: "turn-end", summary: "兜底" }, subscriber: { lastAssistantText: async () => { throw new Error("boom"); } }, sessionId: "s" });
+  assert.deepEqual(d, { text: "兜底", source: "node" });
+  // ⑤ 重试：ok 但空 → 第二次拿到（turn/end 瞬间正文可能还没落库）
+  let n = 0;
+  const retried = await extractTurnSummary({
+    node: { kind: "turn-end", sessionId: "s" },
+    subscriber: { lastAssistantText: async () => { n += 1; return n === 1 ? { ok: true, text: "" } : { ok: true, text: "重试后的总结" }; } },
+    sessionId: "s",
+    retryDelays: [0, 5]
+  });
+  assert.equal(retried.text, "重试后的总结");
+  assert.equal(n, 2);
+});
+
+test("★ buildTurnNotification：标题行 + 正文（1500 字上限/通道格式化/缺正文降级）；审批类返回 null", () => {
+  // completed：✅ 任务完成｜标题 + 正文
+  const done = buildTurnNotification({ node: { kind: "turn-end", reason: "completed" }, channel: "wecom", summary: "改了三个文件", sessionTitle: "修端口" });
+  assert.equal(done, "✅ 任务完成｜修端口\n\n改了三个文件");
+  // error / blocked / aborted
+  assert.match(buildTurnNotification({ node: { kind: "turn-end", reason: "error" }, channel: "wecom", summary: "报错摘要" }), /^❌ 出错了\n\n报错摘要$/);
+  assert.match(buildTurnNotification({ node: { kind: "turn-end", reason: "blocked" }, channel: "wecom", summary: "被拦原因" }), /^⛔ 被拦下了\n\n被拦原因$/);
+  assert.match(buildTurnNotification({ node: { kind: "turn-end", reason: "aborted" }, channel: "wecom" }), /^⏹ 已停止$/);
+  // session-error 也用 ❌ 出错了
+  assert.match(buildTurnNotification({ node: { kind: "session-error", message: "x" }, channel: "wecom" }), /^❌ 出错了/);
+  // 缺正文 → 仅标题（不留多余空段）
+  assert.equal(buildTurnNotification({ node: { kind: "turn-end", reason: "completed" }, channel: "wecom", summary: "" }), "✅ 任务完成");
+  // 审批类不混入总结（返回 null，仍走卡片）
+  assert.equal(buildTurnNotification({ node: { kind: "approval-request", toolName: "Bash" }, channel: "wecom", summary: "不该出现" }), null);
+  // 表格按通道转换（企微不支持表格 → 可读列表）
+  const table = "| 文件 | 改动 |\n|---|---|\n| a.mjs | 修端口 |";
+  const withTable = buildTurnNotification({ node: { kind: "turn-end", reason: "completed" }, channel: "wecom", summary: table });
+  assert.ok(!/\|\s*-{2,}/.test(withTable), "★ 通知里不得有裸表格分隔行");
+  assert.match(withTable, /• 文件：a\.mjs · 改动：修端口/);
+  // 1500 字上限（长正文截断 + 注明）
+  const long = "开头" + "长".repeat(3000);
+  const longNotice = buildTurnNotification({ node: { kind: "turn-end", reason: "completed" }, channel: "feishu", summary: long });
+  const body = longNotice.split("\n\n").slice(1).join("\n\n");
+  assert.ok(body.endsWith(TRUNCATED_NOTE), "超长正文要带截断提示");
+  assert.ok(Array.from(body).length <= SUMMARY_MAX_CHARS + Array.from(TRUNCATED_NOTE).length + 2, "正文不超过 1500 字（+提示）");
+  assert.ok(!body.includes("长".repeat(2000)), "明显截断");
+});

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

@@ -152,6 +152,8 @@ function fakeSubscriber(over = {}) {
   sub.started = false;
   sub.closed = false;
   sub.promptCalls = [];
+  sub.cancelCalls = [];
+  sub.cancelSession = async ({ sessionId } = {}) => { sub.cancelCalls.push({ sessionId }); return { ok: true }; };
   sub.sessionDetails = Array.isArray(over.sessions) ? over.sessions.slice() : [];
   sub.start = () => { sub.started = true; };
   sub.close = () => { sub.closed = true; };
@@ -688,62 +690,56 @@ async function setupRelayBot(over = {}) {
   return { server, sub, bot, lines, sends, inbound, turnEnd, close: async () => { await bot.stop(); await server.close(); } };
 }
 
-test("★ 回答回传：入站后同会话 turn_done 发**回答正文**（不再发 ✅标题）；其它会话/已消费保持标题通知；取不到正文降级标题", async () => {
-  const rt = await setupRelayBot({ assistantText: { ok: true, text: "这是 agent 的最终回答" } });
+test("★ 任务通知带总结（企微）：turn_done → 一条「✅ 任务完成｜标题 + 正文」；同 turn 不重发；缺正文降级标题；正文不进日志", async () => {
+  const rt = await setupRelayBot({ assistantText: { ok: true, text: "这是 agent 的最终总结" } });
   try {
     rt.bot.start();
     await waitFor(() => rt.bot.status().authenticated, { label: "认证完成" });
     await rt.inbound("relay-1", "你好");
-
-    // ① 入站后同会话 turn/end → 只发正文，不发标题
     rt.turnEnd({ turn: 1, seq: 11 });
-    const first = await waitFor(() => rt.sends()[0], { label: "回答回传" });
-    assert.equal(first.body.chatid, "user-a", "回答必须发回最近入站的会话（boundChatId）");
+    const first = await waitFor(() => rt.sends()[0], { label: "任务通知" });
+    assert.equal(first.body.chatid, "user-a");
     assert.equal(first.body.msgtype, "markdown");
-    assert.equal(first.body.markdown.content, "这是 agent 的最终回答", "回答回传 = 正文本身（不带 ✅ 标题）");
-    assert.equal(rt.bot.status().answers, 1);
-    assert.deepEqual(rt.sub.lastAssistantCalls, [{ sessionId: "session-abc" }], "应通过 lastAssistantText 取正文");
+    const content = first.body.markdown.content;
+    assert.match(content, /^✅ 任务完成/, "★ 通知必须带「任务完成」标题行");
+    assert.match(content, /\n\n这是 agent 的最终总结$/, "★ 同一条消息里带总结正文（不是另发一条）");
+    assert.deepEqual(rt.sub.lastAssistantCalls[0], { sessionId: "session-abc" }, "正文通过 lastAssistantText 取");
+    await sleep(120);
+    assert.equal(rt.sends().length, 1, "★ 同一次 turn 只发一条（不得标题一条 + 正文一条）");
+
+    // 同 turn 重复事件 → 去重，不重发
+    rt.turnEnd({ turn: 1, seq: 11 });
     await sleep(120);
-    assert.equal(rt.sends().length, 1, "同一次对话不得再补一条「✅ 任务完成」");
+    assert.equal(rt.sends().length, 1, "★ 同 turn 重复事件去重");
 
-    // ② 其它会话的 turn/end → 仍是标题通知
+    // 其它会话的 turn/end 也带总结（订阅器能给到该会话正文）
     rt.sub.emit("event", { kind: NODE_KINDS.TURN_END, sessionId: "session-other", reason: "completed", turn: 1, seq: 12, at: Date.now() });
-    const other = await waitFor(() => rt.sends().find((f) => /任务完成/.test(f.body.markdown.content)), { label: "其它会话标题通知" });
+    const other = await waitFor(() => rt.sends().find((f) => f.body.markdown.content.includes("这是 agent 的最终总结") && f !== first), { label: "其它会话通知" });
     assert.match(other.body.markdown.content, /^✅ 任务完成/);
 
-    // ③ 同会话但已消费过一次 → 保持标题通知（不会重复回传正文）
-    rt.turnEnd({ turn: 2, seq: 13 });
-    const again = await waitFor(() => rt.sends().filter((f) => /任务完成/.test(f.body.markdown.content)).length >= 2, { label: "消费一次后的标题通知" });
-    assert.ok(again, "同一次入站只回传一次正文，之后回落到标题通知");
-
-    // ④ 取不到正文 → 降级标题通知（不丢消息、也不假装有正文）
+    // 取不到正文 → 降级仅标题（不丢消息、不报错）
     await rt.inbound("relay-2", "再问一句");
     rt.sub.assistantReply = { ok: false, code: "page-failed", text: "" };
     rt.turnEnd({ turn: 3, seq: 14 });
-    await waitFor(() => rt.lines.some((l) => /降级为标题通知/.test(l)), { label: "降级日志" });
-    const fallback = rt.sends().filter((f) => /任务完成/.test(f.body.markdown.content)).pop();
-    assert.match(fallback.body.markdown.content, /^✅ 任务完成/, "取不到正文时退回标题通知");
-
-    // ⑤ 重连快照补报的旧 turn（fromSnapshot）不得回传正文
-    await rt.inbound("relay-3", "第三句");
-    rt.sub.assistantReply = { ok: true, text: "来自快照的旧回答" };
-    const beforeSnapshot = rt.sends().length;
-    rt.turnEnd({ turn: 4, seq: 15, fromSnapshot: true });
-    await sleep(150);
-    assert.equal(rt.sends().length, beforeSnapshot + 1, "fromSnapshot 只走标题通知（一条），不触发正文回传");
-    assert.ok(!rt.sends().some((f) => f.body.markdown.content === "来自快照的旧回答"));
+    await waitFor(() => rt.sends().length >= 3, { label: "降级通知" });
+    const fallback = rt.sends()[rt.sends().length - 1];
+    assert.match(fallback.body.markdown.content, /^✅ 任务完成/, "★ 取不到正文时仅标题");
+    assert.ok(!fallback.body.markdown.content.includes("\n\n"), "无正文时不要多余空段");
+    // 正文绝不进日志（只打长度）
+    const allLogs = rt.lines.join("\n");
+    assert.ok(!allLogs.includes("这是 agent 的最终总结"), "★ 总结正文绝不能进日志");
+    assert.ok(allLogs.split("\n").some((l) => /任务通知 .*len=\d+/.test(l)), "日志只记长度");
   } finally {
     await rt.close();
   }
 });
 
-test("★ 回答回传：turn/end 瞬间正文还没落库 → 短重试后仍能回传（不是直接降级）", async () => {
+test("★ 任务通知：turn/end 瞬间正文还没落库 → 短重试后仍带总结（不是直接降级标题）", async () => {
   let call = 0;
   const rt = await setupRelayBot({
     assistantText: () => {
       call += 1;
-      // 第一次「ok 但空」（真实竞态），第二次拿到正文
-      return call === 1 ? { ok: true, text: "" } : { ok: true, text: "重试后拿到的回答" };
+      return call === 1 ? { ok: true, text: "" } : { ok: true, text: "重试后拿到的总结" };
     }
   });
   try {
@@ -751,68 +747,52 @@ test("★ 回答回传：turn/end 瞬间正文还没落库 → 短重试后仍
     await waitFor(() => rt.bot.status().authenticated, { label: "认证完成" });
     await rt.inbound("retry-1", "你好");
     rt.turnEnd({ turn: 1, seq: 31 });
-    const send = await waitFor(() => rt.sends()[0], { label: "重试后的回答回传" });
-    assert.equal(send.body.markdown.content, "重试后拿到的回答", "ok 但空 → 补一次再发，不应直接降级");
+    const send = await waitFor(() => rt.sends()[0], { label: "重试后的通知" });
+    const content = send.body.markdown.content;
+    assert.match(content, /^✅ 任务完成/);
+    assert.match(content, /\n\n重试后拿到的总结$/);
     assert.equal(rt.sub.lastAssistantCalls.length, 2, "应恰好重试一次");
-    assert.equal(rt.bot.status().answers, 1);
   } finally {
     await rt.close();
   }
 });
 
-test("★ 回答回传边界：超过 TTL 不回传、超长截断+注明、正文绝不进日志、非 completed 带状态行", async () => {
-  // ① TTL：注入 40ms，入站后等过期再 turn/end → 只发标题通知
-  {
-    const rt = await setupRelayBot({ assistantText: { ok: true, text: "过期不该发的回答" }, bot: { answerRelayTtlMs: 40 } });
-    try {
-      rt.bot.start();
-      await waitFor(() => rt.bot.status().authenticated, { label: "认证完成" });
-      await rt.inbound("ttl-1", "你好");
-      await sleep(120); // 超过 40ms TTL
-      rt.turnEnd({ turn: 1, seq: 21, at: Date.now() });
-      const send = await waitFor(() => rt.sends()[0], { label: "超时后的标题通知" });
-      assert.match(send.body.markdown.content, /^✅ 任务完成/, "超过 10 分钟语义（测试缩放为 40ms）应回到标题通知");
-      assert.ok(!send.body.markdown.content.includes("过期不该发的回答"));
-    } finally {
-      await rt.close();
-    }
-  }
-
-  // ② 截断 + 正文不进日志 + 非 completed 状态行
-  {
-    const longAnswer = "开头" + "长".repeat(300) + "SECRET-ANSWER-TAIL";
-    const rt = await setupRelayBot({
-      assistantText: { ok: true, text: longAnswer },
-      bot: { answerMaxChars: 50 }
-    });
-    try {
-      rt.bot.start();
-      await waitFor(() => rt.bot.status().authenticated, { label: "认证完成" });
-      await rt.inbound("trunc-1", "来点长的");
-      rt.turnEnd({ turn: 1, seq: 22 });
-      const send = await waitFor(() => rt.sends()[0], { label: "截断后的回答" });
-      const content = send.body.markdown.content;
-      assert.ok(content.endsWith(ANSWER_TRUNCATED_NOTE), `超长回答要以「${ANSWER_TRUNCATED_NOTE}」结尾`);
-      assert.equal(content.length, 50 + ANSWER_TRUNCATED_NOTE.length, "正文部分必须恰好截到 answerMaxChars");
-      assert.ok(!content.includes("SECRET-ANSWER-TAIL"));
-      assert.ok(content.startsWith("开头"));
-      // 日志只打长度，不打正文
-      const allLogs = rt.lines.join("\n");
-      assert.ok(!allLogs.includes("SECRET-ANSWER-TAIL"), "★ 回答正文绝不能进日志");
-      assert.ok(!allLogs.includes("长".repeat(40)), "★ 回答正文片段也不能进日志");
-      assert.ok(allLogs.split("\n").some((l) => /回答回传 .* len=\d+/.test(l)), "日志只记长度");
-      assert.ok(allLogs.split("\n").some((l) => /已截断/.test(l)), "日志要标出截断");
-
-      // ③ 非 completed：带一句状态行 + 正文（仍是一条消息）
-      rt.sub.assistantReply = { ok: true, text: "只跑了一半的结果" };
-      await rt.inbound("err-1", "再试");
-      rt.turnEnd({ turn: 2, seq: 23, reason: "error" });
-      const errSend = await waitFor(() => rt.sends().find((f) => f.body.markdown.content.includes("只跑了一半的结果")), { label: "出错时回传" });
-      assert.match(errSend.body.markdown.content, /^❌ 出错了/);
-      assert.ok(errSend.body.markdown.content.includes("只跑了一半的结果"), "同一条消息里既给状态也给正文");
-    } finally {
-      await rt.close();
-    }
+test("★ 任务通知边界：超长正文按 1500 字截断+注明；出错带错误摘要；正文不进日志", async () => {
+  const longSummary = "开头" + "长".repeat(3000) + "SECRET-SUMMARY-TAIL";
+  const rt = await setupRelayBot({ assistantText: { ok: true, text: longSummary } });
+  try {
+    rt.bot.start();
+    await waitFor(() => rt.bot.status().authenticated, { label: "认证完成" });
+    await rt.inbound("trunc-1", "来点长的");
+    rt.turnEnd({ turn: 1, seq: 22 });
+    const send = await waitFor(() => rt.sends()[0], { label: "截断后的通知" });
+    const content = send.body.markdown.content;
+    assert.match(content, /^✅ 任务完成/);
+    assert.ok(content.endsWith(ANSWER_TRUNCATED_NOTE), `超长正文要以「${ANSWER_TRUNCATED_NOTE}」结尾`);
+    const bodyPart = content.split("\n\n").slice(1).join("\n\n");
+    assert.ok(Array.from(bodyPart).length <= 1500 + Array.from(ANSWER_TRUNCATED_NOTE).length + 2, "正文长度不得超过 1500 字（+截断提示）");
+    assert.ok(!content.includes("SECRET-SUMMARY-TAIL"));
+    const allLogs = rt.lines.join("\n");
+    assert.ok(!allLogs.includes("SECRET-SUMMARY-TAIL"), "★ 总结正文绝不能进日志");
+    assert.ok(!allLogs.includes("长".repeat(40)), "★ 正文片段也不能进日志");
+    assert.ok(allLogs.split("\n").some((l) => /任务通知 .* len=\d+/.test(l)), "日志只记长度");
+
+    // 出错：❌ 标题 + 错误摘要（同一条消息）
+    rt.sub.assistantReply = { ok: true, text: "只跑了一半的结果" };
+    await rt.inbound("err-1", "再试");
+    rt.turnEnd({ turn: 2, seq: 23, reason: "error" });
+    const errSend = await waitFor(() => rt.sends().find((f) => f.body.markdown.content.includes("只跑了一半的结果")), { label: "出错通知" });
+    assert.match(errSend.body.markdown.content, /^❌ 出错了/);
+    assert.match(errSend.body.markdown.content, /\n\n只跑了一半的结果$/);
+
+    // 被拦下（blocked）：状态行 + 总结
+    rt.sub.assistantReply = { ok: true, text: "被安全策略拦截的说明" };
+    await rt.inbound("block-1", "危险操作");
+    rt.turnEnd({ turn: 3, seq: 24, reason: "blocked" });
+    const blocked = await waitFor(() => rt.sends().find((f) => f.body.markdown.content.includes("被安全策略拦截的说明")), { label: "被拦通知" });
+    assert.match(blocked.body.markdown.content, /^⛔ 被拦下了/);
+  } finally {
+    await rt.close();
   }
 });
 
@@ -1716,3 +1696,38 @@ test("atomicWriteJson：覆盖写、目录自动创建、0600、失败不留临
     fs.rmSync(dir, { recursive: true, force: true });
   }
 });
+
+// ─────────────────────── 命令层（2026-11-08：/ls 不再转给模型）───────────────────────
+
+test("★ 命令层：/help /status 直接回复、/ls 免费档被拦、/stop 免费急停；命中命令**不进 promptSession**", async () => {
+  const rt = await setupRelayBot();
+  try {
+    rt.bot.start();
+    await waitFor(() => rt.bot.status().authenticated, { label: "认证" });
+    const replies = () => rt.server.state.frames.filter((f) => f.cmd === "aibot_respond_msg");
+    const sendCmd = async (msgid, content) => {
+      const before = replies().length;
+      rt.server.push({ cmd: "aibot_msg_callback", headers: { req_id: `cmd-${msgid}` }, body: { msgid: `m-${msgid}`, msgtype: "text", text: { content }, from: { userid: "user-a" } } });
+      await waitFor(() => replies().length > before, { label: `命令 ${msgid} 回复` });
+      return String(replies()[before].body.stream.content || "");
+    };
+    const help = await sendCmd("help", "/help");
+    assert.match(help, /可用命令/);
+    assert.match(help, /\/ls/);
+    assert.match(help, /\/unbind/);
+    assert.equal(rt.sub.promptCalls.length, 0, "★ 命令不得进模型");
+    const status = await sendCmd("status", "/status");
+    assert.match(status, /连接状态/);
+    assert.match(status, /当前会话/);
+    const ls = await sendCmd("ls", "/ls");
+    assert.match(ls, /会员功能/, "免费档 /ls 必须被拦");
+    assert.equal(rt.sub.promptCalls.length, 0);
+    const stop = await sendCmd("stop", "/stop");
+    assert.match(stop, /已急停|没有正在运行/);
+    assert.deepEqual(rt.sub.cancelCalls, [{ sessionId: "session-abc" }], "★ /stop 调 cancelSession");
+    assert.equal(rt.sub.promptCalls.length, 0, "★ 全部命令都不进模型");
+    // 普通文本照旧进模型
+    await rt.inbound("normal-1", "帮我改一下代码");
+    assert.equal(rt.sub.promptCalls.length, 1);
+  } finally { await rt.close(); }
+});