fix(切号): wait_after 显式填 0 时不该被当成没填（别用 or 15 这种写法）

用户实测要求："去掉切完账号下拉刷新这一步，直接改成等待 15 秒"。
原来的做法是"回读不到就再点一次「我」页签"—— 在设备上看着像去点刷新，还可能打断
抖音换号后的整体重载。

· tasks/generic/task.py：切完后按 wait_after（默认 15s，步骤参数可调）静等，等完只回读、
  **不再点任何东西**（读不到就多读几次，页面渲染有零点几秒抖动）
· 参数落到位：STEP_TYPES / 骨架 build_switch_step / 编辑器面板 / 发布页就地编辑字段表
· 测试：用例里 wait_after=0.2（不然一跑就一分多钟）
· 文档：TASK_DEV §3 的 switch_account 行 + research/U2_ELEMENT_SELECTORS §七（记下"只能等"这条实测教训）

.env.example

@@ -108,6 +108,34 @@ TAILSCALE_API_KEY=请填写Tailscale_API_key
 # 设置后不启动 cron 调度器（跑测试脚本时避免真实触发任务、占用设备）
 # DISABLE_SCHEDULER=1
 
+# 视频发布计划的素材目录（默认 data/videos）。
+# **自动化测试必须指到临时目录**，否则测试传的视频会落进用户真实数据目录。
+# DATA_VIDEO_DIR=/tmp/videos_test
+
+# 单次上传体积上限（MB，默认 2048）。
+# ⚠ 必须大于「应用管理」里最大的 APK（实测有 336MB 的包），否则 APK 上传会被一起卡死。
+# MAX_UPLOAD_MB=2048
+
+# ==================== 发布计划：抖音「我」页面上的控件（抓一次填这里） ====================
+# 发布任务按**名字**发（名字 = 抖音昵称），所以平台要知道"名字在屏幕上哪个控件里"。
+# 用「抓取元素」抓一次抖音「我」页面上的**昵称**（那个 TextView），填到下面。
+# 一处配置、三处一致：任务骨架的「读取本机账号名字」步骤默认值、切号后的回读校验、
+# 以及「发布计划 → 一键推送（按名字找设备）」的实时探测。
+# 留空 = 还没抓：相关步骤会明确报错并跳过，**绝不会猜一个名字去发**。
+#
+# 2026-10-12 在 A01（抖音 40.6.0）实测可用的值：昵称那个 TextView 的 resource-id 是混淆 id `tk+`，
+# 所以填 resourceId（等价 xpath：//*[@resource-id="com.ss.android.ugc.aweme:id/tk+"]）。
+# DOUYIN_NAME_SELECTOR_TYPE=resourceId
+# DOUYIN_NAME_SELECTOR_VALUE=com.ss.android.ugc.aweme:id/tk+
+
+# 「我」页面 →「切换账号」列表那个入口（自动切号用，同样抓一次填这里）。
+# 它是个只有 content-desc 的 ImageView（desc 就是「切换账号」），所以用 descriptionContains。
+# 留空 = 「切换账号」步骤会明确报错并跳过（不会瞎点）。
+# DOUYIN_SWITCH_SELECTOR_TYPE=descriptionContains
+# DOUYIN_SWITCH_SELECTOR_VALUE=切换账号
+#
+# 细节与结构图见 doc/research/U2_ELEMENT_SELECTORS.md §七（含"为什么不要用 (…b7w)[N]"）。
+
 
 # ==============================================================================
 # 已废弃的历史配置（STF 已从代码层摘除，下列键代码不再使用，保留仅为兼容旧 .env）

.gitignore

@@ -12,6 +12,8 @@ env/
 logs/*.log
 data/*.log
 data/apks/*.apk
+# 视频发布计划的素材（几百 MB 一个，绝不入库）
+data/videos/
 data/*.migrated
 # uiauto.pid 之类的运行时 PID 文件（**注释必须单独一行**：gitignore 不支持行尾注释）
 data/*.pid

README.md

@@ -47,12 +47,13 @@
 | **设备池** | SQLite 清单 + adb 在线状态；支持手工添加、网段自动发现、一键重连、型号采集、启用/停用 |
 | **电量监控** | 后台每分钟 `dumpsys battery`（只读）采一次电量，**大屏卡片**与**监控页设备列表**都显示（按档位着色 + ⚡ 充电中）；低于阈值推 webhook 告警（**充电中不报、"插着却没充电"照报**，掉档/恢复各报一次，不刷屏）。电量只放内存不落库（见 [NOTIFY.md](doc/NOTIFY.md) §3.1） |
 | **任务调度** | 手动 / cron 定时 / 定时启停；运行窗口；失败重试（含端口耗尽类的长退避） |
-| **步骤编辑器** | 可视化拖拽编排 22 种步骤（含循环/条件/OCR/通知/录制回放），可打包成"自定义动作"复用 |
+| **步骤编辑器** | 可视化拖拽编排 24 种步骤（含循环/条件/OCR/通知/录制回放），可打包成"自定义动作"复用 |
 | **拟人化操作** | 滑动默认走弧线轨迹、位置/幅度/时长每次抖动，且**每台设备有自己的手速与习惯**（同设备风格稳定、设备之间明显不同）——批量跑时不像同步机器人（见 [TASK_DEV.md](doc/TASK_DEV.md) §8.4） |
 | **录制回放** | 「录制手势」步骤 = **纯录制**：**用手指在真机上划**（读 getevent 真触屏）或在网页画面上拖，把轨迹点列原样存下来，回放时**照原路径与时长重放**——不套滑动那套方向/幅度/拟人参数 |
 | **动作配置 / 录制** | 「任务 → 动作配置」：① 配**步骤默认值**（新建步骤预填：滑动时长/幅度/抖动/拟人、点击超时、等待区间…）② **录制动作**——在设备画面上点/划/按键，自动翻译成步骤（点元素记选择器、划一下记方向/幅度/时长），可存成可复用动作，也可只取一个手势回填滑动步骤 |
 | **公共巡检** | 任务级的守护条件（**独立于步骤画布**）：每 N 秒检查屏幕亮/熄、元素在不在、前台是不是某 App，命中就点亮/息屏/停本设备/推通知——通知标题正文自己写（见 [TASK_DEV.md](doc/TASK_DEV.md) §4.5） |
 | **去重账本** | 解决"**同一个号被做两次、有的号还没做**"：任务里用「条件判断→去重」+「记为已做」，把"这个身份做过了"记进一张**所有设备共享**的账本——多台手机、反复重跑都不会重复做同一个号。「任务 → 去重记录」页能看"谁做过了、还差谁"，也能删记录让它重跑（见 [TASK_DEV.md](doc/TASK_DEV.md) §4.6） |
+| **视频发布计划** | 「发布计划」页：批量上传**视频/图片**（文件名 `名字_日期_编号`，**名字 = 抖音昵称**；视频和图片同一套规则）与标题 txt（每行 `标题 || 正文_名字_日期_编号`）→ 自动按 (名字,日期,编号) 配对 → **按日期的时间线**看每天谁要发、发到哪一步。**平台只负责把素材推到手机**（推到 `/sdcard/DCIM/Camera/`、触发相册刷新、把标题写进剪贴板），**抖音里怎么发由你自己在任务里写步骤**（步骤顺序：`读取本机账号名字` → `条件判断`校验 → `推送发布视频` → 你的发布步骤 → `标记发布结果`；页顶部有**「发布任务」**块可一键建好骨架 + 看下次运行/启停，`输入文字` 那一步可以选**取值来源＝计划标题/正文**自动填文案并回读校验）；发完可抓作品的**分享链接**存下来（平台不长期囤视频，链接才是长期资产，也方便后续铺评论：可一键复制、按日期/名字导出 CSV）。状态区分"**可重试**"（推送阶段失败，还没到抖音）与"**结果未知、需人工确认**"（推送之后出的岔子，绝不自动重发）（见 [DATA_MODEL.md](doc/DATA_MODEL.md) §2.11、[TASK_DEV.md](doc/TASK_DEV.md) §4.7） |
 | **元素抓取** | 拉取设备 UI 元素树 → 点选回填选择器；支持"点一下"与"测选择器"真机验证 |
 | **实时看屏** | MJPEG 实时流 + 点击/滑动/按键/文字输入；全屏监控大屏（`/wall`） |
 | **应用管理** | APK 上传/解析/批量安装；设备已装应用与版本查询；剪贴板注入 |
@@ -133,12 +134,14 @@ auto_control/
 │
 ├── core/                      # 基础设施层
 │   ├── models.py              #   SQLAlchemy 模型 + 建表 + 版本化迁移 + 旧 JSON 迁移
-│   ├── device_pool.py         #   设备池（清单/在线状态/型号）
+│   ├── device_pool.py         #   设备池（清单/在线状态/型号/设备名→当前地址）
 │   ├── device_worker.py       #   BaseWorker + 设备生命周期 + 心跳看门狗 + 全局状态表
 │   ├── task_manager.py        #   调度器：分组/任务/APScheduler/重试/运行控制
 │   ├── adb_helper.py          #   adb 命令封装（全局锁，红线：绝不 kill-server）
 │   ├── device_discovery.py    #   网段扫描发现设备 → 待连接池
 │   ├── device_battery.py      #   设备电量采集（dumpsys 只读）+ 低电量告警
+│   ├── video_plan.py          #   视频发布计划（文件名解析配对 / 时间线 / 幂等占位 / 素材清理）
+│   ├── account_probe.py       #   实时探测设备当前登录的抖音号（按名字找设备用）
 │   ├── u2_helper.py           #   uiautomator2 通用辅助（等首页/安全点击等）
 │   ├── uiauto_helper.py       #   uiautodev 客户端（元素树 + XPath 建议）
 │   ├── ocr.py                 #   屏幕 OCR（RapidOCR，条件判断用）
@@ -158,7 +161,7 @@ auto_control/
 ├── tasks/                     # 任务定义层
 │   ├── base.py                #   BaseTask + _TASK_TYPES + register_task
 │   └── generic/               #   通用步骤任务（task_type=generic_steps，当前唯一类型）
-│       └── task.py            #     STEP_TYPES（22 种步骤）+ Worker + 执行器
+│       └── task.py            #     STEP_TYPES（24 种步骤）+ Worker + 执行器
 │
 ├── mcp_server/                # MCP Server（20 个 de_* 工具，:8033）
 │   ├── mcp_server.py          #   工具定义 + 平台登录 + 门控
@@ -284,7 +287,7 @@ self.set_progress(done=5, total=80, unit="视频", action_counts={"like": 3}, el
 
 `generic_steps` 的执行内容全在 `params.steps`（JSON 数组），由步骤编辑器产出。**没有默认步骤**——空步骤任务执行时会明确报错。
 
-**22 种步骤**（完整参数见 [doc/TASK_DEV.md](doc/TASK_DEV.md)）：
+**24 种步骤**（完整参数见 [doc/TASK_DEV.md](doc/TASK_DEV.md)）：
 
 | 类别 | 步骤 |
 |------|------|
@@ -406,7 +409,7 @@ read_log_text()`，`file` 参数走白名单，不接受任意路径。
 | [doc/ARCHITECTURE.md](doc/ARCHITECTURE.md) | 架构详解（分层、装配顺序、线程模型、设备生命周期、调度链路、设计决策） |
 | [doc/DATA_MODEL.md](doc/DATA_MODEL.md) | 数据模型（表结构、迁移、`app_meta`、数据目录、备份覆盖清单） |
 | [doc/API.md](doc/API.md) | HTTP 接口全量说明 |
-| [doc/TASK_DEV.md](doc/TASK_DEV.md) | 任务与步骤开发（22 种步骤、公共巡检、录制回放、去重、选择器、自定义动作） |
+| [doc/TASK_DEV.md](doc/TASK_DEV.md) | 任务与步骤开发（24 种步骤、公共巡检、录制回放、去重、选择器、自定义动作） |
 | [doc/MCP.md](doc/MCP.md) · [doc/MCP_DESIGN.md](doc/MCP_DESIGN.md) | MCP 使用手册 / 设计文档 |
 | [doc/AI_CONSOLE.md](doc/AI_CONSOLE.md) · [doc/AI_TASK_GEN.md](doc/AI_TASK_GEN.md) | AI 控制台机制 / AI 建任务设计（规划） |
 | [doc/DEPLOY.md](doc/DEPLOY.md) | 部署与运维（含生产容器、备份导入、故障排查） |

config.py

@@ -87,6 +87,28 @@ DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
 # APK 文件存储目录（应用管理功能）
 APK_DIR = os.path.join(DATA_DIR, "apks")
 
+# 视频发布计划的素材目录（发布计划功能）。**支持 env 覆盖**，理由同下面三个：
+# 自动化测试必须把素材目录指到临时位置，否则测试上传的视频会落进用户真实数据目录。
+VIDEO_DIR = _env("DATA_VIDEO_DIR", "") or os.path.join(DATA_DIR, "videos")
+
+# ================== 抖音「我」页面的昵称控件（发布计划按名字发） ==================
+# **抓一次填这里**（用「抓取元素」抓抖音「我」页面上的昵称那个 TextView）。
+# 一处配置、三处一致：发布任务骨架的「读取本机账号名字」步骤默认值、
+# 「切换账号」的切后校验、以及「发布计划 → 一键推送（按名字找设备）」的实时探测。
+# 任务步骤里仍可单独改（存进那一步的参数），这里只是**默认值**。
+# 留空 = 还没抓：相关步骤会明确报"请抓取元素"，绝不会猜一个名字去发。
+DOUYIN_NAME_SELECTOR_TYPE = _env("DOUYIN_NAME_SELECTOR_TYPE", "xpath")
+DOUYIN_NAME_SELECTOR_VALUE = _env("DOUYIN_NAME_SELECTOR_VALUE", "")
+
+# 「我」页面 →「切换账号」列表那个入口（同样是**抓一次填这里**）：自动切号要用。
+# 留空 = 「切换账号」步骤会明确报"请抓取元素"并跳过（不会瞎点）。
+DOUYIN_SWITCH_SELECTOR_TYPE = _env("DOUYIN_SWITCH_SELECTOR_TYPE", "xpath")
+DOUYIN_SWITCH_SELECTOR_VALUE = _env("DOUYIN_SWITCH_SELECTOR_VALUE", "")
+
+# 单次请求体上限（字节）。**必须大于现有 APK 上传的最大包**（实测 336MB），
+# 否则「应用管理」的 APK 上传会被一起卡死。默认 2GiB：一个视频 + 余量。
+MAX_CONTENT_LENGTH = int(_env("MAX_UPLOAD_MB", "2048")) * 1024 * 1024
+
 # ================== 系统数据备份（导出/导入） ==================
 # 导出 zip 与恢复前快照存放；导入暂存目录；待下次启动生效的恢复目录
 # （运行时产物，不入 git，见 .gitignore data/backups 等）

core/account_probe.py

@@ -0,0 +1,158 @@
+"""实时探测"这台设备现在登的是哪个抖音号"（**按名字找设备**用）。
+
+**谁用它**：人工入口 —— 「发布计划」页的「一键推送（按名字找设备）」要先知道
+"哪台在线设备现在登着这个名字"，才能把素材推过去。
+**自动任务不靠它**：任务里的「读取本机账号名字」永远是现场读屏幕（缓存旧了也不能影响发布正确性）。
+
+它只做**只读/幂等**的动作：连设备 → 需要时把抖音拉到前台 → 点「我」→ 读昵称控件 → 清洗。
+**绝不登录、绝不滑块、绝不改设备设置**；连不上/读不到只报那一台，不影响别的设备。
+也绝不 `kill-server` / `disconnect`（技术约束红线）。
+
+昵称控件在 `config.DOUYIN_NAME_SELECTOR_VALUE`（**抓一次填 .env**，与任务骨架同一处配置）；
+没填就明确报"还没抓"，不去猜。
+"""
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+from config import DOUYIN_NAME_SELECTOR_TYPE, DOUYIN_NAME_SELECTOR_VALUE
+from core import u2_helper
+from core.logger import get_logger
+
+_log = get_logger("core.account_probe")
+
+DOUYIN_PKG = "com.ss.android.ugc.aweme"
+_CONNECT_TIMEOUT = 20        # u2.connect 超时（秒）；设备端 u2 服务没响应时别把请求挂死
+_STEP_WAIT = 2.5             # 进「我」页面后等它渲染完
+
+
+def _connect(serial, timeout=_CONNECT_TIMEOUT):
+    """带超时的 u2.connect。
+
+    ⚠ 用**手动 shutdown(wait=False)** —— `with ThreadPoolExecutor(...)` 退出时会
+    `shutdown(wait=True)`，超时线程不死它就跟着等，30 秒的"超时"会变成真卡住
+    （`core/device_worker` 里踩过这个坑）。
+    """
+    import uiautomator2 as u2
+    pool = ThreadPoolExecutor(max_workers=1)
+    try:
+        return pool.submit(u2.connect, serial).result(timeout=timeout)
+    finally:
+        pool.shutdown(wait=False)
+
+
+def probe_one(serial, click_me=True):
+    """读一台设备当前登录的抖音名字。返回 `{serial, name, error}`。
+
+    `name` 非空 = 读到了；`error` 非空 = 没读到（人话原因，给界面直接显示）。
+    """
+    if not DOUYIN_NAME_SELECTOR_VALUE:
+        return {"serial": serial, "name": "",
+                "error": "还没抓抖音昵称控件：在 .env 里填 DOUYIN_NAME_SELECTOR_VALUE"
+                         "（抓取元素抓一下「我」页面上的昵称）"}
+    d = None
+    try:
+        d = _connect(serial)
+    except Exception as e:
+        return {"serial": serial, "name": "",
+                "error": f"连不上设备（u2 {_CONNECT_TIMEOUT}s 超时）：{type(e).__name__}"}
+    try:
+        pkg = u2_helper.current_package(d)
+        if pkg != DOUYIN_PKG:
+            # 不在抖音 → 拉到前台（幂等：已经在就什么都不做）
+            try:
+                d.app_start(DOUYIN_PKG, wait=True)
+            except Exception as e:
+                return {"serial": serial, "name": "",
+                        "error": f"打不开抖音：{type(e).__name__}: {str(e)[:60]}"}
+            time.sleep(4)
+        if click_me:
+            u2_helper.find_and_click(d, timeout=3,
+                                     **{"descriptionContains": "我"})
+        time.sleep(_STEP_WAIT)
+        from core import video_plan as vp
+        if DOUYIN_NAME_SELECTOR_TYPE == "xpath":
+            el = d.xpath(DOUYIN_NAME_SELECTOR_VALUE)
+            raw = el.get_text() if el.exists else ""
+        else:
+            el = d(**{DOUYIN_NAME_SELECTOR_TYPE: DOUYIN_NAME_SELECTOR_VALUE})
+            raw = el.get_text(timeout=3) if el.exists(timeout=3) else ""
+        name = vp.clean_account_name(raw)
+        if not name:
+            return {"serial": serial, "name": "",
+                    "error": f"读到空（元素原文 {raw!r}）—— 昵称控件的选择器可能抓错了"}
+        return {"serial": serial, "name": name, "error": ""}
+    except Exception as e:
+        return {"serial": serial, "name": "",
+                "error": f"读取失败：{type(e).__name__}: {str(e)[:80]}"}
+    finally:
+        # **不 disconnect、不 kill-server**（红线）：u2 的连接自己会超时回收
+        pass
+
+
+def busy_serials():
+    """正在跑任务/正在连接的设备（探测要跳过它们：抢屏会打断任务）。"""
+    from core import device_worker
+    out = set()
+    try:
+        for s in device_worker.get_all_worker_status():
+            if (s.get("status") or "") in ("running", "connecting"):
+                out.add(s.get("serial") or "")
+    except Exception as e:
+        _log.warning(f"读设备运行状态失败（按「都不忙」处理）: {e}")
+    return {x for x in out if x}
+
+
+def probe_online(serials=None, skip_busy=True, workers=4):
+    """并行探测多台设备。返回 `{serial: {serial, name, error}}`。
+
+    · `serials=None` → 取设备池里**在线且启用**的设备（`device_pool.list_ready()`）
+    · `skip_busy=True`（默认）→ 跳过正在跑任务/连接中的设备（别抢它们的屏）
+    · 单台失败只影响那一台；顺序按传入/池里的顺序
+    """
+    from core import device_pool
+    if serials is None:
+        try:
+            serials = list(device_pool.list_ready())
+        except Exception as e:
+            _log.warning(f"取在线设备失败: {e}")
+            return {}
+    serials = [s for s in (serials or []) if s]
+    if skip_busy:
+        busy = busy_serials()
+        if busy:
+            _log.info(f"探测跳过正在跑任务的设备：{'、'.join(sorted(busy))}")
+        serials = [s for s in serials if s not in busy]
+    out = {}
+    if not serials:
+        return out
+    with ThreadPoolExecutor(max_workers=max(1, min(workers, len(serials)))) as pool:
+        for r in pool.map(probe_one, serials):
+            out[r["serial"]] = r
+    return out
+
+
+def cache_names(result):
+    """把探测结果写进 `device.cur_account_name/cur_name_at`（**只用于人工入口的设备建议**）。
+
+    ⚠ 必须在 **Flask app context** 里调用（web 请求线程本身就有；脚本里自己推）。
+    探测失败的那台**不清空旧值**（旧值好歹是个线索，界面上带时间戳显示）。
+    """
+    from core.models import Device, db
+    try:
+        now = time.strftime("%Y-%m-%d %H:%M:%S")
+        for serial, r in (result or {}).items():
+            name = (r or {}).get("name") or ""
+            if not name:
+                continue
+            row = Device.query.get(serial)
+            if not row:
+                continue
+            row.cur_account_name = name[:80]
+            row.cur_name_at = now
+        db.session.commit()
+    except Exception as e:
+        _log.warning(f"写设备当前账号缓存失败（不影响探测结果）: {e}")
+        try:
+            db.session.rollback()
+        except Exception:
+            pass

core/clipboard_helper.py

@@ -1,10 +1,13 @@
-"""剪贴板注入公共模块（ClipInject APK 通道）。
+"""剪贴板注入公共模块（设备端 Agent 通道）。
 
 背景：Android 10+ 禁止后台（atx-agent/shell）写剪贴板——u2.set_clipboard
-调用"成功"但内容被系统静默丢弃（Android 12/13 实测）。ClipInject
+调用"成功"但内容被系统静默丢弃（Android 12/13 实测）。设备端 APK 通过 am start
-（com.example.clipinject，用户自研 APK）通过 am start 启动透明 Activity，
+启动**透明 Activity**，窗口聚焦后 setPrimaryClip；shell 身份启动 Activity 不受
-窗口聚焦后 setPrimaryClip；shell 身份启动 Activity 不受后台启动限制
+后台启动限制（广播方式在 MIUI 会被 Background activity start 拦截，必须用 am start）。
-（广播方式在 MIUI 会被 Background activity start 拦截，必须用 am start）。
+
+**注入目标按顺序尝试**：先设备端聚合 Agent（`com.example.deviceagent`，现在的标准通道），
+再兜底老设备上可能残留的独立 ClipInject（`com.example.clipinject`）。
+两者只有一个 `--es text_b64` 的契约差异为零，所以是"换个包名再试一次"。
 
 工具页（web/tools_api.py）与任务执行器（tasks/generic/task.py）共用本模块。
 """
@@ -19,17 +22,43 @@ from core.logger import get_logger
 
 _log = get_logger("core.clip")
 
-_CLIP_PACKAGE = "com.example.clipinject"
+# (包名, am start 目标, 给用户看的名字)；顺序 = 尝试顺序
-_CLIP_ACTIVITY = "com.example.clipinject/.ClipActivity"
+_CLIP_TARGETS = (
+    ("com.example.deviceagent", "com.example.deviceagent/.ClipActivity", "设备端 Agent"),
+    ("com.example.clipinject", "com.example.clipinject/.ClipActivity", "旧版 ClipInject"),
+)
+
+
+def _am_start(serial, activity, b64):
+    """拉起透明 Activity 写剪贴板。返回 (输出文本, 是否执行成功)。"""
+    try:
+        r = subprocess.run(
+            [ADB_PATH, "-s", serial, "shell", "am", "start",
+             "-n", activity, "--es", "text_b64", b64],
+            capture_output=True, timeout=30)
+    except subprocess.TimeoutExpired:
+        return "am start 超时（adb 无响应）", False
+    except Exception as e:
+        return f"{type(e).__name__}: {str(e)[:120]}", False
+    out = ((r.stdout or b"") + (r.stderr or b"")).decode(errors="replace")
+    # "Starting: Intent {…}" 后面跟 "Error type 3 / Error: Activity class … does not exist."
+    # 时也是失败——所以不能只看有没有 Starting
+    if "does not exist" in out or "unable to resolve Intent" in out or "Error type 3" in out:
+        return out, False
+    if "Error" in out or ("Starting" not in out and r.returncode != 0):
+        return out, False
+    return out, True
 
 
 def inject_clipboard(serial, text, d=None):
     """向设备剪贴板注入文字，返回 (ok, msg)。
 
+    - 依次尝试 `_CLIP_TARGETS`（设备端 Agent → 旧版 ClipInject）：设备上装哪个用哪个，
+      两个都没有时明确报"需要装设备端 Agent"（不再只说 ClipInject，用户会以为要装老 APK）
     - d：可选，任务执行器已持有 u2 Device 时传入复用（跳过重复连接），
       读回验证直接用它；不传则临时 u2.connect（工具页场景，带超时保护）
     - IP:port 设备先 adb connect（已连接自动跳过；绝不 disconnect，红线）
-    - 未装 ClipInject / 读回不一致都会明确报错（不再静默失败）
+    - 通道缺失 / 读回不一致都会明确报错（不再静默失败）
     """
     import uiautomator2 as u2
     if ":" in serial:
@@ -39,31 +68,45 @@ def inject_clipboard(serial, text, d=None):
             return False, f"adb 连接失败: {e}"
     b64 = base64.b64encode(text.encode("utf-8")).decode()
     # 1. am start 透明 Activity 写剪贴板（shell 身份，不受后台启动限制）
-    try:
+    tried = []
-        r = subprocess.run(
+    for pkg, activity, label in _CLIP_TARGETS:
-            [ADB_PATH, "-s", serial, "shell", "am", "start",
+        out, started = _am_start(serial, activity, b64)
-             "-n", _CLIP_ACTIVITY, "--es", "text_b64", b64],
+        if started:
-            capture_output=True, timeout=30)
+            if tried:
-        out = ((r.stdout or b"") + (r.stderr or b"")).decode(errors="replace")
+                # 走到兜底通道：记一条，好提醒"这台设备该装 Agent 了"
-        if "does not exist" in out or "unable to resolve Intent" in out:
+                _log.info(f"[{serial}] 剪贴板注入：{'、'.join(tried)} 都没有，"
-            return False, f"设备未安装 ClipInject（{_CLIP_PACKAGE}），请先安装"
+                          f"改用{label}（{pkg}）成功 —— 建议给这台设备装设备端 Agent")
-        if "Error" in out or ("Starting" not in out and r.returncode != 0):
+            break
-            return False, f"am start 失败: {out.strip()[:120]}"
+        if "does not exist" in out or "unable to resolve Intent" in out or "Error type 3" in out:
-    except subprocess.TimeoutExpired:
+            tried.append(label)
-        return False, "am start 超时（adb 无响应）"
+            continue
-    except Exception as e:
+        # 装了但启动失败：直接报错，不再往下试（下一个包大概率也没装）
-        return False, f"{type(e).__name__}: {str(e)[:120]}"
+        return False, f"am start 失败（{label}）: {out.strip()[:120]}"
-    # 2. 读回验证（等透明 Activity 完成写入；u2 读剪贴板在 Android 12 实测可用）
+    else:
-    time.sleep(0.5)
+        return False, ("设备未安装剪贴板注入通道：需要设备端 Agent"
+                       "（com.example.deviceagent）——从「应用管理 → 设备端应用商店」安装；"
+                       "旧版独立 ClipInject（com.example.clipinject）也可以，但已不再随平台分发")
+    # 2. 读回验证：**必须轮询**。透明 Activity 要等窗口拿到焦点才写（还有 800ms 兜底），
+    #    只睡一次 0.5s 会读到**上一次的剪贴板内容** → 误报"写入可能被拒"（实测踩过：
+    #    内容明明写进去了，接口却回 1 台失败）。轮询到 ~3 秒：一致即成功；
+    #    一直不一致才算真的被拒。
     try:
         if d is None:
             with ThreadPoolExecutor(max_workers=1) as pool:
                 d = pool.submit(u2.connect, serial).result(timeout=30)
+    except Exception as e:
+        return True, f"已注入（读回验证不可用: {type(e).__name__}: {str(e)[:80]}）"
+    deadline = time.time() + 3.0
+    got = None
+    while True:
+        time.sleep(0.4)
+        try:
             with ThreadPoolExecutor(max_workers=1) as pool:
                 got = pool.submit(lambda: d.clipboard).result(timeout=15)
-        if got == text:
-            return True, "已注入"
-        return False, f"剪贴板读回不一致（写入可能被拒）: {str(got)[:60]!r}"
         except Exception as e:
             # 读回不可用（旧版 u2/连接失败）时按写入成功处理，避免误报，但带上具体原因
             return True, f"已注入（读回验证不可用: {type(e).__name__}: {str(e)[:80]}）"
+        if got == text:
+            return True, "已注入"
+        if time.time() >= deadline:
+            return False, f"剪贴板读回不一致（写入可能被拒）: {str(got)[:60]!r}"

core/device_pool.py

@@ -124,6 +124,33 @@ def list_devices():
         return [d.to_dict() for d in Device.query.order_by(Device.serial).all()]
 
 
+def serial_of(device_name):
+    """设备名 → **当前**地址（拿不到返回空串）。
+
+    从已删掉的 `core/ledger.py` 迁过来的（账号台账停用后，那边只剩这一个函数还有用 ——
+    它跟账号无关，只做"设备名 ↔ 地址"）。
+
+    ⚠ 为什么不能直接用计划行里的 `serial` 快照：设备地址会变（换 IP、重连）。
+    快照是"录入时"的值，久了就是错的 —— 要下发操作（推视频等）时必须现查。
+    优先设备池的**内存快照**（零 DB、已经是刷新过的），再退回 DB。
+    """
+    name = (device_name or "").strip()
+    if not name:
+        return ""
+    try:
+        for d in list_devices():
+            if (d.get("name") or "") == name:
+                return d.get("serial") or ""
+    except Exception:
+        pass
+    try:
+        with _ctx():
+            dev = Device.query.filter(Device.name == name).first()
+            return (dev.serial if dev else "") or ""
+    except Exception:
+        return ""
+
+
 # ================== 在线状态 ==================
 def list_online():
     """本机 adb 中 state=device 的设备 + 池内 USB 设备（经 220 远程 adb server）。

core/models.py

@@ -250,6 +250,10 @@ class Device(db.Model):
     enabled = db.Column(db.Boolean, default=True)      # 是否参与调度
     note = db.Column(db.Text, default="")              # 备注
     created_at = db.Column(db.String(20), default="")  # 添加时间
+    # 上次探测到的**抖音当前登录账号名字**（「发布计划 → 一键推送（按名字找设备）」用）。
+    # 只是**缓存**：自动任务永远现场读屏幕，不读这两列（缓存旧了也不影响发布正确性）。
+    cur_account_name = db.Column(db.String(80), default="")
+    cur_name_at = db.Column(db.String(20), default="")   # 上面那个名字是什么时候读的
     # 设备指纹（ro.serialno）：识别"同一台物理设备"的稳定标识。
     # 网络设备（serial=IP:5555）换 IP 后靠它认领回原记录，名称/分组/任务引用都不丢。
     fingerprint = db.Column(db.String(120), default="")
@@ -258,7 +262,9 @@ class Device(db.Model):
         return {"serial": self.serial, "name": self.name or "",
                 "model": self.model or "", "enabled": bool(self.enabled),
                 "note": self.note or "", "created_at": self.created_at or "",
-                "fingerprint": self.fingerprint or ""}
+                "fingerprint": self.fingerprint or "",
+                "cur_account_name": self.cur_account_name or "",
+                "cur_name_at": self.cur_name_at or ""}
 
     def __repr__(self):
         return f"<Device {self.serial}>"
@@ -436,6 +442,153 @@ class DoneMark(db.Model):
     )
 
 
+class DeviceAccount(db.Model):
+    """账号台账（**2026-10-12 起已停用**：页面/接口/任务依赖全部下线，表和数据保留）。
+
+    保留模型 = 保留表和 42 行历史数据、并继续留在备份清单（`SUMMARY_TABLES` 按模型派生）——
+    停用不等于删数据（删不可逆）。新功能**不要再读写这张表**。
+    历史用途：一台设备上登录着哪些账号（「账号」页维护）。
+
+    要解决的问题（用户场景）：一台手机登好几个抖音号、十几台手机四五十个号，
+    账号信息散在一张电子表格里 —— 换 IP、加号、想查"这台登的是哪几个号"都要翻表。
+    这里把台账落进平台：web 能查能改（支持从表格粘贴导入），
+    手机端 Agent 的「身份大字页」顺带显示本机账号，任务的「条件判断」
+    也可以直接从台账取号（不用再把号一个个手写进 cmp_value）。
+
+    ⚠ **`douyin_id` 是纯号（`35377983067`），而元素原文是 `抖音号：35377983067`。**
+    - 当条件判断的**比对值**可以 ✓（运算符用「包含」，纯号是子串）
+    - **绝不能当去重身份** ✗ —— `done_mark.identity` 存的是元素原文、逐字算 key，
+      格式不一致会让去重**静默失效**（见 `core/dedup.py`）。
+
+    `device_name` 是设备号（平台设备名，如 A01）；`serial` 是**录入时的地址快照**，
+    设备换 IP 或改名后，台账靠任一侧都能找回来（账号管理已停用，这列仅留作历史数据）。
+    同一抖音号不允许两条 —— 唯一性由服务层保证（号可能为空，DB 层要做
+    "部分唯一索引"三处方言适配，人工维护的几十条不值当）。
+    """
+    __tablename__ = "device_account"
+    id = db.Column(db.String(32), primary_key=True)                 # uuid 前 8 位
+    device_name = db.Column(db.String(80), default="", index=True)  # 设备号（平台设备名）
+    serial = db.Column(db.String(120), default="")                  # 录入时的地址快照
+    phone = db.Column(db.String(32), default="", index=True)        # 手机号
+    nickname = db.Column(db.String(80), default="")                 # 账号名称
+    douyin_id = db.Column(db.String(64), default="", index=True)    # 抖音号（纯号，不带前缀）
+    registered_at = db.Column(db.String(20), default="")            # 注册时间（原样存文本）
+    sim_in_device = db.Column(db.Boolean, default=False)            # 卡在机内（空=否）
+    can_post_video = db.Column(db.Boolean, default=False)           # 可发视频（空=否）
+    bio = db.Column(db.Text, default="")                            # 简介
+    note = db.Column(db.Text, default="")                           # 备注
+    created_at = db.Column(db.String(20), default="")
+    updated_at = db.Column(db.String(20), default="")
+
+    def to_dict(self):
+        return {"id": self.id, "device_name": self.device_name or "",
+                "serial": self.serial or "", "phone": self.phone or "",
+                "nickname": self.nickname or "", "douyin_id": self.douyin_id or "",
+                "registered_at": self.registered_at or "",
+                "sim_in_device": bool(self.sim_in_device),
+                "can_post_video": bool(self.can_post_video),
+                "bio": self.bio or "", "note": self.note or "",
+                "created_at": self.created_at or "", "updated_at": self.updated_at or ""}
+
+    def __repr__(self):
+        return f"<DeviceAccount {self.device_name} {self.nickname}>"
+
+
+class VideoPlan(db.Model):
+    """视频发布计划：账号 × 发布日期 × 编号 → 一个视频素材 + 一条标题 + 发布结果。
+
+    一条记录 = **一个账号在某天要发的一个视频**（素材与计划天然 1:1，所以不拆两张表；
+    但上传是分两步的 —— 先视频后标题或反过来 —— 靠 `status` 的 `pending` 态兜住）。
+
+    **状态机**（这是本表的灵魂，不要简化）：
+
+    | status | 含义 |
+    |---|---|
+    | `pending` | 有视频、还没标题 |
+    | `ready` | 素材齐，等发布日期 |
+    | `pushing` | 已原子占位，正在把视频推到手机 |
+    | `publishing` | 已推到手机，正在走抖音发布流程 |
+    | `done` | 发布成功（终态） |
+    | `failed` | 失败在 `push`/`scan` 阶段 —— 还没碰抖音，**可安全重试** |
+    | `unknown` | 失败在 `post`/`verify` 阶段 —— **可能已经发出去了，绝不自动重试**，要人工裁决 |
+    | `skipped` | 人工跳过（终态） |
+
+    ⚠ **`failed` 与 `unknown` 必须分开**：把"不知道自己发没发"混成"知道自己没发"，
+    就是重复发布的来源。`stage` 记录失败发生在哪一步，是这两者互相转换的唯一依据。
+
+    **唯一性**：`(nickname, release_date, seq)` 由服务层（`core/video_plan.py`）保证，
+    **不加 DB 唯一索引** —— `seq` 从 1 起、没有"空值"可言，做部分唯一索引要写三处方言适配
+    （见 §唯一索引那段注释与 `_ensure_unique_indexes`），收益不匹配；违反的代价只是
+    低频人工上传产生的重复行，可见、可删。
+
+    **分享链接**：发布成功后抓作品的分享链接存 `share_url` —— 平台**不长期囤视频**
+    （存不下），链接才是长期资产，也方便后续拿它去铺评论。
+    """
+    __tablename__ = "video_plan"
+    id = db.Column(db.String(32), primary_key=True)                 # uuid 前 8 位
+    account_id = db.Column(db.String(32), default="", index=True)   # 老台账账号 id（已停用，保留列）
+    phone = db.Column(db.String(32), default="", index=True)        # 老台账手机号快照（已停用，保留列）
+    device_name = db.Column(db.String(80), default="", index=True)  # 设备号快照（**已不写入**；实际由谁发的看 posted_device_name）
+    nickname = db.Column(db.String(80), default="")                 # **识别键**：上传文件名里的名字（= 抖音昵称）
+    douyin_id = db.Column(db.String(64), default="")                # 抖音号快照（已停用，保留列）
+    serial = db.Column(db.String(120), default="")                  # 地址快照（已停用，保留列）
+    release_date = db.Column(db.String(10), default="", index=True)  # "YYYY-MM-DD"（纯日期，等值比较）
+    seq = db.Column(db.Integer, default=1)                          # 编号，从 1 起（不用 0 表示"无"）
+    seq_auto = db.Column(db.Boolean, default=True)                  # 编号是自动分配出来的（界面要提示）
+    title = db.Column(db.Text, default="")                          # 标题（抖音发布页的「标题」框）
+    body = db.Column(db.Text, default="")                           # 正文/文案（发布页的文案框；标题 txt 里用 || 分隔）
+    video_file = db.Column(db.String(120), default="")              # 平台落盘文件名（不含绝对路径）
+    video_name = db.Column(db.String(200), default="")              # 原始上传名（排查用）
+    video_size = db.Column(db.Integer, default=0)
+    video_sha1 = db.Column(db.String(40), default="")               # 内容指纹（重复上传的判据）
+    status = db.Column(db.String(16), default="", index=True)
+    stage = db.Column(db.String(16), default="")                    # push/scan/post/verify（决定 failed vs unknown）
+    attempts = db.Column(db.Integer, default=0)                     # 尝试次数（超上限不再自动取）
+    published_at = db.Column(db.String(20), default="")
+    share_url = db.Column(db.String(300), default="")               # 作品分享链接（发布后抓取）
+    link_at = db.Column(db.String(20), default="")                  # 抓到链接的时刻
+    video_deleted_at = db.Column(db.String(20), default="")         # 平台素材文件何时被清理
+    push_verify = db.Column(db.String(16), default="")              # 推送后的相册校验：ok=进索引 / no_index=没进 / nofile=文件不在
+    push_remote = db.Column(db.String(200), default="")             # 推到手机上的绝对路径（删它/排查用）
+    posted_serial = db.Column(db.String(120), default="")           # **实际是哪台设备发的**（地址快照）
+    posted_device_name = db.Column(db.String(80), default="")       # **实际是哪台设备发的**（设备名，界面显示用）
+    last_error = db.Column(db.String(500), default="")
+    note = db.Column(db.Text, default="")
+    created_at = db.Column(db.String(20), default="", index=True)
+    updated_at = db.Column(db.String(20), default="")
+
+    __table_args__ = (
+        db.Index("ix_video_plan_date_status", "release_date", "status"),
+        db.Index("ix_video_plan_acct_date", "account_id", "release_date"),
+        db.Index("ix_video_plan_phone_slot", "phone", "release_date", "seq"),
+        db.Index("ix_video_plan_file", "video_file"),
+        # 主查询路径（按名字取待发计划/查重）——老库靠 _ensure_plain_indexes 补建
+        db.Index("ix_video_plan_name_date", "nickname", "release_date"),
+    )
+
+    def to_dict(self):
+        return {"id": self.id, "account_id": self.account_id or "",
+                "phone": self.phone or "", "device_name": self.device_name or "",
+                "nickname": self.nickname or "", "douyin_id": self.douyin_id or "",
+                "serial": self.serial or "", "release_date": self.release_date or "",
+                "seq": int(self.seq or 1), "seq_auto": bool(self.seq_auto),
+                "title": self.title or "", "body": self.body or "",
+                "video_file": self.video_file or "",
+                "video_name": self.video_name or "", "video_size": int(self.video_size or 0),
+                "video_sha1": self.video_sha1 or "", "status": self.status or "",
+                "stage": self.stage or "", "attempts": int(self.attempts or 0),
+                "published_at": self.published_at or "", "share_url": self.share_url or "",
+                "link_at": self.link_at or "", "video_deleted_at": self.video_deleted_at or "",
+                "push_verify": self.push_verify or "", "push_remote": self.push_remote or "",
+                "posted_serial": self.posted_serial or "",
+                "posted_device_name": self.posted_device_name or "",
+                "last_error": self.last_error or "", "note": self.note or "",
+                "created_at": self.created_at or "", "updated_at": self.updated_at or ""}
+
+    def __repr__(self):
+        return f"<VideoPlan {self.phone} {self.release_date} #{self.seq} {self.status}>"
+
+
 class AgentConversation(db.Model):
     """AI 控制台会话：整个消息序列以 JSON 存在一行里（单会话几十 KB，够用）。"""
     __tablename__ = "agent_conversation"
@@ -461,6 +614,15 @@ SCHEMA_MIGRATIONS = [
     (5, "设备池：device 表新增 fingerprint 列（设备指纹 ro.serialno，换 IP 后认领回原记录）", None),
     (6, "自动发现：pending_device 表新增 fingerprint 列（扫描时读取，用于提示是已有设备换了 IP）", None),
     (7, "去重账本：done_mark 表（跨设备幂等的「已做过」标记，唯一索引 scope_key）", None),
+    (8, "账号台账：device_account 表（设备号/手机号/账号名称/抖音号/注册时间/卡在机内/可发视频/简介/备注）", None),
+    (9, "视频发布计划：video_plan 表（账号×发布日期×编号 → 素材 + 标题 + 发布状态 + 分享链接）", None),
+    (10, "视频发布计划：video_plan 新增 push_verify（推送后相册校验：ok/no_index/nofile）"
+         "与 push_remote（手机上的绝对路径，删它/排查用）", None),
+    (11, "视频发布计划：video_plan 新增 body（正文）—— 标题 txt 一行里用 || 分隔「标题 || 正文」", None),
+    (12, "发布计划按名字发：计划行以 nickname 为识别键，新增 posted_serial/posted_device_name"
+         "（**实际是哪台设备发的**）；账号台账（device_account）停用但表与数据保留", None),
+    (13, "按名字找设备：device 表新增 cur_account_name/cur_name_at"
+         "（上次探测到的抖音当前账号名字，仅供人工入口做设备建议）", None),
 ]
 
 # 当前 schema 版本（备份/恢复用它判断新旧，也写进 app_meta.schema_version）
@@ -491,13 +653,20 @@ _MYSQL_UNIQUE_INDEXES = (
     ("ux_device_fingerprint", "device", "fingerprint_uq"),
 )
 
+# 普通索引：模型里已经声明了（`__table_args__`），但那对**已有表**不生效 ——
+# `create_all` 只建缺的表，不补已有表的新索引。这里按名字查了再建，老库升级也能有。
+_PLAIN_INDEXES = (
+    ("ix_video_plan_name_date", "video_plan", "nickname, release_date"),
+)
+
 
 def init_db(app):
     """在 Flask app context 里初始化数据库 + 创建默认管理员。
 
     web_server 启动时调用。自动迁移旧 groups.json/jobs.json 到数据库。
 
-    顺序：建表（create_all）→ 补列（_sync_columns）→ 版本账本 → 唯一索引 → 管理员/旧 JSON。
+    顺序：建表（create_all）→ 补列（_sync_columns）→ 版本账本 → 唯一索引 → 普通索引
+          → 管理员/旧 JSON。
     建表与补列都以模型定义为准，SQLite / MySQL 两种方言自动匹配，不再手写 DDL。
     """
     db.init_app(app)
@@ -506,6 +675,7 @@ def init_db(app):
         _sync_columns()
         _migrate_schema()
         _ensure_unique_indexes()
+        _ensure_plain_indexes()
         _ensure_default_admin()
         _migrate_old_json()
 
@@ -638,6 +808,26 @@ def _ensure_unique_indexes_mysql():
             _log.warning(f"唯一索引 {name} 创建失败（历史数据可能有重复）: {e}")
 
 
+def _ensure_plain_indexes():
+    """补建模型里声明、但已有表上还没有的普通索引（幂等）。
+
+    SQLite / MySQL 都能跑同一条 `CREATE INDEX`（MySQL 5.7 没有 `IF NOT EXISTS`，
+    所以先 inspect 查名字再建，不靠方言特有能力）。
+    """
+    from sqlalchemy import inspect
+    for name, table, cols in _PLAIN_INDEXES:
+        try:
+            have = {i["name"] for i in inspect(db.engine).get_indexes(table)}
+            if name in have:
+                continue
+            db.session.execute(text("CREATE INDEX {} ON {}({})".format(name, table, cols)))
+            db.session.commit()
+            _log.info(f"已建索引 {name}")
+        except Exception as e:
+            db.session.rollback()
+            _log.warning(f"索引 {name} 创建失败（不阻塞启动）: {e}")
+
+
 def _ensure_default_admin():
     """首次启动创建默认管理员 admin/admin123。"""
     if not User.query.filter_by(username="admin").first():

core/notify_events.py

@@ -111,6 +111,26 @@ EVENTS = [
        ["serial", "device_name", "selector", "miss_count"],
        "某选择器连续 10 次未命中——任务可能显示成功但什么都没做", agg_window=0,
        recommend=True),
+    _e("task.account.switch_failed", "切号失败", "业务",
+       ["serial", "device_name", "model", "want", "got", "attempts", "msg"],
+       "想切到某个账号但没切成功（列表里找不到这个名字，或切完读回来的还是别人）——"
+       "**本次不会发这个号的内容**。请人工到设备上确认这个号还在不在抖音的账号列表里",
+       agg_window=0, agg_key=_BY_SERIAL, recommend=True),
+    _e("task.account.need_login", "需要登录/验证码", "业务",
+       ["serial", "device_name", "model", "want", "msg"],
+       "抖音停在登录页或要验证码 —— **需要人工登录**（平台绝不代替登录/过滑块），"
+       "本设备已停止本轮任务", agg_window=0, agg_key=_BY_SERIAL, recommend=True),
+    _e("task.video.published", "视频已发布", "业务",
+       ["serial", "device_name", "model", "phone", "nickname", "release_date", "seq",
+        "title", "share_url"],
+       "「发布视频」步骤把某个账号的视频发出去了（share_url 是作品分享链接，"
+       "没抓到链接时为空——界面上会标「缺链接」）", agg_window=0, recommend=True),
+    _e("task.video.failed", "视频发布失败/结果未知", "业务",
+       ["serial", "device_name", "model", "phone", "nickname", "release_date", "seq",
+        "title", "msg"],
+       "「发布视频」步骤失败：推文件阶段失败=可重试；抖音那一步失败=**可能已经发出去了**，"
+       "要到计划页看状态并人工确认（平台不会自动重发）", agg_window=0,
+       agg_key=_BY_SERIAL, recommend=True),
 
     # ---------------- 设备 ----------------
     _e("device.online", "设备恢复在线", "设备",

core/system_backup.py

@@ -58,6 +58,8 @@ TABLE_LABELS = {
     "agent_action": "动作库", "device_install_log": "设备端安装记录",
     "task_step_log": "任务步骤明细",
     "done_mark": "去重记录（已做过）",
+    "device_account": "账号台账",
+    "video_plan": "视频发布计划",
 }
 _STAGE_TTL = 1800  # 导入暂存有效期（秒）
 
@@ -139,6 +141,46 @@ def _summary_info(con):
     return rows
 
 
+def _video_summary():
+    """视频素材目录的概况（写进 manifest；**不进备份包**，但要交代清楚）。
+
+    · `missing`：`video_plan` 引用了、但文件已经不在了的清单 —— 反向自检
+      （与 `coverage_missing` 同一个思路：别让"看起来有其实没有"悄悄发生）
+    """
+    try:
+        from config import VIDEO_DIR
+    except Exception:
+        return {"included": False, "error": "config 读取失败"}
+    count = 0
+    size = 0
+    try:
+        for root, _dirs, files in os.walk(VIDEO_DIR):
+            for fn in files:
+                if fn.startswith(".tmp_"):
+                    continue
+                try:
+                    size += os.path.getsize(os.path.join(root, fn))
+                    count += 1
+                except OSError:
+                    pass
+    except Exception:
+        pass
+    missing = []
+    try:
+        from core.models import VideoPlan
+        with db.app_context():
+            for r in VideoPlan.query.filter(VideoPlan.video_file != "").all():
+                p = os.path.join(VIDEO_DIR, r.video_file)
+                if not os.path.exists(p):
+                    missing.append({"id": r.id, "file": r.video_file})
+    except Exception:
+        pass
+    return {"included": False, "dir": "data/videos", "count": count, "bytes": size,
+            "note": "视频素材不进备份包（体积）。恢复后需重新上传；"
+                    "计划、发布状态与分享链接在 video_plan 表里，已备份。",
+            "missing": missing[:200], "missing_count": len(missing)}
+
+
 def _prune_old_exports(max_age=3600):
     """清理过期的导出临时 zip（下载完成后的 call_on_close 在 Windows 上可能
     因文件锁删不掉，这里按时间兜底清理；保留近 1 小时的便于失败重试）。"""
@@ -298,6 +340,9 @@ def create_export(include_apk=True):
             "include_apk": include_apk,
             "tables": _summary_info(con),
             "apks": apk_meta,
+            # 视频发布计划的素材**不进备份包**（几十 GB 会把备份能力搞坏），
+            # 但必须在 manifest 里交代清楚 —— 否则就是"以为备份了其实没有"（红线）。
+            "videos": _video_summary(),
         }
         # 覆盖自检：登记在册的业务表若在快照里缺失（新增功能忘了登记 / 建表失败），
         # 显式告警并写进 manifest——避免"以为备份了其实没有"（备份覆盖红线）。

core/task_draft.py

@@ -59,7 +59,7 @@ NEED_SELECTOR = ("click", "long_click", "wait_el", "swipe_until", "if_el")
 # 需要包名的步骤类型
 NEED_PACKAGE = ("open_app", "stop_app")
 # 需要非空 children 的容器
-NEED_CHILDREN = ("loop", "group")
+NEED_CHILDREN = ("loop", "group", "foreach_account")
 
 # 有副作用的动作关键词：命中的步骤在 AI 通道只给 warning（人工复核），不拦
 DESTRUCTIVE_HINTS = ("评论", "发送", "发布", "投稿", "转发", "分享到",
@@ -225,12 +225,19 @@ def validate_steps(steps, depth=1, path="steps", errors=None, warnings=None,
             # 执行器对认不出的运算符是"一律不命中"，写错了会静默走 else，
             # 所以在这里拦住，别让 AI 草稿悄悄变成"永远不命中"
             cmp_op = (params.get("cmp_op") or "").strip()
+            cmp_src = (params.get("cmp_source") or "").strip()
+            if cmp_src not in ("", "manual", "release", "account_target"):
+                errors.append(f"{here}.params.cmp_source: 不支持的候选值来源 {cmp_src!r}"
+                              f"（可用：空/manual/release/account_target）")
             if cmp_op:
                 from tasks.generic.task import CMP_OPS
                 if cmp_op not in CMP_OPS:
                     errors.append(f"{here}.params.cmp_op: 不支持的比对运算符 {cmp_op!r}"
                                   f"（可用：{'、'.join(CMP_OPS)}）")
-                elif not str(params.get("cmp_value") or "").strip():
+                elif not str(params.get("cmp_value") or "").strip() \
+                        and cmp_src not in ("release", "account_target"):
+                    # 候选值来自发布计划 / 本次要发的名字时，允许手填留空（候选由平台给）；
+                    # 其余情况仍要求填值，否则永远不命中
                     errors.append(f"{here}.params.cmp_value: 选了文本比对"
                                   f"（{cmp_op}）就必须填比对的值，否则永远不命中")
                 elif (params.get("selector_type") or "xpath") == "screen":
@@ -268,6 +275,10 @@ def validate_steps(steps, depth=1, path="steps", errors=None, warnings=None,
                               f"（当前 min={lo!r} max={hi!r}）")
 
         if stype == "input_text":
+            # 文案来自「发布计划」（`text_source` 不是 manual）时 texts/fixed_text **都不参与输入** ——
+            # 别按"手填"的规则要求候选文案（发布任务骨架里那两步就是这么配的：
+            # mode 留默认、内容由计划给，靠 `release_title`/`release_body` 现取）
+            if str(params.get("text_source") or "manual").strip() == "manual":
                 mode = params.get("mode", "random")
                 if mode not in ("random", "fixed"):
                     errors.append(f"{here}.params.mode: 必须是 random 或 fixed"

doc/API.md

@@ -62,7 +62,9 @@
 
 ## 2. 接口总索引
 
-> 共 **107 条路由**。`鉴权` 列：`—` 无、`L` 登录、`T/D/A/G` = tasks/devices/apks/logs 权限位、`Admin` 仅管理员。
+> 本表列出全部业务路由（页面路由除外；同一路径的不同方法合并成一行）。
+> `鉴权` 列：`—` 无、`L` 登录、`T/D/A/G` = tasks/devices/apks/logs 权限位、`Admin` 仅管理员。
+> 想看实际注册了多少条：`python -c "from web_server import app; print(len([r for r in app.url_map.iter_rules() if r.rule.startswith('/api')]))"`。
 
 ### 2.1 auth（`web/auth.py`）
 
@@ -137,6 +139,21 @@
 | GET | `/api/done_marks?job=&limit=` | L | 去重记录列表 + 统计（`{marks, stats{total,devices,identities,today_devices,today_identities}}`） |
 | POST | `/api/done_marks/delete` | T | 删一条去重记录（`{id}`）→ 该设备/身份下次会重新执行 |
 | POST | `/api/done_marks/clear` | T | 清空某任务的全部去重记录（`{job}`）→ 整批重跑 |
+| POST | `/api/video_plan/upload_video` | D | 上传单个素材（**视频或图片**，文件名 `名字_日期_编号`）→ 解析名字 + 入计划 |
+| POST | `/api/video_plan/upload_titles` | D | 上传标题（txt 文本或文件）→ 配到已有计划行 |
+| GET | `/api/video_plan/timeline` | D | 发布计划时间线（按日期分组的卡片 + 统计 + 磁盘） |
+| GET | `/api/video_plan/stats` | D | 今天要发/已发/待标题/过期未发 + 素材占用与磁盘余量 |
+| GET/PUT/DELETE | `/api/video_plan/<id>` | D | 单条计划：查看 / 改标题·正文（`PUT {title,body}`）/ 删除（连素材文件） |
+| GET | `/api/video_plan/<id>/video` | D | 预览平台上的素材（文件清理后 → 410） |
+| POST | `/api/video_plan/<id>/push` | D | **把素材推到手机**（只推送、不发布；后台线程） |
+| POST | `/api/video_plan/push_all` | D | **一键推送**：某天（默认今天）所有待发布/失败的计划 → 各自手机（每台设备一个线程、设备内串行） |
+| POST | `/api/video_plan/<id>/mark` | D | 人工标记结果（`done`/`failed`/`unknown`，推完之后用） |
+| POST | `/api/video_plan/<id>/skip\|retry\|resolve` | D | 跳过 / 重试 / 裁决「结果未知」 |
+| GET | `/api/video_plan/links` | D | 已发布作品的分享链接（`format=csv` 导出，给铺评论用） |
+| GET | `/api/video_plan/tasks` | T | 可编辑的任务列表（全部通用步骤任务 + `is_release` 标记：状态/调度/下次运行 + 完整步骤） |
+| POST | `/api/video_plan/tasks` | T | 一键新建标准发布任务（骨架 18 步：亮屏 → 打开抖音 → 读本机账号名字 → 校验账号 → 推送 → 抖音点击 → 填标题 → 填正文 → 标记） |
+| GET/PUT | `/api/video_plan/tasks/<job_id>` | T | **发布任务的就地编辑**（就在「发布计划」页改名字/目标/时间/启停/步骤） |
+| POST | `/api/video_plan/tasks/<job_id>/adopt` | T | 给已有任务插上平台两步（推送放最前 / 标记放最后，自己的步骤不动） |
 
 ### 2.4 admin（`web/admin_api.py`）
 
@@ -482,6 +499,40 @@
 账本表与语义见 [DATA_MODEL.md](DATA_MODEL.md) §2.9；任务侧怎么用见
 [TASK_DEV.md](TASK_DEV.md) §4.6。
 
+### 视频发布计划（「发布计划」页）
+
+表与状态机见 [DATA_MODEL.md](DATA_MODEL.md) §2.11，任务侧怎么自动发布见
+[TASK_DEV.md](TASK_DEV.md) §4.7；权限 `devices`。
+
+| 接口 | 请求 | 响应要点 |
+|------|------|---------|
+| `POST /api/video_plan/upload_video` | multipart `file`（单文件，**视频或图片**）+ `replace` | `{ok,name,action:add\|skip\|replace,plan,msg}`；解析不通过 → **400 + `error`（人话原因）**。前端**逐文件串行**发（才能给每个文件一条进度与结果） |
+| `POST /api/video_plan/upload_titles` | `{text, dry_run}` 或 multipart `file`（txt） | `{ok, counts:{total,attached,skipped,rejected}, rows:[{line,name,date,seq,title,body,action,error}], msg}`；**一行里可带正文**：`标题 || 正文_名字_日期_编号`（`||` 分隔，正文可省，只切第一处）；**只有这一种写法**（名字在日期前一段，右锚定）；**编号可省略**；标题/正文里可以有下划线和 `#话题`；空行忽略，`#` 开头的行**只有认不出名字/日期时**才当注释；拒收条件：名字里带下划线/是纯数字/是手机号、日期不合法、标题为空或 >100 字、该槽位已有标题、没有对应视频 |
+| `GET /api/video_plan/timeline` | `?range=today\|week\|all&from=&to=&status=&q=&limit=` | `{ok, days:[{date,weekday,total,done,plans:[…]}], stats, disk, today}` |
+| `GET /api/video_plan/stats` | — | `{ok, stats, disk, today}`；`stats` 里**三个口径都给**：`today_ready`（今天要发几个号，按发布日期）/ `today_done`（今天完成）/ `published_today`（今天实际发的，按 `published_at`，补发也算今天） |
+| `GET /api/video_plan/<id>` · `PUT` · `DELETE` | `PUT {"title","body","nickname"}` | `PUT` 改标题/正文/**名字**（名字 = 识别键，走同一套校验：不许含下划线/不许纯数字；改完按"有没有内容"切 `pending↔ready`）；`DELETE` **先删行再删素材文件** |
+| `GET /api/video_plan/<id>/video` | — | 素材预览（`send_file`，支持 Range）；文件已被清理 → **410** |
+| `POST /api/video_plan/<id>/push` | — | **把素材推到手机**（只推送、不发布）：**按名字找设备**（实时探测哪台在线设备登着这条计划的名字）→ 推文件 → 触发相册刷新 → 标题写进剪贴板；已推送/结果未知 → 409；没有设备登着这个名字 → **400 + 人话原因**（先去切号） |
+| `POST /api/video_plan/push_by_account` | `{date?, retry_failed?, serials?}` | **一键推送（按名字找设备）**：某天（默认今天）`ready`/`failed` 且未超尝试上限的计划 → 按 `nickname` 分组 → **实时探测**在线设备当前登的号（跳过正在跑任务的设备）→ 每台设备一个线程、设备内串行。返回 `{ok,count,devices,matched:[{name,count,serial,device_name}],unmatched:[{name,count,reason}],msg}`；**全部 unmatched → 400**（`error` 里逐条说清"没有在线设备登着这个号"）。`serials` 可只探指定设备 |
+| `POST /api/video_plan/push_all` | 同上 | 老入口，语义与 `push_by_account` 完全一致（都按名字找设备） |
+| `POST /api/video_plan/<id>/mark` | `{status: done\|failed\|unknown, why}` | 人工标记结果（推完之后用）：`done` 补 `published_at`；`failed`/`unknown` 把 `why` 记进 `last_error` |
+| `POST /api/video_plan/<id>/skip` | `{reason}` | 人工跳过 |
+| `POST /api/video_plan/<id>/retry` | — | `failed`→`ready`，`attempts` 清零 |
+| `POST /api/video_plan/<id>/resolve` | `{published, note}` | **`unknown` 的人工裁决**：确认真发出去了 → `done`；确认没发 → `failed`（可重试） |
+| `GET /api/video_plan/links` | `?from=&to=&name=&format=csv` | 已发布作品的分享链接；CSV 带 BOM（Excel 打开中文不乱码）。列：发布日期/**名字**/编号/标题/**正文**/分享链接/发布时间 |
+| `GET /api/video_plan/tasks` | — | `{ok, tasks:[{id,name,enabled,mode,cron,next_run,target,steps,step_count,schedule,retry,is_release,has_push}], release_count, other_count}`：**全部通用步骤任务**（不止发布任务 —— 只列发布任务的话，手写的抖音发布流程会一条都不显示，人会以为"这页没有能改的地方"），界面按 `is_release`（有 `push_release` **或** `mark_release`，含嵌套）分两组。带完整 `steps` 是为**就地编辑**（抓选择器）；`step_count` 数的是**含嵌套**的总步数。权限 `T` |
+| `POST /api/video_plan/tasks` | `{"name","target":{"mode":"all\|group\|serial","group_name","serial"},"time":"10:00","enabled"}` | 一键新建：骨架 **18 步**（亮屏 → 打开抖音(等首页) → 点「我」→ `read_account_name` 读本机账号名字（昵称控件的选择器填在 .env）→ `if_el(cmp_source=account_target)` 校验登的是不是要发的名字 → then: `push_release(account=name)` → 「+」(预填 `descriptionContains=拍摄`) → 相册/第一个视频/下一步/标题框/正文框/发布（**空选择器占位**）→ `input_text(text_source=release_title)` → `input_text(text_source=release_body)` → `mark_release`；else: `notify` 跳过）；**走 TaskManager 建**（内存+库一起更新，直接写库调度器不认）。⚠ `target` 分组键名是 **`group_name`**（写成 `group` 会静默解析出 0 台设备）；分组/单设备没给具体目标 → 400。权限 `T` |
+| `GET/PUT /api/video_plan/tasks/<job_id>` | `PUT {name?, time?, target?, steps?, enabled?}` | **发布任务的就地编辑**（「发布计划」页里改，不用跳任务页）。只放开这几个字段，**没传的字段原样保留**；`steps` 整块替换但 `params` 里的通用参数（去重有效期、抢占…）**深合并保留**。校验：空名字/坏时间/`steps` 不是数组/什么都不传 → 400，未知任务 → 404。权限 `T`。底层仍是 `TaskManager.update_job()`（内存+库一起改） |
+| `POST /api/video_plan/tasks/<job_id>/adopt` | — | 给**已有任务**插上平台那两步：`push_release` 放最前、`mark_release` 放最后（**中间你自己的步骤一步不动**；位置理由见 `core.video_plan.insert_release_steps`）。只对「通用步骤」任务；没有步骤 → 400，已经有这两步 → 409，未知任务 → 404。权限 `T` |
+
+**逐文件上传的幂等**：同一 `(名字,日期,编号)` 已有行时 —— 文件内容相同 → `action=skip`（不重复落盘）；
+内容不同 → **拒收**，前端给「覆盖」按钮（二次确认后带 `replace=1` 重传）。
+标题同理：同槽位已有别的标题 → 拒收（不静默覆盖，文案是发出去就改不了的东西）。
+
+> ⚠ 上传体积：`MAX_CONTENT_LENGTH`（默认 2GiB，`.env` 的 `MAX_UPLOAD_MB` 可调）**必须大于
+> 「应用管理」最大的 APK**（实测 336MB），否则 APK 上传会被一起卡死；超限返回 **JSON 413**。
+> 上反代时 nginx 那侧还要 `client_max_body_size`（见 [DEPLOY.md](DEPLOY.md) §6）。
+
 ---
 
 ## 6. 设备池与自动发现
@@ -719,7 +770,7 @@
 
 | 接口 | 请求 | 说明 |
 |------|------|------|
-| `POST /api/tools/clipboard/set` | `{"serials":[…],"text":"…"}` | ClipInject 通道写入并读回校验；serials 空或非列表 → 400 |
+| `POST /api/tools/clipboard/set` | `{"serials":[…],"text":"…"}` | 设备端 Agent 通道写入并读回校验（旧版独立 ClipInject 自动兜底）；serials 空或非列表 → 400 |
 | `POST /api/tools/appver` | `{"package":"com.xxx"}` | 并发查所有在线设备（≤10 并发）；包名须匹配 `^[A-Za-z0-9_.]+$` |
 
 ### Tailscale（全部 Admin）

doc/ARCHITECTURE.md

@@ -86,7 +86,7 @@
 | 阶段 | 位置 | 做了什么 |
 |------|------|---------|
 | **E** | `:64-67` | `context.init(...)`；`register_blueprints(app)`（10 个蓝图）；`agent_api.set_app(app)`（供后台线程推 app context） |
-| **F** | 同上附近 | **第二个独立 APScheduler**：`CronTrigger(hour=3, minute=47)` 挂经验库巡检、`hour=4, minute=13` 挂步骤明细清理（`_purge_step_log`）、`hour=4, minute=23` 挂去重记录清理（`_purge_done_mark`，只清 `day`/`hours` 桶）——两个清理任务都自建 app context；失败仅 warning |
+| **F** | 同上附近 | **第二个独立 APScheduler**：`CronTrigger(hour=3, minute=47)` 挂经验库巡检、`hour=4, minute=13` 挂步骤明细清理（`_purge_step_log`）、`hour=4, minute=23` 挂去重记录清理（`_purge_done_mark`，只清 `day`/`hours` 桶）、`hour=4, minute=41` 挂发布计划清理（`_purge_video_plan`：僵尸占位回收 + 过期行）、`hour=4, minute=47` 挂素材文件清理（`_purge_video_files`）——时间刻意错开（都是删数据的大操作），各任务自建 app context；失败仅 warning。**僵尸回收是必须有的一步**：占位后崩溃的行没有它会永远卡在"推送中"，再也不会被取到 |
 | **G** | `__main__` | `_ensure_uiauto_running()`（拉起 uiautodev:20242，写 `data/uiauto.pid`，`atexit` 清理）→ `_preconnect_pool_devices()`（后台并发 connect 池内网络设备）→ `_purge_step_log_async()`（后台清理超期步骤明细）→ `_run_server()`（候选端口依次 bind：`0.0.0.0:18050` → `127.0.0.1:18050` → `127.0.0.1:18051..18055`）；退出时 `notifier.shutdown()` + `step_log.shutdown()` + `mgr.shutdown()` + `device_discovery.shutdown()` + `device_battery.shutdown()` + 停 uiautodev |
 
 > ⚠️ **阶段 A~F 在 import 期就会起线程/调度器**，只有 uiautodev 拉起与预连接在 `__main__` 分支。以 WSGI 方式 import 本模块会得到"半个启动"的进程——本地调试请直接 `python web_server.py`。
@@ -270,7 +270,7 @@ connecting ──获取设备──▶ u2 连接 ──▶ running ──▶ set
 
 ### 6.1 单页应用
 
-- 主页面 `templates/admin/monitor.html`：一个内联 `<style>` + 7 个 Tab 面板 + 10 个模态框容器 + 16 个 `<script src>`
+- 主页面 `templates/admin/monitor.html`：一个内联 `<style>` + 8 个 Tab 面板 + 10 个模态框容器 + 17 个 `<script src>`
 - 独立页面：`login.html`（登录）、`wall.html`（监控大屏，**完全自包含**，自带 CSS/JS，不加载 `static/admin/*.js`）
 - 服务端内联页：`GET /locate`（设备端定位大字页，免登录）
 - 响应头强制 `no-store`，避免后台改版后浏览器拿旧页面
@@ -280,6 +280,7 @@ connecting ──获取设备──▶ u2 连接 ──▶ running ──▶ set
 | 顶级 Tab | `data-tab` | 权限 | 子分栏 |
 |---------|-----------|------|--------|
 | 监控 | `monitor` | 登录即可 | — |
+| **发布计划** | `plan` | `devices` | 上传视频与标题（按**名字**配对）、时间线、推送到手机、导出链接 + **发布任务就地编辑**（见 [DATA_MODEL.md](DATA_MODEL.md) §2.11）。2026-10-12 起「账号台账」整页下线（表保留），本页从「账号」页的子分栏升为一级页签 |
 | 任务 | `tasks` | 登录即可（写操作需 `tasks`） | `plan` 任务计划 / `actions` 自定义动作 / `actioncfg` 动作配置 / `dedup` 去重记录 |
 | 日志 | `logs` | `logs` | — |
 | 用户 | `users` | `admin` | — |
@@ -296,6 +297,7 @@ connecting ──获取设备──▶ u2 连接 ──▶ running ──▶ set
 | `base.js` | esc / CSRF / 权限 / API 封装 / Toast / Tab 与子分栏切换 / 模态框 / 常量表 | 所有模块的公共底座 |
 | `markdown.js` | 轻量 Markdown 渲染（`renderMarkdown`） | 无 CDN 依赖；**先转义再套标记** |
 | `list.js` | 统一列表组件：搜索 + 分页 + 排序 | 状态注册表 `_LIST_PAGERS`；`setListPager` **不重置**页码/搜索/排序（避免轮询刷新打断用户） |
+| `release.js` | 发布计划页（时间线按日期分组 / 多选**素材（视频/图片）**串行上传 + 逐文件进度与结果 / 标题+正文 txt 上传（`标题 || 正文_名字_日期_编号`，卡片与明细**以名字为主**）/ 推送到手机 + **一键推送**（当天全部，**按名字找设备**：实时探测哪台在线设备登着这个号，逐条报出"没有设备登着"的号）、相册校验徽章与裁决 / 链接复制与导出 CSV / **发布任务的就地编辑**） | 服务层 `core/video_plan.py`（实时探测在 `core/account_probe.py`）；上传前把队列**按文件名排序**并让用户确认解析结果（顺序 = "无编号按顺序配"的依据）。就地编辑只放常用字段（名字/目标/时间/启停/逐步参数 + 抓取元素），更复杂的编排走「打开通用编辑器」→ `openTaskModal`；步骤路径里 `then/else/children` 在**步骤的 params 下**（`_rpWalk`），走错这一层会把分支当数组下标用 |
 | `monitor.js` | 监控页：设备表（含**电量列**，按 `battery.tier` 上色）、批量操作、异常汇总、任务概况卡片（含覆盖设备 chip） | 5s 轮询 + 脏检查（签名不变不重渲染） |
 | `editor.js` | 步骤编辑器（拖拽 / 参数表单 / 条件分支 / 元素抓取 / 测试此步骤）+ `saveTask` | 最大的前端文件；`_stepEditor` 单例；设备选择卡 `_devCard` 供「抓取元素」「测试此步骤」共用（**名字优先**，型号·地址作副标题） |
 | `tasks.js` | 任务 Tab：任务 CRUD / 调度解析 / 运行窗口 + 自定义动作 | |

doc/DATA_MODEL.md

@@ -16,7 +16,7 @@
 | SQLite 回退时的 PRAGMA | `journal_mode=WAL`、`busy_timeout=5000`、`synchronous=NORMAL`（监听器按连接类型守卫，MySQL 连接不会执行） |
 | 建表方式 | **唯一真相是模型**：`db.create_all()`（建缺表）+ `_sync_columns()`（补缺列）；`SCHEMA_MIGRATIONS` 只作版本账本与数据回填 |
 | 库位置 | MySQL：由 `DB_HOST/DB_NAME` 指定；SQLite：`data/users.db` |
-| 当前 schema 版本 | `app_meta.schema_version = 6` |
+| 当前 schema 版本 | `app_meta.schema_version = 11`（迁移清单见 `core/models.py` 的 `SCHEMA_MIGRATIONS`：建表/补列以模型为准，这里只作版本账本） |
 
 **环境与库的绑定**（防混库，见 [DEPLOY.md](DEPLOY.md) §2.2）
 
@@ -27,7 +27,7 @@
 
 启动时校验「`.env` 声明」与「库名」「库中登记的 `app_meta.deployment_env`」三方一致，不符**拒绝启动**。
 
-**表清单（14 张，全部是 `core/models.py` 里的 ORM 模型）**
+**表清单（17 张，全部是 `core/models.py` 里的 ORM 模型）**
 
 | # | 表 | 用途 |
 |---|---|------|
@@ -45,6 +45,9 @@
 | 12 | `agent_action` | 动作库（命名动作） |
 | 13 | `device_install_log` | 设备端应用商店的下载/安装记录（设备上报，见 [DEVICE_AGENT.md](DEVICE_AGENT.md)） |
 | 14 | `task_step_log` | 任务步骤明细（每次步骤执行一条，见 §2.8；**唯一有无界增长风险的表**，靠保留期清理） |
+| 15 | `done_mark` | 去重账本：跨设备"已做过"标记（见 §2.9；本清单此前漏列，2026-09-24 补上） |
+| 16 | `device_account` | **已停用**：账号台账（见 §2.10；2026-10-12 起页面/接口/任务依赖全部下线，**表和 42 行历史数据保留、仍在备份内**，可回滚） |
+| 17 | `video_plan` | 视频发布计划：**名字** × 发布日期 × 编号 → 素材 + 标题/正文 + 发布状态 + 分享链接（见 §2.11） |
 
 > 2026-09-13 之前，`app_meta` 与 4 张 `agent_*` 表是各模块里的裸 `CREATE TABLE`
 > （不进模型层）。迁 MySQL 时那批 SQL 的 `AUTOINCREMENT`/`TEXT DEFAULT ''`/`TEXT PRIMARY KEY`
@@ -125,6 +128,7 @@
 | `note` | Text | `""` | |
 | `created_at` | String(20) | `""` | |
 | `fingerprint` | String(120) | `""` | **设备指纹**（`ro.serialno`，迁移 v5 追加）：同一台物理设备换 IP 后据此认领回原记录 |
+| `cur_account_name` / `cur_name_at` | String(80)/String(20) | `""` | **上次探测到的抖音当前账号名字**（迁移 v13 追加）：只有「按名字找设备」（计划页的推送）会写它。**纯缓存** —— 自动任务永远现场读屏幕，缓存旧了也不影响发布的正确性；界面上带时间戳显示 |
 
 ### 2.7 `pending_device` — 待确认的发现设备
 
@@ -197,6 +201,98 @@
 
 ⚠️ 这张表**自动进整库备份**（§6 派生规则）；接任务步骤见 [TASK_DEV.md](TASK_DEV.md) §4.6。
 
+### 2.10 `device_account` — 账号台账（**已停用，表保留**）
+
+> **2026-10-12：账号管理整块下线。** 页面（「账号」页）、接口（`/api/ledger*`）、
+> 服务层（`core/ledger.py` 已删）、任务取号（`cmp_source=device/all/group`）、
+> 设备端身份页的账号块（`accounts_b64`）、设备池的「账号 N」列**全部移除**。
+>
+> 为什么留着表和这 42 行数据：**删数据不可逆**，而这张表在备份清单里（红线：功能涉及的数据
+> 必须纳入备份）—— 先停用、确认稳定后再单开一次清理动作。
+> 发布计划改走**名字**（见 §2.11），不再需要台账。
+>
+> 唯一从 `core/ledger.py` 迁走的是 `serial_of(设备名) → 当前地址`（与账号无关），
+> 现在在 `core/device_pool.py`。
+
+历史结构（停用前）：一台设备上登录着哪些账号。「账号」页维护。
+
+| 列 | 类型 | 说明 |
+|----|------|------|
+| `id` | String(32) PK | uuid 前 8 位 |
+| `device_name` | String(80) **index** | 设备号（= 设备池里的**设备名**，如 `A01`） |
+| `serial` | String(120) | 录入时的**地址快照**（设备换 IP / 改名后台账仍能靠任一侧找回） |
+| `phone` | String(32) index | 手机号 |
+| `nickname` | String(80) | 账号名称 |
+| `douyin_id` | String(64) index | **抖音号（纯号）**，如 `35377983067` |
+| `registered_at` | String(20) | 注册时间（**原样存文本**，如 `2026/9/24`） |
+| `sim_in_device` | Boolean | 卡在机内（**空 = 否**） |
+| `can_post_video` | Boolean | 可发视频（**空 = 否**） |
+| `bio` / `note` | Text | 简介 / 备注 |
+| `created_at` / `updated_at` | String(20) | 字符串时间（仓库惯例） |
+
+**（停用前的）三个使用方**：① web「账号」页（列表/增删改/从 Excel 粘贴导入）；
+② 任务「条件判断」取号（`cmp_source=device/all/group`）；③ 手机端 Agent 的身份大字页（`accounts_b64`）。
+**三个都已移除**；发布计划现在按**名字**走（§2.11）。
+
+⚠️ 历史提醒：`douyin_id` 是纯号，**绝不能当去重身份**（`done_mark.identity` 存的是元素原文、
+逐字算 key，格式不一致会让去重静默失效）—— 这是当年 `cmp_source` 取号的边界，
+现在候选值来自"本次要发的名字"，同理不得拿去填 `ident_value`。
+
+这张表**仍在整库备份内**（§6 派生规则）—— 停用不等于删数据。
+
+### 2.11 `video_plan` — 视频发布计划（**一个名字**在某天要发的一个视频）
+
+「发布计划」页维护；服务层 `core/video_plan.py`，接口 `/api/video_plan/*`（见 [API.md](API.md) §2.14），
+任务步骤「发布视频」按它自动发布（见 [TASK_DEV.md](TASK_DEV.md) §4.7）。
+**素材文件（视频/图片）**落在 `data/videos/YYYY-MM/`（文件名 `{sha1[:12]}_{安全原名}`，内容寻址），**不进整库备份**（§6）。
+
+| 列 | 类型 | 说明 |
+|----|------|------|
+| `id` | String(32) PK | uuid 前 8 位 |
+| `nickname` | String(80) | **识别键**：上传文件名里的**名字**（= 抖音昵称）。运行时就按它取计划、找设备/账号 |
+| `account_id` / `phone` / `douyin_id` / `device_name` / `serial` | String | **已停用**（老台账快照，保留列不再写入）：账号 id / 手机号 / 抖音号 / 设备号 / 地址 |
+| `release_date` | String(10) index | **`2026-09-12`** 纯日期（等值比较走索引） |
+| `seq` / `seq_auto` | Integer / Boolean | 编号从 **1** 起（不用 0 表示"无"）；`seq_auto`=号是自动分配的 |
+| `title` | Text | **标题**（发布页的「标题」框；标题 txt 配对写入） |
+| `body` | Text | **正文/文案**（发布页的文案框，可带 `#话题`）—— 标题 txt 一行里用 `||` 分隔：`标题 || 正文_名字_日期_编号`；**标题与正文都为空的行不会被发布** |
+| `video_file` / `video_name` / `video_size` / `video_sha1` | 各自 | **素材**（视频或图片，看扩展名）：落盘相对路径 / 原始名 / 大小 / 内容指纹（重复上传判据）。推送时**扩展名原样带到手机**——抖音按它判断视频还是图文 |
+| `status` | String(16) index | 见下方状态机 |
+| `stage` | String(16) | 失败发生在哪一步：`push`/`scan`/`post`/`verify` |
+| `attempts` | Integer | 尝试次数（上限 3，超了不再自动取） |
+| `published_at` / `share_url` / `link_at` / `video_deleted_at` | String | 发布时刻 / **作品分享链接** / 抓到链接的时刻 / 素材何时清理 |
+| `push_verify` / `push_remote` | String(16)/String(200) | **推送后的相册校验**：`ok`=已进相册索引 / `no_index`=文件在但没进索引（相册里可能看不到）/ `nofile`=文件不在；`push_remote` = 推到手机上的绝对路径（删它、排查用）。**文件推上去了 ≠ 相册里点得到它**，所以单独存一列而不是混进 `last_error` |
+| `posted_serial` / `posted_device_name` | String(120)/String(80) | **实际是哪台设备发的**（推送时现场写）。计划不再绑设备，所以"这条最后是谁发的"只能这么记 —— 排查"怎么发到那台机器上去了"全靠它 |
+| `last_error` / `note` / `created_at` / `updated_at` | | 失败原因 / 人工备注 / 时间 |
+
+**状态机**（本表的灵魂，别简化）：
+
+```
+pending    有视频、还没标题              ready      素材齐，等推送
+pushing    已推到手机（等人/用户的步骤去发）  done       已发布（终态）
+skipped    人工跳过（终态）              failed     推送阶段就失败 —— 还没到抖音，**可安全重试**
+unknown    推送之后出的岔子 —— **可能已经发出去了，绝不自动重试**，要人工裁决
+```
+
+> **平台只负责把素材推到手机**（`push_release` 步骤 / 计划页「推送到手机」）：
+> 推文件 → 触发相册刷新 → 把标题写进手机剪贴板。**抖音里怎么发由用户在任务画布上自己写**，
+> 最后放一个 `mark_release`「标记发布结果」回写这里的状态（`published`→`done`、`failed`、`unknown`）。
+> 这样抖音改版时用户改自己的步骤即可，不用等平台发版。
+
+> ⚠ **`failed` 与 `unknown` 必须分开**：把"不知道自己发没发"混成"知道自己没发"，
+> 就是重复发布的来源。`stage` 是两者互相转换的唯一依据（`core/video_plan.STAGE_STATUS`）。
+> 界面上的 `unknown` 卡片标橙 + 硬提示，人工到抖音确认后点「已发出 / 未发出」裁决。
+
+**唯一性**：`(nickname, release_date, seq)` 由**服务层**保证，**不加 DB 唯一索引** ——
+`seq` 从 1 起、没有"空值"可言，做部分唯一索引要写三处方言适配 + MySQL 生成列（§4.2），
+收益不匹配；违反的代价只是低频人工上传产生的重复行（可见、可删）。
+
+**索引**：`(release_date,status)` 时间线主查询 · `(nickname,release_date)` **按名字取计划/查重**（主路径）·
+`(account_id,release_date)` · `(phone,release_date,seq)` 老台账路径（已停用，保留）· `(video_file)` 清理时反查引用。
+后三个里带 `account_id`/`phone` 的两个是历史遗留（账号台账停用后不再走），等确认稳定后一并清理。
+`ix_video_plan_name_date` 由 `_ensure_plain_indexes()` 在启动时补建（`create_all` 不管已有表的新索引）。
+
+这张表**自动进整库备份**（§6 派生规则）；**素材文件不进备份包**，见 §6 与 §7。
+
 ---
 
 ## 3. 非模型表
@@ -331,6 +427,11 @@ SUMMARY_TABLES = tuple(sorted(t.name for t in db.metadata.tables.values()))
 - **导入侧**：备份里出现未登记的表（排除 `sqlite_` 前缀）→ 预览告警（字段 `extra_tables`）
 - `REQUIRED_TABLES = (app_meta, user, task_job, device_group)`：缺任一直接拒绝导入（这四项是"判定这是不是本平台备份"的最小集合，故意手工维护）
 
+> **素材文件不进备份包**：`create_export()` 只打包 `data/apks/*.apk`，**不含 `data/videos/`**
+> （几十 GB 会把"数据库备份"这个核心能力搞坏）。备份的 `manifest.json` 里有
+> `videos.included=false` + 数量/字节数，备份预览页也会提示"素材需另外备份 `data/videos/`"
+> —— **不能让人以为备份了**。恢复后素材要重新上传（计划与发布状态、分享链接都在表里，已备份）。
+
 > **红线**：新增持久化表时**同时补 `TABLE_LABELS` 的中文标签**并更新 [DEPLOY.md](DEPLOY.md) §数据备份。
 > 覆盖清单本身不再需要手工登记（已由 metadata 派生）。历史教训：`agent_action` 曾漏登记，
 > 导致"动作库看起来没备份"（数据其实在快照里，只是清单没列）。
@@ -343,6 +444,7 @@ SUMMARY_TABLES = tuple(sorted(t.name for t in db.metadata.tables.values()))
 |------|------|--------|
 | `data/users.db`(+`-wal`/`-shm`) | SQLite 主库（**仅回退模式用**；连 MySQL 时这些文件不被读写，可留作历史归档） | 否 |
 | `data/apks/*.apk` | 上传的 APK | 否 |
+| `data/videos/YYYY-MM/*` | 视频发布计划的素材（几百 MB 一个；**不进整库备份**，见 §6） | 否 |
 | `data/backups/` | 导出临时 zip、`pre_restore_*.zip`（导入前安全网）、`restore_failed_*` | 否 |
 | `data/restore_staging/<token>/` | 导入暂存（TTL 1800s 自动清理） | 否 |
 | `data/restore_pending/` | 待生效恢复任务（重启时单事务消费） | 否 |

doc/DEPLOY.md

@@ -71,8 +71,17 @@ DB_NAME=auto_control
 # USB_ADB_HOST=100.100.10.1             # USB 设备所在的部署机（默认值通常可用）
 # TAILSCALE_API_KEY=<...>               # 需要 Tailscale 管理功能时
 # MCP_PLATFORM_PASS=<admin 的密码>       # 改过 admin 密码必须同步，否则 MCP 登录失败
+
+# 发布计划按名字发：抖音「我」页面上的**昵称控件**（用「抓取元素」抓一次，见 .env.example）
+# DOUYIN_NAME_SELECTOR_VALUE=
+# 自动切号：进「账号切换」列表那个入口（同样抓一次）
+# DOUYIN_SWITCH_SELECTOR_VALUE=
 ```
 
+> ⚠ **发布计划相关的两个选择器必须抓一次**（`DOUYIN_NAME_SELECTOR_VALUE` /
+> `DOUYIN_SWITCH_SELECTOR_VALUE`）：不填时「读取本机账号名字」「切换账号」会**明确报错并跳过**
+> （不会瞎点、不会发错号），但也就发不出视频。改完 `.env` 要重启容器生效。
+
 **防混库**（`DEPLOY_ENV` 与库名/库标签双向校验，配置项说明见 [DEVELOPMENT.md](DEVELOPMENT.md) §4.2
 与 `.env.example` 的「数据库」段）：启动时若
 「`.env` 声明的环境」与「库名」或「库中登记的 `app_meta.deployment_env`」不符，**直接拒绝启动**并打印
@@ -212,11 +221,16 @@ tail -20 logs/web.log                              # 无 ERROR/Traceback
 SUMMARY_TABLES = tuple(sorted(t.name for t in db.metadata.tables.values()))
 ```
 
-当前 15 张表：`app_meta` / `user` / `device_group` / `task_job` / `custom_action` /
+当前 17 张表：`app_meta` / `user` / `device_group` / `task_job` / `custom_action` /
 `apk_file` / `device` / `pending_device` / `agent_conversation` / `agent_experience` /
-`experience_audit` / `agent_action` / `device_install_log` / `task_step_log` / `done_mark`。
+`experience_audit` / `agent_action` / `device_install_log` / `task_step_log` / `done_mark` /
+`device_account`（账号台账，**已停用但仍在备份内**——停用不等于删数据）/ `video_plan`（视频发布计划）。
 完整说明见 [DATA_MODEL.md](DATA_MODEL.md) §6。
 
+> ⚠ **视频素材（`data/videos/`）不进备份包**（几十 GB 会把备份搞坏）：manifest 里有
+> `videos.included=false` 与数量/字节数，预览页也会提示 —— **素材要另外备份**。
+> 计划、发布状态与分享链接都在 `video_plan` 表里，随备份一起走。
+
 > ⚠️ `task_step_log`（任务步骤明细）是会持续增长的表：它按 `KEEP_DAYS`
 > （默认 14 天，见 `core/step_log.py`）自动清理，但备份包里会带上保留期内的全部行。
 > 设备多、任务密时导出 zip 会明显变大——需要更小的包就调小那个常量。
@@ -228,6 +242,10 @@ SUMMARY_TABLES = tuple(sorted(t.name for t in db.metadata.tables.values()))
 > 还需要手工做的只有：给新表补 `TABLE_LABELS` 的中文标签。
 > 导出侧有**覆盖自检**（登记表缺失 → `manifest.coverage_missing` + 日志告警）；
 > 导入侧有**反向自检**（备份含未登记表 → 预览告警）。
+>
+> **回滚注意事项**：把"含新表的备份"导回**旧版本代码**时，旧代码的 `SUMMARY_TABLES`
+> 里没有那张新表 → 导入预览会报 `extra_tables` 告警。**数据仍在快照里、不会丢**，
+> 属于预期行为（升级回新版即可正常识别）。
 
 ### 5.3 目录与手工备份
 
@@ -258,7 +276,13 @@ SUMMARY_TABLES = tuple(sorted(t.name for t in db.metadata.tables.values()))
 - **HTTPS/80 端口**：用 Nginx 反代
 
 ```nginx
-location / { proxy_pass http://127.0.0.1:18050; proxy_set_header Host $host; }
+location / {
+    proxy_pass http://127.0.0.1:18050;
+    proxy_set_header Host $host;
+    # ⚠ 必须加：nginx 默认 client_max_body_size 只有 1m，
+    # 不加的话「应用管理」传 APK（有 336MB 的包）和视频素材上传都会 413。
+    client_max_body_size 2048m;
+}
 ```
 
 ---

doc/DEVELOPMENT.md

@@ -107,6 +107,7 @@ MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<密码> \
 | 后端逻辑验证 | 直接 `python -c "…"` 调用 `core/`、`tasks/` 的函数（如构造 worker 检查参数合并） |
 | 前端验证 | 无 npm/构建，改完强刷；浏览器控制台看报错 |
 | 接口 500 巡检 | `python scripts/regression_test.py`（**⚠️ 当前在 Windows 上会因 `signal.alarm` 报错**，Linux/macOS 可用） |
+| 发布计划（按名字发）用例 | `python scripts/tests/run_all.py` —— 6 套：解析 / 上传配标题 / 读名字与作用域 / 切换账号 / 循环本机待发的号 / 按名字找设备推送。**纯临时库 + 假设备，不连真机**（见 `scripts/tests/run_all.py` 顶部） |
 | 停止设备/清异常 | 监控页「停止全部 / 停止选中 / 清除全部异常」 |
 | AI 建任务（designer）验证 | AI 控制台 →「AI 建任务」选**空闲**设备跑一轮；脚本方式见 [AI_TASK_GEN.md](AI_TASK_GEN.md) §10.5。草稿只落 `app_meta.agent_task_draft`（不是任务），验证完 `POST /api/agent/task_draft/clear` 清掉。**注意它会真在设备上点按**（导航类动作），且与聊天共用同一个运行槽 |
 
@@ -140,6 +141,8 @@ MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<密码> \
 | `WEB_HOST` / `WEB_PORT` | `0.0.0.0` / `18050` | 硬编码 | 18050 避开 Windows 动态端口段 |
 | `DATA_DIR` / `APK_DIR` | `data/` / `data/apks/` | 代码计算 | |
 | `BACKUP_DIR` / `RESTORE_STAGING_DIR` / `RESTORE_PENDING_DIR` | `data/backups` / `data/restore_staging` / `data/restore_pending` | 代码计算 | 备份相关 |
+| `VIDEO_DIR` | `data/videos` | `DATA_VIDEO_DIR` | 视频发布计划的素材目录（**不进整库备份**；测试要指到临时目录） |
+| `MAX_CONTENT_LENGTH` | 2 GiB | `MAX_UPLOAD_MB` | 单次上传体积上限；**必须大于最大的 APK（实测 336MB）**，否则 APK 上传会被卡死 |
 | `DEPLOY_ENV` | `dev` | `.env` 可覆盖 | 声明这套配置连哪个环境的库；与库名绑定（dev→`auto_control_dev`，prod→`auto_control`），不符拒绝启动 |
 | `DB_HOST` / `DB_PORT` / `DB_USER` / `DB_PASSWORD` / `DB_NAME` | 空 / `3306` / 空 / 空 / 空 | `.env` 可覆盖 | MySQL 目标；`DB_HOST` 为空则回退 SQLite（**生产禁止静默回退**，需 `DB_ALLOW_SQLITE_FALLBACK=1`） |
 | `DB_CHARSET` / `DB_COLLATION` | `utf8mb4` / `utf8mb4_bin` | `.env` 可覆盖 | 排序规则必须用 `_bin`（逐码点比较，等价 SQLite 的大小写敏感语义） |
@@ -198,7 +201,7 @@ MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<密码> \
 | 页面结构 / 样式 / 引入脚本 | `templates/admin/monitor.html` |
 | 公共工具（API/权限/Toast/Tab） | `static/admin/base.js` |
 | 列表分页排序 | `static/admin/list.js` |
-| 各功能域逻辑 | `static/admin/{monitor,editor,tasks,tools,apps,admin,agent,system,markdown}.js` |
+| 各功能域逻辑 | `static/admin/{monitor,editor,tasks,tools,apps,admin,agent,system,markdown,dedup,release}.js` |
 
 新增 JS 模块：建文件 → 在 `monitor.html` 里按依赖顺序加 `<script src>` → 更新 [ARCHITECTURE.md](ARCHITECTURE.md) §6.3 与本文 §5.3。
 

doc/DEVICE_AGENT.md

@@ -192,8 +192,18 @@ adb -s <serial> shell am start -n <pkg>/.ClipActivity --es text_b64 <base64(UTF-
 
 - **必须 base64**：adb shell 直传中文/特殊字符会变形
 - 必须用**透明 Activity**（有焦点才能写剪贴板），写完**立即退出**
-- 平台判定失败的方式：`am start` 输出里有 `unable to resolve Intent` / `does not exist`
+- 平台判定失败的方式：`am start` 输出里有 `unable to resolve Intent` / `does not exist` /
-  → 视为"设备未安装 Agent"
+  `Error type 3` → 视为"这台设备没有这个通道"
+
+**平台按顺序试两个包**（`core/clipboard_helper.py` 的 `_CLIP_TARGETS`）：
+
+| 顺序 | 包 | 说明 |
+|---|---|---|
+| 1 | `com.example.deviceagent`（**本 Agent**） | 现在的标准通道；装了就只调它 |
+| 2 | `com.example.clipinject`（早期独立 APK） | 老设备上可能还残留 → 兜底；走这条会在日志里提示"建议装设备端 Agent" |
+
+两个都没有时报"设备未安装剪贴板注入通道：需要设备端 Agent"（不再只说 ClipInject，
+否则用户会去装那个已经不再分发的旧 APK）。**设备端无需为这条改动做任何事**。
 
 ### 5.2 设备身份显示（设备端已实现）
 
@@ -239,6 +249,9 @@ adb -s <serial> shell am start -n <pkg>/.ConfigActivity \
 
 ## 6. 版本与兼容
 
+- 身份页 extras（`name`/`ip`/`serial`/`server`/`close`）是**平台单向下发**：设备端多收/少收
+  都不影响旧行为。（2026-10-12：账号台账下线，原先顺带下发的 `accounts_b64` 已不再发送 ——
+  设备端收到"没有这个 extra"时照旧只显示身份信息即可。）
 - `agent_api_version`（当前 **1**）在每次 `bootstrap` 响应里返回
 - **设备端**：启动时对比自己实现的版本，不一致要在日志里明确记下来（不要静默）
 - **平台端**：

doc/MCP.md

@@ -108,7 +108,7 @@ MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<平台密码> \
 | 工具 | 参数 | 说明 |
 |------|------|------|
 | `de_type_text` | `serial`, `text` | 向当前输入框输入（支持中文，直设 EditText，不依赖剪贴板） |
-| `de_set_clipboard` | `serial`, `text` | 写入设备剪贴板（ClipInject 通道 + 读回验证） |
+| `de_set_clipboard` | `serial`, `text` | 写入设备剪贴板（设备端 Agent 通道 + 读回验证） |
 
 ### 4.5 App 管理（**写操作**，走 adb 直连不建 u2 会话）
 

doc/MCP_DESIGN.md

@@ -58,8 +58,8 @@
 | 点击 | `POST /api/screen/tap {serial,x,y}` | 封装 tool `tap` |
 | 滑动 | `POST /api/screen/swipe` | 封装 `swipe` |
 | 按键 | `POST /api/screen/key` | 封装 `press_key` |
-| 输入文字 | ClipInject 通道（core.clipboard_helper）+ u2 input | 封装 `type_text` |
+| 输入文字 | 设备端 Agent 通道（core.clipboard_helper）+ u2 input | 封装 `type_text` |
-| 剪贴板 | `POST /api/tools/clipboard/set`（ClipInject 通道） | 封装 `set_clipboard` |
+| 剪贴板 | `POST /api/tools/clipboard/set`（设备端 Agent 通道） | 封装 `set_clipboard` |
 | 元素树 | `GET /api/uiauto/...`（uiautodev） | 封装 `get_ui_tree` |
 | OCR | core.ocr（RapidOCR） | 封装 `ocr_screen` |
 | 打开 App | u2 `app_start`（经任务层/直连） | 封装 `open_app`（走 core device 直连） |
@@ -150,11 +150,11 @@
 - key ∈ back/home/recent/menu/power/enter/delete…
 
 #### `de_type_text(serial, text: str, clear_first: bool=True)`
-- 实现：优先 ClipInject 通道（`core.clipboard_helper.inject_clipboard` 语义：写入剪贴板 + paste 到焦点输入框），失败回退 u2 input
+- 实现：优先设备端 Agent 通道（`core/clipboard_helper.inject_clipboard` 语义：写入剪贴板 + paste 到焦点输入框），失败回退 u2 input
-- 中文/emoji 全支持（ClipInject 实测通过）
+- 中文/emoji 全支持（Agent 通道实测通过）
 
 #### `de_set_clipboard(serial, text: str)`
-- 写入设备剪贴板（ClipInject am start 通道），读回验证
+- 写入设备剪贴板（设备端 Agent 的 am start 通道），读回验证
 
 #### `de_open_app(serial, package: str)`
 - 打开指定 App（u2 app_start）；`package` 需在已知清单或完全限定名
@@ -247,7 +247,7 @@
 3. **横竖屏/分辨率异构**：设备多样 → 坐标换算依赖截图 1:1；`de_find_and_tap`（语义层）不受分辨率影响
 4. **图像 content block 兼容性**：Claude 系原生支持；其他多模态客户端需验证（M0 用 Claude Code 验证）
 5. **是否接任务系统**：二期决策——`de_run_task` 语义与"单设备操作"不同（任务面向多设备调度），倾向二期用独立命名空间
-6. **clipboard/input 通道差异**：个别 MIUI 需授权 ClipInject——M0 阶段在受控设备集验证，必要时 fallback 链已在 core 层
+6. **clipboard/input 通道差异**：个别 MIUI 需授权写入剪贴板的透明 Activity——M0 阶段在受控设备集验证，必要时 fallback 链已在 core 层（设备端 Agent → 旧版 ClipInject）
 
 ## 12. 附录：平台 API 映射（MCP → 平台）
 
@@ -262,8 +262,8 @@
 | de_press_key | POST /api/screen/key |
 | de_tap_text | POST /api/screen/tap_text（UI 树子串匹配 → OCR 兜底） |
 | de_tap_element | u2 元素直连（uiautomator2 `d(by=value).click()`，无平台端点） |
-| de_type_text | u2 `EditText.set_text`（direct_ops.type_text，不走 ClipInject） |
+| de_type_text | u2 `EditText.set_text`（direct_ops.type_text，不走剪贴板通道） |
-| de_set_clipboard | core.clipboard_helper ClipInject 通道（inject_clipboard，读回验证） |
+| de_set_clipboard | core.clipboard_helper 设备端 Agent 通道（inject_clipboard，读回验证） |
 | de_read_clipboard | u2 `d.clipboard` |
 | de_open_app | adb monkey 直启（direct_ops.open_app） |
 | de_stop_app | adb `am force-stop`（direct_ops.stop_app） |

doc/NOTIFY.md

@@ -52,6 +52,8 @@ daemon 线程。所以：
 | 任务批次 | `task.batch.started` · `.finished` · `.no_device` · `.unknown_type` · `task.cron.stopped` |
 | 任务·单设备 | `task.device.success` · `.failed` · `.offline` · `.error` · `.retry` · `.stopped` · `.preempted` · `.preempt_timeout` · `.released` |
 | 业务 | `task.selector.invalid`（选择器连续 10 次未命中——"任务成功但什么都没做"的隐蔽故障） |
+| 业务 | `task.video.published`（视频发布成功，带作品分享链接）/ `task.video.failed`（发布失败**或结果未知**——结果未知意味着可能已经发出去了，要到计划页人工确认，平台不会自动重发） |
+| 业务 | `task.account.switch_failed`（切号失败：账号列表里没这个名字，或切完回读还是别人 —— **本轮不会发这个号的内容**，要人工到设备上确认号还在不在）/ `task.account.need_login`（抖音停在登录/验证码页，**需要人工登录**，平台绝不代替登录/过滑块；本设备已停止本轮任务）—— 都由「切换账号」步骤发出 |
 | 业务·任务自己发 | `task.notify.custom`（步骤「发通知」）/ `task.patrol.hit`（任务「公共巡检」命中）——**标题正文由任务自己写**，见下 |
 | Worker | `worker.connected` · `.attempt.done` · `.attempt.error`（单次尝试级，噪音大，默认没人勾） |
 | 设备 | `device.online` · `.offline` · `.discovered` · `.claimed` · `device.heartbeat_timeout` · `device.battery.low` · `.battery.recovered` |

doc/README.md

@@ -13,7 +13,7 @@
 | [ARCHITECTURE.md](ARCHITECTURE.md) | **架构详解**：分层、启动装配顺序、线程与并发模型、设备生命周期、任务调度链路、状态机、关键设计决策与扩展点 | 所有开发者（先读这篇） |
 | [DATA_MODEL.md](DATA_MODEL.md) | **数据模型**：SQLite 表与字段、schema 迁移、非模型表、`app_meta` 配置键、数据目录、备份覆盖清单 | 后端开发、运维 |
 | [API.md](API.md) | **HTTP 接口全量**：按蓝图分组的路由表、鉴权、请求/响应示例、非 JSON 响应、错误分支 | 前端开发、外部接入 |
-| [TASK_DEV.md](TASK_DEV.md) | **任务与步骤开发**：TaskType/TaskJob 概念、22 种步骤全表、公共巡检、选择器与定位、自定义动作、新增任务类型模板 | 写任务的开发 |
+| [TASK_DEV.md](TASK_DEV.md) | **任务与步骤开发**：TaskType/TaskJob 概念、24 种步骤全表、公共巡检、选择器与定位、自定义动作、新增任务类型模板 | 写任务的开发 |
 | [MCP.md](MCP.md) | **MCP 手机控制手册**：20 个 `de_*` 工具用法、写操作门控、坐标换算、接入示例 | 接入方、数字员工 |
 | [MCP_DESIGN.md](MCP_DESIGN.md) | **MCP 设计文档**：边界划分、错误码、白名单/审计设计、演进方向 | 平台开发者 |
 | [AI_CONSOLE.md](AI_CONSOLE.md) | **AI 控制台**：会话/SSE、经验库、动作库、巡检、Markdown 渲染、推理链、token 统计 | 使用者、平台开发者 |

doc/TASK_DEV.md

@@ -10,7 +10,7 @@
 
 - [1. 核心概念](#1-核心概念)
 - [2. 通用步骤任务 generic_steps](#2-通用步骤任务-generic_steps)
-- [3. 22 种步骤全表](#3-22-种步骤全表)（含 [3.1 步骤默认值与动作录制](#31-步骤默认值与动作录制任务--动作配置)）
+- [3. 24 种步骤全表](#3-24-种步骤全表)（含 [3.1 步骤默认值与动作录制](#31-步骤默认值与动作录制任务--动作配置)）
 - [4. 容器步骤与公共参数](#4-容器步骤与公共参数)（含 [4.5 公共巡检](#45-公共巡检任务级独立于步骤画布)）
 - [5. 选择器与元素定位](#5-选择器与元素定位)
 - [6. 自定义动作](#6-自定义动作)
@@ -109,7 +109,7 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 
 ---
 
-## 3. 22 种步骤全表
+## 3. 27 种步骤全表
 
 > 参数与默认值以 `tasks/generic/task.py` 为准；前端 `STEP_LIB`（`static/admin/editor.js`）负责在编辑器里呈现这些字段。
 
@@ -127,16 +127,22 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 | 10 | `click_xy` | 点击坐标 | — | `x`(50)、`y`(50) | — | **屏幕百分比**（0-100，会夹取），50/50 = 屏幕中心。无选择器时的兜底，**最脆的方式** |
 | 11 | `long_click` | 长按元素 | `selector_type`、`selector_value` | `duration`(1.0)、`wait_timeout`(2) | — | 先等元素出现再 `long_click` |
 | 12 | `wait_el` | 等待元素 | `selector_type`、`selector_value` | `timeout`(10) | — | 等元素出现（条件等待，优于固定 `wait`） |
-| 13 | `input_text` | 输入文字 | — | `mode`("random")、`texts`("你好\n有趣\n支持")、`fixed_text`("")、`clear_first`(True) | — | `mode="fixed"` 用 `fixed_text`，否则从 `texts` 按行随机选一条；**只负责输入，不负责定位输入框**（要先 click 输入框） |
+| 13 | `input_text` | 输入文字 | — | `mode`("random")、`texts`("你好\n有趣\n支持")、`fixed_text`("")、`clear_first`(True)、`text_source`("manual")、`release_topics`("") | — | `mode="fixed"` 用 `fixed_text`，否则从 `texts` 按行随机选一条；`text_source` 还可取**本机当前那条发布计划**的内容：`release_title`(±`_topics`) = 标题、`release_body`(±`_topics`) = 正文、`release_title_body` = 标题+正文（配 `release_topics` 自动加话题），**并回读输入框校验**（不校验就可能发出一篇空文案）；**只负责输入，不负责定位输入框**（要先 click 输入框） |
-| 14 | `clipboard` | 剪贴板注入 | `text` | `paste`(True) | — | 走 ClipInject 通道（绕开 Android 10+ 后台写剪贴板限制）；`paste=true` 时再触发一次粘贴 |
+| 14 | `clipboard` | 剪贴板注入 | `text` | `paste`(True) | — | 走**设备端 Agent** 通道（透明 Activity，绕开 Android 10+ 后台写剪贴板限制）；老设备上只有独立 ClipInject 时自动兜底（见 `core/clipboard_helper.py`）；`paste=true` 时再触发一次粘贴 |
 | 15 | `wait` | 等待 | — | `min`(1.0)、`max`(3.0)、`vary_pace`(False) | — | 随机时长；**分片 sleep**（每 ≤0.5s 检查停止/超时），可被抢占打断；勾了 `vary_pace` 再按**本设备节奏**缩放 0.8~1.35 倍（批量跑时设备之间会逐渐错开） |
 | 16 | `loop` | 循环块 | — | `loop_mode`("rounds")、`max_iterations`(10)、`loop_duration`(600) | `children` | 见 §4.1 |
+| 16 | `loop` | 循环块 | — | `loop_mode`("rounds")、`max_iterations`(10)、`loop_duration`(600) | `children` | 见 §4.1 |
 | 17 | `group` | 动作组 | — | — | `children` | 子步骤**按序执行一次**（不循环）；自定义动作拖入画布就是展开成 group |
-| 18 | `if_el` | 条件判断 | `selector_type`、`selector_value`、`timeout`(3) | `ocr_click`(False)、`cmp_op`("")、`cmp_value`("")、`ident_type`/`ident_value`（去重身份） | `then` / `else` | 见 §4.2；条件类型除元素/OCR 外还支持 **屏幕状态**、**前台App**、**去重**（见 §4.6）；填 `cmp_op` 则改成**比元素的文本**（等于/不等于/包含/不包含，多值任一命中） |
+| 18 | `if_el` | 条件判断 | `selector_type`、`selector_value`、`timeout`(3) | `ocr_click`(False)、`cmp_op`("")、`cmp_value`("")、`cmp_source`("")、`ident_type`/`ident_value`（去重身份） | `then` / `else` | 见 §4.2；条件类型除元素/OCR 外还支持 **屏幕状态**、**前台App**、**去重**（见 §4.6）；填 `cmp_op` 则改成**比元素的文本**（等于/不等于/包含/不包含，多值任一命中），候选值还可以由平台给：**本次要发的名字**（`cmp_source=account_target`）或**本机要发的那条发布计划**的名字（`cmp_source=release`） |
 | 19 | `notify` | 发通知 | — | `title`("")、`message`("")、`level`("info") | — | 推一条**自定义**通知（事件 `task.notify.custom`）：标题正文自己写，支持 `{device} {serial} {job} {time} {app} {screen}`；谁收到取决于 webhook 的事件订阅。两者都空则跳过 |
 | 20 | `stop_self` | 停止本设备 | — | `reason`("") | — | 只停**本设备**的任务（其它设备照跑）：置 worker 停止位，后续步骤不再执行，任务记成**被停止而不是失败**（不触发重试） |
 | 21 | `gesture` | 录制手势 | `points`（录出来的） | `speed`(1.0) | — | **纯录制回放**：把录下的轨迹点列 `[[x,y,t_ms],…]` 按原路径与时长交给设备插值，不做弧线/抖动/手速加工。与「滑动」是两套东西，见 §3.2 |
 | 22 | `mark_done` | 记为已做 | —（身份元素可选填 `selector_type`/`selector_value`） | — | — | 把身份值记进**去重账本**（跨设备共享）。放动作**成功之后**——失败不记账，下次重跑会重试。**留空 = 自动跟随上面「去重」检查的身份（推荐）**；没有前置检查时才退回设备 `serial`。见 §4.6 |
+| 23 | `push_release` | 推送发布视频 | `date_source`(today/fixed)、`fixed_date` | `account`(name/phone)、`account_phone`、`album_dir`(/sdcard/DCIM/Camera)、`to_clipboard`(True)、`retry_failed`(True)、`max_same_run`(1) | — | 取**本次要发的那个名字**名下的「发布计划」→ **只把素材推到手机**（+ 触发相册刷新 + 标题写进剪贴板）。**不发布** —— 抖音流程你自己在后面画。`account=name`（默认）时**推送前会重读昵称核对**，对不上就不推。幂等靠原子占位（多设备/重跑不会重复推）。见 §4.7 |
+| 24 | `mark_release` | 标记发布结果 | `result`(published/failed/unknown)、`why` | `capture_link`(True)、`delete_phone`(True)、`album_dir` | — | 放在**你自己发布流程的末尾**：把"发出去了没有"回写到计划行（成功时顺手抓作品分享链接、删手机上的素材）。拿不准就填 `unknown` —— 平台不会自动重发它。见 §4.7 |
+| 25 | `read_account_name` | 读取本机账号名字 | `selector_value`（昵称控件；值填在 `.env` 的 `DOUYIN_NAME_SELECTOR_VALUE`，40.6.0 实测值见 [research/U2_ELEMENT_SELECTORS.md](research/U2_ELEMENT_SELECTORS.md) §七） | `selector_type`(xpath)、`timeout`(8)、`on_missing`(fail) | — | 读抖音「我」页面上的**昵称** → 清洗后存进运行期变量（`account_name`），并记下用的选择器供 `push_release`/`switch_account` 核对。**读不到 = 本机没有号**：条件判断走 `else`、推送跳过（都不发）。`on_missing=fail`(默认) 让这一步直接失败、`skip` 只记一句继续。见 §4.7 |
+| 26 | `switch_account` | 切换账号 | `switch_selector_value`（进「账号切换」列表那一下；填 `.env` 的 `DOUYIN_SWITCH_SELECTOR_VALUE`，实测值同上） | `target`(`var:target_name`)、`target_value`、`name_selector_*`、`me_selector_*`(descriptionContains=我)、`timeout`(8)、**`wait_after`(15)**、`verify`(True)、`max_attempts`(2)、`on_login_page`(stop) | — | **只在本机已登录过的号之间切**：当前已是目标→直接成功；否则点「我」→ 点切换入口 → **在列表里按名字找控件点击**（**禁 `[N]` 序号**：序号型会随界面变形错位）→ 等重载 → **回读校验**。列表里没这个名字 = 本机没登这个号 → 立刻 False（不重试、不算故障）。**切完先等 `wait_after` 秒（默认 15）再回读** —— 换号会触发抖音整体重启，中途去点任何东西（包括点「我」页签那一下『刷新』）都可能打断它加载。停在登录/验证码页 → 通知 + 默认停本设备（平台不做登录/滑块）。见 §4.7 |
+| 27 | `foreach_account` | 循环本机待发的号 | — | `date_source`(today/fixed)、`fixed_date`、`retry_failed`(True)、`max_accounts`(0=不限) | `children` | **一轮把本机待发的号跑完**：数据源 = 计划表里还有待发内容的名字（`pending_names`，**不需要账号台账**），逐个写进运行期变量 `target_name` 后跑 children；试过的名字不回头（防死循环）；内层"这个名字还有待发就一直发"，跑一轮没进展（切号失败/守卫没过）就换下一个。三个干净出口：停止 / 任务时长上限 / `max_accounts`。见 §4.7 |
 
 ### 3.2 录制手势：**纯录制、纯回放**（`core/gesture.py`）
 
@@ -283,6 +289,39 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
   走了 `else`，不是选择器失效，不该攒出「连续未命中」告警。
 - 读元素文本是**只读**操作（`get_text`，2 秒超时），不会点击或改动任何状态。
 
+#### 候选值由平台给（`cmp_source`，可选）
+
+几十个号时手写 `cmp_value` 很累、而且换号要回来改。`cmp_source` 让候选值由平台给：
+
+| `cmp_source` | 候选值 |
+|---|---|
+| `""` / `manual`（默认） | 只用手填的 `cmp_value` —— **行为与以前完全一致** |
+| `account_target` | **本次要发的那个名字**：循环块设的目标名字优先，没有就用「读取本机账号名字」刚读到的|
+| `release` | **本机当前发布计划**要发的那个名字：优先本次运行里「推送发布视频」刚取到的那条；还没有就**看**下一条待发的（只看不占位） |
+
+#### `account_target`：发布前先确认"登的是要发的那个号"（一台手机登好几个号时必配）
+
+一台手机可能登着好几个号，发布前必须确认当前抖音登的就是**这次要发的**那个号 ——
+就在发布流程**最前面**放一个条件判断（`cmp_source=account_target` + `包含`），
+命中了才走发布，没命中走 `else`（发通知/跳过）。这样"发错号"变成"这条跳过"，
+而不是把 A 号的视频发到 B 号上。
+
+- 比对的元素原文 = **昵称控件**（和「读取本机账号名字」用**同一个选择器**，抓一次两处都填）；
+  候选值是名字，所以用 **`包含`**。
+- **读不到名字 → 候选为空 → 这一步永远走 `else`**（日志会写明"没读到本次要发的名字"）。
+  这是故意的：**读不到名字 = 不知道现在登的是谁 = 不发**。
+- ⚠ **绝不能用「不等于」**：读不到名字时候选为空，`不等于` 对空候选算**命中**，
+  会把"读不到"误判成"可以发"。
+- **与手填值是合并（OR）**，不是二选一：平台给的候选 + 你补的值，任一命中即可
+  （平台的候选取不到时手填值仍然生效，不会把任务直接打哑）。
+- 「推送发布视频」自己**还会再核对一次**（推送前重读昵称，见 §4.7），所以就算这个条件判断
+  没画，也不会发错号 —— 条件是给"要先看一眼再决定"的场景用的。
+
+> ⚠ **比对用的候选值绝不能拿去填「去重」的身份元素**（`ident_value`）：
+> 去重身份存的是**元素原文**、逐字算 key（`core/dedup.py` 的 `build_key`），
+> 格式不一致（`小王` vs `昵称：小王`）会让**检查与记账算出两个不同的 key → 去重静默失效**
+> （重复评论，而且日志看不出问题）。去重身份继续用「抓取元素」抓到的那个账号元素即可。
+
 ### 4.3 公共参数
 
 | 参数 | 说明 |
@@ -420,6 +459,187 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 
 ---
 
+### 4.7 发布计划：平台推素材，发布流程你自己写（`push_release` + `mark_release`）
+
+数据与界面见 [DATA_MODEL.md](DATA_MODEL.md) §2.11 与「发布计划」页。
+
+**全部按「名字」走**（名字 = 上传文件名里的那个名字 = 抖音昵称）：计划行认名字，
+运行时读本机当前账号名字，**读不到名字就当"本机没有号"、什么都不发**。
+
+**素材可以是视频，也可以是图片**（扩展名各带各的，一路原样带到手机上 —— 抖音按它判断
+这是视频还是「图文」）：**发布流程是同一条**（相册里点第一个素材 → 下一步 → 填标题/正文 → 发布），
+所以任务画布不用为图片另写一套。
+
+**分工**（这是刻意的设计）：**平台只管"素材到手机 + 状态记账"，抖音里怎么发由你画** ——
+因为发布流程跟账号、版本、界面都在变，写死在平台里改不动。
+
+```
+[读取本机账号名字] → [条件判断 account_target] → [推送发布视频] → [你的发布步骤…] → [标记发布结果]
+ read_account_name    登的是要发的号吗？            push_release     打开抖音→点+→相册→选视频   mark_release
+                       不是/读不到 → else：通知跳过                   →下一步→填标题→填正文→发布  published 放成功分支
+                                                                                            failed 放失败分支
+```
+
+**先读名字、再校验、最后才发**（一台手机登好几个号时必配）：
+
+- 「读取本机账号名字」：读抖音「我」页面上的**昵称控件**（选择器抓一次填进 `.env` 的 `DOUYIN_NAME_SELECTOR_VALUE`），
+  清洗后的名字进运行期变量（见 §3 第 25 行）。**读不到 = 本机没有号**。
+- 条件判断用 `cmp_source=account_target`（候选值 = 本次要发的名字，见 §4.2）+ `包含`；
+  没命中就走 `else` —— **宁可不发，也不发错号**。
+- 「推送发布视频」自己**再核对一次**：推送前重读昵称，与要发的名字对不上（或读不到）→ 不推。
+
+**自动切号（`switch_account`，一台手机多个号时用）**：
+
+一轮任务里"切号 → 读名 → 推 → 发 → 标记"循环跑多个号（由 `foreach_account` 循环块驱动）：
+
+```
+[foreach_account]  ← 一轮把本机待发的号跑完（数据源 = 计划表里还有待发内容的名字）
+   └ [switch_account] → [read_account_name] → [if_el account_target] → [push_release] → 你的发布步骤 → [mark_release]
+      切到这个名字        确认切成了            登的是它吗？              取这个号的计划
+```
+
+- **只在本机已登录过的号之间切**（抖音账号列表里有的号）：不做登录新号、不做滑块。
+- 列表里**没有**这个名字 → 立刻返回 False（= 本机没登这个号，**不重试、不算故障**）：
+  多台设备各自"试自己有的号"，不会互相误报。
+- 切完**回读校验**（`verify=True`）：读回来的不是目标 → 该号这一轮**不推送**（守卫会挡下）。
+- 停在登录/验证码页 → 通知 `task.account.need_login` + **默认停本设备**（见 [NOTIFY.md](NOTIFY.md)）。
+- ⚠ **选择器只能按名字**（`textContains`），**绝不能用 `[N]` 序号**：序号会随界面变形错位，
+  点错就是把内容发到别人号上（[research/U2_ELEMENT_SELECTORS.md](research/U2_ELEMENT_SELECTORS.md) 有实测）。
+
+**人工入口也一样按名字找设备**（「发布计划」页）：
+
+- 「推送到手机」：实时探测**哪台在线设备现在登着这条计划的名字**，推给它；没有设备登着 →
+  400 + 人话原因（"先去那台设备上切号"）。
+- 「一键推送（今天）」：当天所有待推计划按名字分组 → 逐条推；**没设备登着的号在 `unmatched`
+  里逐条报出来**（见 [API.md](API.md) §`push_by_account`）。
+- 探测在 `core/account_probe.py`：只读/幂等（连设备 → 抖音前台 → 点「我」→ 读昵称），
+  **跳过正在跑任务的设备**（不抢屏），单台失败只报那台；结果顺手缓存进 `device.cur_account_name`
+  （**纯缓存**，自动任务永远现场读屏幕）。
+
+**「推送发布视频」做六件事**（`tasks/generic/publish_flow.py` 的 `push_one()`）：
+
+```
+⓪ 核对：重读昵称 → 与本次要发的名字不一致/读不到 → **不推**（返回"跳过"）
+① 取计划（**队列口径**）：**这个名字**名下 `发布日期 <= 目标日期`（过期会补发、未来的不发）、
+   `status ∈ (ready, failed)`（**done/skipped 永不入队**）、`attempts < 3` 的行，
+   按 `(发布日期, 编号)` 升序取最早的 —— 即"按顺序发没发过的"
+   （名字从哪来：「读取本机账号名字」读到的，或循环块设的目标名字，见 `_release_scope`）
+② **原子占位**：UPDATE … SET status='pushing' WHERE id=? AND status IN ('ready','failed')
+   ← **幂等的唯一判据**（多设备/任务重跑不会把同一条推两遍）
+③ adb push → {album_dir}/{计划id}.mp4（默认 /sdcard/DCIM/Camera）→ 校验**大小**（按 ls -l 的大小列比）
+④ **touch 一下**把手机上这个文件的 mtime 改成"现在" + 清掉同一计划在旧目录里的副本
+⑤ 触发媒体扫描 → **按路径**校验它真的进了相册索引 → 把标题写进手机剪贴板（供「粘贴」用）
+```
+
+**为什么是 `DCIM/Camera`、为什么要 touch**（都是实测踩出来的）：
+
+- 相册（含抖音的选视频页）读的是 **MediaStore 索引**：`adb push` 只放文件、不进索引，
+  推完必须触发扫描，否则"推送成功但相册里没有"。
+- MIUI 会把自建子目录（`DCIM/rp`）归到「其他相册」，抖音的选视频页列不顺 —— 所以放官方相机目录。
+- 放 Camera 的代价：**用户自己拍的视频也在这个目录里** → "相册里第一个 = 刚推的那个"靠排序成立。
+  而 `adb push` 保留的是**本地文件的修改时间**（推一个 3 天前上传的素材 → 排在很后面，
+  "点第一个"就点到别的视频了）→ **推完必须 `touch`**，把 mtime 改成现在。
+- 同一个 plan id 在老目录里可能还留着副本（换目录后的残留）→ 推送时顺手按**精确路径**清掉，
+  并重扫让相册索引把那行去掉；不清的话相册里同一个视频出现两三份，点第一个可能点到死文件。
+- **校验必须比路径，不能只比文件名**：MediaStore 的 `_data` 返回的是
+  `/storage/emulated/0/dcim/rp/...`（目录部分被小写），而 `_indexed_paths()` 归一化后再比；
+  只比文件名会被"老副本在索引里"骗过去，判成"新文件已就绪"。
+- 校验结果落 `video_plan.push_verify`（`ok` / `no_index` / `nofile`）+ `push_remote`（手机上的绝对路径），
+  界面上标「已推送·相册可见 / 已推送·相册未见」——**文件推上去了 ≠ 相册里点得到它**，
+  这两件事必须分开显示。
+
+> ⚠ **uiautomator2 3.x 的 `d.shell()` 返回 `ShellResponse`（tuple 子类），不是 str**：
+> 直接 `'abc' in resp`（元组成员判断，恒 False）或 `resp.strip()`（没这方法）都会得到错误结果。
+> 实测踩过：推送的"文件大小校验"永远不通过（每次推送都被记成失败，而文件其实推上去了）、
+> "有没有进相册"永远报没进。取输出统一走 `publish_flow._sh(d, cmd)`。
+
+远程名用**计划 id**（唯一可识别）。老默认目录 `Movies/rp`、`DCIM/rp` 里的历史副本会被 `drop_old_copies()` 清掉。
+
+**「标记发布结果」**放在你的流程末尾：
+
+| `result` | 什么时候用 | 落库 |
+|---|---|---|
+| `published` | 确认发出去了 | `done`（顺手抓作品分享链接存进计划行、删手机上的素材） |
+| `failed` | 确认没发出去 | `failed`（**可重试**：下次任务会再推一次） |
+| `unknown` | 拿不准 | `unknown`（**绝不自动重发**，计划页标橙，人工裁决） |
+
+**阶段与状态的对应**（`core/video_plan.STAGE_STATUS`，本设计最要紧的一张表）：
+
+| 阶段 | 含义 | 落库 | 能不能自动重试 |
+|---|---|---|---|
+| `push` | 推文件到手机失败（还没碰抖音） | `failed` | ✅ 安全 |
+| `scan` | 媒体扫描 | `failed` | ✅ 同上 |
+| `manual` | **已推到手机**，后面归你/你的人管 | — | — |
+| `post` / `verify` | 推送之后出的岔子（你标记失败/未知） | `unknown` | ❌ **可能已经发出去了** |
+
+> ⚠ **`failed` 与 `unknown` 必须分开**：把"不知道自己发没发"当成"知道自己没发"，
+> 就是重复发布的来源。每日 04:41 的清理 job 会把卡住的占位按阶段降级
+> （`manual` 阶段 → `unknown`，不会降成"可重试"）—— 没有它，一条计划崩一次就永远卡住。
+
+**几条硬约束**（都是踩过的坑）：
+
+- **只删平台自己推的文件**（`{计划id}.mp4` 精确路径）。**绝不 `rm` 通配** —— 会删用户自己拍的东西。
+- **一次只推一个视频**（`max_same_run=1`）：这样"相册里第一个 = 我要发的那个"才成立；
+  要一次发多条，就重复"推送 + 你的发布步骤 + 标记"这一组。
+- **你的发布步骤里，文案要用「粘贴」**（推送时标题已进剪贴板）；如果非要用「输入文字」，
+  记得后面加一步**回读校验**（读输入框的 text）—— 抖音的 EditText 有时不吃 `send_keys`，
+  不校验就可能发出一篇空文案而每一步都显示成功。
+- **不靠 `done_mark` 判重**：去重账本的 identity 是元素原文，与 `(名字,日期,编号)` 两套 key
+  语义不同，混用会静默失效。
+- **任务状态 ≠ 发布结果**：`_exec_steps` 不检查步骤结果，**标记失败不会让任务失败** ——
+  「这次发布的真相」以计划行的 `status` 为准（计划页看得到），并会推
+  `task.video.published` / `task.video.failed` 通知。
+
+**「发布计划」页顶部还有一块「发布任务」**（`GET/POST /api/video_plan/tasks`）：
+上面一组是**发布任务**（步骤里含「推送发布视频」**或**「标记发布结果」，含嵌套在条件/循环里的），
+下面「其它任务」折叠着**全部通用步骤任务** —— 都能就地编辑。
+列全部是刻意的：**手写的抖音发布流程**（自己点相册→输入框→发布，没有平台的 `push_release` 步骤）
+如果被筛掉，人打开这页只会看到"一键新建"，会以为"这页没有能改的地方"；
+这类任务行上会标「**缺平台推送步骤**」并给一个「**插上平台步骤**」按钮
+（`POST /api/video_plan/tasks/<id>/adopt`：推送放最前、标记放最后、**你原来的步骤一步不动**）。
+还支持**一键新建标准发布任务** ——
+骨架 **17 步**已经排好（**标题和正文各一步** —— 对应抖音发布页上那两个框）：
+
+```
+⓪ 亮屏  ① 打开抖音(等「首页」出来)  ② 点击「我」(desc 含"我")  ③ 等待 3~5s
+④ 条件判断  //*[contains(@text,'抖音号')] 包含 cmp_source=release
+   ├─ then（登的就是要发的号）⑤ 推送发布视频 ⑥ 点击「+」(desc 含"拍摄")
+   │        ⑦ 相册 ⑧ 第一个视频 ⑨ 下一步 ⑩ 输入框 ⑪ 输入文字(text_source=release_title)
+   │        ⑫ 点击正文输入框 ⑬ 输入文字(text_source=release_body)
+   │        ⑭ 点击「发布」 ⑮ 标记发布结果
+   └─ else（不是这个号 / 今天没有待发计划）⑯ 发通知"本条跳过"
+```
+
+> ⚠ **⓪ 亮屏 + ① 等「首页」是踩出来的，别删**：真机实测（2026-09-28，A01）——
+> **屏幕没亮就启动抖音，它会永远停在启动页**（`mCurrentFocus=splash.SplashActivity`、UI 树是空的），
+> 于是"点击我"必然 miss、"等抖音号出现"必然超时，最后报成一句误导人的"账号不符"。
+> 屏幕亮着时冷启动 5 秒就出底部栏。
+
+建好之后**就在「发布计划」这一块点「编辑」就地改**（名字/目标/每天几点/启停/逐步参数，
+选择器旁边就有「抓取元素」），把 6 个空选择器（相册/第一个视频/下一步/标题框/正文框/发布）抓一次就能跑 ——
+要加步骤、循环、自定义动作这些更复杂的编排，才走「打开通用编辑器」（跳任务页）——
+**抖音那几步故意不写死选择器**：混淆 id / 结构 xpath 改版就废，
+抓一次的成本远低于每次发版都改平台代码。②⑥ 两条预填的是**按描述定位**
+（`descriptionContains`，跨版本稳），一般不用改。
+
+**「输入文字」自动用计划里的内容**（`text_source`，常量 `RELEASE_TEXT_SOURCES` 一处定义）：
+
+| text_source | 取什么 | 用在哪个框 |
+|---|---|---|
+| `release_title` / `release_title_topics` | 计划的**标题**（`video_plan.title`） | 抖音发布页的「标题」框 |
+| `release_body` / `release_body_topics` | 计划的**正文**（`video_plan.body`） | 抖音发布页的文案/正文框 |
+| `release_title_body` | 标题 + 换行 + 正文 | 只有一个输入框的抖音版本 |
+
+带 `_topics` 的会再把 `release_topics`（逗号分隔）拼成 `#话题`。
+内容由 `push_release` 在同一次运行里传递（断档了就取最近一条"已推送到手机"的）；
+**取计划内容时会回读输入框校验**，不通过就改走剪贴板通道再验一次 ——
+抖音的 EditText 有时不吃键盘输入，不校验的后果是"发出一篇空文案，而每一步都显示成功"。
+
+**抓分享链接**（`mark_release` 的 `capture_link=True`，或计划页人工点「标记已发布」时）：
+进「我 → 作品」第一条 → 分享 → 复制链接 → 读剪贴板 → 正则抠出 `v.douyin.com` 链接。
+**这一段仍是抖音 UI 流程**（按文字定位），抖音改版会失效 —— 失效时链接空着，
+计划页标"缺链接"、素材文件**不删**（链接与素材至少留一个），不影响"已发布"这个结论。
+
 ## 5. 选择器与元素定位
 
 ### 5.1 `selector_type` 支持的值

doc/research/U2_ELEMENT_SELECTORS.md

@@ -172,3 +172,62 @@
 `core/uiauto_helper.py` 里 `_child_path()` 的注释与 `doc/TASK_DEV.md` §5.4 都记了这两个坑，
 避免以后又写回来。
 
+
+---
+
+## 七、抖音「我」页面 + 账号切换列表的选择器（2026-10-12，A01 实测）
+
+**背景**：发布计划改成按**名字**发（`doc/TASK_DEV.md` §4.7），平台需要两处控件：
+① 「我」页面上的**昵称**（读当前登的是谁）；② 「我」页面右上角的**切换账号**入口。
+抖音 40.6.0 / 720×1650 实测（A01 = `192.168.20.82:5555`）。
+
+### 用哪个（已实测可用）
+
+| 用途 | 选择器 | 说明 |
+|---|---|---|
+| **读昵称** | `resourceId = com.ss.android.ugc.aweme:id/tk+` | 读回来就是昵称原文（如 `周周苏州吃喝玩乐`）。等价 xpath：`//*[@resource-id="com.ss.android.ugc.aweme:id/tk+"]` |
+| **进切换列表** | `descriptionContains = 切换账号` | 右上角那个按钮是个 ImageView，**只有 content-desc**（`切换账号`），没有文字 |
+| **切到某个号** | `textContains = <名字>` 点它 | 列表每行的名字是 `TextView`（id `tv_nickname`），**本身 `clickable=false`** —— 但 u2 的 `click()` 是**按中心坐标点屏**，行容器（无 id 的 `ViewGroup`，`clickable=true`）会接住这次点击，实测能切成 |
+| **底部「我」页签** | `descriptionContains = 我` | 页签的 content-desc 是 `我，按钮`（**全角逗号**），`包含` 就能命中；别用 `text=我`（会撞上「我的订单」等） |
+
+### 结构（40.6.0）
+
+```
+「我」页面
+└ LinearLayout uj+                      资料块
+  ├ ukd → s=g → TextView tk+ = 昵称      ← 读名字就用它
+  │        └ j2f → 1gp → ImageView oxp（desc=切换账号）  ← 点它进列表
+  └ ukc → l1= → j6c → g7j = 抖音号：xxx
+
+切换账号列表（点 oxp 后弹出的面板）
+└ View（desc=返回，铺满面板，可点）         ← "点面板外关掉"那层
+  ├ ViewGroup（无 id，clickable）894~1060  ← 第 1 行（当前号）
+  │   ├ ImageView iv_avatar / TextView tv_nickname / TextView 37_（粉丝数）/ CheckBox b7w
+  ├ ViewGroup 1060~1228                   ← 第 2 行
+  ├ ViewGroup 1228~1396                   ← 第 3 行
+  └ ViewGroup 1396~1556（添加或注册新账号）
+```
+
+### 为什么**不要**用 `(…b7w)[N]`
+
+`b7w` 是每行那个单选框（CheckBox）的 id —— `(…b7w)[2]` 看着能选中第 2 行，
+但这正是本文 §二说的**序号型**：`[N]` 依赖"列表里有几行、面板从哪一行开始"，号一多/一少、
+或者抖音把「添加或注册新账号」挪个位置就点到别人号上了（**把内容发到别人号上**，最严重的一类错）。
+按名字点（`textContains=<名字>`）永远指着那一行本身。
+
+### 实测记录
+
+- 冷启动（`app_stop` → `app_start`）后切号：**17.2s** 成功；热态切号 12.9s
+- ⚠ 切完之后**只能等**：实测『回读不到就再点一次「我」』会被当成去点刷新、还可能打断抖音重载，用户直接要求『别刷新，等 15 秒』 → 现在是 `wait_after`（默认 15s，步骤参数可调）等完再回读
+- ⚠ **第一次实现踩的坑**：把"进列表"后的等待写成**固定 sleep(1.2s) 再找一次**，
+  冷启动时列表还没渲染出来 → 判成"本机没登这个号" → **漏发**（还不会报错，只是不发）。
+  现在两处都改成**轮询到 deadline**（`max(6s, timeout)`）：等面板出目标行、等回读变成目标名。
+  教训同 §一：**"找不到"和"没加载出来"必须用等待区分开**。
+
+### 抓取命令（下次 App 改版后重抓）
+
+```bash
+# 前台确保是抖音且在「我」页，然后
+.venv/Scripts/python -c "import uiautomator2 as u2; d=u2.connect('<serial>'); open('me.xml','w',encoding='utf-8').write(d.dump_hierarchy())"
+# 在 me.xml 里找 text 是昵称、或 content-desc 是「切换账号」的节点，看它的 resource-id
+```

scripts/tests/run_all.py

@@ -0,0 +1,46 @@
+"""发布计划「按名字发」相关用例：一次跑完，汇总结果。
+
+用法（项目根目录）：
+    .venv/Scripts/python scripts/tests/run_all.py        # Windows
+    .venv/bin/python scripts/tests/run_all.py            # Linux/macOS
+
+这些用例的**铁律**（与 doc/DEVELOPMENT.md 的测试约定一致）：
+  · 一律**临时 SQLite + 临时目录**（`DATABASE_URL` / `DATA_VIDEO_DIR` 指向 tempfile 建的目录），
+    **绝不碰用户的真实库与真实素材目录**；
+  · 需要设备的地方一律用**假设备**（桩对象/stub），**不连真机、不下发 adb**；
+  · 每个用例自己退出码非 0 表示失败，本脚本据此汇总。
+
+覆盖：
+  test_parse_name        文件名/标题行解析（`名字_日期_编号`、`标题 || 正文_...`、各种拒收）
+  test_upload_name       上传 + 配标题落库（不再依赖任何账号台账）
+  test_name_scope        读本机账号名字、按名字取计划、推送前核对
+  test_switch_account    切换账号（按名字点控件、回读校验、登录页停设备）
+  test_foreach_account   循环本机待发的号（一轮跑完、试过不回头、干净退出）
+  test_push_by_name      按名字找设备推送（matched/unmatched、缓存）
+"""
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+CASES = ["test_parse_name.py", "test_upload_name.py", "test_name_scope.py",
+         "test_switch_account.py", "test_foreach_account.py", "test_push_by_name.py"]
+
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+failed = []
+for name in CASES:
+    print("=" * 66)
+    print("▶", name)
+    print("=" * 66)
+    r = subprocess.run([sys.executable, os.path.join(HERE, name)])
+    if r.returncode != 0:
+        failed.append(name)
+
+print()
+print("=" * 66)
+if failed:
+    print("❌ 失败 %d / %d：%s" % (len(failed), len(CASES), "、".join(failed)))
+    sys.exit(1)
+print("✅ 全部 %d 个用例通过" % len(CASES))

scripts/tests/test_foreach_account.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+"""P5 测试：`foreach_account`（一轮把本机待发的号跑完）—— 临时库，不碰真实数据。"""
+import io
+import os
+import shutil
+import sys
+import tempfile
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+
+TMP = tempfile.mkdtemp(prefix='ac_p5_')
+os.environ['DATABASE_URL'] = 'sqlite:///' + TMP.replace(chr(92), '/') + '/ac.db'
+os.environ['DATA_VIDEO_DIR'] = os.path.join(TMP, 'videos')
+os.environ['DEPLOY_ENV'] = 'dev'
+os.environ['DB_ALLOW_SQLITE_FALLBACK'] = '1'
+
+# 仓库根 = scripts/tests/ 往上三级（不写死绝对路径，换机器也能跑）
+_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, _ROOT)
+os.chdir(_ROOT)
+
+from flask import Flask                                              # noqa: E402
+from core import db_config, models                                   # noqa: E402
+from core import video_plan as vp                                    # noqa: E402
+from tasks.generic import task as gt                                 # noqa: E402
+
+DATE = '2026-09-12'
+fails = []
+
+
+def check(label, got, want):
+    ok = got == want
+    if not ok:
+        fails.append(label)
+    print(('  ✅ ' if ok else '  ❌ ') + label + ('' if ok else '\n       得到 %r\n       期望 %r' % (got, want)))
+
+
+app = Flask("t")
+uri = db_config.build_db_uri()
+app.config["SQLALCHEMY_DATABASE_URI"] = uri
+app.config["SQLALCHEMY_ENGINE_OPTIONS"] = db_config.engine_options(uri)
+app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+models.db.init_app(app)
+with app.app_context():
+    models.db.create_all()
+vp.init_app(app)
+
+
+def seed():
+    """小王 2 条、小李 1 条、小张 1 条（未来）。"""
+    with app.app_context():
+        for i, (nm, d, s) in enumerate([('小王', DATE, 1), ('小王', DATE, 2),
+                                        ('小李', DATE, 1), ('小张', '2027-01-01', 1)]):
+            models.db.session.add(models.VideoPlan(
+                id='p%d' % i, nickname=nm, phone='', device_name='', douyin_id='',
+                serial='', release_date=d, seq=s, seq_auto=False, title='t' + str(s),
+                body='', video_file='x', video_name='x', status=vp.ST_READY,
+                created_at=vp._now(), updated_at=vp._now()))
+        models.db.session.commit()
+
+
+def status_of():
+    with app.app_context():
+        out = {}
+        for r in models.VideoPlan.query.all():
+            out.setdefault(r.nickname, []).append(r.status)
+        return {k: sorted(v) for k, v in out.items()}
+
+
+print('=== 1. 一轮把本机待发的号跑完（模拟"推+发成功"）===')
+seed()
+w = gt.GenericStepsWorker("FAKE01", {}, ctx={"job_id": "t1", "device_name": "A01"})
+order = []
+
+
+def fake_exec_ok(d, steps, depth=0):
+    """模拟一段正常的循环体：把当前 target_name 的下一条待发计划标成 done。"""
+    name = w._vars.get('target_name')
+    order.append(name)
+    with app.app_context():
+        row = (models.VideoPlan.query.filter_by(nickname=name, status=vp.ST_READY)
+               .order_by(models.VideoPlan.seq).first())
+        if row:
+            row.status = vp.ST_DONE
+            models.db.session.commit()
+
+
+w._exec_steps = fake_exec_ok
+w._exec_foreach_account(None, {"children": [{"type": "x"}],
+                               "date_source": "fixed", "fixed_date": DATE})
+# 同日期同编号时按名字**码点**定序：李 U+674E < 王 U+738B → 小李先跑
+check('两个号都跑过（小李 1 条 → 小王 2 条）', order, ['小李', '小王', '小王'])
+check('小王两条都发了', status_of()['小王'], ['done', 'done'])
+check('小李发了', status_of()['小李'], ['done'])
+check('未来的小张没动', status_of()['小张'], ['ready'])
+check('跑完把 target_name 清掉了', w._vars.get('target_name'), None)
+
+print('=== 2. 本机没登这个号 → 不卡死，直接换下一个 ===')
+with app.app_context():
+    models.VideoPlan.query.delete()
+    models.db.session.commit()
+seed()
+w2 = gt.GenericStepsWorker("FAKE02", {}, ctx={"job_id": "t2"})
+seen = []
+
+
+def fake_exec_only_xiaowang(d, steps, depth=0):
+    """只有小王的号在这台机器上：切到别人时什么都不做（模拟切号失败/守卫挡下）。"""
+    name = w2._vars.get('target_name')
+    seen.append(name)
+    if name != '小王':
+        return
+    with app.app_context():
+        row = (models.VideoPlan.query.filter_by(nickname=name, status=vp.ST_READY)
+               .order_by(models.VideoPlan.seq).first())
+        if row:
+            row.status = vp.ST_DONE
+            models.db.session.commit()
+
+
+w2._exec_steps = fake_exec_only_xiaowang
+w2._exec_foreach_account(None, {"children": [{"type": "x"}],
+                                "date_source": "fixed", "fixed_date": DATE})
+check('小王发完（2 条）', status_of()['小王'], ['done', 'done'])
+check('小李只被试了 1 次就跳过（没空转）', seen.count('小李'), 1)
+check('试过的名字不回头', seen, ['小李', '小王', '小王'])
+check('小李还是待发', status_of()['小李'], ['ready'])
+
+print('=== 3. 下一轮会接着发小李（上一轮没发完的还在队列里）===')
+w3 = gt.GenericStepsWorker("FAKE03", {}, ctx={"job_id": "t3"})
+
+
+def fake_exec_all(d, steps, depth=0):
+    name = w3._vars.get('target_name')
+    with app.app_context():
+        row = (models.VideoPlan.query.filter_by(nickname=name, status=vp.ST_READY)
+               .order_by(models.VideoPlan.seq).first())
+        if row:
+            row.status = vp.ST_DONE
+            models.db.session.commit()
+
+
+w3._exec_steps = fake_exec_all
+w3._exec_foreach_account(None, {"children": [{"type": "x"}],
+                                "date_source": "fixed", "fixed_date": DATE})
+check('小李补上了', status_of()['小李'], ['done'])
+
+print('=== 4. 没有待发的号 → 干净收工 ===')
+w4 = gt.GenericStepsWorker("FAKE04", {}, ctx={"job_id": "t4"})
+w4._exec_steps = lambda d, s, depth=0: None
+w4._exec_foreach_account(None, {"children": [{"type": "x"}],
+                                "date_source": "fixed", "fixed_date": DATE})
+check('一条都没跑（不会死循环）', w4._vars.get('target_name'), None)
+
+print('=== 5. max_accounts 上限 ===')
+with app.app_context():
+    models.VideoPlan.query.delete()
+    models.db.session.commit()
+seed()
+w5 = gt.GenericStepsWorker("FAKE05", {}, ctx={"job_id": "t5"})
+ran = []
+w5._exec_steps = lambda d, s, depth=0: ran.append(w5._vars.get('target_name'))
+w5._exec_foreach_account(None, {"children": [{"type": "x"}], "max_accounts": 1,
+                               "date_source": "fixed", "fixed_date": DATE})
+check('只跑 1 个号', ran, ['小李'])
+
+print('=== 6. 子步骤为空 → 不报错、直接结束 ===')
+w6 = gt.GenericStepsWorker("FAKE06", {})
+w6._exec_foreach_account(None, {"children": []})
+check('空 children 直接返回', w6._vars.get('target_name'), None)
+
+print()
+shutil.rmtree(TMP, ignore_errors=True)
+if fails:
+    print('❌ 失败 %d 项：%s' % (len(fails), ' / '.join(fails)))
+    sys.exit(1)
+print('✅ 全部通过（临时库已清理）')

scripts/tests/test_name_scope.py

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*-
+"""P2 测试：读名字 / 按名字取计划 / 推送前核对（**临时库 + 假设备**，不碰真实数据、不连真机）。"""
+import io
+import os
+import shutil
+import sys
+import tempfile
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+
+TMP = tempfile.mkdtemp(prefix='ac_p2_')
+os.environ['DATABASE_URL'] = 'sqlite:///' + os.path.join(TMP, 'ac.db').replace('\\', '/')
+os.environ['DATA_VIDEO_DIR'] = os.path.join(TMP, 'videos')
+os.environ['DEPLOY_ENV'] = 'dev'
+os.environ['DB_ALLOW_SQLITE_FALLBACK'] = '1'
+
+# 仓库根 = scripts/tests/ 往上三级（不写死绝对路径，换机器也能跑）
+_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, _ROOT)
+os.chdir(_ROOT)
+
+from flask import Flask                                              # noqa: E402
+from core import db_config, models                                   # noqa: E402
+from core import video_plan as vp                                    # noqa: E402
+from tasks.generic import task as gt                                 # noqa: E402
+from tasks.generic import publish_flow as flow                       # noqa: E402
+
+fails = []
+
+
+def check(label, got, want):
+    ok = got == want
+    if not ok:
+        fails.append(label)
+    print(('  ✅ ' if ok else '  ❌ ') + label + ('' if ok else '\n       得到 %r\n       期望 %r' % (got, want)))
+
+
+def ok(label, cond, detail=''):
+    if not cond:
+        fails.append(label)
+    print(('  ✅ ' if cond else '  ❌ ') + label + ('' if cond else '  ' + str(detail)))
+
+
+class StubEl:
+    """假元素：u2 的 XPathSelector / UiObject 各用到的成员都给上。"""
+
+    def __init__(self, text):
+        self._t = text
+
+    @property
+    def exists(self):
+        return self._t is not None
+
+    def wait(self, timeout=0):
+        return self._t is not None
+
+    def get_text(self, timeout=None):
+        return self._t
+
+
+class StubD:
+    def __init__(self, text):
+        self.text = text
+
+    def xpath(self, v):
+        return StubEl(self.text)
+
+
+app = Flask("t")
+uri = db_config.build_db_uri()
+app.config["SQLALCHEMY_DATABASE_URI"] = uri
+app.config["SQLALCHEMY_ENGINE_OPTIONS"] = db_config.engine_options(uri)
+app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+models.db.init_app(app)
+with app.app_context():
+    models.db.create_all()
+vp.init_app(app)
+
+print('=== 1. clean_account_name（纯函数）===')
+check('只有名字', vp.clean_account_name('小王'), '小王')
+check('多行：取第一行', vp.clean_account_name('小王\n编辑资料\n抖音号：35377983067'), '小王')
+check('首行是标签 → 往下找', vp.clean_account_name('编辑资料\n小王'), '小王')
+check('抖音号行跳过', vp.clean_account_name('抖音号：35377983067\n小王'), '小王')
+check('统计行跳过', vp.clean_account_name('关注\n粉丝\n小王'), '小王')
+check('名字里的双空格保留', vp.clean_account_name('有牛奶面包  你吃吗？'), '有牛奶面包  你吃吗？')
+check('名字带表情保留', vp.clean_account_name('🐟小鱼'), '🐟小鱼')
+check('「关注我领福利」不当标签', vp.clean_account_name('关注我领福利'), '关注我领福利')
+check('读到空 → ""', vp.clean_account_name('编辑资料\n抖音号：123'), '')
+check('None → ""', vp.clean_account_name(None), '')
+check('首尾空白去掉', vp.clean_account_name('  小王  '), '小王')
+
+print('=== 2. 临时库里造两条计划（小王 / 小李）===')
+with app.app_context():
+    def mk(name, date, seq, status=vp.ST_READY, title="标题"):
+        row = models.VideoPlan(id=name + str(seq) + date[-2:], nickname=name, phone="",
+                               device_name="", douyin_id="", serial="", release_date=date,
+                               seq=seq, seq_auto=False, title=title, body="",
+                               video_file=f"2026-10/x{seq}.mp4", video_name="x.mp4",
+                               status=status, created_at=vp._now(), updated_at=vp._now())
+        models.db.session.add(row)
+    mk('小王', '2026-09-12', 1)
+    mk('小王', '2026-09-13', 2)          # 同一个号，后天那条
+    mk('小李', '2026-09-12', 1)
+    mk('小张', '2026-09-20', 1)          # 未来：不该被取到
+    mk('小赵', '2026-09-10', 1, status=vp.ST_DONE)   # 已发：不该被取到
+    models.db.session.commit()
+
+    print('=== 3. 按名字取计划 ===')
+    check('小王 在 09-12 有一条', [p['seq'] for p in vp.take_for_name(['小王'], '2026-09-12')], [1])
+    check('取 09-13 时，过期的那条先发', [p['seq'] for p in vp.take_for_name(['小王'], '2026-09-13')], [1])
+    check('小李 只认自己的', [p['nickname'] for p in vp.take_for_name(['小李'], '2026-09-12')],
+          ['小李'])
+    check('没有的名字取不到', vp.take_for_name(['不存在'], '2026-09-12'), [])
+    check('名字为空不取（绝不猜）', vp.take_for_name([], '2026-09-12'), [])
+    check('未来的不发', vp.take_for_name(['小张'], '2026-09-12'), [])
+    check('已发的（done）不再入队', vp.take_for_name(['小赵'], '2026-09-12'), [])
+    check('peek 只看不占位', vp.peek_for_name(['小王'], '2026-09-12')['seq'], 1)
+    check('peek 不存在的名字 → None', vp.peek_for_name(['不存在'], '2026-09-12'), None)
+
+    print('=== 4. pending_names / pending_count（循环块的数据源）===')
+    # 同日期同编号时按名字的**码点**定序（只要确定就行，不追求拼音序）：李 U+674E < 王 U+738B
+    check('有待发内容的名字（按最早日期，同日期按名字定序）',
+          [(x['name'], x['release_date'], x['seq'])
+           for x in vp.pending_names('2026-09-13')],
+          [('小李', '2026-09-12', 1), ('小王', '2026-09-12', 1)])
+    check('只看指定的名字', [x['name'] for x in vp.pending_names('2026-09-13', names=['小王'])],
+          ['小王'])
+    check('小王 待发 2 条', vp.pending_count('小王', '2026-09-13'), 2)
+    check('小李 待发 1 条', vp.pending_count('小李', '2026-09-13'), 1)
+    check('已完成的名字不在列表里', [x['name'] for x in vp.pending_names('2026-09-12', names=['小赵'])],
+          [])
+    check('未来日期还没到 → 今天不列', vp.pending_count('小张', '2026-09-12'), 0)
+
+    print('=== 5. 读名字步骤（假设备）===')
+    ctx = {"job_id": "t1", "job_name": "测试"}
+    w = gt.GenericStepsWorker("FAKE01", {}, ctx=ctx)
+    el_raw = '小王\n编辑资料\n抖音号：35377983067'
+    r = w._exec_read_account_name(StubD(el_raw), {"selector_type": "xpath",
+                                                  "selector_value": "//x", "timeout": 1})
+    check('读到名字 → True', r, True)
+    check('_vars.account_name', w._vars.get('account_name'), '小王')
+    check('_vars.name_selector 记下了', w._vars.get('name_selector'), ('xpath', '//x'))
+
+    w2 = gt.GenericStepsWorker("FAKE02", {}, ctx=ctx)
+    r2 = w2._exec_read_account_name(StubD('编辑资料\n抖音号：123'),
+                                    {"selector_type": "xpath", "selector_value": "//x", "timeout": 1})
+    check('读不到（on_missing=fail）→ False', r2, False)
+    check('读不到时不写 account_name', w2._vars.get('account_name'), None)
+
+    w3 = gt.GenericStepsWorker("FAKE03", {}, ctx=ctx)
+    r3 = w3._exec_read_account_name(StubD('编辑资料'), {"selector_type": "xpath",
+                                                       "selector_value": "//x",
+                                                       "on_missing": "skip"})
+    check('on_missing=skip → None（不失败）', r3, None)
+
+    w4 = gt.GenericStepsWorker("FAKE04", {}, ctx=ctx)
+    r4 = w4._exec_read_account_name(StubD('小王'), {"selector_type": "xpath",
+                                                   "selector_value": ""})
+    check('选择器为空 → False（并提示去抓元素）', r4, False)
+
+    print('=== 6. _release_scope：这次发的是哪个号 ===')
+    check('默认按名字（读到谁就是谁）', w._release_scope({}), ('name', ['小王'], '名字『小王』'))
+    check('没有名字 → 空值（跳过，不猜）', w2._release_scope({}),
+          ('name', [], '没读到本机账号名字（前面要有「读取本机账号名字」，'
+                       '或由循环块设目标名字）→ 跳过'))
+    check('account=phone 走老路径', w._release_scope({'account': 'phone',
+                                                    'account_phone': '13300000000'}),
+          ('phone', ['13300000000'], '指定手机号 13300000000'))
+    check('cycle 设的目标名字优先', (w._vars.__setitem__('target_name', '小李'),
+                                    w._release_scope({}))[1], ('name', ['小李'], '名字『小李』'))
+    w._vars.pop('target_name')
+
+    print('=== 7. 条件判断候选值 ===')
+    txt, note = w._resolve_cmp_value({'cmp_source': 'account_target'}, '')
+    check('account_target → 候选=名字', txt, '小王')
+    ok('说明里写了名字', '小王' in note, note)
+    txt2, _ = w2._resolve_cmp_value({'cmp_source': 'account_target'}, '')
+    check('读不到名字 → 候选为空（永远不命中 → 不发）', txt2, '')
+    txt3, _ = w2._resolve_cmp_value({'cmp_source': 'account_target', 'cmp_value': '手填的'}, '手填的')
+    check('读不到名字时手填值仍然生效', txt3, '手填的')
+
+    print('=== 8. 推送前核对（假设备，push_one 打桩）===')
+    calls = []
+    orig = flow.push_one
+
+    def fake_push(serial, plan, opts, log=None):
+        calls.append((serial, plan['id']))
+        return True, "ok"
+
+    flow.push_one = fake_push
+    try:
+        # 8a 屏幕上不是我们要发的人 → 不推
+        w._vars['account_name'] = '小王'
+        w._vars['name_selector'] = ('xpath', '//x')
+        bad = w._exec_push_release(StubD('小李'), {'account': 'name',
+                                                  'date_source': 'fixed',
+                                                  'fixed_date': '2026-09-12'})
+        check('核对不过 → 不推（返回 None）', bad, None)
+        check('push_one 一次都没调', calls, [])
+
+        # 8b 屏幕上就是本人 → 推
+        good = w._exec_push_release(StubD('小王'), {'account': 'name',
+                                                   'date_source': 'fixed',
+                                                   'fixed_date': '2026-09-12'})
+        check('核对通过 → 推成功', good, True)
+        check('push_one 被调了 1 次', len(calls), 1)
+        check('推的是小王那条', calls[0][1], '小王112')
+
+        # 8c 读不到名字 → 不推
+        calls.clear()
+        w2._vars['name_selector'] = ('xpath', '//x')
+        none_ = w2._exec_push_release(StubD('编辑资料'), {'date_source': 'fixed',
+                                                          'fixed_date': '2026-09-12'})
+        check('读不到名字 → 不推', none_, None)
+        check('push_one 没被调', calls, [])
+    finally:
+        flow.push_one = orig
+
+print()
+shutil.rmtree(TMP, ignore_errors=True)
+if fails:
+    print('❌ 失败 %d 项：%s' % (len(fails), ' / '.join(fails)))
+    sys.exit(1)
+print('✅ 全部通过（临时库已清理）')

scripts/tests/test_parse_name.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+"""P1 纯函数测试：`名字_日期_编号` 解析（不碰 DB、不碰用户数据）。"""
+import io
+import os
+import sys
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+# 仓库根 = scripts/tests/ 往上三级（不写死绝对路径，换机器也能跑）
+_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, _ROOT)
+os.chdir(_ROOT)
+from core import video_plan as vp                                     # noqa: E402
+
+fails = []
+
+
+def check(label, got, want):
+    ok = got == want
+    if not ok:
+        fails.append(label)
+    print(('  ✅ ' if ok else '  ❌ ') + label + ('' if ok else '\n       得到 %r\n       期望 %r' % (got, want)))
+
+
+print('=== parse_video_name：合法 ===')
+check('名字_日期_编号', vp.parse_video_name('小王_20260912_1.mp4')[0],
+      {"name": "小王", "date": "2026-09-12", "seq": 1, "seq_given": True})
+check('名字_日期（无编号）', vp.parse_video_name('建材王总_20260913.mp4')[0],
+      {"name": "建材王总", "date": "2026-09-13", "seq": None, "seq_given": False})
+check('名字里带数字', vp.parse_video_name('翻斗花园我最强2号_20260913.mp4')[0]['name'], '翻斗花园我最强2号')
+check('名字里带空格/表情', vp.parse_video_name('有牛奶面包  你吃吗？_20260912_2.mp4')[0]['name'],
+      '有牛奶面包  你吃吗？')
+check('名字里带表情', vp.parse_video_name('🐟小鱼_20260912.mp4')[0]['name'], '🐟小鱼')
+check('大写扩展名', vp.parse_video_name('小王_20260912.MP4')[0]['date'], '2026-09-12')
+check('编号 3 位', vp.parse_video_name('小王_20260912_999.mp4')[0]['seq'], 999)
+
+print('=== parse_video_name：图片（图文）也认 ===')
+check('jpg', vp.parse_video_name('小王_20260912_1.jpg')[0],
+      {"name": "小王", "date": "2026-09-12", "seq": 1, "seq_given": True})
+check('png（无编号）', vp.parse_video_name('建材王总_20260913.png')[0],
+      {"name": "建材王总", "date": "2026-09-13", "seq": None, "seq_given": False})
+check('大写 JPG', vp.parse_video_name('小王_20260912.JPG')[0]['name'], '小王')
+check('webp', vp.parse_video_name('小王_20260912.webp')[0]['date'], '2026-09-12')
+check('gif 不收（没进白名单）',
+      '不是视频/图片' in (vp.parse_video_name('小王_20260912.gif')[1] or ''), True)
+
+print('=== parse_video_name：拒收 ===')
+
+
+def err_of(fn):
+    return fn[1]
+
+
+check('名字带下划线', err_of(vp.parse_video_name('小_王_20260912.mp4')),
+      '名字里不能有下划线：`小_王_20260912` 里日期前面有 2 段 ——应为 名字_日期_编号')
+check('名字是纯数字', err_of(vp.parse_video_name('12345678_20260912.mp4')),
+      '名字不能是纯数字（12345678 会被当成日期/编号）—— 请填抖音上的昵称')
+check('结尾不是日期', err_of(vp.parse_video_name('小王_20260912_1234.mp4')),
+      '文件名格式不对：`小王_20260912_1234` 的结尾既不是日期（8 位数字，如 20260912），'
+      '也不是「日期_编号」—— 应为 名字_日期_编号')
+check('老格式（手机号在前）', err_of(vp.parse_video_name('13382508423_20261011_01.mp4')),
+      '这一段（13382508423）是手机号 —— 文件名第一段要填**抖音上的名字**，'
+      '格式是 名字_日期_编号（现在不认手机号了）')
+check('非法日期', err_of(vp.parse_video_name('小王_20260230.mp4')),
+      '日期 20260230 不是合法日期（应为 20260912 这种 8 位）')
+check('只有一段', err_of(vp.parse_video_name('小王.mp4')),
+      '文件名格式不对，应为 名字_日期_编号（编号可省略，如 小王_20260912.mp4）')
+check('不是视频/图片', err_of(vp.parse_video_name('小王_20260912.txt')),
+      '不是视频/图片文件（支持 mp4/mov/mkv/avi/3gp/flv/wmv/m4v/ts/webm/jpg/jpeg/png/webp/heic）')
+check('空文件名', err_of(vp.parse_video_name('')), '文件名为空')
+check('多段（名字含下划线还带日期）', err_of(vp.parse_video_name('小_王_总_20260912.mp4')),
+      '名字里不能有下划线：`小_王_总_20260912` 里日期前面有 3 段 ——应为 名字_日期_编号')
+
+print('=== parse_title_line：合法 ===')
+check('标题 || 正文_名字_日期_编号', vp.parse_title_line('中秋祝福 || 祝大家中秋快乐_小王_20260912_1')[0],
+      {"title": "中秋祝福", "body": "祝大家中秋快乐", "name": "小王",
+       "date": "2026-09-12", "seq": 1, "seq_given": True})
+check('只有标题', vp.parse_title_line('中秋祝福_小王_20260912')[0],
+      {"title": "中秋祝福", "body": "", "name": "小王",
+       "date": "2026-09-12", "seq": None, "seq_given": False})
+check('只有正文（|| 在最前）', vp.parse_title_line(' || 只有正文_小王_20260912')[0]['body'], '只有正文')
+check('标题里带下划线', vp.parse_title_line('名字带_下划线也行_小王_20260912')[0]['title'], '名字带_下划线也行')
+check('#话题开头的标题', vp.parse_title_line('#中秋快乐_小王_20260929')[0]['title'], '#中秋快乐')
+check('正文里再有 || 原样保留', vp.parse_title_line('标题 || 正文 || 又一处_小王_20260912')[0]['body'],
+      '正文 || 又一处')
+check('标题是纯数字', vp.parse_title_line('2026_小王_20260912_1')[0]['title'], '2026')
+
+print('=== parse_title_line：拒收 ===')
+check('只有名字/日期（没文字）', err_of(vp.parse_title_line('小王_20260912')),
+      '缺标题/正文内容（只有名字/日期/编号，没有文字）')
+check('名字/日期/编号（没文字）', err_of(vp.parse_title_line('小王_20260912_1')),
+      '缺标题/正文内容（只有名字/日期/编号，没有文字）')
+check('老写法（名字在前）', err_of(vp.parse_title_line('19286456013_20260912_1_标题')),
+      "格式不对，应为「标题 || 正文_名字_日期_编号」（编号可省略；日期是 8 位数字，如 20260912）")
+check('名字是手机号', err_of(vp.parse_title_line('标题_13382508423_20260912')),
+      '这一段（13382508423）是手机号 —— 文件名第一段要填**抖音上的名字**，'
+      '格式是 名字_日期_编号（现在不认手机号了）')
+check('标题里带下划线（名字取紧挨日期那段）',
+      vp.parse_title_line('标题_小_王_20260912')[0],
+      {"title": "标题_小", "body": "", "name": "王", "date": "2026-09-12",
+       "seq": None, "seq_given": False})
+check('空行', err_of(vp.parse_title_line('   ')), '空行')
+
+print('=== parse_titles_text：注释与多行 ===')
+rows, errors = vp.parse_titles_text(
+    '标题一_小王_20260912\n# 这是注释\n\n#中秋快乐_小王_20260913\n'
+    '#真注释_没有日期\n标题没有日期')
+check('收下 2 条标题', [r['title'] for r in rows], ['标题一', '#中秋快乐'])
+check('# 认不出名字/日期 → 当注释忽略', [(e['line'], e['raw']) for e in errors], [(6, '标题没有日期')])
+
+print('=== pair_slots：按名字配对 ===')
+videos = [dict(vp.parse_video_name('小王_20260912_1.mp4')[0], ref='v1'),
+          dict(vp.parse_video_name('小王_20260912_2.mp4')[0], ref='v2'),
+          dict(vp.parse_video_name('小李_20260912.mp4')[0], ref='v3')]
+titles = [dict(vp.parse_title_line('标题A_小王_20260912')[0], ref='t1'),
+          dict(vp.parse_title_line('标题B_小王_20260912')[0], ref='t2'),
+          dict(vp.parse_title_line('标题C_小李_20260912')[0], ref='t3')]
+pairs, rejected = vp.pair_slots(videos, titles)
+check('配成 3 对', len(pairs), 3)
+check('没有拒收', rejected, [])
+check('按 (日期,名字,编号) 排序', [(p['date'], p['name'], p['seq']) for p in pairs],
+      [('2026-09-12', '小李', 1), ('2026-09-12', '小王', 1), ('2026-09-12', '小王', 2)])
+check('每对都配上标题', sorted(p['title']['title'] for p in pairs), ['标题A', '标题B', '标题C'])
+check('配对结果里的键是 name', all('name' in p and 'phone' not in p for p in pairs), True)
+
+print()
+if fails:
+    print('❌ 失败 %d 项：%s' % (len(fails), ' / '.join(fails)))
+    sys.exit(1)
+print('✅ 全部通过')

scripts/tests/test_push_by_name.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+"""P6 测试：按名字找设备推送（`_push_by_name`）—— 临时库 + 假探测/假推送，不碰真机。"""
+import io
+import os
+import shutil
+import sys
+import tempfile
+import time
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+
+TMP = tempfile.mkdtemp(prefix='ac_p6_')
+os.environ['DATABASE_URL'] = 'sqlite:///' + TMP.replace(chr(92), '/') + '/ac.db'
+os.environ['DATA_VIDEO_DIR'] = os.path.join(TMP, 'videos')
+os.environ['DEPLOY_ENV'] = 'dev'
+os.environ['DB_ALLOW_SQLITE_FALLBACK'] = '1'
+
+# 仓库根 = scripts/tests/ 往上三级（不写死绝对路径，换机器也能跑）
+_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, _ROOT)
+os.chdir(_ROOT)
+
+from flask import Flask                                              # noqa: E402
+from core import db_config, models, device_pool                      # noqa: E402
+from core import video_plan as vp                                    # noqa: E402
+from core import account_probe                                       # noqa: E402
+from tasks.generic import publish_flow as flow                       # noqa: E402
+from web import video_plan_api as vapi                               # noqa: E402
+
+DATE = '2026-09-12'
+fails = []
+
+
+def check(label, got, want):
+    ok = got == want
+    if not ok:
+        fails.append(label)
+    print(('  ✅ ' if ok else '  ❌ ') + label + ('' if ok else '\n       得到 %r\n       期望 %r' % (got, want)))
+
+
+app = Flask("t")
+uri = db_config.build_db_uri()
+app.config["SQLALCHEMY_DATABASE_URI"] = uri
+app.config["SQLALCHEMY_ENGINE_OPTIONS"] = db_config.engine_options(uri)
+app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+models.db.init_app(app)
+with app.app_context():
+    models.db.create_all()
+vp.init_app(app)
+device_pool.init_app(app)
+
+with app.app_context():
+    models.db.session.add(models.Device(serial='A:5555', name='A01', enabled=True,
+                                        created_at=vp._now()))
+    models.db.session.add(models.Device(serial='B:5555', name='A02', enabled=True,
+                                        created_at=vp._now()))
+    for i, (nm, s) in enumerate([('小王', 1), ('小王', 2), ('小李', 1)]):
+        models.db.session.add(models.VideoPlan(
+            id='p%d' % i, nickname=nm, phone='', device_name='', douyin_id='', serial='',
+            release_date=DATE, seq=s, seq_auto=False, title='t', body='',
+            video_file='x', video_name='x', status=vp.ST_READY,
+            created_at=vp._now(), updated_at=vp._now()))
+    models.db.session.commit()
+
+pushed = []
+lock = []
+
+
+def fake_push(serial, plan, opts=None, log=None):
+    pushed.append((serial, plan['nickname'], plan['seq'], (opts or {}).get('device_name')))
+    return True, "ok"
+
+
+print('=== 1. 名字 → 设备（两台设备各登一个）===')
+probe = {'A:5555': {'serial': 'A:5555', 'name': '小王', 'error': ''},
+         'B:5555': {'serial': 'B:5555', 'name': '小李', 'error': ''}}
+orig_probe, orig_push = account_probe.probe_online, flow.push_one
+account_probe.probe_online = lambda serials=None, skip_busy=True, workers=4: probe
+flow.push_one = fake_push
+try:
+    with app.app_context():
+        rows = vp.pushable_plans(DATE)
+        matched, unmatched = vapi._push_by_name(rows)
+        deadline = time.time() + 3
+        while len(pushed) < 3 and time.time() < deadline:
+            time.sleep(0.05)
+    check('两个名字都找到设备', sorted((m['name'], m['count']) for m in matched),
+          [('小李', 1), ('小王', 2)])
+    check('小王的设备是 A01', [m['device_name'] for m in matched if m['name'] == '小王'], ['A01'])
+    check('没有 unmatched', unmatched, [])
+    check('推了小王的 2 条 + 小李的 1 条', len(pushed), 3)
+    check('推给 A 的是小王的两条（按编号）',
+          sorted((s, q) for (ser, n, q, dn) in pushed if ser == 'A:5555'), [(1, 1), (1, 2)])
+    check('推给 B 的是小李', [(n, q) for (ser, n, q, dn) in pushed if ser == 'B:5555'],
+          [('小李', 1)])
+    check('顺手把设备名字传给了 push_one（写 posted_device_name 用）',
+          {dn for (ser, n, q, dn) in pushed}, {'A01', 'A02'})
+    with app.app_context():
+        cached = [(d.serial, d.cur_account_name)
+                  for d in models.Device.query.order_by(models.Device.serial)]
+    check('探测结果缓存进了 device 表', cached,
+          [('A:5555', '小王'), ('B:5555', '小李')])
+
+    print('=== 2. 没人登着某个名字 → unmatched 里逐条说明 ===')
+    pushed.clear()
+    probe2 = {'A:5555': {'serial': 'A:5555', 'name': '小王', 'error': ''},
+              'B:5555': {'serial': 'B:5555', 'name': '别的号', 'error': ''}}
+    account_probe.probe_online = lambda serials=None, skip_busy=True, workers=4: probe2
+    with app.app_context():
+        rows = vp.pushable_plans(DATE)
+        matched2, unmatched2 = vapi._push_by_name(rows)
+        deadline = time.time() + 3
+        while len(pushed) < 2 and time.time() < deadline:
+            time.sleep(0.05)
+    check('只推了小王那 2 条', len(pushed), 2)
+    check('小李进了 unmatched', [(u['name'], u['count']) for u in unmatched2], [('小李', 1)])
+    check('原因说清了「先切号」', ('没有在线设备登着' in unmatched2[0]['reason']
+                                  and '小李' in unmatched2[0]['reason']
+                                  and '先到设备上切到它' in unmatched2[0]['reason']), True)
+    check('原因里带上当前探测到的号（排查用，别把整个 dict 打出来）',
+          unmatched2[0]['reason'].endswith('（当前探测到：A:5555(小王)、B:5555(别的号)）'), True)
+    if 'dict' in unmatched2[0]['reason'] or '{' in unmatched2[0]['reason']:
+        print('     原因里混进了原始 dict：', unmatched2[0]['reason'])
+
+    print('=== 3. 探测失败（比如选择器没配）→ 也算没设备登着，不炸 ===')
+    pushed.clear()
+    account_probe.probe_online = lambda serials=None, skip_busy=True, workers=4: {
+        'A:5555': {'serial': 'A:5555', 'name': '', 'error': '还没抓昵称控件'},
+        'B:5555': {'serial': 'B:5555', 'name': '', 'error': '连不上设备'}}
+    with app.app_context():
+        rows = vp.pushable_plans(DATE)
+        matched3, unmatched3 = vapi._push_by_name(rows)
+    check('一条都没推', pushed, [])
+    check('两个名字都 unmatched', sorted(u['name'] for u in unmatched3), ['小李', '小王'])
+    with app.app_context():
+        keep = models.Device.query.get('A:5555').cur_account_name
+    check('失败的那台不清空旧缓存', keep, '小王')
+finally:
+    account_probe.probe_online, flow.push_one = orig_probe, orig_push
+
+print()
+shutil.rmtree(TMP, ignore_errors=True)
+if fails:
+    print('❌ 失败 %d 项：%s' % (len(fails), ' / '.join(fails)))
+    sys.exit(1)
+print('✅ 全部通过（临时库已清理）')

scripts/tests/test_switch_account.py

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+"""P4 测试：`switch_account`（按名字找控件点击 + 回读校验）—— 假设备，不碰真机。
+
+不连 adb、不连真机：`d` 是个模拟对象，只实现 u2 里这一步用到的那几个成员。
+"""
+import io
+import os
+import sys
+import time
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+os.environ['DATABASE_URL'] = 'sqlite:///:memory:'
+os.environ['DEPLOY_ENV'] = 'dev'
+os.environ['DB_ALLOW_SQLITE_FALLBACK'] = '1'
+# 仓库根 = scripts/tests/ 往上三级（不写死绝对路径，换机器也能跑）
+_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, _ROOT)
+os.chdir(_ROOT)
+
+from tasks.generic import task as gt                                 # noqa: E402
+
+fails = []
+
+
+def check(label, got, want):
+    ok = got == want
+    if not ok:
+        fails.append(label)
+    print(('  ✅ ' if ok else '  ❌ ') + label + ('' if ok else '\n       得到 %r\n       期望 %r' % (got, want)))
+
+
+class Exists:
+    """u2 的 `exists` 语义：**既可当属性判真假、也可当函数带超时调用**。
+
+    真实 u2 里 `d.xpath(...).exists` 是纯 bool 属性，而 `d(text=...).exists` 是
+    可调用的 Exists 对象（`bool()` 即时判断、`exists(timeout=t)` 带等待）。
+    两处写法都要能被这一步的代码用，所以桩里做个两者通吃的。
+    """
+
+    def __init__(self, flag):
+        self.flag = flag
+
+    def __call__(self, timeout=0):
+        return self.flag
+
+    def __bool__(self):
+        return self.flag
+
+
+class El:
+    def __init__(self, text=None, exists=True, on_click=None):
+        self._t = text
+        self._on = on_click
+        self._e = Exists(exists)
+
+    @property
+    def exists(self):
+        return self._e
+
+    def wait(self, timeout=0):
+        return self._e.flag
+
+    def get_text(self, timeout=None):
+        return self._t
+
+    def click(self):
+        if self._on:
+            self._on()
+
+
+class StubD:
+    """模拟抖音：能读昵称、能进账号列表、能按名字点号。"""
+
+    def __init__(self, cur='小李', accounts=('小王', '小李'), login=False):
+        self.cur = cur
+        self.accounts = list(accounts)
+        self.login = login
+        self.clicked = []
+        self.switch_ok = True          # False = 点了但没切过去（模拟没生效）
+        self.switch_open = True        # False = 进不去账号列表
+
+    def _click_name(self, name):
+        self.clicked.append(name)
+        if self.switch_ok:
+            self.cur = name
+            self.accounts = []      # 真机上点成功后**面板会关掉**（那几行消失）——
+            # 步骤就是靠这个判断"点成功了"的：面板还在 = 这一下被吞了，要再点一次
+
+    LOGIN_HINTS = ('验证码', '其他方式登录', '手机号登录', '一键登录', '密码登录')
+
+    def xpath(self, v):
+        if v == '//name':
+            # 登录页上**根本没有昵称这个控件**（元素不存在）—— 这才是真实情况，
+            # 所以"读名字"会读到空串（而不是读到一堆登录页的文字）
+            return El(None, exists=False) if self.login else El(self.cur)
+        if v == '//switch':
+            return El('', exists=(self.switch_open and not self.login))
+        return El('', exists=False)
+
+    def __call__(self, **kw):
+        if 'descriptionContains' in kw:
+            return El('', exists=(kw['descriptionContains'] == '我'))
+        if 'textContains' in kw:
+            nm = kw['textContains']
+            if self.login and nm in self.LOGIN_HINTS:
+                return El(nm)
+            if nm in self.accounts:
+                return El(nm, on_click=lambda n=nm: self._click_name(n))
+            return El('', exists=False)
+        if 'text' in kw:
+            nm = kw['text']
+            if nm in self.accounts:
+                return El(nm, on_click=lambda n=nm: self._click_name(n))
+            return El('', exists=False)
+        return El('', exists=False)
+
+
+PARAMS = {'target': 'var:target_name', 'switch_selector_type': 'xpath',
+          'switch_selector_value': '//switch', 'name_selector_type': 'xpath',
+          'name_selector_value': '//name', 'timeout': 1, 'max_attempts': 2,
+          # 切完后等它重载的秒数（真机默认 15s）—— 用例里调小，不然一跑就是一分多钟
+          'wait_after': 0.2}
+
+notes = []
+orig_notify = gt.notifier.notify
+gt.notifier.notify = lambda ev, **kw: notes.append((ev, kw.get('want') or ''))
+try:
+    print('=== 1. 已经是目标 → 直接成功，不点任何东西 ===')
+    w = gt.GenericStepsWorker("F1", {})
+    w._vars['target_name'] = '小李'
+    d = StubD(cur='小李')
+    check('返回 True', w._exec_switch_account(d, PARAMS), True)
+    check('一个号都没点', d.clicked, [])
+
+    print('=== 2. 切到另一个号（在列表里按名字点）===')
+    w = gt.GenericStepsWorker("F2", {})
+    w._vars['target_name'] = '小王'
+    d = StubD(cur='小李')
+    check('返回 True', w._exec_switch_account(d, PARAMS), True)
+    check('点是按名字点的', d.clicked, ['小王'])
+    check('当前号变了', d.cur, '小王')
+    check('顺手把运行期变量同步成新名字', w._vars.get('account_name'), '小王')
+
+    print('=== 3. 列表里没有这个名字（本机没登）→ 立刻 False、不重试 ===')
+    notes.clear()
+    w = gt.GenericStepsWorker("F3", {})
+    w._vars['target_name'] = '不存在的号'
+    d = StubD(cur='小李')
+    check('返回 False', w._exec_switch_account(d, PARAMS), False)
+    check('只找了一次（没重试）', d.clicked, [])
+    check('发了切号失败通知', [n[0] for n in notes], ['task.account.switch_failed'])
+    check('通知里带上想切的目标', notes[0][1], '不存在的号')
+
+    print('=== 4. 点了但没切过去 → 按 max_attempts 重试后放弃 + 通知 ===')
+    notes.clear()
+    w = gt.GenericStepsWorker("F4", {})
+    w._vars['target_name'] = '小王'
+    d = StubD(cur='小李')
+    d.switch_ok = False            # 抖音没反应
+    check('返回 False', w._exec_switch_account(d, PARAMS), False)
+    # 面板一直没关（点一次吞一次）→ 每次尝试点两下、共 2 次尝试
+    check('试了 2 次尝试、每次点两下', d.clicked, ['小王', '小王', '小王', '小王'])
+    check('发了切号失败通知', [n[0] for n in notes], ['task.account.switch_failed'])
+
+    print('=== 5. 卡在登录/验证码页 → 通知 + 停本设备 ===')
+    notes.clear()
+    w = gt.GenericStepsWorker("F5", {})
+    w._vars['target_name'] = '小王'
+    d = StubD(cur='小李', login=True)
+    check('返回 False', w._exec_switch_account(d, PARAMS), False)
+    check('发了 need_login 通知', [n[0] for n in notes], ['task.account.need_login'])
+    check('本设备已停止', w.stopped(), True)
+
+    print('=== 6. on_login_page=continue → 不停设备（只记一句）===')
+    notes.clear()
+    w = gt.GenericStepsWorker("F6", {})
+    w._vars['target_name'] = '小王'
+    d = StubD(cur='小李', login=True)
+    p = dict(PARAMS, on_login_page='continue')
+    check('返回 False', w._exec_switch_account(d, p), False)
+    check('还是发了 need_login 通知', [n[0] for n in notes], ['task.account.need_login'])
+    check('设备没被停', w.stopped(), False)
+
+    print('=== 7. 进账号列表的选择器没配 → 明确报错、不乱点 ===')
+    notes.clear()
+    w = gt.GenericStepsWorker("F7", {})
+    w._vars['target_name'] = '小王'
+    d = StubD(cur='小李')
+    p = dict(PARAMS, switch_selector_value='')
+    check('返回 False', w._exec_switch_account(d, p), False)
+    check('没点任何东西', d.clicked, [])
+    check('没瞎发通知（这是配置问题，不是切号失败）', notes, [])
+
+    print('=== 8. 没给目标名字 → 跳过 ===')
+    w = gt.GenericStepsWorker("F8", {})
+    d = StubD(cur='小李')
+    check('返回 False', w._exec_switch_account(d, PARAMS), False)
+    check('没点任何东西', d.clicked, [])
+
+    print('=== 9. verify=False → 点了就算过（不回读）===')
+    w = gt.GenericStepsWorker("F9", {})
+    w._vars['target_name'] = '小王'
+    d = StubD(cur='小李')
+    d.switch_ok = False
+    check('返回 True', w._exec_switch_account(d, dict(PARAMS, verify=False)), True)
+finally:
+    gt.notifier.notify = orig_notify
+
+print()
+if fails:
+    print('❌ 失败 %d 项：%s' % (len(fails), ' / '.join(fails)))
+    sys.exit(1)
+print('✅ 全部通过（没连任何真机）')

scripts/tests/test_upload_name.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+"""P1 集成测试：按名字上传/配标题走通（**临时 SQLite + 临时视频目录**，不碰真实数据）。"""
+import io
+import os
+import shutil
+import sys
+import tempfile
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+
+TMP = tempfile.mkdtemp(prefix='ac_p1_')
+os.environ['DATABASE_URL'] = 'sqlite:///' + os.path.join(TMP, 'ac.db').replace('\\', '/')
+os.environ['DATA_VIDEO_DIR'] = os.path.join(TMP, 'videos')
+os.environ['DEPLOY_ENV'] = 'dev'
+os.environ['DB_ALLOW_SQLITE_FALLBACK'] = '1'
+
+# 仓库根 = scripts/tests/ 往上三级（不写死绝对路径，换机器也能跑）
+_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, _ROOT)
+os.chdir(_ROOT)
+
+from flask import Flask                                              # noqa: E402
+from sqlalchemy import inspect                                       # noqa: E402
+from core import db_config, models                                   # noqa: E402
+from core import video_plan as vp                                    # noqa: E402
+
+fails = []
+
+
+def check(label, got, want):
+    ok = got == want
+    if not ok:
+        fails.append(label)
+    print(('  ✅ ' if ok else '  ❌ ') + label + ('' if ok else '\n       得到 %r\n       期望 %r' % (got, want)))
+
+
+def ok(label, cond, detail=''):
+    if not cond:
+        fails.append(label)
+    print(('  ✅ ' if cond else '  ❌ ') + label + ('' if cond else '  ' + str(detail)))
+
+
+class FakeFile:
+    """够用的 FileStorage 替身：只用到 .filename / .stream。"""
+
+    def __init__(self, filename, data):
+        self.filename = filename
+        self.stream = io.BytesIO(data)
+
+
+app = Flask("t")
+uri = db_config.build_db_uri()
+print('测试库:', uri)
+app.config["SQLALCHEMY_DATABASE_URI"] = uri
+app.config["SQLALCHEMY_ENGINE_OPTIONS"] = db_config.engine_options(uri)
+app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+models.db.init_app(app)
+with app.app_context():
+    models.db.create_all()
+    models._ensure_plain_indexes()        # 生产启动路径里的那一步（老库补索引）
+vp.init_app(app)
+
+with app.app_context():
+    print('=== 0. 前提：台账一张空表也不依赖 ===')
+    check('device_account 里 0 行（上传完全不查台账）', models.DeviceAccount.query.count(), 0)
+    check('video_plan 里 0 行', models.VideoPlan.query.count(), 0)
+
+    print('=== 1. 上传：名字_日期_编号 ===')
+    r = vp.upload_video(FakeFile('小王_20260912_1.mp4', b'A' * 500))
+    ok('上传成功', r.get('ok') is True, r)
+    p = r['plan']
+    check('昵称 = 文件名里的名字', p['nickname'], '小王')
+    check('手机号留空（不再写台账快照）', p['phone'], '')
+    check('设备号留空', p['device_name'], '')
+    check('发布日期', p['release_date'], '2026-09-12')
+    check('编号', p['seq'], 1)
+    check('编号不是自动的', p['seq_auto'], False)
+    check('状态 = 待标题', p['status'], 'pending')
+
+    print('=== 2. 幂等：同一份内容重传 ===')
+    r2 = vp.upload_video(FakeFile('小王_20260912_1.mp4', b'A' * 500))
+    check('跳过', r2.get('action'), 'skip')
+
+    print('=== 3. 同槽位换内容：先拒收、replace 才行 ===')
+    r3 = vp.upload_video(FakeFile('小王_20260912_1.mp4', b'B' * 600))
+    ok('拒收', r3.get('ok') is False and '已有视频' in (r3.get('error') or ''), r3)
+    r4 = vp.upload_video(FakeFile('小王_20260912_1.mp4', b'B' * 600), replace=True)
+    check('覆盖成功', r4.get('action'), 'replace')
+    check('还是 1 行', models.VideoPlan.query.count(), 1)
+
+    print('=== 4. 不带编号 → 自动排到空位 ===')
+    r5 = vp.upload_video(FakeFile('小王_20260912.mp4', b'C' * 700))
+    check('自动编号 = 2', r5['plan']['seq'], 2)
+    check('标记为自动', r5['plan']['seq_auto'], True)
+
+    print('=== 5. 老格式（手机号）被拒 + 说清怎么改 ===')
+    r6 = vp.upload_video(FakeFile('13382508423_20261011_01.mp4', b'D' * 700))
+    ok('拒收且提示是手机号', r6.get('ok') is False and '手机号' in (r6.get('error') or ''), r6)
+    check('库里还是 2 行', models.VideoPlan.query.count(), 2)
+
+    print('=== 6. 配标题（`标题 || 正文_名字_日期_编号`）===')
+    t1 = vp.import_titles('聚划算 || 今天全场五折，点进来看看_小王_20260912')
+    check('配到 1 条', t1['counts']['attached'], 1)
+    row1 = models.VideoPlan.query.filter_by(nickname='小王', release_date='2026-09-12',
+                                            seq=1).first()
+    check('标题落库', row1.title, '聚划算')
+    check('正文落库', row1.body, '今天全场五折，点进来看看')
+    check('状态自动切到待发布', row1.status, 'ready')
+    check('返回体里键是 name', t1['rows'][0]['name'], '小王')
+
+    t2 = vp.import_titles('第二个 || 正文二_小王_20260912_2')
+    check('按编号精确配对', t2['counts']['attached'], 1)
+    row2 = models.VideoPlan.query.filter_by(nickname='小王', release_date='2026-09-12',
+                                            seq=2).first()
+    check('第 2 条标题', row2.title, '第二个')
+
+    t3 = vp.import_titles('这条没有主_不存在的名字_20260912')
+    check('认不出名字 → 拒收', (t3['counts']['rejected'], t3['rows'][0]['error']),
+          (1, '该名字 2026-09-12 没有待配标题的视频（请先上传视频）'))
+
+    # 带编号重配同一条 → 认出来是"配过了"，跳过（幂等）
+    t4 = vp.import_titles('聚划算 || 今天全场五折，点进来看看_小王_20260912_1')
+    check('带编号重配同一条 → 跳过', t4['counts']['skipped'], 1)
+    # 不带编号：它只会找"还没有标题的行"，两行都配过 → 拒收（既有语义，文案说清了原因）
+    t5 = vp.import_titles('聚划算 || 今天全场五折，点进来看看_小王_20260912')
+    check('不带编号且两行都有标题 → 拒收', (t5['counts']['rejected'], t5['rows'][0]['error']),
+          (1, '该名字 2026-09-12 没有待配标题的视频（请先上传视频）'))
+
+    print('=== 7. 老命名空间不受影响：按名字查重/取槽位 ===')
+    check('taken_slots 按名字', vp.taken_slots('小王', '2026-09-12'), {1, 2})
+    check('别的名字是空的', vp.taken_slots('小李', '2026-09-12'), set())
+
+    print('=== 8. 索引补建 ===')
+    idx = {i['name'] for i in inspect(models.db.engine).get_indexes('video_plan')}
+    ok('ix_video_plan_name_date 已建', 'ix_video_plan_name_date' in idx, sorted(idx))
+
+    print('=== 9. 素材落盘 ===')
+    files = os.listdir(os.path.join(TMP, 'videos', '2026-10'))
+    check('落盘 2 个文件（覆盖后旧文件已删）', len(files), 2)
+
+print()
+shutil.rmtree(TMP, ignore_errors=True)
+if fails:
+    print('❌ 失败 %d 项：%s' % (len(fails), ' / '.join(fails)))
+    sys.exit(1)
+print('✅ 全部通过（临时库已清理）')

static/admin/base.js

@@ -102,6 +102,7 @@ function showTab(name){
   if(_monitorTimer){clearInterval(_monitorTimer);_monitorTimer=null;}
   if(_logTimer){clearInterval(_logTimer);_logTimer=null;}
   if(_discoveryTimer){clearInterval(_discoveryTimer);_discoveryTimer=null;}
+  if(typeof _rpTimer!=='undefined'&&_rpTimer){clearInterval(_rpTimer);_rpTimer=null;}
   // 按需加载数据
   if(name==='monitor'){loadMonitor();_monitorTimer=setInterval(loadMonitor,5000);}
   if(name==='tasks'){showSubTab('tasks',_activeSubs.tasks);loadTasks();loadCustomActions();
@@ -116,6 +117,11 @@ function showTab(name){
     showSubTab('agent', _activeSubs.agent||'chat');   // 聊天 / AI 建任务
     if(typeof initAgentChat==='function') initAgentChat();
   }
+  // 发布计划（原「发布计划」子分栏，账号台账下线后升为一级页签）
+  if(name==='plan'){
+    if(typeof loadReleasePlan==='function')loadReleasePlan();
+    if(typeof loadReleaseTasks==='function')loadReleaseTasks();
+  }
   if(name==='users')loadUsers();
   if(name==='system'){showSubTab('system',_activeSubs.system||'backup');}
 }

static/admin/editor.js

@@ -7,7 +7,7 @@ var STEP_LIB=[
   {type:'long_click',label:'长按元素',icon:'👆',cat:'interact',params:{selector_type:'xpath',selector_value:'',duration:1.0,wait_timeout:2}},
   {type:'swipe',label:'滑动',icon:'↕',cat:'interact',params:{direction:'up',duration_min:0.25,duration_max:0.50,distance_ratio:0.6,jitter:0.15,humanize:true}},
   {type:'swipe_until',label:'滑动直到元素',icon:'🔍',cat:'interact',params:{selector_type:'xpath',selector_value:'',direction:'up',max_swipes:8,click_when_found:true,duration_min:0.25,duration_max:0.50,distance_ratio:0.6,jitter:0.15,humanize:true}},
-  {type:'input_text',label:'输入文字',icon:'⌨',cat:'interact',params:{mode:'random',texts:'你好\n有趣\n支持',fixed_text:'',clear_first:true}},
+  {type:'input_text',label:'输入文字',icon:'⌨',cat:'interact',params:{mode:'random',texts:'你好\n有趣\n支持',fixed_text:'',clear_first:true,text_source:'manual',release_topics:''}},
   {type:'clipboard',label:'剪贴板注入',icon:'📋',cat:'interact',params:{text:'',paste:true}},
   {type:'key_event',label:'按键',icon:'⌨️',cat:'interact',params:{key:'back'}},
   {type:'open_app',label:'打开App',icon:'▶',cat:'screen',params:{package:'',wait_home:false,home_feature:''}},
@@ -19,8 +19,11 @@ var STEP_LIB=[
   {type:'wait_el',label:'等待元素',icon:'⏳',cat:'flow',params:{selector_type:'xpath',selector_value:'',timeout:10}},
   {type:'loop',label:'循环块',icon:'↻',cat:'flow',params:{loop_mode:'rounds',max_iterations:10,loop_duration:600,children:[]}},
   {type:'group',label:'动作组',icon:'📦',cat:'flow',params:{children:[]}},
-  {type:'if_el',label:'条件判断',icon:'❓',cat:'flow',params:{selector_type:'xpath',selector_value:'',timeout:3,ocr_click:false,cmp_op:'',cmp_value:'',ident_type:'text',ident_value:'',then:[],else:[]}},
+  {type:'if_el',label:'条件判断',icon:'❓',cat:'flow',params:{selector_type:'xpath',selector_value:'',timeout:3,ocr_click:false,cmp_op:'',cmp_value:'',cmp_source:'',cmp_group:'',ident_type:'text',ident_value:'',then:[],else:[]}},
   {type:'mark_done',label:'记为已做',icon:'✅',cat:'flow',params:{selector_type:'text',selector_value:''}},
+  {type:'read_account_name',label:'读取本机账号名字',icon:'🏷',cat:'flow',params:{selector_type:'xpath',selector_value:'',timeout:8,on_missing:'fail'}},
+  {type:'switch_account',label:'切换账号',icon:'🔁',cat:'flow',params:{target:'var:target_name',target_value:'',switch_selector_type:'xpath',switch_selector_value:'',name_selector_type:'',name_selector_value:'',me_selector_type:'descriptionContains',me_selector_value:'我',timeout:8,wait_after:15,verify:true,max_attempts:2,on_login_page:'stop'}},
+  {type:'foreach_account',label:'循环本机待发的号',icon:'🔂',cat:'flow',params:{date_source:'today',fixed_date:'',retry_failed:true,max_accounts:0,children:[]}},
   {type:'notify',label:'发通知',icon:'🔔',cat:'flow',params:{title:'',message:'',level:'info'}},
   {type:'stop_self',label:'停止本设备',icon:'⛔',cat:'flow',params:{reason:''}},
   {type:'gesture',label:'录制手势',icon:'⏺',cat:'interact',params:{points:[],speed:1.0}}
@@ -265,7 +268,7 @@ var _stepEditor={
     var self=this;
     var lib=_findLib(step.type)||{icon:'?',label:step.type};
     var card=document.createElement('div');
-    card.className='step-card'+(step.type==='loop'?' loop-block':'')+(step.type==='group'?' group-block':'')+(step.type==='if_el'?' if-block':'');
+    card.className='step-card'+(step.type==='loop'?' loop-block':'')+(step.type==='group'?' group-block':'')+(step.type==='if_el'?' if-block':'')+(step.type==='foreach_account'?' loop-block':'');
     card.draggable=true;
     card.dataset.idx=idx;
     card.dataset.stepId=step.id||'';
@@ -313,8 +316,9 @@ var _stepEditor={
       card.classList.remove('drag-over');
       self._handleDrop(e,parentArr,idx);
     });
-    // loop/group 子步骤
+    // loop/group/foreach_account 子步骤（**容器不列进来就看不到里面** —— 加新容器类型时
-    if(step.type==='loop'||step.type==='group'){
+    // 记得同时改这里、card.className 和 _renderParams 三处）
+    if(step.type==='loop'||step.type==='group'||step.type==='foreach_account'){
       if(step.params&&step.params.children){
         var childWrap=document.createElement('div');
         childWrap.className='step-children';
@@ -440,11 +444,25 @@ var _stepEditor={
       h+='<div class="help">批量发链接场景：先"点击元素"聚焦评论区输入框，再执行本步骤注入+粘贴；循环里依次更换注入内容即可逐个发</div>';
     }else if(step.type==='input_text'){
       const im=p.mode==='fixed'?'fixed':'random';
-      h+='<div class="form-group"><label>输入模式</label><select class="form-control" data-key="mode" onchange="_stepEditor._toggleInputMode(this)">'+
+      const tsrc=p.text_source||'manual';
+      const fromPlan=(tsrc!=='manual');
+      // 取值来源：默认手填（行为与以前一致）；也可以直接吃「发布计划」里那一条的标题
+      h+='<div class="form-group"><label>取值来源</label><select class="form-control" data-key="text_source" onchange="_stepEditor._inputSourceChanged(this)">'+
+        [['manual','手填 / 随机候选（默认）'],['release_title','发布计划这一条的标题'],
+         ['release_title_topics','发布计划标题 + 话题'],['release_body','发布计划这一条的正文'],
+         ['release_body_topics','发布计划正文 + 话题'],['release_title_body','标题 + 正文（一个框时用）']]
+          .map(function(o){return '<option value="'+o[0]+'"'+(tsrc===o[0]?' selected':'')+'>'+o[1]+'</option>';}).join('')+
+        '</select><div class="help">选"发布计划"时，标题由前面的「推送发布视频」那一步取出来（同一次运行里传递；没取到会跳过并告警）—— 你就不用把同一句文案再抄一遍了</div></div>';
+      if(fromPlan){
+        h+='<div class="form-group" data-key-wrap="release_topics" style="display:'+(/topics$/.test(tsrc)?'block':'none')+'"><label>话题（逗号分隔，不带 # 会自动补）</label><input type="text" class="form-control" data-key="release_topics" value="'+esc(p.release_topics||'')+'" placeholder="如 苏州,日常"></div>';
+        h+='<div class="help" style="color:#f59e0b">取计划标题时<b>会回读输入框校验</b>：抖音的输入框有时不吃键盘输入，不校验就可能发出一篇空文案；校验不过会自动改走剪贴板粘贴再验一次</div>';
+      }
+      // 手填那两块：**只隐藏不删**（_syncParams 按 DOM 存在与否收集，删了会把用户填的值抹掉）
+      h+='<div class="form-group" style="display:'+(fromPlan?'none':'block')+'"><label>输入模式</label><select class="form-control" data-key="mode" onchange="_stepEditor._toggleInputMode(this)">'+
         '<option value="random"'+(im==='random'?' selected':'')+'>随机候选</option>'+
         '<option value="fixed"'+(im==='fixed'?' selected':'')+'>指定文字</option></select></div>';
-      h+='<div class="form-group" data-mode="random" style="display:'+(im==='random'?'block':'none')+'"><label>候选文字（每行一个，随机选一条）</label><textarea class="form-control" data-key="texts" rows="4" style="font-family:monospace;min-height:80px">'+esc(p.texts||'你好\n有趣\n支持')+'</textarea></div>';
+      h+='<div class="form-group" data-mode="random" style="display:'+((!fromPlan&&im==='random')?'block':'none')+'"><label>候选文字（每行一个，随机选一条）</label><textarea class="form-control" data-key="texts" rows="4" style="font-family:monospace;min-height:80px">'+esc(p.texts||'你好\n有趣\n支持')+'</textarea></div>';
-      h+='<div class="form-group" data-mode="fixed" style="display:'+(im==='fixed'?'block':'none')+'"><label>指定文字</label><input type="text" class="form-control" data-key="fixed_text" value="'+esc(p.fixed_text||'')+'"></div>';
+      h+='<div class="form-group" data-mode="fixed" style="display:'+((!fromPlan&&im==='fixed')?'block':'none')+'"><label>指定文字</label><input type="text" class="form-control" data-key="fixed_text" value="'+esc(p.fixed_text||'')+'"></div>';
       h+='<div class="form-group form-check"><input type="checkbox" data-key="clear_first" '+(p.clear_first!==false?'checked':'')+'><label>输入前先清空</label></div>';
       h+='<div class="help">需先用"点击元素"步骤定位到输入框，本步骤只负责输入文字</div>';
     }else if(step.type==='loop'){
@@ -456,6 +474,16 @@ var _stepEditor={
         '<div class="form-group" data-lmode="rounds" style="display:'+(lm==='rounds'?'block':'none')+'"><label>最大循环次数</label><input type="number" class="form-control" data-key="max_iterations" value="'+(p.max_iterations||10)+'" min="1" max="100000"></div>'+
         '<div class="form-group" data-lmode="time" style="display:'+(lm==='time'?'block':'none')+'"><label>循环时长(秒)</label><input type="number" class="form-control" data-key="loop_duration" value="'+(p.loop_duration||600)+'" min="1"></div></div>';
       h+='<div class="help">将下方子步骤循环执行指定轮次/时长；<b>一直循环</b>无限跑直到任务被外部停止——配合调度"定时启动+停止"（如 9:00 启动 / 18:00 停止）实现全天候养号，或配合任务"运行时长上限"自动停止</div>';
+    }else if(step.type==='foreach_account'){
+      // 循环本机待发的号（发布流程的最外层容器）：把"跑哪些号"讲清楚，别让人以为是普通循环
+      const fds=(p.date_source==='fixed')?'fixed':'today';
+      h+='<div class="form-row"><div class="form-group"><label>跑哪天的计划</label><select class="form-control" data-key="date_source">'+
+        '<option value="today"'+(fds==='today'?' selected':'')+'>今天</option>'+
+        '<option value="fixed"'+(fds==='fixed'?' selected':'')+'>指定日期</option></select></div>'+
+        '<div class="form-group"><label>指定日期(YYYY-MM-DD，仅上面选"指定日期"时用)</label><input type="text" class="form-control" data-key="fixed_date" value="'+esc(p.fixed_date||'')+'" placeholder="2026-10-12"></div></div>';
+      h+='<div class="form-row"><div class="form-group"><label>最多跑几个号（0=不限）</label><input type="number" class="form-control" data-key="max_accounts" value="'+(p.max_accounts||0)+'" min="0"></div>'+
+        '<div class="form-group form-check" style="align-self:end"><input type="checkbox" data-key="retry_failed" '+(p.retry_failed!==false?'checked':'')+'><label>失败过的也再试</label></div></div>';
+      h+='<div class="help">一轮把本机<b>待发的号</b>跑完：逐个把名字写进"本次要发的名字"，执行下方子步骤（切号 → 读名字 → 校验 → 推送 → 发布 → 标记）；<b>试过的不回头</b>，跑完/被停/超时/到上限就收工。数据源是<b>计划表</b>（谁还有待发内容谁就在里面），不需要任何账号维护。</div>';
     }else if(step.type==='group'){
       h+='<div class="help">动作组：按顺序执行下方子步骤一次。把多个步骤打包成一个可复用的整体。</div>';
       h+='<div class="form-group"><button class="btn btn-xs btn-primary" onclick="_stepEditor.saveAsCustomAction(\''+esc(step.id||'')+'\')">存为自定义动作</button> <span class="help" style="display:inline">把本组步骤保存到左侧自定义动作库，方便复用</span></div>';
@@ -464,16 +492,35 @@ var _stepEditor={
       var isDedup=(p.selector_type==='dedup');
       var dyn=(p.selector_type==='screen'||p.selector_type==='foreground'||isDedup);
       // 文本比对：屏幕状态没有文本可比（亮/熄）、去重也不比文本，只有元素/OCR/前台 App 才给这块
+      // 候选值来源：默认"手填"（行为与以前完全一致）；也可以取"本次要发的名字"/发布计划
+      var cmpSrc=p.cmp_source||'';
+      var fromPlatform=(cmpSrc==='account_target'||cmpSrc==='release');
       var cmpRow=dyn?'':'<div class="form-row"><div class="form-group"><label>文本比对</label>'+
         '<select class="form-control" data-key="cmp_op">'+
         [['','不比对（只看元素在不在）'],['等于','等于'],['不等于','不等于'],['包含','包含'],['不包含','不包含']]
           .map(function(o){return '<option value="'+o[0]+'"'+((p.cmp_op||'')===o[0]?' selected':'')+'>'+o[1]+'</option>';}).join('')+
         '</select></div>'+
-        '<div class="form-group" style="grid-column:span 2"><label>比对的值（可多行，任一命中即可）</label>'+
+        '<div class="form-group"><label>候选值来源</label>'+
+        '<select class="form-control" data-key="cmp_source" onchange="_stepEditor._cmpSourceChanged(this)">'+
+        [['','手填（默认）'],['account_target','本次要发的名字（读名字/循环块给的）'],
+         ['release','本机当前发布计划（要发的那条）']]
+          .map(function(o){return '<option value="'+o[0]+'"'+((p.cmp_source||'')===o[0]?' selected':'')+'>'+o[1]+'</option>';}).join('')+
+        '</select><div class="help">'+(p.cmp_source==='release'
+          ? '取<b>本机下一条要发的发布计划</b>的<b>名字</b>（推送前校验"当前登的是不是要发的号"就用它）'
+          : (p.cmp_source==='account_target'
+             ? '取<b>本次要发的那个名字</b>（「读取本机账号名字」读到的，或循环块设的目标）。'
+               +'<b>读不到名字时候选为空 → 不命中 → 走 else（不发）</b>，这是故意的'
+             : '手填要比对的文本；要用本机账号名就用上面的两个来源'))+'</div></div>'+
+        // 候选值来自平台时**只隐藏、不删**这个输入框：_syncParams 是按 DOM 存在与否收集的，
+        // 删了就等于把用户手填的值悄悄抹掉（同类坑见本文件 927 行附近的注释）
+        '<div class="form-group" style="grid-column:span 2'+(fromPlatform?';display:none':'')+'">'+
+        '<label>比对的值（可多行，任一命中即可）</label>'+
         '<textarea class="form-control" data-key="cmp_value" rows="2" style="font-family:var(--mono)" '+
         'placeholder="如 35377983067&#10;35377983068">'+esc(p.cmp_value||'')+'</textarea>'+
-        '<div class="help">一行一个（也认 <code>|</code> 分隔）：<b>任意一个命中就算命中</b>——多个号的场景把号都列上。'+
+        '<div class="help">一行一个（也认 <code>|</code> 分隔）：<b>任意一个命中就算命中</b>——多个值的场景把值都列上。'+
-        '<b>逗号不当分隔符</b>，因为要比对的文本本身常带逗号</div></div></div>';
+        '<b>逗号不当分隔符</b>，因为要比对的文本本身常带逗号'
+        +(fromPlatform?'<br>候选值由平台给（上面选的来源），手填的值会<b>追加</b>在后面。':'')
+        +'</div></div></div>';
       // 「去重」条件：身份元素用 ident_type/ident_value（主选择器那行只剩类型下拉）
       var identRow=isDedup?_selRowHtml(p,
         '<div class="help"><b>身份元素</b>：填"账号"那个元素（点「抓取元素」选，如抖音号那个 TextView）。'
@@ -814,6 +861,19 @@ var _stepEditor={
       g.style.display=g.dataset.lmode===mode?'block':'none';
     });
   },
+  // 输入文字：取值来源切到"发布计划"时，把手填那两块藏起来（话题输入框反过来显示）
+  _inputSourceChanged:function(sel){
+    this._syncFromDom();          // 同 _cmpSourceChanged：不先同步，重渲染会吞掉刚改的值
+    var self=this;
+    setTimeout(function(){self._renderCanvas();},0);
+  },
+  // 条件判断：候选值来源切到"平台给"（本次要发的名字 / 发布计划）时，把"比对的值"藏起来
+  _cmpSourceChanged:function(sel){
+    // 同 _condTypeChanged：先把 DOM 的值同步回 _steps，否则重渲染会吞掉刚改的东西
+    this._syncFromDom();
+    var self=this;
+    setTimeout(function(){self._renderCanvas();},0);
+  },
   // 条件判断：选择器类型切到 OCR 时显示"命中后点击"开关
   _condTypeChanged:function(sel){
     // 条件类型一变，"值"控件也要跟着换（元素值输入框 / 屏幕亮熄下拉 / 包名输入），
@@ -930,10 +990,24 @@ var _stepEditor={
           if(s.params.selector_type!=='dedup'&&!s.params.selector_value){
             warnings.push(name+' "'+label+'": 条件判断的选择器为空，会直接走"未找到"分支。');
           }
-          if(cmpUsed&&s.params.cmp_op&&!String(s.params.cmp_value||'').trim()){
+          var cmpSrcV=(s.params.cmp_source||'');
+          var fromPlatform=(cmpSrcV==='account_target'||cmpSrcV==='release');
+          // 候选值"平台给"的那两档（本次要发的名字 / 发布计划）：手填可以留空，别报"没填值"
+          var fromOther=fromPlatform;
+          if(cmpUsed&&s.params.cmp_op&&!String(s.params.cmp_value||'').trim()&&!fromOther){
             warnings.push(name+' "'+label+'": 选了"文本比对('+s.params.cmp_op+')"但没填比对的值，'
               +'执行时永远不命中（相当于每次都走"未找到时"分支）。');
           }
+          if(cmpUsed&&cmpSrcV==='account_target'&&s.params.cmp_op){
+            warnings.push(name+' "'+label+'": 候选值来自"本次要发的名字" —— 前面要有'
+              +'「读取本机账号名字」步骤（或循环块设的目标名字），名字读不到时候选为空、'
+              +'这一步会走"未找到"分支。这是设计如此（读不到名字 = 不发）。');
+          }
+          if(cmpUsed&&cmpSrcV==='release'&&s.params.cmp_op){
+            warnings.push(name+' "'+label+'": 候选值来自"本机当前发布计划" —— 本机没有待发的计划'
+              +'时取不到号（这一步会走"未找到"分支）。这是设计如此（宁可不发、也不发错号），'
+              +'但请确认前面有「推送发布视频」步骤、且这条计划确实排到了本机。');
+          }
           if(s.params.selector_type==='dedup'){
             hasDedupCheck=true;
             // 空值也收进来：一边填了、另一边没填 = 两处身份不一致（去重会对不上），
@@ -1447,10 +1521,16 @@ var _stepEditor={
     }
     // 填入推荐选择器值，并切换选择器类型
     this._elTargetInput.value=el.suggested.value;
-    var sel=this._elTargetInput.closest('.sc-body').querySelector('[data-key="selector_type"]');
+    // 选择器类型下拉：通用编辑器里在同一个 .sc-body 内；别的编辑器（「发布计划」页的
+    // 步骤就地编辑）结构不同，取不到就跳过、交给下面的 _onFill 自己处理
+    var box=this._elTargetInput.closest('.sc-body');
+    var sel=box?box.querySelector('[data-key="selector_type"]'):null;
     if(sel)sel.value=el.suggested.type;
-    // 程序赋值不会触发 input 事件，手动同步回 _steps 防丢失
+    // 程序赋值不会触发 input 事件，手动同步防丢失。
-    this._syncFromDom();
+    // 默认同步回通用编辑器的 _steps；**别的编辑器用 _onFill 接管**
+    // （见 static/admin/release.js 的就地编辑），否则会同步到不相干的模型上
+    if(typeof this._onFill==='function')this._onFill(el, this._elTargetInput);
+    else this._syncFromDom();
     // 只关闭抓取元素弹窗，不影响任务编辑窗口
     closeElPicker();
     showToast('已填入: '+el.suggested.type+'='+el.suggested.value,'success');

static/admin/tools.js

@@ -561,7 +561,7 @@ async function loadDevPool(){
         '<button class="btn btn-xs" onclick="togglePoolDev(\''+esc(d.serial)+'\','+(!d.enabled)+')">'+(d.enabled?'停用':'启用')+'</button> '+
         '<button class="btn btn-xs btn-danger" onclick="removePoolDev(\''+esc(d.serial)+'\')">删除</button>'+
       '</td></tr>';
-  }).join('')||'<tr><td colspan="8" class="empty">设备池为空，添加第一台设备开始</td></tr>';
+  }).join('')||'<tr><td colspan="9" class="empty">设备池为空，添加第一台设备开始</td></tr>';
 }
 
 async function addPoolDev(){

tasks/generic/publish_flow.py

@@ -0,0 +1,385 @@
+"""发布计划的执行原语：**把视频推到手机**、抓分享链接、清理手机上的素材。
+
+**分工**（用户定的）：平台只负责"素材到手机 + 状态记账"，
+**抖音里怎么发（打开→点+→相册→下一步→填文案→发布）由用户在任务画布里自己写步骤** ——
+所以这里**没有**写死的抖音发布流程，只有三个原语 + 一段编排：
+
+```
+push_one()            取计划 → 原子占位 → adb push 到指定目录 → 触发相册刷新
+                      → 把标题写进剪贴板（供后面的「粘贴」步骤直接用）
+capture_share_link()  进「我 → 作品」第一条 → 分享 → 复制链接 → 读剪贴板 → 抠出 v.douyin.com 链接
+clean_phone_video()   删手机上的素材（**精确路径**，绝不 rm 通配）
+```
+
+任务步骤（`task.py`）：
+  · 「推送发布视频」`push_release` —— 调 `push_one()`
+  · 「标记发布结果」`mark_release` —— 用户在自己的发布流程末尾调用，回写状态（可顺带抓链接）
+
+⚠ **失败阶段决定落 `failed` 还是 `unknown`**（见 `core/video_plan.STAGE_STATUS`）：
+推送阶段失败=还没碰抖音 → `failed`（可安全重试）；推送完成后（stage=`post`）出的岔子
+→ `unknown`（**可能已经发出去了，绝不自动重试**）。
+"""
+import os
+import re
+import time
+
+from core.logger import get_logger
+
+_log = get_logger("task.publish")
+
+# 相册目录：**DCIM/Camera**（用户定的）。
+# ⚠ 实测踩过的两件事：
+#   ① 相册（含抖音的选视频页）读的是 **MediaStore 索引**，`adb push` 只放文件、不进索引
+#      → 推完必须触发一次扫描（见 scan_media），否则"推送成功但相册里没有"。
+#   ② 推到自建子目录 `/sdcard/DCIM/rp` 时，MIUI 会把它归进「其他相册」，
+#      抖音的选视频页看不顺眼 —— 干脆放官方相机目录，哪儿都列得出来。
+# 放 Camera 的代价：用户自己拍的视频也在这个目录里 → **必须靠"刚推的排最前"来定位它**
+#   → 所以推完要 `touch` 把手机上那个文件的 mtime 改成"现在"（adb push 会保留**本地**修改时间，
+#     推一个 3 天前上传的素材，在按时间排序的相册里就排不到最前面 —— 实测踩过）。
+ALBUM_DIR = "/sdcard/DCIM/Camera"
+SCAN_WAIT = 2.0          # 媒体扫描后等相册刷新（真机实测再调）
+# 平台**曾经用过**的推送目录：推送前把同一计划在别处的旧副本清掉（历史遗留 + 换目录后的残留）。
+# 不清的后果实测过：相册里同一个 plan id 出现 2~3 个同名视频，"点第一个"点到的可能是指向
+# 已删文件的老记录 —— 这正是"相册里选错视频"的来源。
+KNOWN_ALBUM_DIRS = ("/sdcard/DCIM/Camera", "/sdcard/DCIM/rp", "/sdcard/Movies/rp")
+
+
+def _norm_path(p):
+    """路径归一化，用于比对：去掉引号、`/storage/emulated/0` 与 `/sdcard` 等价、统一小写。
+
+    ⚠ 大小写不是洁癖：MediaStore 的 `_data` 返回的是 **`/storage/emulated/0/dcim/rp/...`**
+    （目录部分被小写了），而我们写的是 `/sdcard/DCIM/...` —— 直接字符串比对永远不相等。
+    """
+    s = (p or "").strip().strip("'\"")
+    s = s.replace("/storage/emulated/0", "/sdcard").replace("/storage/self/primary", "/sdcard")
+    return s.lower()
+
+
+def _log_of(log):
+    return log or (lambda s: _log.info(s))
+
+
+def _sh(d, cmd):
+    """跑一条 shell 并**拿回文本**。
+
+    uiautomator2 3.x 的 `d.shell()` 返回 `ShellResponse`（**tuple 子类**，字段 .output/.exit_code），
+    不是 str —— 直接 `'abc' in resp`（元组成员判断，恒 False）或 `resp.strip()`（没有这方法）
+    都会得到错误结果。实测踩过：推送后的"文件大小校验"永远不通过、
+    "有没有进相册"永远报没进 —— 全是这一步读错了。统一走这里取文本。
+    """
+    r = d.shell(cmd)
+    out = getattr(r, "output", None)          # u2 3.x
+    if out is None:
+        out = r if isinstance(r, str) else str(r)   # 老版本 u2 / 异常返回
+    return (out or "").strip()
+
+
+# ================== 原语 ==================
+def push_video(d, serial, local_path, plan_id, album_dir=ALBUM_DIR, ext=""):
+    """把平台素材推到手机相册目录，并把手机上的时间改成"现在"。返回 (remote_path, error)。
+
+    改时间是为了**排序**：相册/抖音的选素材页按时间倒序，
+    `adb push` 保留的是**本地文件的修改时间**（推一个 3 天前上传的素材 → 排在很后面），
+    那"点第一个缩略图 = 刚推的那个"就不成立、可能点到别的素材。所以推完 `touch` 一下。
+
+    `ext` 默认**从本地文件名上取**（视频/图片各带各的扩展名）—— 抖音是按扩展名/MIME
+    判断这是视频还是图片的，把图片推成 `xxx.mp4`，相册里就成了一段坏视频。
+    """
+    ext = (ext or os.path.splitext(local_path)[1] or ".mp4").lower()
+    remote = f"{album_dir}/{plan_id}{ext}"
+    try:
+        local_size = os.path.getsize(local_path)
+        _sh(d, f"mkdir -p {album_dir}")
+        if hasattr(d, "push"):
+            d.push(local_path, remote)
+        else:                                   # 老版本 u2 兜底
+            from core.adb_helper import _adb
+            out = _adb("-s", serial, "push", local_path, remote)
+            if "error" in (out or "").lower():
+                return "", f"adb push 失败: {out[:120]}"
+        # 校验：**比对大小列**（不是"输出里有没有这个数字"—— 那种子串匹配会把日期里的
+        # 数字也当命中；u2 的 ShellResponse 更会让它恒不通过，见 _sh 的注释）
+        info = _sh(d, f"ls -l '{remote}'")
+        got = _remote_size(info)
+        if got is None:
+            return "", f"推上去的文件找不到: {info[:120] or '（ls 无输出）'}"
+        if got != local_size:
+            return "", f"推上去的文件大小不对: 本地 {local_size} / 手机 {got}"
+        # 排到最前：把手机上这个文件的 mtime 改成现在（改不动也不拦，只是排序可能不理想）
+        try:
+            _sh(d, f"touch '{remote}'")
+        except Exception as e:
+            _log.warning(f"touch 手机上的素材失败（排序可能不理想）: {e}")
+        drop_old_copies(d, plan_id, keep=remote, ext=ext)   # 老目录里的同名副本顺手清掉
+        return remote, ""
+    except Exception as e:
+        return "", f"推文件异常: {type(e).__name__}: {str(e)[:120]}"
+
+
+def _remote_size(ls_out):
+    """从 `ls -l` 输出里取**大小列**（字节）。取不到返回 None。
+
+    MIUI 的 toybox 输出形如 `-rw-rw---- 1 u0_a163 media_rw 15405006 2026-09-25 08:42 /sdcard/...`。
+    判据两道：① 行首是文件类型字符（`-`/`d`/`l`…）—— 挡住 "No such file" 这类错误行；
+    ② 第 5 列是纯数字 —— 大小列就在那（`ls -l` 一定有 size 列，第 4 列是 owner）。
+    比"输出里有没有这个数字"这种子串匹配可靠得多（后者会被日期/权限里的数字骗到）。
+    """
+    for line in (ls_out or "").splitlines():
+        parts = line.split()
+        if len(parts) >= 6 and parts[0][:1] in "-dlcbps" and parts[4].isdigit():
+            return int(parts[4])
+    return None
+
+
+def _indexed_paths(d, name):
+    """这个文件名在相册索引里对应哪些路径（MediaStore 的 `_data` 列表）。"""
+    query = ("content query --uri content://media/external/video/media --user 0 "
+             f"--projection _id:_display_name:_data --where \"_display_name='{name}'\"")
+    out = _sh(d, query)
+    return [m.group(1) for m in re.finditer(r"_data=(\S+)", out or "")]
+
+
+def scan_media(d, remote):
+    """触发相册刷新，并**按路径**验证它真的进了相册索引。
+
+    返回 `(verify, detail)`：`verify` ∈ `ok`（**这个路径**在索引里）/ `no_index`（扫完还是查不到）。
+
+    ⚠ 为什么要验证：相册读的是 MediaStore 索引，`adb push` 只是放文件 ——
+    推成功但相册看不到是个**静默失败**（"点了第一个缩略图结果点到别的东西"就是这么来的）。
+    ⚠ **必须比路径而不是比文件名**：同一个 plan id 可能在老目录里还留着同名副本
+    （实测 A01 上 `Movies/rp` + `DCIM/rp` 各有一份），只比名字会把"老副本在索引里"
+    误判成"新文件已就绪" —— 相册里点第一个，点到的是那份指向旧文件的记录。
+    ⚠ 命令只用**实测有效**的那两条：Android 12 上 `am broadcast MEDIA_SCANNER_SCAN_FILE`
+    已基本无效（返回 result=0 但什么也不做），真正干活的是 `content call … scan_file`；
+    老写法里那条 `MEDIA_MOUNTED` 广播在新系统上无效、还可能触发全盘重扫，已去掉。
+    """
+    for cmd in (f"content call --uri content://media/external/file --method scan_file --arg '{remote}'",
+                f"am broadcast -a android.intent.action.MEDIA_SCANNER_SCAN_FILE -d file://{remote}"):
+        try:
+            _sh(d, cmd)
+        except Exception as e:
+            _log.warning(f"媒体扫描命令失败（继续）: {e}")
+    time.sleep(SCAN_WAIT)
+    name = remote.split("/")[-1]
+    want = _norm_path(remote)
+    others = []
+    for _ in range(3):          # 索引有时慢半拍，给它一秒再查两次
+        try:
+            paths = _indexed_paths(d, name)
+            if any(_norm_path(p) == want for p in paths):
+                return "ok", f"已进相册索引（{remote}）"
+            others = [p for p in paths if _norm_path(p) != want]
+        except Exception as e:
+            _log.warning(f"查相册索引失败（当作没进）: {e}")
+            break
+        time.sleep(1)
+    if others:
+        _log.warning(f"⚠ 相册索引里只有**同名但不同路径**的记录：{others[:2]} ——"
+                     f"这个文件本身（{remote}）还没进索引")
+    _log.warning(f"⚠ 文件已推到 {remote}，但**没进相册索引**（相册里可能看不到它）——"
+                 f"推送目录 {ALBUM_DIR} 或系统抓取策略可能要调整，见 doc/TASK_DEV.md §4.7")
+    return "no_index", "扫完仍没进相册索引（相册里可能看不到它）"
+
+
+def drop_old_copies(d, plan_id, keep, ext=".mp4"):
+    """（`ext` 由 `push_video` 按素材真实扩展名传进来：视频/图片各删各的旧副本）"""
+    """把**同一个计划**在平台用过别的目录里的旧副本删掉（精确文件名，绝不通配）。
+
+    为什么要删：换了推送目录之后，老目录里的同名副本还在相册里（实测一个 plan id 躺了 3 份），
+    "点第一个缩略图 = 刚推的那个"就不成立了。删完顺手扫一下，让相册索引把那行去掉。
+    """
+    gone = []
+    for adir in KNOWN_ALBUM_DIRS:
+        old = f"{adir}/{plan_id}{ext}"
+        if _norm_path(old) == _norm_path(keep):
+            continue
+        try:
+            if _remote_size(_sh(d, f"ls -l '{old}'")) is None:
+                continue
+            _sh(d, f"rm -f '{old}'")
+            _sh(d, f"content call --uri content://media/external/file --method scan_file --arg '{old}'")
+            gone.append(old)
+        except Exception as e:
+            _log.warning(f"清旧副本失败（不影响本次推送）: {old}: {e}")
+    if gone:
+        _log.info(f"已清掉同一计划在旧目录里的副本: {gone}")
+    return gone
+
+
+def verify_pushed(d, remote):
+    """**推送后的一致性检查**：文件在不在 + 进没进相册索引。返回 (verify, detail)。
+
+    `verify` ∈ `ok` / `no_index` / `nofile`。**这是"推送成功"的判据**：
+    只看文件在不在是不够的 —— 后面的步骤要在相册里点它。
+    """
+    size = _remote_size(_sh(d, f"ls -l '{remote}'"))
+    if size is None:
+        return "nofile", "手机上找不到这个文件"
+    return scan_media(d, remote)
+
+
+def clean_phone_video(d, remote):
+    """删手机上的素材（**精确路径**，绝不通配 —— 通配会删掉用户自己拍的东西）。"""
+    if not remote:
+        return False
+    try:
+        _sh(d, f"rm -f '{remote}'")
+        if _remote_size(_sh(d, f"ls -l '{remote}'")) is not None:
+            _log.warning(f"手机上的素材没删掉: {remote}")
+            return False
+        return True
+    except Exception as e:
+        _log.warning(f"删手机素材异常（不影响发布结论）: {e}")
+        return False
+
+
+def _first_album_item(d):
+    """点相册/作品网格里的**第一个**缩略图（抖音按时间倒序，最新的在最前）。
+
+    不用固定坐标：dump 出网格里的图片单元，按 (y, x) 排序取第一个 ——
+    分辨率/刘海不同的机器都能用。仅用于**抓分享链接**（进「我」的作品第一条）。
+    """
+    try:
+        xml = d.dump_hierarchy()
+    except Exception as e:
+        return False, f"dump 失败: {e}"
+    cells = []
+    for m in re.finditer(r"<node[^>]*>", xml):
+        tag = m.group(0)
+
+        def g(k):
+            mm = re.search(k + r'="([^"]*)"', tag)
+            return mm.group(1) if mm else ""
+        bounds = g("bounds")
+        mb = re.match(r"\[(\d+),(\d+)\]\[(\d+),(\d+)\]", bounds)
+        if not mb:
+            continue
+        x0, y0, x1, y1 = (int(v) for v in mb.groups())
+        if y0 < 200 or (y1 - y0) < 120 or (x1 - x0) < 120:
+            continue
+        cells.append((y0, x0, (x0 + x1) // 2, (y0 + y1) // 2))
+    if not cells:
+        return False, "没找到缩略图"
+    cells.sort()
+    d.click(cells[0][2], cells[0][3])
+    return True, f"点了第一个缩略图 ({cells[0][2]},{cells[0][3]})"
+
+
+def _click_any(d, sels, timeout=3):
+    """按顺序试几个选择器（形如 "text=分享" / "descriptionContains=分享"），点中即返回。"""
+    for sel in sels:
+        try:
+            key, val = sel.split("=", 1)
+            el = d(**{key: val})
+            if el.exists(timeout=timeout):
+                el.click()
+                return True, sel
+        except Exception:
+            continue
+    return False, ""
+
+
+def capture_share_link(d, serial, timeout=30):
+    """抓作品的分享链接：我 → 作品第一条 → 分享 → 复制链接 → 读剪贴板。
+
+    返回 (url, msg)。**抓不到不算失败**：链接空着，界面上标"缺链接"、素材文件不删。
+    ⚠ 这一段仍是抖音 UI 流程，**按文字定位、需真机确认**；抖音改版就走不通。
+    """
+    from core.video_plan import extract_share_url
+    from core.clipboard_helper import inject_clipboard
+    try:
+        _click_any(d, ["descriptionContains=我", "text=我"], timeout=4)
+        time.sleep(2)
+        ok, msg = _first_album_item(d)
+        if not ok:
+            return "", f"进作品页失败: {msg}"
+        time.sleep(2.5)
+        ok, sel = _click_any(d, ["descriptionContains=分享", "text=分享"], timeout=4)
+        if not ok:
+            return "", "没找到「分享」按钮"
+        time.sleep(1.5)
+        ok, sel = _click_any(d, ["text=复制链接", "text=复制"], timeout=4)
+        if not ok:
+            return "", "分享面板里没找到「复制链接」"
+        time.sleep(1.2)
+        try:
+            got = d.clipboard
+        except Exception as e:
+            return "", f"读剪贴板失败: {e}"
+        url = extract_share_url(got or "")
+        return (url, "ok") if url else ("", f"剪贴板里没有抖音链接: {str(got)[:60]!r}")
+    except Exception as e:
+        return "", f"抓链接异常: {type(e).__name__}: {str(e)[:100]}"
+
+
+# ================== 编排 ==================
+def push_one(serial, plan, opts=None, log=None):
+    """把一条计划的素材推到手机（**不发布**）。返回 (ok, msg)。
+
+    做四件事：原子占位（防多设备/重跑重复推）→ 推文件 → 触发相册刷新 →
+    （可选）把标题写进手机剪贴板，供你后面画的「粘贴」步骤直接用。
+
+    占位成功后把 `stage` 置成 `post` —— 意思是"**后面的事不归平台管了**"：
+    再出岔子（比如你标记失败）按 `unknown` 处理，而不是"可安全重试"，
+    避免任务把一条你其实已经发出去的计划又推一遍、又发一遍。
+    """
+    opts = opts or {}
+    log = _log_of(log)
+    import uiautomator2 as u2
+    from core import video_plan as vp
+
+    plan_id = plan["id"]
+    if not vp.claim(plan_id, status=vp.ST_PUSHING, stage=vp.STAGE_MANUAL):
+        return False, "这条已被别的任务/设备领走了（跳过）"
+    d = None
+    try:
+        local = vp._video_path(plan.get("video_file"))
+        if not local or not os.path.exists(local):
+            vp.mark_failed(plan_id, "push", "平台上的素材文件不在了（可能已被清理，要发请重传视频）")
+            return False, "平台素材缺失"
+        d = u2.connect(serial)
+        remote, err = push_video(d, serial, local, plan_id,
+                                 album_dir=opts.get("album_dir") or ALBUM_DIR)
+        if err:
+            vp.mark_failed(plan_id, "push", err)
+            return False, err
+        log(f"素材已推到手机: {remote}")
+        verify, vmsg = verify_pushed(d, remote)
+        if verify == "nofile":
+            # 文件都不在 → 真失败（可重试），别往后走
+            vp.mark_failed(plan_id, "push", vmsg)
+            return False, f"推送校验失败：{vmsg}"
+        log(f"推送校验：{'✅ ' + vmsg if verify == 'ok' else '⚠ ' + vmsg}")
+        title = (plan.get("title") or "").strip()
+        if opts.get("to_clipboard", True) and title:
+            try:
+                from core.clipboard_helper import inject_clipboard
+                okc, msgc = inject_clipboard(serial, title, d=d)
+                log(f"标题已写进剪贴板（{'成功' if okc else '失败: ' + msgc}）"
+                    f"—— 后面用「粘贴」步骤就能填进抖音")
+            except Exception as e:
+                log(f"标题写剪贴板失败（不影响推送）: {e}")
+        vp.mark_pushed(plan_id, remote=remote, verify=verify, serial=serial,
+                       device_name=opts.get("device_name") or "")
+        return True, (f"已推送到手机：{remote}" if verify == "ok"
+                      else f"已推送到手机：{remote}（⚠ {vmsg}）")
+    except Exception as e:
+        vp.mark_failed(plan_id, "push", f"异常: {type(e).__name__}: {str(e)[:150]}")
+        return False, f"推送异常: {type(e).__name__}"
+    finally:
+        try:
+            row = vp.get_plan(plan_id)
+            if row and row["status"] == vp.ST_PUSHING and not row.get("stage") == vp.STAGE_MANUAL:
+                vp.mark_failed(plan_id, "push", "执行中断（兜底降级）")
+        except Exception:
+            pass
+
+
+def run_push(serial, plan_id, opts=None):
+    """给计划页「推送到手机」按钮用的入口（在后台线程里跑）。"""
+    from core import video_plan as vp
+    plan = vp.get_plan(plan_id)
+    if not plan:
+        _log.warning(f"推送：计划 {plan_id} 不存在")
+        return False, "计划不存在"
+    return push_one(serial, plan, opts)

tasks/generic/task.py

@@ -32,6 +32,7 @@ worker 按 steps 顺序执行，支持 loop 步骤循环、停止信号、进度
   loop        - 循环块（含 children 步骤列表 + max_iterations）
   group       - 动作组（含 children 步骤列表，按序执行一次，可折叠复用）
 """
+import os
 import random
 import re
 import time
@@ -72,6 +73,16 @@ def _norm_legacy_xpath(sel_val):
 
 
 # ================== 步骤类型定义（前端操作库 + 后端执行共用）==================
+# 「输入文字」的取值来源：plan 的字段名 → build_caption 的 key。
+# 集中一处定义，免得下面判据分叉（取了标题却当正文填）——加新来源只改这里。
+RELEASE_TEXT_SOURCES = {
+    "release_title": "title",
+    "release_title_topics": "title",
+    "release_body": "body",
+    "release_body_topics": "body",
+    "release_title_body": "title_body",
+}
+
 STEP_TYPES = [
     {"type": "open_app", "label": "打开App", "icon": "▶",
      "params": {"package": "", "wait_home": False, "home_feature": ""}},
@@ -102,7 +113,8 @@ STEP_TYPES = [
     {"type": "wait_el", "label": "等待元素", "icon": "⏳",
      "params": {"selector_type": "xpath", "selector_value": "", "timeout": 10}},
     {"type": "input_text", "label": "输入文字", "icon": "⌨",
-     "params": {"mode": "random", "texts": "你好\n有趣\n支持", "fixed_text": "", "clear_first": True}},
+     "params": {"mode": "random", "texts": "你好\n有趣\n支持", "fixed_text": "",
+                "clear_first": True, "text_source": "manual", "release_topics": ""}},
     {"type": "clipboard", "label": "剪贴板注入", "icon": "📋",
      "params": {"text": "", "paste": True}},
     {"type": "wait", "label": "等待", "icon": "⏱",
@@ -113,11 +125,32 @@ STEP_TYPES = [
      "params": {"children": []}},
     {"type": "if_el", "label": "条件判断", "icon": "❓",
      "params": {"selector_type": "xpath", "selector_value": "", "timeout": 3,
-                "cmp_op": "", "cmp_value": "",
+                "cmp_op": "", "cmp_value": "", "cmp_source": "", "cmp_group": "",
                 "ident_type": "text", "ident_value": "",
                 "then": [], "else": []}},
     {"type": "mark_done", "label": "记为已做", "icon": "✅",
      "params": {"selector_type": "text", "selector_value": ""}},
+    {"type": "read_account_name", "label": "读取本机账号名字", "icon": "🏷",
+     "params": {"selector_type": "xpath", "selector_value": "",
+                "timeout": 8, "on_missing": "fail"}},
+    {"type": "switch_account", "label": "切换账号", "icon": "🔁",
+     "params": {"target": "var:target_name", "target_value": "",
+                "switch_selector_type": "xpath", "switch_selector_value": "",
+                "name_selector_type": "", "name_selector_value": "",
+                "me_selector_type": "descriptionContains", "me_selector_value": "我",
+                "timeout": 8, "wait_after": 15, "verify": True, "max_attempts": 2,
+                "on_login_page": "stop"}},
+    {"type": "foreach_account", "label": "循环本机待发的号", "icon": "🔂",
+     "params": {"date_source": "today", "fixed_date": "", "retry_failed": True,
+                "max_accounts": 0, "children": []}},
+    {"type": "push_release", "label": "推送发布视频", "icon": "📤",
+     "params": {"date_source": "today", "fixed_date": "",
+                "account": "name", "account_phone": "",
+                "album_dir": "/sdcard/DCIM/Camera", "to_clipboard": True,
+                "retry_failed": True, "max_same_run": 1}},
+    {"type": "mark_release", "label": "标记发布结果", "icon": "🏁",
+     "params": {"result": "published", "why": "", "capture_link": True,
+                "delete_phone": True, "album_dir": "/sdcard/DCIM/Camera"}},
     {"type": "notify", "label": "发通知", "icon": "🔔",
      "params": {"title": "", "message": "", "level": "info"}},
     {"type": "stop_self", "label": "停止本设备", "icon": "⛔",
@@ -234,6 +267,12 @@ class GenericStepsWorker(BaseWorker):
         # 「去重」条件最近一次解析出的身份：`mark_done` 留空时复用它，
         # 保证"检查"与"记账"用的是**同一个身份字符串**（否则 key 对不上、去重失效）
         self._last_ident = ""
+        self._last_release = None      # 「推送发布视频」推的那条计划，供「标记发布结果」用
+        # 运行期变量（一台设备一个 worker 实例，天然隔离，不同任务不会串）：
+        #   account_name   「读取本机账号名字」刚读到的名字
+        #   name_selector  读名字用的选择器 (sel_type, sel_val) —— 推送前核对要用同一个控件
+        #   target_name    循环块（foreach_account）本轮设的**目标名字**
+        self._vars = {}
         self._dedup_seen = False     # 本轮是否跑过「去重」检查（区分"没配"与"配了但没读到"）
         # 公共巡检（任务级配置，独立于步骤画布；见 core/patrol.py）：
         # _wid 内部标识，用来记"下次到点 / 上次命中"两个节奏
@@ -346,8 +385,8 @@ class GenericStepsWorker(BaseWorker):
             _log.warning(f"[{self.serial}] 未知步骤类型: {stype}")
             result, detail = "unknown", f"未知步骤类型: {stype}"
         self._record_step(step, result, detail, int((time.time() - t0) * 1000))
-        # 容器步骤（loop/group/if_el）不计入操作计数，避免监控显示噪音
+        # 容器步骤（loop/group/if_el/foreach_account）不计入操作计数，避免监控显示噪音
-        if stype not in ("loop", "group", "if_el"):
+        if stype not in ("loop", "group", "if_el", "foreach_account"):
             self._action_counts[label] = self._action_counts.get(label, 0) + 1
         elapsed = self.elapsed()
         # done=累计执行的操作次数（无固定总数），前端显示"已执行 N 次操作"
@@ -683,6 +722,12 @@ class GenericStepsWorker(BaseWorker):
         timeout = float(params.get("timeout", 3))
         cmp_op = str(params.get("cmp_op") or "").strip()
         cmp_val = str(params.get("cmp_value") or "")
+        # 候选值可以来自「账号台账」（cmp_source）——这里只把 cmp_val 这个**字符串**
+        # 换掉来路，下面 762-780 的比对、候选计数、日志文案全自动跟着对
+        # （_cmp_hit 保持纯函数，不掺 DB）
+        src_note = ""
+        if cmp_op:
+            cmp_val, src_note = self._resolve_cmp_value(params, cmp_val)
         # 去重条件不用 selector_value（身份元素在 ident_value 里），所以别按"缺选择器"拦
         if not sel_val and sel_type != "dedup":
             _log.warning(f"[{self.serial}] if_el 缺少选择器，跳过")
@@ -783,6 +828,11 @@ class GenericStepsWorker(BaseWorker):
             # 界面上那块是隐藏的，旧值会留在 params 里，那种残留每轮都刷警告没意义
             _log.warning(f"[{self.serial}] {sel_type} 没有文本可比，已忽略文本比对设置")
 
+        # 候选值来源（台账/手填）也要进日志与步骤明细：取 0 个号会让这一步
+        # **永远走 else 分支**，而任务照样"跑完了"——只有这里能看出原因
+        if src_note:
+            detail = f"{detail}；{src_note}" if detail else src_note
+
         if dynamic:
             _log.info(f"[{self.serial}] 条件判断 {detail} → {'命中' if found else '未命中'}")
         else:
@@ -797,6 +847,611 @@ class GenericStepsWorker(BaseWorker):
         self._exec_steps(d, branch, depth + 1)
         return found
 
+    def _resolve_cmp_value(self, params, manual_raw):
+        """「条件判断」的候选值 = 手填值 + 台账取号（合并，OR 语义）。
+
+        返回 (候选值文本, 给日志/步骤明细的来源说明)。
+
+        · **合并**而不是二选一：台账取空时手填值仍然生效（台账没维护好不会把任务
+          直接打哑）；"台账里的号 + 临时补一个"也是自然需求 —— split_cmp_values
+          与 `_cmp_hit` 本来就是多值 OR 语义。
+        · 取 0 个号时**必须留痕**：候选为空 ⇒ 这一步永远走 else 分支，而任务本身
+          "跑完了、显示成功"，不写日志就只能靠人猜。
+        · ⚠ 这里产出的只是**比对用的文本**，绝不参与去重 identity：
+          身份是元素原文逐字算 key，候选值格式不同（`小王` vs `昵称：小王`）会让
+          去重静默失效（见 core/dedup.py 的 build_key）。
+        """
+        source = str(params.get("cmp_source") or "").strip()
+        manual = split_cmp_values(manual_raw)
+        if source == "release":
+            # 「发布计划」：本机**下一条将要推送**的那条计划的**名字**（推送前校验账号就靠它）。
+            ids, note = self._release_candidates()
+        elif source == "account_target":
+            # 「本次要发的名字」= 循环块设的目标名字，没有就用刚读到的名字（见 _release_scope）。
+            # ⚠ 读不到名字时候选**为空** → 永远不命中 → 走 else 分支（**不发**）。
+            #   这正是想要的：读不到名字 = 不知道现在登的是谁 = 不能发。
+            name = self._scope_name()
+            if not name:
+                _log.warning(f"[{self.serial}] 条件判断：本次要发的名字读不到"
+                             f"（前面要有「读取本机账号名字」或循环块设目标）→ 候选为空，"
+                             f"这一步永远不命中（走未找到分支）")
+                return manual_raw, "没读到本次要发的名字（读不到 = 不发）"
+            ids, note = [name], f"本次要发的名字『{name}』"
+        else:
+            return manual_raw, ""          # 手填（默认）：行为与以前完全一致
+        merged = list(ids) + [v for v in manual if v not in ids]
+        if not ids:
+            _log.warning(
+                f"[{self.serial}] 条件判断取号为空（来源 {source}）：{note}；手填候选 "
+                f"{len(manual)} 个 → "
+                + ("仅用手填值" if manual else "候选为空，这一步将永远不命中（走未找到分支）"))
+        where = "发布计划" if source == "release" else "本次要发的名字"
+        src_txt = (f"候选来自{where}：{'、'.join(ids)}" if ids
+                   else f"{where}取不到：{note}")
+        if manual:
+            src_txt += f"，另加手填 {len(manual)} 个"
+        return "\n".join(merged), src_txt
+
+    def _scope_name(self):
+        """本次要发的**名字**：循环块设的目标优先，其次刚读到的本机账号名字。取不到返回 ""。"""
+        return ((self._vars.get("target_name") or "").strip()
+                or (self._vars.get("account_name") or "").strip())
+
+    def _release_scope(self, params):
+        """推送/标记/输入文字共用的"这次发的是哪个号"。返回 `(mode, values, who)`。
+
+        `account` 参数：
+          · `name`（默认）—— **本次要发的名字**（`_scope_name()`）。名字取不到时 values 为空，
+            调用方按"没有号"跳过：**绝不猜一个号去发**（读不到名字 = 不发）。
+          · `phone` —— 手填手机号（老任务兼容；账号台账已停用，新任务别再用这条）。
+
+        **这个口径只在这一处定义**（`push_release` / `mark_release` / `input_text` 都走它）：
+        分叉就会出现"推的是 A 号、标记的是 B 号"这种对不上的账。
+        """
+        mode = (params.get("account") or "name").strip().lower()
+        if mode == "phone":
+            phone = (params.get("account_phone") or "").strip()
+            return ("phone", [phone] if phone else [],
+                    f"指定手机号 {phone}" if phone else "没填手机号 → 跳过")
+        name = self._scope_name()
+        if not name:
+            return ("name", [],
+                    "没读到本机账号名字（前面要有「读取本机账号名字」，"
+                    "或由循环块设目标名字）→ 跳过")
+        return ("name", [name], f"名字『{name}』")
+
+    def _release_fetch(self, mode, values, date="", how="take", limit=1, retry_failed=True):
+        """按 scope 取计划。`how`：`take`=候选（**仍要 claim 占位**）/ `peek`=看下一条(不占位) /
+        `last`=最近一条"已推到手机、还没标记"的。"""
+        from core import video_plan as vp
+        if not values:
+            return [] if how == "take" else None
+        if mode == "phone":
+            if how == "peek":
+                return vp.peek_for_device(values, date)
+            if how == "last":
+                return vp.last_pushed_for_device(values)
+            return vp.take_for_device(values, date, limit=limit, retry_failed=retry_failed)
+        if how == "peek":
+            return vp.peek_for_name(values, date)
+        if how == "last":
+            return vp.last_pushed_for_name(values)
+        return vp.take_for_name(values, date, limit=limit, retry_failed=retry_failed)
+
+    def _verify_account_name(self, d, name):
+        """推送前**再读一次**手机屏幕上的昵称，核对是不是真的要发的那个名字。
+
+        返回 `(是否通过, 读到什么)`。**读不到 = 不通过**（宁可不发，也不发错号）。
+        没记录昵称选择器时返回 `(True, "")` —— 那种情况下前面必然已经校验过
+        （切号步骤切完会回读、读取名字步骤刚读过），这里不再重复读一次。
+
+        比对用**双向包含**：元素文本可能是 `小王`，也可能带前缀/后缀（`@小王`），
+        只要有一边包含另一边就算对上 —— 但空文本永远不算对上。
+        """
+        from core import video_plan as vp
+        sel_type, sel_val = self._vars.get("name_selector") or ("", "")
+        if not sel_val:
+            return True, ""
+        got = vp.clean_account_name(self._read_element_text(d, sel_type, sel_val))
+        if not got:
+            return False, ""
+        return (name in got or got in name), got
+
+    def _release_candidates(self):
+        """条件判断的「候选值来源 = 发布计划」：本机要发的那条计划的**名字**。
+
+        优先用本次运行里「推送发布视频」已经拿到的那条（`_last_release`）；
+        还没有就**看**下一条（peek，不占位）—— 这正是"推送前先校验账号对不对"的用法：
+        命中（当前登的就是要发的那个名字）→ 走 then 去推送/发布；未命中 → else 跳过并通知。
+        配「包含」运算符即可。
+        """
+        from core import video_plan as vp
+        plan = getattr(self, "_last_release", None)
+        src = "本次已推送的那条"
+        if not plan:
+            mode, values, _who = self._release_scope({})
+            plan = self._release_fetch(mode, values, vp._today(), how="peek")
+            src = "本机下一条待发"
+        if not plan:
+            return [], "本机没有待发的发布计划"
+        cands = [c for c in (plan.get("nickname"),) if c]
+        note = (f"{src}计划的名字『{plan.get('nickname')}』"
+                f"（{plan.get('release_date')} #{plan.get('seq')}）")
+        return cands, note
+
+    def _exec_read_account_name(self, d, params, depth=0):
+        """读取本机当前登录的账号名字（抖音「我」页面上的昵称控件）。
+
+        参数：`selector_type`(默认 xpath) `selector_value`（**昵称控件，先抓一次**）
+        `timeout`(8) `on_missing`(`fail` 默认 = 读不到就算这一步失败 | `skip` = 记一句继续)
+        `probability`
+
+        读到的东西写进 `self._vars`：
+          · `account_name` = 清洗后的名字（`core.video_plan.clean_account_name`）
+          · `name_selector` = 用的选择器 —— 「推送发布视频」推送前**用同一个控件**再读一次核对
+
+        为什么单独一步而不是藏在推送里：后面的「条件判断」要拿这个名字当候选值
+        （`cmp_source=account_target`），推送前还要核对 —— 三处必须**同一个控件、同一套清洗**，
+        所以选择器与清洗规则都收在这里。读到什么会写进「步骤明细」，
+        名字对不上时一眼能看出"读到的到底是什么"。
+
+        返回 True=读到 / False=读不到（`on_missing=fail`）/ None=读不到但 `on_missing=skip`。
+        """
+        from core import video_plan as vp
+        sel_type = (params.get("selector_type") or "xpath").strip()
+        sel_val = (params.get("selector_value") or "").strip()
+        timeout = float(params.get("timeout") or 8)
+        soft = (params.get("on_missing") or "fail").strip().lower() == "skip"
+        if not sel_val:
+            msg = ("昵称控件的选择器是空的 —— 用「抓取元素」抓一下抖音「我」页面上的昵称，"
+                   "在「读取本机账号名字」和后面的「条件判断」里都填上它")
+            _log.error(f"[{self.serial}] {msg}")
+            self.set_action(msg)
+            return None if soft else False
+        raw = ""
+        try:
+            if sel_type == "xpath":
+                el = d.xpath(sel_val)
+                if el.wait(timeout=timeout):
+                    raw = el.get_text() or ""
+            else:
+                el = d(**{sel_type: sel_val})
+                if el.exists(timeout=timeout):
+                    raw = el.get_text(timeout=_TEXT_READ_TIMEOUT) or ""
+        except Exception as e:
+            _log.warning(f"[{self.serial}] 读取账号名字失败: {e}")
+        name = vp.clean_account_name(raw)
+        self._vars["name_selector"] = (sel_type, sel_val)
+        if not name:
+            _log.warning(f"[{self.serial}] 读取账号名字：读不到（元素原文 {raw!r}）→ "
+                         f"本机算**没有号**：条件判断会走 else、推送会跳过（不发）")
+            self.set_action("读不到本机账号名字（不发）")
+            return None if soft else False
+        self._vars["account_name"] = name
+        _log.info(f"[{self.serial}] 本机账号名字 = 『{name}』（元素原文 {raw!r}）")
+        self.set_action(f"本机账号：{name}")
+        return True
+
+    # 抖音停在登录/验证码页的字样。**只在"切号后回读校验没过"时才拿它判定** ——
+    # 平时查会把「我」页面上的普通文字误判成登录页，而误判会让整台设备停掉。
+    _LOGIN_HINTS = ("验证码", "其他方式登录", "手机号登录", "一键登录", "密码登录",
+                    "登录/注册", "同意用户协议", "选择登录方式")
+
+    def _notify_account(self, event, want="", got="", attempts=0, msg=""):
+        """账号相关通知（切号失败 / 需要登录）。notify 零 DB，发不出去不影响任务。"""
+        try:
+            notifier.notify(event, serial=self.serial,
+                            device_name=(self.ctx or {}).get("device_name", ""),
+                            model=(self.ctx or {}).get("model", ""),
+                            want=want, got=got, attempts=attempts, msg=msg)
+        except Exception as e:
+            _log.warning(f"账号通知发送失败（不影响任务）：{e}")
+
+    def _read_name_now(self, d, params):
+        """现在屏幕上读一次昵称（清洗后）。选择器：步骤参数优先，其次「读取本机账号名字」
+        记下的那个；都没有 → 返回 ""（= 读不到，调用方按"没有号"处理）。"""
+        from core import video_plan as vp
+        sel_type = (params.get("name_selector_type") or "").strip()
+        sel_val = (params.get("name_selector_value") or "").strip()
+        if not sel_val:
+            sel_type, sel_val = self._vars.get("name_selector") or ("", "")
+        if not sel_val:
+            return ""
+        return vp.clean_account_name(self._read_element_text(d, sel_type or "xpath", sel_val))
+
+    def _click_sel(self, d, sel_type, sel_val, timeout=8):
+        """按选择器等元素出现并点击。找不到返回 False（不抛异常）。"""
+        if not sel_val:
+            return False
+        try:
+            if sel_type == "xpath":
+                el = d.xpath(sel_val)
+                if el.wait(timeout=timeout):
+                    el.click()
+                    return True
+                return False
+            el = d(**{sel_type: sel_val})
+            if el.exists(timeout=timeout):
+                el.click()
+                return True
+        except Exception as e:
+            _log.warning(f"[{self.serial}] 点击失败（{sel_type}={sel_val}）: {e}")
+        return False
+
+    def _find_in_list(self, d, name, timeout=1):
+        """账号列表里**有没有**这个名字的控件（只判断，不点）。返回那个 UiObject 或 None。"""
+        for kw in ({"textContains": name}, {"descriptionContains": name}, {"text": name}):
+            try:
+                obj = d(**kw)
+                if obj.exists(timeout=timeout):
+                    return obj
+            except Exception as e:
+                _log.debug(f"[{self.serial}] 列表里按 {kw} 找『{name}』失败: {e}")
+        return None
+
+    def _click_in_list(self, d, name, timeout=4):
+        """在账号列表里**按名字**找控件并点击（文本优先，再试描述/精确文本）。
+
+        ⚠ **绝不用 `[N]` 序号**：`doc/research/U2_ELEMENT_SELECTORS.md` 实测序号型会随界面
+        变形错位 —— 多点一个就是把内容发到别人号上。
+        """
+        obj = self._find_in_list(d, name, timeout)
+        if obj is None:
+            return False
+        try:
+            obj.click()
+            return True
+        except Exception as e:
+            _log.warning(f"[{self.serial}] 点列表里的『{name}』失败: {e}")
+            return False
+
+    def _screen_digest(self, d, limit=6):
+        """给日志用的一小段"现在屏幕上有什么"。
+
+        「点了没反应」这类故障，光看"找不到元素"没法判：是息屏了、跳到别的页面了、
+        还是界面还没加载出来 —— 把当时屏上的头几个字打出来，一眼能分辨。
+        """
+        try:
+            xml = d.dump_hierarchy()
+        except Exception as e:
+            return f"（读元素树失败：{type(e).__name__}）"
+        vals = []
+        for m in re.finditer(r'(?:text|content-desc)="([^"]{1,24})"', xml):
+            v = m.group(1).strip()
+            if v and v not in vals:
+                vals.append(v)
+            if len(vals) >= limit:
+                break
+        on = ""
+        try:
+            on = "亮屏" if screen_is_on(d) else "**息屏/锁屏**"
+        except Exception:
+            pass
+        return f"{on} 前台={current_package(d) or '未知'} 屏上：{'、'.join(vals) or '（空）'}"
+
+    def _switch_target(self, params):
+        """这一步切到哪个名字：`var:target_name`（默认，循环块设的目标）/
+        `var:account_name`（刚读到的）/ `literal` + `target_value`。"""
+        t = (params.get("target") or "var:target_name").strip()
+        if t.startswith("var:"):
+            key = t[4:].strip() or "target_name"
+            val = (self._vars.get(key) or "").strip()
+            if not val and key == "target_name":
+                val = (self._vars.get("account_name") or "").strip()
+            return val
+        return (params.get("target_value") or "").strip()
+
+    def _page_has_text(self, d, words, timeout=0.4):
+        """页面上有没有这些字样（返回命中的词，都没有返回 ""）。"""
+        for w in words:
+            try:
+                if d(textContains=w).exists(timeout=timeout):
+                    return w
+            except Exception:
+                pass
+        return ""
+
+    def _handle_login_page(self, target, hint, params):
+        """停在登录/验证码页：通知 + （默认）停本设备。**平台绝不代替登录/过滑块**。"""
+        msg = f"抖音停在需要登录的页面（出现「{hint}」）—— 请人工登录后再跑"
+        _log.error(f"[{self.serial}] {msg}（想切『{target}』）")
+        self.set_action(f"需要人工登录（{hint}）→ 停本设备")
+        self._notify_account("task.account.need_login", want=target, msg=msg)
+        if (params.get("on_login_page") or "stop").strip().lower() != "continue":
+            self.stop()
+        return False
+
+    def _exec_switch_account(self, d, params, depth=0):
+        """切到本次要发的那个账号（**只在本机已登录过的号之间切**）。
+
+        参数：`target`（`var:target_name` 默认，或 `literal` + `target_value`）、
+        `switch_selector_type`/`switch_selector_value`（进「账号切换」列表那一下，**待抓**）、
+        `name_selector_*`（昵称控件，默认沿用「读取本机账号名字」记下的那个）、
+        `me_selector_*`（底部「我」，默认 `descriptionContains=我`）、
+        `timeout`(8) `verify`(True) `max_attempts`(2) `on_login_page`(stop)
+
+        流程：当前名字已经是目标 → 直接成功（第一个号不用切）→ 点「我」→ 点切换入口 →
+        **在列表里按名字找控件点击** → 等待重载 → **回读校验**（`verify`）。
+
+        返回 True=已经是目标/切成功；False=没切成（本轮该号会被守卫挡下、**不推送**）。
+        **列表里没有这个名字 = 本机没登这个号** → 立刻返回 False（不重试、不算故障）：
+        多台设备各自"试自己有的号"就靠这条，不会互相误报。
+        停在登录/验证码页 → 通知 `task.account.need_login` + 默认停本设备。
+        """
+        target = self._switch_target(params)
+        if not target:
+            _log.warning(f"[{self.serial}] 切换账号：没给目标名字 → 跳过（不发）")
+            self.set_action("切号：没给目标名字 → 跳过")
+            return False
+        timeout = float(params.get("timeout") or 8)
+        want_verify = params.get("verify", True) is not False
+        attempts = max(1, int(params.get("max_attempts") or 2))
+        got = self._read_name_now(d, params)
+        if got and got == target:
+            _log.info(f"[{self.serial}] 切换账号：当前就是『{target}』，不用切")
+            self.set_action(f"已经是『{target}』，不用切")
+            return True
+        switch_val = (params.get("switch_selector_value") or "").strip()
+        if not switch_val:
+            msg = ("「进账号切换列表」的选择器是空的 —— 用「抓取元素」抓一下抖音里那个入口"
+                   "（「我」页面 → 切换账号），填到这一步上")
+            _log.error(f"[{self.serial}] {msg}")
+            self.set_action(msg)
+            return False
+        me_type = params.get("me_selector_type") or "descriptionContains"
+        me_val = params.get("me_selector_value") or "我"
+        last_got = ""
+        for i in range(1, attempts + 1):
+            if self.stopped():
+                return False
+            self._click_sel(d, me_type, me_val, timeout=min(timeout, 4))
+            time.sleep(1.0)
+            if not self._click_sel(d, params.get("switch_selector_type") or "xpath",
+                                   switch_val, timeout):
+                hint = self._page_has_text(d, self._LOGIN_HINTS)
+                if hint:
+                    return self._handle_login_page(target, hint, params)
+                _log.warning(f"[{self.serial}] 切换账号：进不去账号列表（第 {i}/{attempts} 次）"
+                             f"—— {self._screen_digest(d)}")
+                continue
+            # 先**只等**面板开稳（等目标那一行出现，不点）：实测"刚出现就点"会被
+            # 面板的入场动画**吞掉** —— 号没切成、面板还开着，第二轮又变成"进不去列表"。
+            hit = False
+            deadline = time.time() + max(6.0, timeout)
+            while time.time() < deadline:
+                if self.stopped():
+                    return False
+                if self._find_in_list(d, target, timeout=1) is not None:
+                    hit = True
+                    break
+                time.sleep(0.5)
+            if hit:
+                time.sleep(0.8)          # 等面板动画结束（上面那条注释说的时间点）
+                # 点一下；点完**面板还开着**就再点一次，仍开着就按回退把面板关掉。
+                # 为什么要关：**点的如果正好是当前号，抖音什么都不做、面板也不关** ——
+                # 那种情况下"面板还开着"不代表失败，得回到「我」页用**回读**来判。
+                self._click_in_list(d, target, timeout=2)
+                time.sleep(1.5)
+                if self._find_in_list(d, target, timeout=1) is not None:
+                    self._click_in_list(d, target, timeout=2)
+                    time.sleep(1.5)
+                    if self._find_in_list(d, target, timeout=1) is not None:
+                        try:
+                            d.press("back")          # 关掉面板，露出「我」页
+                        except Exception:
+                            pass
+                        time.sleep(1.5)
+            if not hit:
+                hint = self._page_has_text(d, self._LOGIN_HINTS)
+                if hint:
+                    return self._handle_login_page(target, hint, params)
+                _log.warning(f"[{self.serial}] 切换账号：账号列表里没有『{target}』"
+                             f"（等了 {int(max(6.0, timeout))}s）→ 本机没登这个号，跳过（不重试）")
+                self.set_action(f"本机没有『{target}』这个号 → 跳过")
+                self._notify_account("task.account.switch_failed", want=target,
+                                     msg="账号列表里没有这个名字（本机没登这个号）")
+                return False
+            if not want_verify:
+                self.set_action(f"已点击『{target}』（未校验）")
+                return True
+            # 切完之后**先等它自己重载**（默认 15 秒，`wait_after` 可在步骤参数里调）。
+            # 抖音换号会整体重启，中途去点任何东西（包括再点一次「我」页签那一下"刷新"）
+            # 都可能打断它加载 —— 实测用户的要求就是："别刷新，等 15 秒就行"。
+            wait_after = params.get("wait_after")
+            # 注意别写成 `or 15`：那样**显式设 0 会被当成没填**（想"不等"的人会莫名等 15 秒）
+            wait_after = 15.0 if wait_after is None or wait_after == "" else float(wait_after)
+            end = time.time() + max(0.0, wait_after)
+            while time.time() < end and not self.stopped():
+                time.sleep(0.5)
+            # 等完再回读；**不再点任何东西**，只多读几次（页面渲染有零点几秒的抖动）
+            last_got = ""
+            for _ in range(5):
+                if self.stopped():
+                    return False
+                last_got = self._read_name_now(d, params)
+                if last_got == target:
+                    _log.info(f"[{self.serial}] 切换账号成功：『{target}』（第 {i} 次，"
+                              f"等了 {wait_after:.0f}s）")
+                    self.set_action(f"已切到『{target}』")
+                    self._vars["account_name"] = target
+                    return True
+                time.sleep(0.8)
+            hint = self._page_has_text(d, self._LOGIN_HINTS) if not last_got else ""
+            if hint:
+                return self._handle_login_page(target, hint, params)
+            _log.warning(f"[{self.serial}] 切换账号：点完『{target}』回读是"
+                         f"『{last_got or '读不到'}』（第 {i}/{attempts} 次）")
+        self._notify_account("task.account.switch_failed", want=target, got=last_got,
+                             attempts=attempts,
+                             msg=f"切换后回读仍是『{last_got or '读不到'}』")
+        self.set_action(f"切号失败：要『{target}』，读到『{last_got or '读不到'}』")
+        return False
+
+    def _exec_push_release(self, d, params, depth=0):
+        """推送发布视频：把本机某天待发的计划**推到手机相册**（**不发布**）。
+
+        **平台只负责到这里**：推文件 + 触发相册刷新 + 把标题写进剪贴板；
+        抖音里怎么发（打开→点+→相册→选视频→下一步→粘贴标题→发布）由你在这条步骤
+        **后面自己画步骤**，最后放一个「标记发布结果」回写状态。
+
+        参数：`date_source`(today/fixed) `fixed_date` `account`(name/phone) `account_phone`
+        `album_dir`（默认 `/sdcard/DCIM/Camera`）`to_clipboard`(True) `retry_failed`(True)
+        `max_same_run`(1 —— 一次运行推几条；**多条时「标记」只认最后一条**，要发多条就重复"推送+标记"两步)
+
+        `account=name`（默认）时**推送前会再读一次屏幕上的昵称核对**：对不上（或读不到）
+        就**不推**（宁可不发，也不发错号），返回 None 让后面按"没有计划"走。
+
+        返回 None=本机没有待推的（跳过）；True/False=至少推成一条/全失败。
+        """
+        from tasks.generic import publish_flow as flow
+        from core import video_plan as vp
+
+        date = ((params.get("fixed_date") or "").strip()
+                if params.get("date_source") == "fixed" else vp._today()) or vp._today()
+        mode, values, who = self._release_scope(params)
+        if not values:
+            _log.warning(f"[{self.serial}] 推送发布视频：{who}")
+            self.set_action(f"跳过：{who}")
+            return None
+        if mode == "name":
+            ok, got = self._verify_account_name(d, values[0])
+            if not ok:
+                _log.warning(f"[{self.serial}] 推送发布视频：核对不过 —— 屏幕上是『{got or '读不到'}』，"
+                             f"要发的是『{values[0]}』**不推**（宁可不发，也不发错号）")
+                self.set_action(f"跳过：当前账号『{got or '读不到'}』≠ 要发的『{values[0]}』")
+                return None
+        plans = self._release_fetch(mode, values, date, how="take",
+                                    limit=int(params.get("max_same_run") or 1),
+                                    retry_failed=params.get("retry_failed", True) is not False)
+        if not plans:
+            _log.info(f"[{self.serial}] 推送发布视频：{who} 在 {date} 没有待推送的计划 → 跳过")
+            self.set_action(f"{date} 没有待推送计划")
+            return None
+
+        opts = {"album_dir": (params.get("album_dir") or "").strip() or flow.ALBUM_DIR,
+                "to_clipboard": params.get("to_clipboard", True) is not False,
+                # 记"这条实际是哪台设备发的"（计划不绑设备，只能推的时候现场记）
+                "device_name": (self.ctx or {}).get("device_name", "")}
+        okN = badN = 0
+        for plan in plans:
+            if self.stopped():
+                break
+            self._last_release = plan          # 供后面的「标记发布结果」用
+            self.set_action(f"推送中：{plan.get('nickname') or plan['phone']} "
+                            f"{plan['release_date']} #{plan['seq']}")
+            ok, msg = flow.push_one(self.serial, plan, opts,
+                                    log=lambda s: _log.info(f"[{self.serial}] {s}"))
+            if ok:
+                okN += 1
+                # 相册校验结果**单独说一句**：文件上去了 ≠ 相册里点得到它，
+                # 后面那步"点相册里第一个"靠的就是索引（不写这句，出了问题只能猜）
+                row = vp.get_plan(plan["id"]) or {}
+                if row.get("push_verify") == "no_index":
+                    _log.warning(f"[{self.serial}] ⚠ 素材推上去了但**没进相册索引**"
+                                 f"（抖音选视频时可能看不到它）")
+            else:
+                badN += 1
+                self._notify_publish(plan, ok=False, msg=msg)
+        if okN and self._last_release:
+            lr = self._last_release
+            title = (lr.get("title") or "")[:20]
+            self.set_action(f"已推送到手机：{lr.get('nickname') or lr.get('phone')} "
+                            f"{lr['release_date']} #{lr['seq']}"
+                            + (f"（标题『{title}』已进剪贴板）" if title else "")
+                            + "；发完记得放「标记发布结果」")
+            _log.info(f"[{self.serial}] 已推到手机，标题『{title}』已进剪贴板 —— "
+                      f"后面用「粘贴」把它填进抖音，发完记得放一个「标记发布结果」")
+        else:
+            self.set_action(f"推送发布视频：成功 {okN} 条"
+                            + (f"，失败 {badN} 条" if badN else ""))
+        return okN > 0 if (okN or badN) else None
+
+    def _exec_mark_release(self, d, params, depth=0):
+        """标记发布结果：把"发出去了没有"回写到计划行（**你自己发布流程的最后一步**）。
+
+        参数：`result` = `published`(发出去了) / `failed`(没发出去，可重试) / `unknown`(不确定)
+        · `why` 失败原因（可选）· `capture_link`(True) 成功时顺带抓作品分享链接
+        · `delete_phone`(True) 成功/失败后删掉手机上的素材
+
+        放在你画布的**成功分支**里填 `published`、失败分支里填 `failed`；
+        拿不准有没有发出去就填 `unknown`（平台不会自动重发它）。
+        返回 True=标记成功 / False=发布失败 / None=找不到对应的计划（跳过）。
+        """
+        from tasks.generic import publish_flow as flow
+        from core import video_plan as vp
+        import uiautomator2 as u2
+
+        plan = getattr(self, "_last_release", None)
+        if not plan:
+            mode, values, _who = self._release_scope(params)
+            plan = self._release_fetch(mode, values, how="last")
+        if not plan:
+            _log.warning(f"[{self.serial}] 标记发布结果：找不到对应的计划行 → 跳过"
+                         f"（前面要先有一个「推送发布视频」步骤）")
+            self.set_action("没有可标记的计划")
+            return None
+
+        result = (params.get("result") or "published").strip().lower()
+        if result not in ("published", "failed", "unknown"):
+            _log.warning(f"[{self.serial}] 标记发布结果：result={result!r} 认不出 → 按 unknown 处理")
+            result = "unknown"
+        why = (params.get("why") or "").strip()
+
+        # 手机上的素材：先删再回写状态 —— 删失败不影响发布结论。
+        # 路径优先用**推送时记下的** `push_remote`（视频/图片扩展名不同，不能靠猜），
+        # 没有就按 `{相册目录}/{计划id}{素材自己的扩展名}` 现算。
+        if params.get("delete_phone", True) is not False:
+            try:
+                dd = d or u2.connect(self.serial)
+                album = (params.get("album_dir") or "").strip() or flow.ALBUM_DIR
+                ext = os.path.splitext(plan.get("video_file") or "")[1] or ".mp4"
+                remote = (plan.get("push_remote") or "").strip() or f"{album}/{plan['id']}{ext}"
+                flow.clean_phone_video(dd, remote)
+            except Exception as e:
+                _log.warning(f"[{self.serial}] 删手机素材失败（不影响标记）: {e}")
+
+        if result == "published":
+            url = ""
+            if params.get("capture_link", True) is not False:
+                try:
+                    dd = d or u2.connect(self.serial)
+                    url, lmsg = flow.capture_share_link(dd, self.serial)
+                    _log.info(f"[{self.serial}] 抓分享链接：{url or ('失败：' + lmsg)}")
+                except Exception as e:
+                    _log.warning(f"[{self.serial}] 抓分享链接异常: {e}")
+            vp.mark_done(plan["id"], share_url=url, msg=why)
+            self._notify_publish(dict(plan, share_url=url), ok=True, msg=why or "已标记发布成功")
+            self.set_action(f"已标记发布成功（{'链接 ' + url if url else '没抓到链接'}）")
+            return True
+        if result == "failed":
+            # **确认没发出去** → 直接落 `failed`（可重试），不能走 mark_failed('post')
+            # —— 那会落到"结果未知"、反而不敢重试。这里人是亲眼确认过的。
+            vp.set_status(plan["id"], vp.ST_FAILED, note=why or "人工标记：没发出去")
+            self._notify_publish(plan, ok=False, msg=why or "人工标记：没发出去")
+            self.set_action("已标记失败（下次任务会再推一次）")
+            return False
+        vp.mark_failed(plan["id"], "verify", why or "人工标记：结果不确定")
+        self._notify_publish(plan, ok=False, msg=why or "人工标记：结果不确定")
+        self.set_action("已标记「结果未知」（不会自动重发，需人工确认）")
+        return False
+
+    def _notify_publish(self, plan, ok, msg):
+        """发布结果推通知（notify 零 DB：字段都在计划行里，不查库）。"""
+        try:
+            notifier.notify("task.video.published" if ok else "task.video.failed",
+                            serial=self.serial,
+                            device_name=(self.ctx or {}).get("device_name", ""),
+                            model=(self.ctx or {}).get("model", ""),
+                            phone=plan.get("phone", ""),
+                            nickname=plan.get("nickname", ""),
+                            release_date=plan.get("release_date", ""),
+                            seq=plan.get("seq", 0),
+                            title=(plan.get("title") or "")[:60],
+                            share_url=plan.get("share_url", ""),
+                            msg=msg)
+        except Exception as e:
+            _log.warning(f"发布通知发送失败（不影响发布）：{e}")
+
     def _dedup_policy(self):
         """任务级去重有效期（`dedup_reset` / `dedup_hours`）→ (kind, hours)。
 
@@ -1069,6 +1724,78 @@ class GenericStepsWorker(BaseWorker):
             # 扣掉这段时间后可能已经过点了，负数 sleep 会直接抛异常
             time.sleep(max(0.0, min(0.5, end - time.time())))
 
+    def _exec_foreach_account(self, d, params, depth=0):
+        """循环块：**一轮把本机待发的号跑完**（一直切号发，直到发完）。
+
+        参数：`date_source`(today/fixed)、`fixed_date`、`retry_failed`(True)、
+        `max_accounts`(0=不限)、`children`（要重复跑的那段：切号 → 读名 → 守卫 → 推送 → 发布 → 标记）
+
+        循环口径（**只在这一处定义**）：
+
+        · 数据源 = `vp.pending_names(date)` —— 计划表里**还有待发内容**的名字，
+          按 `(发布日期, 编号)` 升序。**不需要任何账号台账**：谁还有待发内容谁就在列表里。
+        · 外层：挑一个**还没试过**的名字 → 写 `_vars["target_name"]` → 跑 children。
+          试过一次就不回头（`tried`）——"本机没登这个号"不会把整轮卡死。
+        · 内层：这个名字**还有待发内容就一直发**（同一个号多条视频）；
+          跑完 children 后待发数没变（切号失败/守卫没过/什么都没占位）→ 立刻换下一个号，
+          绝不空转。
+        · 三个干净出口：`stopped()`（外部停止）/ `is_time_up()`（任务时长上限）/ `max_accounts`。
+
+        跑到一半被停是安全的：`claim()` 已经占位的行由僵尸回收落 `failed`/`unknown`，
+        没跑到的号下一轮 `pending_names` 还会选中 —— **不用怕"没发完就走了"**。
+        """
+        from core import video_plan as vp
+        children = params.get("children") or []
+        if not children:
+            _log.warning(f"[{self.serial}] 循环本机待发的号：没有子步骤 → 直接结束")
+            return None
+        date = ((params.get("fixed_date") or "").strip()
+                if params.get("date_source") == "fixed" else vp._today()) or vp._today()
+        retry_failed = params.get("retry_failed", True) is not False
+        max_accounts = int(params.get("max_accounts") or 0)
+        tried, sent = [], 0
+        while True:
+            if self.stopped() or self.is_time_up():
+                _log.info(f"[{self.serial}] 循环本机待发的号：停止/超时 → 收工（跑过 {sent} 个号）")
+                break
+            if max_accounts and sent >= max_accounts:
+                _log.info(f"[{self.serial}] 循环本机待发的号：到 max_accounts={max_accounts} → 收工")
+                break
+            names = [x["name"] for x in vp.pending_names(date, retry_failed)
+                     if x["name"] not in tried]
+            if not names:
+                _log.info(f"[{self.serial}] 循环本机待发的号：没有待发的号了 → 收工"
+                          f"（跑过 {sent} 个：{'、'.join(tried) or '无'}）")
+                break
+            target = names[0]
+            tried.append(target)               # 试过就不回头（防死循环）
+            self._vars["target_name"] = target
+            sent += 1
+            self.set_action(f"第 {sent} 个号：{target}（本机还有 {len(names)} 个待发名字）")
+            _log.info(f"[{self.serial}] 循环本机待发的号：轮到『{target}』"
+                      f"（本机还有 {len(names)} 个待发名字）")
+            inner = 0
+            while True:
+                if self.stopped() or self.is_time_up():
+                    break
+                before = vp.pending_count(target, date, retry_failed)
+                if before <= 0:
+                    break
+                self._exec_steps(d, children, depth + 1)
+                after = vp.pending_count(target, date, retry_failed)
+                if after >= before:
+                    # 这一轮一条都没占到（切号失败 / 守卫没过 / 推送没成）→ 别空转
+                    _log.info(f"[{self.serial}] 『{target}』这一轮没有进展（仍 {after} 条待发）"
+                              f"→ 换下一个号")
+                    break
+                inner += 1
+                if inner > 20:      # 同一个号一次跑这么多轮显然不对（正常一个号几条）
+                    _log.warning(f"[{self.serial}] 『{target}』已跑 {inner} 轮 → 收手，换下一个号")
+                    break
+        self._vars.pop("target_name", None)
+        self.set_action(f"本轮跑过 {sent} 个号：{'、'.join(tried)}" if tried else "没有待发的号")
+        return None
+
     def _exec_loop(self, d, params, depth=0):
         children = params.get("children", [])
         if not children:
@@ -1123,7 +1850,38 @@ class GenericStepsWorker(BaseWorker):
         需先用"点击元素"步骤定位到输入框，本步骤只负责输入。
         mode=random: 从 texts（换行分隔）随机选一条
         mode=fixed:  输入 fixed_text
+
+        **`text_source`（可选）：文字从哪来**
+          · `manual`（默认）= 用上面的 mode（行为与以前完全一致）
+          · `release_title` = **本机当前那条发布计划的标题**（"推送发布视频"推的那条；
+            本机没有就取最近一条已推送的）· 配 `release_topics` 还能自动加话题
+          · `release_body` = 那条计划的**正文**（同一套来源与回读校验）
+          · `release_title_body` = 标题 + 换行 + 正文（抖音只有一个输入框时用这个）
+        选发布计划来源时**会回读校验**（读输入框的 text）：不校验的后果是
+        "抖音不吃 send_keys → 发出一篇空文案，而每一步都显示成功"；
+        校验不过就自动改走剪贴板通道粘贴（设备端 Agent）再验一次。
         """
+        src = str(params.get("text_source") or "manual").strip()
+        text = ""
+        if src in RELEASE_TEXT_SOURCES:
+            from core import video_plan as vp
+            plan = getattr(self, "_last_release", None)
+            if not plan:
+                mode, values, _who = self._release_scope(params)
+                plan = self._release_fetch(mode, values, how="last")
+            if plan:
+                text, _err = vp.build_caption(
+                    plan, params.get("release_topics") or "",
+                    key=RELEASE_TEXT_SOURCES[src])
+                self._last_release = self._last_release or plan
+                _log.info(f"[{self.serial}] 输入文字取计划{RELEASE_TEXT_SOURCES[src]}："
+                          f"{plan.get('nickname')} "
+                          f"{plan.get('release_date')} #{plan.get('seq')}")
+            if not text:
+                _log.warning(f"[{self.serial}] 输入文字：本机没有可用的发布计划内容 → 跳过"
+                             f"（前面要先有「推送发布视频」步骤）")
+                return None
+        if not text:
             mode = params.get("mode", "random")
             if mode == "fixed":
                 text = params.get("fixed_text", "")
@@ -1154,6 +1912,48 @@ class GenericStepsWorker(BaseWorker):
                     _log.warning(f"[{self.serial}] input_text 未找到输入框: {e}")
             except Exception as e2:
                 _log.warning(f"[{self.serial}] input_text 失败: {e2}")
+        # 取计划标题时**必须回读校验**：抖音的 EditText 有时不吃 send_keys，
+        # 不校验就可能发出一篇空文案而每一步都显示成功
+        if src in RELEASE_TEXT_SOURCES:
+            return self._verify_input(d, text, clear_first)
+        return None
+
+    def _verify_input(self, d, text, clear_first):
+        """回读输入框，确认文字真的进去了；不行就改走剪贴板通道再验一次。"""
+        def _read():
+            try:
+                el = d(className="android.widget.EditText")
+                if el.exists:
+                    return el.get_text(timeout=2) or ""
+            except Exception:
+                pass
+            return ""
+
+        for attempt in (1, 2):
+            got = _read()
+            if got and text[:12] in got:
+                return True
+            _log.warning(f"[{self.serial}] 文案回读不一致（第 {attempt} 次）："
+                         f"期望『{text[:20]}…』读到『{got[:20]}』")
+            if attempt == 1:
+                # 第 2 次改走剪贴板通道（设备端 Agent 写剪贴板 + 粘贴），中文不会变形
+                try:
+                    from core.clipboard_helper import inject_clipboard
+                    okc, msgc = inject_clipboard(self.serial, text, d=d)
+                    if okc:
+                        d.jsonrpc.pasteClipboard()
+                        time.sleep(1)
+                    else:
+                        _log.warning(f"[{self.serial}] 剪贴板兜底注入失败: {msgc}")
+                except Exception as e:
+                    _log.warning(f"[{self.serial}] 剪贴板兜底异常: {e}")
+                time.sleep(1)
+        got = _read()
+        if got and text[:12] in got:
+            return True
+        _log.warning(f"[{self.serial}] ⚠ 文案没填进去（读回『{got[:30]}』）——"
+                     f"接着发布就会发出空文案，这一步判失败")
+        return False
 
 
 @register_task

templates/admin/monitor.html

@@ -513,6 +513,7 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
     <button class="tab active" data-tab="monitor" onclick="showTab('monitor')">监控</button>
     <button class="tab" data-tab="tasks" onclick="showTab('tasks')">任务</button>
     <button class="tab" data-tab="logs" onclick="showTab('logs')" data-perm="logs">日志</button>
+    <button class="tab" data-tab="plan" onclick="showTab('plan')" data-perm="devices">发布计划</button>
     <button class="tab" data-tab="users" onclick="showTab('users')" data-perm="admin">用户</button>
     <button class="tab" data-tab="tools" onclick="showTab('tools')" data-perm="admin">工具</button>
     <button class="tab" data-tab="agent" onclick="showTab('agent')" data-perm="admin">AI 控制台</button>
@@ -581,6 +582,88 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
   <div id="jobs-grid" class="jobs-grid"></div>
 </div>
 
+<!-- ========== Tab: 发布计划 ========== -->
+<div id="tab-plan" class="tab-panel">
+  <div class="page-title">发布计划</div>
+  <div class="page-sub">每个视频 = 一条计划：<b>文件名里的名字</b>（= 抖音昵称）+ 发布日期 + 编号，
+    到日子由任务推到手机、按名字找设备/账号发布（谁在机内、能不能发视频由运行时现场读名字判断）</div>
+
+  <div>
+    <div class="toolbar" style="flex-wrap:wrap">
+      <button class="btn btn-primary" onclick="document.getElementById('rp-video-input').click()"
+              data-perm="devices">上传视频/图片</button>
+      <button class="btn" onclick="document.getElementById('rp-title-input').click()"
+              data-perm="devices">上传标题/正文</button>
+      <button class="btn btn-primary" onclick="rpPushAll()" data-perm="devices"
+              title="把今天所有「待发布/失败」的计划推给「现在登着对应名字」的设备（按名字找设备；同台设备串行推）">一键推送（今天）</button>
+      <button class="btn" onclick="rpExportLinks()">导出链接 CSV</button>
+      <button class="btn" onclick="loadReleasePlan()">刷新</button>
+      <select class="form-control" id="rp-range" style="width:130px" onchange="rpRangeChanged()">
+        <option value="today">今天</option>
+        <option value="week">未来 7 天</option>
+        <option value="all">全部</option>
+      </select>
+      <select class="form-control" id="rp-status" style="width:150px" onchange="rpRangeChanged()">
+        <option value="">全部状态</option>
+        <option value="pending">待标题</option>
+        <option value="ready">待发布</option>
+        <option value="done">已发布</option>
+        <option value="failed,unknown">失败/未知</option>
+        <option value="skipped">已跳过</option>
+      </select>
+      <input class="form-control list-search" id="search-release" placeholder="搜索名字/标题/文件名...">
+      <span class="text-muted" id="rp-stats"></span>
+    </div>
+
+    <!-- 发布任务：到点自动"推送 + 发视频"。素材（上面）与执行（这里）在同一页 -->
+    <div style="border:1px solid var(--border);border-radius:6px;padding:8px 10px;margin-bottom:10px">
+      <div style="display:flex;justify-content:space-between;align-items:center;gap:8px;flex-wrap:wrap">
+        <div><b>发布任务</b>
+          <span class="text-muted" style="font-size:12px">
+            到点自动跑：推送素材 → 你的抖音步骤 → 标记结果（抖音那几步的选择器要你自己抓一次）
+          </span></div>
+        <div style="white-space:nowrap">
+          <button class="btn btn-xs btn-primary" onclick="rpNewTask()" data-perm="tasks">一键新建发布任务</button>
+          <button class="btn btn-xs" onclick="loadReleaseTasks()">刷新</button>
+        </div>
+      </div>
+      <div id="rp-tasks" style="margin-top:6px"></div>
+    </div>
+
+    <div id="rp-timeline"></div>
+    <div class="list-pager" id="pager-release"></div>
+
+    <details style="margin-top:12px">
+      <summary style="cursor:pointer;color:var(--text-light)">明细表（与时间线同一份数据）</summary>
+      <table class="table table-sm" style="margin-top:8px">
+        <thead><tr>
+          <th>发布日期</th><th>名字</th><th>由哪台发出</th><th>编号</th><th>素材文件</th>
+          <th>标题</th><th>正文</th><th>状态</th><th>分享链接</th><th>操作</th>
+        </tr></thead>
+        <tbody id="tb-release"></tbody>
+      </table>
+    </details>
+
+    <div class="help">
+      素材文件名规则 <code>名字_日期_编号</code>（<b>名字 = 抖音上的昵称</b>；<b>视频、图片都行</b>，扩展名各带各的；编号可省略，日期如 <code>20260912</code> 就是发布日期）；
+      标题 txt 每行 <code>标题 || 正文_名字_日期_编号</code>（<code>||</code> 后面是正文、可省略；编号可省，标题/正文里可以有下划线、可以有 <code>#话题</code>；<code>#</code> 开头的行<b>只要认得出名字/日期就当标题</b>，认不出才当注释忽略）。
+      <b>名字里不能有下划线、不能是纯数字</b>（那样切不出名字来），不满足会直接拒收并说明原因。<br>
+      上传后自动按 (名字, 日期, 编号) 配对：有编号按编号精确对，没编号按顺序配 ——
+      <b>没传标题的视频不会被推送</b>（先在计划页改标题或补传标题）。<br>
+      <b>平台只负责把视频推到手机</b>（推到 <code>/sdcard/DCIM/Camera/</code>、把文件时间改成"现在"好排在相册最前、触发相册刷新并<b>按路径</b>校验进了索引、
+      把标题写进手机剪贴板）；**抖音里怎么发由你在任务里自己写步骤** ——
+      步骤顺序是：<b>「推送发布视频」→ 你自己的发布步骤（打开抖音→点+→相册→选视频→下一步→粘贴标题→发布）→ 最后放一个「标记发布结果」</b>。<br>
+      计划页的「推送到手机」是同一件事的人工入口（推完你在手机上发，发完点「标记已发布」）。<br>
+      ⚠ 发布结果以<b>每行的状态</b>为准：<b>失败(可重试)</b>说明推送都没成功、可以再推；
+      <b>结果未知(需确认)</b>说明推送之后那一段出了岔子、<b>可能已经发出去了</b>，
+      要先到抖音里看一眼，再用「已发出 / 未发出」裁决（平台不会自动重发）。
+    </div>
+
+    <input type="file" id="rp-video-input" multiple accept="video/*,image/*" style="display:none" onchange="rpPickVideos(this)">
+    <input type="file" id="rp-title-input" accept=".txt" style="display:none" onchange="rpPickTitles(this)">
+  </div>
+</div>
+
 <!-- ========== Tab 2: 任务 ========== -->
 <div id="tab-tasks" class="tab-panel">
   <div class="page-title">任务</div>
@@ -1481,5 +1564,6 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 <script src="/static/admin/steplog.js"></script>
 <script src="/static/admin/recorder.js"></script>
 <script src="/static/admin/dedup.js"></script>
+<script src="/static/admin/release.js"></script>
 </body>
 </html>

web/__init__.py

@@ -6,7 +6,8 @@
   tasks       — 任务计划/分组/自定义动作/元素抓取/步骤测试
   admin       — 用户管理/日志
   tools       — adb 终端/剪贴板注入/应用版本
-  devices     — 设备池管理
+  devices     — 设备池管理 + 账号台账
+  video_plan  — 视频发布计划（上传/时间线/链接导出/单条发布）
   apks        — 应用管理
   tailscale   — Tailscale 管理
   system      — 系统数据备份导出/导入
@@ -24,6 +25,7 @@ def register_blueprints(app):
     from .admin_api import bp as admin_bp
     from .tools_api import bp as tools_bp
     from .devices_api import bp as devices_bp
+    from .video_plan_api import bp as video_plan_bp
     from .apks_api import bp as apks_bp
     from .tailscale_api import bp as tailscale_bp
     from . import agent_api as _agent_mod
@@ -33,6 +35,6 @@ def register_blueprints(app):
     from .device_agent_api import bp as devagent_bp
     from .notify_api import bp as notify_bp
     for bp in (auth_bp, monitor_bp, tasks_bp, admin_bp, tools_bp,
-               devices_bp, apks_bp, tailscale_bp, agent_bp, system_bp,
+               devices_bp, video_plan_bp, apks_bp, tailscale_bp, agent_bp, system_bp,
                devagent_bp, notify_bp):
         app.register_blueprint(bp)

web/device_agent_api.py

@@ -317,6 +317,9 @@ def api_agent_show_info():
                 "--es", "server", server]
         if ip:
             args += ["--es", "ip", ip]
+        # 账号台账块（`accounts_b64`）随账号管理一起下线了：身份页只显示
+        # 名称/地址/平台地址这些设备信息。老版本 Agent 收到"没有这个 extra"照常显示。
+        warn = ""
 
     # 先点亮屏幕、解除锁屏：设备息屏时 am start 会把大字页开在锁屏**后面**，
     # 人看到的还是一片黑（实测踩过）——这正是原来"定位"按钮里的"点亮屏幕"那一步
@@ -339,7 +342,10 @@ def api_agent_show_info():
                         "error": "这台设备没装设备 Agent（com.example.deviceagent）——"
                                  "可以从「应用管理 → 设备端应用商店」装，或用扫码配置"}), 400
     _log.info("设备端 Agent %s: %s", "关闭身份页" if close else "打开身份页", serial)
-    return jsonify({"ok": True, "msg": "已关闭" if close else "已让设备显示身份信息"})
+    resp = {"ok": True, "msg": "已关闭" if close else "已让设备显示身份信息"}
+    if not close and warn:
+        resp["warn"] = warn          # 前端用 toast 提示（同二维码接口的 warn 惯例）
+    return jsonify(resp)
 
 
 @bp.route("/api/agent-store/config", methods=["GET", "POST"])

web/devices_api.py

@@ -445,7 +445,6 @@ def api_devices_battery_scan():
     return jsonify({"ok": True, "msg": "采集已启动（约 1-3 秒）"})
 
 
-# ================== API：Tailscale 管理（仅管理员） ==================
 # 通过 Tailscale 官方 API v2 管理 tailnet 设备（列表/改名/授权/密钥不过期/删除/生成 auth key）。
 # 设备 IP 由 tailnet 自动分配，API 无法修改，列表只读展示。
 

web/video_plan_api.py

@@ -0,0 +1,554 @@
+"""视频发布计划 API（「发布计划」页）。
+
+数据在 `video_plan` 表、服务层 `core/video_plan.py`；任务侧怎么自动发布见
+`tasks/generic/task.py` 的 `_exec_publish_video`（本文件的「立即发布」调的是同一段逻辑）。
+
+红线（与 `core/video_plan.py` 顶部一致）：发布前必须原子占位；失败要分
+"推文件阶段（可重试）"与"抖音阶段（结果未知、绝不自动重试）"两类。
+"""
+import csv
+import io
+
+from flask import Blueprint, jsonify, request, send_file
+
+from core import video_plan as vp
+from core.logger import get_logger
+from web.auth import perm_required, PERM_DEVICES, PERM_TASKS
+
+_log = get_logger("web")
+bp = Blueprint("video_plan", __name__)
+
+
+@bp.route("/api/video_plan/upload_video", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_vp_upload_video():
+    """上传单个素材（**视频或图片**；前端**逐文件**发，才能给每个文件一条结果与进度）。
+
+    文件名规则 `名字_日期_编号`（编号可省略，名字 = 抖音昵称，不查台账）。
+    视频与图片同一套规则、同一条发布流程（图片走抖音「图文」）；扩展名一路带到手机上，
+    抖音按它判断这是视频还是图片。
+    """
+    f = request.files.get("file")
+    if not f or not f.filename:
+        return jsonify({"ok": False, "error": "没收到文件"}), 400
+    replace = str(request.form.get("replace") or "") in ("1", "true", "yes")
+    order = request.form.get("order")
+    result = vp.upload_video(f, order=order, replace=replace)
+    if not result.get("ok"):
+        return jsonify(result), 400
+    return jsonify(result)
+
+
+@bp.route("/api/video_plan/upload_titles", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_vp_upload_titles():
+    """上传标题：`{text, dry_run}`；也接受 multipart 的 txt 文件（字段名 file）。
+
+    每行 `标题 || 正文_名字_日期_编号`（`||` 后面是正文、可省略；编号可省略、标题里可以有下划线）；
+    `#` 开头的行**只有认不出名字/日期时才当注释**（`#话题` 开头的标题照收）。
+    """
+    if request.files.get("file"):
+        raw = request.files["file"].stream.read()
+        try:
+            text = raw.decode("utf-8")
+        except UnicodeDecodeError:
+            text = raw.decode("gbk", errors="replace")
+        dry = str(request.form.get("dry_run") or "") in ("1", "true", "yes")
+    else:
+        data = request.json or {}
+        text = data.get("text") or ""
+        dry = bool(data.get("dry_run"))
+    if not text.strip():
+        return jsonify({"ok": False, "error": "内容是空的"}), 400
+    result = vp.import_titles(text, dry_run=dry)
+    return jsonify(result)
+
+
+@bp.route("/api/video_plan/timeline")
+@perm_required(PERM_DEVICES)
+def api_vp_timeline():
+    """时间线：?range=today|week|all &from=&to=&status=&q=&limit="""
+    rng = (request.args.get("range") or "").strip()
+    today = vp._today()
+    date_from = (request.args.get("from") or "").strip()
+    date_to = (request.args.get("to") or "").strip()
+    if rng == "today" and not date_from:
+        date_from = date_to = today
+    elif rng == "week" and not date_from:
+        import time as _t
+        date_from = today
+        date_to = _t.strftime("%Y-%m-%d", _t.localtime(_t.time() + 7 * 86400))
+    data = vp.timeline(date_from, date_to,
+                       status=(request.args.get("status") or "").strip(),
+                       q=(request.args.get("q") or "").strip(),
+                       limit=int(request.args.get("limit") or 500))
+    return jsonify({"ok": True, **data})
+
+
+@bp.route("/api/video_plan/stats")
+@perm_required(PERM_DEVICES)
+def api_vp_stats():
+    """顶部统计（今天要发/已发/待标题/过期未发 + 素材占用与磁盘余量）。"""
+    return jsonify({"ok": True, "stats": vp.stats(), "disk": vp.disk_info(),
+                    "today": vp._today()})
+
+
+@bp.route("/api/video_plan/<pid>", methods=["GET", "PUT", "DELETE"])
+@perm_required(PERM_DEVICES)
+def api_vp_one(pid):
+    if request.method == "GET":
+        row = vp.get_plan(pid)
+        if not row:
+            return jsonify({"ok": False, "error": "计划不存在"}), 404
+        return jsonify({"ok": True, "plan": row})
+    if request.method == "DELETE":
+        if not vp.delete_plan(pid):
+            return jsonify({"ok": False, "error": "计划不存在"}), 404
+        return jsonify({"ok": True, "msg": "已删除（素材文件一并删除）"})
+    data = request.json or {}
+    if "title" in data or "body" in data or "nickname" in data:
+        row, err = vp.set_title(pid, data.get("title") or "", body=data.get("body"),
+                                nickname=data.get("nickname") if "nickname" in data else None)
+        if err:
+            bad = "太长" in err or "名字不对" in err
+            return jsonify({"ok": False, "error": err}), 400 if bad else 404
+        return jsonify({"ok": True, "msg": "标题/正文/名字已改", "plan": row})
+    return jsonify({"ok": False, "error": "没有要改的字段"}), 400
+
+
+@bp.route("/api/video_plan/<pid>/video")
+@perm_required(PERM_DEVICES)
+def api_vp_video(pid):
+    """预览平台上的素材（文件被清理后返回 410）。"""
+    import os
+    from flask import send_file as _send
+    row = vp.get_plan(pid)
+    if not row:
+        return jsonify({"ok": False, "error": "计划不存在"}), 404
+    path = vp._video_path(row.get("video_file"))
+    if not path or not os.path.exists(path):
+        return jsonify({"ok": False, "error": "素材文件已清理"}), 410
+    return _send(path, conditional=True)
+
+
+def _push_by_name(rows, serials=None):
+    """**按名字找设备**：把一批计划推到"现在登着这个名字的那台设备"上。
+
+    ① 计划按 `nickname` 分组；
+    ② **实时探测**在线设备当前登的号（`core.account_probe`，跳过正在跑任务的设备）；
+    ③ 名字 → 设备；找到就**每台设备一个线程、设备内串行**推（同一个手机同时推两个文件
+       会互相干扰：两条 adb push 抢带宽 + 两条 `content call scan_file` 抢相册索引）；
+    ④ 没有在线设备登着某个名字 → 进 `unmatched`，**如实报出来**（人要先去那台设备上切号）。
+
+    返回 `(matched, unmatched)`，推送本身在后台线程里跑（接口立刻返回）。
+    """
+    from core import account_probe, device_pool
+    from tasks.generic.publish_flow import push_one
+
+    by_name = {}
+    for row in rows:
+        by_name.setdefault(row.get("nickname") or "", []).append(row)
+
+    dev_names = {}
+    try:
+        for d in device_pool.list_devices():
+            dev_names[d.get("serial") or ""] = d.get("name") or ""
+    except Exception:
+        pass
+
+    probes = account_probe.probe_online(serials)
+    account_probe.cache_names(probes)      # 顺手存进 device 表（人工入口的设备建议用）
+    name2serial = {}
+    for serial, r in probes.items():
+        nm = (r or {}).get("name") or ""
+        if nm and nm not in name2serial:
+            name2serial[nm] = serial       # 同名多机：取第一台（下面的 dup 里说明）
+
+    by_serial, matched, unmatched = {}, [], []
+    for name, plans in by_name.items():
+        serial = name2serial.get(name)
+        if not serial:
+            who = "、".join(f"{s}({(v or {}).get('name')})"
+                            for s, v in sorted(probes.items()) if (v or {}).get("name")) \
+                or "没有在线设备"
+            unmatched.append({"name": name, "count": len(plans),
+                              "reason": f"没有在线设备登着『{name}』——先到设备上切到它"
+                                        f"（当前探测到：{who}）"})
+            continue
+        by_serial.setdefault(serial, []).extend(plans)
+        matched.append({"name": name, "count": len(plans), "serial": serial,
+                        "device_name": dev_names.get(serial, "")})
+
+    def _push_device(serial, plans, dname):
+        for row in plans:
+            try:
+                push_one(serial, row, {"device_name": dname})
+            except Exception as e:
+                _log.warning(f"按名字推送 {row.get('id')} 异常: {e}")
+
+    if rows:
+        import threading
+        for serial, plans in by_serial.items():
+            threading.Thread(target=_push_device,
+                             args=(serial, plans, dev_names.get(serial, "")),
+                             daemon=True).start()
+    return matched, unmatched
+
+
+@bp.route("/api/video_plan/<pid>/push", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_vp_push(pid):
+    """把这一条的素材**推到手机**（只推送，不在手机上发布）。
+
+    计划不绑设备了，所以这里**按名字找设备**：实时探测哪台在线设备现在登着这条计划的
+    名字，推给它；没有设备登着 → 400 说清"先去切号"。
+    """
+    row = vp.get_plan(pid)
+    if not row:
+        return jsonify({"ok": False, "error": "计划不存在"}), 404
+    if row["status"] in (vp.ST_PUSHING, vp.ST_PUBLISHING):
+        return jsonify({"ok": False, "error": "这条已经推到手机上了，别重复推"}), 409
+    if row["status"] == vp.ST_UNKNOWN:
+        return jsonify({"ok": False,
+                        "error": "这条上次结果未知（可能已经发出去了）—— 先去抖音确认，"
+                                 "再用「已发出 / 未发出」裁决"}), 409
+    matched, unmatched = _push_by_name([row])
+    if unmatched:
+        return jsonify({"ok": False, "error": unmatched[0]["reason"]}), 400
+    m = matched[0]
+    _log.info(f"推送素材到手机 video_plan {pid}（{row.get('nickname')} "
+              f"{row['release_date']}）→ {m['device_name'] or m['serial']}")
+    return jsonify({"ok": True, "device_name": m["device_name"],
+                    "msg": f"已开始推送到『{m['device_name'] or m['serial']}』"
+                           f"（推完状态变「已推送到手机」，之后你在手机上发；"
+                           f"发完点「标记已发布」）"})
+
+
+def _push_plans_by_account():
+    """`push_by_account` / `push_all` 两个路由的公共实现（避免"调用另一个视图"）。"""
+    data = request.json or {}
+    date = (data.get("date") or "").strip() or vp._today()
+    rows = vp.pushable_plans(date, retry_failed=bool(data.get("retry_failed", True)))
+    if not rows:
+        return jsonify({"ok": True, "count": 0, "devices": 0, "matched": [],
+                        "unmatched": [],
+                        "msg": f"{date} 没有待推送的计划（有标题的才推）"})
+    matched, unmatched = _push_by_name(rows, data.get("serials") or None)
+    if not matched:
+        return jsonify({"ok": False, "count": 0, "devices": 0, "matched": [],
+                        "unmatched": unmatched,
+                        "error": "没有在线设备登着这些号：" +
+                                 "、".join(f"{u['name']}({u['count']}条)" for u in unmatched) +
+                                 " —— 先到设备上切号，或到「工具 → 设备池」确认设备在线"}), 400
+    _log.info(f"一键推送（按名字）{date}：{len(rows)} 条 → {len(matched)} 个名字"
+              f"（没设备登着的 {len(unmatched)} 个名字已跳过）")
+    return jsonify({"ok": True, "count": sum(m["count"] for m in matched),
+                    "devices": len({m["serial"] for m in matched}),
+                    "matched": matched, "unmatched": unmatched,
+                    "msg": f"已开始推送 {sum(m['count'] for m in matched)} 条"
+                           f"（{len(matched)} 个号）"
+                           + (f"；{len(unmatched)} 个名字没有在线设备登着，见明细"
+                              if unmatched else "")})
+
+
+@bp.route("/api/video_plan/push_by_account", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_vp_push_by_account():
+    """**按名字找设备**的批量推送（「一键推送」）：某天所有待推的计划，谁登着谁推。
+
+    立刻返回受理条数（推送在后台跑）——进度与结果看时间线的状态徽章 /
+    「已推送·相册可见」标记。**没设备登着的名字**在 `unmatched` 里逐条说明。
+    """
+    return _push_plans_by_account()
+
+
+@bp.route("/api/video_plan/push_all", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_vp_push_all():
+    """老入口（前端旧版本还可能在调）：语义与 `push_by_account` 一致 —— 都按名字找设备。"""
+    return _push_plans_by_account()
+
+
+@bp.route("/api/video_plan/<pid>/mark", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_vp_mark(pid):
+    """人工标记结果：`{status: done|failed|unknown, why}`（推送到手机之后用）。"""
+    data = request.json or {}
+    st = (data.get("status") or "").strip()
+    if st not in (vp.ST_DONE, vp.ST_FAILED, vp.ST_UNKNOWN):
+        return jsonify({"ok": False, "error": "status 只能是 done / failed / unknown"}), 400
+    why = (data.get("why") or "").strip()
+    row, err = vp.set_status(pid, st, note=why)
+    if err:
+        return jsonify({"ok": False, "error": err}), 400
+    _log.info(f"人工标记 video_plan {pid} → {st}")
+    return jsonify({"ok": True, "msg": "已标记", "plan": row})
+
+
+@bp.route("/api/video_plan/<pid>/<action>", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_vp_action(pid, action):
+    """单条操作：skip 跳过 / retry 重试（failed→ready）/ resolve 裁决 unknown。"""
+    data = request.json or {}
+    if action == "skip":
+        row, err = vp.set_status(pid, vp.ST_SKIPPED, note=data.get("reason") or "")
+        msg = "已跳过"
+    elif action == "retry":
+        row, err = vp.set_status(pid, vp.ST_READY, note="人工重试")
+        msg = "已放回待发布（尝试次数已清零）"
+    elif action == "resolve":
+        row, err = vp.resolve_unknown(pid, bool(data.get("published")),
+                                      note=data.get("note") or "")
+        msg = "已记为「已发出」" if data.get("published") else "已记为「未发出」（可重试）"
+    else:
+        return jsonify({"ok": False, "error": f"未知操作 {action}"}), 400
+    if err:
+        return jsonify({"ok": False, "error": err}), 400
+    return jsonify({"ok": True, "msg": msg, "plan": row})
+
+
+def _norm_target(target):
+    """规范化任务目标。**分组键必须是 `group_name`** —— `TaskJob.resolve_serials()`
+    只认这个键，写成 `group` 会静默解析出 0 台设备（任务"跑完了"但谁也没跑）。"""
+    t = dict(target or {})
+    mode = (t.get("mode") or "all").strip()
+    out = {"mode": mode}
+    if mode == "group":
+        out["group_name"] = (t.get("group_name") or t.get("group") or "").strip()
+    elif mode == "serial":
+        out["serial"] = (t.get("serial") or "").strip()
+    return out
+
+
+def _target_error(target):
+    if target["mode"] not in ("all", "group", "serial"):
+        return "目标只能是 全部/分组/单设备"
+    if target["mode"] == "group" and not target.get("group_name"):
+        return "选了「设备分组」但没指定分组名"
+    if target["mode"] == "serial" and not target.get("serial"):
+        return "选了「单台设备」但没指定设备"
+    return ""
+
+
+def _parse_hhmm(text):
+    try:
+        h, m = [int(x) for x in str(text).split(":")]
+        assert 0 <= h < 24 and 0 <= m < 60
+        return h, m, ""
+    except Exception:
+        return 0, 0, "时间格式应为 HH:MM"
+
+
+def _count_steps(steps):
+    """步骤总数（**含嵌套**：条件判断的 then/else、循环块里的）—— 界面上给人看的数字，
+    只数顶层会让人以为任务很短（骨架顶层 4 步、实际 14 步）。"""
+    n = 0
+    for s in steps or []:
+        if not isinstance(s, dict):
+            continue
+        n += 1
+        p = s.get("params") or {}
+        for k in ("then", "else", "children"):
+            n += _count_steps(p.get(k) or [])
+    return n
+
+
+def _job_brief(j, mgr):
+    """任务摘要（列表用）+ 步骤（就地编辑用）。"""
+    steps = (j.params or {}).get("steps") or []
+    try:
+        nxt = mgr.next_run_of(j)
+        nxt = nxt.strftime("%Y-%m-%d %H:%M") if nxt else ""
+    except Exception:
+        nxt = ""
+    sch = j.schedule or {}
+    return {"id": j.id, "name": j.name, "enabled": bool(j.enabled),
+            "mode": sch.get("mode", "once"), "cron": sch.get("cron", ""),
+            "next_run": nxt, "target": j.target, "steps": steps,
+            "step_count": _count_steps(steps),
+            "retry": j.retry or {},
+            "schedule": sch}
+
+
+@bp.route("/api/video_plan/tasks")
+@perm_required(PERM_DEVICES)
+def api_vp_tasks():
+    """**可编辑的任务列表** —— 「发布计划」页顶部那一块。
+
+    返回**全部通用步骤任务**，每条带 `is_release`（含「推送/标记发布结果」= 发布任务）：
+    - 只列发布任务的话，手写的抖音发布流程（自己点相册/输入框/发布，没有平台的
+      `push_release` 步骤）就会**一条都不显示** —— 人会以为"这页没有能改的地方"
+    - 界面上按 `is_release` 分成两组：上面「发布任务」，下面「其它任务」也能就地改步骤
+
+    带上完整 `steps`：这一页要**就地编辑**这些步骤（抓选择器），不用再跳「任务」页。
+    """
+    from web import context
+    release, other = [], []
+    try:
+        jobs = list((context.mgr.jobs or {}).values())
+    except Exception:
+        jobs = []
+    for j in jobs:
+        # 只有通用步骤任务有步骤可编（其它任务类型的 params 是另一套）
+        if getattr(j, "task_type", "generic_steps") != "generic_steps":
+            continue
+        b = _job_brief(j, context.mgr)
+        b["is_release"] = vp.is_release_task((j.params or {}).get("steps") or [])
+        b["has_push"] = vp.has_push_step((j.params or {}).get("steps") or [])
+        (release if b["is_release"] else other).append(b)
+    release.sort(key=lambda x: x["name"])
+    other.sort(key=lambda x: x["name"])
+    return jsonify({"ok": True, "tasks": release + other,
+                    "release_count": len(release), "other_count": len(other)})
+
+
+@bp.route("/api/video_plan/tasks", methods=["POST"])
+@perm_required(PERM_TASKS)
+def api_vp_task_create():
+    """一键新建「标准发布任务」：账号校验 → 推送 → 抖音点击（占位待你抓）→ 填标题 → 标记。
+
+    请求：{"name": "发布视频", "target": {"mode":"all"|"group"|"serial", …},
+           "time": "10:00", "enabled": true}
+    **走 TaskManager 建**（内存 + 库一起更新）—— 直接写库的话调度器不认。
+    """
+    from web import context
+    data = request.json or {}
+    name = (data.get("name") or "发布视频").strip()[:120]
+    target = _norm_target(data.get("target"))
+    err = _target_error(target)
+    if err:
+        return jsonify({"ok": False, "error": err}), 400
+    h, m, err = _parse_hhmm((data.get("time") or "10:00").strip())
+    if err:
+        return jsonify({"ok": False, "error": err}), 400
+    schedule = {"mode": "cron", "cron": f"{m} {h} * * *", "stop_cron": "",
+                "window": {"start": "", "end": ""}}
+    params = {"steps": vp.build_release_steps(),
+              "dedup_reset": "day", "dedup_hours": 6,
+              "preempt": False, "skip_offline": True, "max_duration": 0}
+    try:
+        job = context.mgr.add_job(name=name, task_type="generic_steps", target=target,
+                                  params=params, schedule=schedule,
+                                  retry={"max_attempts": 1, "delay": 60},
+                                  enabled=bool(data.get("enabled", True)))
+    except Exception as e:
+        _log.warning(f"新建发布任务失败: {e}")
+        return jsonify({"ok": False, "error": f"创建失败: {str(e)[:120]}"}), 500
+    _log.info(f"新建发布任务 {job.name}({job.id})，每天 "
+              f"{h:02d}:{m:02d}，目标 {target}")
+    return jsonify({"ok": True, "msg": f"已创建「{name}」（每天 {h:02d}:{m:02d} 跑）——"
+                                       f"就在下面这一块把抖音那几步的选择器抓一下就能用了",
+                    "job_id": job.id, "task": _job_brief(job, context.mgr)})
+
+
+@bp.route("/api/video_plan/tasks/<job_id>/adopt", methods=["POST"])
+@perm_required(PERM_TASKS)
+def api_vp_task_adopt(job_id):
+    """给**已有任务**插上平台那两步（`push_release` 放最前、`mark_release` 放最后）。
+
+    手写的抖音发布流程常缺这两步：不插的话计划页的视频永远不会被推到手机、
+    发布结果也不会回写状态。**中间你自己的步骤一步不动**（位置理由见
+    `core.video_plan.insert_release_steps`）。
+    """
+    from web import context
+    job = (context.mgr.jobs or {}).get(job_id)
+    if not job:
+        return jsonify({"ok": False, "error": "任务不存在"}), 404
+    if getattr(job, "task_type", "generic_steps") != "generic_steps":
+        return jsonify({"ok": False, "error": "只有「通用步骤」任务能插平台发布步骤"}), 400
+    steps = (job.params or {}).get("steps") or []
+    if not steps:
+        return jsonify({"ok": False, "error": "这个任务没有步骤，先去「任务」页把抖音流程画好"}), 400
+    if vp.has_push_step(steps) and vp.has_mark_step(steps):
+        return jsonify({"ok": False, "error": "这个任务已经有平台发布步骤了"}), 409
+    params = dict(job.params or {})
+    params["steps"] = vp.insert_release_steps(steps)
+    try:
+        context.mgr.update_job(job_id, params=params)
+    except Exception as e:
+        _log.warning(f"给任务 {job_id} 插平台发布步骤失败: {e}")
+        return jsonify({"ok": False, "error": f"保存失败: {str(e)[:120]}"}), 500
+    _log.info(f"给任务 {job.name}({job_id}) 插上平台发布步骤")
+    return jsonify({"ok": True, "msg": "已插入「推送发布视频」（最前）与「标记发布结果」（最后）——"
+                                       "你原来的步骤没动；到「发布计划」里核对一下顺序",
+                    "task": _job_brief(job, context.mgr)})
+
+
+@bp.route("/api/video_plan/tasks/<job_id>", methods=["GET", "PUT"])
+@perm_required(PERM_TASKS)
+def api_vp_task_one(job_id):
+    """就地编辑发布任务（「发布计划」页里，不用跳「任务」页）。
+
+    只放开这一页用得上的字段：`name` / `time`(HH:MM) / `target` / `steps` / `enabled`。
+    **没传的字段原样保留**（深合并：`params` 里还有去重有效期、抢占等通用参数，
+    整块覆盖会把它们抹掉）。底层仍是 `context.mgr.update_job()` —— 内存 + 库一起改，
+    否则调度器不认（直接写库的坑见 `core/task_manager` 的 `_save_jobs`）。
+    """
+    from web import context
+    job = (context.mgr.jobs or {}).get(job_id)
+    if not job:
+        return jsonify({"ok": False, "error": "任务不存在"}), 404
+    if request.method == "GET":
+        return jsonify({"ok": True, "task": _job_brief(job, context.mgr)})
+    data = request.json or {}
+    fields = {}
+    if "name" in data:
+        nm = (data.get("name") or "").strip()[:120]
+        if not nm:
+            return jsonify({"ok": False, "error": "任务名不能为空"}), 400
+        fields["name"] = nm
+    if "target" in data:
+        target = _norm_target(data.get("target"))
+        err = _target_error(target)
+        if err:
+            return jsonify({"ok": False, "error": err}), 400
+        fields["target"] = target
+    if "enabled" in data:
+        fields["enabled"] = bool(data.get("enabled"))
+    if "time" in data:
+        h, m, err = _parse_hhmm((data.get("time") or "").strip())
+        if err:
+            return jsonify({"ok": False, "error": err}), 400
+        sch = dict(job.schedule or {})
+        sch["mode"] = "cron"
+        sch["cron"] = f"{m} {h} * * *"
+        sch.setdefault("stop_cron", "")
+        sch.setdefault("window", {"start": "", "end": ""})
+        fields["schedule"] = sch
+    if "steps" in data:
+        steps = data.get("steps")
+        if not isinstance(steps, list):
+            return jsonify({"ok": False, "error": "steps 必须是数组"}), 400
+        params = dict(job.params or {})
+        params["steps"] = steps
+        fields["params"] = params
+    if not fields:
+        return jsonify({"ok": False, "error": "没有要改的字段"}), 400
+    try:
+        context.mgr.update_job(job_id, **fields)
+    except Exception as e:
+        _log.warning(f"改发布任务 {job_id} 失败: {e}")
+        return jsonify({"ok": False, "error": f"保存失败: {str(e)[:120]}"}), 500
+    _log.info(f"改发布任务 {job.name}({job_id})：{'/'.join(fields)}")
+    return jsonify({"ok": True, "msg": "已保存", "task": _job_brief(job, context.mgr)})
+
+
+@bp.route("/api/video_plan/links")
+@perm_required(PERM_DEVICES)
+def api_vp_links():
+    """已发布作品的分享链接（界面展示 / `format=csv` 导出，给后续铺评论用）。"""
+    rows = vp.links(date_from=(request.args.get("from") or "").strip(),
+                    date_to=(request.args.get("to") or "").strip(),
+                    name=(request.args.get("name") or "").strip())
+    if (request.args.get("format") or "") == "csv":
+        buf = io.StringIO()
+        w = csv.writer(buf)
+        # 按**名字**导出（手机号/抖音号随台账停用一起下线；由谁发的看 posted_device_name）
+        w.writerow(["发布日期", "名字", "编号", "标题", "正文", "分享链接", "发布时间"])
+        for r in rows:
+            w.writerow([r["release_date"], r["nickname"], r["seq"], r["title"],
+                        r.get("body", ""), r["share_url"], r["published_at"]])
+        data = ("" + buf.getvalue()).encode("utf-8")   # BOM：Excel 打开中文不乱码
+        return send_file(io.BytesIO(data), mimetype="text/csv", as_attachment=True,
+                         download_name=f"video_links_{vp._today()}.csv")
+    return jsonify({"ok": True, "links": rows, "count": len(rows)})

web_server.py

@@ -35,6 +35,7 @@ app.config["SECRET_KEY"] = _web_secret
 app.config["TEMPLATES_AUTO_RELOAD"] = True
 # 数据库目标与连接参数统一由 core/db_config 装配（.env 的 DEPLOY_ENV / DB_* 决定）。
 # 这里就把配置校验做完：连不上、环境与库名不匹配 → 直接拒绝启动，不要带着错配置跑起来。
+from config import MAX_CONTENT_LENGTH as _MAX_UPLOAD
 from core import db_config
 try:
     _DB_URI = db_config.build_db_uri()
@@ -45,11 +46,26 @@ except db_config.DBConfigError as _e:
 app.config["SQLALCHEMY_DATABASE_URI"] = _DB_URI
 app.config["SQLALCHEMY_ENGINE_OPTIONS"] = db_config.engine_options(_DB_URI)
 app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+# 单次请求体上限（视频发布计划要传几百 MB 的视频素材）。
+# 默认 2GiB：**必须大于现有 APK 上传的最大包（实测 336MB）**，否则会把「应用管理」的
+# APK 上传一起卡死。原来是没设的（Werkzeug 默认无上限）—— 现在有了上限，
+# 超限必须回 **JSON**（见下面 413 处理器），否则前端 JSON.parse 会炸成
+# "解析响应失败"，用户看不出是文件太大。
+app.config["MAX_CONTENT_LENGTH"] = _MAX_UPLOAD
 
 login_manager = LoginManager(app)
 login_manager.login_view = "auth.login"  # 蓝图化后路由前缀 auth
 
 
+@app.errorhandler(413)
+def _payload_too_large(e):
+    """上传超限要说人话（默认返回 HTML，前端 JSON.parse 会炸成"解析响应失败"）。"""
+    from flask import jsonify as _jsonify
+    mb = _MAX_UPLOAD // (1024 * 1024)
+    return _jsonify({"ok": False,
+                     "error": f"文件太大：单次上传上限 {mb} MB（可在 .env 里调 MAX_UPLOAD_MB）"}), 413
+
+
 def _consume_pending_restore():
     """消费「待生效的备份恢复」（若存在 data/restore_pending/users.db）。
 
@@ -104,6 +120,9 @@ device_battery.init_app(app)
 # 去重账本（跨设备幂等）：绑 app 供任务线程/Web/清理任务自推 context
 from core import dedup
 dedup.init_app(app)
+# 视频发布计划：绑 app 供任务线程（发布步骤）/ Web / 清理 job 自推 context
+from core import video_plan
+video_plan.init_app(app)
 mgr = TaskManager(app=app)
 # 设备换地址（认领/迁址）后同步分组与任务的引用：它们的"内存副本"在 TaskManager 里
 # （调度用内存对象），device_pool 只改库不改内存不生效，所以在此注册回调打通
@@ -151,6 +170,35 @@ def _purge_done_mark():
         _log.warning(f"去重记录清理失败（不影响主服务）: {e}")
 
 
+def _purge_video_plan():
+    """发布计划：僵尸占位回收 + 过期行清理（每日 04:41）。
+
+    僵尸回收是**必须有的一步**：占位（pushing/publishing）后崩溃的话，没有它
+    这条计划永远停在"发布中"，再也不会被取到 —— 表现成"这个号就是不发"。
+    """
+    try:
+        from core.video_plan import reclaim_zombies, purge_plan
+        with app.app_context():
+            reclaim_zombies()
+            purge_plan()
+    except Exception as e:
+        _log.warning(f"发布计划清理失败（不影响主服务）: {e}")
+
+
+def _purge_video_files():
+    """发布计划：平台素材文件清理（每日 04:47）。
+
+    **只删"已发布 + 已抓到分享链接 + 超过保留期"的**：没抓到链接的一律留着
+    （链接与素材至少留一个），未发布/失败/未知的更不删。
+    """
+    try:
+        from core.video_plan import purge_files
+        with app.app_context():
+            purge_files()
+    except Exception as e:
+        _log.warning(f"发布素材清理失败（不影响主服务）: {e}")
+
+
 # 经验库每日 AI 巡检（凌晨 03:47）：评审标记疑似问题经验，删除只走人工确认。
 # 巡检线程在 run_experience_audit 内自建 app context，不依赖这里。
 try:
@@ -164,6 +212,10 @@ try:
     _audit_sched.add_job(_purge_step_log, CronTrigger(hour=4, minute=13))
     # 去重记录清理：只清 day/hours 桶（all 永不清理，清了等于"只做一次"失效）
     _audit_sched.add_job(_purge_done_mark, CronTrigger(hour=4, minute=23))
+    # 发布计划：僵尸占位回收 + 过期行清理（04:41）、孤儿素材清理（04:47）。
+    # 时间刻意与 04:13/04:23 错开 15 分钟以上：都是删数据的大操作，别挤同一分钟。
+    _audit_sched.add_job(_purge_video_plan, CronTrigger(hour=4, minute=41))
+    _audit_sched.add_job(_purge_video_files, CronTrigger(hour=4, minute=47))
     _audit_sched.start()
     _log.info("经验库每日巡检已注册（03:47 Asia/Shanghai）")
 except Exception as e: