feat(monitor): 抖音 Web 接口客户端 —— 绕开爬虫子进程，直接发 HTTP

移植自 mac-agent-os 的 mediacrawler_adapter：不起子进程、不开页面，用浏览器里那份
登录态直接调抖音 Web 接口。产物键名照抄 store/douyin，所以 ingest 那条链路一个字不用改。

**目前能用的（真环境实测，非推断）**：

    profile/other : 200, 7075 字节  —— 博主主页指标（粉丝/获赞/作品数/昵称）
    aweme/detail  : 200, 45425 字节 —— 单条作品详情（含点赞/评论/收藏/分享）

**目前不能用的：作品列表 `aweme/post`。** 两个互相独立的原因：
  1. 这个接口被抖音单独升级成了真校验：不带 x-tt-argus 回 403「Uifid Not Found」，
     带上 dummy 值回 200 + **空 body**。也就是说「头在不在」骗得过，「真校验」过不了。
     同一套头打 profile/other 和 aweme/detail 都是通的 —— 抖音是挑着接口加保护的，
     挑中的恰好是「批量拉作品列表」这个最敏感的动作。
  2. 改走页面截获也不行：CDP 浏览器打开博主主页会落到「验证码中间页」（当天大量探测的
     代价，过几小时要重测）。

  所以现在的边界是：**已知作品的指标刷新能做，自动发现新作品做不了**。

**排查中控住变量后得到的两条事实**（都写进注释了）：
  · `Accept` / `Accept-Language` / `Referer` 才是主页接口能返回真数据的原因 —— 只有
    UA+client hints+Cookie 时是 200 但仅 121 字节的空壳，补上这三个头变 7074 字节。
    （我先前猜的 sec-ch-ua 不是关键。）
  · 因此 UA 与 client hints 必须**成套地取自同一个浏览器**，所以 BrowserIdentity 一次
    从 CDP 取齐 cookie + UA + hints，而不是各自写死。

「200 + 空 body 必须当场报错」也是刻意写死的：放过去它会在下游变成「这个博主没作品」，
把一次失败伪装成一条正常结果 —— 爬虫那条路正是这么栽的，还被翻译成「账号被封」。

测试 +11：cookie 解析、请求头成套性（含 uifid 缺失/回退）、产物键名与 store 对齐、
以及 _get 的三条失败路径（空 body / 403 带网关原话 / 正常返回）。

mac-agent-os-main/05_tools/07_matrix/scripts/mc/engine.py

