cortico-world-mosey 2.1.0 → 2.1.2

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # 更新日志
 
+## 2.1.2
+
+**修「私信发进了群聊」——会话没切过去也照发。**
+
+- 发私信前先核实页面真的停在目标会话上；核实不通过就不发，回执写「没发」，不再把话打进当前开着的那个会话。
+- 核实方式按页面能力来：**标题读得出来就比标题，读不出来就比「会话内容有没有换」**（实测有些账号的抖音聊天页根本读不到标题，只靠标题会误判）。
+- 「现在停在哪个人」的缓存（`chatThread`）改成**核实通过之后**才写，核实失败立刻清空。以前是点完就记：只要那一下点空了，后面每一条都会跳过点击、全打进同一个错误的会话——11-08 那三条私信进群就是这么来的。
+- 主人私信优先走**监听器专门停在主人会话上的那一页**（不和群聊页共用），那一页不要求标题可读，避免每条私信都被逼去「打开主页点私信」的慢路。
+- 陌生人预热（prewarm）同样只在核实后才写缓存。
+- 顺手修了子组件拿不到 logger 的问题（宿主不传 logger 时，抖音/B站的日志会整片丢失），排查时不再抓瞎。
+
+> 当时的触发条件：正在被 `-509` 限流，「操作频繁」的 toast 浮在会话列表上，点击被吞掉，但代码认为点成功了。
+
+## 2.1.1
+
+**修「最近做过什么」被风控记录刷屏，顺带修掉一个连带问题：她可能一直被按着出不了门。**
+
+### 风控记录不再占满列表
+
+- 只读请求撞 `-509` 不再写进「最近做过什么」，也不再加 `strikes`、不续期限流退避。B站私信轮询每 3 秒打一次 inbox，以前每次被限流都记一条——实测 300 条记录里 **267 条**是「风控停手」，点赞评论反而被挤没了。
+- 限流期间，B站私信轮询从 3 秒降到 60 秒一次，不用每 3 秒去撞一次墙。
+- 「最近做过什么」加了 **动作 / 风控 / 全部** 三个筛选，默认落在「动作」；面板首页的「最近」也不再显示风控条目。
+- 老数据自动清理：历史风控记录只保留最近 20 条，把位置还给真实动作；顺手把被只读请求刷高的 `strikes` 归零（以前累计到 800 多，切严格模式会直接触发 6 小时冷却）。
+
+### 为什么这算 bug
+
+只读请求把 30 分钟的限流退避一直续期，`until` 永远在将来——面板一直显示「限流歇 N 分钟」，她自己也一直不出门。现在只有**写动作真的被挡**才会退避。
+
 ## 2.1.0
 
 **出门方式自己选：按次数 / 按额度。** 以前「每天出门几次」和「每日额度」两道闸同时生效，谁先撞上谁停——次数 8/8 之后必做还没做完，就只能干等到第二天。现在二选一，只留一道闸门。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortico-world-mosey",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "type": "module",
   "description": "摸鱼（Mosey）：让 Coopanion 的桌宠自己去抖音和 B站逛一圈。评论和私信都能收能回；能一起看视频（B站带字幕弹幕，抖音可自动连刷）；关注流、周报、本地书库；按额度点赞、评论、关注、发动态。默认人审，三把工具、少 token。\n\nQQ 交流群：745879632",
   "license": "MIT",

package/src/bilibili.js

