cortico-world-mosey 2.0.3 → 2.1.0

package/CHANGELOG.md

@@ -1,9 +1,49 @@
 # 更新日志
 
-## 2.0.3
+## 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.3",
+  "version": "2.1.0",
   "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/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/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);
@@ -222,6 +263,22 @@ export class Policy {
     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 +305,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 +318,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 +339,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,8 @@ function blank() {
     actions: [],
     drafts: [],
     risk: { until: 0, reason: '', strikes: 0, lastCode: '' },
+    /** 限流退避（-509/429）：只拦她自己出门，不拦主人点的事。 */
+    softBackoff: { until: 0, at: 0, n: 0, reason: '' },
     lastWriteAt: 0,
     /** 每个平台各自的上次公开动作时间：抖音限流不该连带卡住 B站。 */
     lastWriteByPlat: {},
@@ -50,6 +52,7 @@ 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.stats = { ...blank().stats, ...(parsed.stats ?? {}) };
       for (const d of this.data.drafts) {
         if (d.status === 'sending') {
@@ -211,6 +214,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,27 @@ export class StrollWorld {
     this.log?.info?.('stroll migrate stranger pending', { before: list.length, after: next.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 +401,7 @@ export class StrollWorld {
   migrateConfig() {
     this.migrateStrangerKeys();
     this.migrateStrangerSeenEcho();
+    this.migrateOutingMode();
     this.refundDmLoopQuota();
     const done = this.store.data.migrated ?? {};
     if (done.dmQuota) return;
@@ -413,20 +438,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 +481,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 +603,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 +639,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',
     );
@@ -3044,7 +3190,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 +3248,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(),
       },
@@ -4474,7 +4627,7 @@ export class StrollWorld {
     }
     return (
       `「${s}」不在能发的目录里。现在只能发这几个目录里的图：\n${dirs.join('\n')}\n` +
-      '想放开别的目录：设置 → 高级与节奏 → 额外允许发图的目录，填绝对路径（逗号分隔）。'
+      '想放开别的目录：设置 → 高级 → 额外允许发图的目录，填绝对路径（逗号分隔）。'
     );
   }
 
@@ -5433,6 +5586,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 +5688,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] ?? '');
@@ -5825,22 +6000,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。 */
@@ -6015,6 +6220,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$/, '');
@@ -2211,16 +2258,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) {