cortico-world-mosey 2.0.4 → 2.1.1

package/CHANGELOG.md

@@ -1,9 +1,64 @@
 # 更新日志
 
+## 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 之后必做还没做完，就只能干等到第二天。现在二选一，只留一道闸门。
+
+### 新的「出门方式」
+
+- **按次数**（默认，和以前一样）：每天出去几次就收工，额度只当单个动作的上限。
+- **按额度**：出去几次不限，把勾了必做的那几项做满才收工。适合「今天想让她把评论和点赞做完」。
+  - 只追勾了必做的项；一项都没勾时退回全部主动额度。
+  - 私信 / 群聊不算——没人找你时这两项永远做不满，算进去会变成一直出门却没事干。
+  - 被关掉的动作（不允许关注、只读模式、两个平台都关注不了……）不算目标，免得额度永远填不满、白跑。
+  - 还堆着 8 条以上草稿没批时先不出门：「等我批准」模式下草稿不涨额度，不拦会越堆越多。
+- **不自己出门**：只在你叫的时候逛。
+- 老配置自动迁移：以前「每天自己出门 = 0」→ 不自己出门，其余 → 按次数，行为不变。
+
+### 必做在两种模式下的分工
+
+- 按额度：勾了的项就是今天的目标，做满才收工；晚上没做完会催（最多 3 次、间隔 30 分钟），只催真正的目标项。
+- 按次数：必做只决定「先补哪个」，不催、也不压缩出门间隔——切模式不用再跑去把几个勾取消掉。
+
+### 被限流不再硬撞
+
+- `-509 / 429` 按 2 → 5 → 10 → 20 → 30 分钟退避（封顶 30 分钟），一小时内没再撞就从头算。
+- 只拦「她自己出门」的动作；你当场让她做的、回你私信的一律照旧（以前一刀切，限流一次连你叫都不应）。
+- 面板会写「限流歇 N 分钟」，不用再猜她为什么不动。
+
+### 面板和设置页
+
+- 「自己出门」卡片按模式显示：按次数是 `5/8`；按额度是 `5 次 · 额度 7/24`，并直接写「还差 赞 17、评 3」。
+- 出门推送同样列出还差哪几项，让她先补差距大的。
+- 设置页重排：基础 → 主人 → 公开动作 → 每日额度 → **自己出门** → 私信与群 → 看视频 → 一起看 → 抖音一起刷 → 高级。
+  - 「出不出去 / 一天几次 / 间隔 / 时段 / 安静时段 / 每次看几条 / 模型预算」全部收进「自己出门」。
+  - 每个「每天最多 X」下面紧跟「必做：X」，一眼看得出哪些被当成目标。
+
+### 其它
+
+- `stroll action=brief` 多给 `outingMode` / `autoSessions` / `quotaLeft`，她按模式决定还要不要继续出门。
+
 ## 2.0.4
 
 **继续脱敏，并瘦身。** 上一次漏了 `docs/` 里的面板预览页（假数据里有真实昵称和 B站 uid）。现在预览页也换成虚构占位，并且 `docs/` 不再随 npm 包分发——那几张截图只是市场素材，没必要塞进安装包（顺带把安装包瘦了 1.5MB）。
 
+> 2.0.3 与 2.0.4 内容完全相同：发布 2.0.3 时 npm 还在异步处理，误判成失败后换号重发，两版代码一致。
+
 ## 2.0.2
 
 **文档脱敏。**

package/package.json

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

package/src/ENV_PROMPT.md

@@ -21,7 +21,7 @@
 ### 怎么逛（省 token）
 
 - 一次 `stroll action=brief` 拿全：登录、额度、3 条候选、3 条消息。不要连着 `status`→`feed`→`inbox` 刷三遍。
-- **必做日**：`brief` 里有 `mustDo`（勾了「必做」的项，带 `need/done/left`）。只要有一项 `left>0`，这次出门就先把它们补够——`left` 是几次就做几次，别点一条就交差。晚上收到「今天还有必做没完成」的推送，立刻去补，不用等下一次出门。
+- **必做日**：`brief` 里有 `mustDo`（勾了「必做」的项，带 `need/done/left`）。只要有一项 `left>0`，这次出门就先把它们补够——`left` 是几次就做几次，别点一条就交差。**出门方式由主人选**：`brief.status.outingMode` 是 `sessions`（按次数：出去几次就收工，必做只决定先补哪个，晚上不会额外催你）或 `quota`（按额度：次数不限，**只有勾了必做的项算目标**，`quotaLeft` 是这些目标还剩多少个，做满才收工；没勾必做的额度只当上限，不用为了“做满”去硬做），`off` 是主人没让你自己出门。私信/群聊任何时候都不算“没做完”。收到「今天还有必做没完成」的推送（只有按额度模式会发），立刻去补，不用等下一次出门。
   - 「私信」「群聊」这两项要看有没有对象：没人给你发消息、群里也没人说话时，**不要为了凑数去私聊陌生人或硬插话**，如实告诉主人「今天没人找我说话，私信/群聊这项补不上」。
 - 从候选里挑 **1-3 条**真的想看的（按上面的活跃度来），再 `stroll action=open`。剩下的不点、不看、不评论。
 - 默认是**后台看**：不会弹出网页，也不会抢主人的鼠标。只有「一起看」和扫码登录会开窗。
@@ -146,7 +146,7 @@
 - 抖音的 @ 通知有时不弹（平台侧限流、对方关掉了被 @ 提醒）：`mentioned=true` 只代表评论里真的带了 @。主人说「没看到」时别争，把视频链接私信发过去，说清评论大概内容、让他按「最新」排一下；实在找不到就重新发一条，不要连刷。
 - **评论回执里的 `status` / `visible` / `note` 要看**：`visible=true`（status=1）才是别人也能看见；`status=2` 是「只有你自己看得见」，别人和被 @ 的人都看不到，也不会有通知——`note` 里写的就是原因和替代办法，照着说给主人听，别嘴硬、也别重发同一条。`status=7` 是还在审核，过一会儿再看。
 - **图文动态（`/note/` 链接）一样能评论、点赞**：走的是和视频同一条路，只是评论框要多展开一次（代码里已经处理好了）。如果回执说 `NO_INPUT`「找不到评论输入框」，先确认这条是不是关了评论，别硬重试。
-- **风控默认不拦人**：`-509 操作频繁` 这类限流只记一笔，不暂停任何动作，也不用干等到某个时间点。真发不出去平台会当场报错，那时如实告诉主人「抖音这边暂时发不出，稍后再试」。只有要短信验证码/封号这种情况才真的要停手。
+- **风控默认不拦人，但限流会让她自己歇几分钟**：`-509 操作频繁` 这类限流只记一笔，不暂停审批，也不拦主人当场让你做的事；**你自己出门的动作用完会按 2/5/10/20 分钟退避（最多 30 分钟）**，这段时间调 `stroll_act` 会返回 `SOFT_WAIT`——看到就老实等，别硬试，如实告诉主人「抖音这边限流了，歇几分钟再补」。只有要短信验证码/封号这种（`RISK_PAUSE`）才真的要停手。
 - **抖音评论不带 @ 时走的是接口直发**：`stroll_act action=comment` 一两秒就出结果（`via=api`）。带 `mention_owner` 的才需要点评论框，慢几秒——那是插 @ chip 必须的，别因为慢就自己去掉 @。
 - 评论发没发出去，以回执里的 `confirmed` / `queued` 为准（`confirmed=true` 是接口里能查到这条评论）。`queued=true` 说明平台还没回显，别立刻发第二遍。
 - 公开动作默认进草稿箱，等主人在「摸鱼」面板点批准。**你不能自己批准**，也不要催第二次；主人没点就是不想发。

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/config.js