@@ -364,7 +364,7 @@ export class Bilibili {
     }
 
     if ([412, 429].includes(res.status)) {
-      this.policy.noteRisk(String(res.status), 'B站要求冷却');
+      this.policy.noteRisk(String(res.status), 'B站要求冷却', { source: opts.post ? 'write' : 'read' });
       throw new BiliError('RISK', 'B站要求冷却，已自动停手。');
     }
     if (!res.ok) {
@@ -380,7 +380,7 @@ export class Bilibili {
 
     if (data.code !== 0) {
       if ([-412, -352, -509, -799].includes(data.code)) {
-        this.policy.noteRisk(String(data.code), data.message || 'B站风控');
+        this.policy.noteRisk(String(data.code), data.message || 'B站风控', { source: opts.post ? 'write' : 'read' });
         throw new BiliError('RISK', 'B站风控拦截，已停手。');
       }
       if (data.code === -101) {

package/src/douyin.js

@@ -843,20 +843,24 @@ export class DouyinBrowser {
   }
 
   /** 把一次风险命中翻译成人话，顺手记一笔；限流时进入两分钟冷却，别让她连着重试。 */
-  riskError(f, where = '操作') {
+  /**
+   * source='read'：只是读页面时看到风控提示（导航、翻页）——不记动作、不续期退避。
+   * source='write'：点发送/点赞之后被挡，这种才算「她真的被拦住了」。
+   */
+  riskError(f, where = '操作', { source = 'write' } = {}) {
     const why = String(f?.hit || '页面提示').slice(0, 60);
     if (f?.kind === 'rate') {
-      this.rateUntil = Date.now() + 2 * 60 * 1000;
-      this.policy.noteRisk('DOUYIN_RATE', `${where}后限流（${why}）`);
+      if (source !== 'read') this.rateUntil = Date.now() + 2 * 60 * 1000;
+      this.policy.noteRisk('DOUYIN_RATE', `${where}后限流（${why}）`, { source });
       return new DouyinError('RISK', `抖音限流了（${why}），等两分钟再发，别连着重试。`);
     }
-    this.policy.noteRisk('DOUYIN_VERIFY', `${where}后要验证（${why}）`);
+    this.policy.noteRisk('DOUYIN_VERIFY', `${where}后要验证（${why}）`, { source });
     return new DouyinError('RISK', `抖音要验证（${why}），得主人在手机上过一下验证码。`);
   }
 
   async checkRisk(page) {
     const f = await bodyFlags(page);
-    if (f.risk) throw this.riskError(f, '刷抖音');
+    if (f.risk) throw this.riskError(f, '刷抖音', { source: 'read' });
   }
 
   async goto(page, url, waitMs = 4200) {
@@ -1032,7 +1036,13 @@ export class DouyinBrowser {
           opened = !!ok;
           // 没有「陌生人消息」文件夹的账号，人就排在主列表里
           if (!ok) ok = await this.clickThread(page, want).catch(() => false);
-          if (ok) this.chatThread = want;
+          if (ok) {
+            // 点完核一次标题：点空了就别把 chatThread 记成这个人，
+            // 否则下一次回复会跳过点击、直接打进当前开着的会话（11-08 私信进群就是这么来的）
+            await page.waitForTimeout(120);
+            const after = await this.currentChatTitle(page).catch(() => '');
+            if (after && this.threadTitleMatches(after, want)) this.chatThread = want;
+          }
           return !!ok;
         } finally {
           // 文件夹是浮层：收起来，别挡着后面打字
@@ -6073,7 +6083,7 @@ export class DouyinBrowser {
    * 在聊天页发一条。mention 是「要真的 @ 到的昵称」（群里才有意义）：
    * 传了就会先从候选面板插一个真 chip，再写正文。
    */
-  async replyDm(name, text, { mention = '', strict = false } = {}) {
+  async replyDm(name, text, { mention = '', strict = false, requireTitle = false } = {}) {
     const who = String(name ?? '').trim();
     if (!who) throw new DouyinError('BAD_TARGET', '没有会话昵称，回不了');
     // 各段耗时带上：主人在追「一秒内」，得知道慢在哪一段（挂在回执里，不额外打日志）
@@ -6081,12 +6091,19 @@ export class DouyinBrowser {
     // 私信页正停在这个会话上：不用跳转、不用点会话，直接打字回车。
     // 这是「秒回」的关键一段——省掉整页导航（6-8 秒）和点会话后的固定停顿（2.4 秒）。
     const dm = this.dmPage;
+    // 诊断用：只在失败/走兜底时打一行，正常发送零开销
+    const diag = { who, dmThread: this.dmThread, chatThread: this.chatThread, steps: [] };
     if (dm && !dm.isClosed() && this.dmThread === who) {
       // 先确认页面真的停在主人这个会话上。点不回来就别硬发——宁可走慢路径重开，
       // 也不能把私信打进别人的会话里（GLM 审出来的 #1）。
+      // dmPage 是监听器专门停在主人会话上的那一页（群里用的是 groupPages，不共用），
+      // 所以这里不再要求「标题可读」——这套页面读不到标题，强求只会把每条私信都逼到慢兜底。
       const onThread = await this.ensureThreadOpen(dm, who, { strict }).catch(() => false);
       if (!onThread) {
         this.dmThread = '';
+        diag.steps.push('dmPage:verify-fail');
+        diag.dmTitle = await this.currentChatTitle(dm).catch(() => '');
+        diag.dmUrl = String(dm.url?.() ?? '');
       } else {
         const t1 = Date.now();
         const input = await this.waitMsgInput(dm, 3000).catch(() => null);
@@ -6150,29 +6167,74 @@ export class DouyinBrowser {
       try {
         // 已经在这个会话里就直接用：省一次整页跳转和点击，回私信快好几秒
         // 用 chatThread 而不是 openThread：后者被 dmPage 的读取共用，会误判
-        if (this.chatThread !== who || !/\/chat/.test(page.url())) {
+        const needSwitch = this.chatThread !== who || !/\/chat/.test(page.url());
+        // 点之前先记一份内容指纹：这套页面读不出标题，靠「内容有没有换」判断切没切过去
+        let before = null;
+        if (needSwitch) {
           if (!/\/chat/.test(page.url())) await this.gotoChat(page);
+          before = await this.threadFingerprint(page);
           let ok = await this.clickThread(page, who);
+          diag.steps.push(`click:${ok ? 'ok' : 'miss'}`);
           if (!ok) {
             // 主列表里没有：抖音会把非好友的私信收进「陌生人消息」文件夹
             ok = await this.clickStrangerThread(page, who);
+            diag.steps.push(`stranger:${ok ? 'ok' : 'miss'}`);
           }
           if (!ok) {
+            diag.chatUrl = String(page.url?.() ?? '');
+            diag.chatTitle = await this.currentChatTitle(page).catch(() => '');
+            this.log?.info?.('stroll dm diag', { ...diag, fail: 'NO_DM' });
             throw new DouyinError('NO_DM', '聊天列表和「陌生人消息」里都找不到这个会话，可能被新消息刷下去了');
           }
-          this.openThread = who;
-          this.chatThread = who;
           // 点完不用干等两秒：下面 waitMsgInput 会一轮一轮等到输入框真的能打字
           await page.waitForTimeout(200);
         }
-        // 慢路径也核一次标题：openThread 只是我们记的，页面可能没真的切过去
-        if (!(await this.ensureThreadOpen(page, who, { strict }).catch(() => false))) {
-          const driftTitle = await this.currentChatTitle(page).catch(() => '');
-          this.log?.warn?.('stroll thread drift', { who, title: driftTitle, url: String(page.url?.() ?? '') });
-          throw new DouyinError('THREAD_DRIFT', `页面没切到「${who}」这个会话，没发`);
+        /**
+         * 先核实、再认账。
+         * 以前点完就把 chatThread 记成 who：只要那一下点空了（限流 toast 盖住列表时很常见），
+         * 后面每一条都会跳过点击、直接打进当前开着的会话——2026-11-08 那三条私信进群就是这么来的。
+         */
+        const readTitle = async () => await this.currentChatTitle(page).catch(() => '');
+        /**
+         * 核实「页面真的切过去了」：
+         *   标题读得出来 → 按标题比；
+         *   标题读不出来（这套页面就是这样）→ 看会话内容有没有换过。
+         * 都不通过就不发——比把私信打进群聊强。
+         */
+        const verifyThread = async () => {
+          const t = await readTitle();
+          if (t) return this.threadTitleMatches(t, who);
+          return needSwitch ? await this.waitThreadChanged(page, before) : true;
+        };
+        if (!(await verifyThread())) {
+          // 可能是点空了（限流 toast 盖住列表时很常见）：再点一次再核
+          diag.steps.push('retry-click');
+          await this.clickThread(page, who).catch(() => {});
+          await page.waitForTimeout(300);
+          if (!(await verifyThread())) {
+            // 没核实通过就把缓存清掉，别让下一条继续错下去
+            if (this.chatThread === who) this.chatThread = '';
+            if (this.openThread === who) this.openThread = '';
+            const driftTitle = await readTitle();
+            this.log?.info?.('stroll thread drift', {
+              who,
+              title: driftTitle,
+              url: String(page.url?.() ?? ''),
+              needSwitch,
+              steps: diag.steps,
+            });
+            throw new DouyinError('THREAD_DRIFT', `页面没切到「${who}」这个会话（标题：${driftTitle || '空'}），没发`);
+          }
         }
+        this.openThread = who;
+        this.chatThread = who;
         const input = await this.waitMsgInput(page, 6000);
-        if (!input) throw new DouyinError('NO_INPUT', '没找到输入框，抖音可能改版了');
+        if (!input) {
+          diag.chatUrl = String(page.url?.() ?? '');
+          diag.chatTitle = await this.currentChatTitle(page).catch(() => '');
+          this.log?.info?.('stroll dm diag', { ...diag, fail: 'NO_INPUT' });
+          throw new DouyinError('NO_INPUT', '没找到输入框，抖音可能改版了');
+        }
         await this.sendInChat(page, input, text, { mention });
         this.lastAction = `dm ${who}`;
         return { ok: true, sent: true, mentioned: mention ? !!this.lastMention : null, mentionDebug: this.lastMention ? '' : this.lastMentionDump || '' };
@@ -6360,6 +6422,38 @@ export class DouyinBrowser {
       .catch(() => '');
   }
 
+  /**
+   * 会话内容指纹：切换会话之后这里会变。
+   * 这套页面读不到标题（实测 `currentChatTitle` 一直返回空），所以「有没有真的切过去」
+   * 只能靠内容变没变来判断——这也是 2.1.2 把主人私信逼进 20 秒慢路的原因。
+   */
+  async threadFingerprint(page) {
+    return await page
+      .evaluate(() => {
+        const nodes = Array.from(document.querySelectorAll('[data-e2e="msg-item-content"]'));
+        const txt = (n) => String(n?.innerText ?? '').replace(/\s+/g, ' ').trim().slice(0, 40);
+        return {
+          n: nodes.length,
+          first: nodes.length ? txt(nodes[0]) : '',
+          last: nodes.length ? txt(nodes[nodes.length - 1]) : '',
+        };
+      })
+      .catch(() => null);
+  }
+
+  /** 等内容真的换掉（切会话的动画/请求要一点时间）。读不到指纹时放行，别误伤。 */
+  async waitThreadChanged(page, before, timeout = 1800) {
+    if (!before) return true;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      const now = await this.threadFingerprint(page);
+      if (!now) return true;
+      if (now.n !== before.n || now.last !== before.last || now.first !== before.first) return true;
+      await page.waitForTimeout(120);
+    }
+    return false;
+  }
+
   /** 会话标题比对：忽略空白、大小写和同名群的「#2」后缀；认不出标题时算匹配（别误伤）。 */
   threadTitleMatches(title, who) {
     const norm = (s) =>
@@ -6385,7 +6479,7 @@ export class DouyinBrowser {
    * 群页是常驻的，抖音可能自己切到别的会话（新群、刷新、消息跳转）；
    * 不确认就往当前输入框里打字，话会落到另一个群里——看起来「发了」，群里却没有。
    */
-  async ensureThreadOpen(page, who, { strict = false } = {}) {
+  async ensureThreadOpen(page, who, { strict = false, requireTitle = false } = {}) {
     let title = await this.currentChatTitle(page).catch(() => '');
     if (!title) {
       // 刚切换会话时标题可能还没重绘：再给一次机会
@@ -6398,9 +6492,17 @@ export class DouyinBrowser {
      * strict 是给陌生人用的：宁可报没发，也不能把话打进别人的会话里。
      */
     if (!title) {
-      // 读不出标题时放行：点会话那一步已经核过（点不到会直接抛 NO_DM），
-      // 这里再拦就变成「永远发不出去」。日志留一条，方便后面修标题选择器。
       this.lastTitleMiss = { at: Date.now(), who, url: String(page.url?.() ?? '') };
+      /**
+       * requireTitle：连标题都读不出来，就没法确认页面停在哪。
+       * 主人私信走这条——宁可回执写「没发」，也不能像 11-08 那样把私信打进群聊。
+       * 其它调用照旧放行：点会话那一步已经核过（点不到会直接抛 NO_DM），
+       * 这里再拦就变成「永远发不出去」。
+       */
+      if (requireTitle) {
+        this.log?.info?.('stroll chat title miss', { who, url: String(page.url?.() ?? '') });
+        return false;
+      }
       return true;
     }
     if (this.threadTitleMatches(title, who)) return true;

package/src/policy.js

@@ -255,11 +255,27 @@ export class Policy {
    * 停掉全部动作只会把主人当场点的事一起埋了——之前评论发不出去、要等一两个小时就是这么来的。
    * 真被验证码/封号挡住时平台自己会报错，她会如实告诉主人。
    * light：只有验证码/封禁这种「再试也没用」的才停 30 分钟。strict：旧的 48h/24h 分档。
+   *
+   * source：
+   *   'write' 写动作被挡（默认）——要退避、要记一笔，面板上能看到；
+   *   'read'  只读请求被限流——**不续期退避、不记 action、不加 strikes**。
+   *           以前读接口（B站私信每 3 秒一次的 inbox）撞 -509 也照记，结果 300 条记录里 267 条是风控，
+   *           退避还被这些只读请求一直续命，她自己反倒永远出不了门。
    */
-  noteRisk(code, message) {
+  noteRisk(code, message, { source = 'write' } = {}) {
     const text = `${code ?? ''} ${message ?? ''}`.toLowerCase();
     const verify = /验证|captcha|verify|异常|封禁|ban|-352|-799/.test(text);
     const rate = /429|-509|请求过于频繁|操作频繁|访问过于频繁|rate/.test(text);
+
+    // 只读请求的限流：只累一个计数（给面板/日志看趋势），不写记录、不动退避。
+    // 但如果同时是验证码/封号（verify），还是照常往下走——那种必须让主人知道。
+    if (rate && !verify && source === 'read') {
+      const prev = this.store.data.rateRead ?? {};
+      this.store.data.rateRead = { n: Number(prev.n ?? 0) + 1, at: Date.now(), reason: String(message ?? code ?? '').slice(0, 120) };
+      // 不 save：这个数秒级会变，跟着下一次正常写盘落盘就行
+      return { until: 0, hours: 0, reason: '', guard: this.guard(), soft: this.rateWait(), read: true };
+    }
+
     const guard = this.guard();
     const before = Number(this.store.data.risk.strikes ?? 0);
     const strikes = rate ? before + 1 : before;

package/src/store.js

@@ -20,6 +20,8 @@ function blank() {
     risk: { until: 0, reason: '', strikes: 0, lastCode: '' },
     /** 限流退避（-509/429）：只拦她自己出门，不拦主人点的事。 */
     softBackoff: { until: 0, at: 0, n: 0, reason: '' },
+    /** 只读请求被限流的次数（不算动作、不加 strikes，只用来看看平台压力）。 */
+    rateRead: { n: 0, at: 0, reason: '' },
     lastWriteAt: 0,
     /** 每个平台各自的上次公开动作时间：抖音限流不该连带卡住 B站。 */
     lastWriteByPlat: {},
@@ -53,6 +55,7 @@ export class Store {
       this.data = { ...blank(), ...parsed };
       this.data.risk = { ...blank().risk, ...(parsed.risk ?? {}) };
       this.data.softBackoff = { ...blank().softBackoff, ...(parsed.softBackoff ?? {}) };
+      this.data.rateRead = { ...blank().rateRead, ...(parsed.rateRead ?? {}) };
       this.data.stats = { ...blank().stats, ...(parsed.stats ?? {}) };
       for (const d of this.data.drafts) {
         if (d.status === 'sending') {

package/src/world.js

@@ -160,9 +160,14 @@ export class StrollWorld {
     this.store = new Store(path.join(dataDir, 'stroll'), this.timeZone).load();
     this.store.data.autoSessions ??= {};
     this.policy = new Policy({ store: this.store, cfg, timeZone: this.timeZone });
-    this.bili = new Bilibili({ dataDir, cfg, log, policy: this.policy, store: this.store });
-    this.stickers = new StickerBook({ dataDir, log });
-    this.douyin = new DouyinBrowser({ dataDir, cfg, log, policy: this.policy, stickers: this.stickers });
+    /**
+     * 注意这里必须传 `this.log`，不能传构造参数 `log`：
+     * 宿主没给 logger 时 `log` 是 undefined，子组件拿到的就是 undefined，
+     * 它们所有 `this.log?.info?.()` 全是空操作——抖音那边的日志会整片消失（2026-11-08 排查踩过）。
+     */
+    this.bili = new Bilibili({ dataDir, cfg, log: this.log, policy: this.policy, store: this.store });
+    this.stickers = new StickerBook({ dataDir, log: this.log });
+    this.douyin = new DouyinBrowser({ dataDir, cfg, log: this.log, policy: this.policy, stickers: this.stickers });
     // 扫码成功后顺手记下「现在登的是哪个抖音号」，面板要显示，也要防「给自己发私信」
     this.douyin.onSelf = (self) => this.noteDouyinSelf(self);
     this.timer = null;
@@ -372,6 +377,33 @@ export class StrollWorld {
     this.log?.info?.('stroll migrate stranger pending', { before: list.length, after: next.length });
   }
 
+  /**
+   * 一次性清理：2.1.0 之前每次只读请求撞 -509 都会记一条 action，
+   * 实测 300 条上限里 267 条是「风控停手」，真实动作反而被挤掉。
+   * 这里只保留最近 20 条风控记录（够看趋势），把位置还给点赞/评论。
+   */
+  pruneRiskActions() {
+    const done = this.store.data.migrated ?? {};
+    if (done.riskPrune) return;
+    const list = this.store.data.actions ?? [];
+    const kept = list.map((a, i) => (a?.action === 'risk' ? i : -1)).filter((i) => i >= 0);
+    const keepFrom = kept.length > 20 ? kept[kept.length - 20] : -1;
+    if (kept.length > 20) {
+      this.store.data.actions = list.filter((a, i) => a?.action !== 'risk' || i >= keepFrom);
+    }
+    // 顺手把被只读请求刷高的 strikes 归零：以前累计到 800 多，切严格模式会直接触发 6 小时冷却
+    const strikes = Number(this.store.data.risk?.strikes ?? 0);
+    if (strikes > 20) {
+      this.store.data.risk = { ...(this.store.data.risk ?? {}), strikes: 0 };
+      this.log?.info?.('stroll reset inflated strikes', { before: strikes });
+    }
+    this.store.data.migrated = { ...done, riskPrune: true };
+    this.store.save();
+    if (kept.length > 20) {
+      this.log?.info?.('stroll prune risk actions', { before: list.length, after: this.store.data.actions.length });
+    }
+  }
+
   /**
    * 一次性迁移：2.0 以前用「每天自己出门 = 0」表示不出去。
    * 2.1 起这件事交给「出门方式」，这里把老配置翻译过去，之后主人改的就不动了：
@@ -402,6 +434,7 @@ export class StrollWorld {
     this.migrateStrangerKeys();
     this.migrateStrangerSeenEcho();
     this.migrateOutingMode();
+    this.pruneRiskActions();
     this.refundDmLoopQuota();
     const done = this.store.data.migrated ?? {};
     if (done.dmQuota) return;
@@ -657,6 +690,8 @@ export class StrollWorld {
     this.stopDmWatch();
     if (!this.running) return;
     this.dmLastAt = 0;
+    /** B站私信上一次真的去拉的时间：限流时用它把轮询从 3 秒降到 60 秒。 */
+    this.biliDmAt = 0;
     const live = this.liveConfig() ?? {};
     const warm = this.dmWatchOn(live) && (live.douyin ?? this.cfg.douyin) !== false;
     // 抖音监听要靠浏览器读 DOM：保持后台页面热着，冷启动一次要十几秒，那段时间的消息接不住
@@ -1236,7 +1271,18 @@ export class StrollWorld {
     this.dmBusy = true;
     try {
       const fresh = [];
-      if (useBili) fresh.push(...(await this.newBiliDm().catch(() => [])));
+      /**
+       * B站私信平时按 dmPollSec（3 秒）拉；被 -509 限流时降到 60 秒一次。
+       * 以前限流期间照旧 3 秒一打：每次都被 -509 挡回来，既把「最近」刷满风控记录，
+       * 又不断续期 softBackoff，结果她自己反倒一直出不了门。
+       */
+      const wait = this.policy.rateWait();
+      const pollSec = Math.max(3, Number(live.dmPollSec ?? this.cfg.dmPollSec ?? 3) || 3);
+      const biliGap = (wait.waiting ? 60 : pollSec) * 1000;
+      if (useBili && Date.now() - Number(this.biliDmAt ?? 0) >= biliGap) {
+        this.biliDmAt = Date.now();
+        fresh.push(...(await this.newBiliDm().catch(() => [])));
+      }
       // 抖音已经走事件通道时就不必每 5 秒读一遍 DOM 了；但每 60 秒仍然对一次账，
       // 万一观察器漏了（页面卡住、切走了），最多晚一分钟，而不是一直不响。
       const dyArmed = !!this.douyin.dmArmed?.();
@@ -3538,7 +3584,11 @@ export class StrollWorld {
   history() {
     return {
       ok: true,
-      recent: this.store.lastActions(8),
+      // 给她看的是「做过什么」；风控记录另算，不塞进动作列表
+      recent: this.store
+        .lastActions(24)
+        .filter((x) => x.platform !== 'system')
+        .slice(0, 8),
       drafts: this.store.pendingDrafts().map((d) => ({ id: d.id, preview: this.previewText(d), ageSec: d.ageSec })),
       stats: this.store.data.stats,
       interests: this.store.topInterests(8),
@@ -4352,10 +4402,22 @@ export class StrollWorld {
   async douyinDmFast(secUid, text) {
     const name = this.douyinOwner().name || (await this.douyinOwnerName().catch(() => ''));
     if (name) {
+      /**
+       * 主人私信也要求「先核实会话再发」：
+       * strict + requireTitle —— 标题读不出来就当作没切过去，走下面按 secUid 的慢路径。
+       * 2026-11-08 那次三条私信落进群聊，就是因为这里不核实就按「当前开着的会话」发了。
+       */
       const ok = await this.douyin
-        .replyDm(name, cutChars(text, 300))
+        .replyDm(name, cutChars(text, 300), { strict: true, requireTitle: true })
         .then(() => true)
-        .catch(() => false);
+        .catch((error) => {
+          // 诊断用：走兜底就记下原因（NO_DM / NO_INPUT / THREAD_DRIFT…），好定位是哪一步过不去
+          this.log?.info?.('stroll dm fast failed', {
+            code: error?.code ?? '',
+            error: String(error?.message ?? error ?? '').slice(0, 120),
+          });
+          return false;
+        });
       if (ok) return { ok: true, sent: true, via: 'chat' };
     }
     return await this.douyin.dm(secUid, text);
@@ -5869,7 +5931,7 @@ export class StrollWorld {
         return { ok: true, items, sig: items.map((x) => x.id).join(',') };
       }
       if (method === 'usage_detail') return this.usageDetail(String(args[0] ?? ''));
-      if (method === 'timeline') return { ok: true, items: this.timelineItems(args[0]) };
+      if (method === 'timeline') return { ok: true, items: this.timelineItems(args[0]), total: this.store.data.actions.length };
       if (method === 'set_ramp') {
         const on = args[0] !== false && args[0] !== 'false';
         this.persist({ newAccountRamp: on });
@@ -6196,8 +6258,15 @@ export class StrollWorld {
       })),
       // 「先问我」模式下等主人点头的陌生人私信（面板「待你点头」里显示）
       strangerPending: this.strangerPendingList(),
-      recent: this.store.lastActions(10).map((x) => this.describeAction(x)),
-      recentTotal: this.store.data.actions.length,
+      // 面板「最近」只放真动作：风控/系统记录单独算，不跟点赞评论抢位置
+      // （先扫足够多：老数据里风控可能把末尾几十条全占了）
+      recent: this.store
+        .lastActions(300)
+        .filter((x) => x.platform !== 'system')
+        .slice(0, 10)
+        .map((x) => this.describeAction(x)),
+      recentTotal: this.store.data.actions.filter((x) => x.platform !== 'system').length,
+      riskCount: this.store.data.actions.filter((x) => x.action === 'risk').length,
       risk: this.store.data.risk,
       policy: this.policyView(),
       lastOpen: this.lastOpen,

package/webui/client.js

@@ -1344,16 +1344,46 @@ export default {
         async function openTimeline() {
           let data = null;
           try {
-            data = await ctx.invoke('timeline', [60]);
+            data = await ctx.invoke('timeline', [120]);
           } catch {
             // 读不到就退回面板上那几条
           }
-          const items = Array.isArray(data?.items) ? data.items : (lastData?.recent ?? []);
-          openSheet({
-            title: '最近做过什么',
-            hint: `${items.length} 条${Number(lastData?.recentTotal ?? items.length) > items.length ? `（更早的已折叠）` : ''}`,
-            render: (body) => renderDetailList(body, items, '还没出过门', '等她自己出门，或者在上面贴个链接。'),
-          });
+          const all = Array.isArray(data?.items) ? data.items : (lastData?.recent ?? []);
+          const total = Number(data?.total ?? all.length);
+          const isRisk = (x) => x?.action === 'risk' || x?.platform === 'system';
+          const groups = {
+            action: all.filter((x) => !isRisk(x)),
+            risk: all.filter(isRisk),
+          };
+          // 默认落在「动作」：风控记录再多也不该把真正做过的事盖住
+          let active = groups.action.length ? 'action' : groups.risk.length ? 'risk' : 'all';
+          const filters = [
+            { key: 'action', label: '动作', count: groups.action.length },
+            { key: 'risk', label: '风控', count: groups.risk.length },
+            { key: 'all', label: '全部', count: all.length },
+          ];
+          const paint = () => {
+            const items = active === 'all' ? all : groups[active] ?? [];
+            openSheet({
+              title: '最近做过什么',
+              hint: `${items.length} 条${total > all.length ? '（更早的已折叠）' : ''}`,
+              tabs: filters,
+              active,
+              onTab: (key) => {
+                if (key === active) return;
+                active = key;
+                paint();
+              },
+              render: (body) =>
+                renderDetailList(
+                  body,
+                  items,
+                  active === 'risk' ? '没被限流过' : '还没出过门',
+                  active === 'risk' ? '只有平台限流/要验证的时候才会记在这里。' : '等她自己出门，或者在上面贴个链接。',
+                ),
+            });
+          };
+          paint();
         }
 
         async function openComments(urlOverride) {