@zaofan/dsh-qqbot 1.10.4 → 1.10.6

package/examples/ext-commands//344/274/232/350/257/235/345/210/227/350/241/250.mjs

@@ -30,8 +30,25 @@
  *      一律走 **`globalThis` 符号槽（`publishShared`/`adoptShared`）+ 磁盘（`saveState`/`loadState`）**，
  *      模块变量只当本地缓存。
  */
-const PAGE = 20;                          // 一页 20 个选项（4 行 × 5 列；第 5 行留给导航）
-const LETTERS = 'ABCDEFGHIJKLMNOPQRST';
+/**
+ * ★★ 一页几个选项 = 由 **QQ 内联键盘的硬上限**倒推出来的，不是随便定的（2026-10-14 真机踩中）
+ *
+ * QQ 官方对内联键盘的限制：**总行数 ≤ 5**、每行 ≤ 5 个按钮。
+ * 超了会被直接拒绝，原话见诊断日志：
+ *   `HTTP 400: {"message":"请求错误，内联键盘行/列超限","code":40034029}`
+ * 更坑的是：tier① 被拒后会**静默退化成纯文本兜底** —— 现象就是主人反馈的
+ * 「文字发出来了，按钮选项消失」。
+ *
+ * 所以布局固定为 **5 行**：
+ *   第 1~3 行 = 选项（**一页最多 15 个**）
+ *   第 4 行   = 翻页（◀ 上一页 / 下一页 ▶），没得翻时放一个占位按钮
+ *   第 5 行   = 取消
+ * （2026-10-14 之前是 PAGE=20 ⇒ 4 行选项 + 2 行尾巴 = **6 行** ⇒ 必然被拒。）
+ */
+const PAGE = 15;
+const OPT_ROWS = 3;                       // 选项最多 3 行（3×5 = 15）
+const MAX_KB_ROWS = 5;                    // QQ 内联键盘总行数硬上限
+const LETTERS = 'ABCDEFGHIJKLMNO';        // 15 个
 const CARD_EXPIRE_MS = 10 * 60_000;
 const MAX_PAGE_MS = 30 * 60_000;
 const TOOL = '会话列表';                   // ★ 必须与文件名/注册名一致
@@ -174,7 +191,11 @@ async function regCardSelf(ctx, cardId, buttonIds) {
   } catch { return false; }
 }
 
-/** 发卡（markdown + 按钮键盘）；四级兜底，与 /子会话 同款 */
+/** 发卡（markdown + 按钮键盘）；四级兜底，与 /子会话 同款。
+ *  ★ 返回值要说实话（2026-10-14 修）：`'kb'`=带按钮发出去了 / `'text'`=**退化成纯文本**（按钮没了）
+ *  / `'fail'`=什么都没发出去。之前只会返回 true/false，**退化被当成成功**，
+ *  于是"文字出来了、按钮消失"这种事故在日志里显示 `发出=ok`，白排查半天。 */
+let LAST_SEND_ERR = '';
 async function sendCard(ctx, text, keyboard) {
   const caps = ctx?.caps ?? ctx ?? {};
   const mc = ctx?.message ?? {};
@@ -189,24 +210,25 @@ async function sendCard(ctx, text, keyboard) {
     const body = { msg_type: 2, markdown: { content: text }, keyboard, ...(gid ? {} : { content: text }) };
     try {
       const r = await api(path, { method: 'POST', body });
-      void diag(`[sendCard] ①api=${JSON.stringify(r ?? null).slice(0, 140)}`);
-      if (r && r.ok !== false) return true;
-    } catch (e) { void diag(`[sendCard] ①抛错=${short(e?.message ?? e, 140)}`); }
+      void diag(`[sendCard] ①api=${JSON.stringify(r ?? null).slice(0, 200)}`);
+      if (r && r.ok !== false) { LAST_SEND_ERR = ''; return 'kb'; }
+      LAST_SEND_ERR = cn(r?.err?.human ?? r?.err?.message ?? r?.err?.code ?? 'ok=false');
+    } catch (e) { LAST_SEND_ERR = cn(e?.message ?? e); void diag(`[sendCard] ①抛错=${short(e?.message ?? e, 200)}`); }
   }
   try {
     if (keyboard && typeof caps.markdownCard === 'function') {
       const r2 = await caps.markdownCard(text, keyboard);
-      if (r2) return true;
+      if (r2) return 'kb';
     }
   } catch { /* ignore */ }
   try {
     if (keyboard && typeof ctx?.sender?.sendMarkdownWithKeyboard === 'function') {
       await ctx.sender.sendMarkdownWithKeyboard(ctx.replyTarget, text, keyboard);
-      return true;
+      return 'kb';
     }
   } catch { /* ignore */ }
-  try { if (typeof caps.markdown === 'function' && (await caps.markdown(text))) return true; } catch { /* ignore */ }
-  return false;
+  try { if (typeof caps.markdown === 'function' && (await caps.markdown(text))) return 'text'; } catch { /* ignore */ }
+  return 'fail';
 }
 
 /** 按钮（id 不能带冒号） */
@@ -514,7 +536,7 @@ function cardKeyboard(st) {
   const opts = st.options;
   const start = st.page * PAGE;
   const cur = opts.slice(start, start + PAGE);
-  for (let r = 0; r * 5 < cur.length && r < 4; r++) {
+  for (let r = 0; r * 5 < cur.length && r < OPT_ROWS; r++) {
     const row = [];
     for (let c = 0; c < 5; c++) {
       const i = r * 5 + c;
@@ -528,6 +550,8 @@ function cardKeyboard(st) {
   if (start + PAGE < opts.length) nav.push(btn('next', '下一页 ▶', 1));
   rows.push(nav.length ? nav : [btn('noop', '·', 1)]);
   rows.push([btn('cancel', '取消', 4)]);
+  // ★ 保底：QQ 只收 ≤5 行；真超了就砍尾巴（正常布局下正好 5 行，走不到这里）
+  while (rows.length > MAX_KB_ROWS) rows.splice(rows.length - 2, 1);
   return keyboardOf(rows, st.cardId);
 }
 
@@ -535,9 +559,11 @@ function cardKeyboard(st) {
 async function paint(ctx, st) {
   st.options = await optionsOf(ctx, st.step, st);
   if (st.page * PAGE >= st.options.length) st.page = Math.max(0, Math.ceil(st.options.length / PAGE) - 1);
+  st.error = '';
   st.cardId = `${TOOL}-${++seq}-${Date.now().toString(36)}`;
   const kb = cardKeyboard(st);
-  const ok = await sendCard(ctx, cardText(st), kb);
+  const mode = await sendCard(ctx, cardText(st), kb);
+  const ok = mode === 'kb';
   const caps = ctx?.caps ?? ctx ?? {};
   const allIds = [...st.options.map((_, i) => `p${i}`), 'prev', 'next', 'cancel', 'noop'];
   try {
@@ -552,8 +578,12 @@ async function paint(ctx, st) {
   }
   publishShared({ dataRoot: dataRootOf(ctx) });
   try { await saveState(ctx, st.cardId, st); } catch { /* ignore */ }   // ★ 落盘：回调侧可能是**另一个模块实例**
-  void diag(`[paint] step=${st.step} page=${st.page} 选项=${st.options.length} 发出=${ok ? 'ok' : 'FAIL'} 表=${W.size}`);
-  if (!ok) st.error = '卡片没发出去（当前环境可能不支持富文本卡片）';
+  void diag(`[paint] step=${st.step} page=${st.page} 选项=${st.options.length} 发出=${mode}${LAST_SEND_ERR ? ' err=' + short(LAST_SEND_ERR, 80) : ''} 表=${W.size}`);
+  if (mode !== 'kb') {
+    st.error = mode === 'text'
+      ? `按钮没发出去（QQ 拒了键盘：${short(LAST_SEND_ERR, 50) || '未知'}），这一步只能纯文本显示`
+      : '卡片完全没发出去（当前环境可能不支持富文本卡片）';
+  }
   return ok;
 }
 

package/examples/ext-inbound/README.md

@@ -228,3 +228,31 @@ export default { name: 'x', onInbound, onDecide, dispose() {} };   // 对象默
 | 低分消息还是回话了 | 日志里搜 `强制入站(入站扩展 forceWake…` —— 可能是你自己的扩展要求的；也可能是 `forceWake` 之后 debounce 把标记带下去了（正常） |
 | 禁言没生效 | `isMuted()` 是不是写在"消灭"之前却被后面的分支覆盖了；名单文件在 `.state/<你的文件名>.json` |
 | 熔断了 | 日志搜 `⚠ 熔断「…」`；复位 = 改文件 + `/tools-reload` |
+
+---
+
+## 附：`annihilate({ ownerAck: true })` —— 唯一能吞"主人消息"的通道（v1.10.5 新增）
+
+**背景**：白名单写着「主人的消息永不可被入站扩展吞掉」，`ctx.annihilate()` 遇到主人发送者会**直接返回 false**
+（审计 `refused-owner`），引擎还有第二道兜底（扩展没调 `next()` 时替它放行）。这两道一起保证了
+"用户脚本坏了也吞不掉主人的话"。
+
+**但有一类是主人自己的意图**：例如**二档路由隔绝** —— 群里那条 `[s:c0246642] 来我房间` 已经被扩展
+投递到目标会话了，主人明确要求**不要再留在本会话上下文里**。这时扩展可以：
+
+```js
+const ok = ctx.annihilate({ reason: '二档路由隔绝：已投到目标会话', ownerAck: true });
+if (!ok) return next();          // 没吞掉 ⇒ 交回原路径，别双投
+// ★ 吞掉之后照样要 return next()：annihilate 置位会让 next() 变成空操作、链停在这里
+return next();
+```
+
+**三条纪律**（写在 `ExtInboundCaps.annihilate` 的类型注释里）：
+
+1. **只在"你确实已经把内容投递到别处"时传** —— 否则主人的话会凭空消失；
+2. 用了它**一定落审计** `result: 'ok-owner-ack'`（外加一条 warn），事后可查"哪条主人的消息被谁吞了、为什么"；
+3. 它只解开**这一条**的白名单 —— 挂点检查、熔断等其它保护一律照旧。
+
+**向后兼容**：老版本插件不认识 `ownerAck`，会照旧按白名单拒绝 ⇒ 行为退回"主人的消息照常放行"，不会更糟。
+
+**参考实现**：同目录 `route-isolate.mjs`。

package/examples/ext-inbound/route-isolate.mjs

@@ -0,0 +1,132 @@
+/**
+ * route-isolate.mjs — 入站中间件：**二档绑定的路由消息，不进父会话上下文（彻底隔绝）**
+ *
+ * 放在 `{数据根}/.qqbot-extensions/inbound/route-isolate.mjs`；改完 `/tools-reload` 立即生效。
+ *
+ * ── 它解决什么（主人 2026-10-14 需求，原话）────────────────────────────────
+ *   「如果是挡位2的情况下，所有的路由的消息，不进入父会话的上下文，彻底隔绝」
+ *   「我是说，用户发的消息，如果是路由用的，不进入你的上下文，不是说回灌的消息」
+ * 即：群里那条 `[s:c0249642] 喜欢你` —— 只该出现在**目标会话**里，
+ * 不该同时躺进鲸鱼娘本尊（父会话）的上下文。二档本就意味着"子会话内容只去 QQ、不进父上下文"，
+ * 本扩展把**反方向**补齐：**父上下文 ↔ 子会话 彻底互不可见**。
+ *
+ * ── 为什么只能写在**早挂点 onInbound** ──────────────────────────────────────
+ * 链上位置：`… → quoteRef → ★onInbound（本文件）★ → 引用图预取 → 记群历史 → … → AI`
+ * 只有这里在"记群历史之前"，所以只有这里的 `ctx.annihilate()` 才真的等于"这条没来过"
+ * （不进历史、不进上下文、不占冷却）。晚挂点调它会**被拒 + 告警**。
+ *
+ * ── 三个必须这么写的地方 ───────────────────────────────────────────────────
+ * ① **消灭之后必须自己投递**：`session_watch_lib` 原来那条路由投递挂在 `session/event` 的
+ *    `user/message` 上；消息都被消灭了，那个事件**永远不会发生** ⇒ 这里消灭前先解析目标、
+ *    消灭后直接调 `lib.routeToSession()`。
+ * ② **`return next()`，不能"消灭完就 return"**：插件引擎有条兜底 —— 扩展"既没调 next、
+ *    又没有成功的消灭"时**替它放行**，且白名单写着"主人的消息永远不被入站扩展吞掉"。
+ *    但这条兜底**只在 `!onward` 时触发**（=扩展压根没调 next）；调了 next，
+ *    `annihilate` 的置位会**直接吃掉 next**（链停在这里 + 跳过兜底）⇒ **主人的消息也真的被消灭**。
+ *    这正是主人要的。⚠️ 该语义照 `src/features/ext-inbound.ts` 的
+ *    `runEarlyInboundExtensions` 确认；哪天插件收紧它，这里会退化成"主人消息照进上下文"（不会更糟）。
+ * ③ **只有二档才隔绝**：`modeOfRoute(key) === 2`。没绑过 / 一档 / 三档 ⇒ 原样放行。
+ *
+ * ── 安全阀（宁可"不隔绝"，也不要"消息凭空消失"）──────────────────────────
+ *   · 没路由标记 ⇒ 放行；· 不是二档 ⇒ 放行；
+ *   · **路由 id 解析不出会话**（写错了）⇒ 放行；· `annihilate` 返回 false（熔断/挂点不允许）⇒ 放行，
+ *     交回原路径投递，避免"我投一次 + 原路径再投一次"双投；
+ *   · 已消灭但投递失败（目标不在线且唤不醒）⇒ 不回父上下文（这是隔绝的代价），只记诊断日志。
+ *
+ * ── 诊断 ──────────────────────────────────────────────────────────────────
+ * 全程写 `{数据根}/.qqbot-extensions/data/route-isolate-diag.log`。
+ * （教训：一开始只往 logger 写，而**从来没人注入过 logger** ⇒ 真机上完全静默、无法定位。）
+ */
+
+/** 只在插件日志里显示的名字 */
+export const name = 'route-isolate';
+
+/** ★ 诊断必须**落盘**：logger 没人注入过，只往 logger 写等于瞎的 */
+const DIAG_FILE = 'D:/newwenjianjia/aiwork/鲸鱼娘/dshqqbot/.qqbot-extensions/data/route-isolate-diag.log';
+let LOG = null;
+
+async function note(msg) {
+  try { LOG?.(msg); } catch { /* ignore */ }
+  try {
+    const { appendFile, mkdir } = await import('node:fs/promises');
+    const { dirname } = await import('node:path');
+    await mkdir(dirname(DIAG_FILE), { recursive: true });
+    const line = new Date().toISOString() + ' ' + String(msg) + '\n';
+    await appendFile(DIAG_FILE, line);
+  } catch { /* 诊断失败绝不影响主流程 */ }
+}
+
+async function loadLib() {
+  return await import(new URL('../tools/lib/session_watch_lib.mjs?v=' + Date.now(), import.meta.url).href);
+}
+
+/** 早挂点：链上唯一"还没记群历史"的位置 */
+export async function onInbound(ctx, next) {
+  try {
+    // ★★ 正文从哪读：**`ctx.text` 才是插件给的规范读法**（它内部 = `textOf(ctx)`），
+    //    实际存在 `ctx.message.content` 里。**不存在 `ctx.message.text`** ——
+    //    2026-10-14 就是因为写成 `.text` 读到空串、第一行就 return next()，
+    //    整条链路静默放行（审计里一条记录都没有）才排查了半天。
+    const text = String(ctx?.text ?? ctx?.message?.content ?? ctx?.message?.text ?? '');
+    if (!text) return next();
+    const lib = await loadLib();
+
+    // ★★ 2026-10-14：**顺手把 sender/replyTarget 交给回灌库**（`rememberFwd`）。
+    //   为什么必须挂在入站链上：QQ 转发能力 `fwd` 是**内存态**，插件一重启就丢；
+    //   唯一的自愈路径是"父会话发言时 hydrateFwd"，而它需要 sender ——
+    //   工具侧只有"被调用过"才注入（`session_watch.mjs` 里的 rememberFwd），
+    //   于是重启后如果没人记得调工具，转发就一直断（实测踩到）。
+    //   挂在这里 ⇒ **每条群消息都刷新一次** ⇒ 重启后父会话随便说一句话转发就自动恢复。
+    //   注意用 `ctx.caps.*` 而不是 `ctx.*`：ctx 上那个 `sender` 已被插件定义成"发送者 openid"（字符串）。
+    try {
+      lib.rememberFwd?.(ctx?.caps?.sender, ctx?.caps?.replyTarget);
+    } catch { /* 注入失败不影响隔绝 */ }
+
+    const key = lib.parseRouteKey(text);
+    // 每次都记"手上有什么" —— kernel / annihilate 缺任一个都会走放行分支，先看清
+    void note('[enter] text=' + JSON.stringify(text.slice(0, 50))
+      + ' key=' + (key || '-')
+      + ' kernel=' + typeof ctx?.kernel
+      + ' annihilate=' + typeof ctx?.annihilate
+      + ' next=' + typeof next);
+
+    if (!key) return next();
+
+    // ① 只有二档才隔绝（没绑 = 0，一/三档 = 1/3，都放行）
+    const mode = lib.modeOfRoute(key);
+    void note('[mode] key=' + key + ' mode=' + mode);
+    if (mode !== 2) return next();
+
+    // ② 目标解析不出来 ⇒ 不吞（写错 id 时别让消息凭空消失）
+    const kernel = ctx?.kernel ?? null;
+    let full = '';
+    try { full = lib.resolveShortId(kernel, key) ?? ''; } catch { full = ''; }
+    if (!full) {
+      try { full = lib.findSessionOnDisk(key)?.id ?? ''; } catch { full = ''; }
+    }
+    if (!full) { void note('[skip] id 解析不到会话 key=' + key); return next(); }
+
+    // ③ 先消灭再投递 —— 顺序不能反：先投再吞的话，一旦消灭被熔断拒绝就会双投
+    // ★ `ownerAck: true` —— 唯一能吞"主人消息"的通道（2026-10-14 为此专门给插件加了显式例外）。
+    //   语义：这条我已经**另行投递到目标会话**了，请允许对主人生效；插件会落审计 ok-owner-ack。
+    const acked = ctx?.annihilate?.({ reason: '二档路由隔绝：目标 ' + key, ownerAck: true });
+    if (!acked) { void note('[skip] annihilate 被拒 key=' + key + ' target=' + full.slice(0, 20)); return next(); }
+
+    // ④ 已消灭 ⇒ 自己投递（原路径的 user/message 钩子不会跑了）
+    let r = null;
+    try {
+      r = await lib.routeToSession(kernel, text, { message: ctx?.message });
+    } catch (e) {
+      r = { ok: false, reason: 'throw:' + (e?.message ?? e) };
+    }
+    void note('[done] key=' + key + ' target=' + full.slice(0, 20)
+      + ' 已从父上下文移除；投递=' + (r?.ok ? 'ok(' + r.reason + ')' : 'FAIL(' + r?.reason + ')'));
+  } catch (e) {
+    void note('[error] ' + (e?.message ?? e));
+  }
+  // ★ 必须调 next()：跳过"发送者是主人 ⇒ 引擎替它放行"那条兜底（见文件头 ②）
+  return next();
+}
+
+/** 插件可用它注入日志（没注入也会落盘诊断） */
+export function setLogger(fn) { LOG = typeof fn === 'function' ? fn : null; }

package/examples/ext-tools/lib/session_watch_lib.mjs

@@ -56,7 +56,7 @@
  * 版本标记：供调用方打印，用来确认**热刷后加载到的到底是哪一版**。
  * 改动本文件时顺手把这个号 +1（或换日期），排查"改了不生效"时一眼就能看出来。
  */
-export const __LIB_VERSION__ = 'lib-v13-20261014-通用路由([s:短id] / 【会话 id】)+扫盘解析+会话列表';
+export const __LIB_VERSION__ = 'lib-v14-20261014-通用路由+扫盘解析+会话列表+父会话跟QQ对象走+二档路由隔绝';
 
 // ── ★ 2026-10-13 持久化改造（主人指示：**以本地存档为准，别只靠内存**）──────────────
 //   本文件的风格是"用到时动态 import"；这里用**顶层 await** 一次性取到同步版 fs，
@@ -97,6 +97,68 @@ export function rememberFwd(sender, replyTarget) {
 }
 const watching = (globalThis[WATCHING_KEY] ??= new Map()); // childSessionId -> entry
 
+/**
+ * ★★ 2026-10-14：**父会话跟着「QQ 对象」走**（主人定：绑的应该是 QQ 对象，不是那一刻的会话 id）
+ *
+ * 病根：原来 `parentAgentId` 是绑定时写死的 session id，回灌直接 `agents.get(那个 id)`。
+ *   在 QQ 里发 `/bot-new` 会**新开一个会话**（新 id），名单里那条记录却还指着旧会话
+ *   ⇒ 回灌继续落进旧会话；而"转发到 QQ"那一路用的是 openid、照旧正常 ⇒ 表面上完全看不出错。
+ *
+ * 修法（不需要插件内部 API）：记一张 `peerKey = scope:peerId`（QQ 对象）→ **最近一次为该对象发言的
+ *   会话 id** 的表；回灌前先按 peerKey 取最新会话，取不到才回落到写死的旧 id。
+ *   `/bot-new` 之后该对象的下一条消息必然落到新会话 ⇒ 这张表立刻学到新 id ⇒ 回灌自动跟过去。
+ *
+ * 自愈：老记录（没有 peerKey）在"它的父会话下一次发言"时自动补上 peerKey —— 与 fwd 补回同一套路数。
+ */
+const PEER_KEY = Symbol.for('dsh-qqbot.session-watch.peerLatest');
+const peerLatest = (globalThis[PEER_KEY] ??= new Map()); // peerKey -> sessionId
+
+/** 从**会话对象**里取 QQ 对象键（scope:peerId）。刻意不用 `o.id` —— 那是会话 id，不是 peer */
+function peerKeyOfSession(s) {
+  try {
+    if (!s) return '';
+    const peerId = String(s.peerId ?? s.groupOpenid ?? s.groupId ?? '');
+    if (!peerId) return '';
+    const scope = String(s.scope ?? s.peerScope ?? '') || 'group';
+    return scope + ':' + peerId;
+  } catch { return ''; }
+}
+
+/** 从 **replyTarget / peer 视图**里取 QQ 对象键 */
+function peerKeyOfTarget(rt) {
+  try {
+    if (!rt) return '';
+    const id = String(rt.peerId ?? rt.targetId ?? rt.groupOpenid ?? rt.openid ?? rt.groupId ?? rt.id ?? '');
+    if (!id) return '';
+    const scope = String(rt.scope ?? rt.kind ?? '') || 'group';
+    return scope + ':' + id;
+  } catch { return ''; }
+}
+
+/** 学到"这个 QQ 对象最近在哪个会话里说话"，顺手给老盯梢补 peerKey（自愈） */
+export function notePeerSeen(session, sid) {
+  try {
+    const pk = peerKeyOfSession(session);
+    if (!pk || !sid) return false;
+    let changed = peerLatest.get(pk) !== sid;
+    if (changed) peerLatest.set(pk, sid);
+    for (const w of watching.values()) {
+      if (!w.peerKey && w.parentAgentId === sid) { w.peerKey = pk; changed = true; }
+    }
+    if (changed) void persist();   // 落盘失败静默，不影响监听
+    return changed;
+  } catch { return false; }
+}
+
+/** 回灌该投给谁：优先"该 QQ 对象当前所在的会话"，其次绑定时写死的父会话（老行为） */
+function resolveParentId(w) {
+  try {
+    const pk = String(w?.peerKey ?? '');
+    const latest = pk ? String(peerLatest.get(pk) ?? '') : '';
+    return latest || String(w?.parentAgentId ?? '');
+  } catch { return String(w?.parentAgentId ?? ''); }
+}
+
 /**
  * 默认存档路径：`{dataRoot}/.qqbot-extensions/tools/data/session-watch-watching.json`
  * （**与 `vote.json` 同一个 data 目录** —— 对齐既有约定：扩展各类的存档都放
@@ -126,6 +188,8 @@ export function ensureLoaded() {
     if (!file) return watching.size;
     const j = JSON.parse(readFileSync(file, 'utf8'));
     const rows = Array.isArray(j?.rows) ? j.rows : [];
+    // ★ 2026-10-14：读回"QQ 对象 → 最近发言会话"表（父会话跟着 QQ 对象走的依据）
+    try { for (const [k, v] of Object.entries(j?.peers ?? {})) if (k && v) peerLatest.set(String(k), String(v)); } catch { /* ignore */ }
     for (const r of rows) {
       const child = String(r?.child ?? '').trim();
       const parent = String(r?.parent ?? '').trim();
@@ -140,6 +204,7 @@ export function ensureLoaded() {
         preset: String(r?.preset ?? ''),
         workspace: String(r?.workspace ?? ''),
         peerName: String(r?.peerName ?? ''),
+        peerKey: String(r?.peerKey ?? ''),
         // ⚠️ 重启后拿不到 sender/replyTarget ⇒ 先恢复"回灌父会话"，
         //    QQ 转发等下次 register（或主人重挂）时补上 ⇒ 这里如实置空、不假装就绪。
         fwd: null,
@@ -199,8 +264,12 @@ async function persist() {
       workspace: w.workspace ?? '',
       mode: w.mode ?? 1,
       peerName: w.peerName ?? '',
+      peerKey: w.peerKey ?? '',
     }));
-    writeFileSync(file, JSON.stringify({ v: 1, at: Date.now(), rows }, null, 2), 'utf8');
+    // ★ 2026-10-14：把"QQ 对象 → 最近发言会话"表一起落盘（父会话跟着 QQ 对象走的依据）
+    const peers = {};
+    for (const [k, v] of peerLatest.entries()) if (k && v) peers[k] = v;
+    writeFileSync(file, JSON.stringify({ v: 1, at: Date.now(), rows, peers }, null, 2), 'utf8');
   } catch { /* ignore */ }
 }
 
@@ -665,7 +734,12 @@ function parentEntryOf(sid) {
  *   只取文本会把图丢掉，所以这里额外把附件 URL/语音转写一并拼进载荷。
  * @returns {Promise<{ok: boolean, reason: string, id?: string, workspace?: string, atts?: number}>}
  */
-async function routeToSession(root, text, ev) {
+/**
+ * ★ 对外导出（2026-10-14）：入站扩展要**在钩子之前**自己投递 —— 因为"二档路由隔绝"会把这条消息
+ * 在早挂点就 annihilate 掉，一旦消灭成功，`session/event` 的 `user/message` 就永远不会发生，
+ * 原来那条投递路径（本文件里的监听器）根本不会跑。所以投递逻辑必须能被扩展直接调。
+ */
+export async function routeToSession(root, text, ev) {
   try {
     const key = parseRouteKey(text);
     if (!key) return { ok: false, reason: 'no-key' };
@@ -838,6 +912,9 @@ async function handler(root, session, event) {
 
     // ── 引用回流：只关心**入站 user 消息**，且只在"某个盯梢对象的父会话"里认 ──
     if (type === 'user/message') {
+      // ★ 2026-10-14：先学"这个 QQ 对象最近在哪个会话说话"（父会话跟着 QQ 对象走的依据）。
+      //   必须放在路由分支**之前** —— 否则主人只发路由消息时，这张表永远学不到东西。
+      notePeerSeen(session, sid);
       const t = textOf(event);
       // ★ 2026-10-14：**通用路由优先** —— 正文里出现会话 id（`[s:xxx]` / `【会话 xxx】`）就直接投给
       //   那个会话。**不限已盯梢、不限是不是父会话**（主人要的"任何已有会话都能被点名"）。
@@ -919,7 +996,10 @@ async function handler(root, session, event) {
     w.lastSent = text;
 
     const agents = root.get('agents');
-    const parent = agents?.get?.(w.parentAgentId) ?? null;
+    // ★ 2026-10-14：**父会话跟着 QQ 对象走** —— 该 QQ 对象当前所在的会话优先（/bot-new 之后自动跟过去），
+    //   没学到才回落到绑定时写死的那个 id（老行为，向后兼容）。
+    const parentId = resolveParentId(w);
+    const parent = agents?.get?.(parentId) ?? null;
     if (!parent) return; // 父不在（不 live）→ 静默跳过，不制造错误
 
     const candidate = buildSettlementNotice({ sessionId: sid, label: w.label, rawReason, text });
@@ -990,6 +1070,9 @@ export async function register(root, opts = {}) {
   if (HOOK_DISABLED) return '未挂（回灌钩子当前被 HOOK_DISABLED 主动关闭，属预期；恢复见 installHook 注释）';
   if (!hooked) return '未挂（root.on 抛错）';
   const fwd = (opts.sender && opts.replyTarget) ? { sender: opts.sender, replyTarget: opts.replyTarget } : null;
+  // ★ 2026-10-14：记下这条盯梢属于哪个 **QQ 对象**（scope:peerId）—— 父会话要跟着它走。
+  //   优先级：调用方显式给的 peerKey ＞ replyTarget 里能抠出来的 ＞ 空（空则退回写死的 parentAgentId）。
+  const pk = String(opts.peerKey ?? '').trim() || peerKeyOfTarget(opts.replyTarget);
   watching.set(childSessionId, {
     parentAgentId,
     label,
@@ -1000,6 +1083,7 @@ export async function register(root, opts = {}) {
     preset: String(opts.preset ?? '').trim(),
     workspace: String(opts.workspace ?? '').trim(),
     peerName: String(opts.peerName ?? ''),
+    peerKey: pk,
     fwd,
     lastText: '',
     texts: [],
@@ -1008,6 +1092,8 @@ export async function register(root, opts = {}) {
     firedAt: 0,
     lastForwarded: '',
   });
+  // 绑定时先按"当时那个会话"给这张表起步；**只在没记录时写**，别把已经学到的新会话覆盖回旧的。
+  if (pk && parentAgentId && !peerLatest.has(pk)) peerLatest.set(pk, parentAgentId);
   await persist();
   const modeText = mode === 2 ? '二档(全部正文+报错→QQ，不进父上下文)'
     : mode === 3 ? '三档(进父上下文但不唤醒 + 全转QQ)'
@@ -1032,13 +1118,47 @@ export async function unregister(childSessionId) {
 }
 
 /** 给别的工具（如 session_watch 状态查询）读当前盯着的清单 */
-export function listWatching() {
-  ensureLoaded();   // ★ 先保证存档已读回内存（重启后第一次调它就能看到完整名单）
+/**
+ * ★ 某个路由短 id 对应的**回灌挡位**（读内存名单；没绑过返回 0）。
+ *
+ * 入站扩展用它判断"这条路由消息要不要在父上下文里彻底消失"：
+ *   挡位 2（二档）= 双向隔绝 —— 子会话的正文只去 QQ、**不进父上下文**（原有语义），
+ *   那么反向也一样：**用户发进群的路由消息也不该落进父上下文**（2026-10-14 主人定）。
+ * 没绑过的（纯通用路由）返回 0 ⇒ **不进隔绝**，保持原样投递 + 照常进上下文。
+ */
+export function modeOfRoute(key) {
+  try {
+    ensureLoaded();
+    const k = String(key ?? '').trim();
+    if (!k) return 0;
+    for (const [sid, w] of watching.entries()) {
+      const short = shortSessionId(sid);           // 例：fc871e99
+      if (short === k || sid === k || sid === `session-${k}`) return Number(w?.mode ?? 1) || 1;
+    }
+  } catch { /* ignore */ }
+  return 0;
+}
+
+/**
+ * 供工具/命令展示：这条盯梢**当前**会把回灌投给谁（= 跟着 QQ 对象动态解析之后的结果）。
+ * 与 `parentAgentId`（绑定时写死的那个）不同：发过 `/bot-new` 之后这两个会不一样。
+ */
+export function effectiveParentOf(childSessionId) {
+  ensureLoaded();
+  const w = watching.get(String(childSessionId ?? ''));
+  return w ? resolveParentId(w) : '';
+}
+
+export function listWatching() {  ensureLoaded();   // ★ 先保证存档已读回内存（重启后第一次调它就能看到完整名单）
   return [...watching.entries()].map(([sid, w]) => ({
     childSessionId: sid,
     shortId: shortSessionId(sid),
     parentAgentId: w.parentAgentId,
     parentShortId: shortSessionId(w.parentAgentId),
+    /** QQ 对象键（scope:peerId）；父会话会跟着它动态解析 */
+    peerKey: w.peerKey ?? '',
+    /** 当前实际会投给的父会话（发过 /bot-new 后会与 parentAgentId 不同） */
+    effectiveParentShortId: shortSessionId(resolveParentId(w)),
     label: w.label,
     mode: w.mode ?? 1,
     /** 归属行三件套（会随转发消息发到 QQ） */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaofan/dsh-qqbot",
-  "version": "1.10.4",
+  "version": "1.10.6",
   "description": "QQ Bot IM channel plugin for deepseek-harness (dsh)",
   "type": "module",
   "main": "./entry.js",
@@ -94,13 +94,15 @@
     "@deepseek-ai/dsh-client-ui-settings": "0.1.7-rc.1",
     "@deepseek-ai/dsh-client-ui-slots": "0.1.7-rc.1",
     "@deepseek-ai/schemastery": "3.18.4",
-    "@huggingface/transformers": "^4.3.0",
     "@tencent-connect/qqbot-connector": "1.2.0",
     "@tencent-connect/qqbot-nodejs": "^1.0.4",
     "js-yaml": "^4.1.0",
     "lamejs-fixed": "^1.2.2",
     "silk-wasm": "^3.7.1"
   },
+  "optionalDependencies": {
+    "@huggingface/transformers": "^4.3.0"
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1",
     "@deepseek-ai/dsh-agent": ">=0.1.0-rc.6",
@@ -112,19 +114,19 @@
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {
-      "optional": false
+      "optional": true
     },
     "@deepseek-ai/schemastery": {
-      "optional": false
+      "optional": true
     },
     "@deepseek-ai/dsh-agent": {
-      "optional": false
+      "optional": true
     },
     "@deepseek-ai/dsh-session": {
-      "optional": false
+      "optional": true
     },
     "@deepseek-ai/dsh-llm": {
-      "optional": false
+      "optional": true
     }
   },
   "devDependencies": {