@@ -0,0 +1,718 @@
+"""
+engine.py — mc run 执行引擎（v5.3 — 身份共享 + 多平台同浏览器）
+
+核心逻辑：
+  1. 按 identity_dir 分组账号 → 同身份共用一个浏览器
+  2. 每个浏览器内先做完抖音，再做小红书
+  3. 不同身份组之间错峰启动（防假死）
+  4. 每个账号在其平台上顺序执行蓝图
+"""
+import asyncio
+import json
+import logging
+import os
+import random
+import subprocess
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+log = logging.getLogger(__name__)
+
+SCRIPTS_DIR = Path(__file__).resolve().parent.parent
+TOOL_DIR = SCRIPTS_DIR.parent
+from matrix_mgmt import AGENT_SYNC, AGENT_LOCAL
+
+IDENTITIES_ROOT = AGENT_LOCAL / "tools" / "matrix" / "identities"
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+
+# ════════════════════════════════════════════════════════════
+# 工具函数
+# ════════════════════════════════════════════════════════════
+
+def resolve_account(account_id: str) -> dict:
+    from matrix_mgmt import MatrixManager
+    mgr = MatrixManager()
+    for a in mgr.list_accounts():
+        if a["id"] == account_id:
+            return a
+    raise ValueError(f"账号不存在: {account_id}")
+
+
+def resolve_blueprint(name: str) -> Optional[dict]:
+    bp_dir = TOOL_DIR / "blueprints"
+    # 长名字优先（避免 douyin_daily 被子串匹配到 douyin_daily_clean）
+    for f in sorted(bp_dir.glob("*.json"), key=lambda p: -len(p.stem)):
+        bp = json.loads(f.read_text())
+        if name in (bp.get("id", ""), bp.get("name", ""), f.stem):
+            return bp
+        if name in f.stem or f.stem in name:
+            return json.loads(f.read_text())
+    return None
+
+
+def merge_blueprints(names: str) -> Optional[dict]:
+    """组合蓝图：把多个蓝图（+ 分隔）合并为一个执行序列
+
+    规则：
+      1. 第一个 goto_url 保留，后续蓝图的 goto_url 跳过（页面已在目标视频）
+      2. 连续 wait/wait_watch 合并（取较大 seconds）
+    """
+    bps = []
+    for n in names.split("+"):
+        bp = resolve_blueprint(n.strip())
+        if bp:
+            bps.append(bp)
+    if not bps:
+        return None
+    merged_steps = []
+    seen_url_goto = False
+    prev_was_wait = False
+    for bp in bps:
+        for s in bp.get("steps", []):
+            op = s.get("op", "")
+            if op == "goto_url":
+                if seen_url_goto:
+                    continue  # 已在目标视频，跳过重复导航
+                seen_url_goto = True
+                prev_was_wait = False
+                merged_steps.append(s)
+            elif op in ("wait", "wait_watch"):
+                if prev_was_wait:
+                    # 合并连续等待：保留较大 seconds
+                    try:
+                        prev_s = float((merged_steps[-1].get("args", {}) or {}).get("seconds") or 0)
+                        cur_s = float((s.get("args", {}) or {}).get("seconds") or 0)
+                        merged_steps[-1]["args"]["seconds"] = max(prev_s, cur_s)
+                    except Exception:
+                        pass
+                    continue
+                prev_was_wait = True
+                merged_steps.append(s)
+            else:
+                prev_was_wait = False
+                merged_steps.append(s)
+    return {
+        "id": "+".join(b["id"] for b in bps),
+        "name": "+".join(b["name"] for b in bps),
+        "description": "组合蓝图（多动作连做）",
+        "platform": bps[0].get("platform", "douyin"),
+        "steps": merged_steps,
+    }
+
+
+def check_cookie(identity_hint: str) -> str:
+    """检查身份目录 cookie 状态 → 'ok'|'no_cookie'|'expired'|'no_identity'"""
+    if not identity_hint:
+        return "no_identity"
+    ident_dir = IDENTITIES_ROOT / identity_hint
+    if not ident_dir.exists():
+        return "no_identity"
+    ck = ident_dir / "user_data" / "cookies.sqlite"
+    if not ck.exists() or ck.stat().st_size < 100:
+        return "no_cookie"
+    try:
+        import sqlite3
+        conn_ck = sqlite3.connect(str(ck), timeout=2)
+        cnt = conn_ck.execute("SELECT count(*) FROM moz_cookies WHERE name LIKE '%session%'").fetchone()[0]
+        conn_ck.close()
+        return "ok" if cnt > 0 else "expired"
+    except:
+        return "error"
+
+
+def group_accounts_by_identity(account_ids: List[str]) -> dict:
+    """按 identity_dir 分组账号，同目录的放到一个组里"""
+    groups = {}
+    for aid in account_ids:
+        try:
+            info = resolve_account(aid)
+        except ValueError:
+            continue
+        ident = info.get("identity_dir", aid).replace("identities/", "")
+        groups.setdefault(ident, []).append(info)
+    return groups
+
+
+# ════════════════════════════════════════════════════════════
+# 执行报告
+# ════════════════════════════════════════════════════════════
+
+class StepResult:
+    def __init__(self, op: str, step_id: int, success: bool = True,
+                 duration: float = 0, error: str = ""):
+        self.op = op; self.step_id = step_id; self.success = success
+        self.duration = duration; self.error = error
+
+    def __str__(self):
+        icon = "✅" if self.success else "❌"
+        return f"{icon} [{self.step_id:2d}] {self.op:20s} ({self.duration:.1f}s) {self.error}"
+
+
+class AccountRunReport:
+    def __init__(self, account: str, blueprint: str, round_idx: int):
+        self.account = account; self.blueprint = blueprint; self.round = round_idx
+        self.steps: List[StepResult] = []; self.start = time.time()
+        self.success = 0; self.failed = 0; self.skipped = False
+
+    @property
+    def duration(self) -> float: return time.time() - self.start
+
+    def add_step(self, result: StepResult):
+        self.steps.append(result)
+        if result.success: self.success += 1
+        else: self.failed += 1
+
+    def to_dict(self) -> dict:
+        return {"account": self.account, "blueprint": self.blueprint,
+                "round": self.round, "success": self.success, "failed": self.failed,
+                "skipped": self.skipped, "duration": round(self.duration, 1),
+                "steps": [{"op": s.op, "step_id": s.step_id, "success": s.success,
+                           "duration": round(s.duration, 1), "error": s.error} for s in self.steps]}
+
+
+class BatchReport:
+    def __init__(self):
+        self.accounts: List[str] = []; self.blueprints: List[str] = []
+        self.rounds_total = 0; self.mix_mode = False
+        self.start = time.time(); self.account_reports: List[AccountRunReport] = []
+        self.error: Optional[str] = None
+
+    @property
+    def duration(self) -> float: return time.time() - self.start
+    @property
+    def success(self) -> int: return sum(r.success for r in self.account_reports)
+    @property
+    def failed(self) -> int: return sum(r.failed for r in self.account_reports)
+    @property
+    def skipped(self) -> int: return sum(1 for r in self.account_reports if r.skipped)
+
+    def to_dict(self) -> dict:
+        return {"accounts": self.accounts, "blueprints": self.blueprints,
+                "rounds": self.rounds_total, "mix_mode": self.mix_mode,
+                "duration": round(self.duration, 1),
+                "total_steps": self.success + self.failed,
+                "success": self.success, "failed": self.failed,
+                "skipped": self.skipped,
+                "account_reports": [r.to_dict() for r in self.account_reports],
+                "error": self.error}
+
+
+# ════════════════════════════════════════════════════════════
+# 核心引擎
+# ════════════════════════════════════════════════════════════
+
+# 平台→默认蓝图映射（当不传蓝图时自动匹配）
+PLATFORM_BLUEPRINTS = {
+    "douyin": "douyin_read_profile",
+    "xiaohongshu": "xiaohongshu_read_profile",
+}
+PLATFORM_DAILY_BLUEPRINTS = {
+    "douyin": "douyin_daily",
+    "xiaohongshu": "xhs_daily",
+}
+
+
+class BatchEngine:
+    def __init__(self, accounts: List[str], blueprints: List[str] = None,
+                 rounds: int = 10, mix: bool = False,
+                 corpus: List[str] = None,
+                  stagger: str = "15-30",
+                  keep_open: bool = False,
+                  max_browsers: int = 3,
+                  run_id: str = "",
+                  task_params: dict = None):
+        self.accounts = accounts
+        self.blueprints = blueprints or []
+        self.rounds_total = rounds
+        self.mix = mix
+        self.corpus = corpus or []
+        self.stagger = stagger
+        self.keep_open = keep_open
+        self.max_browsers = max_browsers
+        self.run_id = run_id
+        self.task_params = task_params or {}
+
+    def _mark_banned(self, account_id: str, platform: str):
+        """将账号标记为封号状态，写入 profiles.json"""
+        try:
+            from pathlib import Path
+            home = Path.home()
+            profiles_path = home / "workbuddy-agent-os" / "agent-local" / "tools" / "matrix" / "data" / "profiles.json"
+            if profiles_path.exists():
+                import json
+                all_p = json.loads(profiles_path.read_text())
+            else:
+                all_p = {}
+            all_p[account_id] = {
+                "nickname": all_p.get(account_id, {}).get("nickname", "?"),
+                "fans": "0", "following": "0", "likes": "0", "posts": "0", "bio": "",
+                "status": "banned",
+                "platform": platform,
+                "updated": __import__("time").strftime("%Y-%m-%dT%H:%M:%S"),
+            }
+            profiles_path.parent.mkdir(parents=True, exist_ok=True)
+            profiles_path.write_text(json.dumps(all_p, ensure_ascii=False, indent=2))
+            log.warning(f"  🚫 [{account_id}] 已写入封号标记到 profiles.json")
+        except Exception as e:
+            log.warning(f"  ❌ [{account_id}] 写入封号标记失败: {e}")
+
+    def _pick_blueprint(self, round_idx: int) -> str:
+        if not self.blueprints:
+            return ""  # 由 _run_acct_on_conn 按平台自动匹配
+        if self.mix:
+            return random.choice(self.blueprints)
+        return self.blueprints[(round_idx - 1) % len(self.blueprints)]
+
+    def _resolve_args(self, sargs: dict, account_id: str, platform: str) -> dict:
+        """解析蓝图步骤中的占位符，替换为实际内容"""
+        import copy
+        resolved = copy.deepcopy(sargs)
+        for k, v in resolved.items():
+            if not isinstance(v, str):
+                continue
+            if "@corpus" in v:
+                # 优先使用命令行/计划指定的评论内容（--comment-text），未指定才从语料库随机取
+                ct = (self.task_params.get("comment_text") or "").strip()
+                if ct:
+                    resolved[k] = v.replace("@corpus", ct)
+                else:
+                    from mc.corpus import CorpusManager
+                    cm = CorpusManager()
+                    direction = resolved.get("direction", "") or self.task_params.get("direction", "")
+                    text = cm.get_comment_for_video(
+                        video_title=self.task_params.get("keyword", ""),
+                        direction=direction,
+                        account_id=account_id,
+                    )
+                    resolved[k] = v.replace("@corpus", text)
+            if "@keyword" in v:
+                kw = self.task_params.get("keyword", "")
+                resolved[k] = v.replace("@keyword", kw)
+            if "@direction" in v:
+                dr = self.task_params.get("direction", "")
+                resolved[k] = v.replace("@direction", dr)
+            if "@url" in v:
+                url = self.task_params.get("url", "")
+                resolved[k] = v.replace("@url", url)
+            if "@comment_text" in v:
+                ct = self.task_params.get("comment_text", "")
+                if ct:
+                    resolved[k] = v.replace("@comment_text", ct)
+            if "@reply_text" in v:
+                rt = self.task_params.get("reply_text", "")
+                if rt:
+                    resolved[k] = v.replace("@reply_text", rt)
+            if "@my_code" in v:
+                mc = self.task_params.get("my_code", "")
+                if mc:
+                    resolved[k] = v.replace("@my_code", mc)
+            if "@target_code" in v:
+                tc = self.task_params.get("target_code", "")
+                if tc:
+                    resolved[k] = v.replace("@target_code", tc)
+            if "@scene" in v:
+                scene = self.task_params.get("scene", "first_comment")
+                from mc.corpus import CorpusManager
+                cm = CorpusManager()
+                text = cm.get_comment_for_scene(
+                    persona=self.task_params.get("persona", ""),
+                    scene=scene,
+                    keyword=self.task_params.get("keyword", ""),
+                    round_num=self.task_params.get("round_num", 1),
+                )
+                if text:
+                    resolved[k] = v.replace("@scene", text)
+        return resolved
+
+    async def _run_acct_on_conn(self, account_info: dict, blueprint_name: str,
+                                 round_idx: int, conn) -> AccountRunReport:
+        """在已有浏览器连接上执行单个账号的单个轮次"""
+        account_id = account_info["id"]
+        platform = account_info.get("platform", "douyin")
+
+        # 没传蓝图时按平台自动匹配（支持不同平台账号同一次批量执行）
+        if not blueprint_name:
+            blueprint_name = PLATFORM_BLUEPRINTS.get(platform, "douyin_read_profile")
+        report = AccountRunReport(account_id, blueprint_name, round_idx)
+
+        # 组合蓝图（+ 分隔）：合并多个蓝图为同一视频连做序列
+        if "+" in blueprint_name:
+            bp = merge_blueprints(blueprint_name)
+            log.info(f"  🧬 组合蓝图: {blueprint_name} → {len(bp['steps']) if bp else 0} 步")
+        else:
+            bp = resolve_blueprint(blueprint_name)
+        # 蓝图与账号平台不匹配→自动切换（例如xhs账号用了douyin_daily_clean）
+        if bp and bp.get("platform") and bp["platform"] != platform:
+            old_bp = blueprint_name
+            blueprint_name = PLATFORM_DAILY_BLUEPRINTS.get(platform, blueprint_name)
+            log.info(f"  🔄 蓝图 [{old_bp}] 与平台 [{platform}] 不匹配，自动切换为 [{blueprint_name}]")
+            bp = resolve_blueprint(blueprint_name)
+        if not bp:
+            report.skipped = True
+            return report
+        steps = bp.get("steps", [])
+        log.info(f"  📱 {account_id} ({platform}) → {blueprint_name} ({len(steps)}步)")
+
+        # ── 平台区分：导航到不同入口再检测登录 ──
+        if platform == "xiaohongshu":
+            # 小红书：导航到 explore 首页，依赖 Cookie 检测
+            try:
+                await conn.page.goto("https://www.xiaohongshu.com/explore",
+                                     timeout=30000, wait_until="domcontentloaded")
+                await asyncio.sleep(5)
+            except:
+                await conn.page.goto("https://www.xiaohongshu.com/explore",
+                                     timeout=60000, wait_until="load")
+                await asyncio.sleep(5)
+        else:
+            # 抖音：导航到 user/self 强制触发登录弹窗（受保护页面，未登录必弹）
+            # 避免在首页等待弹窗随机出现导致检测不稳定
+            try:
+                await conn.page.goto("https://www.douyin.com/user/self",
+                                     timeout=30000, wait_until="domcontentloaded")
+                await asyncio.sleep(6)
+            except:
+                await conn.page.goto("https://www.douyin.com/user/self",
+                                     timeout=60000, wait_until="load")
+                await asyncio.sleep(6)
+
+        # ── 钩子1: 登录状态检测（执行前确保登录）──
+        if bp and bp.get("skip_sms"):
+            from matrix_modules.account.login_state_machine import (
+                LoginStateMachine, RecoveryChain, CookieRecovery, VisualRecovery
+            )
+            lsm = LoginStateMachine(recovery_chain=RecoveryChain(steps=[
+                CookieRecovery(),
+                VisualRecovery(),
+            ]))
+        else:
+            from matrix_modules.account.login_state_machine import LoginStateMachine
+            lsm = LoginStateMachine()
+        phone = None
+        login_ok = await lsm.ensure_login(conn.page, account_id, platform)
+        # skip_sms 模式：登录后立即检查是否有 SMS 弹窗（服务器主动触发）
+        if login_ok and bp and bp.get("skip_sms"):
+            sms_popup = await lsm.check_verify_dialog(conn.page)
+            if sms_popup == "sms":
+                log.warning(f"  ⏭️ [{account_id}] 服务器弹出短信验证，skip_sms 跳过，关闭浏览器")
+                await conn.close()
+                return report
+        if not login_ok:
+            # 检测是否被封号
+            if hasattr(lsm, 'last_status') and lsm.last_status == 'banned':
+                log.warning(f"  🚫 [{account_id}] 账号被封禁，写入标记")
+                self._mark_banned(account_id, platform)
+            else:
+                log.warning(f"  ❌ [{account_id}] 登录检测不通过，跳过本轮")
+            report.skipped = True
+            return report
+
+        # 创建 platform ops
+        if platform == "xiaohongshu":
+            from ops.xhs_ops import XhsOps
+            ops = XhsOps(conn.page)
+        else:
+            from douyin_ops import DouyinOps
+            ops = DouyinOps(conn.page)
+        print(f"[engine] set_account_id({account_id}) for platform={platform}")
+        ops.set_account_id(account_id)
+
+        # 抖音：进入视频播放
+        # 如果蓝图第一步是 goto_url(@url)，用户提供了目标 URL，
+        # 跳过 open_video 预调用（避免点开随机视频又导航走，浪费时间）
+        _needs_open_video = True
+        if steps and steps[0].get("op") == "goto_url":
+            _args = steps[0].get("args", {})
+            _url_arg = _args.get("url", "")
+            if "@url" in _url_arg:
+                _needs_open_video = False
+                log.info(f"  ⏭️ 跳过 open_video（蓝图第一步使用 @url 跳转到目标视频）")
+        if platform == "douyin" and _needs_open_video:
+            await ops.execute("open_video")
+
+        # 执行步骤
+        for i, step in enumerate(steps):
+            sn = step.get("step_id", i + 1)
+            op_name = step.get("op", "")
+            sargs = self._resolve_args(step.get("args", {}), account_id, platform)
+            result = await ops.execute(op=op_name, args=sargs, step_id=sn)
+            report.add_step(StepResult(op_name, sn, result.success, result.elapsed,
+                                       "" if result.success else result.error))
+            icon = "✅" if result.success else "❌"
+            log.info(f"    {icon} [{sn:2d}] {op_name:18s} → {result.detail[:25]} ({result.elapsed:.1f}s)")
+
+            # ── 钩子2: 操作后检查验证弹窗 + 登录态检查 ──
+            verify_type = await lsm.check_verify_dialog(conn.page)
+            if verify_type == "login_required":
+                log.warning(f"    🔑 [{account_id}] 登录态丢失（页面重定向到登录页），恢复中...")
+                # 尝试恢复登录态，最多重试2次
+                recovered = False
+                for retry in range(2):
+                    if retry > 0:
+                        log.info(f"    🔄 [{account_id}] 登录恢复重试 ({retry+1}/2)...")
+                    ok = await lsm.ensure_login(conn.page, account_id, platform)
+                    if ok:
+                        recovered = True
+                        break
+                    await asyncio.sleep(3)
+                if recovered:
+                    log.info(f"    ✅ [{account_id}] 登录恢复成功，重试当前操作 [{sn}]")
+                    # 重试当前失败的步骤
+                    result = await ops.execute(op=op_name, args=sargs, step_id=sn)
+                    report.add_step(StepResult(op_name, sn, result.success, result.elapsed,
+                                               "" if result.success else result.error))
+                    icon = "✅" if result.success else "❌"
+                    log.info(f"    {icon} [{sn:2d}] {op_name:18s} → {result.detail[:25]} (重试, {result.elapsed:.1f}s)")
+                else:
+                    log.warning(f"    ❌ [{account_id}] 登录恢复失败，跳过当前操作 [{sn}]")
+            elif verify_type == "quick_login":
+                log.warning(f"    🔑 [{account_id}] 检测到一键登录弹窗，点击一键登录...")
+                try:
+                    await conn.page.locator('text="一键登录"').click(timeout=5000)
+                    await asyncio.sleep(3)
+                    # 链式检查：点完一键登录后可能弹出短信验证码或仍需完整登录
+                    verify2 = await lsm.check_verify_dialog(conn.page)
+                    if verify2 == "sms":
+                        log.warning(f"    📱 [{account_id}] 一键登录后弹出短信验证码，自动处理...")
+                        await lsm.recover_sms(conn.page, account_id)
+                        log.info(f"    ✅ [{account_id}] 短信验证完毕，继续执行")
+                    elif verify2 == "login_required":
+                        log.warning(f"    🔑 [{account_id}] 一键登录后仍需完整登录，走恢复链")
+                        ok = await lsm.ensure_login(conn.page, account_id, platform)
+                        if ok:
+                            log.info(f"    ✅ [{account_id}] 登录成功，重试当前操作 [{sn}]")
+                            result = await ops.execute(op=op_name, args=sargs, step_id=sn)
+                            report.add_step(StepResult(op_name, sn, result.success, result.elapsed,
+                                                       "" if result.success else result.error))
+                            icon = "✅" if result.success else "❌"
+                            log.info(f"    {icon} [{sn:2d}] {op_name:18s} → {result.detail[:25]} (重试, {result.elapsed:.1f}s)")
+                        else:
+                            log.warning(f"    ❌ [{account_id}] 完整登录恢复失败，跳过当前操作 [{sn}]")
+                    else:
+                        log.info(f"    ✅ [{account_id}] 已点击一键登录，继续执行")
+                except Exception as e:
+                    log.warning(f"    ⚠️ [{account_id}] 点击一键登录失败: {e}, 走完整恢复链")
+                    ok = await lsm.ensure_login(conn.page, account_id, platform)
+                    if ok:
+                        log.info(f"    ✅ [{account_id}] 登录恢复成功，重试当前操作 [{sn}]")
+                        result = await ops.execute(op=op_name, args=sargs, step_id=sn)
+                        report.add_step(StepResult(op_name, sn, result.success, result.elapsed,
+                                                   "" if result.success else result.error))
+                        icon = "✅" if result.success else "❌"
+                        log.info(f"    {icon} [{sn:2d}] {op_name:18s} → {result.detail[:25]} (重试, {result.elapsed:.1f}s)")
+            elif verify_type == "sms":
+                if bp.get("skip_sms"):
+                    log.warning(f"    ⏭️ [{account_id}] 蓝图标记跳过短信验证，关闭浏览器")
+                    await conn.close()
+                    return report
+                log.warning(f"    📱 [{account_id}] 触发短信验证，自动恢复...")
+                await lsm.recover_sms(conn.page, account_id)
+                log.info(f"    ⏭️ 跳过当前操作 [{sn}]")
+            elif verify_type == "captcha":
+                log.warning(f"    🔐 [{account_id}] 滑块验证，需手动处理")
+                # 上报但不中断（留给你手动处理）
+
+            # ── 钩子3: 冷却管理 ──
+            cooldown = self._get_cooldown(op_name)
+            await asyncio.sleep(cooldown)
+
+        return report
+
+    def _get_cooldown(self, op_name: str) -> float:
+        """操作完成后冷却时间（自动去掉 xhs_/dy_ 前缀匹配）"""
+        import random, re
+        COOLDOWNS = {
+            "like":       (2, 4),
+            "collect":    (3, 6),
+            "comment":    (30, 45),
+            "post_comment": (30, 45),
+            "follow":     (10, 20),
+            "search":     (3, 6),
+            "scroll_feed": (2, 3),
+            "wait_watch":  (0, 0),   # wait_watch 自带等待
+        }
+        # 去掉 xhs_/dy_ 前缀再匹配
+        base_name = re.sub(r'^(xhs_|dy_|xhs_|dy_)', '', op_name)
+        base = COOLDOWNS.get(base_name, COOLDOWNS.get(op_name, (2, 5)))
+        return random.uniform(*base)
+
+    async def _run_identity_group(self, group_accts: List[dict]) -> List[AccountRunReport]:
+        """运行同一身份下的所有账号（共用一个浏览器）"""
+        reports = []
+        identity_dir = group_accts[0].get("identity_dir", group_accts[0]["id"]).replace("identities/", "")
+
+        # ── 浏览器数限制检查（L2 层，谁开浏览器谁检查）──
+        import subprocess as _sp
+        while True:
+            try:
+                out = _sp.run("pgrep camoufox | wc -l", shell=True, capture_output=True, text=True, timeout=5)
+                count = int(out.stdout.strip() or 0)
+            except:
+                count = 0
+            if count < self.max_browsers:
+                break
+            log.warning(f"  ⏳ 已达最大浏览器数({self.max_browsers})，等待其他任务释放...")
+            await asyncio.sleep(15)
+
+        if check_cookie(identity_dir) == "no_identity":
+            log.warning(f"  ⏭️ 身份 {identity_dir}: 身份目录不存在，全部跳过")
+            for acct in group_accts:
+                for r in range(1, self.rounds_total + 1):
+                    rpt = AccountRunReport(acct["id"], "", r)
+                    rpt.skipped = True
+                    reports.append(rpt)
+            return reports
+        
+        # cookie 不存在或过期 → 让 ensure_login 恢复链处理
+        ck_status = check_cookie(identity_dir)
+        if ck_status in ("no_cookie", "expired", "error"):
+            # skip_sms 模式：cookie 过期不打开浏览器，直接跳过（防服务器主动发短信）
+            _skip_sms_bp = False
+            if self.blueprints:
+                _bp_data = resolve_blueprint(self.blueprints[0])
+                if _bp_data and _bp_data.get("skip_sms"):
+                    _skip_sms_bp = True
+            if _skip_sms_bp:
+                log.warning(f"  ⏭️ [{identity_dir}] skip_sms + cookie {ck_status}，跳过（不打开浏览器）")
+                for acct in group_accts:
+                    for r in range(1, self.rounds_total + 1):
+                        rpt = AccountRunReport(acct["id"], "", r)
+                        rpt.skipped = True
+                        reports.append(rpt)
+                return reports
+            log.info(f"  🔐 [{identity_dir}] cookie 状态需恢复，由 LoginStateMachine 处理")
+
+        # 分配窗口位置槽位
+        try:
+            from mc.execution_policy import slot_for
+            slot = slot_for(group_accts[0]["id"])
+            win_pos = tuple(slot["position"]) if slot else (0, 0)
+            win_size = tuple(slot["size"]) if slot else (802, 783)
+        except Exception:
+            win_pos, win_size = (0, 0), (802, 783)
+
+        from cdp_connector import CDPConnector
+        conn = CDPConnector(browser_type="camoufox", headless=False,
+                            window=win_size,
+                            window_position=win_pos,
+                            identity_dir=str(IDENTITIES_ROOT / identity_dir))
+        try:
+            await conn.connect()
+            await conn.init_anti_detection()
+            log.info(f"  🖥️ 浏览器已启动 [身份: {identity_dir}]")
+
+            # 按平台排序：先抖音后小红书
+            sorted_accts = sorted(group_accts, key=lambda a: (a.get("platform", "") == "xiaohongshu", a.get("platform", "")))
+
+            for acct_info in sorted_accts:
+                acct_id = acct_info["id"]
+                for round_idx in range(1, self.rounds_total + 1):
+                    bp_name = self._pick_blueprint(round_idx)
+                    rpt = await self._run_acct_on_conn(acct_info, bp_name, round_idx, conn)
+                    reports.append(rpt)
+                    if round_idx < self.rounds_total:
+                        wait = random.uniform(5, 10)
+                        log.info(f"  ⏳ [{acct_id}] 等待 {wait:.0f}s...")
+                        await asyncio.sleep(wait)
+
+        except Exception as e:
+            log.error(f"  ❌ 身份 {identity_dir}: {e}")
+            for acct in group_accts:
+                if not any(r.account == acct["id"] and r.blueprint for r in reports):
+                    rpt = AccountRunReport(acct["id"], "", 1)
+                    rpt.failed = 99
+                    reports.append(rpt)
+        finally:
+            if not self.keep_open:
+                try:
+                    # 先给 8 秒优雅关闭
+                    await asyncio.wait_for(conn.close(), timeout=8)
+                    log.info(f"  🛑 浏览器已关闭 [身份: {identity_dir}]")
+                except (asyncio.TimeoutError, Exception) as e:
+                    log.warning(f"  ⚠️ 浏览器关闭超时 [{identity_dir}]: {e}")
+                # 无论 close 成不成功，强制杀本身份的浏览器进程
+                # 注意: identity_dir = 手机号/账号名, 唯一且不含空格, 不会误杀
+                subprocess.run(["pkill", "-f", identity_dir],
+                               capture_output=True, timeout=3)
+                await asyncio.sleep(2)
+                # 验证
+                for _ in range(3):
+                    chk = subprocess.run(["pgrep", "-f", identity_dir],
+                                        capture_output=True, text=True, timeout=2)
+                    if not chk.stdout.strip():
+                        break
+                    subprocess.run(["pkill", "-9", "-f", identity_dir],
+                                   capture_output=True, timeout=2)
+                    await asyncio.sleep(1)
+
+        return reports
+
+    async def run(self) -> BatchReport:
+        report = BatchReport()
+        report.accounts = self.accounts; report.blueprints = self.blueprints
+        report.rounds_total = self.rounds_total; report.mix_mode = self.mix
+
+        # 1. 按身份分组
+        groups = group_accounts_by_identity(self.accounts)
+        if not groups:
+            report.error = "没有有效的账号"
+            return report
+
+        log.info(f"\n{'='*50}")
+        log.info(f"  🚀 批量执行计划")
+        log.info(f"     身份组: {len(groups)}")
+        for ident, accts in groups.items():
+            log.info(f"       🖥️ {ident} → {[a['id'] for a in accts]}")
+        log.info(f"     每账号 {self.rounds_total} 轮 | 蓝图: {self.blueprints}")
+        log.info(f"{'='*50}")
+
+        # 2. 解析错峰参数
+        try:
+            s_min, s_max = [int(x) for x in self.stagger.split("-")]
+        except:
+            s_min, s_max = 15, 30
+
+        # 3. 并行执行身份组（Semaphore 控制并发数 = max_browsers）
+        #    错峰启动：每个身份组之间随机延迟 stagger 范围
+        sem = asyncio.Semaphore(self.max_browsers)
+        all_reports = []
+
+        group_list = list(groups.items())
+
+        async def _run_one_group(ident, accts, delay: float = 0):
+            if delay > 0:
+                log.info(f"  ⏳ 错峰等待 {delay:.0f}s 后启动身份组 [{ident}]")
+                await asyncio.sleep(delay)
+            async with sem:
+                log.info(f"\n  🖥️ 启动身份组 [{ident}]")
+                return await self._run_identity_group(accts)
+
+        cumulative_delay = 0.0
+        tasks = []
+        for ident, accts in group_list:
+            tasks.append(asyncio.create_task(
+                _run_one_group(ident, accts, delay=cumulative_delay)
+            ))
+            stagger_sec = random.uniform(s_min, s_max)
+            cumulative_delay += stagger_sec
+        for coro in asyncio.as_completed(tasks):
+            group_reports = await coro
+            all_reports.extend(group_reports)
+
+        report.account_reports = all_reports
+
+        # 写入标准结果文件（供 CommandBus / 看板读取）
+        if self.run_id:
+            try:
+                from mc.execution_policy import write_result
+                status = "completed" if not report.error else "failed"
+                write_result(self.run_id, status, report=report.to_dict(),
+                            error=report.error)
+            except:
+                pass
+
+        return report