@@ -75,7 +75,13 @@ export const DEFAULTS = {
   /** 她自己出门时的动作间隔；主人当场让她做的事不走这个数（只防连点）。 */
   minGapSeconds: 20,
 
-  /** 0 = 不自己出门；默认一天五次，比较像会自己刷手机的人。 */
+  /**
+   * 出门方式：off=不自己出门 / sessions=按次数 / quota=按额度。
+   * 以前是「次数」和「额度」两道闸门同时生效，谁先撞谁停——
+   * 次数用完之后必做还没做完，就只能干等到明天。
+   */
+  outingMode: 'sessions',
+  /** 0 = 不自己出门（等同于 outingMode=off）；按次数模式时一天出门几次。 */
   autoSessionsPerDay: 5,
   /** 两次自动出门之间至少隔多少分钟；和主人手动互动无关。 */
   autoGapMinutes: 90,
@@ -141,7 +147,7 @@ export const DEFAULTS = {
 
 const P = 'worlds.stroll.';
 
-/** 基础：开关、平台、放行方式、身份。 */
+/** 基础：开关、平台、放行方式。 */
 const BASIC = {
   id: 'world:stroll',
   owner: 'world:stroll',
@@ -180,42 +186,6 @@ const BASIC = {
         'x-hot': true,
         'x-warning': true,
       },
-      [P + 'autoSessionsPerDay']: {
-        type: 'integer',
-        title: '每天自己出门',
-        description: '0＝只在你叫的时候；5 次像正常人刷手机。',
-        minimum: 0,
-        maximum: 10,
-        'x-suffix': ' 次/天',
-        'x-hot': true,
-      },
-      [P + 'autoGapMinutes']: {
-        type: 'integer',
-        title: '两次出门至少隔',
-        description: '太密容易撞风控；90 分钟≈一天 5 次。',
-        minimum: 30,
-        maximum: 360,
-        'x-suffix': ' 分钟',
-        'x-hot': true,
-      },
-      [P + 'outingFrom']: {
-        type: 'integer',
-        title: '出门时段：从几点',
-        description: '只在这个时间段自己出门。想只走谷时可以填 1 到 6。',
-        minimum: 0,
-        maximum: 23,
-        'x-suffix': ' 点',
-        'x-hot': true,
-      },
-      [P + 'outingTo']: {
-        type: 'integer',
-        title: '出门时段：到几点',
-        description: '填 24 表示到当天结束。和上面填一样的值＝全天都能出门；跨天也行，比如 22 到 6。',
-        minimum: 0,
-        maximum: 24,
-        'x-suffix': ' 点',
-        'x-hot': true,
-      },
     },
   },
 };
