@pi-flash-plugins/pf-wxbot 0.0.0-stage → 0.1.3

package/pi/hook.mjs

@@ -0,0 +1,231 @@
+// hook —— pi 事件出站面：message_end 提取 agent 发言 → 分块 → transport 出站队列；
+// 启停通知（002 §4）的置位/冲刷规则。参考：PF 仓 remote_control/mod.rs
+// `on_assistant`/`flush_notice`（出站语义唯一依据）+ state.rs `stop_notice`。
+//
+// **与老实现的边界差异**：老模块吃流式事件（TextDelta 累积 / TextEnd 覆盖 /
+// ToolCallStart 强制冲刷），因为它是进程外的采样者；pi ext 的 `message_end`
+// 给的是**终态完整消息**——缓冲语义坍缩成逐消息处理，可见行为不变
+// （工具调用前的发言在工具执行前发出，最终发言在消息终态发出）。
+//
+// 出站门：transport 句柄在（服务 On）才转发；句柄不在 = 服务关停/未起，
+// 静默丢弃是产品语义（关了服务就不转发），不是事故。
+
+import * as state from "./state.mjs";
+import { Wire } from "./wire.mjs";
+import { send_text } from "./poller.mjs";
+import { split_long_reply_text } from "./reply.mjs";
+import { WX_LINK_ON, WX_LINK_OFF } from "./messages.mjs";
+
+// ── 启停通知文案（002·通知）───────────────────────────────────────
+// ⚡ 顶替【pf icon】——sendmessage 只走文本 item，图片要先上传拿
+// media id（老模块同款定夺，mod.rs:46 注释）。文案单源在 messages.mjs
+// 文案表（zh 逐字 = 002 定稿），这里转出（hook.test 断言的是本文件出口）。
+export { WX_LINK_ON, WX_LINK_OFF };
+
+/** 停服务通知规则（002·通知 定案，**有意偏离** Rust stop_notice 的节制规则）：
+ * 用户显式关停/面板卸载 + 服务当时在跑 → 宣告「已失联」。
+ * 不再要求「已连接已发出」——真机 2026-11-01：连接宣告可能粘在待发队列
+ *（渠道被夺/进程被杀抢在冲刷前），旧规则会把 002 的卸载场景吞成静默。
+ * was_on 本身就是「链接真的断过」的判据；没在跑（未起/已停）才静默。 */
+export function stop_notice(user_stop, was_on) {
+  return user_stop && was_on ? false : null;
+}
+
+/** 对端投递路由就绪（`chat_id` / `user_id` 随首条入站回写，state.rs 同口径）。 */
+export function is_routed(st) {
+  return !!(state.get_str(st, "chat_id") ?? state.get_str(st, "user_id"));
+}
+
+// ── 消息 → 发言（滤工具调用）─────────────────────────────────────
+
+/** pi AssistantMessage → 发言文本块（保序）。只取 `type:"text"`；
+ * thinking / toolCall 一律滤掉（002：微信只收 agent 发言）。 */
+export function assistant_speech_blocks(message) {
+  if (!message || message.role !== "assistant") return [];
+  const out = [];
+  for (const block of message.content ?? []) {
+    if (block && block.type === "text" && typeof block.text === "string") {
+      out.push(block.text);
+    }
+  }
+  return out;
+}
+
+/** 消息 → 待发微信的文本数组：每个发言块独立 CRLF 归一 + 3500 分块，
+ * 按块顺序拼接（老模块 per-content-index 缓冲 + blocks.mixed 黄金同语义）。 */
+export function replies_for_message(message) {
+  const out = [];
+  for (const block of assistant_speech_blocks(message)) {
+    for (const chunk of split_long_reply_text(block.replace(/\r\n/g, "\n"))) {
+      out.push(chunk);
+    }
+  }
+  return out;
+}
+
+// ── 异常停止回执（2026-11-01 buglist#2：错误只上桌面不进微信）─────
+// agent 出错的消息 stopReason="error"、content 为空——发言提取自然是空，
+// 微信就一片沉默，用户只看到「没反应」+ 服务端兜底提示。错误必须发：
+// message_end 记账（运行恢复即清），agent_settled（重试链彻底结束后）
+// 才发出——重试中途的瞬态错不刷屏，只有真的停了才报。
+
+/** 任务异常停止回执前缀（zh 固定，与 ⚡ 启停通知同口径）。**不带空格**：
+ * 超长错误走 3500 分块时断点优先空格，带空格会把「⚠️」单独切成一条。 */
+export const WX_TASK_ERROR_PREFIX = "⚠️任务异常停止：";
+
+/** 助手消息 → 异常停止通知文本；非 error 停止（正常/aborted）或缺
+ * errorMessage = null（用户主动 /停止 不是异常，不报）。 */
+export function error_notice_text(message) {
+  if (!message || message.role !== "assistant") return null;
+  if (message.stopReason !== "error") return null;
+  const err = typeof message.errorMessage === "string" ? message.errorMessage.trim() : "";
+  if (err === "") return null;
+  return `${WX_TASK_ERROR_PREFIX}${err}`;
+}
+
+// ── hook 主体 ────────────────────────────────────────────────────
+
+/**
+ * 出站 hook。deps 可注入（单测）；生产用默认。
+ * - `transport()`：当前 Transport 句柄 getter（入口串接提供，服务 On 才非空）
+ * - `loadState()`：状态盘读取
+ * - `directSend(text)`：降沿一次性直发（transport 已收，走新 Wire）
+ */
+export function create_hook(deps = {}) {
+  const loadState = deps.loadState ?? state.load;
+  const transport = deps.transport ?? (() => null);
+  const directSend = deps.directSend ?? default_direct_send;
+  const trace = deps.trace ?? (() => {}); // 诊断痕迹（真机 ext stderr 不可见，落镜像 notice_log）
+
+ // 待发通知：true = 待发「已开启」，false = 待发「已关闭」，null = 无。
+ // **由服务状态迁移点置位**（mod.rs:190 注释同款，不靠沿检测造假前态）。
+  let pending = null;
+  let warned_direct = false;
+ // 待发异常停止回执：message_end 记最新一次（重试覆盖旧的），settle 发出。
+  let error_text = null;
+
+  const hook = {
+    /** 升沿（进 On）：挂起「已开启」。路由未就绪则由 flush_notice 留到下一拍。 */
+    on_start() {
+      pending = true;
+      trace("挂起:已连接");
+    },
+
+    /** 降沿（stop 迁移点）：按 stop_notice 规则挂起「已失联」（或静默）。 */
+    on_stop(user_stop, was_on) {
+      pending = stop_notice(user_stop, was_on);
+      if (pending === false) trace("挂起:已失联"); // 静默路径不留痕
+    },
+
+    /** 待发通知（测试/状态盘观测用）。 */
+    get notice() {
+      return pending;
+    },
+
+    /** message_end 出站：滤工具调用提取发言 → 分块 → transport 出站队列。
+     * 异常停止（stopReason=error）只记账不即发——等 agent_settled 定论。
+     * 返回已入队的文本（测试断言用）。handler 不替换消息（observe-only），
+     * 链式语义留给后续 handler。 */
+    on_message_end(message) {
+      const notice = error_notice_text(message);
+      if (notice) {
+        error_text = notice;
+        return [];
+      }
+ // 正常发言落地 = 运行恢复（重试成功等）：待报异常一笔勾销
+ // （非 error/aborted 的助手消息终态都算，缺 stopReason 的宽松视为健康）
+      if (message?.role === "assistant" && message?.stopReason !== "error" &&
+          message?.stopReason !== "aborted") {
+        error_text = null;
+      }
+      const tr = transport();
+      if (!tr) return [];
+      const sent = [];
+      for (const text of replies_for_message(message)) {
+        try {
+          tr.send(text);
+          sent.push(text);
+        } catch (e) {
+ // send 线程已退出（stop 竞态）：丢这一条，下条消息重判
+          console.error(`[wxbridge] 出站入队失败：${e?.message ?? e}`);
+        }
+      }
+      return sent;
+    },
+
+    /** agent_settled（自动重试/续跑全停，本轮定论）：有待报异常 → 补发微信。
+     * aborted = 用户主动停，不是异常；无 transport（服务关停）= 微信整体
+     * 不出站，账一并清（ desktop 自有错误展示，不留陈账到下轮）。 */
+    on_agent_settled(aborted) {
+      const text = error_text;
+      error_text = null;
+      if (!text || aborted) return [];
+      const tr = transport();
+      if (!tr) return [];
+      const sent = [];
+      for (const chunk of split_long_reply_text(text.replace(/\r\n/g, "\n"))) {
+        try {
+          tr.send(chunk);
+          sent.push(chunk);
+        } catch (e) {
+          console.error(`[wxbridge] 异常回执入队失败：${e?.message ?? e}`);
+          break;
+        }
+      }
+      return sent;
+    },
+
+    /** 每拍调用（泵循环后/状态迁移后）：冲刷待发通知。返回本次发出文本。
+     *
+     * 升沿：transport 出站队列入队即可，send 线程每次发送前重读状态。
+     * 降沿：transport 已 drop——一次性直发（15s 超时在 wire 层，
+     * 失败只 stderr，绝不阻塞调用方）。 */
+    flush_notice() {
+      if (pending === null) return [];
+      const st = loadState();
+      if (!is_routed(st)) return []; // 路由未就绪：留到下一拍
+      if (pending === true) {
+        const tr = transport();
+        if (!tr) return [];
+        try {
+          tr.send(WX_LINK_ON);
+        } catch {
+          return []; // send 线程已退出：留到下一拍（下一拍 transport 会被换掉）
+        }
+        pending = null;
+        trace("发出:已连接");
+        return [WX_LINK_ON];
+      }
+ // pending === false（用户关停降沿）
+      pending = null;
+      const text = WX_LINK_OFF;
+      trace("发出:已失联");
+      Promise.resolve()
+        .then(() => directSend(text))
+        .catch((e) => {
+          if (!warned_direct) {
+            warned_direct = true;
+            console.error(`[wxbridge] 关停通知直发失败：${e?.message ?? e}（此提示只出现一次）`);
+          }
+        });
+      return [text];
+    },
+  };
+  return hook;
+}
+
+/** 降沿直发默认实现：状态盘取路由五件套，新 Wire 一次发出（mod.rs
+ * wx-stop-notice 线程的 JS 对位）。不落盘任何东西——client_id 在副本上
+ * 临时生成（Rust `ensure_client_id(&mut st.clone())` 同款）。 */
+async function default_direct_send(text) {
+  const st = state.load();
+  const token = state.get_str(st, "bot_token");
+  if (!token) return;
+  const to_user = state.get_str(st, "chat_id") ?? state.get_str(st, "user_id");
+  if (!to_user) return;
+  const from_user = state.get_str(st, "bot_user_id");
+  if (!from_user) return;
+  const client_id = state.ensure_client_id({ ...st });
+  const wire = new Wire(state.dump_dir());
+  await send_text(wire, token, from_user, to_user, text, state.get_str(st, "context_token"), client_id);
+}

