feat(activity): 屏幕专注态搭话调度改固定间隔+后端抖动，竞技 skip 归零 (#1327)

* feat(activity): 屏幕专注态搭话调度改固定间隔+后端抖动，竞技类 skip_probability 归零

用户负面反馈：竞技对局是用户最长会话段，AI 30% 概率整轮静默打了陪伴产品命题的脸。
原 3-tier 退避会让间隔指数级增长到 60min 硬顶，叠加 skip_probability=0.3 后竞技
游戏期间几乎听不见 AI。改用：

  前端：propensity=restricted_screen_only 时跳过 tier backoff，重置 level=0，
        按 baseInterval 等间隔触发，不做前端抖动。模式切换由 /proactive_chat
        响应的 next_schedule_fixed_mode 字段反向通知（_end_proactive 统一注入）。
  后端：/proactive_chat 入口在 restricted_screen_only 时 sleep
        random.uniform(0, 0.5 * baseInterval)（兜底 60s 上限），把实际间隔
        抹成 [base, 1.5*base] 均匀分布，均值 1.25*base。
  默认：competitive 0.3 → 0（screen-only 安静感由新机制承担）；
        immersive_horror 保留 0.3（氛围比信息密度更怕打扰）。

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(activity): screen-only 抖动 sleep 让位给 must-fire 提醒，注释表达收紧

Codex P2 / CodeRabbit Major：focused_work 也走 restricted_screen_only，
而 anti_slack_pending / work_break_pending 是这个状态下的 must-fire 提醒，
本身时间敏感。原实现把抖动 sleep 放在 must-fire 分支之前，会让本该 ASAP
投递的提醒被随机延后最多 60s。修法：

  - 标志位 _next_schedule_fixed_mode 仍然总是设置（否则 must-fire 走
    _end_proactive 时响应里带回 False，前端误切回 tier backoff）
  - sleep 仅在 anti_slack_pending 与 work_break_pending 都为 None 时才执行

CodeRabbit Minor：activity_keywords.py 把 "base*1.25 + 后端抖动" 这种
易误读为"先乘 1.25 再叠抖动"的口语描述，改成精确的
"前端 base_interval + 后端 uniform(0, 0.5*base)"，并标注实际区间
[base, 1.5*base] 与 60s 上限。

CodeRabbit Low：voice mode 故意不带 base_interval_seconds 也不读
next_schedule_fixed_mode（语音 fast path 早退、本身固定间隔无 backoff），
原代码没说清，加注释记录设计意图。

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(proactive): 字段缺席时保留 fixed mode，避免短路响应踢出 fixed 调度

Codex P2 review (PR #1327): triggerProactiveChat 之前在 next_schedule_fixed_mode
缺席时硬重置成 false，但 409 try_start_proactive 冲突 / voice fast path /
game-route active 这些短路响应都不走 _end_proactive，自然拿不到这个字段——
而用户的活动状态没变，重置会让一次纯并发冲突就把客户端踢出 fixed 模式、
被 tier backoff 吞几轮。改成：只有显式收到 boolean 才同步，缺席时保留旧状态。

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(proactive): level 推进用本轮调度时捕获的 fixedMode，避免 fixed→tier 切换误升一级

CodeRabbit Minor (PR #1327): triggerProactiveChat() 内部会用响应里的
next_schedule_fixed_mode 同步 S.proactiveFixedScheduleMode；本轮的 level 推进
决策应该基于「这一 round 是按哪种模式调度的」而不是「返回后的最新模式」。
否则 fixed→tier 切换的那一跳会误升一级（本来按 fixed 走 delay=base、level=0，
却被升到 1），下一轮 tier 不能从干净的 base 起步。

修法：用循环顶部已捕获的局部 fixedMode，而不是被同步过的 S.proactiveFixedScheduleMode。

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Hongzhi Wen <cartabio.coder1@gmail.com>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 3 people

config/activity_keywords.py

@@ -298,10 +298,15 @@ class ClassifyResult:
 #
 # Tagged games drive propensity / skip_probability / tone derivation:
 #
-#   competitive            → propensity=restricted_screen_only, skip 0.3,
+#   competitive            → propensity=restricted_screen_only, skip 0.0,
 #                            tone=terse  (LoL team fight, CS round, etc.)
+#                            screen-only 的安静感由 /proactive_chat 的
+#                            前端固定 base_interval + 后端 uniform(0, 0.5*base)
+#                            抖动承担（实际间隔 [base, 1.5*base]，0.5*base 上限
+#                            兜底 60s）；skip 不再叠加。
 #   immersive horror       → propensity=restricted_screen_only, skip 0.3,
-#                            tone=hushed (silent hill, RE2, etc.)
+#                            tone=hushed (silent hill, RE2, etc.) —
+#                            氛围比信息密度更怕打扰，保留整轮 skip
 #   immersive (other)      → propensity=restricted_screen_only, skip 0.0,
 #                            tone=mellow (RPG, story-driven)
 #   casual                 → propensity=open, skip 0.0, tone=playful

docs/design/user-activity-tracker.md

@@ -115,13 +115,23 @@ Defaults are derived from `(state, intensity, genre)` in
 
 | Combo | Default skip |
 |---|---|
-| `gaming + competitive` (any genre) | 0.3 |
+| `gaming + competitive` (any genre) | 0.0 |
 | `gaming + immersive + horror` | 0.3 |
 | `gaming + immersive` (other genre) | 0.0 |
 | `gaming + casual` | 0.0 |
 | `gaming + varied` / untagged | 0.0 |
 | Non-gaming states | 0.0 |
 
+Note: `competitive` used to default to `0.3` but produced negative user
+feedback (the AI vanishing during the user's longest gaming sessions
+defeats the companion product thesis). The quietness for
+`restricted_screen_only` propensity is now handled by the
+fixed-interval scheduler branch in `static/app-proactive.js` plus a
+backend `[0, 0.5×baseInterval]` sleep in `proactive_chat` — see the
+`restricted_screen_only` block in `main_routers/system_router.py`. Only
+`immersive_horror` keeps the full-skip default (atmosphere is more
+sensitive to interruption than information density).
+
 User overrides via `user_preferences.json`'s
 `__global_conversation__::activity::skip_probability_overrides` take
 precedence — set `1.0` for "fully silent during this combo" or `0.0`

main_logic/activity/snapshot.py

@@ -433,13 +433,19 @@ def derive_tone(
 
 # ── Default skip_probability for gaming subtypes ───────────────────
 #
-# Source: design doc + user direction (concise: competitive, immersive
-# horror are the only two non-zero defaults; casual/immersive_rpg/varied
-# all stay at 0). User can shift via ``skip_probability_overrides``
-# in preferences. Keys are gaming-only; non-gaming states always have
-# default 0 (skip is not a propensity-strength choice for non-game).
+# Source: design doc + user direction. Only immersive_horror keeps a
+# non-zero default — atmospheric tension genuinely breaks on
+# interruption, so a probabilistic full-skip is worth it. Competitive
+# games used to have 0.3 here too but produced negative feedback (the
+# AI vanishing during the user's longest gaming sessions defeats the
+# companion product thesis); the quietness for restricted_screen_only
+# gaming now comes from the frontend-scheduler / backend-jitter path
+# instead (see proactive_chat in main_routers/system_router.py).
+# Casual / immersive_rpg / varied / competitive all stay at 0. User
+# can shift via ``skip_probability_overrides`` in preferences. Keys
+# are gaming-only; non-gaming states always have default 0 (skip is
+# not a propensity-strength choice for non-game).
 _DEFAULT_GAMING_SKIP_PROB: dict[tuple[GameIntensity, str | None], float] = {
-    ('competitive', None):     0.3,   # Any competitive game (genre doesn't refine further)
     ('immersive',   'horror'): 0.3,   # Atmospheric tension — interruption breaks immersion
     ('immersive',   None):     0.0,   # RPG / story — propensity already restricts to screen
     ('casual',      None):     0.0,   # Pause-anytime

main_routers/system_router.py

@@ -22,6 +22,7 @@
 import hashlib
 import hmac
 import ipaddress
+import json
 import math
 import random
 import re
@@ -4245,17 +4246,38 @@ async def proactive_chat(request: Request):
                 "state": mgr.state.snapshot(),
             }, status_code=409)
         _proactive_done_emitted = False
+        # Set after activity snapshot fetch — tells the frontend scheduler
+        # to skip the regular tier backoff and use a flat baseInterval on
+        # the next round (the backend will then inject a uniform
+        # [0, 0.5*baseInterval] sleep to provide the jitter). See the
+        # screen-only delay block further down and the matching
+        # ``S.proactiveFixedScheduleMode`` branch in static/app-proactive.js.
+        _next_schedule_fixed_mode = False
 
         async def _end_proactive(resp: JSONResponse) -> JSONResponse:
-            """包装所有 proactive 正常/短路退出：幂等地 fire PROACTIVE_DONE。"""
+            """包装所有 proactive 正常/短路退出：幂等地 fire PROACTIVE_DONE。
+
+            同时把 ``next_schedule_fixed_mode`` 注入响应体，前端读取后
+            决定下一轮调度走 tier backoff 还是固定 base interval。注入
+            发生在统一出口，新增的响应路径无需逐个修改。
+            """
             nonlocal _proactive_done_emitted
             if not _proactive_done_emitted:
                 _proactive_done_emitted = True
                 try:
                     await mgr.state.fire(_SE.PROACTIVE_DONE)
                 except Exception as _done_err:
                     logger.warning("[%s] PROACTIVE_DONE fire 异常: %s", lanlan_name, _done_err)
-            return resp
+            try:
+                body = json.loads(resp.body)
+            except Exception:
+                return resp
+            if not isinstance(body, dict):
+                return resp
+            if 'next_schedule_fixed_mode' in body:
+                return resp
+            body['next_schedule_fixed_mode'] = _next_schedule_fixed_mode
+            return JSONResponse(body, status_code=resp.status_code)
 
         def _proactive_preempted_json(where: str) -> dict:
             logger.info(
@@ -4371,6 +4393,50 @@ def _proactive_preempted_json(where: str) -> dict:
                 "message": f"user state={activity_snapshot.state} → closed (privacy lockdown)",
             }))
 
+        # ========== Screen-only：固定间隔 + 后端抖动 ==========
+        # 用户处于 gaming / focused_work（propensity=restricted_screen_only）
+        # 时，常规的前端 3-tier 退避会让搭话间隔指数级增长，跟陪伴产品
+        # 命题冲突（用户最长会话段反而最安静）。改用：
+        #   1. 前端 reset backoffLevel=0 并按 baseInterval 等间隔触发
+        #      （由响应里的 next_schedule_fixed_mode=True 通知前端切换）
+        #   2. 后端在 LLM 调用前 sleep uniform(0, 0.5 * baseInterval)，把每轮
+        #      实际间隔从 base 抹成 [base, 1.5*base] 的均匀分布
+        # 总效果：屏幕态平均间隔 ≈ 1.25*base，且有自然的随机抖动。
+        # skip_probability（仅 immersive_horror=0.3）作为正交机制保留。
+        #
+        # ⚠️ 标志位 vs sleep 拆开：anti_slack_pending / work_break_pending
+        # 是 focused_work 下的 must-fire 提醒（紧跟在下一段 4425+），本身
+        # 时间敏感，不能被这里的随机抖动延后。但前端 fixed_mode 标志位
+        # 仍然要设——否则 must-fire 走 _end_proactive 时响应里会带回
+        # next_schedule_fixed_mode=False，前端误切回 tier backoff，让用户
+        # 离开 must-fire 状态后又被退避机制吞掉一段时间。
+        # Codex P2 + CodeRabbit Major review。
+        if (
+            activity_snapshot is not None
+            and activity_snapshot.propensity == 'restricted_screen_only'
+        ):
+            _next_schedule_fixed_mode = True
+            _has_must_fire = (
+                activity_snapshot.anti_slack_pending is not None
+                or activity_snapshot.work_break_pending is not None
+            )
+            if _has_must_fire:
+                print(f"[{lanlan_name}] propensity=restricted_screen_only 但有 must-fire 提醒待发，跳过本轮抖动 sleep")
+            else:
+                try:
+                    _base_interval_raw = data.get('base_interval_seconds')
+                    _base_interval = float(_base_interval_raw) if _base_interval_raw is not None else 0.0
+                except (TypeError, ValueError):
+                    _base_interval = 0.0
+                # 上限兜底：base 过大时把 0.5*base 截到 60s，避免极端配置
+                # （比如 user 把 proactiveChatInterval 调到 300s）让后端
+                # 单请求占连接十分钟。
+                if _base_interval > 0:
+                    _jitter_max = min(_base_interval * 0.5, 60.0)
+                    _jitter = random.uniform(0.0, _jitter_max)
+                    print(f"[{lanlan_name}] propensity=restricted_screen_only, 后端注入 {_jitter:.2f}s 间隔抖动（base={_base_interval:.1f}s）")
+                    await asyncio.sleep(_jitter)
+
         # ========== Must-fire: break-reminder branches ==========
         # Anti-slack outranks water-break (transition trigger more
         # time-sensitive than the cumulative one). Both bypass Phase 1

static/app-proactive.js

@@ -543,6 +543,14 @@
         //
         // 单调性: 固定 M1 使 delay(T) ≈ base + T×(M1-1)，
         //         ∂delay/∂base = 1 > 0，base 越高期望 delay 越高。
+        //
+        // ── 固定间隔分支 (proactiveFixedScheduleMode) ──
+        // 当后端 propensity=restricted_screen_only（屏幕专注态：gaming /
+        // focused_work）时，常规退避会让搭话间隔指数级增长，跟陪伴产品
+        // 命题冲突。前端跳过 tier backoff，按 baseInterval 等间隔触发，
+        // 后端在 /proactive_chat 入口注入 [0, 0.5×base] sleep 把实际间隔
+        // 抹成 [base, 1.5×base] 均匀分布。详见 main_routers/system_router.py
+        // 的 restricted_screen_only 处理段。
 
         var baseInterval = S.proactiveChatInterval;
         var BACKOFF_TARGET = 120;
@@ -562,10 +570,18 @@
         var cap1 = caps.cap1;
         var cap2 = caps.cap2;
 
+        var fixedMode = !!S.proactiveFixedScheduleMode;
         var level = S.proactiveChatBackoffLevel;
         var delay;
 
-        if (level < cap1) {
+        if (fixedMode) {
+            // 屏幕专注态：跳过 tier backoff，重置 level，按 baseInterval 等间隔
+            // 触发。抖动完全交给后端（[0, 0.5×base] sleep），前端不做乘性抖动，
+            // 否则两层叠加会让方差大于设计目标。
+            S.proactiveChatBackoffLevel = 0;
+            level = 0;
+            delay = baseInterval * 1000;
+        } else if (level < cap1) {
             // Tier 1: base × M1^level，确定性爬升
             delay = (baseInterval * 1000) * Math.pow(BACKOFF_M1, level);
         } else {
@@ -576,7 +592,10 @@
         }
 
         // 对 delay 做 ±12% 乘性随机抖动，避免节奏过于机械
-        delay *= 1 + (Math.random() - 0.5) * 0.24;
+        // 固定模式下抖动由后端注入，前端不再叠加
+        if (!fixedMode) {
+            delay *= 1 + (Math.random() - 0.5) * 0.24;
+        }
 
         // 首次启动时额外等待 6 秒，避免程序刚启动就触发音乐推荐。
         // 用一次性 flag 而非 backoffLevel === 0 —— 后者在 user_input reset 或
@@ -589,12 +608,18 @@
         }
         delay += startupDelay;
 
+        // 输入放缓 floor 跟 fixed/tier 模式正交：用户在打字时不该被主动搭话打断，
+        // 不管处于屏幕专注态还是常规态。两边都套这个下限。
         var inputSlowdownDelay = _getChatInputSlowdownDelay(baseInterval);
         if (inputSlowdownDelay > 0) {
             delay = Math.max(delay, inputSlowdownDelay);
         }
 
-        console.log('主动搭话：' + (delay / 1000).toFixed(1) + '秒后触发（基础间隔：' + baseInterval + '秒，退避级别：' + level + '，cap1：' + cap1 + '，cap2：' + cap2 + '，启动延迟：' + (startupDelay / 1000) + '秒，输入放缓：' + (inputSlowdownDelay ? ((inputSlowdownDelay / 1000) + '秒') : '无') + '）');
+        if (fixedMode) {
+            console.log('主动搭话：' + (delay / 1000).toFixed(1) + '秒后触发（屏幕专注态固定间隔，base=' + baseInterval + 's，level 已重置，后端注入抖动，启动延迟：' + (startupDelay / 1000) + '秒，输入放缓：' + (inputSlowdownDelay ? ((inputSlowdownDelay / 1000) + '秒') : '无') + '）');
+        } else {
+            console.log('主动搭话：' + (delay / 1000).toFixed(1) + '秒后触发（基础间隔：' + baseInterval + '秒，退避级别：' + level + '，cap1：' + cap1 + '，cap2：' + cap2 + '，启动延迟：' + (startupDelay / 1000) + '秒，输入放缓：' + (inputSlowdownDelay ? ((inputSlowdownDelay / 1000) + '秒') : '无') + '）');
+        }
 
         S.proactiveChatTimer = setTimeout(async function () {
             // 双重检查锁：定时器触发时再次检查是否正在执行
@@ -628,7 +653,16 @@
             //   tier 1 (level < cap1): 每次必升 — 确定性爬升阶段
             //   tier 2 (cap1 ≤ level < cap2): 9% 概率升级 — 慢区，长时间停留
             //   tier 3 (level ≥ cap2): 每次必升 — 快区，快速逼近 60min 硬顶
-            if (triggered) {
+            // 屏幕专注态固定模式下不动 level（由 next_schedule_fixed_mode
+            // 反向通知后续 reset），让用户离开屏幕态回到常规态时 backoff
+            // 不会带着旧值。
+            //
+            // ⚠️ 用本轮调度时捕获的 ``fixedMode`` 而非已被响应同步过的
+            // ``S.proactiveFixedScheduleMode``：本轮的 level 推进决策应该基于
+            // 「这一 round 是按哪种模式调度的」而不是「返回后的最新模式」。
+            // 否则 fixed → tier 切换的那一跳会误升一级，下一轮 tier 不能从
+            // 干净的 base 起步。CodeRabbit Minor review: PR #1327。
+            if (triggered && !fixedMode) {
                 var currentCaps = computeBackoffCaps(S.proactiveChatInterval);
                 var currentCap1 = currentCaps.cap1;
                 var currentCap2 = currentCaps.cap2;
@@ -714,6 +748,11 @@
                     voiceModes.push('vision');
                 }
                 console.log('[ProactiveChat] 语音模式快速路径，modes: [' + voiceModes.join(', ') + ']');
+                // 故意不带 base_interval_seconds / 不读 next_schedule_fixed_mode：
+                // 语音模式在后端走 voice fast path（system_router.py 4222 行附近），
+                // 在 propensity / restricted_screen_only / 抖动 sleep 这一整套门
+                // 之前就早退；语音 scheduler 自己也是固定 baseInterval 不带 backoff。
+                // 既然两边都不读，发了也是冗余字段。
                 var resp = await fetch('/api/proactive_chat', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
@@ -823,7 +862,11 @@
                 // mini-game 邀请的用户级 toggle；后端 _maybe_deliver_mini_game_invite
                 // 与 source-driven sources 解耦，不进 enabled_modes 数组。
                 mini_game_invite_enabled: !!S.proactiveMiniGameInviteEnabled,
-                i18n_language: i18nLanguage
+                i18n_language: i18nLanguage,
+                // 屏幕专注态后端会按 [0, 0.5×base] 注入间隔抖动，需要知道
+                // 当前用户配置的 baseInterval。后端 propensity 非屏幕专注态
+                // 时忽略此字段。
+                base_interval_seconds: S.proactiveChatInterval
             };
 
             // 独立计时器：确保 vision/window 模式的屏幕感知间隔不低于 proactiveVisionInterval
@@ -984,6 +1027,20 @@
 
             var result = await response.json();
 
+            // 同步下一轮调度模式：后端在 propensity=restricted_screen_only
+            // 时会把这个字段置 true，前端 scheduleProactiveChat 据此跳过
+            // tier backoff、按 baseInterval 等间隔触发。
+            //
+            // 字段缺席 ≠ 模式应该回退。短路响应路径（409 try_start_proactive
+            // 冲突、voice fast path、game-route active 早退）都不走 _end_proactive，
+            // 也就拿不到这个字段——但用户的活动状态没变，把模式硬重置成 false
+            // 会让一次并发冲突就把客户端踢出 fixed 模式、被 tier backoff 吞几轮。
+            // 改为：只有显式收到 boolean 才同步，缺席时保留旧状态。
+            // Codex P2 review: PR #1327。
+            if (typeof result.next_schedule_fixed_mode === 'boolean') {
+                S.proactiveFixedScheduleMode = result.next_schedule_fixed_mode;
+            }
+
             if (result.success) {
                 if (result.action === 'chat') {
                     console.log('主动搭话已发送:', result.message, result.source_mode ? '(来源: ' + result.source_mode + ')' : '');

static/app-state.js

@@ -140,6 +140,12 @@
         mergeMessagesEnabled: false,
         proactiveChatTimer: null,
         proactiveChatBackoffLevel: 0,
+        // 屏幕专注态（gaming / focused_work，后端 propensity=restricted_screen_only）
+        // 切到「固定间隔 + 后端抖动」调度：跳过 3-tier 退避，按 baseInterval
+        // 等间隔触发，后端 /proactive_chat 入口注入 [0, 0.5×base] 的 sleep
+        // 把实际间隔抹成 [base, 1.5×base] 均匀分布。由 /proactive_chat 响应里的
+        // next_schedule_fixed_mode 字段控制开关；默认 false（即走常规退避）。
+        proactiveFixedScheduleMode: false,
         _voiceProactiveNoResponseCount: 0,
         _voiceSessionInitialTimer: null,
         isProactiveChatRunning: false,

tests/test_activity_tracker_followup.py

@@ -450,8 +450,10 @@ def test_skip_probability_defaults():
     assert derive_skip_probability('chatting') == 0.0
     assert derive_skip_probability('idle') == 0.0
 
-    # Gaming defaults
-    assert derive_skip_probability('gaming', game_intensity='competitive') == pytest.approx(0.3)
+    # Gaming defaults — competitive intentionally dropped to 0 (was 0.3).
+    # 屏幕专注态的安静感现在由 /proactive_chat 的 base-interval×1.25 + 后端
+    # 抖动机制承担，skip_probability 只留 immersive_horror 这一例外。
+    assert derive_skip_probability('gaming', game_intensity='competitive') == 0.0
     assert derive_skip_probability(
         'gaming', game_intensity='immersive', game_genre='horror',
     ) == pytest.approx(0.3)