@@ -266,7 +236,8 @@ const QUOTA = {
   schema: {
     type: 'object',
     title: '每日额度',
-    description: '每天最多做多少，自己填。勾「必做」就从上限变成目标；周上限自动是日上限 × 7。',
+    description:
+      '每天最多做多少。「必做」＝当成今天的目标：按额度出门时，勾了的要做满才收工；按次数出门时只决定先补哪个，不会额外催她出门（所以切模式不用取消勾选）。没勾的只当上限。周上限自动是日上限 × 7。',
     properties: {
 
       [P + 'dailyLikes']: {
@@ -276,6 +247,11 @@ const QUOTA = {
         maximum: 200,
         'x-suffix': ' 次',
       },
+      [P + 'mustLike']: {
+        type: 'boolean',
+        title: '必做：点赞',
+        description: '勾上后，今天要做满「每天最多点赞」的次数；按额度出门时这是收工条件之一。',
+      },
       [P + 'dailyComments']: {
         type: 'integer',
         title: '每天最多评论',
@@ -283,6 +259,11 @@ const QUOTA = {
         maximum: 100,
         'x-suffix': ' 条',
       },
+      [P + 'mustComment']: {
+        type: 'boolean',
+        title: '必做：评论',
+        description: '勾上后，今天要做满「每天最多评论」的条数。审批不是 auto 时评论会进草稿，批准后才算完成。',
+      },
       [P + 'dailyDms']: {
         type: 'integer',
         title: '每天最多私信',
@@ -291,6 +272,12 @@ const QUOTA = {
         minimum: 0,
         'x-suffix': ' 条',
       },
+      [P + 'mustDm']: {
+        type: 'boolean',
+        title: '必做：私信',
+        description:
+          '勾上后，今天要发够「每天最多私信」的条数，晚上没做完会提醒你。但按额度出门不拿它当收工条件——没人给你发消息时，硬凑会变成骚扰陌生人。',
+      },
       [P + 'dailyGroups']: {
         type: 'integer',
         title: '每天最多群聊',
@@ -298,6 +285,11 @@ const QUOTA = {
         minimum: 0,
         'x-suffix': ' 条',
       },
+      [P + 'mustGroup']: {
+        type: 'boolean',
+        title: '必做：群聊',
+        description: '勾上后，今天要在群里说够「每天最多群聊」的条数。**按额度出门也不拿它当收工条件**（群里没人说话时不能硬插话）。',
+      },
       [P + 'dailyFollows']: {
         type: 'integer',
         title: '每天最多关注',
@@ -305,6 +297,11 @@ const QUOTA = {
         maximum: 100,
         'x-suffix': ' 人',
       },
+      [P + 'mustFollow']: {
+        type: 'boolean',
+        title: '必做：关注',
+        description: '勾上后，今天要关注够「每天最多关注」的人数；按额度出门时这是收工条件之一。',
+      },
       [P + 'dailyPosts']: {
         type: 'integer',
         title: '每天最多发动态',
@@ -312,6 +309,11 @@ const QUOTA = {
         maximum: 30,
         'x-suffix': ' 条',
       },
+      [P + 'mustPost']: {
+        type: 'boolean',
+        title: '必做：发动态',
+        description: '勾上后，今天要发够「每天最多发动态」的条数。审批不是 auto 时会进草稿，批准后才算完成。',
+      },
       [P + 'dailySaves']: {
         type: 'integer',
         title: '每天最多稍后再看',
@@ -319,36 +321,6 @@ const QUOTA = {
         maximum: 100,
         'x-suffix': ' 条',
       },
-      [P + 'mustLike']: {
-        type: 'boolean',
-        title: '必做：点赞',
-        description: '勾上后，今天必须完成「每天最多点赞」的次数，没完成她会优先去补。',
-      },
-      [P + 'mustComment']: {
-        type: 'boolean',
-        title: '必做：评论',
-        description: '勾上后，今天必须完成「每天最多评论」的条数。审批不是 auto 时评论会进草稿，批准后才算完成。',
-      },
-      [P + 'mustDm']: {
-        type: 'boolean',
-        title: '必做：私信',
-        description: '勾上后，今天必须发够「每天最多私信」的条数。没有可回的人时她会告诉你，不会硬找陌生人发。',
-      },
-      [P + 'mustGroup']: {
-        type: 'boolean',
-        title: '必做：群聊',
-        description: '勾上后，今天必须在群里说够「每天最多群聊」的条数。群里没人说话时不算她的错，她会说明。',
-      },
-      [P + 'mustFollow']: {
-        type: 'boolean',
-        title: '必做：关注',
-        description: '勾上后，今天必须关注够「每天最多关注」的人数。',
-      },
-      [P + 'mustPost']: {
-        type: 'boolean',
-        title: '必做：发动态',
-        description: '勾上后，今天必须发够「每天最多发动态」的条数。审批不是 auto 时会进草稿，批准后才算完成。',
-      },
 
     },
   },
@@ -399,23 +371,61 @@ const INTERACT = {
   },
 };
 
-/** 高级：兴趣、省 token、一起看、风控。 */
-const ADVANCED = {
-  id: 'world:stroll-advanced',
+/** 自己出门：方式、次数、间隔、时段、预算——她自己的节奏全在这一组。 */
+const OUTING = {
+  id: 'world:stroll-outing',
   owner: 'world:stroll',
   schema: {
     type: 'object',
-    title: '高级与节奏',
-    description: '一般不用改。改错最多多花点 token 或多等一会儿。',
+    title: '自己出门',
+    description:
+      '她什么时候出去、一天出去几次、被什么挡住。按次数＝出去几次就收工；按额度＝把勾了必做的项做满才收工。',
     properties: {
-
-      [P + 'tokenDailyBudget']: {
+      [P + 'outingMode']: {
+        type: 'string',
+        title: '出门方式',
+        'x-options': 'stroll-outing-mode',
+        description:
+          '按次数：每天出去几次就收工，额度只当单个动作的上限。' +
+          '按额度：出去几次不限，把勾了必做的项做满才收工（一个都没勾时按全部主动额度算）；' +
+          '私信/群聊不算，没人找你时这两项永远做不满。没勾必做的额度只当上限，不会逼她做。',
+        'x-hot': true,
+      },
+      [P + 'autoSessionsPerDay']: {
         type: 'integer',
-        title: '每天模型预算',
-        description: '只限制主动出门的频率，不拦你找她。',
-        minimum: 1000,
-        maximum: 50000,
-        'x-suffix': ' token',
+        title: '每天自己出门',
+        description: '只在「出门方式＝按次数」时生效；0＝不自己出门。',
+        minimum: 0,
+        maximum: 10,
+        'x-suffix': ' 次/天',
+        'x-hot': true,
+      },
+      [P + 'autoGapMinutes']: {
+        type: 'integer',
+        title: '两次出门至少隔',
+        description: '太密容易撞风控；90 分钟≈一天 5 次。按额度模式也按这个间隔走。',
+        minimum: 30,
+        maximum: 360,
+        'x-suffix': ' 分钟',
+        'x-hot': true,
+      },
+      [P + 'outingFrom']: {
+        type: 'integer',
+        title: '出门时段：从几点',
+        description: '只在这个时间段自己出门。想只走谷时可以填 1 到 6。',
+        minimum: 0,
+        maximum: 23,
+        'x-suffix': ' 点',
+        'x-hot': true,
+      },
+      [P + 'outingTo']: {
+        type: 'integer',
+        title: '出门时段：到几点',
+        description: '填 24 表示到当天结束。和上面填一样的值＝全天都能出门；跨天也行，比如 22 到 6。',
+        minimum: 0,
+        maximum: 24,
+        'x-suffix': ' 点',
+        'x-hot': true,
       },
       [P + 'quietFrom']: {
         type: 'integer',
@@ -449,6 +459,28 @@ const ADVANCED = {
         maximum: 12,
         'x-suffix': ' 条',
       },
+      [P + 'tokenDailyBudget']: {
+        type: 'integer',
+        title: '每天模型预算',
+        description: '按每出门一次约 1500 token 折算成「今天最多还能出门几次」，两种出门方式都受它限制。',
+        minimum: 1000,
+        maximum: 50000,
+        'x-suffix': ' token',
+      },
+    },
+  },
+};
+
+/** 高级：兴趣、评论、风控、图片目录。 */
+const ADVANCED = {
+  id: 'world:stroll-advanced',
+  owner: 'world:stroll',
+  schema: {
+    type: 'object',
+    title: '高级',
+    description: '一般不用改。改错最多多花点 token 或多等一会儿。',
+    properties: {
+
       [P + 'commentMaxChars']: {
         type: 'integer',
         title: '评论最多几个字',
@@ -781,7 +813,12 @@ const MESSAGES = {
   },
 };
 
-export const CONFIG_GROUPS = [BASIC, OWNER, QUOTA, VIEWING, WATCH, SHORTS, MESSAGES, INTERACT, ADVANCED];
+/**
+ * 设置页的顺序（从「最常改」到「一般不动」）：
+ *   基础 → 主人 → 公开动作（她能做什么）→ 每日额度（做多少 / 哪些必做）
+ *   → 自己出门（怎么出去）→ 私信与群 → 看视频 → 一起看 → 抖音一起刷 → 高级
+ */
+export const CONFIG_GROUPS = [BASIC, OWNER, INTERACT, QUOTA, OUTING, MESSAGES, VIEWING, WATCH, SHORTS, ADVANCED];
 
 /** 旧引用兼容：第一组即基础组。 */
 
@@ -835,6 +872,7 @@ export const POLICY_FIELDS = {
   minGapSeconds: { type: 'int', min: 10, max: 600 },
   riskGuard: { type: 'enum', values: ['off', 'light', 'strict'] },
   autoSessionsPerDay: { type: 'int', min: 0, max: 10 },
+  outingMode: { type: 'enum', values: ['off', 'sessions', 'quota'] },
   autoGapMinutes: { type: 'int', min: 30, max: 360 },
   outingFrom: { type: 'int', min: 0, max: 23 },
   outingTo: { type: 'int', min: 0, max: 24 },

package/src/definition.js

@@ -60,6 +60,13 @@ export const STROLL = {
         { value: 'strict', label: zh ? '严格' : 'Strict' },
       ];
     }
+    if (kind === 'stroll-outing-mode') {
+      return [
+        { value: 'sessions', label: zh ? '按次数：出去几次就收工（默认）' : 'By trip count (default)' },
+        { value: 'quota', label: zh ? '按额度：额度做满才收工' : 'By daily quota' },
+        { value: 'off', label: zh ? '不自己出门' : 'Never go out on its own' },
+      ];
+    }
     if (kind !== 'stroll-approval') return [];
     return [
       { value: 'confirm', label: zh ? '全部等我批准（推荐）' : 'Ask me first (recommended)' },

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) {

package/src/policy.js

@@ -1,5 +1,14 @@
 import { clamp, dayKey, hourOf, weekKey } from './util.js';
 
+/**
+ * -509 / 429 这类「只是太快了」的限流：按撞墙次数退避 2 / 5 / 10 / 20 分钟，封顶 30 分钟。
+ * 和 riskGuard 解耦——riskGuard 管「要不要把所有动作停掉」，这里只管「她自己出门的节奏」，
+ * 主人当场点的、回主人私信的一律不拦（不然被限流一次就连主人叫都不应了）。
+ */
+const RATE_BACKOFF_MIN = [2, 5, 10, 20, 30];
+/** 离上次限流超过一小时，就当上一波已经过去，退避从头算。 */
+const RATE_RESET_MS = 60 * 60 * 1000;
+
 /**
  * 日额度直接读配置；周额度 = 日额度 × 7（不再另设一个写死的周上限）。
  * 以前 follow 的 weeklyMax 是 12——即使主人把日额度调到 5，一周也只能关注 12 个，
@@ -86,6 +95,24 @@ export class Policy {
     return { paused: true, until, reason };
   }
 
+  /**
+   * 限流退避：`{ waiting, until, minutes, n, reason }`。
+   * 只拦「她自己出门」时做的动作；主人当场点的、回主人私信的不受影响。
+   */
+  rateWait() {
+    const soft = this.store.data.softBackoff ?? {};
+    const until = Number(soft.until ?? 0);
+    const n = Number(soft.n ?? 0);
+    if (!until || until <= Date.now()) return { waiting: false, until: 0, minutes: 0, n, reason: '' };
+    return {
+      waiting: true,
+      until,
+      minutes: Math.max(1, Math.ceil((until - Date.now()) / 60000)),
+      n,
+      reason: String(soft.reason ?? '-509'),
+    };
+  }
+
   /**
    * 公开动作总闸。userInitiated 是你亲手点的：只做防连点，不再按节奏拦。
    *
@@ -132,6 +159,20 @@ export class Policy {
     //                    永远撞 90 秒的 TOO_FAST，表现就是每次评论都要等一两分钟
     //   自己出门         minGapSeconds（默认 20 秒）
     const asked = userInitiated || this.ownerActive();
+    /**
+     * 刚被 -509/429 挡过：她自己先歇几分钟，别继续撞（撞得越勤退避越长）。
+     * 只拦「她自己出门」的动作：主人当场点的（asked）、回主人私信的（free）照旧——
+     * 以前这里一刀切，结果一次限流连主人叫她做的事都做不了。
+     */
+    const wait = this.rateWait();
+    if (wait.waiting && !asked && !free) {
+      return {
+        ok: false,
+        code: 'SOFT_WAIT',
+        message: `刚被平台限流（${wait.reason}），歇 ${wait.minutes} 分钟再动。`,
+        until: wait.until,
+      };
+    }
     const minGap = Math.max(5, Number(this.cfg.minGapSeconds ?? 20));
     const sincePlat = Date.now() - Number((this.store.data.lastWriteByPlat ?? {})[platform] ?? 0);
     const sinceAny = Date.now() - Number(this.store.data.lastWriteAt ?? 0);
@@ -214,14 +255,46 @@ 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;
+    // 限流退避（和 riskGuard 无关）：-509 只是「太快了」，几分钟自己就好，
+    // 但一路硬撞会越来越久——按次数 2/5/10/20/30 分钟递增。
+    let soft = null;
+    if (rate) {
+      const prev = this.store.data.softBackoff ?? {};
+      const fresh = Date.now() - Number(prev.at ?? 0) > RATE_RESET_MS;
+      const n = fresh ? 1 : Math.max(1, Number(prev.n ?? 0) + 1);
+      const minutes = RATE_BACKOFF_MIN[Math.min(n, RATE_BACKOFF_MIN.length) - 1];
+      this.store.data.softBackoff = {
+        n,
+        at: Date.now(),
+        until: Date.now() + minutes * 60 * 1000,
+        reason: String(message ?? code ?? '-509').slice(0, 120),
+      };
+      soft = this.rateWait();
+    }
 
     let hours = 0;
     if (guard === 'strict') {
@@ -248,7 +321,7 @@ export class Policy {
       result: hours > 0 ? 'paused' : 'noted',
     });
     this.store.save();
-    return { until, hours, reason: this.store.data.risk.reason, guard };
+    return { until, hours, reason: this.store.data.risk.reason, guard, soft };
   }
 
   /** 给 ENV_PROMPT 的一行摘要。 */
@@ -261,9 +334,10 @@ export class Policy {
       })
       .join(' ');
     const paused = this.paused();
+    const wait = this.rateWait();
     const risk = paused.paused ? `停到 ${new Date(paused.until).toLocaleString('zh-CN')}` : '正常';
     const approval = { confirm: '全批准', auto_low_risk: '赞自动', auto_all: '按额度', dry_run: '只读' }[this.cfg.approval] ?? this.cfg.approval;
-    return `今日 ${parts} · 风险 ${risk} · 审批 ${approval}`;
+    return `今日 ${parts} · 风险 ${risk}${wait.waiting ? ` · 限流歇 ${wait.minutes} 分钟` : ''} · 审批 ${approval}`;
   }
 
   /** 给面板的完整计数。 */
@@ -281,6 +355,7 @@ export class Policy {
       caps,
       quiet: this.isQuiet(),
       paused: this.paused(),
+      rateWait: this.rateWait(),
       ramp: this.rampFactor(),
       approval: this.cfg.approval,
       summary: this.summary(),

package/src/store.js

@@ -18,6 +18,10 @@ function blank() {
     actions: [],
     drafts: [],
     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: {},
@@ -50,6 +54,8 @@ export class Store {
       const parsed = JSON.parse(raw);
       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') {
@@ -211,6 +217,8 @@ export class Store {
 
   clearRisk() {
     this.data.risk = { until: 0, reason: '', strikes: 0, lastCode: '' };
+    // 限流退避一起清：主人都点「继续」了，别再自己歇着
+    this.data.softBackoff = { until: 0, at: 0, n: 0, reason: '' };
   }
 
   noteInterest(tags) {

package/src/world.js

@@ -46,6 +46,9 @@ const ACTION_NAMES = {
 
 const PLATFORM_NAMES = { bilibili: 'B站', douyin: '抖音' };
 
+/** 额度模式里给主人看的短名：出门推送和面板上的「还差 赞 17、评 3」用它。 */
+const QUOTA_SHORT = { like: '赞', comment: '评', follow: '关注', post: '动态', save: '稍后再看' };
+
 /**
  * 别人发来的内容统一加边界。
  *
@@ -369,6 +372,54 @@ 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 起这件事交给「出门方式」，这里把老配置翻译过去，之后主人改的就不动了：
+   * 0 → 不自己出门；正数 → 按次数（和原来完全一样）。
+   */
+  migrateOutingMode() {
+    if (String(this.cfg.outingMode ?? '').trim()) return;
+    const mode = Number(this.cfg.autoSessionsPerDay ?? 5) > 0 ? 'sessions' : 'off';
+    try {
+      this.cfg.outingMode = mode;
+    } catch {
+      // 宿主冻结了配置对象：outingMode() 会自己按次数推断，不影响这一版的行为
+    }
+    try {
+      this.persist({ outingMode: mode });
+    } catch {
+      // 宿主不让写就只影响这次进程，面板里还能手改
+    }
+    this.log?.info?.('stroll migrate outing mode', { to: mode, autoSessionsPerDay: this.cfg.autoSessionsPerDay });
+  }
+
   /**
    * 一次性迁移：旧版本里 `dailyDms` 有个值（默认 3），但那时候私信一律 free，
    * 这个数从来没生效过，主人也没在界面上见过。1.25.0 起它真的开始限额了，
@@ -377,6 +428,8 @@ export class StrollWorld {
   migrateConfig() {
     this.migrateStrangerKeys();
     this.migrateStrangerSeenEcho();
+    this.migrateOutingMode();
+    this.pruneRiskActions();
     this.refundDmLoopQuota();
     const done = this.store.data.migrated ?? {};
     if (done.dmQuota) return;
@@ -413,20 +466,42 @@ export class StrollWorld {
     if (!this.inOutingWindow(hour)) return;
     if (this.policy.isQuiet() || this.policy.paused().paused) return;
     const day = dayKey(new Date(now), this.timeZone);
-    // 勾了「必做」但今天还没做够的项：出门要优先补，晚上到点还要单独催
+    // 勾了「必做」但今天还没做够的项：按额度模式下决定要不要出门，按次数模式下只决定先补哪个
     const pending = this.mustDoList().filter((x) => x.left > 0);
     await this.maybeMustNudge(pending, hour, day);
-    if (this.cfg.autoSessionsPerDay <= 0) return;
+    const mode = this.outingMode();
+    if (mode === 'off') return;
+    // 刚被 -509/429 挡过：她先歇几分钟再出门（主人当场点的事不受影响）
+    if (this.policy.rateWait().waiting) return;
     const used = Number(this.store.data.autoSessions[day] ?? 0);
+    // token 预算是两种模式共用的天花板：每出门一次大约 1500 token
     const budgetCap = Math.max(0, Math.floor(Number(this.cfg.tokenDailyBudget ?? DEFAULTS.tokenDailyBudget) / 1500));
-    const cap = Math.min(Number(this.cfg.autoSessionsPerDay), budgetCap);
-    if (used >= cap) return;
+    if (used >= budgetCap) return;
+    let gap;
+    if (mode === 'quota') {
+      // 按额度：出去几次不限，目标做满才收工（私信/群聊不算——没人找时永远做不满）
+      if (this.quotaLeftForOuting() <= 0) return;
+      /**
+       * 还堆着一批草稿等你点头：先别出去。
+       * 「等我批准」模式下草稿不涨额度，不拦的话她会一趟趟出去、草稿越堆越多。
+       */
+      if (this.store.pendingDrafts().length >= 8) return;
+      gap = this.autoGapMs();
+    } else {
+      // 按次数：次数用完就收工；额度仍然拦每个动作
+      if (used >= Math.min(Number(this.cfg.autoSessionsPerDay ?? 0), budgetCap)) return;
+      /**
+       * 节奏只看次数，**不看必做**：必做在按次数模式下只决定「先补哪个」，
+       * 不压缩间隔、也不取消 40% 的随机跳过。
+       * 以前压到 30 分钟，等于切到按次数后还得把必做一个个关掉才省得下 token。
+       */
+      gap = this.autoGapMs();
+    }
     // 用 lastAutoAt 而不是 lastSessionAt：主人手动让她看东西，不该把自动出门往后推
     const lastAuto = Number(this.store.data.lastAutoAt ?? this.store.data.lastSessionAt ?? 0);
-    // 有必做没完成：间隔压到最多 30 分钟，而且不再掷骰子跳过
-    const gap = pending.length ? Math.min(this.autoGapMs(), 30 * 60 * 1000) : this.autoGapMs();
     if (Date.now() - lastAuto < gap) return;
-    if (!pending.length && Math.random() > 0.6) return;
+    // 按次数保留 40% 跳过（像人一样不是每次都去）；按额度是「有活就干」，不掷骰子
+    if (mode === 'sessions' && Math.random() > 0.6) return;
     this.store.data.lastAutoAt = Date.now();
     this.store.data.autoSessions[day] = used + 1;
     // 记住「这是一次自己出门」：出门窗口内她连续做动作要按 20 秒节奏，
@@ -434,17 +509,103 @@ export class StrollWorld {
     this.autoWalkAt = Date.now();
     this.store.save();
     const mustLine = pending.length
-      ? `\n今天是必做日，还差：${pending.map((x) => `${x.label} ${x.left}`).join('、')}。先补这些，别只刷着看。`
+      ? `\n今天是必做日，还差：${[...pending]
+          .sort((a, b) => b.left - a.left)
+          .map((x) => `${x.label} ${x.left}`)
+          .join('、')}。先补差得多的（一次出门做不完就挑差距最大的），别只刷着看。`
       : '';
+    const quotaLine =
+      mode === 'quota'
+        ? `\n现在是「按额度」出门：还差 ${this.quotaLeftList()
+            .filter((x) => x.left > 0)
+            .map((x) => `${x.label} ${x.left}`)
+            .join('、')}，做满就收工（私信和群聊没人找你时不算没做完）。`
+        : '';
     const maxItems = clamp(Number(this.cfg.sessionMaxItems ?? 8), 3, 12);
     await this.push(
       'stroll.due',
-      `该出门溜达了。今天还剩：${this.policy.summary()}。${mustLine}\n这次最多看 ${maxItems} 条，看完就回来。\n想逛就调 stroll action=brief（一次拿全，别连续 status/feed/inbox）；不想去就回「今天不逛」。`,
-      { day, used: used + 1, must: pending.length > 0 },
+      `该出门溜达了。今天还剩：${this.policy.summary()}。${mustLine}${quotaLine}\n这次最多看 ${maxItems} 条，看完就回来。\n想逛就调 stroll action=brief（一次拿全，别连续 status/feed/inbox）；不想去就回「今天不逛」。`,
+      { day, used: used + 1, must: pending.length > 0, mode },
       'debounce',
     );
   }
 
+  /**
+   * 出门方式：
+   *   off      = 不自己出门（只在你叫的时候）
+   *   sessions = 按次数（默认，和 2.0 一模一样）
+   *   quota    = 按额度（次数不限，主动额度做满才收工）
+   * 没填这个键（老配置）时按「次数」理解；次数填 0 一律当作不出去。
+   */
+  outingMode() {
+    const raw = String(this.cfg.outingMode ?? '').toLowerCase();
+    if (raw === 'off') return 'off';
+    if (raw === 'quota') return 'quota';
+    return Number(this.cfg.autoSessionsPerDay ?? 0) > 0 ? 'sessions' : 'off';
+  }
+
+  /**
+   * 额度模式追哪些项：**勾了必做的**才算目标；一个都没勾就退回全部主动额度。
+   * 私信、群聊永远不算——没人找她的时候这两项做不满，算进去就变成一直出门却没事干。
+   */
+  quotaTargetKeys() {
+    const wanted = [
+      ['like', 'mustLike'],
+      ['comment', 'mustComment'],
+      ['follow', 'mustFollow'],
+      ['post', 'mustPost'],
+    ]
+      .filter(([, flag]) => this.cfg[flag] === true)
+      .map(([key]) => key)
+      .filter((key) => this.canAct(key));
+    if (wanted.length) return wanted;
+    // 没勾必做（或者勾了但都做不了）：退回全部主动额度，不然额度模式会永远不出门
+    return ['like', 'comment', 'follow', 'post', 'save'].filter((key) => this.canAct(key));
+  }
+
+  /** 这个动作现在还有没有可能做成：开关关掉、只读模式就不算目标。 */
+  canAct(key) {
+    if (this.cfg.approval === 'dry_run') return false;
+    if (key === 'follow') {
+      if (!this.cfg.allowFollow) return false;
+      // 两个平台都关注不了才算做不了：B站关掉、抖音关注方式也关掉
+      const bili = this.cfg.bilibili !== false;
+      const douyin = this.cfg.douyin !== false && String(this.cfg.douyinFollowMode ?? 'browser') !== 'off';
+      if (!bili && !douyin) return false;
+    }
+    if (key === 'post' && !this.cfg.allowPost) return false;
+    if (key === 'save' && !this.cfg.allowSave) return false;
+    return true;
+  }
+
+  /** 额度模式的进度（只算目标项）。 */
+  quotaProgress() {
+    let left = 0;
+    let total = 0;
+    const keys = this.quotaTargetKeys();
+    for (const key of keys) {
+      const r = this.policy.remaining(key);
+      left += Math.max(0, Math.min(r.daily, r.weekly));
+      total += Math.max(0, Math.min(r.dailyCap, r.weeklyCap));
+    }
+    return { left, total, done: Math.max(0, total - left), keys };
+  }
+
+  /** 额度模式还差哪几项（差距从大到小），给出门推送和面板用。 */
+  quotaLeftList() {
+    return this.quotaTargetKeys()
+      .map((key) => {
+        const r = this.policy.remaining(key);
+        return { key, label: QUOTA_SHORT[key] ?? key, left: Math.max(0, Math.min(r.daily, r.weekly)) };
+      })
+      .sort((a, b) => b.left - a.left);
+  }
+
+  /** 额度模式还能不能出门：目标项只要还剩一个动作就还能出去。 */
+  quotaLeftForOuting() {
+    return this.quotaProgress().left;
+  }
+
   /**
    * 今天的「必做」清单：勾了开关的项，目标次数就是对应的每日额度。
    * 用 usage 里的今日计数（unlike→like、reply→comment、unfollow→follow 已经在 capAction 里归一）。
@@ -470,9 +631,22 @@ export class StrollWorld {
       .filter((x) => x.need > 0);
   }
 
-  /** 晚上还没做完必做：单独催她，最多 3 次、每次间隔 30 分钟。 */
+  /** 晚上还没做完必做：单独催她，最多 3 次、每次间隔 30 分钟。**只在按额度模式下催**。 */
   async maybeMustNudge(pending, hour, day) {
     if (!pending?.length) return;
+    /**
+     * 按次数 / 不自己出门都不催。
+     * 按次数模式的语义就是「出去几次就收工」，次数用完之后再把她叫出去补必做，
+     * 等于逼主人切模式时顺手把必做一个个关掉——那不该是主人的活儿。
+     */
+    if (this.outingMode() !== 'quota') return;
+    /**
+     * 只催「额度模式真正在追的项」。
+     * 私信/群聊（以及被关掉的动作）不在目标里，催了也没用——没人找她的时候做不完。
+     */
+    const targets = new Set(this.quotaTargetKeys());
+    const list = pending.filter((x) => targets.has(x.action));
+    if (!list.length) return;
     // 原来写死「18 点后催」；窗口换成凌晨就永远催不到。
     // 改成「离窗口结束不到 4 小时」才开始催。
     const { to } = this.outingWindow();
@@ -493,7 +667,7 @@ export class StrollWorld {
     this.store.save();
     await this.push(
       'stroll.due',
-      `今天还有必做没完成：${pending.map((x) => `${x.label} ${x.done}/${x.need}`).join('、')}。现在就去补，不用等下一次出门；补完再回我一句。`,
+      `今天还有必做没完成：${list.map((x) => `${x.label} ${x.done}/${x.need}`).join('、')}。现在就去补，不用等下一次出门；补完再回我一句。`,
       { must: true, day },
       'flush',
     );
@@ -511,6 +685,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：保持后台页面热着，冷启动一次要十几秒，那段时间的消息接不住
@@ -1090,7 +1266,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?.();
@@ -3044,7 +3231,10 @@ export class StrollWorld {
       pending: this.store.pendingDrafts().map((d) => ({ id: d.id, action: d.action, platform: d.platform, preview: this.previewText(d) })),
       last: this.store.lastActions(3),
       interests: this.store.topInterests(6),
+      // 出门方式（off/sessions/quota）和「按额度」还剩多少个主动动作
+      outingMode: this.outingMode(),
       autoSessions: this.store.data.autoSessions[dayKey()] ?? 0,
+      quotaLeft: this.quotaLeftForOuting(),
       // 必做清单（勾了开关的项）：她出门前先看还差多少
       mustDo: this.mustDoList(),
     };
@@ -3099,6 +3289,10 @@ export class StrollWorld {
         policy: status.policy.summary,
         pending: status.pending.length,
         owner: status.owner,
+        // 出门方式：sessions 按次数 / quota 按额度（quotaLeft = 主动动作还剩多少个）/ off 不自己出门
+        outingMode: status.outingMode,
+        autoSessions: status.autoSessions,
+        quotaLeft: status.quotaLeft,
         // 必做清单要跟着 brief 一起给她，不然出门推送里只能看到「还剩几次」却不知道目标
         mustDo: status.mustDo ?? this.mustDoList(),
       },
@@ -3385,7 +3579,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),
@@ -4474,7 +4672,7 @@ export class StrollWorld {
     }
     return (
       `「${s}」不在能发的目录里。现在只能发这几个目录里的图：\n${dirs.join('\n')}\n` +
-      '想放开别的目录：设置 → 高级与节奏 → 额外允许发图的目录，填绝对路径（逗号分隔）。'
+      '想放开别的目录：设置 → 高级 → 额外允许发图的目录，填绝对路径（逗号分隔）。'
     );
   }
 
@@ -5433,6 +5631,9 @@ export class StrollWorld {
       caps: this.policy.snapshot(),
       quiet: { from: this.cfg.quietFrom, to: this.cfg.quietTo },
       autoSessionsPerDay: this.cfg.autoSessionsPerDay,
+      // 出门方式：sessions 按次数 / quota 按额度 / off 不自己出门
+      outingMode: this.outingMode(),
+      quotaLeft: this.quotaLeftForOuting(),
       interests: this.cfg.interests,
       avoid: this.cfg.avoid,
       tokenDailyBudget: this.cfg.tokenDailyBudget,
@@ -5532,7 +5733,26 @@ export class StrollWorld {
       if (method === 'set_auto') {
         const n = clamp(Number(args[0] ?? 0), 0, 10);
         this.persist({ autoSessionsPerDay: n });
-        return { ok: true, autoSessionsPerDay: n };
+        // 面板上那个开关只管「开/关」：填 0 等于不自己出门，填正数等于按次数
+        const mode = n > 0 ? 'sessions' : 'off';
+        try {
+          this.cfg.outingMode = mode;
+        } catch {
+          // 配置对象被冻结：下面的 persist 已经把磁盘改了，宿主热更新会接上
+        }
+        this.persist({ outingMode: mode });
+        return { ok: true, autoSessionsPerDay: n, outingMode: mode };
+      }
+      if (method === 'set_outing') {
+        const v = String(args[0] ?? '');
+        if (!['off', 'sessions', 'quota'].includes(v)) return { ok: false, error: '不认识这个出门方式。' };
+        try {
+          this.cfg.outingMode = v;
+        } catch {
+          // 同上
+        }
+        this.persist({ outingMode: v });
+        return { ok: true, outingMode: v };
       }
       if (method === 'set_approval') {
         const v = String(args[0] ?? '');
@@ -5694,7 +5914,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 });
@@ -5825,22 +6045,52 @@ export class StrollWorld {
     }
   }
 
-  /** 下一次自动出门大概什么时候；今天用完或关着就返回 null。 */
+  /** 下一次自动出门大概什么时候；今天收工或关着就返回 null。 */
   autoNextView() {
-    const daily = Number(this.cfg.autoSessionsPerDay ?? 0);
-    if (daily <= 0 || !this.cfg.enabled) return null;
+    const mode = this.outingMode();
+    if (!this.cfg.enabled || mode === 'off') return null;
     const budgetCap = Math.max(0, Math.floor(Number(this.cfg.tokenDailyBudget ?? DEFAULTS.tokenDailyBudget) / 1500));
-    const cap = Math.min(daily, budgetCap);
     const day = dayKey(new Date(), this.timeZone);
     const used = Number(this.store.data.autoSessions[day] ?? 0);
-    if (used >= cap) return { done: true, used, cap };
+    const quota = this.quotaProgress();
+    const daily = Math.max(0, Math.floor(Number(this.cfg.autoSessionsPerDay ?? 0)));
+    // 按额度模式不看「每天自己出门」；按次数模式才看
+    const cap = mode === 'quota' ? budgetCap : Math.min(daily, budgetCap);
+    const base = {
+      mode,
+      used,
+      cap,
+      quotaLeft: quota.left,
+      quotaTotal: quota.total,
+      // 还差哪几项（只剩没做满的）：面板和推送都直接照这个念，别只说一个总数
+      targets: mode === 'quota' ? this.quotaLeftList().filter((x) => x.left > 0) : [],
+      drafts: this.store.pendingDrafts().length,
+      budgetLeft: Math.max(0, budgetCap - used),
+    };
+    // token 预算是两种模式共用的天花板
+    if (used >= budgetCap) return { ...base, done: true, reason: 'budget' };
+    // 按额度但一个能做的动作都没有（只读模式、公开动作全关）：不出门，别空跑
+    if (mode === 'quota' && !quota.keys.length) return { ...base, done: true, reason: 'none' };
+    // 按额度但草稿堆着没人批：先等你批完再出去
+    if (mode === 'quota' && this.store.pendingDrafts().length >= 8) return { ...base, done: true, reason: 'drafts' };
+    // 按额度：目标做满 = 今天收工
+    if (mode === 'quota' && quota.left <= 0) return { ...base, done: true, reason: 'quota' };
+    // 按次数：次数用完 = 今天收工
+    if (mode === 'sessions' && used >= cap) return { ...base, done: true, reason: 'sessions' };
+
     const last = Number(this.store.data.lastAutoAt ?? this.store.data.lastSessionAt ?? 0);
-    // tick 里有 40% 概率跳过（Math.random() > 0.6 才出门），按期望 1/0.6 折算，
+    // 两种模式都按正常间隔走：必做不影响节奏（按额度里它决定的是「还出不出门」）
+    const gapMs = this.autoGapMs();
+    // tick 里有 40% 概率跳过（只发生在按次数模式下），按期望 1/0.6 折算，
     // 不然显示的时间永远比实际早一截
-    const gap = this.autoGapMs() / 0.6;
-    let at = last ? last + gap : Date.now() + 90 * 1000;
+    const skip = mode === 'sessions';
+    const expect = skip ? gapMs / 0.6 : gapMs;
+    let at = last ? last + expect : Date.now() + 90 * 1000;
     at = this.nextOutingWindow(Math.max(at, Date.now()));
-    return { done: false, used, cap, gapMinutes: Math.round(this.autoGapMs() / 60000), at };
+    // 限流退避中：把「下次」推到歇完之后，不然面板显示「快出门了」却动不了
+    const wait = this.policy.rateWait();
+    if (wait.waiting) at = Math.max(at, wait.until);
+    return { ...base, done: false, at, gapMinutes: Math.round(gapMs / 60000) };
   }
 
   /** 自动出门只在 9:00-23:00；落在窗外就推到下一个 9:00。 */
@@ -5991,8 +6241,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,
@@ -6015,6 +6272,7 @@ export class StrollWorld {
         background: this.cfg.background !== false,
         approval: this.cfg.approval,
         autoSessionsPerDay: Number(this.cfg.autoSessionsPerDay ?? 0),
+        outingMode: this.outingMode(),
         outingFrom: Number(this.cfg.outingFrom ?? 9),
         outingTo: Number(this.cfg.outingTo ?? 23),
         dailyLikes: Number(this.cfg.dailyLikes ?? 0),

package/webui/client.js

@@ -738,8 +738,9 @@ export default {
         let liveWatch = null;
         let toastTimer = null;
         let lastPresenceKey = '';
-        // 关掉「自己出门」再打开时，恢复上次的次数，而不是硬塞成 1 次
+        // 关掉「自己出门」再打开时，恢复上次的次数/方式，而不是硬塞成 1 次
         let autoRemember = 5;
+        let autoRememberMode = 'sessions';
 
         function msgSet(text, bad = false) {
           msg.textContent = text || '';
@@ -838,7 +839,15 @@ export default {
           const rawComment = Number(cfg.dailyComments ?? caps.comment);
           const rawAuto = Number(cfg.autoSessionsPerDay ?? 0);
           const rawGap = Number(cfg.autoGapMinutes ?? 90);
-          const tail = rawAuto > 0 ? ` · 自己出门 ${rawAuto} 次（每 ${rawGap} 分钟一次）` : ' · 不自己出门';
+          const rawMode = String(cfg.outingMode ?? 'sessions');
+          const tail =
+            rawMode === 'off'
+              ? ' · 不自己出门'
+              : rawMode === 'quota'
+                ? ` · 按额度出门（每 ${rawGap} 分钟一次，做满就停）`
+                : rawAuto > 0
+                  ? ` · 自己出门 ${rawAuto} 次（每 ${rawGap} 分钟一次）`
+                  : ' · 不自己出门';
           activityNote.textContent =
             activityKey === 'custom'
               ? `自定义：每天 ${rawLike} 赞 / ${rawComment} 评${tail}`
@@ -894,24 +903,62 @@ export default {
           switchTrack.classList.toggle('on', bgOn);
           switchLabel.textContent = bgOn ? '后台模式' : '开窗模式';
           browseSwitch.setAttribute('aria-checked', String(bgOn));
+          const outingMode = String(cfg.outingMode ?? 'sessions');
+          if (outingMode !== 'off') autoRememberMode = outingMode;
+          const autoOn = outingMode !== 'off';
           const autoCap = Number(cfg.autoSessionsPerDay ?? 0);
           if (autoCap > 0) autoRemember = autoCap;
-          autoTrack.classList.toggle('on', autoCap > 0);
-          autoSwitch.setAttribute('aria-checked', String(autoCap > 0));
+          autoTrack.classList.toggle('on', autoOn);
+          autoSwitch.setAttribute('aria-checked', String(autoOn));
           const autoNext = data?.autoNext;
-          let autoText = autoCap > 0 ? `每天自己逛 ${autoCap} 次` : '关着，只在你叫的时候';
-          if (autoCap > 0) {
-            if (autoNext?.done) autoText += ' · 今天够了';
-            else if (autoNext?.at) {
-              const remainMs = Number(autoNext.at) - Date.now();
-              autoText += remainMs > 5 * 60 * 1000 ? ` · 下次约 ${hhmm(Number(autoNext.at))}` : ' · 快出门了';
+          const autoUsed = Number(data?.autoSessions ?? 0);
+          const quotaLeft = Number(autoNext?.quotaLeft ?? 0);
+          const quotaTotal = Number(autoNext?.quotaTotal ?? 0);
+          const quotaDone = Math.max(0, quotaTotal - quotaLeft);
+          let autoText = '关着，只在你叫的时候';
+          if (autoOn) {
+            if (outingMode === 'quota') {
+              // 按额度：目标项 = 勾了必做的那几项（没勾就按全部主动额度）
+              const targets = Array.isArray(autoNext?.targets) ? autoNext.targets : [];
+              const pendingText = targets.map((t) => `${t.label} ${t.left}`).join('、');
+              if (autoNext?.done && autoNext?.reason === 'budget') {
+                autoText = `按额度 · token 预算用完了（还差 ${pendingText || `${quotaLeft} 个`}）`;
+              } else if (autoNext?.done && autoNext?.reason === 'none') {
+                autoText = '按额度 · 没有能做的动作（看「公开动作」和是不是只读模式）';
+              } else if (autoNext?.done && autoNext?.reason === 'drafts') {
+                autoText = `按额度 · 还有 ${Number(autoNext?.drafts ?? 0)} 条草稿等你批，先不出门`;
+              } else if (quotaLeft <= 0) {
+                autoText = '按额度 · 目标做完了，今天收工';
+              } else {
+                autoText = `按额度 · 还差 ${pendingText || `${quotaLeft} 个`}`;
+                if (autoNext?.at) {
+                  const remainMs = Number(autoNext.at) - Date.now();
+                  autoText += remainMs > 5 * 60 * 1000 ? ` · 下次约 ${hhmm(Number(autoNext.at))}` : ' · 快出门了';
+                }
+              }
+            } else {
+              autoText = autoCap > 0 ? `按次数 · 每天自己逛 ${autoCap} 次` : '按次数 · 次数是 0，不会自己出门';
+              const effCap = Number(autoNext?.cap ?? autoCap);
+              if (autoCap > 0 && effCap < autoCap) autoText += `（token 预算只够 ${effCap} 次）`;
+              if (autoCap > 0) {
+                if (autoNext?.done) autoText += ' · 今天够了';
+                else if (autoNext?.at) {
+                  const remainMs = Number(autoNext.at) - Date.now();
+                  autoText += remainMs > 5 * 60 * 1000 ? ` · 下次约 ${hhmm(Number(autoNext.at))}` : ' · 快出门了';
+                }
+              }
             }
+            // 撞了 -509 会自己歇几分钟：面板上说清楚，别让主人以为她卡住了
+            const rateWait = p?.caps?.rateWait;
+            if (rateWait?.waiting) autoText += ` · 限流歇 ${Number(rateWait.minutes ?? 0)} 分钟`;
           }
           autoLabel.textContent = autoText;
           statReads.set(Number(data?.todayReads ?? 0), ' 条');
+          // 按次数看「出门几次」；按额度看「额度做了多少」，两边的分母不是一个东西
+          const autoShownCap = Number(autoNext?.cap ?? autoCap);
           statAuto.set(
-            autoCap > 0 ? `${Number(data?.autoSessions ?? 0)}/${autoCap}` : String(Number(data?.autoSessions ?? 0)),
-            autoCap > 0 ? ' 次' : ' 次 · 关着',
+            autoOn && outingMode === 'sessions' ? `${autoUsed}/${autoShownCap}` : String(autoUsed),
+            !autoOn ? ' 次 · 关着' : outingMode === 'quota' ? ` 次 · 额度 ${quotaDone}/${quotaTotal}` : ' 次',
           );
           // 这是「预算」（配置值），不是已用量；原来 Math.round(8600/1000) 会显示成 9k，看着像超了
           const budgetK = (Number(cfg.tokenDailyBudget ?? 0) / 1000).toFixed(1).replace(/\.0$/, '');
@@ -1297,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) {
@@ -2211,16 +2288,23 @@ export default {
         }
 
         async function toggleAuto() {
-          const cur = Number(lastData?.config?.autoSessionsPerDay ?? 0);
-          const next = cur > 0 ? 0 : autoRemember > 0 ? autoRemember : 5;
-          msgSet(cur > 0 ? '正在关掉自己出门…' : '正在开启自己出门…');
+          const cur = String(lastData?.config?.outingMode ?? 'sessions');
+          const turningOn = cur === 'off';
+          const next = turningOn ? autoRememberMode || 'sessions' : 'off';
+          msgSet(turningOn ? '正在开启自己出门…' : '正在关掉自己出门…');
           try {
-            const result = await ctx.invoke('set_auto', [next]);
+            // 按次数但次数是 0：顺手把次数填回去，不然开了等于没开
+            const needCount = turningOn && next === 'sessions' && Number(lastData?.config?.autoSessionsPerDay ?? 0) <= 0;
+            const result = needCount
+              ? await ctx.invoke('set_auto', [autoRemember > 0 ? autoRemember : 5])
+              : await ctx.invoke('set_outing', [next]);
             if (result?.ok === false) throw new Error(result.error || '没改成');
             msgSet(
-              cur > 0
+              !turningOn
                 ? '已关掉自己出门，只在你叫的时候逛。'
-                : `已开启：每天最多自己逛 ${next} 次，两次之间会隔一会儿。`,
+                : next === 'quota'
+                  ? '已开启：按额度出门，主动额度做满才收工。'
+                  : `已开启：每天最多自己逛 ${Number(lastData?.config?.autoSessionsPerDay ?? 5)} 次，两次之间会隔一会儿。`,
             );
             await refresh();
           } catch (error) {