package/pi/hook.test.mjs

@@ -0,0 +1,351 @@
+// hook/reply 单测 —— 三路锚点：
+// ① wxprobe format/reply.rs 单测逐条镜像（同输入同断言值）；
+// ② parity/golden.jsonl 黄金值逐字复刻（ZCode 真实源码跑出的 71 条中
+// hook 消费的 flush.*/blocks.* content 段）；
+// ③ remote_control/mod.rs notice 流程对拍（启停通知置位/冲刷规则）。
+// 跑法：node --test packages/wechat-bridge/pi/hook.test.mjs
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  MAX_REPLY_MESSAGE_LENGTH,
+  split_long_reply_text,
+  extract_bot_assistant_response_messages,
+} from "./reply.mjs";
+import {
+  WX_LINK_ON,
+  WX_LINK_OFF,
+  WX_TASK_ERROR_PREFIX,
+  stop_notice,
+  is_routed,
+  assistant_speech_blocks,
+  replies_for_message,
+  error_notice_text,
+  create_hook,
+} from "./hook.mjs";
+
+// ---------------------------------------------------------------- ① reply.rs 单测镜像
+
+test("split_prefers_space_break_over_earlier_newline", () => {
+ // 窗口内既有换行又有空格时取 max → 空格更靠后就断在空格
+  const text = "line1\n" + "b".repeat(40) + " " + "c".repeat(3600);
+  const chunks = split_long_reply_text(text);
+ // 首块在空格处断（index 46），剩余 3600 个 c 还要再硬切一次 → 共 3 块。
+  assert.equal(chunks.length, 3, JSON.stringify(chunks.map((c) => c.length)));
+  assert.ok(chunks[0].endsWith("b".repeat(40)), JSON.stringify(chunks[0].slice(-50)));
+  assert.ok(chunks[0].startsWith("line1"), JSON.stringify(chunks[0].slice(0, 10)));
+  assert.equal(Array.from(chunks[1]).length, 3500, "第二次无断点硬切");
+});
+
+test("split_hard_cuts_when_no_breakpoint_in_window", () => {
+  const chunks = split_long_reply_text("x".repeat(7000));
+  assert.equal(chunks.length, 2, "无断点硬切 3500");
+  assert.equal(Array.from(chunks[0]).length, 3500);
+  assert.equal(Array.from(chunks[1]).length, 3500);
+});
+
+test("split_keeps_short_text_whole_and_trims", () => {
+  assert.deepEqual(split_long_reply_text("  hello  "), ["hello"]);
+  assert.deepEqual(split_long_reply_text(""), []);
+  assert.equal(split_long_reply_text("a".repeat(3500)).length, 1, "等于上限不切");
+});
+
+test("split_counts_by_code_points_like_rust_char", () => {
+ // 代理对 emoji 按码点计数：2000 个 emoji = 4000 UTF-16 单元但 2000 码点，
+ // 加 1600 个 ascii = 3600 码点 > 3500 → 切两块（UTF-16 切法会切出乱码块）
+  const text = "😀".repeat(2000) + "a".repeat(1600);
+  const chunks = split_long_reply_text(text);
+  assert.equal(chunks.length, 2);
+  for (const c of chunks) {
+    assert.ok(Array.from(c).every((ch) => !/\uD800/.test(ch)), "不产生孤立代理项");
+  }
+});
+
+test("flush_only_on_terminal_state", () => {
+  let { messages, rest } = extract_bot_assistant_response_messages(" partial ", false);
+  assert.deepEqual(messages, [], "非终态不 flush");
+  assert.equal(rest, " partial ", "原文保留在 buffer");
+
+  ({ messages, rest } = extract_bot_assistant_response_messages(" done ", true));
+  assert.deepEqual(messages, ["done"]);
+  assert.equal(rest, "", "flush 后 buffer 清空");
+});
+
+// ---------------------------------------------------------------- ② parity 黄金值（golden.jsonl 逐字）
+
+test("parity_flush_partial", () => {
+ // {"id":"flush.partial","out":{"messages":[],"rest":" 正在写入 wire.rs "}}
+  const { messages, rest } = extract_bot_assistant_response_messages("  正在写入 wire.rs  ", false);
+  assert.deepEqual(messages, []);
+  assert.equal(rest, "  正在写入 wire.rs  ");
+});
+
+test("parity_flush_terminal", () => {
+ // {"id":"flush.terminal","out":{"messages":["写完了\n第二行"],"rest":""}}
+  const { messages, rest } = extract_bot_assistant_response_messages("  写完了\r\n第二行  ", true);
+  assert.deepEqual(messages, ["写完了\n第二行"]);
+  assert.equal(rest, "");
+});
+
+test("parity_blocks_content_segments", () => {
+ // blocks.* 三条的 content 段（工具调用/变更摘要块被 hook 过滤，不在移植面）
+ // blocks.mixed: content "我先看看测试。" → ["我先看看测试。"]
+  assert.deepEqual(split_long_reply_text("我先看看测试。"), ["我先看看测试。"]);
+ // blocks.en: "Line one.\r\nLine two." → CRLF 归一 → ["Line one.\nLine two."]
+  assert.deepEqual(extract_bot_assistant_response_messages("Line one.\r\nLine two.", true).messages, [
+    "Line one.\nLine two.",
+  ]);
+ // blocks.long_content: 尾随空格 trim，单块整发
+  const long =
+    "先来一段很长的话用来验证分块：" +
+    Array.from({ length: 26 }, (_, i) => `${String.fromCharCode(97 + i)}`.repeat(4)).join(" ") +
+    " ";
+  assert.deepEqual(split_long_reply_text(long.replace(/\r\n/g, "\n")), [long.trimEnd()]);
+});
+
+test("max_reply_message_length_is_3500", () => {
+  assert.equal(MAX_REPLY_MESSAGE_LENGTH, 3500);
+});
+
+// ---------------------------------------------------------------- 消息 → 发言（滤工具调用）
+
+const assistant_msg = (content) => ({ role: "assistant", content });
+
+test("speech_blocks_filter_thinking_and_tool_calls", () => {
+  const msg = assistant_msg([
+    { type: "thinking", thinking: "内部推理" },
+    { type: "text", text: "第一段" },
+    { type: "toolCall", id: "t1", name: "bash", arguments: {} },
+    { type: "text", text: "第二段" },
+  ]);
+  assert.deepEqual(assistant_speech_blocks(msg), ["第一段", "第二段"]);
+});
+
+test("speech_blocks_reject_non_assistant_and_malformed", () => {
+  assert.deepEqual(assistant_speech_blocks({ role: "user", content: [{ type: "text", text: "x" }] }), []);
+  assert.deepEqual(assistant_speech_blocks(null), []);
+  assert.deepEqual(assistant_speech_blocks(assistant_msg(undefined)), []);
+ // 非 text 类型/非字符串 text 一律不进发言
+  assert.deepEqual(
+    assistant_speech_blocks(assistant_msg([{ type: "text", text: 42 }, { type: "text" }, "raw"])),
+    [],
+  );
+});
+
+test("replies_chunk_per_block_in_order", () => {
+ // 两个发言块独立分块后按序拼接；thinking/toolCall 不产生任何块
+  const long = "c".repeat(7000);
+  const msg = assistant_msg([
+    { type: "text", text: "先跑个命令" },
+    { type: "toolCall", id: "t", name: "bash", arguments: {} },
+    { type: "text", text: long },
+    { type: "thinking", thinking: "…" },
+  ]);
+  const replies = replies_for_message(msg);
+  assert.equal(replies.length, 3);
+  assert.equal(replies[0], "先跑个命令");
+  assert.equal(Array.from(replies[1]).length, 3500);
+  assert.equal(Array.from(replies[2]).length, 3500);
+});
+
+test("replies_empty_for_tool_call_only_or_whitespace", () => {
+  assert.deepEqual(replies_for_message(assistant_msg([{ type: "toolCall", id: "t", name: "bash", arguments: {} }])), []);
+  assert.deepEqual(replies_for_message(assistant_msg([{ type: "text", text: "   \r\n  " }])), []);
+});
+
+// ---------------------------------------------------------------- ③ 启停通知（002·通知 定案）
+
+test("stop_notice_rules_002", () => {
+ // 有意偏离 Rust 节制规则（见 hook.mjs 注释）：服务在跑 + 用户关停/卸载 →
+ // 宣告「已失联」；没在跑或非用户关停 → 静默
+  assert.equal(stop_notice(true, true), false, "用户关停+在跑 → 发「已失联」");
+  assert.equal(stop_notice(true, false), null, "没在跑谈不上关停通知");
+  assert.equal(stop_notice(false, true), null, "换绑（非用户关停）→ 静默");
+});
+
+test("notice_texts_match_002_notice", () => {
+ // 002·通知 定稿文案（messages.mjs 文案表单源，hook.mjs 转出）
+  assert.equal(WX_LINK_ON, "⚡️Pi-Flash已连接");
+  assert.equal(WX_LINK_OFF, "⚡️Pi-Flash已失联");
+});
+
+test("is_routed_reads_chat_id_or_user_id", () => {
+  assert.equal(is_routed({}), false);
+  assert.equal(is_routed({ chat_id: " " }), false, "空串视同缺失");
+  assert.equal(is_routed({ chat_id: "room@chat" }), true);
+  assert.equal(is_routed({ user_id: "u@im.wechat" }), true, "私聊只有 user_id 也算路由就绪");
+});
+
+// ---------------------------------------------------------------- hook 流程（create_hook 注入对拍）
+
+function mk_hook({ routed = true, transport = null, directSend } = {}) {
+  const sends = [];
+  const directs = [];
+  const tr = transport
+    ? { send: (t) => sends.push(t) }
+    : transport === null
+      ? null
+      : transport; // 传入 {send} 对象则用之
+  const hook = create_hook({
+    loadState: () => (routed ? { chat_id: "room@chat" } : {}),
+    transport: () => tr,
+    directSend: directSend ?? ((t) => directs.push(t)),
+  });
+  return { hook, sends, directs, tr };
+}
+
+const settle = () => new Promise((r) => setTimeout(r, 0));
+
+test("flush_start_waits_for_route_then_sends_once", () => {
+  const h = mk_hook({ routed: false });
+  h.hook.on_start();
+  assert.equal(h.hook.notice, true);
+  assert.deepEqual(h.hook.flush_notice(), [], "路由未就绪：留到下一拍");
+  assert.equal(h.hook.notice, true, "挂起不丢");
+ // 路由就绪但 transport 未起：继续等
+  const h2 = mk_hook({ routed: true, transport: null });
+  h2.hook.on_start();
+  assert.deepEqual(h2.hook.flush_notice(), []);
+  assert.equal(h2.hook.notice, true);
+ // transport 就绪 → 发出并清挂起；再拍 no-op
+  const h3 = mk_hook({ routed: true, transport: true });
+  h3.hook.on_start();
+  assert.deepEqual(h3.hook.flush_notice(), [WX_LINK_ON]);
+  assert.deepEqual(h3.sends, [WX_LINK_ON]);
+  assert.equal(h3.hook.notice, null);
+  assert.deepEqual(h3.hook.flush_notice(), []);
+});
+
+test("flush_start_retries_when_send_queue_rejects", () => {
+  const hook = create_hook({
+    loadState: () => ({ chat_id: "c" }),
+    transport: () => ({ send: () => { throw new Error("send 线程已退出"); } }),
+    directSend: () => {},
+  });
+  hook.on_start();
+  assert.deepEqual(hook.flush_notice(), []);
+  assert.equal(hook.notice, true, "入队失败不丢通知，下一拍重试");
+});
+
+test("user_stop_after_announced_sends_off_via_direct", async () => {
+  const h = mk_hook({ routed: true, transport: true });
+  h.hook.on_start();
+  h.hook.flush_notice(); // 已连接宣告完成
+  h.hook.on_stop(true, true); // 用户关停
+  assert.equal(h.hook.notice, false);
+  assert.deepEqual(h.hook.flush_notice(), [WX_LINK_OFF]);
+  await settle();
+  assert.deepEqual(h.directs, [WX_LINK_OFF], "降沿走一次性直发");
+  assert.deepEqual(h.sends, [WX_LINK_ON], "已停的 transport 不再入队");
+  assert.equal(h.hook.notice, null);
+  assert.deepEqual(h.hook.flush_notice(), [], "冲刷完 no-op");
+});
+
+test("user_stop_while_connect_pending_still_announces", () => {
+  const h = mk_hook({ routed: true, transport: true });
+  h.hook.on_start();
+ // 连接宣告还没冲出去就关停（真机 2026-11-01：渠道被夺/进程被杀抢在冲刷前）：
+ // 002·通知 = 服务在跑就报失联，不再被旧 announced 规则吞掉
+  h.hook.on_stop(true, true);
+  assert.equal(h.hook.notice, false, "was_on 即判据：挂起「已失联」");
+});
+
+test("rebind_stop_is_silent_even_after_announced", () => {
+  const h = mk_hook({ routed: true, transport: true });
+  h.hook.on_start();
+  h.hook.flush_notice();
+  h.hook.on_stop(false, true); // 换绑：stop(false) 落 Pending
+  assert.equal(h.hook.notice, null, "换绑静默，紧接着的 On 会发「已连接」");
+});
+
+test("message_end_queues_speech_chunks_to_transport", () => {
+  const h = mk_hook({ routed: true, transport: true });
+  const sent = h.hook.on_message_end(
+    assistant_msg([
+      { type: "text", text: "你好\r\n世界" },
+      { type: "toolCall", id: "t", name: "bash", arguments: {} },
+    ]),
+  );
+  assert.deepEqual(sent, ["你好\n世界"], "CRLF 归一后入队");
+  assert.deepEqual(h.sends, ["你好\n世界"]);
+ // 无 transport（服务关停）→ 静默丢弃（产品语义）
+  const h2 = mk_hook({ routed: true, transport: null });
+  assert.deepEqual(h2.hook.on_message_end(assistant_msg([{ type: "text", text: "x" }])), []);
+  assert.deepEqual(h2.sends, []);
+ // 非助手消息 / 工具调用消息 → 空
+  assert.deepEqual(h.hook.on_message_end({ role: "user", content: [{ type: "text", text: "hi" }] }), []);
+  assert.deepEqual(h.hook.on_message_end(assistant_msg([{ type: "thinking", thinking: "t" }])), []);
+});
+
+test("message_end_long_speech_splits_at_3500", () => {
+  const h = mk_hook({ routed: true, transport: true });
+  const sent = h.hook.on_message_end(assistant_msg([{ type: "text", text: "x".repeat(7000) }]));
+  assert.equal(sent.length, 2);
+  assert.ok(sent.every((s) => s.length === 3500));
+});
+
+// ---------------------------------------------------------------- 异常停止回执（2026-11-01 buglist#2）
+
+/** pi 出错形态的助手消息：stopReason="error"、errorMessage 携带文案、content 空。 */
+const error_msg = (errorMessage, stopReason = "error") => ({
+  role: "assistant",
+  content: [],
+  stopReason,
+  errorMessage,
+  usage: {},
+});
+
+test("error_notice_only_for_error_stop_with_text", () => {
+  assert.equal(error_notice_text(error_msg("boom")), `${WX_TASK_ERROR_PREFIX}boom`);
+  assert.equal(error_notice_text(error_msg("  boom  ")), `${WX_TASK_ERROR_PREFIX}boom`, "首尾空白裁掉");
+  assert.equal(error_notice_text(error_msg(undefined)), null, "无错误文本不报");
+  assert.equal(error_notice_text(error_msg("   ")), null);
+  assert.equal(error_notice_text(error_msg("boom", "aborted")), null, "用户主动停不是异常");
+  assert.equal(error_notice_text(error_msg("boom", "stop")), null);
+  assert.equal(error_notice_text(error_msg("boom", "toolUse")), null);
+  assert.equal(error_notice_text({ role: "user", content: [] }), null);
+  assert.equal(error_notice_text(null), null);
+});
+
+test("error_message_not_sent_immediately_stashed_for_settle", () => {
+  const h = mk_hook({ routed: true, transport: true });
+  assert.deepEqual(h.hook.on_message_end(error_msg("boom")), [], "error 消息不即发");
+  assert.deepEqual(h.sends, [], "等 settle 定论：瞬态错不刷屏");
+  assert.deepEqual(h.hook.on_agent_settled(false), [`${WX_TASK_ERROR_PREFIX}boom`]);
+  assert.deepEqual(h.sends, [`${WX_TASK_ERROR_PREFIX}boom`]);
+  assert.deepEqual(h.hook.on_agent_settled(false), [], "账已清：不重发");
+});
+
+test("recovered_run_clears_stashed_error", () => {
+  const h = mk_hook({ routed: true, transport: true });
+  h.hook.on_message_end(error_msg("transient"));
+ // 重试成功，正常发言落地 = 运行恢复
+  h.hook.on_message_end(assistant_msg([{ type: "text", text: "好了" }]));
+  assert.deepEqual(h.hook.on_agent_settled(false), [], "恢复了的运行不报旧账");
+  assert.deepEqual(h.sends, ["好了"]);
+});
+
+test("aborted_settle_swallows_error_notice", () => {
+  const h = mk_hook({ routed: true, transport: true });
+  h.hook.on_message_end(error_msg("boom"));
+  assert.deepEqual(h.hook.on_agent_settled(true), [], "/停止语义：不报异常");
+  assert.deepEqual(h.hook.on_agent_settled(false), [], "账已清");
+});
+
+test("settled_without_transport_clears_silently", () => {
+  const h = mk_hook({ routed: true, transport: null });
+  h.hook.on_message_end(error_msg("boom"));
+  assert.deepEqual(h.hook.on_agent_settled(false), [], "服务关停 = 微信整体不出站，不留陈账");
+});
+
+test("settled_error_long_text_splits_at_3500", () => {
+  const h = mk_hook({ routed: true, transport: true });
+  h.hook.on_message_end(error_msg("x".repeat(7000)));
+  const sent = h.hook.on_agent_settled(false);
+ // 前缀 9 码点 + 7000 = 7009 → 3500/3500/9 三块；前缀内无空格，首块整带前缀
+  assert.equal(sent.length, 3, `应分三块：${sent.length}`);
+  assert.ok(sent[0].startsWith(WX_TASK_ERROR_PREFIX), "首块整带前缀");
+  assert.equal(Array.from(sent[0]).length, 3500);
+  assert.equal(Array.from(sent[2]).length, 7009 - 7000);
+});