@zaofan/dsh-qqbot 1.10.6 → 1.10.7

package/examples/ext-inbound/no-wake-on-child-quote.mjs

@@ -91,6 +91,27 @@ export function isChildSessionForwardQuote(quotedText) {
  */
 const ANNIHILATE_EMPTY_CHILD_FORWARD = false;
 
+/**
+ * ★★ 2026-10-15 主人定：**只要引用了子会话转发消息，整条消灭** ★★
+ *
+ * 为什么比上面那个开关更强：二档的语义是"主人**完全独立地**跟子会话对话" ——
+ * 子会话的内容**一个字都不该进父会话上下文**。而 QQ 的引用会把**被引原文**
+ * 一起带进上下文（`buildQuotePart` 会把它拼成引用块），等于**绕过二档**。
+ * 更要紧的是：QQ 引用**自带 @ 机器人**，所以这种消息还必然触发一次 @ 判定 ——
+ * 与其"剥掉原文/压掉 @"两头补，不如**整条吃掉**（主人原话：懒得删了）。
+ *
+ * ⚠️ 代价（有意接受）：主人在这条消息里**自己写的正文也一起消失** ——
+ *    想跟本尊说话就别引用子会话转发的消息，直接说即可。
+ * ⚠️ 对**所有人**生效（群友引用子会话转发也会被吃）；若只想管主人，
+ *    把 ownerOnly 改成 true（下面消灭分支里已留好位置）。
+ * ⚠️ 消灭 = 不进群历史、不进上下文、不占群冷却（`annihilate` 的语义）。
+ * ⚠️ 主人消息要被吃必须带 `ownerAck: true`（默认白名单保护主人消息，不给就拒绝执行）。
+ */
+const ANNIHILATE_ANY_CHILD_QUOTE = true;
+
+/** 上面那个开关是否只对主人（owner）生效。false = 群里任何人引用都吃 */
+const ANNIHILATE_ANY_CHILD_QUOTE_OWNER_ONLY = false;
+
 /**
  * true = 把正文开头的转发头 `【子会话 xxx】` **改写**掉（群历史里存的就是改后文本）。
  * ⚠️ 默认 **false**：转发头有时是用户自己想要的线索，先看清楚再开。
@@ -108,6 +129,71 @@ function contentWithoutMentions(ctx) {
     .replace(/\s+/g, '');
 }
 
+/**
+ * ★ 2026-10-15 新增：与 route-isolate 共用同一个会话库。
+ *
+ * 用途只有一个 —— **识别"这条消息带不带路由标记"**（`lib.parseRouteKey`）。
+ * 带路由标记的消息归 `route-isolate.mjs` 管（它负责"先消灭、再自己投递给子会话"），
+ * 本扩展必须**让路**；否则按文件名排序本文件跑在前面，抢先吃掉又 return，
+ * route-isolate 永远不会执行 ⇒ 消息既没进父上下文、也没路由到子会话。
+ *
+ * 引法与 route-isolate 完全一致（带 `?v=mtime` 做 cache-bust，防 ESM 注册表缓存旧模块）。
+ */
+let _lib = null;
+async function loadLib() {
+  if (_lib) return _lib;
+  try {
+    _lib = await import(new URL('../tools/lib/session_watch_lib.mjs?v=' + Date.now(), import.meta.url).href);
+  } catch {
+    _lib = null;
+  }
+  return _lib;
+}
+
+/**
+ * ★★ 2026-10-15：诊断必须**落盘** ★★
+ * route-isolate 文件头留的教训："一开始只往 logger 写，而**从来没人注入过 logger**
+ * ⇒ 真机上完全静默、无法定位。" 本扩展此前一直用 `ctx.logger.debug` ⇒ 等于瞎的，
+ * 导致"引用回流没投递"排查了三轮全靠猜。此后所有关键判定一律 `appendDiag` 落盘。
+ */
+const DIAG_FILE = 'D:/newwenjianjia/aiwork/鲸鱼娘/dshqqbot/.qqbot-extensions/data/no-wake-diag.log';
+
+async function appendDiag(line) {
+  try {
+    const { appendFile, mkdir } = await import('node:fs/promises');
+    const { dirname } = await import('node:path');
+    await mkdir(dirname(DIAG_FILE), { recursive: true });
+    await appendFile(DIAG_FILE, new Date().toISOString() + ' ' + line + '\n');
+  } catch { /* 诊断失败绝不影响主链 */ }
+}
+
+/**
+ * ★★ 2026-10-15：稳妥读"被引原文" ★★
+ * 契约（`ext-inbound-context.ts` 注释）写的是 `ctx.quoted({ text, fromSelf })`，
+ * 而 316 行又说它是"**可调用 + 带属性的对象**（两种读法都支持）"。
+ * 之前只按 `.text` 读 ⇒ 若它是函数就读到空串 ⇒ 正则永远不命中 ⇒ 整条分支静默跳过。
+ * 这里两种读法都试，并兜到 `ctx.state.quote.text`（晚挂点用的那个）。
+ */
+function readQuotedText(ctx) {
+  const out = { text: '', via: 'none', type: typeof ctx?.quoted };
+  try {
+    const q = ctx?.quoted;
+    if (typeof q === 'function') {
+      const v = q();
+      out.via = 'call';
+      out.text = String(v?.text ?? '');
+    }
+    if (!out.text) {
+      const t = q?.text ?? ctx?.state?.quote?.text ?? '';
+      if (t) out.via = out.via === 'call' ? 'call+prop' : 'prop';
+      out.text = String(t ?? '');
+    }
+  } catch (e) {
+    out.via = 'throw:' + (e?.message ?? e);
+  }
+  return out;
+}
+
 /**
  * ★ 早挂点 `onInbound`（2026-10-12 新增）★
  *
@@ -124,9 +210,83 @@ export async function onInbound(ctx, next) {
     // 这里读不到 ctx.state.mention —— 想看"平台认为这条 @ 了她吗"，用 ctx.platform.mentioned
     // （判据与 SDK 的 mentionGate 完全一致：rawEventType / mentions[].is_you / 正文里的 <@appId>）
     const mentioned = ctx?.platform?.mentioned === true;
-    const quoted = ctx?.quoted?.text ?? '';
+    // ★ 2026-10-15：改用 readQuotedText（两种读法都试），并把读到的东西**落盘**
+    const q = readQuotedText(ctx);
+    const quoted = q.text ?? '';
+    const hit = isChildSessionForwardQuote(quoted);
+    void appendDiag('[enter] text=' + JSON.stringify(String(ctx?.text ?? '').slice(0, 40))
+      + ' quotedType=' + q.type + ' via=' + q.via
+      + ' quoted=' + JSON.stringify(quoted.slice(0, 60))
+      + ' hit=' + hit + ' scope=' + String(ctx?.scope ?? '-'));
 
     if (ctx?.scope === 'group' && isChildSessionForwardQuote(quoted)) {
+      // ── ★ 2026-10-15 主人定：只要引用了子会话转发 ⇒ **整条消灭**（不再区分有没有正文）★ ──
+      //   理由：二档 = 主人完全独立地跟子会话对话，子会话内容一个字都不该进父上下文；
+      //   而 QQ 引用会把被引原文带进上下文（绕过二档），且引用自带 @ 机器人 ⇒ 干脆整条吃掉。
+      if (ANNIHILATE_ANY_CHILD_QUOTE) {
+        // ★★ 2026-10-15 重写（第三版）：语义 = 「引用子会话转发消息」等价于「发给那个子会话」★★
+        //   要做三件事，缺一不可 —— 照 route-isolate.mjs 的姿势抄：
+        //     ① 从**被引原文**里解析出子会话 key（`【子会话 bee798c0】`）；
+        //     ② `annihilate({ ownerAck: true })` 登记消灭；
+        //     ③ **自己投递**（lib.routeToSession）—— 消息被消灭后，原路径的
+        //        `user/message` 钩子永远不会发生，没人投递就等于消息凭空消失；
+        //     ④ 末尾 **`return next()`**（★不是"消灭完就 return"★）。
+        //       引擎兜底只在"没调 next"时替扩展放行；调了 next，annihilate 的置位
+        //       会**直接吃掉那记 next**（链停在这里 + 跳过兜底）⇒ 主人生效且真被消灭。
+        //       上一版写成"消灭后直接 return"，反而触发了兜底放行、还把投递漏了。
+        let routeKey = null;
+        try {
+          const lib0 = await loadLib();
+          routeKey = lib0?.parseRouteKey?.(String(ctx?.text ?? '')) ?? null;
+        } catch { routeKey = null; }
+
+        if (!routeKey) {
+          // 从被引原文解析子会话短 id（宽松：不要求右括号，平台可能按 60 字截断）
+          const m = /【子会话[\s\u3000]*([0-9a-fA-F]{1,32})/.exec(String(quoted));
+          const childKey = m ? m[1] : null;
+          const kernel = ctx?.kernel ?? null;
+          void appendDiag('[branch] routeKey=- childKey=' + (childKey || '-')
+            + ' kernel=' + typeof ctx?.kernel + ' annihilate=' + typeof ctx?.annihilate);
+
+          if (!childKey) {
+            void appendDiag('[skip] 引用的是子会话转发但解析不出 id ⇒ 放行');
+          } else {
+            const acked = ctx?.annihilate?.({
+              reason: '引用子会话转发消息：对父上下文消灭（二档语义），并投递给子会话 ' + childKey,
+              ownerAck: true,   // 主人消息默认受白名单保护，必须显式解除；只解除这一条
+            });
+            void appendDiag('[annihilate] key=' + childKey + ' acked=' + acked);
+
+            if (!acked) {
+              // 消灭被拒（熔断/挂点不允许）⇒ 不自己投，交回原路径，避免"我投一次 + 原路径再投一次"
+              void appendDiag('[skip] annihilate 被拒 key=' + childKey + ' ⇒ 放行');
+            } else {
+              // 已登记消灭 ⇒ 必须自己投递（原路径的 user/message 钩子不会跑了）
+              let r = null;
+              try {
+                const lib = await loadLib();
+                // ★★ 2026-10-15 关键：**必须把 key 补进文本** ★★
+                //   `routeToSession` 内部自己 `parseRouteKey(text)`；引用这条路**没有** `[s:xxx]`
+                //   标记 ⇒ 会直接返回 `no-key` 而不投递（实测 diag：投递=FAIL(no-key)）。
+                //   补上标记后它就能解析到目标；随后 `stripRouteMark(text)` 会把标记剥掉，
+                //   所以**子会话收到的正文里不会留下这个前缀**。
+                const textToRoute = '[s:' + childKey + ']' + String(ctx.text ?? '');
+                r = await lib?.routeToSession?.(kernel, textToRoute, { message: ctx?.message });
+              } catch (e) {
+                r = { ok: false, reason: 'throw:' + (e?.message ?? e) };
+              }
+              void appendDiag('[done] key=' + childKey
+                + ' 已从父上下文消灭；投递=' + (r?.ok ? 'ok(' + r.reason + ')' : 'FAIL(' + r?.reason + ')'));
+            }
+          }
+        } else {
+          // 带路由标记 ⇒ 让路给 route-isolate（它负责消灭 + 投递），本扩展什么都不做
+          void appendDiag('[pass] 带路由标记 key=' + routeKey + ' → 让路给 route-isolate');
+        }
+        // ★★ 末尾必须调 next()：见上面 ④。annihilate 成功时它会吃掉这记 next。★★
+        return next();
+      }
+
       // 只读观测（debug 级，别刷屏）：这一步群历史**还没记** —— 对照晚挂点那条日志的时间序
       ctx?.logger?.debug?.(
         `[ext-inbound:${name}] 早挂点：引用的是子会话转发（平台@=${mentioned}，正文"${String(ctx.text).slice(0, 20)}"）` +
@@ -144,8 +304,10 @@ export async function onInbound(ctx, next) {
       // ── 可选动作 ②：消灭（纯转发空壳：没正文、没附件，只剩一个 @）──
       const atts = Array.isArray(ctx?.message?.attachments) ? ctx.message.attachments : [];
       if (ANNIHILATE_EMPTY_CHILD_FORWARD && atts.length === 0 && contentWithoutMentions(ctx) === '') {
-        ctx.annihilate({ reason: '子会话转发空壳（无正文无附件）' });
-        return;   // ★ 不调 next() = 这条不进历史、不进上下文、不占冷却
+        // ⚠️ 2026-10-15：消灭后必须**继续交给 next()**（不是直接 return）——
+        //    引擎兜底只在"没调 next"时替扩展放行；调了 next，annihilate 会吃掉它。
+        ctx.annihilate({ reason: '子会话转发空壳（无正文无附件）', ownerAck: true });
+        return next();
       }
 
       // ── 可选动作 ③：强制入站（确定要她看到这条时）──

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

@@ -662,23 +662,132 @@ export function buildSettlementNotice(input = {}) {
 async function forwardToQq(entry, text) {
   const fwd = entry?.fwd;
   const body = String(text ?? '').trim();
-  if (!fwd?.sender || !fwd?.replyTarget || !body) return '';
+  // ★ 2026-10-15：**不再静默**。之前三个条件任一不满足就 `return ''`，日志里一个字都没有，
+  //   "重启后那段时间子会话内容悄悄没转发"因此无从定位（主人实测踩到）。
+  if (!fwd?.sender || !fwd?.replyTarget || !body) {
+    void swDiag('forward-skip short=' + String(entry?.shortId ?? '?')
+      + ' fwd=' + (fwd ? 'obj' : String(fwd))
+      + ' sender=' + !!fwd?.sender + ' replyTarget=' + !!fwd?.replyTarget
+      + ' bodyLen=' + body.length);
+    return '';
+  }
   const target = fwd.replyTarget;
-  try {
-    if (typeof fwd.sender.sendMarkdown === 'function') {
-      await fwd.sender.sendMarkdown(target, body);
-      return 'md';
+
+  /**
+   * ★★ 2026-10-15：**摘掉 msgId 的"主动版" target** ★★
+   *   实测真凶：`fwd.replyTarget` 里钉着**绑定那一刻的 msgId**（为走"被动回复"），
+   *   而 QQ 的被动回复 **msg_id 会过期** ⇒ 老盯梢（如 bee798c0）发送时报
+   *   `API Error: 回复消息msg_id已过期`，markdown/纯文本两条降级链**都**因此失败，
+   *   内容静默丢失。新建的盯梢 msgId 新鲜 ⇒ 正常。
+   *   ⇒ 发送失败时摘掉 msgId 再发一次 = 转"主动发送"（会耗主动配额，但总比丢消息好）。
+   */
+  const activeTarget = (() => {
+    try {
+      if (!target || typeof target !== 'object') return null;
+      const t = { ...target };
+      let touched = false;
+      for (const k of ['msgId', 'msg_id', 'messageId', 'referenceMessageId']) {
+        if (k in t) { delete t[k]; touched = true; }
+      }
+      return touched ? t : null;
+    } catch { return null; }
+  })();
+
+  /**
+   * ★ 2026-10-15 主人定：**同一 msgId 用满 4 条就直接转主动**（不等它失败）。
+   *   被动回复有两条硬限制：①同一 msg_id 最多 ~4-5 条；②msg_id 会过期。
+   *   插件的 outbound.ts 对"AI 正文"有 ADAPTIVE_MAX_PASSIVE=5 的同类计数，但**转发这条路没有**，
+   *   所以这里自己数：同一 msgId 发到第 4 条起就摘掉它走主动。
+   */
+  const _midOf = (t) => String(t?.msgId ?? t?.msg_id ?? t?.messageId ?? '');
+  const passiveMid = _midOf(target);
+  const counts = (entry.__fwdPassiveCounts ??= new Map());
+  const used = passiveMid ? (counts.get(passiveMid) ?? 0) : 0;
+  const PASSIVE_LIMIT = 4;
+  const skipPassive = !passiveMid || used >= PASSIVE_LIMIT;
+  if (skipPassive) {
+    void swDiag('forward-passive-skip short=' + String(entry?.shortId ?? '?')
+      + ' mid=' + (passiveMid ? passiveMid.slice(0, 12) : '-') + ' used=' + used);
+  }
+
+  const trySend = async (tg) => {
+    try {
+      if (typeof fwd.sender.sendMarkdown === 'function') {
+        await fwd.sender.sendMarkdown(tg, body);
+        return 'md';
+      }
+    } catch (e) {
+      const em = String(e?.message ?? e);
+      try {
+        if (typeof fwd.sender.sendText === 'function') {
+          await fwd.sender.sendText(tg, body);
+          return 'text';
+        }
+      } catch (e2) { throw new Error(em + ' | text:' + String(e2?.message ?? e2)); }
+      throw new Error(em);
     }
-  } catch { /* markdown 失败 → 退纯文本 */ }
+    try {
+      if (typeof fwd.sender.sendText === 'function') {
+        await fwd.sender.sendText(tg, body);
+        return 'text';
+      }
+    } catch (e) { throw new Error(String(e?.message ?? e)); }
+    return '';
+  };
+
+  // ① 先按原样（被动回复，省主动配额）
   try {
-    if (typeof fwd.sender.sendText === 'function') {
-      await fwd.sender.sendText(target, body);
-      return 'text';
+    // ★ 同一 msgId 用满 4 条 ⇒ 直接跳过被动、走下面的主动分支（不再等它失败）
+    if (skipPassive) throw new Error('skip-passive: mid=' + (passiveMid || '-') + ' used=' + used);
+    const how = await trySend(target);
+    if (how) {
+      if (passiveMid) counts.set(passiveMid, used + 1);
+      void swDiag('forward-ok(' + how + ') short=' + String(entry?.shortId ?? '?') + ' len=' + body.length
+        + ' passive=' + (passiveMid ? passiveMid.slice(0, 12) + '#' + (used + 1) : '-'));
+      return how;
     }
-  } catch { /* ignore */ }
+  } catch (e1) {
+    void swDiag('forward-passive-fail short=' + String(entry?.shortId ?? '?')
+      + ' err=' + String(e1?.message ?? e1));
+    // ② 失败 ⇒ 摘掉 msgId 重发（主动）。这是"msg_id 过期"的正解。
+    if (activeTarget) {
+      try {
+        const how2 = await trySend(activeTarget);
+        if (how2) {
+          void swDiag('forward-ok-active(' + how2 + ') short=' + String(entry?.shortId ?? '?')
+            + ' len=' + body.length + '（被动失败后转主动）');
+          return how2 + '-active';
+        }
+      } catch (e2) {
+        void swDiag('forward-active-fail short=' + String(entry?.shortId ?? '?')
+          + ' err=' + String(e2?.message ?? e2));
+      }
+    } else {
+      void swDiag('forward-active-skip short=' + String(entry?.shortId ?? '?')
+        + '（target 上没有 msgId 可摘，或 target 形状异常）');
+    }
+  }
+  void swDiag('forward-fail short=' + String(entry?.shortId ?? '?') + ' senderKeys='
+    + (fwd?.sender ? Object.keys(fwd.sender).slice(0, 10).join(',') : '-'));
   return '';
 }
 
+/**
+ * ★ 2026-10-15：诊断**落盘**。route-isolate 文件头留过教训：
+ *   "一开始只往 logger 写，而**从来没人注入过 logger** ⇒ 真机上完全静默、无法定位。"
+ *   本库涉及"转发到 QQ"，静默一次就是一条内容永久丢失，必须能事后追。
+ */
+const SW_DIAG_FILE = 'D:/newwenjianjia/aiwork/鲸鱼娘/dshqqbot/.qqbot-extensions/data/session-watch-diag.log';
+
+async function swDiag(line) {
+  try {
+    const { appendFile, mkdir } = await import('node:fs/promises');
+    const { dirname } = await import('node:path');
+    await mkdir(dirname(SW_DIAG_FILE), { recursive: true });
+    await appendFile(SW_DIAG_FILE, new Date().toISOString() + ' ' + line + '\n');
+  } catch { /* 诊断失败不影响主链 */ }
+}
+
 /**
  * 转发到 QQ 之前，把「只给插件自己看的标记」洗掉（主人 2026-10-12 要求："剥掉 @"）。
  *
@@ -975,11 +1084,40 @@ async function handler(root, session, event) {
     w.errors = [];
     const mode = Number(w.mode) === 2 ? 2 : (Number(w.mode) === 3 ? 3 : 1);
 
+    // ★★ 2026-10-15：**每回合无条件落盘一行** ★★
+    //   实测踩到：bee798c0 重启后"不转发"，而日志里连 forward-skip 都没有 ⇒ 说明它压根没
+    //   走到 forwardToQq（`toForward` 为空、for 循环没进）。要区分"没收到正文事件"和"收到但被过滤"，
+    //   只能在 turn/end 这里把手上有什么如实记下来。
+    void swDiag('turn-end short=' + String(w.shortId ?? '?')
+      + ' mode=' + mode + ' rawMode=' + JSON.stringify(w.mode)
+      + ' texts=' + allTexts.length + ' errs=' + errors.length
+      + ' textLen=' + String(text ?? '').length
+      + ' seen=' + w.seen + ' reason=' + String(rawReason ?? '-'));
+
     // ── 转发到 QQ ──────────────────────────────────────────────
     // 一档：只转末段；二/三档：所有正文 + 报错
     const toForward = mode === 1
       ? (text ? [text] : [])
       : [...allTexts, ...(errors.length ? ['⚠️ 报错：\n' + errors.join('\n')] : [])];
+    // ★★ 2026-10-15 主人定：转发前**先刷新 target + 数被动条数**，别钉死绑定时的 msgId ★★
+    //   被动回复（带 msg_id）有两条硬限制：①同一 msg_id 最多回 ~4-5 条；②msg_id 会过期。
+    //   踩到的实例：老盯梢 bee798c0 的 replyTarget 里钉着很久以前的 msgId ⇒ 发送报
+    //   `回复消息msg_id已过期`，md/文本两条链全挂、内容静默丢失。
+    //   口径（与插件 outbound.ts 的 ADAPTIVE_MAX_PASSIVE=5 对齐）：
+    //     · 每次转发前，把 fwd.replyTarget 刷新成**最新注入**的那份（带最新 msgId）；
+    //     · 同一 msgId 数着用，**到 4 条**就主动转主动（摘掉 msgId），不再等它失败；
+    //     · 真失败（过期/超限/其它）⇒ forwardToQq 里还有一层"摘 msgId 重发"兜底。
+    if (toForward.length > 0) {
+      const injected = globalThis[FWD_KEY] ?? null;
+      if (injected?.sender && injected?.replyTarget) {
+        w.fwd = { sender: injected.sender, replyTarget: injected.replyTarget };
+      } else if (!w.fwd?.sender || !w.fwd?.replyTarget) {
+        const hadFwd = !!w.fwd;
+        const ok = hydrateFwd(w, root, session);
+        void swDiag('pre-forward hydrate short=' + String(w.shortId ?? '?')
+          + ' hadFwd=' + hadFwd + ' ok=' + ok + ' mode=' + mode);
+      }
+    }
     for (const piece of toForward) {
       const body = withOwner(w, piece);
       // 去重：同一条内容不重复转发

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaofan/dsh-qqbot",
-  "version": "1.10.6",
+  "version": "1.10.7",
   "description": "QQ Bot IM channel plugin for deepseek-harness (dsh)",
   "type": "module",
   "main": "./entry.js",