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

@@ -116,6 +116,26 @@ TAILSCALE_API_KEY=请填写Tailscale_API_key
 # ⚠ 必须大于「应用管理」里最大的 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）

README.md

@@ -53,8 +53,7 @@
 | **动作配置 / 录制** | 「任务 → 动作配置」：① 配**步骤默认值**（新建步骤预填：滑动时长/幅度/抖动/拟人、点击超时、等待区间…）② **录制动作**——在设备画面上点/划/按键，自动翻译成步骤（点元素记选择器、划一下记方向/幅度/时长），可存成可复用动作，也可只取一个手势回填滑动步骤 |
 | **公共巡检** | 任务级的守护条件（**独立于步骤画布**）：每 N 秒检查屏幕亮/熄、元素在不在、前台是不是某 App，命中就点亮/息屏/停本设备/推通知——通知标题正文自己写（见 [TASK_DEV.md](doc/TASK_DEV.md) §4.5） |
 | **去重账本** | 解决"**同一个号被做两次、有的号还没做**"：任务里用「条件判断→去重」+「记为已做」，把"这个身份做过了"记进一张**所有设备共享**的账本——多台手机、反复重跑都不会重复做同一个号。「任务 → 去重记录」页能看"谁做过了、还差谁"，也能删记录让它重跑（见 [TASK_DEV.md](doc/TASK_DEV.md) §4.6） |
-| **账号台账** | 「账号」页维护"**哪台设备上登着哪些号**"（设备号/手机号/账号名/抖音号/注册时间/卡在机内/可发视频/简介/备注）：支持**从 Excel 粘贴批量导入**（表头识别、逐行结果、先预览后写入）。三个用处：① 任务的「条件判断」**直接从这里取号**，不用把几十个号手写进比对值；② 手机端 Agent 的**身份大字页**显示本机账号；③ 设备池里一眼看到每台登记了几个号（见 [DATA_MODEL.md](doc/DATA_MODEL.md) §2.10、[TASK_DEV.md](doc/TASK_DEV.md) §4.2） |
-| **视频发布计划** | 「账号 → 发布计划」页：批量上传视频（文件名 `手机号_日期_编号`）与标题 txt → 自动按 (手机号,日期,编号) 配对到台账账号 → **按日期的时间线**看每天谁要发、发到哪一步。**平台只负责把素材推到手机**（推到 `/sdcard/DCIM/rp/`、触发相册刷新、把标题写进剪贴板），**抖音里怎么发由你自己在任务里写步骤**（步骤顺序：`推送发布视频` → 你的发布步骤 → `标记发布结果`；「发布计划」页顶部有**「发布任务」**块可一键建好骨架 + 看下次运行/启停，`输入文字` 那一步可以选**取值来源＝计划标题**自动填文案并回读校验）；发完可抓作品的**分享链接**存下来（平台不长期囤视频，链接才是长期资产，也方便后续铺评论：可一键复制、按日期/账号导出 CSV）。状态区分"**可重试**"（推送阶段失败，还没到抖音）与"**结果未知、需人工确认**"（推送之后出的岔子，绝不自动重发）（见 [DATA_MODEL.md](doc/DATA_MODEL.md) §2.11、[TASK_DEV.md](doc/TASK_DEV.md) §4.7） |
+| **视频发布计划** | 「发布计划」页：批量上传**视频/图片**（文件名 `名字_日期_编号`，**名字 = 抖音昵称**；视频和图片同一套规则）与标题 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 上传/解析/批量安装；设备已装应用与版本查询；剪贴板注入 |
@@ -135,14 +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 只读）+ 低电量告警
-│   ├── ledger.py              #   账号台账（CRUD / 表格粘贴解析 / 给任务取号 / 设备端账号块）
 │   ├── video_plan.py          #   视频发布计划（文件名解析配对 / 时间线 / 幂等占位 / 素材清理）
+│   ├── account_probe.py       #   实时探测设备当前登录的抖音号（按名字找设备用）
 │   ├── u2_helper.py           #   uiautomator2 通用辅助（等首页/安全点击等）
 │   ├── uiauto_helper.py       #   uiautodev 客户端（元素树 + XPath 建议）
 │   ├── ocr.py                 #   屏幕 OCR（RapidOCR，条件判断用）

config.py

@@ -91,6 +91,20 @@ APK_DIR = os.path.join(DATA_DIR, "apks")
 # 自动化测试必须把素材目录指到临时位置，否则测试上传的视频会落进用户真实数据目录。
 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

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/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/ledger.py

@@ -1,551 +0,0 @@
-"""账号台账：一台设备上登录着哪些账号。
-
-**它解决什么**（用户场景）：一台手机登好几个抖音号、十几台手机四五十个号，
-账号信息散在一张电子表格里 —— 换 IP、加号、想查"这台登的是哪几个号"都得翻表。
-台账落进平台后有三个月牙：
-
-  1. web「账号」页 —— 列表 / 增删改 / **从表格粘贴导入**（`web/devices_api.py` 的 `/api/ledger*`）
-  2. 任务的「条件判断」取号 —— `if_el` 的 `cmp_source=device|all|group`
-     （比对运算符用「包含」时，纯号 `35377983067` 能匹配元素原文 `抖音号：35377983067`）
-  3. 手机端 Agent 的「身份大字页」 —— 平台推 `accounts_b64`（`doc/DEVICE_AGENT.md` §5.2）
-
-⚠ **台账里的抖音号是纯号，绝不能拿去当去重身份**：
-`done_mark.identity` 存的是**元素原文**、逐字算 key，格式不一致（`35377983067`
-vs `抖音号：35377983067`）会让去重**静默失效**。取号只用于条件判断的比对值。
-
-DB 访问自建 app context（照 `core/dedup.py`），调用方（任务线程 / Web 线程）不用关心。
-"""
-import re
-import time
-import uuid
-
-from core.logger import get_logger
-from core.models import db, Device, DeviceAccount, DeviceGroup
-
-_log = get_logger("core.ledger")
-
-# 可编辑字段（接口 / 导入 / 前端共用一份清单，避免某处漏字段）
-FIELDS = ("device_name", "phone", "nickname", "douyin_id", "registered_at",
-          "sim_in_device", "can_post_video", "bio", "note")
-# 这两列是布尔（"空=否"）
-BOOL_FIELDS = ("sim_in_device", "can_post_video")
-
-# 粘贴导入：表头列名 → 字段（允许乱序/缺列/多列；认不出的列忽略）
-HEADER_ALIASES = {
-    "device_name": ("设备号", "设备", "设备名", "机器", "机型"),
-    "phone": ("手机号", "手机", "号码", "手机号码"),
-    "nickname": ("账号名称", "账号名", "昵称", "账号", "名称"),
-    "douyin_id": ("抖音号", "抖音", "抖音id", "douyin"),
-    "registered_at": ("注册时间", "注册日期", "注册"),
-    "sim_in_device": ("卡在机内", "卡在机", "卡在", "机内"),
-    "can_post_video": ("可发视频", "可发", "发视频"),
-    "bio": ("简介", "签名", "个人简介"),
-    "note": ("备注", "说明"),
-}
-# 没有表头时按这个顺序解析（= 用户表格的列顺序，界面上要写明）
-DEFAULT_ORDER = FIELDS
-
-_TRUE_WORDS = ("是", "有", "对", "在", "✔", "√", "✓", "1", "true", "y", "yes", "t")
-_FALSE_WORDS = ("否", "无", "没有", "不在", "不", "0", "false", "n", "no", "f", "")
-# 抖音号形态：纯数字。不拦（少数号可能带字母），只在导入结果里留痕 ——
-# 候选值一旦是错的，任务会"正常跑完但永远不命中"，最难查
-_DOUYIN_RE = re.compile(r"^\d{6,20}$")
-
-_app = None
-
-
-def init_app(app):
-    """web_server 启动时调用：绑 app（后台线程/任务线程访问 db 要自推 context）。"""
-    global _app
-    _app = app
-
-
-def _ctx():
-    if _app is None:
-        raise RuntimeError("ledger 未关联 Flask app（web_server 启动时调用 init_app）")
-    return _app.app_context()
-
-
-def _now():
-    return time.strftime("%Y-%m-%d %H:%M:%S")
-
-
-def _norm_bool(v):
-    """是/否 → (True/False, 是否认得)。认不出的按"否"处理，但**留痕**。"""
-    if isinstance(v, bool):
-        return v, True
-    s = str(v or "").strip().lower()
-    if s in _TRUE_WORDS:
-        return True, True
-    if s in _FALSE_WORDS:
-        return False, True
-    return False, False
-
-
-def _clean(fields):
-    """把接口来的字段清洗成可落库的值。只处理传进来的键。返回 (values, error)。"""
-    out = {}
-    for k in FIELDS:
-        if k not in (fields or {}):
-            continue
-        v = fields.get(k)
-        out[k] = _norm_bool(v)[0] if k in BOOL_FIELDS else str(v or "").strip()
-    if "device_name" in out and not out["device_name"]:
-        return {}, "设备号不能为空"
-    if "douyin_id" in out and not out["douyin_id"]:
-        return {}, "抖音号不能为空"
-    return out, ""
-
-
-# ================== 查 ==================
-def get_by_id(acc_id):
-    """取一条（dict）或 None。
-
-    **跨边界一律返回 dict**：commit 之后 ORM 行的属性会过期，出了 app context
-    再读属性会抛 DetachedInstanceError（接口层 `row.to_dict()` 必炸）。
-    """
-    with _ctx():
-        row = DeviceAccount.query.get(acc_id)
-        return row.to_dict() if row else None
-
-
-def find_by_douyin(douyin_id, exclude_id=""):
-    """按抖音号找已存在的那条（唯一性判据；空号不参与）。返回 (id, 设备号) 或 None。
-
-    只返回两个纯值，同样是为了不让 ORM 行溜出 context。
-    """
-    d = str(douyin_id or "").strip()
-    if not d:
-        return None
-    with _ctx():
-        q = DeviceAccount.query.filter(DeviceAccount.douyin_id == d)
-        if exclude_id:
-            q = q.filter(DeviceAccount.id != exclude_id)
-        row = q.first()
-        return (row.id, row.device_name or "") if row else None
-
-
-def list_accounts(device_name="", q="", limit=500):
-    """列表 + 统计（「账号」页用）。返回 (rows, stats)。"""
-    with _ctx():
-        query = DeviceAccount.query
-        if device_name:
-            query = query.filter(DeviceAccount.device_name == device_name)
-        if q:
-            like = f"%{q.strip()}%"
-            query = query.filter(db.or_(DeviceAccount.douyin_id.like(like),
-                                        DeviceAccount.phone.like(like),
-                                        DeviceAccount.nickname.like(like)))
-        rows = (query.order_by(DeviceAccount.device_name, DeviceAccount.id)
-                .limit(max(1, min(int(limit or 500), 2000))).all())
-        all_rows = DeviceAccount.query.all()
-        stats = {
-            "total": len(all_rows),
-            "devices": len({r.device_name for r in all_rows if r.device_name}),
-            "can_post_video": len([r for r in all_rows if r.can_post_video]),
-            "shown": len(rows),
-        }
-        return [r.to_dict() for r in rows], stats
-
-
-def device_names():
-    """台账里出现过的设备号（筛选下拉用）。"""
-    try:
-        with _ctx():
-            return sorted({r.device_name for r in DeviceAccount.query.all() if r.device_name})
-    except Exception:
-        return []
-
-
-def for_device(serial="", device_name=""):
-    """这台设备的账号。serial 优先，再按设备名（换 IP / 改名都找得到）。
-
-    `serial` 是**录入时的快照**：设备换 IP 后台账里那条还是旧地址，
-    所以两边都查一遍并按抖音号去重。
-    """
-    with _ctx():
-        rows, seen = [], set()
-        if serial:
-            for r in DeviceAccount.query.filter(DeviceAccount.serial == serial).all():
-                rows.append(r)
-                seen.add(r.douyin_id)
-        name = device_name
-        if not name and serial:
-            dev = Device.query.get(serial)
-            name = (dev.name if dev else "") or ""
-        if name:
-            for r in DeviceAccount.query.filter(DeviceAccount.device_name == name).all():
-                if r.douyin_id not in seen:
-                    rows.append(r)
-                    seen.add(r.douyin_id)
-        return [r.to_dict() for r in rows]
-
-
-def resolve_device(serial="", device_name=""):
-    """serial/设备名 → (设备号, 账号行, 说明)。
-
-    "本机是哪台设备"这条链只在这一个地方定义，任务侧和设备端都走它 ——
-    两套规则必然分叉（那会变成"任务取到 3 个号、页面显示 0 个号"这种鬼故事）。
-    """
-    name = (device_name or "").strip()
-    if not name and serial:
-        with _ctx():
-            dev = Device.query.get(serial)
-            name = (dev.name if dev else "") or ""
-    rows = for_device(serial=serial, device_name=name)
-    # 兜底：台账里有人把"设备号"直接填成地址（手填习惯），按 serial 再认一次
-    if not rows and serial:
-        with _ctx():
-            hit = DeviceAccount.query.filter(DeviceAccount.device_name == serial).all()
-            if hit:
-                name = serial
-                rows = [r.to_dict() for r in hit]
-    if not rows:
-        note = (f"设备名『{name}』在台账里没有账号" if name
-                else f"设备 {serial or '（无地址）'} 认不出设备名（设备池里没登记或还没刷新）")
-        if serial and name:
-            note += f"，地址 {serial} 也没对上台账"
-        return name, [], note
-    return name, rows, f"设备『{name}』登记 {len(rows)} 个号"
-
-
-def serial_of(device_name):
-    """设备名 → **当前**地址（拿不到返回空串）。
-
-    ⚠ 为什么不能直接用台账/计划行里的 `serial` 快照：设备地址会变（换 IP、重连）。
-    快照是"录入时"的值，久了就是错的 —— 要下发操作（发布视频等）时必须现查。
-    优先设备池的**内存快照**（零 DB、已经是刷新过的），再退回 DB。
-    """
-    name = (device_name or "").strip()
-    if not name:
-        return ""
-    try:
-        from core import device_pool
-        for d in device_pool.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 douyin_ids(scope, serial="", device_name="", group=""):
-    """按范围取抖音号（任务「条件判断」取号用）。返回 (去重后的纯号列表, 说明)。
-
-    说明是给日志/步骤明细看的**人话解释** —— 取不到号时它是唯一线索
-    （取不到候选值的后果是"这一步永远不命中"，但任务本身会正常跑完）。
-    scope: `device`=本机台账 / `all`=全部 / `group`=某设备分组 / 其他=不取
-    """
-    scope = (scope or "").strip()
-    if scope in ("", "manual", "none"):
-        return [], ""
-    try:
-        with _ctx():
-            if scope == "device":
-                _, rows, note = resolve_device(serial=serial, device_name=device_name)
-                return _uniq([r.get("douyin_id") for r in rows]), note
-            if scope == "all":
-                ids = _uniq([r.douyin_id for r in DeviceAccount.query.all()])
-                return ids, f"全部台账共 {len(ids)} 个号"
-            if scope == "group":
-                names = _device_names_of_group(group)
-                if not names:
-                    return [], f"设备分组『{group}』没有设备（或分组不存在）"
-                rows = DeviceAccount.query.filter(
-                    DeviceAccount.device_name.in_(list(names))).all()
-                ids = _uniq([r.douyin_id for r in rows])
-                return ids, f"设备分组『{group}』（{len(names)} 台设备）共 {len(ids)} 个号"
-            return [], f"未知的取号范围 {scope!r}"
-    except Exception as e:
-        # 取号失败绝不拦住任务：返回空，由调用方回落到手填值
-        _log.warning(f"台账取号失败（回落手填值）: {e}")
-        return [], f"台账取号失败: {e}"
-
-
-def _uniq(ids):
-    out, seen = [], set()
-    for i in ids or []:
-        s = str(i or "").strip()
-        if s and s not in seen:
-            seen.add(s)
-            out.append(s)
-    return out
-
-
-def _device_names_of_group(group_name):
-    """设备分组 → 设备名集合（分组里存的是 serial，这里换成台账里的设备号）。"""
-    g = DeviceGroup.query.filter(DeviceGroup.name == (group_name or "").strip()).first()
-    if not g:
-        return set()
-    serials = g.get_serials() or []
-    if not serials:
-        return set()
-    devs = Device.query.filter(Device.serial.in_(list(serials))).all()
-    return {d.name for d in devs if d.name}
-
-
-def counts_by_device():
-    """{设备名: 号数}（设备池显示"这台几个号"用，一次拿全避免 N 次请求）。"""
-    try:
-        with _ctx():
-            out = {}
-            for r in DeviceAccount.query.all():
-                if r.device_name:
-                    out[r.device_name] = out.get(r.device_name, 0) + 1
-            return out
-    except Exception as e:
-        _log.warning(f"台账统计失败: {e}")
-        return {}
-
-
-def by_device():
-    """{设备名: {count, accounts[]}}（设备维度查看弹窗用）。"""
-    groups = {}
-    try:
-        with _ctx():
-            for r in DeviceAccount.query.order_by(DeviceAccount.douyin_id).all():
-                g = groups.setdefault(r.device_name or "", {"count": 0, "accounts": []})
-                g["count"] += 1
-                g["accounts"].append(r.to_dict())
-    except Exception as e:
-        _log.warning(f"台账按设备分组失败: {e}")
-    return groups
-
-
-def agent_accounts(serial="", device_name="", limit=50, include_phone=False):
-    """设备端 Agent 的账号块（身份大字页用）。
-
-    · **默认不带手机号**：大字页是放在机器旁的公开屏幕，手机号不该默认上屏
-    · 超量**按整条丢**（`truncated=True`），绝不按字节切 —— 切了就是坏 JSON，
-      设备端只能整块丢掉
-    · 任何异常都返回空块（不是抛）：台账坏了不能把"显示身份"这个动作弄坏
-    """
-    try:
-        name, rows, note = resolve_device(serial=serial, device_name=device_name)
-        out = []
-        for r in rows[:max(1, int(limit or 50))]:
-            item = {"name": r.get("nickname") or "", "douyin_id": r.get("douyin_id") or "",
-                    "device_name": r.get("device_name") or "", "device_no": name,
-                    "sim_in_device": bool(r.get("sim_in_device")),
-                    "can_post_video": bool(r.get("can_post_video"))}
-            if include_phone:
-                item["phone"] = r.get("phone") or ""
-            out.append(item)
-        return {"v": 1, "total": len(rows), "shown": len(out),
-                "truncated": len(out) < len(rows), "accounts": out, "note": note}
-    except Exception as e:
-        _log.warning(f"设备端账号块生成失败: {e}")
-        return {"v": 1, "total": 0, "shown": 0, "truncated": False, "accounts": [],
-                "note": f"读取失败: {e}"}
-
-
-# ================== 增 / 改 / 删 ==================
-def add(fields):
-    """新增一条。返回 (dict, error)。"""
-    values, err = _clean(fields)
-    if err:
-        return None, err
-    if not values.get("device_name"):
-        return None, "设备号不能为空"
-    if not values.get("douyin_id"):
-        return None, "抖音号不能为空"
-    # try 必须在 `with _ctx()` 里面：否则 rollback 自己会在 context 外抛
-    # RuntimeError，把真正的错误盖掉（这条踩过一次，别挪出去）
-    with _ctx():
-        try:
-            if find_by_douyin(values["douyin_id"]):
-                return None, f"抖音号 {values['douyin_id']} 已在台账里（一个号只能有一条）"
-            row = DeviceAccount(id=uuid.uuid4().hex[:8], created_at=_now(), updated_at=_now())
-            for k in FIELDS:
-                # 没传的布尔列必须是 False，不能是 ""（Boolean 列收到空串会直接报
-                # TypeError: Not a boolean value，整条插不进去）
-                setattr(row, k, values.get(k, False if k in BOOL_FIELDS else ""))
-            _fill_serial(row)
-            db.session.add(row)
-            db.session.commit()
-            _log.info(f"账号台账新增：{row.device_name} / {row.nickname} / {row.douyin_id}")
-            return row.to_dict(), ""       # 出 context 前转成纯值
-        except Exception as e:
-            db.session.rollback()
-            return None, f"保存失败: {e}"
-
-
-def update(acc_id, fields):
-    """改一条（只改传进来的键）。返回 (dict, error)。"""
-    with _ctx():
-        try:
-            row = DeviceAccount.query.get(acc_id)
-            if not row:
-                return None, "记录不存在"
-            values, err = _clean(fields)
-            if err:
-                return None, err
-            new_id = values.get("douyin_id", row.douyin_id)
-            dup = find_by_douyin(new_id, exclude_id=acc_id)
-            if dup:
-                return None, f"抖音号 {new_id} 已被 {dup[1]} 占用（一个号只能有一条）"
-            for k, v in values.items():
-                setattr(row, k, v)
-            row.updated_at = _now()
-            _fill_serial(row)
-            db.session.commit()
-            return row.to_dict(), ""
-        except Exception as e:
-            db.session.rollback()
-            return None, f"保存失败: {e}"
-
-
-def delete(acc_id):
-    """删一条（删掉之后任务就取不到这个号了）。"""
-    with _ctx():
-        try:
-            row = DeviceAccount.query.get(acc_id)
-            if not row:
-                return False
-            db.session.delete(row)
-            db.session.commit()
-            _log.info(f"账号台账删除：{row.device_name} / {row.nickname} / {row.douyin_id}")
-            return True
-        except Exception as e:
-            db.session.rollback()
-            _log.warning(f"账号台账删除失败: {e}")
-            return False
-
-
-def _fill_serial(row):
-    """按设备名补 serial 快照（台账只填设备号时，自动关联设备池那条）。"""
-    if row.serial:
-        return
-    if not row.device_name:
-        return
-    dev = Device.query.filter(Device.name == row.device_name).first()
-    if dev:
-        row.serial = dev.serial
-
-
-# ================== 粘贴导入 ==================
-def parse_paste(text, delimiter="\t"):
-    """把粘贴的表格文本解析成台账行。返回 (rows, errors)。
-
-    rows 里每行是 `{"_line": 3, "device_name": "...", ..., "_warns": [...]}`
-    （`_line` = 粘贴文本里的行号，界面把错误指回原行；`_warns` 是"能导但要注意"的提示）。
-    errors 是 `[{"line": 3, "reason": "..."}]`（这些行会被跳过）。
-
-    分隔符默认 Tab（Excel 直接粘贴就是 Tab）。**不做"多个空格当分隔"**——
-    账号名里本来就有双空格（实测 `有牛奶面包  你吃吗？`），按空格切会切坏。
-    带表头时按列名映射（顺序随意、缺列留空）；不带表头则按 DEFAULT_ORDER 的固定顺序。
-    """
-    if delimiter not in ("\t", "|", ","):
-        delimiter = "\t"
-    text = (text or "").replace("\r\n", "\n").replace("\r", "\n")
-    lines = [(i + 1, ln) for i, ln in enumerate(text.split("\n")) if ln.strip()]
-    if not lines:
-        return [], [{"line": 0, "reason": "没有可解析的内容"}]
-
-    first_cells = [c.strip() for c in lines[0][1].split(delimiter)]
-    mapped = _map_header(first_cells)
-    if mapped:
-        body = lines[1:]
-    else:
-        mapped = {name: i for i, name in enumerate(DEFAULT_ORDER)}
-        body = lines
-    if not body:
-        return [], [{"line": lines[0][0], "reason": "只有表头，没有数据行"}]
-
-    rows, errors = [], []
-    for lineno, line in body:
-        cells = line.split(delimiter)
-        row = {"_line": lineno, "_warns": []}
-        for f in FIELDS:                       # 先把所有字段填上，缺列留空
-            row[f] = ""
-        for field, idx in mapped.items():
-            if field in FIELDS:
-                row[field] = cells[idx].strip() if idx < len(cells) else ""
-        if not row["device_name"] and not row["douyin_id"]:
-            errors.append({"line": lineno, "reason": "设备号与抖音号都是空的，已跳过"})
-            continue
-        if not row["device_name"]:
-            errors.append({"line": lineno, "reason": "缺设备号，已跳过"})
-            continue
-        if not row["douyin_id"]:
-            errors.append({"line": lineno, "reason": "缺抖音号，已跳过"})
-            continue
-        for f in BOOL_FIELDS:
-            raw = row[f]
-            val, known = _norm_bool(raw)
-            row[f] = val
-            if not known:
-                row["_warns"].append(f"『{raw}』认不出，按「否」处理")
-        if not _DOUYIN_RE.match(row["douyin_id"]):
-            row["_warns"].append(f"抖音号『{row['douyin_id']}』不是纯数字 —— "
-                                 f"任务比对时可能匹配不上")
-        rows.append(row)
-    return rows, errors
-
-
-def _map_header(cells):
-    """列名 → 列下标（认不出"设备号+抖音号"时返回 {}，按固定顺序解析）。"""
-    mapping = {}
-    for idx, cell in enumerate(cells):
-        c = re.sub(r"\s+", "", cell or "")
-        if not c:
-            continue
-        for field, aliases in HEADER_ALIASES.items():
-            if field in mapping:
-                continue
-            if any(c == a or c.startswith(a) for a in aliases):
-                mapping[field] = idx
-                break
-    if "device_name" in mapping and "douyin_id" in mapping:
-        return mapping
-    return {}
-
-
-def import_rows(rows, mode="skip", dry_run=False):
-    """把解析好的行落库（或只预览）。返回逐行结果 + 汇总。
-
-    mode=`skip`（默认）：抖音号已在台账里 → 跳过（不动现有那条）
-    mode=`overwrite`：抖音号已在台账里 → 用粘贴的这行**整行覆盖**它
-    dry_run=True：只判重、不写库（界面上"先预览后导入"）
-    """
-    mode = mode if mode in ("skip", "overwrite") else "skip"
-    counts = {"total": 0, "added": 0, "updated": 0, "skipped": 0, "failed": 0}
-    out_rows = []
-    for row in rows or []:
-        line = row.get("_line", 0)
-        fields = {k: v for k, v in row.items() if k not in ("_line", "_warns")}
-        counts["total"] += 1
-        existing = find_by_douyin(fields.get("douyin_id"))
-        item = {"line": line, "device_name": fields.get("device_name", ""),
-                "douyin_id": fields.get("douyin_id", ""),
-                "nickname": fields.get("nickname", ""),
-                "warns": list(row.get("_warns") or []), "error": ""}
-        if existing:
-            if mode == "overwrite":
-                item["action"] = "update"
-                if not dry_run:
-                    _, err = update(existing[0], fields)
-                    if err:
-                        item["action"], item["error"] = "fail", err
-                counts["updated" if item["action"] == "update" else "failed"] += 1
-            else:
-                item["action"] = "skip"
-                item["error"] = f"已存在（{existing[1]}），跳过"
-                counts["skipped"] += 1
-        else:
-            item["action"] = "add"
-            if not dry_run:
-                _, err = add(fields)
-                if err:
-                    item["action"], item["error"] = "fail", err
-            counts["added" if item["action"] == "add" else "failed"] += 1
-        out_rows.append(item)
-    if not dry_run:
-        _log.info(f"账号台账导入：新增 {counts['added']}、覆盖 {counts['updated']}、"
-                  f"跳过 {counts['skipped']}、失败 {counts['failed']}")
-    return {"counts": counts, "rows": out_rows, "mode": mode, "dry_run": bool(dry_run)}

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}>"
@@ -437,7 +443,11 @@ class DoneMark(db.Model):
 
 
 class DeviceAccount(db.Model):
-    """账号台账：一台设备上登录着哪些账号（「账号」页）。
+    """账号台账（**2026-10-12 起已停用**：页面/接口/任务依赖全部下线，表和数据保留）。
+
+    保留模型 = 保留表和 42 行历史数据、并继续留在备份清单（`SUMMARY_TABLES` 按模型派生）——
+    停用不等于删数据（删不可逆）。新功能**不要再读写这张表**。
+    历史用途：一台设备上登录着哪些账号（「账号」页维护）。
 
     要解决的问题（用户场景）：一台手机登好几个抖音号、十几台手机四五十个号，
     账号信息散在一张电子表格里 —— 换 IP、加号、想查"这台登的是哪几个号"都要翻表。
@@ -451,7 +461,7 @@ class DeviceAccount(db.Model):
       格式不一致会让去重**静默失效**（见 `core/dedup.py`）。
 
     `device_name` 是设备号（平台设备名，如 A01）；`serial` 是**录入时的地址快照**，
-    设备换 IP 或改名后，台账靠任一侧都能找回来（见 `core/ledger.for_device`）。
+    设备换 IP 或改名后，台账靠任一侧都能找回来（账号管理已停用，这列仅留作历史数据）。
     同一抖音号不允许两条 —— 唯一性由服务层保证（号可能为空，DB 层要做
     "部分唯一索引"三处方言适配，人工维护的几十条不值当）。
     """
@@ -506,7 +516,7 @@ class VideoPlan(db.Model):
     ⚠ **`failed` 与 `unknown` 必须分开**：把"不知道自己发没发"混成"知道自己没发"，
     就是重复发布的来源。`stage` 记录失败发生在哪一步，是这两者互相转换的唯一依据。
 
-    **唯一性**：`(phone, release_date, seq)` 由服务层（`core/video_plan.py`）保证，
+    **唯一性**：`(nickname, release_date, seq)` 由服务层（`core/video_plan.py`）保证，
     **不加 DB 唯一索引** —— `seq` 从 1 起、没有"空值"可言，做部分唯一索引要写三处方言适配
     （见 §唯一索引那段注释与 `_ensure_unique_indexes`），收益不匹配；违反的代价只是
     低频人工上传产生的重复行，可见、可删。
@@ -516,16 +526,17 @@ class VideoPlan(db.Model):
     """
     __tablename__ = "video_plan"
     id = db.Column(db.String(32), primary_key=True)                 # uuid 前 8 位
-    account_id = db.Column(db.String(32), default="", index=True)   # → device_account.id（不做外键）
-    phone = db.Column(db.String(32), default="", index=True)        # 配对键（冗余存：账号删了也留痕）
-    device_name = db.Column(db.String(80), default="", index=True)  # 设备号快照（聚合/下发免 join）
-    nickname = db.Column(db.String(80), default="")                 # 账号名称快照（时间线卡片直接显示）
-    douyin_id = db.Column(db.String(64), default="")                # 抖音号快照
-    serial = db.Column(db.String(120), default="")                  # 地址快照
+    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="")                          # 文案
+    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)
@@ -539,6 +550,8 @@ class VideoPlan(db.Model):
     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)
@@ -549,6 +562,8 @@ class VideoPlan(db.Model):
         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):
@@ -557,13 +572,16 @@ class VideoPlan(db.Model):
                 "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 "", "video_file": self.video_file or "",
+                "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 ""}
 
@@ -600,6 +618,11 @@ SCHEMA_MIGRATIONS = [
     (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）
@@ -630,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)
@@ -645,6 +675,7 @@ def init_db(app):
         _sync_columns()
         _migrate_schema()
         _ensure_unique_indexes()
+        _ensure_plain_indexes()
         _ensure_default_admin()
         _migrate_old_json()
 
@@ -777,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,15 @@ 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"],

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 = ("评论", "发送", "发布", "投稿", "转发", "分享到",
@@ -226,19 +226,17 @@ def validate_steps(steps, depth=1, path="steps", errors=None, warnings=None,
             # 所以在这里拦住，别让 AI 草稿悄悄变成"永远不命中"
             cmp_op = (params.get("cmp_op") or "").strip()
             cmp_src = (params.get("cmp_source") or "").strip()
-            if cmp_src not in ("", "manual", "device", "all", "group"):
+            if cmp_src not in ("", "manual", "release", "account_target"):
                 errors.append(f"{here}.params.cmp_source: 不支持的候选值来源 {cmp_src!r}"
-                              f"（可用：空/manual/device/all/group）")
-            if cmp_src == "group" and not (params.get("cmp_group") or "").strip():
-                warnings.append(f"{here}: 候选值来源是「按设备分组」，但没填分组名 —— 取不到号")
+                              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() \
-                        and cmp_src not in ("device", "all", "group"):
-                    # 候选值来自台账时允许手填留空（台账取号就够）；
+                        and cmp_src not in ("release", "account_target"):
+                    # 候选值来自发布计划 / 本次要发的名字时，允许手填留空（候选由平台给）；
                     # 其余情况仍要求填值，否则永远不命中
                     errors.append(f"{here}.params.cmp_value: 选了文本比对"
                                   f"（{cmp_op}）就必须填比对的值，否则永远不命中")
@@ -277,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

@@ -139,17 +139,11 @@
 | 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}`）→ 整批重跑 |
-| GET | `/api/ledger?device=&q=&limit=` | D | 账号台账列表 + 统计（`{accounts, stats{total,devices,can_post_video,shown}, device_names}`） |
-| GET | `/api/ledger/by_device` | D | 按设备分组（`{devices:{设备号:{count,accounts[]}}, counts:{设备号:N}}`） |
-| POST | `/api/ledger` | D | 新增账号（抖音号重复 → 400） |
-| PUT | `/api/ledger/<acc_id>` | D | 改一条账号 |
-| DELETE | `/api/ledger/<acc_id>` | D | 删一条账号 |
-| POST | `/api/ledger/import` | D | 从表格粘贴文本批量导入（`dry_run=true` 只预览不写库） |
-| POST | `/api/video_plan/upload_video` | D | 上传单个视频素材（文件名 `手机号_日期_编号`）→ 解析 + 配对 + 入计划 |
+| 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 | 单条计划：查看 / 改标题 / 删除（连素材文件） |
+| 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 | **一键推送**：某天（默认今天）所有待发布/失败的计划 → 各自手机（每台设备一个线程、设备内串行） |
@@ -157,7 +151,7 @@
 | 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 | 一键新建标准发布任务（骨架 15 步：亮屏 → 打开抖音 → 校验账号 → 推送 → 抖音点击 → 填标题 → 标记） |
+| 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 | 给已有任务插上平台两步（推送放最前 / 标记放最后，自己的步骤不动） |
 
@@ -505,62 +499,33 @@
 账本表与语义见 [DATA_MODEL.md](DATA_MODEL.md) §2.9；任务侧怎么用见
 [TASK_DEV.md](TASK_DEV.md) §4.6。
 
-### 账号台账（「账号」页）
-
-数据在 `device_account` 表（[DATA_MODEL.md](DATA_MODEL.md) §2.10），服务层 `core/ledger.py`，
-权限 `devices`。
-
-| 接口 | 请求 | 响应要点 |
-|------|------|---------|
-| `GET /api/ledger` | `?device=<设备号>&q=<搜索>&limit=500` | `{ok, accounts:[{id,device_name,serial,phone,nickname,douyin_id,registered_at,sim_in_device,can_post_video,bio,note,created_at,updated_at}], stats:{total,devices,can_post_video,shown}, device_names:["A01",…]}`。`q` 匹配抖音号/手机号/账号名 |
-| `GET /api/ledger/by_device` | — | `{ok, devices:{A01:{count,accounts:[…]}}, counts:{A01:4}}`（设备池"账号 N"列 + 点开看明细都用它，省一次请求） |
-| `POST /api/ledger` | 9 个字段（`device_name`/`douyin_id` 必填） | `{ok,msg,account}`；缺必填或抖音号重复 → **400** |
-| `PUT /api/ledger/<id>` | 局部字段 | `{ok,msg,account}`；不存在 → 404；抖音号撞车 → 400 |
-| `DELETE /api/ledger/<id>` | — | `{ok,msg}`；不存在 → 404 |
-| `POST /api/ledger/import` | `{"text":"…","delimiter":"\\t","mode":"skip\|overwrite","dry_run":true}` | `{ok, counts:{total,added,updated,skipped,failed}, rows:[{line,action,device_name,douyin_id,nickname,error,warns}], errors:[{line,reason}], mode, dry_run}` |
-
-**导入语义**（解析规则见 `core/ledger.parse_paste`）：
-
-- 分隔符默认 **Tab**（Excel 直接粘贴就是 Tab）；也支持 `|` 与 `,`。**不做"多个空格当分隔"**——
-  账号名里本来就有双空格（实测 `有牛奶面包  你吃吗？`）。
-- **带表头**时按列名映射（顺序随意、缺列留空、认不出的列忽略）；**不带表头**则按
-  设备号/手机号/账号名称/抖音号/注册时间/卡在机内/可发视频/简介/备注 的固定顺序。
-- 「卡在机内 / 可发视频」认 `是/有/1/true` → True，`否/空` → False；认不出的值按"否"处理
-  并在该行 `warns` 里留痕。
-- 抖音号非纯数字也会 `warns` 留痕（不拦）——它会让任务比对匹配不上。
-- `mode=skip`：库里有同号 → 跳过；`mode=overwrite`：**整行替换**（空单元格会覆盖掉原值）。
-- `dry_run=true` 走同一条解析+判重路径但**一个字节都不写**（界面默认先预览再导入）。
-- 缺设备号或抖音号的行会被跳过，并在 `errors` 里带行号说明。
-
-> ⚠ 台账里的抖音号是**纯号**，只当"比对用的候选值"；**不要**拿它填「去重」的身份元素
-> （身份是元素原文逐字算 key，格式不同会让去重**静默失效**）。
-
-### 视频发布计划（「账号 → 发布计划」页）
+### 视频发布计划（「发布计划」页）
 
 表与状态机见 [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,phone,date,seq,title,action,error}], msg}` |
-| `GET /api/video_plan/timeline` | `?range=today\|week\|all&from=&to=&status=&account_id=&q=&limit=` | `{ok, days:[{date,weekday,total,done,plans:[…]}], stats, disk, today}` |
+| `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"}` | `PUT` 只改标题（改完 `pending→ready`）；`DELETE` **先删行再删素材文件** |
+| `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。发布动作由你写在任务里（见 [TASK_DEV.md](TASK_DEV.md) §4.7） |
-| `POST /api/video_plan/push_all` | `{date?, retry_failed?}` | **一键推送**：某天（默认今天）`ready`/`failed` 且未超尝试上限的计划，**按设备分组**推（每台设备一个线程、设备内串行；设备间并行）。返回 `{ok,count,devices,no_device,msg}`；没绑上设备地址的条数单独在 `no_device` 里报出来。全部设备都解析不到 → 400 |
+| `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=&device=&phone=&format=csv` | 已发布作品的分享链接；CSV 带 BOM（Excel 打开中文不乱码） |
+| `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"}` | 一键新建：骨架 **15 步**（亮屏 → 打开抖音(等首页) → 点「我」→ `if_el(cmp_source=release)` 校验账号 → then: `push_release` → 「+」(预填 `descriptionContains=拍摄`) → 相册/第一个视频/下一步/输入框/发布（**空选择器占位**）→ `input_text(text_source=release_title)` → `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` | `{"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`（不重复落盘）；
+**逐文件上传的幂等**：同一 `(名字,日期,编号)` 已有行时 —— 文件内容相同 → `action=skip`（不重复落盘）；
 内容不同 → **拒收**，前端给「覆盖」按钮（二次确认后带 `replace=1` 重传）。
 标题同理：同槽位已有别的标题 → 拒收（不静默覆盖，文案是发出去就改不了的东西）。
 

doc/ARCHITECTURE.md

@@ -280,7 +280,7 @@ connecting ──获取设备──▶ u2 连接 ──▶ running ──▶ set
 | 顶级 Tab | `data-tab` | 权限 | 子分栏 |
 |---------|-----------|------|--------|
 | 监控 | `monitor` | 登录即可 | — |
-| 账号 | `account` | `devices` | `ledger` 账号台账（列表/增删改/粘贴导入）/ `plan` **发布计划**（上传视频与标题、时间线、推送到手机、导出链接 + **发布任务就地编辑**，见 [DATA_MODEL.md](DATA_MODEL.md) §2.10 §2.11） |
+| **发布计划** | `plan` | `devices` | 上传视频与标题（按**名字**配对）、时间线、推送到手机、导出链接 + **发布任务就地编辑**（见 [DATA_MODEL.md](DATA_MODEL.md) §2.11）。2026-10-12 起「账号台账」整页下线（表保留），本页从「账号」页的子分栏升为一级页签 |
 | 任务 | `tasks` | 登录即可（写操作需 `tasks`） | `plan` 任务计划 / `actions` 自定义动作 / `actioncfg` 动作配置 / `dedup` 去重记录 |
 | 日志 | `logs` | `logs` | — |
 | 用户 | `users` | `admin` | — |
@@ -297,8 +297,7 @@ connecting ──获取设备──▶ u2 连接 ──▶ running ──▶ set
 | `base.js` | esc / CSRF / 权限 / API 封装 / Toast / Tab 与子分栏切换 / 模态框 / 常量表 | 所有模块的公共底座 |
 | `markdown.js` | 轻量 Markdown 渲染（`renderMarkdown`） | 无 CDN 依赖；**先转义再套标记** |
 | `list.js` | 统一列表组件：搜索 + 分页 + 排序 | 状态注册表 `_LIST_PAGERS`；`setListPager` **不重置**页码/搜索/排序（避免轮询刷新打断用户） |
-| `ledger.js` | 账号台账页（列表 / 单条增删改 / 从表格粘贴导入 + 逐行结果 / 设备维度弹窗）+ `ledgerCell()` 供设备池那一列 | 服务层 `core/ledger.py`；导入默认**先预览再写**（`dry_run`） |
-| `release.js` | 发布计划页（时间线按日期分组 / 多选视频**串行**上传 + 逐文件进度与结果 / 标题 txt 上传 / 推送到手机 + **一键推送**（当天全部）、相册校验徽章与裁决 / 链接复制与导出 CSV / **发布任务的就地编辑**） | 服务层 `core/video_plan.py`；上传前把队列**按文件名排序**并让用户确认解析结果（顺序 = "无编号按顺序配"的依据）。就地编辑只放常用字段（名字/目标/时间/启停/逐步参数 + 抓取元素），更复杂的编排走「打开通用编辑器」→ `openTaskModal`；步骤路径里 `then/else/children` 在**步骤的 params 下**（`_rpWalk`），走错这一层会把分支当数组下标用 |
+| `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 = 10`（迁移清单见 `core/models.py` 的 `SCHEMA_MIGRATIONS`：建表/补列以模型为准，这里只作版本账本） |
+| 当前 schema 版本 | `app_meta.schema_version = 11`（迁移清单见 `core/models.py` 的 `SCHEMA_MIGRATIONS`：建表/补列以模型为准，这里只作版本账本） |
 
 **环境与库的绑定**（防混库，见 [DEPLOY.md](DEPLOY.md) §2.2）
 
@@ -46,8 +46,8 @@
 | 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；任务「条件判断」的取号来源、设备端身份页显示用） |
-| 17 | `video_plan` | 视频发布计划：账号 × 发布日期 × 编号 → 素材 + 标题 + 发布状态 + 分享链接（见 §2.11） |
+| 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`
@@ -128,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` — 待确认的发现设备
 
@@ -200,9 +201,20 @@
 
 ⚠️ 这张表**自动进整库备份**（§6 派生规则）；接任务步骤见 [TASK_DEV.md](TASK_DEV.md) §4.6。
 
-### 2.10 `device_account` — 账号台账（一台设备上登录着哪些账号）
+### 2.10 `device_account` — 账号台账（**已停用，表保留**）
 
-「账号」页维护；服务层 `core/ledger.py`，接口 `/api/ledger*`（见 [API.md](API.md) §2.15）。
+> **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`。
+
+历史结构（停用前）：一台设备上登录着哪些账号。「账号」页维护。
 
 | 列 | 类型 | 说明 |
 |----|------|------|
@@ -218,43 +230,38 @@
 | `bio` / `note` | Text | 简介 / 备注 |
 | `created_at` / `updated_at` | String(20) | 字符串时间（仓库惯例） |
 
-**三个使用方**：
+**（停用前的）三个使用方**：① web「账号」页（列表/增删改/从 Excel 粘贴导入）；
+② 任务「条件判断」取号（`cmp_source=device/all/group`）；③ 手机端 Agent 的身份大字页（`accounts_b64`）。
+**三个都已移除**；发布计划现在按**名字**走（§2.11）。
 
-1. **web「账号」页** —— 列表 / 增删改 / 从 Excel 粘贴导入（解析规则见 `core/ledger.parse_paste`）
-2. **任务的「条件判断」取号** —— `if_el` 的 `cmp_source`（`device` 本机 / `all` 全部 / `group` 按设备分组），
-   见 [TASK_DEV.md](TASK_DEV.md) §4.2
-3. **手机端 Agent 的身份大字页** —— 平台推 `accounts_b64`（见 [DEVICE_AGENT.md](DEVICE_AGENT.md) §5.2）
+⚠️ 历史提醒：`douyin_id` 是纯号，**绝不能当去重身份**（`done_mark.identity` 存的是元素原文、
+逐字算 key，格式不一致会让去重静默失效）—— 这是当年 `cmp_source` 取号的边界，
+现在候选值来自"本次要发的名字"，同理不得拿去填 `ident_value`。
 
-⚠️ **`douyin_id` 是纯号，绝不能当去重身份**：`done_mark.identity` 存的是**元素原文**
-（`抖音号：35377983067`）、逐字算 key，格式不一致会让去重**静默失效**。
-它只做"比对用的候选值"（运算符用「包含」时纯号是子串）。
+这张表**仍在整库备份内**（§6 派生规则）—— 停用不等于删数据。
 
-**唯一性在应用层**（`core/ledger`）：同一抖音号不允许两条。没做成 DB 唯一索引的理由：
-抖音号可能为空，DB 级要写"部分唯一索引"（§4.2 那套 SQLite `WHERE` + MySQL 虚拟生成列），
-而台账是人工维护的几十条 —— 三处方言适配不划算。
+### 2.11 `video_plan` — 视频发布计划（**一个名字**在某天要发的一个视频）
 
-这张表**自动进整库备份**（§6 派生规则）。
-
-### 2.11 `video_plan` — 视频发布计划（一个账号在某天要发的一个视频）
-
-「账号 → 发布计划」页维护；服务层 `core/video_plan.py`，接口 `/api/video_plan/*`（见 [API.md](API.md) §2.14），
+「发布计划」页维护；服务层 `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）。
+**素材文件（视频/图片）**落在 `data/videos/YYYY-MM/`（文件名 `{sha1[:12]}_{安全原名}`，内容寻址），**不进整库备份**（§6）。
 
 | 列 | 类型 | 说明 |
 |----|------|------|
 | `id` | String(32) PK | uuid 前 8 位 |
-| `account_id` / `phone` | String(32) | 台账行 id（**不做外键**）/ 配对键（冗余存：账号删了也留痕） |
-| `device_name` / `nickname` / `douyin_id` / `serial` | String | 账号与设备快照（时间线卡片直接显示，免 join） |
+| `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 配对写入；**空标题不会被发布**） |
-| `video_file` / `video_name` / `video_size` / `video_sha1` | 各自 | 落盘相对路径 / 原始名 / 大小 / 内容指纹（重复上传判据） |
+| `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` | | 失败原因 / 人工备注 / 时间 |
 
 **状态机**（本表的灵魂，别简化）：
@@ -275,12 +282,14 @@ unknown    推送之后出的岔子 —— **可能已经发出去了，绝不
 > 就是重复发布的来源。`stage` 是两者互相转换的唯一依据（`core/video_plan.STAGE_STATUS`）。
 > 界面上的 `unknown` 卡片标橙 + 硬提示，人工到抖音确认后点「已发出 / 未发出」裁决。
 
-**唯一性**：`(phone, release_date, seq)` 由**服务层**保证，**不加 DB 唯一索引** ——
+**唯一性**：`(nickname, release_date, seq)` 由**服务层**保证，**不加 DB 唯一索引** ——
 `seq` 从 1 起、没有"空值"可言，做部分唯一索引要写三处方言适配 + MySQL 生成列（§4.2），
 收益不匹配；违反的代价只是低频人工上传产生的重复行（可见、可删）。
 
-**索引**：`(release_date,status)` 时间线主查询 · `(account_id,release_date)` 账号视角 ·
-`(phone,release_date,seq)` 配对/幂等 · `(video_file)` 清理时反查引用。
+**索引**：`(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。
 

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`」不符，**直接拒绝启动**并打印
@@ -215,7 +224,7 @@ SUMMARY_TABLES = tuple(sorted(t.name for t in db.metadata.tables.values()))
 当前 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` /
-`device_account`（账号台账）/ `video_plan`（视频发布计划）。
+`device_account`（账号台账，**已停用但仍在备份内**——停用不等于删数据）/ `video_plan`（视频发布计划）。
 完整说明见 [DATA_MODEL.md](DATA_MODEL.md) §6。
 
 > ⚠ **视频素材（`data/videos/`）不进备份包**（几十 GB 会把备份搞坏）：manifest 里有

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` 清掉。**注意它会真在设备上点按**（导航类动作），且与聊天共用同一个运行槽 |
 
@@ -200,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,dedup,ledger,release}.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

@@ -216,51 +216,6 @@ adb -s <serial> shell am start -n <pkg>/.InfoActivity \
 
 要求：全屏大字、再次调用可覆盖内容、`close` 可关闭、不驻留前台。
 
-#### 5.2.1 本机账号台账（`accounts_b64`，可选 extras — **需要设备端配合实现**）
-
-平台在**打开**身份页时会顺带把这台设备在「账号」页登记的抖音账号推过去
-（`--es close 1` 时**不带**）。**中文必须 base64**（同 §5.1：adb shell 直传中文会变形）：
-
-```bash
-adb -s <serial> shell am start -n <pkg>/.InfoActivity \
-  --es name "A03" --es serial "192.168.20.63:5555" --es server "http://192.168.20.220:18050" \
-  --es ip "192.168.20.63" \
-  --es accounts_b64 "<base64(UTF-8 JSON)>"
-```
-
-解码：**标准 base64**（不是 URL-safe）+ UTF-8。JSON 结构（字段名的设备端解析按名取，多余字段忽略）：
-
-```json
-{"v":1,"total":4,"shown":4,"truncated":false,
- "note":"设备『A03』登记 4 个号",
- "accounts":[
-   {"name":"AA建材王总","douyin_id":"66057500463","device_name":"A03","device_no":"A03",
-    "sim_in_device":true,"can_post_video":true}]}
-```
-
-| 字段 | 说明 |
-|------|------|
-| `v` | 本块格式版本（当前 **1**）。解不出来时用它区分"格式变了"与"平台没给" |
-| `total` / `shown` / `truncated` | 该设备在台账里的总数 / 本次带了几条 / 是否被截断 |
-| `accounts[].name` | 账号名称（台账的「账号名称」列） |
-| `accounts[].douyin_id` | **抖音号（纯号）**，如 `35377983067` |
-| `accounts[].sim_in_device` / `can_post_video` | 卡在机内 / 可发视频（布尔） |
-| `accounts[].phone` | **默认不推**（大字页是机器旁的公开屏幕，手机号不宜默认上屏）。需要时平台请求体传 `{"include_phone":true}` |
-
-**设备端要做的**（当前版本忽略该 extra，行为与旧版逐字一致）：
-
-1. 读 `accounts_b64` → base64 解码 → `JSONObject`
-2. 在身份页上按 `name` / `douyin_id` 渲染一个列表（建议 1~3 行简短列表，最多显示 `shown` 条）
-3. `truncated=true` 时提示"还有更多，见平台账号页"
-
-**约定与边界**（平台侧实现见 `web/device_agent_api.py` 的 `_encode_accounts`）：
-
-- **没有这个 extra = 这台设备在台账里没有账号**（不是"平台忘了给"）——设备端保持原样显示即可，
-  不要显示空列表
-- 超预算时平台**按整条丢**（`shown` 变小 + `truncated=true`），**绝不按字节切**（切了就是坏 JSON）；
-  台账过大时可能**整个 extra 不发**（平台响应体里 `warn` 会说明原因）
-- 台账读取失败时同样**不发**这个 extra —— 台账故障不影响"显示身份"这个动作
-
 ### 5.3 扫码配置（设备端已实现）
 
 平台「设备池」里点某台设备的「**二维码**」→ 生成一张二维码 → 手机上的 Agent 点
@@ -294,9 +249,9 @@ adb -s <serial> shell am start -n <pkg>/.ConfigActivity \
 
 ## 6. 版本与兼容
 
-- **§5.2.1 的 `accounts_b64` 是"加字段"= 小版本**：`agent_api_version` **仍是 1**，
-  设备端忽略它时行为必须与旧版逐字一致（只是大字页少一块内容）。也**不**走
-  `bootstrap`：身份页由平台用 adb 推，加进 bootstrap 没人用还会让契约多一处要同步。
+- 身份页 extras（`name`/`ip`/`serial`/`server`/`close`）是**平台单向下发**：设备端多收/少收
+  都不影响旧行为。（2026-10-12：账号台账下线，原先顺带下发的 `accounts_b64` 已不再发送 ——
+  设备端收到"没有这个 extra"时照旧只显示身份信息即可。）
 - `agent_api_version`（当前 **1**）在每次 `bootstrap` 响应里返回
 - **设备端**：启动时对比自己实现的版本，不一致要在日志里明确记下来（不要静默）
 - **平台端**：

doc/NOTIFY.md

@@ -53,6 +53,7 @@ daemon 线程。所以：
 | 任务·单设备 | `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/TASK_DEV.md

@@ -109,7 +109,7 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 
 ---
 
-## 3. 24 种步骤全表
+## 3. 27 种步骤全表
 
 > 参数与默认值以 `tasks/generic/task.py` 为准；前端 `STEP_LIB`（`static/admin/editor.js`）负责在编辑器里呈现这些字段。
 
@@ -127,18 +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)、`text_source`("manual")、`release_topics`("") | — | `mode="fixed"` 用 `fixed_text`，否则从 `texts` 按行随机选一条；`text_source=release_title`（或 `release_title_topics`）时**取本机当前那条发布计划的标题**（配 `release_topics` 自动加话题），**并回读输入框校验**（不校验就可能发出一篇空文案）；**只负责输入，不负责定位输入框**（要先 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) | — | 走**设备端 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`("")、`cmp_source`("")、`cmp_group`("")、`ident_type`/`ident_value`（去重身份） | `then` / `else` | 见 §4.2；条件类型除元素/OCR 外还支持 **屏幕状态**、**前台App**、**去重**（见 §4.6）；填 `cmp_op` 则改成**比元素的文本**（等于/不等于/包含/不包含，多值任一命中），候选值还可以从**「账号」台账**取（`cmp_source` = device/all/group），或取**本机要发的那条发布计划**的抖音号/昵称（`cmp_source` = release） |
+| 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`(device/phone)、`account_phone`、`album_dir`(/sdcard/DCIM/Camera)、`to_clipboard`(True)、`retry_failed`(True)、`max_same_run`(1) | — | 取本机某天的「发布计划」→ **只把素材推到手机**（+ 触发相册刷新 + 标题写进剪贴板）。**不发布** —— 抖音流程你自己在后面画。幂等靠原子占位（多设备/重跑不会重复推）。见 §4.7 |
+| 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`）
 
@@ -285,45 +289,38 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
   走了 `else`，不是选择器失效，不该攒出「连续未命中」告警。
 - 读元素文本是**只读**操作（`get_text`，2 秒超时），不会点击或改动任何状态。
 
-#### 候选值从「账号」台账取号（`cmp_source` / `cmp_group`，可选）
+#### 候选值由平台给（`cmp_source`，可选）
 
-几十个号时手写 `cmp_value` 很累、而且换号要回来改。`cmp_source` 让候选值直接来自
-「账号」页的台账：
+几十个号时手写 `cmp_value` 很累、而且换号要回来改。`cmp_source` 让候选值由平台给：
 
-| `cmp_source` | 取哪些号 |
+| `cmp_source` | 候选值 |
 |---|---|
 | `""` / `manual`（默认） | 只用手填的 `cmp_value` —— **行为与以前完全一致** |
-| `device` | **本机台账**：这台设备在台账里登记的抖音号（靠 `serial`→设备名 匹配） |
-| `all` | 全部台账 |
-| `group` | 某个**设备分组**内所有设备的号（分组名填在 `cmp_group`） |
-| `release` | **本机当前发布计划**要发的那个号：优先本次运行里「推送发布视频」刚取到的那条；还没有就**看**下一条待发的（只看不占位）。候选值是**抖音号 + 账号名称**两个（任一命中即可） |
+| `account_target` | **本次要发的那个名字**：循环块设的目标名字优先，没有就用「读取本机账号名字」刚读到的|
+| `release` | **本机当前发布计划**要发的那个名字：优先本次运行里「推送发布视频」刚取到的那条；还没有就**看**下一条待发的（只看不占位） |
 
-#### `release`：发布前先确认"登的是要发的那个号"（一台手机登好几个号时必配）
+#### `account_target`：发布前先确认"登的是要发的那个号"（一台手机登好几个号时必配）
 
-一台手机可能登着好几个号，发布前必须确认当前抖音登的就是这条计划要发的号 ——
-就在发布流程**最前面**放一个条件判断（`cmp_source=release` + `包含`），命中了才走发布，
-没命中走 `else`（发通知/跳过）。这样"发错号"变成"这条跳过"，而不是把 A 号的视频发到 B 号上。
+一台手机可能登着好几个号，发布前必须确认当前抖音登的就是**这次要发的**那个号 ——
+就在发布流程**最前面**放一个条件判断（`cmp_source=account_target` + `包含`），
+命中了才走发布，没命中走 `else`（发通知/跳过）。这样"发错号"变成"这条跳过"，
+而不是把 A 号的视频发到 B 号上。
 
-- 比对的元素原文：抖音「我」页面上的那一行（如 `//*[contains(@text,'抖音号')]`）——
-  `cmp_source=release` 给的候选值包含**抖音号**，所以 `包含` 就能命中。
-- 命中判据是**候选值里任一被元素原文包含**；两个候选值（抖音号、昵称）是刻意的：
-  有的界面只显示昵称。
-- **本机没有待发计划 → 候选为空 → 这一步永远走 `else`**（日志会写明"本机没有待发的发布计划"），
-  不会把不该发的号发出去。
+- 比对的元素原文 = **昵称控件**（和「读取本机账号名字」用**同一个选择器**，抓一次两处都填）；
+  候选值是名字，所以用 **`包含`**。
+- **读不到名字 → 候选为空 → 这一步永远走 `else`**（日志会写明"没读到本次要发的名字"）。
+  这是故意的：**读不到名字 = 不知道现在登的是谁 = 不发**。
+- ⚠ **绝不能用「不等于」**：读不到名字时候选为空，`不等于` 对空候选算**命中**，
+  会把"读不到"误判成"可以发"。
+- **与手填值是合并（OR）**，不是二选一：平台给的候选 + 你补的值，任一命中即可
+  （平台的候选取不到时手填值仍然生效，不会把任务直接打哑）。
+- 「推送发布视频」自己**还会再核对一次**（推送前重读昵称，见 §4.7），所以就算这个条件判断
+  没画，也不会发错号 —— 条件是给"要先看一眼再决定"的场景用的。
 
-- **与手填值是合并（OR）**，不是二选一：台账里的号 + 你补的一个号，任一命中即可。
-  更重要的是 —— **台账取不到号时手填值仍然生效**，台账没维护好不会把任务直接打哑。
-- 取到 0 个号时**日志会写明原因**（如"设备名对不上"）：
-  候选为空会让这一步**永远走 `else` 分支**，而任务本身照样"跑完了"。
-  编辑器保存时也会为此报警告，请到「账号」页核对设备号。
-- 比对运算符仍要选：台账里是**纯号**（`35377983067`），元素原文是
-  `抖音号：35377983067` → 用 **`包含`**。（要整段一模一样才用 `等于`。）
-
-> ⚠ **台账的纯号只能当"比对用的候选值"，绝不能拿去填「去重」的身份元素**（`ident_value`）：
+> ⚠ **比对用的候选值绝不能拿去填「去重」的身份元素**（`ident_value`）：
 > 去重身份存的是**元素原文**、逐字算 key（`core/dedup.py` 的 `build_key`），
-> 格式不一致（`35377983067` vs `抖音号：35377983067`）会让**检查与记账算出两个不同的
-> key → 去重静默失效**（重复评论，而且日志看不出问题）。
-> 去重身份继续用「抓取元素」抓到的那个账号元素即可。
+> 格式不一致（`小王` vs `昵称：小王`）会让**检查与记账算出两个不同的 key → 去重静默失效**
+> （重复评论，而且日志看不出问题）。去重身份继续用「抓取元素」抓到的那个账号元素即可。
 
 ### 4.3 公共参数
 
@@ -464,33 +461,74 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 
 ### 4.7 发布计划：平台推素材，发布流程你自己写（`push_release` + `mark_release`）
 
-数据与界面见 [DATA_MODEL.md](DATA_MODEL.md) §2.11 与「账号 → 发布计划」页。
+数据与界面见 [DATA_MODEL.md](DATA_MODEL.md) §2.11 与「发布计划」页。
+
+**全部按「名字」走**（名字 = 上传文件名里的那个名字 = 抖音昵称）：计划行认名字，
+运行时读本机当前账号名字，**读不到名字就当"本机没有号"、什么都不发**。
+
+**素材可以是视频，也可以是图片**（扩展名各带各的，一路原样带到手机上 —— 抖音按它判断
+这是视频还是「图文」）：**发布流程是同一条**（相册里点第一个素材 → 下一步 → 填标题/正文 → 发布），
+所以任务画布不用为图片另写一套。
 
 **分工**（这是刻意的设计）：**平台只管"素材到手机 + 状态记账"，抖音里怎么发由你画** ——
 因为发布流程跟账号、版本、界面都在变，写死在平台里改不动。
 
 ```
-[条件判断 cmp_source=release]  →  [推送发布视频]  →  [你自己写的发布步骤…]  →  [标记发布结果]
- 当前登的是要发的号吗？             push_release        打开抖音→点+→相册→选视频       mark_release
- 不是 → else：发通知（本条跳过）                        →下一步→粘贴标题→发布          result=published 放成功分支
-                                                                                 result=failed 放失败分支
+[读取本机账号名字] → [条件判断 account_target] → [推送发布视频] → [你的发布步骤…] → [标记发布结果]
+ read_account_name    登的是要发的号吗？            push_release     打开抖音→点+→相册→选视频   mark_release
+                       不是/读不到 → else：通知跳过                   →下一步→填标题→填正文→发布  published 放成功分支
+                                                                                            failed 放失败分支
 ```
 
-**先校验账号再发**（一台手机登好几个号时必配）：放在最前面的条件判断用
-`cmp_source=release`（候选值 = 本机要发的那条计划的**抖音号/账号名称**，见 §4.2），
-元素原文取抖音「我」页面上的 `//*[contains(@text,'抖音号')]`，运算符 `包含`；
+**先读名字、再校验、最后才发**（一台手机登好几个号时必配）：
+
+- 「读取本机账号名字」：读抖音「我」页面上的**昵称控件**（选择器抓一次填进 `.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()`）：
 
 ```
-① 取本机账号（core.ledger.resolve_device —— "本机是哪台"只在那处定义，别写第二套）
-② 取计划：本机账号在目标日期上 status ∈ (ready, failed) 且 attempts < 3 的行，按 (日期,编号) 升序
-③ **原子占位**：UPDATE … SET status='pushing' WHERE id=? AND status IN ('ready','failed')
+⓪ 核对：重读昵称 → 与本次要发的名字不一致/读不到 → **不推**（返回"跳过"）
+① 取计划（**队列口径**）：**这个名字**名下 `发布日期 <= 目标日期`（过期会补发、未来的不发）、
+   `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 改成"现在" + 清掉同一计划在旧目录里的副本
-⑥ 触发媒体扫描 → **按路径**校验它真的进了相册索引 → 把标题写进手机剪贴板（供「粘贴」用）
+③ adb push → {album_dir}/{计划id}.mp4（默认 /sdcard/DCIM/Camera）→ 校验**大小**（按 ls -l 的大小列比）
+④ **touch 一下**把手机上这个文件的 mtime 改成"现在" + 清掉同一计划在旧目录里的副本
+⑤ 触发媒体扫描 → **按路径**校验它真的进了相册索引 → 把标题写进手机剪贴板（供「粘贴」用）
 ```
 
 **为什么是 `DCIM/Camera`、为什么要 touch**（都是实测踩出来的）：
@@ -546,7 +584,7 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 - **你的发布步骤里，文案要用「粘贴」**（推送时标题已进剪贴板）；如果非要用「输入文字」，
   记得后面加一步**回读校验**（读输入框的 text）—— 抖音的 EditText 有时不吃 `send_keys`，
   不校验就可能发出一篇空文案而每一步都显示成功。
-- **不靠 `done_mark` 判重**：去重账本的 identity 是元素原文，与 `(手机号,日期,编号)` 两套 key
+- **不靠 `done_mark` 判重**：去重账本的 identity 是元素原文，与 `(名字,日期,编号)` 两套 key
   语义不同，混用会静默失效。
 - **任务状态 ≠ 发布结果**：`_exec_steps` 不检查步骤结果，**标记失败不会让任务失败** ——
   「这次发布的真相」以计划行的 `status` 为准（计划页看得到），并会推
@@ -560,15 +598,16 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 这类任务行上会标「**缺平台推送步骤**」并给一个「**插上平台步骤**」按钮
 （`POST /api/video_plan/tasks/<id>/adopt`：推送放最前、标记放最后、**你原来的步骤一步不动**）。
 还支持**一键新建标准发布任务** ——
-骨架 **15 步**已经排好：
+骨架 **17 步**已经排好（**标题和正文各一步** —— 对应抖音发布页上那两个框）：
 
 ```
 ⓪ 亮屏  ① 打开抖音(等「首页」出来)  ② 点击「我」(desc 含"我")  ③ 等待 3~5s
 ④ 条件判断  //*[contains(@text,'抖音号')] 包含 cmp_source=release
    ├─ then（登的就是要发的号）⑤ 推送发布视频 ⑥ 点击「+」(desc 含"拍摄")
    │        ⑦ 相册 ⑧ 第一个视频 ⑨ 下一步 ⑩ 输入框 ⑪ 输入文字(text_source=release_title)
-   │        ⑫ 点击「发布」 ⑬ 标记发布结果
-   └─ else（不是这个号 / 今天没有待发计划）⑭ 发通知"本条跳过"
+   │        ⑫ 点击正文输入框 ⑬ 输入文字(text_source=release_body)
+   │        ⑭ 点击「发布」 ⑮ 标记发布结果
+   └─ else（不是这个号 / 今天没有待发计划）⑯ 发通知"本条跳过"
 ```
 
 > ⚠ **⓪ 亮屏 + ① 等「首页」是踩出来的，别删**：真机实测（2026-09-28，A01）——
@@ -577,17 +616,24 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 > 屏幕亮着时冷启动 5 秒就出底部栏。
 
 建好之后**就在「发布计划」这一块点「编辑」就地改**（名字/目标/每天几点/启停/逐步参数，
-选择器旁边就有「抓取元素」），把 5 个空选择器（相册/第一个视频/下一步/输入框/发布）抓一次就能跑 ——
+选择器旁边就有「抓取元素」），把 6 个空选择器（相册/第一个视频/下一步/标题框/正文框/发布）抓一次就能跑 ——
 要加步骤、循环、自定义动作这些更复杂的编排，才走「打开通用编辑器」（跳任务页）——
 **抖音那几步故意不写死选择器**：混淆 id / 结构 xpath 改版就废，
 抓一次的成本远低于每次发版都改平台代码。②⑥ 两条预填的是**按描述定位**
 （`descriptionContains`，跨版本稳），一般不用改。
 
-**「输入文字」自动用标题**：`text_source=release_title` 会取**本机当前那条计划**的标题
-（`push_release` 同一次运行里传递；断档了就取最近一条"已推送到手机"的），
-`release_title_topics` 还能自动补话题；**取计划标题时会回读输入框校验**，
-不通过就改走剪贴板通道再验一次 —— 抖音的 EditText 有时不吃键盘输入，
-不校验的后果是"发出一篇空文案，而每一步都显示成功"。
+**「输入文字」自动用计划里的内容**（`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` 链接。

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

@@ -117,7 +117,11 @@ function showTab(name){
     showSubTab('agent', _activeSubs.agent||'chat');   // 聊天 / AI 建任务
     if(typeof initAgentChat==='function') initAgentChat();
   }
-  if(name==='account'){showSubTab('account',_activeSubs.account||'ledger');}
+  // 发布计划（原「发布计划」子分栏，账号台账下线后升为一级页签）
+  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');}
 }
@@ -125,7 +129,7 @@ function showTab(name){
 // ================== 页内子分栏（任务/工具 通用） ==================
 // 每个带子分栏的 Tab 记住上次选中的子分栏，切走再切回来保持原位
 let _activeSubs = {tasks: 'plan', tools: 'clipboard', system: 'backup', agent: 'chat',
-                   logs: 'files', account: 'ledger'};
+                   logs: 'files'};
 let _discoveryTimer = null;   // 设备自动发现 10s 轮询（仅 devpool 子分栏激活时）
 
 function showSubTab(tabId, name){
@@ -139,11 +143,6 @@ function showSubTab(tabId, name){
   if(tabId==='logs' && name==='steps' && typeof loadStepLogs==='function') loadStepLogs(true);
   if(tabId==='tasks' && name==='actioncfg' && typeof loadActionConfig==='function') loadActionConfig();
   if(tabId==='tasks' && name==='dedup' && typeof loadDedup==='function') loadDedup();
-  if(tabId==='account' && name==='ledger' && typeof loadLedger==='function') loadLedger();
-  if(tabId==='account' && name==='plan' && typeof loadReleasePlan==='function'){
-    loadReleasePlan();
-    if(typeof loadReleaseTasks==='function') loadReleaseTasks();
-  }
   if(name==='groups' && typeof loadGroups==='function') loadGroups();
   if(name==='apks' && typeof loadAgentStore==='function') loadAgentStore();
   if(name==='devpool' && typeof loadDevPool==='function'){

static/admin/editor.js

@@ -21,6 +21,9 @@ var STEP_LIB=[
   {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:'',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 子步骤
-    if(step.type==='loop'||step.type==='group'){
+    // loop/group/foreach_account 子步骤（**容器不列进来就看不到里面** —— 加新容器类型时
+    // 记得同时改这里、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';
@@ -444,11 +448,13 @@ var _stepEditor={
       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','发布计划标题 + 话题']]
+        [['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:'+(tsrc==='release_title_topics'?'block':'none')+'"><label>话题（逗号分隔，不带 # 会自动补）</label><input type="text" class="form-control" data-key="release_topics" value="'+esc(p.release_topics||'')+'" placeholder="如 苏州,日常"></div>';
+        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 存在与否收集，删了会把用户填的值抹掉）
@@ -468,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>';
@@ -476,9 +492,9 @@ 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 fromLedger=(cmpSrc==='device'||cmpSrc==='all'||cmpSrc==='group');
+      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">'+
         [['','不比对（只看元素在不在）'],['等于','等于'],['不等于','不等于'],['包含','包含'],['不包含','不包含']]
@@ -486,28 +502,24 @@ var _stepEditor={
         '</select></div>'+
         '<div class="form-group"><label>候选值来源</label>'+
         '<select class="form-control" data-key="cmp_source" onchange="_stepEditor._cmpSourceChanged(this)">'+
-        [['','手填（默认）'],['device','本机台账'],['all','全部台账'],['group','按设备分组'],
-         ['release','本机当前发布计划（要发的那个号）']]
+        [['','手填（默认）'],['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>的抖音号 + 账号名称（推送前校验"当前登录的是不是要发的号"就用它）'
-          : '台账在「账号」页维护')+'</div></div>'+
-        (cmpSrc==='group'?
-          '<div class="form-group"><label>设备分组名</label>'+
-          '<input class="form-control" data-key="cmp_group" value="'+esc(p.cmp_group||'')+'" '+
-          'placeholder="分组名（工具→设备分组）"></div>':'')+
-        // 选台账时**只隐藏、不删**这个输入框：_syncParams 是按 DOM 存在与否收集的，
+          ? '取<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'+(fromLedger?';display:none':'')+'">'+
+        '<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>，因为要比对的文本本身常带逗号'
-        +(fromLedger?'<br><b>候选值来自台账</b>：这台设备在台账里登记的抖音号会作为候选，'
-          +'手填的值<b>追加</b>在后面（台账取不到号时只用手填值，不会把任务打哑）。'
-          +'<br>⚠ 台账只提供<b>比对用的号</b>；<b>不要</b>把台账号填到「去重」的身份元素里'
-          +'（身份是元素原文、逐字比，格式不同会让去重静默失效）。':'')
+        +(fromPlatform?'<br>候选值由平台给（上面选的来源），手填的值会<b>追加</b>在后面。':'')
         +'</div></div></div>';
       // 「去重」条件：身份元素用 ident_type/ident_value（主选择器那行只剩类型下拉）
       var identRow=isDedup?_selRowHtml(p,
@@ -855,7 +867,7 @@ var _stepEditor={
     var self=this;
     setTimeout(function(){self._renderCanvas();},0);
   },
-  // 条件判断：候选值来源切到台账时，把"比对的值"藏起来（按分组还要显示分组名输入框）
+  // 条件判断：候选值来源切到"平台给"（本次要发的名字 / 发布计划）时，把"比对的值"藏起来
   _cmpSourceChanged:function(sel){
     // 同 _condTypeChanged：先把 DOM 的值同步回 _steps，否则重渲染会吞掉刚改的东西
     this._syncFromDom();
@@ -979,17 +991,17 @@ var _stepEditor={
             warnings.push(name+' "'+label+'": 条件判断的选择器为空，会直接走"未找到"分支。');
           }
           var cmpSrcV=(s.params.cmp_source||'');
-          var fromLedger=(cmpSrcV==='device'||cmpSrcV==='all'||cmpSrcV==='group');
-          // 候选值"从别处取"的那两档（台账 / 发布计划）：手填可以留空，别报"没填值"
-          var fromOther=(fromLedger||cmpSrcV==='release');
+          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&&fromLedger&&s.params.cmp_op){
-            warnings.push(name+' "'+label+'": 候选值来自台账 —— 台账里没有这台设备'
-              +'（或设备池里的设备名与台账「设备号」对不上）时会取不到号，'
-              +'这一步将永远走"未找到"分支。请到「账号」页核对设备号。');
+          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+'": 候选值来自"本机当前发布计划" —— 本机没有待发的计划'

static/admin/ledger.js

@@ -1,300 +0,0 @@
-// 账号台账（「账号」顶级 Tab）
-// 数据在 device_account 表，服务层 core/ledger.py，接口 /api/ledger*（web/devices_api.py）。
-//
-// 这一页的三重价值：
-//   ① 一台设备登好几个号、十几台设备几十个号 —— 换 IP / 加号时不用再翻电子表格；
-//   ② 任务的「条件判断」可以直接从这里取号（cmp_source），不用手写一串抖音号；
-//   ③ 手机端 Agent 的「身份大字页」会显示本机账号（平台推 accounts_b64）。
-//
-// ⚠ 台账里的抖音号是**纯号**，只当"比对用的候选值"；**别**拿它去填「去重」的身份元素
-//   ——身份是元素原文、逐字算 key，格式不同会让去重静默失效（core/ledger.py 顶部有警告）。
-var _ledgerAll = [];          // 全部账号（一次拉回，搜索/筛选在前端做：几十条量级）
-var _ledgerStats = {};
-var _ledgerDeviceNames = [];
-var _ledgerCounts = {};       // {设备号: 号数}（设备池那一列用）
-var _ledgerDevices = {};      // {设备号: {count, accounts[]}}（点开看明细用）
-
-function loadLedger() {
-  var sel = document.getElementById('ledger-device');
-  var keep = sel ? sel.value : '';
-  apiGet('/api/ledger?limit=2000').then(function (r) {
-    var tb = document.getElementById('tb-ledger');
-    if (!r || !r.ok) {
-      if (tb) tb.innerHTML = '<tr><td colspan="10" class="empty">读取失败：' + esc((r && r.error) || '') + '</td></tr>';
-      return;
-    }
-    _ledgerAll = r.accounts || [];
-    _ledgerStats = r.stats || {};
-    _ledgerDeviceNames = r.device_names || [];
-    _renderLedgerDeviceFilter(keep);
-    _renderLedgerStats();
-    renderLedger();
-  });
-}
-
-function _renderLedgerDeviceFilter(keep) {
-  var sel = document.getElementById('ledger-device');
-  if (!sel) return;
-  var html = '<option value="">全部设备</option>';
-  _ledgerDeviceNames.forEach(function (n) {
-    html += '<option value="' + esc(n) + '">' + esc(n) + '</option>';
-  });
-  sel.innerHTML = html;
-  sel.value = keep || '';
-}
-
-function _renderLedgerStats() {
-  var el = document.getElementById('ledger-stats');
-  if (!el) return;
-  var s = _ledgerStats || {};
-  el.textContent = '共 ' + (s.total || 0) + ' 个号 · ' + (s.devices || 0) + ' 台设备 · '
-    + (s.can_post_video || 0) + ' 个可发视频';
-}
-
-function ledgerDeviceChanged() { renderLedger(); }
-
-function renderLedger() {
-  var sel = document.getElementById('ledger-device');
-  var dev = sel ? sel.value : '';
-  var rows = dev ? _ledgerAll.filter(function (a) { return a.device_name === dev; }) : _ledgerAll;
-  setListPager('ledger', {
-    data: function () { return rows; },
-    filter: function (a, kw) {
-      return ((a.douyin_id || '') + (a.phone || '') + (a.nickname || '')
-        + (a.device_name || '') + (a.note || '')).toLowerCase().indexOf(kw) >= 0;
-    },
-    sortValue: function (a, k) { return a[k]; },
-    render: renderLedgerRow,
-    tbody: 'tb-ledger', pager: 'pager-ledger', pageSize: 20,
-    empty: '<tr><td colspan="10" class="empty">还没有账号 —— 点「粘贴导入」把你那张表贴进来</td></tr>'
-  });
-  applyListPager('ledger');
-  initListSearch('ledger', 'search-ledger');
-}
-
-function _yn(v) {
-  return v ? '<span class="label label-success">是</span>'
-           : '<span class="label label-default">否</span>';
-}
-
-function _clip(s, n) {
-  var t = String(s || '');
-  if (!t) return '';
-  return '<span title="' + esc(t) + '">' + esc(t.length > n ? t.slice(0, n) + '…' : t) + '</span>';
-}
-
-function renderLedgerRow(a) {
-  return '<tr>' +
-    '<td><strong>' + esc(a.device_name || '-') + '</strong></td>' +
-    '<td>' + esc(a.nickname || '-') + '</td>' +
-    '<td style="font-family:var(--mono)">' + esc(a.douyin_id || '-') + '</td>' +
-    '<td style="font-family:var(--mono)">' + esc(a.phone || '-') + '</td>' +
-    '<td>' + esc(a.registered_at || '-') + '</td>' +
-    '<td>' + _yn(a.sim_in_device) + '</td>' +
-    '<td>' + _yn(a.can_post_video) + '</td>' +
-    '<td>' + _clip(a.bio, 12) + '</td>' +
-    '<td>' + _clip(a.note, 12) + '</td>' +
-    '<td>' +
-      '<button class="btn btn-xs" onclick="openLedgerModal(\'' + a.id + '\')" data-perm="devices">编辑</button> ' +
-      '<button class="btn btn-xs btn-danger" data-id="' + a.id + '" ' +
-        'onclick="deleteLedger(this.dataset.id)" data-perm="devices">删除</button>' +
-    '</td></tr>';
-}
-
-function _ledgerById(id) {
-  for (var i = 0; i < _ledgerAll.length; i++) {
-    if (_ledgerAll[i].id === id) return _ledgerAll[i];
-  }
-  return null;
-}
-
-// ================== 单条新增 / 编辑 ==================
-function _ledgerField(label, key, val, ph) {
-  return '<div class="form-group"><label>' + label + '</label>' +
-    '<input class="form-control" data-lf="' + key + '" value="' + esc(val || '') + '" ' +
-    'placeholder="' + (ph || '') + '"></div>';
-}
-
-function openLedgerModal(id) {
-  var a = id ? _ledgerById(id) : null;
-  document.getElementById('modal-title').textContent = a ? ('编辑账号：' + (a.nickname || a.douyin_id)) : '新增账号';
-  var h = '<div class="form-row">' +
-    _ledgerField('设备号', 'device_name', a && a.device_name, '如 A01（要和设备池里的设备名一致）') +
-    _ledgerField('账号名称', 'nickname', a && a.nickname, '如 AA建材王总') + '</div>' +
-    '<div class="form-row">' +
-    _ledgerField('抖音号', 'douyin_id', a && a.douyin_id, '纯号，如 35377983067（不带「抖音号：」前缀）') +
-    _ledgerField('手机号', 'phone', a && a.phone, '') + '</div>' +
-    '<div class="form-row">' +
-    _ledgerField('注册时间', 'registered_at', a && a.registered_at, '如 2026/9/24（原样存）') +
-    '<div class="form-group"><label>卡在机内 / 可发视频</label>' +
-    '<div style="display:flex;gap:16px;align-items:center;padding-top:4px">' +
-    '<label style="display:inline-flex;gap:4px;align-items:center"><input type="checkbox" data-lf="sim_in_device" '
-      + (a && a.sim_in_device ? 'checked' : '') + '> 卡在机内</label>' +
-    '<label style="display:inline-flex;gap:4px;align-items:center"><input type="checkbox" data-lf="can_post_video" '
-      + (a && a.can_post_video ? 'checked' : '') + '> 可发视频</label>' +
-    '</div></div></div>' +
-    '<div class="form-group"><label>简介</label><input class="form-control" data-lf="bio" value="'
-      + esc(a && a.bio || '') + '"></div>' +
-    '<div class="form-group"><label>备注</label><input class="form-control" data-lf="note" value="'
-      + esc(a && a.note || '') + '"></div>' +
-    '<div class="help">抖音号在整个台账里必须唯一（一个号只能有一条记录）。' +
-    '<b>设备号</b>要和「工具 → 设备池」里的设备名一致 —— 任务的「本机台账」取号、' +
-    '设备端身份页显示本机账号都靠它匹配。</div>';
-  document.getElementById('modal-body').innerHTML = h;
-  document.getElementById('modal-footer').innerHTML =
-    '<button class="btn" onclick="closeModal()">取消</button>' +
-    '<button class="btn btn-primary" onclick="saveLedger(\'' + (a ? a.id : '') + '\')">保存</button>';
-  showModal();
-}
-
-function _ledgerFormValues() {
-  var out = {};
-  document.querySelectorAll('#modal-body [data-lf]').forEach(function (el) {
-    var k = el.dataset.lf;
-    out[k] = (el.type === 'checkbox') ? !!el.checked : el.value;
-  });
-  return out;
-}
-
-function saveLedger(id) {
-  var body = _ledgerFormValues();
-  var p = id ? apiPut('/api/ledger/' + id, body) : apiPost('/api/ledger', body);
-  p.then(function (r) {
-    if (r && r.ok) { closeModal(); showToast(r.msg || '已保存', 'success'); loadLedger(); }
-    else showToast('保存失败: ' + ((r && r.error) || ''), 'error');
-  });
-}
-
-function deleteLedger(id) {
-  var a = _ledgerById(id);
-  var who = a ? ((a.device_name || '') + ' / ' + (a.nickname || '') + ' / ' + (a.douyin_id || '')) : id;
-  if (!confirm('删掉这条账号？\n\n' + who + '\n\n删掉之后：任务从台账取号就取不到它了。')) return;
-  apiDelete('/api/ledger/' + id).then(function (r) {
-    if (r && r.ok) { showToast(r.msg || '已删除', 'success'); loadLedger(); loadLedgerCounts(); }
-    else showToast('删除失败: ' + ((r && r.error) || ''), 'error');
-  });
-}
-
-// ================== 粘贴导入 ==================
-function openLedgerImport() {
-  document.getElementById('modal-title').textContent = '粘贴导入账号台账';
-  document.getElementById('modal-box').classList.add('wide-modal');
-  document.getElementById('modal-body').innerHTML =
-    '<div class="help" style="margin-bottom:8px">' +
-    '把 Excel 里的表格<b>连表头一起</b>复制，粘到下面。首行是列名，顺序随意、缺列留空。<br>' +
-    '认得的列名：<code>设备号 / 手机号 / 账号名称 / 抖音号 / 注册时间 / 卡在机内 / 可发视频 / 简介 / 备注</code>' +
-    '（认不出的列会被忽略）。<b>没有表头</b>时按上面这个顺序解析。<br>' +
-    '「卡在机内 / 可发视频」认 <code>是/有/1</code> 与 <code>否/空</code>。' +
-    '</div>' +
-    '<div class="form-row" style="align-items:end">' +
-    '<div class="form-group"><label>分隔符</label>' +
-    '<select class="form-control" id="ledger-import-delim">' +
-    '<option value="tab">Tab（Excel 直接粘贴）</option>' +
-    '<option value="|">竖线 |</option><option value=",">逗号 ,</option></select></div>' +
-    '<div class="form-group"><label>遇到已存在的抖音号</label>' +
-    '<select class="form-control" id="ledger-import-mode">' +
-    '<option value="skip">跳过（不动已有记录）</option>' +
-    '<option value="overwrite">覆盖（整行替换，空单元格会覆盖掉原值）</option></select></div>' +
-    '</div>' +
-    '<div class="form-group"><textarea id="ledger-import-text" class="form-control" rows="10" ' +
-    'style="font-family:var(--mono);font-size:12px" placeholder="设备号&#9;手机号&#9;账号名称&#9;抖音号&#9;注册时间&#9;卡在机内&#9;可发视频&#9;简介&#9;备注&#10;A01&#9;13800000000&#9;示例账号&#9;35000000001&#9;2026/9/24&#9;否&#9;是&#9;&#9;"></textarea></div>' +
-    '<div id="ledger-import-result"></div>';
-  document.getElementById('modal-footer').innerHTML =
-    '<button class="btn" onclick="closeModal()">取消</button>' +
-    '<button class="btn" onclick="ledgerImport(true)">先预览</button>' +
-    '<button class="btn btn-primary" onclick="ledgerImport(false)">直接导入</button>';
-  showModal();
-}
-
-function ledgerImport(dryRun) {
-  var text = (document.getElementById('ledger-import-text') || {}).value || '';
-  if (!text.trim()) { showToast('先粘贴表格内容', 'error'); return; }
-  var delim = (document.getElementById('ledger-import-delim') || {}).value || 'tab';
-  var mode = (document.getElementById('ledger-import-mode') || {}).value || 'skip';
-  var box = document.getElementById('ledger-import-result');
-  if (box) box.innerHTML = '<div class="text-muted">' + (dryRun ? '解析中…' : '导入中…') + '</div>';
-  apiPost('/api/ledger/import', { text: text, delimiter: delim, mode: mode, dry_run: !!dryRun })
-    .then(function (r) {
-      if (!r || !r.ok) {
-        if (box) box.innerHTML = '<div class="text-danger">失败：' + esc((r && r.error) || '') + '</div>';
-        return;
-      }
-      renderImportResult(r);
-      if (!dryRun) { loadLedger(); loadLedgerCounts(); }
-    });
-}
-
-var _IMP_ACTION = {
-  add: ['label-success', '新增'], update: ['label-warning', '覆盖'],
-  skip: ['label-default', '跳过'], fail: ['label-danger', '失败']
-};
-
-function renderImportResult(r) {
-  var box = document.getElementById('ledger-import-result');
-  if (!box) return;
-  var c = r.counts || {};
-  var head = '<div style="margin:10px 0 6px"><b>' + (r.dry_run ? '预览结果（还没有写入）' : '导入结果')
-    + '</b>　共 ' + (c.total || 0) + ' 行：新增 ' + (c.added || 0) + ' · 覆盖 ' + (c.updated || 0)
-    + ' · 跳过 ' + (c.skipped || 0) + ' · 失败 ' + (c.failed || 0) + '</div>';
-  var rows = (r.rows || []).map(function (x) {
-    var a = _IMP_ACTION[x.action] || ['label-default', x.action];
-    var msg = x.error || (x.warns && x.warns.length ? x.warns.join('；') : '');
-    return '<tr><td>' + esc(x.line) + '</td>' +
-      '<td><span class="label ' + a[0] + '">' + a[1] + '</span></td>' +
-      '<td>' + esc(x.device_name || '') + '</td>' +
-      '<td style="font-family:var(--mono)">' + esc(x.douyin_id || '') + '</td>' +
-      '<td>' + esc(x.nickname || '') + '</td>' +
-      '<td style="color:#f59e0b">' + esc(msg) + '</td></tr>';
-  }).join('');
-  var errs = (r.errors || []).map(function (e) {
-    return '<li>第 ' + esc(e.line) + ' 行：' + esc(e.reason) + '</li>';
-  }).join('');
-  box.innerHTML = head +
-    _importErrorsNote(errs) +
-    '<div style="max-height:320px;overflow:auto"><table class="table table-sm">' +
-    '<thead><tr><th>行</th><th>动作</th><th>设备号</th><th>抖音号</th><th>账号名称</th><th>说明</th></tr></thead>' +
-    '<tbody>' + (rows || '<tr><td colspan="6" class="empty">没有可导入的行</td></tr>') + '</tbody></table></div>' +
-    (r.dry_run ? '<div class="help">确认没问题后点「直接导入」。</div>' : '');
-}
-
-function _importErrorsNote(errs) {
-  return errs ? ('<div class="help" style="color:#f59e0b">这些行被跳过了（不会导入）：<ul>' + errs + '</ul></div>') : '';
-}
-
-// ================== 设备维度：设备池那一列的"账号 N" ==================
-function loadLedgerCounts() {
-  return apiGet('/api/ledger/by_device').then(function (r) {
-    if (r && r.ok) { _ledgerCounts = r.counts || {}; _ledgerDevices = r.devices || {}; }
-    return _ledgerCounts;
-  }).catch(function () { return _ledgerCounts; });
-}
-
-function ledgerCell(serial, name) {
-  var n = _ledgerCounts[name] || 0;
-  if (!n) return '<span class="label label-default">未登记</span>';
-  return '<button class="btn btn-xs" onclick="showDeviceAccounts(\'' + esc(name) + '\')">' + n + ' 个号</button>';
-}
-
-function showDeviceAccounts(name) {
-  var g = _ledgerDevices[name];
-  if (!g) {
-    // 没缓存过就现拉一次（例如直接打开设备池）
-    loadLedgerCounts().then(function () { showDeviceAccounts(name); });
-    return;
-  }
-  document.getElementById('modal-title').textContent = name + ' 上的账号（' + (g.count || 0) + ' 个）';
-  var rows = (g.accounts || []).map(function (a) {
-    return '<tr><td>' + esc(a.nickname || '-') + '</td>' +
-      '<td style="font-family:var(--mono)">' + esc(a.douyin_id || '-') + '</td>' +
-      '<td style="font-family:var(--mono)">' + esc(a.phone || '-') + '</td>' +
-      '<td>' + _yn(a.sim_in_device) + '</td><td>' + _yn(a.can_post_video) + '</td>' +
-      '<td>' + esc(a.registered_at || '-') + '</td><td>' + _clip(a.note, 16) + '</td></tr>';
-  }).join('');
-  document.getElementById('modal-body').innerHTML =
-    '<div style="max-height:60vh;overflow:auto"><table class="table table-sm">' +
-    '<thead><tr><th>账号名称</th><th>抖音号</th><th>手机号</th><th>卡在机内</th><th>可发视频</th><th>注册时间</th><th>备注</th></tr></thead>' +
-    '<tbody>' + (rows || '<tr><td colspan="7" class="empty">这台设备还没有登记账号</td></tr>') + '</tbody></table></div>' +
-    '<div class="help">在「账号」页可以增删改；设备端 Agent 的「身份大字页」显示的就是这些。</div>';
-  document.getElementById('modal-footer').innerHTML = '<button class="btn" onclick="closeModal()">关闭</button>';
-  showModal();
-}

static/admin/release.js

@@ -1,14 +1,14 @@
-// 视频发布计划（「账号 → 发布计划」页）
+// 视频发布计划（「发布计划」页）
 // 数据在 video_plan 表，服务层 core/video_plan.py，接口 /api/video_plan/*（web/video_plan_api.py）。
 //
-// 这一页要解决的事：人员批量传视频与标题 → 自动按文件名配到账号上 → 时间线看每天谁要发、
+// 这一页要解决的事：人员批量传素材（视频/图片）与标题 → 自动按文件名配到账号上 → 时间线看每天谁要发、
 // 发到哪一步了 → 到日子由任务把视频推到手机相册、走抖音发布流程 → 发布后抓分享链接存下来
 // （平台不长期囤视频，链接才是长期资产；后续铺评论也是用这个链接打开视频）。
 //
 // 三条与安全有关的约定（别改）：
 //   ① 上传**串行**：并发会打乱"无编号按顺序配"的顺序，还会撞 SQLite 回退模式的写锁
 //   ② 上传前把队列**按文件名排序**并给用户看一遍顺序（FileList 的顺序在 Windows 上不稳定）
-//   ③ 界面上同时显示"视频文件名"与"标题" —— 配错对这一眼就能看出来
+//   ③ 界面上同时显示"素材文件名"与"标题" —— 配错对这一眼就能看出来
 var _rpRows = [], _rpDays = [], _rpStats = {}, _rpDisk = {}, _rpToday = '';
 var _rpTimer = null;
 
@@ -66,8 +66,8 @@ function renderReleaseStats() {
   if (!el) return;
   var s = _rpStats || {}, d = _rpDisk || {};
   var lowDisk = d.free && d.free < 2 * (1 << 30);
-  el.innerHTML = '今天要发 <b>' + (s.today_ready || 0) + '</b> 个'
-    + '（' + (s.today_devices || 0) + ' 台） · 今天已发 <b>' + (s.today_done || 0) + '</b>'
+  el.innerHTML = '今天要发 <b>' + (s.today_ready || 0) + '</b> 条'
+    + '（' + (s.today_devices || 0) + ' 个号） · 今天已发 <b>' + (s.today_done || 0) + '</b>'
     + ' · 待标题 ' + (s.pending || 0)
     + ' · 过期未发 ' + (s.overdue || 0)
     + (s.unknown ? ' · <span style="color:#f59e0b">结果未知 ' + s.unknown + '</span>' : '')
@@ -81,7 +81,7 @@ function renderReleaseTimeline() {
   if (!box) return;
   if (!_rpDays.length) {
     box.innerHTML = '<div class="empty" style="padding:20px;text-align:center">'
-      + '这个范围里没有计划 —— 点「上传视频」把素材传进来</div>';
+      + '这个范围里没有计划 —— 点「上传视频/图片」把素材传进来</div>';
     return;
   }
   box.innerHTML = _rpDays.map(function (day) {
@@ -97,14 +97,17 @@ function renderReleaseTimeline() {
 }
 
 function rpCard(p) {
-  var acc = '<b>' + esc(p.device_name || '?') + '</b>　' + esc(p.nickname || '')
-    + '　<span class="text-muted" style="font-family:var(--mono)">'
-    + esc(p.douyin_id || p.phone) + '</span>';
+  var acc = '<b>' + esc(p.nickname || '?') + '</b>'
+    + (p.posted_device_name
+        ? '　<span class="text-muted" style="font-size:12px">由 ' + esc(p.posted_device_name) + ' 发出</span>'
+        : '');
   var video = p.video_name
     ? '<span title="' + esc(p.video_name) + '">' + esc(p.video_name.slice(0, 40)) + '</span>'
       + (p.video_deleted_at ? ' <span class="label label-default">素材已清理</span>' : '')
     : '<span class="label label-default">素材已清理</span>';
-  var title = p.title ? esc(p.title.slice(0, 30)) : '<span style="color:#f59e0b">⚠ 缺标题</span>';
+  var title = p.title ? esc(p.title.slice(0, 30))
+    : (p.body ? '' : '<span style="color:#f59e0b">⚠ 缺标题/正文</span>');
+  var body = p.body ? esc(p.body.slice(0, 60)) : '<span class="text-muted">（无正文）</span>';
   var link = p.share_url
     ? '<a href="' + esc(p.share_url) + '" target="_blank" style="font-family:var(--mono)">'
       + esc(p.share_url.replace('https://v.douyin.com/', '…/')) + '</a>'
@@ -126,7 +129,7 @@ function rpCard(p) {
   if (p.status === 'failed' || p.status === 'unknown') {
     ops.push('<button class="btn btn-xs" onclick="rpRetry(\'' + p.id + '\')" data-perm="devices">改回待发</button>');
   }
-  ops.push('<button class="btn btn-xs" onclick="rpEditTitle(\'' + p.id + '\')" data-perm="devices">改标题</button>');
+  ops.push('<button class="btn btn-xs" onclick="rpEditTitle(\'' + p.id + '\')" data-perm="devices">改名字/标题/正文</button>');
   if (p.status !== 'done' && p.status !== 'skipped') {
     ops.push('<button class="btn btn-xs" onclick="rpSkip(\'' + p.id + '\')" data-perm="devices">跳过</button>');
   }
@@ -135,7 +138,7 @@ function rpCard(p) {
   var pv = p.push_verify || '';
   var pushTag = !pv ? ''
     : (pv === 'ok'
-        ? ' <span class="label label-success" title="已进相册索引，抖音选视频能看到它">已推送·相册可见</span>'
+        ? ' <span class="label label-success" title="已进相册索引，抖音选素材能看到它">已推送·相册可见</span>'
         : (pv === 'no_index'
             ? ' <span class="label label-warning" title="文件在手机上，但没进相册索引 —— 相册/抖音里可能看不到它">已推送·相册未见</span>'
             : ' <span class="label label-warning">已推送·文件不在</span>'));
@@ -153,8 +156,8 @@ function rpCard(p) {
     + (p.seq_auto ? '(自动)' : '') + '</span> ' + rpStatusLabel(p.status)
     + (p.attempts ? ' <span class="text-muted">已试 ' + p.attempts + ' 次</span>' : '') + pushTag + '</div>'
     + '<div style="white-space:nowrap">' + ops.join(' ') + '</div></div>'
-    + '<div style="margin-top:4px">素材：' + video + '　｜　标题：' + title
-    + (link ? '　｜　' + link : '') + '</div>'
+    + '<div style="margin-top:4px">素材：' + video + '　｜　标题：' + title + '</div>'
+    + '<div style="margin-top:2px">正文：' + body + (link ? '　｜　' + link : '') + '</div>'
     + (p.published_at ? '<div class="text-muted" style="font-size:12px">发布于 ' + esc(p.published_at) + '</div>' : '')
     + warn + '</div>';
 }
@@ -163,24 +166,26 @@ function renderReleaseTable() {
   setListPager('release', {
     data: function () { return _rpRows; },
     filter: function (p, kw) {
-      return ((p.device_name || '') + (p.nickname || '') + (p.phone || '') + (p.douyin_id || '')
-        + (p.title || '') + (p.video_name || '')).toLowerCase().indexOf(kw) >= 0;
+      return ((p.nickname || '') + (p.posted_device_name || '') + (p.device_name || '')
+        + (p.title || '') + (p.body || '') + (p.video_name || '')).toLowerCase().indexOf(kw) >= 0;
     },
     sortValue: function (p, k) { return p[k]; },
     render: function (p) {
-      return '<tr><td>' + esc(p.release_date) + '</td><td>' + esc(p.device_name || '-') + '</td>'
-        + '<td>' + esc(p.nickname || '-') + '／' + esc(p.douyin_id || p.phone) + '</td>'
+      return '<tr><td>' + esc(p.release_date) + '</td><td><b>' + esc(p.nickname || '-') + '</b></td>'
+        + '<td>' + esc(p.posted_device_name || '-') + '</td>'
         + '<td>' + p.seq + (p.seq_auto ? '*' : '') + '</td>'
         + '<td style="max-width:220px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap" title="'
         + esc(p.video_name) + '">' + esc(p.video_name || '-') + '</td>'
         + '<td style="max-width:220px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap" title="'
         + esc(p.title) + '">' + esc(p.title || '-') + '</td>'
+        + '<td style="max-width:260px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap" title="'
+        + esc(p.body) + '">' + esc(p.body || '-') + '</td>'
         + '<td>' + rpStatusLabel(p.status) + '</td>'
         + '<td>' + (p.share_url ? '<button class="btn btn-xs" onclick="rpCopyLink(\'' + esc(p.share_url) + '\')">复制链接</button>' : '-') + '</td>'
-        + '<td><button class="btn btn-xs" onclick="rpEditTitle(\'' + p.id + '\')" data-perm="devices">改标题</button></td></tr>';
+        + '<td><button class="btn btn-xs" onclick="rpEditTitle(\'' + p.id + '\')" data-perm="devices">改名字/标题/正文</button></td></tr>';
     },
     tbody: 'tb-release', pager: 'pager-release', pageSize: 20,
-    empty: '<tr><td colspan="9" class="empty">这个范围里没有计划</td></tr>'
+    empty: '<tr><td colspan="10" class="empty">这个范围里没有计划</td></tr>'
   });
   applyListPager('release');
   initListSearch('release', 'search-release');
@@ -202,24 +207,33 @@ function rpEnsurePolling() {
   }
 }
 
-// ================== 上传：视频 ==================
+// ================== 上传：素材（视频/图片） ==================
 // 文件名规则与服务端一致（这里只做**本地预检**，真正的判定永远以后端为准）
-var _RP_PHONE = /^1\d{10}$/, _RP_DATE = /^\d{8}$/, _RP_SEQ = /^\d{1,3}$/;
+// `名字_日期_编号`：**右锚定** —— 末尾可省编号 → 日期 → 紧挨日期的那一段就是名字
+var _RP_DATE = /^\d{8}$/, _RP_SEQ = /^\d{1,3}$/;
 
 function rpPrecheck(name) {
   var dot = name.lastIndexOf('.');
   var stem = dot > 0 ? name.slice(0, dot) : name;
   var parts = stem.split('_');
-  var phone = '', date = '', seq = '', bad = '';
-  parts.forEach(function (p) {
-    if (!p) { bad = '有空片段'; return; }
-    if (_RP_PHONE.test(p)) { phone = phone || p; }
-    else if (_RP_DATE.test(p)) { date = date || p; }
-    else if (_RP_SEQ.test(p)) { seq = seq || p; }
-    else bad = bad || p;
-  });
-  return { phone: phone, date: date, seq: seq, bad: bad,
-           ok: !!phone && !!date && !bad };
+  var date = '', seq = '', bad = '';
+  if (parts.length >= 3 && _RP_SEQ.test(parts[parts.length - 1])
+      && _RP_DATE.test(parts[parts.length - 2])) {
+    seq = parts.pop(); date = parts.pop();
+  } else if (parts.length >= 2 && _RP_DATE.test(parts[parts.length - 1])) {
+    date = parts.pop();
+  } else {
+    bad = '结尾不是日期或「日期_编号」';
+  }
+  var acct = '';
+  if (parts.length === 1) acct = parts[0].trim();
+  else if (parts.length > 1) bad = bad || '名字前面多了片段';
+  if (!bad) {
+    if (!acct) bad = '名字是空的';
+    else if (acct.indexOf('_') >= 0) bad = '名字里有下划线';
+    else if (/^\d+$/.test(acct)) bad = '名字不能是纯数字';
+  }
+  return { name: acct, date: date, seq: seq, bad: bad, ok: !!acct && !!date && !bad };
 }
 
 function rpPickVideos(input) {
@@ -237,7 +251,7 @@ function rpPickVideos(input) {
 }
 
 function rpShowUploadConfirm(rows) {
-  document.getElementById('modal-title').textContent = '上传视频（' + rows.length + ' 个）';
+  document.getElementById('modal-title').textContent = '上传视频/图片（' + rows.length + ' 个）';
   document.getElementById('modal-box').classList.add('wide-modal');
   var body = '<div class="help" style="margin-bottom:8px">'
     + '确认下面每个文件解析出的账号与日期对不对（<b>传上去就按这个配</b>）。'
@@ -247,8 +261,8 @@ function rpShowUploadConfirm(rows) {
     + rows.map(function (r) {
       var c = r.c;
       var parsed = c.ok
-        ? esc(c.phone) + ' / ' + esc(c.date) + (c.seq ? ' / 编号 ' + esc(c.seq) : ' / <span class="text-muted">编号自动</span>')
-        : '<span style="color:#ef4444">✗ ' + esc(c.bad ? '多了片段 ' + c.bad : (!c.phone ? '缺手机号' : '缺日期')) + '（会被拒收）</span>';
+        ? esc(c.name) + ' / ' + esc(c.date) + (c.seq ? ' / 编号 ' + esc(c.seq) : ' / <span class="text-muted">编号自动</span>')
+        : '<span style="color:#ef4444">✗ ' + esc(c.bad || (!c.name ? '缺名字' : '缺日期')) + '（会被拒收）</span>';
       return '<tr><td>' + (r.idx + 1) + '</td><td>' + esc(r.file.name) + '</td><td>' + parsed
         + '</td><td>' + _fmtSize(r.file.size) + '</td></tr>';
     }).join('') + '</tbody></table></div>'
@@ -371,7 +385,7 @@ function rpShowTitleConfirm(fname, text) {
   document.getElementById('modal-box').classList.add('wide-modal');
   document.getElementById('modal-body').innerHTML =
     '<div class="help" style="margin-bottom:6px">共 ' + lines.length + ' 行有效标题。'
-    + '每行 <code>标题内容_手机号_日期_编号</code>；没写编号的按顺序配到该账号当天还没标题的视频上。</div>'
+    + '每行 <code>标题 || 正文_名字_日期_编号</code>（<code>||</code> 后面是正文，可省略；编号可省，标题里可以有 <code>#话题</code>）；<br>没写编号的按顺序配到该名字当天还没标题的素材上。</div>'
     + '<div style="max-height:50vh;overflow:auto;font-family:var(--mono);font-size:12px;white-space:pre-wrap">'
     + esc(lines.slice(0, 200).join('\n')) + (lines.length > 200 ? '\n…' : '') + '</div>'
     + '<div id="rp-title-result"></div>';
@@ -399,7 +413,7 @@ function rpDoTitles(dry) {
           + '<table class="table table-sm"><thead><tr><th>行</th><th>标题</th><th>账号/日期/编号</th><th>结果</th></tr></thead><tbody>'
           + (r.rows || []).map(function (x) {
             return '<tr><td>' + x.line + '</td><td>' + esc((x.title || '').slice(0, 24)) + '</td>'
-              + '<td>' + esc(x.phone) + ' / ' + esc(x.date) + ' / ' + (x.seq || '-') + '</td>'
+              + '<td>' + esc(x.name) + ' / ' + esc(x.date) + ' / ' + (x.seq || '-') + '</td>'
               + '<td>' + (x.action === 'attach' ? '<span class="label label-success">已配</span>'
                 : x.action === 'skip' ? '<span class="label label-default">跳过</span>'
                 : '<span class="label label-danger">拒收</span>') + ' ' + esc(x.error || '') + '</td></tr>';
@@ -411,25 +425,39 @@ function rpDoTitles(dry) {
 
 // ================== 单条操作 ==================
 function rpPushToDevice(id) {
-  if (!confirm('把这条的素材推到手机？\n\n只推送、不发布 —— 推完状态变「已推送到手机」，'
-    + '标题会同时写进手机剪贴板；之后由你（或你写的任务步骤）在手机上发布，发完点「标记已发布」。')) return;
+  if (!confirm('把这条的素材推到手机？\n\n'
+    + '平台会**按这条计划的名字找设备**：实时看哪台在线设备现在登着这个号，推给它。\n'
+    + '没有设备登着就推不了（先去那台设备上切号）。\n\n'
+    + '只推送、不发布 —— 推完状态变「已推送到手机」，标题写进手机剪贴板；'
+    + '之后由你（或你写的任务步骤）在手机上发布，发完点「标记已发布」。')) return;
   apiPost('/api/video_plan/' + id + '/push', {}).then(function (r) {
     if (r && r.ok) { showToast(r.msg || '已开始推送', 'success'); setTimeout(loadReleasePlan, 1500); }
     else showToast((r && r.error) || '失败', 'error');
   });
 }
 
-// 一键推送：把今天「待发布/失败」的计划全部推到各自手机上（每台设备串行，设备间并行）
+// 一键推送（**按名字找设备**）：把今天「待发布/失败」的计划推给"现在登着对应号"的设备。
+// 没有设备登着的名字**逐条报出来**（人去切号），别让人以为是平台坏了。
 function rpPushAll() {
   var n = (_rpRows || []).filter(function (p) {
     return p.release_date === _rpToday && (p.status === 'ready' || p.status === 'failed');
   }).length;
   if (!confirm('把今天待推送的计划全部推到手机上？\n\n'
     + '现在视图里有 ' + n + ' 条「待发布/失败」的；平台只推今天这一天的（有标题的才推）。\n'
-    + '每台手机串行推、每台之间并行；推完状态会变成「已推送·相册可见 / 已推送·相册未见」。')) return;
-  apiPost('/api/video_plan/push_all', {}).then(function (r) {
-    if (r && r.ok) { showToast(r.msg || '已开始推送', 'success'); setTimeout(loadReleasePlan, 2000); }
-    else showToast((r && r.error) || '失败', 'error');
+    + '平台会**按名字找设备**：哪台在线设备现在登着这个号，就推给谁（同台设备串行推）。\n'
+    + '没有设备登着的号会列出来（先去那台设备上切号）。')) return;
+  apiPost('/api/video_plan/push_by_account', {}).then(function (r) {
+    if (r && r.ok) {
+      showToast(r.msg || '已开始推送', 'success');
+      setTimeout(loadReleasePlan, 2000);
+    } else if (r && r.unmatched && r.unmatched.length) {
+      alert('推不了：' + (r.error || '')
+        + '\n\n逐条原因：\n' + r.unmatched.map(function (u) {
+          return '· ' + u.name + '（' + u.count + ' 条）：' + u.reason;
+        }).join('\n'));
+    } else {
+      showToast((r && r.error) || '失败', 'error');
+    }
   });
 }
 
@@ -477,14 +505,34 @@ function rpDelete(id) {
   });
 }
 
+// 改标题 + 正文（发布页两个框分别填；都按"有没有内容"决定这条是不是「待发布」）
 function rpEditTitle(id) {
   var p = null;
   for (var i = 0; i < _rpRows.length; i++) if (_rpRows[i].id === id) p = _rpRows[i];
-  var cur = p ? (p.title || '') : '';
-  var t = prompt('标题（发布文案）：', cur);
-  if (t === null) return;
-  apiPut('/api/video_plan/' + id, { title: t }).then(function (r) {
-    if (r && r.ok) { showToast(r.msg, 'success'); loadReleasePlan(); } else showToast((r && r.error) || '失败', 'error');
+  document.getElementById('modal-title').textContent = '改名字 / 标题 / 正文';
+  document.getElementById('modal-body').innerHTML =
+    '<div class="help">抖音发布页有两个框：<b>标题</b>（短，用于搜索展示）和<b>正文</b>（文案，可带 #话题）。'
+    + '两个框在任务里各由一个「输入文字」步骤填（取值来源分别选「计划的标题」/「计划的正文」）。</div>'
+    + '<div class="form-group"><label>名字（= 抖音昵称，发布时按它找号）</label>'
+    + '<input class="form-control" id="rp-ed-n" value="' + esc(p ? (p.nickname || '') : '') + '" maxlength="40">'
+    + '<div class="help">文件名写错了、或抖音上改了名，改这里对齐即可（<b>名字里不能有下划线、不能是纯数字</b>）。</div></div>'
+    + '<div class="form-group"><label>标题</label>'
+    + '<input class="form-control" id="rp-ed-t" value="' + esc(p ? (p.title || '') : '') + '" maxlength="100"></div>'
+    + '<div class="form-group"><label>正文（可留空）</label>'
+    + '<textarea class="form-control" id="rp-ed-b" rows="4">' + esc(p ? (p.body || '') : '') + '</textarea></div>';
+  document.getElementById('modal-footer').innerHTML =
+    '<button class="btn" onclick="closeModal()">取消</button>'
+    + '<button class="btn btn-primary" onclick="rpSaveTitleBody(\'' + id + '\')">保存</button>';
+  showModal();
+}
+
+function rpSaveTitleBody(id) {
+  var n = (document.getElementById('rp-ed-n') || {}).value || '';
+  var t = (document.getElementById('rp-ed-t') || {}).value || '';
+  var b = (document.getElementById('rp-ed-b') || {}).value || '';
+  apiPut('/api/video_plan/' + id, { nickname: n, title: t, body: b }).then(function (r) {
+    if (r && r.ok) { closeModal(); showToast(r.msg || '已改', 'success'); loadReleasePlan(); }
+    else showToast((r && r.error) || '失败', 'error');
   });
 }
 
@@ -651,7 +699,7 @@ function rpNewTargetChanged() {
   sel.innerHTML = html || '<option value="">（没有可选项）</option>';
 }
 
-// ============ 发布任务的**就地编辑**（就在「账号 → 发布计划」这一页，不跳任务页）============
+// ============ 发布任务的**就地编辑**（就在「发布计划」这一页，不跳任务页）============
 // 为什么单独做一套：发布任务的步骤是固定的那十几步，用通用编辑器（拖拽画布）编它要来回跳页，
 // 而这一页的人真正要干的只有一件事 —— **把抖音那几个空选择器抓一遍**。
 // 所以这里给一组紧凑表单：改名字/目标/时间/启停 + 逐步改参数（选择器带「抓取元素」）；
@@ -672,14 +720,42 @@ var _RP_FIELDS = {
   wait: [['min', '最短(秒)', 'num'], ['max', '最长(秒)', 'num']],
   input_text: [['text_source', '文案从哪来', 'sel', [['manual', '手填（下面那栏）'],
                 ['release_title', '这条发布计划的标题'],
-                ['release_title_topics', '计划的标题 + 话题']]],
+                ['release_title_topics', '计划的标题 + 话题'],
+                ['release_body', '这条发布计划的正文'],
+                ['release_body_topics', '计划的正文 + 话题'],
+                ['release_title_body', '标题 + 正文（一个框时用）']]],
                ['release_topics', '话题（逗号分隔）', 'text'],
                ['fixed_text', '手填的文案（上面的来源选手填时才用）', 'area']],
   push_release: [['date_source', '发哪天的计划', 'sel', [['today', '今天'], ['fixed', '指定日期']]],
                  ['fixed_date', '指定日期(YYYY-MM-DD)', 'text'],
+                 ['account', '按什么取计划', 'sel', [['name', '本机账号名字（推荐）'],
+                             ['phone', '手填手机号（老路径）']]],
+                 ['account_phone', '手机号（上面选"手填手机号"时填）', 'text'],
                  ['album_dir', '推到手机哪个目录', 'text'],
                  ['to_clipboard', '标题写进手机剪贴板', 'chk'],
                  ['max_same_run', '一次推几条', 'num']],
+  read_account_name: [['selector_type', '选择器类型', 'seltype'],
+                      ['selector_value', '选择器值（抖音「我」页的昵称）', 'selval'],
+                      ['timeout', '超时(秒)', 'num'],
+                      ['on_missing', '读不到时', 'sel', [['fail', '算失败（推荐：宁可不发）'],
+                                     ['skip', '记一句继续']]]],
+  foreach_account: [['date_source', '循环哪天', 'sel', [['today', '今天'], ['fixed', '指定日期']]],
+                    ['fixed_date', '指定日期(YYYY-MM-DD)', 'text'],
+                    ['retry_failed', '失败过的也再试', 'chk'],
+                    ['max_accounts', '最多跑几个号（0=不限）', 'num']],
+  switch_account: [['target', '切到哪个名字', 'sel', [['var:target_name', '本次要发的那条计划的名字'],
+                            ['var:account_name', '刚读到的本机名字'],
+                            ['literal', '下面手填的名字']]],
+                   ['target_value', '手填的名字（上面选"手填"时才用）', 'text'],
+                   ['switch_selector_type', '选择器类型', 'seltype'],
+                   ['switch_selector_value', '选择器值（进「账号切换」列表那一下）', 'selval'],
+                   ['me_selector_value', '「我」页签的定位描述', 'text'],
+                   ['timeout', '超时(秒)', 'num'],
+                   ['wait_after', '切完后等几秒再回读（默认 15）', 'num'],
+                   ['verify', '切完回读校验（对不上就不发）', 'chk'],
+                   ['max_attempts', '最多试几次', 'num'],
+                   ['on_login_page', '遇到登录页', 'sel', [['stop', '停本设备（推荐）'],
+                                     ['continue', '记一句继续']]]],
   mark_release: [['result', '标记为什么结果', 'sel', [['published', '已发布（成功）'],
                   ['failed', '确认没发出去（可重试）'],
                   ['unknown', '拿不准（绝不自动重发）']]],
@@ -692,10 +768,9 @@ var _RP_FIELDS = {
           ['timeout', '超时(秒)', 'num'],
           ['cmp_op', '文本比对', 'sel', [['', '不比对（只看元素在不在）'], ['等于', '等于'],
                      ['不等于', '不等于'], ['包含', '包含'], ['不包含', '不包含']]],
-          ['cmp_source', '候选值来源', 'sel', [['', '手填'], ['device', '本机台账'],
-                         ['all', '全部台账'], ['group', '按设备分组'],
-                         ['release', '本机当前发布计划（要发的那个号）']]],
-          ['cmp_group', '分组名（来源选"按设备分组"时填）', 'text'],
+          ['cmp_source', '候选值来源', 'sel', [['', '手填'],
+                         ['account_target', '本次要发的名字（读名字/循环块给的）'],
+                         ['release', '本机当前发布计划（要发的那条）']]],
           ['cmp_value', '比对的值（一行一个，任一命中即可）', 'area']],
   mark_done: [['selector_type', '选择器类型', 'seltype'], ['selector_value', '选择器值', 'selval']],
   clipboard: [['text', '要放进剪贴板的文字', 'text']],
@@ -802,8 +877,11 @@ function _rpStepRow(s, path, total, idx) {
   var fields = _RP_FIELDS[s.type] || [];
   var body = fields.map(function (f) { return _rpField(s.type, p, f, path); }).join('');
   // 条件判断：命中/未命中两个分支**照样能就地编辑**（发布流程就藏在 then 里）
+  // foreach_account（循环本机待发的号）也是容器 —— 不列进来的话，发布流程整段会被折叠成
+  // 一个"看不见里面"的步骤（实测踩过：用户打开就地编辑发现改不了）
   var nested = '';
-  if (s.type === 'if_el' || s.type === 'loop' || s.type === 'group') {
+  if (s.type === 'if_el' || s.type === 'loop' || s.type === 'group'
+      || s.type === 'foreach_account') {
     [['then', '命中时（then）'], ['else', '没命中时（else）'], ['children', '里面的步骤']].forEach(function (pair) {
       var k = pair[0];
       if (!(p[k] instanceof Array)) return;

static/admin/tools.js

@@ -517,13 +517,9 @@ async function loadDevPool(){
   const tb=document.getElementById('tb-devpool');
   const status=document.getElementById('devpool-status');
   if(!tb)return;
-  tb.innerHTML='<tr><td colspan="9" class="empty">加载中...</td></tr>';
+  tb.innerHTML='<tr><td colspan="8" class="empty">加载中...</td></tr>';
   const r=await apiGet('/api/devices/pool');
-  if(!r||!r.ok){tb.innerHTML='<tr><td colspan="9" class="empty">加载失败</td></tr>';return;}
-  // 账号台账：这台设备登记了几个号（顺手把明细也缓存下来，点开就弹）
-  if(typeof loadLedgerCounts==='function'){
-    try{ await loadLedgerCounts(); }catch(e){}
-  }
+  if(!r||!r.ok){tb.innerHTML='<tr><td colspan="8" class="empty">加载失败</td></tr>';return;}
   let rows=r.devices||[];
   // 在线优先排序；「只看在线」勾选时过滤掉离线（IP 换了/长期离线的旧条目不再碍眼）
   const onlyOnline=document.getElementById('devpool-filter-online')
@@ -556,10 +552,6 @@ async function loadDevPool(){
       '<td>'+online+'</td>'+
       '<td>'+st+'</td>'+
       '<td style="text-align:center">'+fp+'</td>'+
-      // 账号台账（「账号」页维护）：0 个号显示"未登记"而不是空白 ——
-      // 空白会让人以为功能坏了，而"未登记"是明确信息
-      '<td style="white-space:nowrap">'+(typeof ledgerCell==='function'
-        ? ledgerCell(d.serial, d.name||'') : '—')+'</td>'+
       '<td style="color:var(--text-light)">'+esc(d.created_at||'')+'</td>'+
       '<td style="white-space:nowrap">'+
         '<button class="btn btn-xs" onclick="renamePoolDev(\''+esc(d.serial)+'\')">改名</button> '+

tasks/generic/publish_flow.py

@@ -75,13 +75,17 @@ def _sh(d, cmd):
 
 
 # ================== 原语 ==================
-def push_video(d, serial, local_path, plan_id, album_dir=ALBUM_DIR, ext=".mp4"):
+def push_video(d, serial, local_path, plan_id, album_dir=ALBUM_DIR, ext=""):
     """把平台素材推到手机相册目录，并把手机上的时间改成"现在"。返回 (remote_path, error)。
 
-    改时间是为了**排序**：相册/抖音的选视频页按时间倒序，
+    改时间是为了**排序**：相册/抖音的选素材页按时间倒序，
     `adb push` 保留的是**本地文件的修改时间**（推一个 3 天前上传的素材 → 排在很后面），
-    那"点第一个缩略图 = 刚推的那个"就不成立、可能点到别的视频。所以推完 `touch` 一下。
+    那"点第一个缩略图 = 刚推的那个"就不成立、可能点到别的素材。所以推完 `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)
@@ -178,6 +182,7 @@ def scan_media(d, remote):
 
 
 def drop_old_copies(d, plan_id, keep, ext=".mp4"):
+    """（`ext` 由 `push_video` 按素材真实扩展名传进来：视频/图片各删各的旧副本）"""
     """把**同一个计划**在平台用过别的目录里的旧副本删掉（精确文件名，绝不通配）。
 
     为什么要删：换了推送目录之后，老目录里的同名副本还在相册里（实测一个 plan id 躺了 3 份），
@@ -354,7 +359,8 @@ def push_one(serial, plan, opts=None, log=None):
                     f"—— 后面用「粘贴」步骤就能填进抖音")
             except Exception as e:
                 log(f"标题写剪贴板失败（不影响推送）: {e}")
-        vp.mark_pushed(plan_id, remote=remote, verify=verify)
+        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:

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
@@ -41,7 +42,7 @@ from core.device_worker import BaseWorker, _update_status
 from core.u2_helper import (ensure_app_running, wait_for_app_home, random_sleep,
                            screen_is_on, current_package)
 from core.logger import get_logger
-from core import notifier, step_log, humanize, patrol, gesture, dedup, ledger
+from core import notifier, step_log, humanize, patrol, gesture, dedup
 
 _log = get_logger("task.generic")
 
@@ -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": ""}},
@@ -119,9 +130,22 @@ STEP_TYPES = [
                 "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": "device", "account_phone": "",
+                "account": "name", "account_phone": "",
                 "album_dir": "/sdcard/DCIM/Camera", "to_clipboard": True,
                 "retry_failed": True, "max_same_run": 1}},
     {"type": "mark_release", "label": "标记发布结果", "icon": "🏁",
@@ -244,6 +268,11 @@ class GenericStepsWorker(BaseWorker):
         # 保证"检查"与"记账"用的是**同一个身份字符串**（否则 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 内部标识，用来记"下次到点 / 上次命中"两个节奏
@@ -356,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）不计入操作计数，避免监控显示噪音
-        if stype not in ("loop", "group", "if_el"):
+        # 容器步骤（loop/group/if_el/foreach_account）不计入操作计数，避免监控显示噪音
+        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 次操作"
@@ -829,21 +858,25 @@ class GenericStepsWorker(BaseWorker):
         · 取 0 个号时**必须留痕**：候选为空 ⇒ 这一步永远走 else 分支，而任务本身
           "跑完了、显示成功"，不写日志就只能靠人猜。
         · ⚠ 这里产出的只是**比对用的文本**，绝不参与去重 identity：
-          身份是元素原文逐字算 key，台账里是纯号，格式不同会让去重静默失效
-          （见 core/ledger.py 顶部的警告）。
+          身份是元素原文逐字算 key，候选值格式不同（`小王` vs `昵称：小王`）会让
+          去重静默失效（见 core/dedup.py 的 build_key）。
         """
         source = str(params.get("cmp_source") or "").strip()
         manual = split_cmp_values(manual_raw)
         if source == "release":
-            # 「发布计划」：本机**下一条将要推送**的那条计划（推送前校验账号就靠它）。
-            # 候选值给两个：抖音号（纯号）+ 账号名称 —— 元素原文可能是
-            # `抖音号：35377983067`，也可能只显示昵称，两个都可命中（OR 语义）。
+            # 「发布计划」：本机**下一条将要推送**的那条计划的**名字**（推送前校验账号就靠它）。
             ids, note = self._release_candidates()
-        elif source in ("device", "all", "group"):
-            ids, note = ledger.douyin_ids(
-                source, serial=self.serial,
-                device_name=(self.ctx or {}).get("device_name", ""),
-                group=str(params.get("cmp_group") or "").strip())
+        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]
@@ -852,48 +885,408 @@ class GenericStepsWorker(BaseWorker):
                 f"[{self.serial}] 条件判断取号为空（来源 {source}）：{note}；手填候选 "
                 f"{len(manual)} 个 → "
                 + ("仅用手填值" if manual else "候选为空，这一步将永远不命中（走未找到分支）"))
-        where = "发布计划" if source == "release" else f"台账({source})"
-        src_txt = (f"候选来自{where} {len(ids)} 个号" if ids
-                   else f"{where}取号为空：{note}")
+        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 _release_targets(self, params):
-        """推送/标记步骤共用的"取本机账号手机号"逻辑。返回 (phones, who)。"""
-        from core import ledger
+    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()
-        if (params.get("account") or "device") == "phone" and phone:
-            return [phone], f"指定手机号 {phone}"
-        _, rows, note = ledger.resolve_device(
-            serial=self.serial, device_name=(self.ctx or {}).get("device_name", ""))
-        return [r.get("phone") for r in rows if r.get("phone")], f"本机账号（{note}）"
+            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 跳过并通知。
-
-        给两个候选值是刻意的：元素原文可能是 `抖音号：35377983067`，也可能只显示昵称，
-        两个都算命中（候选值之间是 OR）。配「包含」运算符即可。
+        命中（当前登的就是要发的那个名字）→ 走 then 去推送/发布；未命中 → else 跳过并通知。
+        配「包含」运算符即可。
         """
         from core import video_plan as vp
         plan = getattr(self, "_last_release", None)
         src = "本次已推送的那条"
         if not plan:
-            phones, _who = self._release_targets({})
-            plan = vp.peek_for_device(phones, vp._today()) if phones else None
+            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("douyin_id"), plan.get("nickname")) if c]
-        note = (f"{src}计划的抖音号 {plan.get('douyin_id')}"
-                f"（{plan.get('nickname') or plan.get('phone')} "
-                f"{plan.get('release_date')} #{plan.get('seq')}）")
+        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):
         """推送发布视频：把本机某天待发的计划**推到手机相册**（**不发布**）。
 
@@ -901,10 +1294,13 @@ class GenericStepsWorker(BaseWorker):
         抖音里怎么发（打开→点+→相册→选视频→下一步→粘贴标题→发布）由你在这条步骤
         **后面自己画步骤**，最后放一个「标记发布结果」回写状态。
 
-        参数：`date_source`(today/fixed) `fixed_date` `account`(device/phone) `account_phone`
+        参数：`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
@@ -912,12 +1308,19 @@ class GenericStepsWorker(BaseWorker):
 
         date = ((params.get("fixed_date") or "").strip()
                 if params.get("date_source") == "fixed" else vp._today()) or vp._today()
-        phones, who = self._release_targets(params)
-        if not phones:
-            _log.warning(f"[{self.serial}] 推送发布视频：本机没有台账账号 → 跳过")
-            self.set_action("本机没有台账账号 → 跳过")
+        mode, values, who = self._release_scope(params)
+        if not values:
+            _log.warning(f"[{self.serial}] 推送发布视频：{who}")
+            self.set_action(f"跳过：{who}")
             return None
-        plans = vp.take_for_device(phones, date,
+        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:
@@ -926,7 +1329,9 @@ class GenericStepsWorker(BaseWorker):
             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}
+                "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():
@@ -978,8 +1383,8 @@ class GenericStepsWorker(BaseWorker):
 
         plan = getattr(self, "_last_release", None)
         if not plan:
-            phones, _who = self._release_targets(params)
-            plan = vp.last_pushed_for_device(phones) if phones else None
+            mode, values, _who = self._release_scope(params)
+            plan = self._release_fetch(mode, values, how="last")
         if not plan:
             _log.warning(f"[{self.serial}] 标记发布结果：找不到对应的计划行 → 跳过"
                          f"（前面要先有一个「推送发布视频」步骤）")
@@ -993,13 +1398,15 @@ class GenericStepsWorker(BaseWorker):
         why = (params.get("why") or "").strip()
 
         # 手机上的素材：先删再回写状态 —— 删失败不影响发布结论。
-        # 远程路径是**确定的**（{相册目录}/{计划id}.mp4），所以这里能直接算出来，
-        # 不用把"上次推到哪"存进库（存了还得担心不一致）
+        # 路径优先用**推送时记下的** `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
-                flow.clean_phone_video(dd, f"{album}/{plan['id']}.mp4")
+                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}")
 
@@ -1317,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:
@@ -1376,28 +1855,30 @@ class GenericStepsWorker(BaseWorker):
           · `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_title", "release_title_topics"):
+        if src in RELEASE_TEXT_SOURCES:
             from core import video_plan as vp
             plan = getattr(self, "_last_release", None)
             if not plan:
-                phones, _who = self._release_targets(params)
-                plan = vp.last_pushed_for_device(phones) if phones else None
+                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 ""
-                    if src == "release_title_topics" else "")
+                    plan, params.get("release_topics") or "",
+                    key=RELEASE_TEXT_SOURCES[src])
                 self._last_release = self._last_release or plan
-                _log.info(f"[{self.serial}] 输入文字取计划标题："
-                          f"{plan.get('nickname') or plan.get('phone')} "
+                _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}] 输入文字：本机没有可用的发布计划标题 → 跳过"
+                _log.warning(f"[{self.serial}] 输入文字：本机没有可用的发布计划内容 → 跳过"
                              f"（前面要先有「推送发布视频」步骤）")
                 return None
         if not text:
@@ -1433,7 +1914,7 @@ class GenericStepsWorker(BaseWorker):
                 _log.warning(f"[{self.serial}] input_text 失败: {e2}")
         # 取计划标题时**必须回读校验**：抖音的 EditText 有时不吃 send_keys，
         # 不校验就可能发出一篇空文案而每一步都显示成功
-        if src in ("release_title", "release_title_topics"):
+        if src in RELEASE_TEXT_SOURCES:
             return self._verify_input(d, text, clear_first)
         return None
 

templates/admin/monitor.html

@@ -511,9 +511,9 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
   {% endif %}
   <div class="tabs">
     <button class="tab active" data-tab="monitor" onclick="showTab('monitor')">监控</button>
-    <button class="tab" data-tab="account" onclick="showTab('account')" data-perm="devices">账号</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>
@@ -582,65 +582,20 @@ 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-account" class="tab-panel">
-  <div class="page-title">账号</div>
-  <div class="page-sub">每台设备上登录的抖音账号（谁在哪台机器上、卡在不在机内、能不能发视频）</div>
+<!-- ========== Tab: 发布计划 ========== -->
+<div id="tab-plan" class="tab-panel">
+  <div class="page-title">发布计划</div>
+  <div class="page-sub">每个视频 = 一条计划：<b>文件名里的名字</b>（= 抖音昵称）+ 发布日期 + 编号，
+    到日子由任务推到手机、按名字找设备/账号发布（谁在机内、能不能发视频由运行时现场读名字判断）</div>
 
-  <div class="sub-tabs">
-    <button class="sub-tab active" data-sub="ledger" onclick="showSubTab('account','ledger')">账号台账</button>
-    <button class="sub-tab" data-sub="plan" onclick="showSubTab('account','plan')">发布计划</button>
-  </div>
-
-  <!-- 子分栏 1：账号台账 -->
-  <div class="sub-panel active" id="account-sub-ledger">
-  <div class="toolbar">
-    <button class="btn btn-primary" onclick="openLedgerModal('')" data-perm="devices">新增账号</button>
-    <button class="btn" onclick="openLedgerImport()" data-perm="devices">粘贴导入</button>
-    <button class="btn" onclick="loadLedger()">刷新</button>
-    <select class="form-control" id="ledger-device" style="width:140px" onchange="ledgerDeviceChanged()">
-      <option value="">全部设备</option>
-    </select>
-    <input class="form-control list-search" id="search-ledger" placeholder="搜索设备号/账号名/抖音号/手机号...">
-    <span class="text-muted" id="ledger-stats"></span>
-  </div>
-
-  <table class="table">
-    <thead><tr>
-      <th data-sort="device_name" onclick="_lpSort('ledger','device_name')">设备号</th>
-      <th data-sort="nickname" onclick="_lpSort('ledger','nickname')">账号名称</th>
-      <th data-sort="douyin_id" onclick="_lpSort('ledger','douyin_id')">抖音号</th>
-      <th>手机号</th>
-      <th>注册时间</th>
-      <th>卡在机内</th>
-      <th>可发视频</th>
-      <th>简介</th>
-      <th>备注</th>
-      <th>操作</th>
-    </tr></thead>
-    <tbody id="tb-ledger"></tbody>
-  </table>
-  <div class="list-pager" id="pager-ledger"></div>
-
-  <div class="help">
-    这张台账有三个用处：① 人在机器旁时对照（手机端 Agent 的「身份大字页」也会显示本机账号）；
-    ② 任务的「条件判断」可以直接从这里取号（编辑器里把<b>候选值来源</b>选成「本机台账」，
-    就不用把几十个号手写进去）；③ 设备池里能看到每台登记了几个号。<br>
-    ⚠ 台账里的抖音号是<b>纯号</b>（如 <code>35377983067</code>），只当"比对用的候选值"。
-    <b>不要</b>拿它去填「去重」的身份元素 —— 身份比对的是元素原文
-    （<code>抖音号：35377983067</code>），格式不同会让去重<b>静默失效</b>。
-  </div>
-  </div><!-- /account-sub-ledger -->
-
-  <!-- 子分栏 2：视频发布计划 -->
-  <div class="sub-panel" id="account-sub-plan">
+  <div>
     <div class="toolbar" style="flex-wrap:wrap">
       <button class="btn btn-primary" onclick="document.getElementById('rp-video-input').click()"
-              data-perm="devices">上传视频</button>
+              data-perm="devices">上传视频/图片</button>
       <button class="btn" onclick="document.getElementById('rp-title-input').click()"
-              data-perm="devices">上传标题</button>
+              data-perm="devices">上传标题/正文</button>
       <button class="btn btn-primary" onclick="rpPushAll()" data-perm="devices"
-              title="把今天所有「待发布/失败」的计划按设备推到手机上（每台设备串行推）">一键推送（今天）</button>
+              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()">
@@ -656,7 +611,7 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
         <option value="failed,unknown">失败/未知</option>
         <option value="skipped">已跳过</option>
       </select>
-      <input class="form-control list-search" id="search-release" placeholder="搜索账号/抖音号/标题/文件名...">
+      <input class="form-control list-search" id="search-release" placeholder="搜索名字/标题/文件名...">
       <span class="text-muted" id="rp-stats"></span>
     </div>
 
@@ -682,18 +637,18 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
       <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><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>（编号可省略，日期如 <code>20260912</code> 就是发布日期）；
-      标题 txt 每行 <code>标题内容_手机号_日期_编号</code>（标题里可以有下划线，<code>#</code> 开头的行忽略）。
-      <b>手机号必须在「账号台账」里</b>，否则拒收。<br>
-      上传后自动按 (手机号, 日期, 编号) 配对：有编号按编号精确对，没编号按顺序配 ——
+      素材文件名规则 <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>校验进了索引、
       把标题写进手机剪贴板）；**抖音里怎么发由你在任务里自己写步骤** ——
@@ -704,9 +659,9 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
       要先到抖音里看一眼，再用「已发出 / 未发出」裁决（平台不会自动重发）。
     </div>
 
-    <input type="file" id="rp-video-input" multiple accept="video/*" style="display:none" onchange="rpPickVideos(this)">
+    <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><!-- /account-sub-plan -->
+  </div>
 </div>
 
 <!-- ========== Tab 2: 任务 ========== -->
@@ -1412,7 +1367,6 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
       <thead><tr>
         <th>serial</th><th>名称</th><th>型号</th><th>在线</th><th>状态</th>
         <th title="设备指纹（ro.serialno）：采集到之后，设备换 IP 才能被自动认领">指纹</th>
-        <th title="这台设备在「账号」页登记了几个抖音号（点数字看明细）">账号</th>
         <th>添加时间</th><th>操作</th>
       </tr></thead>
       <tbody id="tb-devpool"></tbody>
@@ -1610,7 +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/ledger.js"></script>
 <script src="/static/admin/release.js"></script>
 </body>
 </html>

web/device_agent_api.py

@@ -17,9 +17,7 @@
 
 管理端接口在文件后半段（`/api/agent-store/*`，走正常登录 + 权限）。
 """
-import base64
 import hmac
-import json
 import os
 import secrets
 import time
@@ -27,7 +25,7 @@ import time
 from flask import Blueprint, jsonify, request, send_file
 
 from config import APK_DIR
-from core import device_pool, ledger
+from core import device_pool
 from core.db_config import meta_get, meta_set
 from core.logger import get_logger
 from web.auth import PERM_APKS, PERM_DEVICES, perm_required
@@ -319,32 +317,9 @@ def api_agent_show_info():
                 "--es", "server", server]
         if ip:
             args += ["--es", "ip", ip]
-        # 本机账号台账（可选块）：身份页顺带显示"这台登的是哪几个号"。
-        # **中文必须 base64**（§5.1：adb shell 直传中文/特殊字符会变形）；
-        # `_adb` 是 argv 形式、不过 shell，base64 里的 +/= 安全 —— 将来谁把
-        # 这里改成 shell=True 就会静默坏掉，别改。
-        # 台账里没有这台设备时**整个 extra 不发**（设备端"没有这个 extra"=
-        # 本来就没登记，跟"发了但解不开"能区分开），原因随响应体的 warn 回给操作者。
+        # 账号台账块（`accounts_b64`）随账号管理一起下线了：身份页只显示
+        # 名称/地址/平台地址这些设备信息。老版本 Agent 收到"没有这个 extra"照常显示。
         warn = ""
-        try:
-            acc = ledger.agent_accounts(serial, device_name=name,
-                                        include_phone=bool(data.get("include_phone")))
-            if acc.get("accounts"):
-                b64, acc = _encode_accounts(acc)
-                if len(b64) + sum(len(a) for a in args) < _ARGS_CMD_MAX:
-                    args += ["--es", "accounts_b64", b64]
-                    _log.info("身份页附账号：%s 共 %s 个号（accounts_b64 %d 字节）",
-                              serial, acc.get("shown"), len(b64))
-                else:
-                    warn = "账号台账过大，未随身份页下发"
-                    _log.warning("身份页未附账号：%s %s（%d 字节）", serial, warn, len(b64))
-            else:
-                warn = f"这台设备在账号台账里没有账号（{acc.get('note') or '未匹配到设备名'}）"
-                _log.warning("身份页未附账号：%s %s", serial, warn)
-        except Exception as e:
-            # 台账坏了不能把"显示身份"这个动作弄坏：跳过该 extra，只回告警
-            warn = f"账号台账读取失败：{e}"
-            _log.warning("身份页附账号失败 %s: %s", serial, e)
 
     # 先点亮屏幕、解除锁屏：设备息屏时 am start 会把大字页开在锁屏**后面**，
     # 人看到的还是一片黑（实测踩过）——这正是原来"定位"按钮里的"点亮屏幕"那一步
@@ -373,33 +348,6 @@ def api_agent_show_info():
     return jsonify(resp)
 
 
-# accounts_b64 的预算：44 条 × ~90 字节 ≈ 4KB，base64 后 ≈ 5.3KB，余量充足。
-# 再加一道**命令行总长**闸（Windows CreateProcess 上限 ~32767）。
-ACCOUNTS_PAYLOAD_MAX = 20000
-_ARGS_CMD_MAX = 28000
-
-
-def _encode_accounts(acc):
-    """把账号块压成 base64（超预算**按整条丢**，永不按字节切）。
-
-    按字节切会产出破损 JSON —— 设备端解析失败只能整块丢掉，
-    还不如少几条但能解开（`truncated`/`shown` 如实反映）。
-    返回 (base64 文本, 修正后的块)。
-    """
-    acc = dict(acc or {})
-    rows = list(acc.get("accounts") or [])
-    total = acc.get("total", len(rows))
-    while True:
-        block = dict(acc, accounts=rows, shown=len(rows),
-                     truncated=len(rows) < total)
-        b64 = base64.b64encode(
-            json.dumps(block, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
-        ).decode("ascii")
-        if len(b64) <= ACCOUNTS_PAYLOAD_MAX or not rows:
-            return b64, block
-        rows = rows[:-1]
-
-
 @bp.route("/api/agent-store/config", methods=["GET", "POST"])
 @perm_required(PERM_APKS)
 def api_agent_store_config():

web/devices_api.py

@@ -4,7 +4,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from flask import Blueprint, jsonify, request
 
-from core import device_battery, device_pool, device_discovery, ledger
+from core import device_battery, device_pool, device_discovery
 from core.adb_helper import adb_connect, adb_connect_light
 from core.logger import get_logger
 from web.auth import perm_required, PERM_DEVICES
@@ -445,110 +445,6 @@ def api_devices_battery_scan():
     return jsonify({"ok": True, "msg": "采集已启动（约 1-3 秒）"})
 
 
-# ================== API：账号台账（「账号」页） ==================
-#
-# 数据在 device_account 表（见 core/ledger.py）；任务侧怎么用它取号见
-# tasks/generic/task.py 的 `_resolve_cmp_value`（if_el 的 cmp_source）。
-# ⚠ 台账的抖音号只做「条件判断」的比对值，**不做去重身份**（格式不同会静默失效）。
-
-@bp.route("/api/ledger")
-@perm_required(PERM_DEVICES)
-def api_ledger_list():
-    """账号列表 + 统计（?device=设备号 &q=搜索 &limit=）。"""
-    device_name = (request.args.get("device") or "").strip()
-    q = (request.args.get("q") or "").strip()
-    try:
-        limit = int(request.args.get("limit") or 500)
-    except ValueError:
-        limit = 500
-    try:
-        rows, stats = ledger.list_accounts(device_name, q, limit)
-        names = ledger.device_names()
-    except Exception as e:
-        _log.warning(f"读取账号台账失败: {e}")
-        return jsonify({"ok": False, "error": str(e)[:120]}), 503
-    return jsonify({"ok": True, "accounts": rows, "stats": stats, "device_names": names})
-
-
-@bp.route("/api/ledger/by_device")
-@perm_required(PERM_DEVICES)
-def api_ledger_by_device():
-    """按设备分组（设备池显示"这台几个号" + 点开看明细都走它，省一次请求）。"""
-    devices = ledger.by_device()
-    counts = {k: v["count"] for k, v in devices.items()}
-    return jsonify({"ok": True, "devices": devices, "counts": counts})
-
-
-@bp.route("/api/ledger", methods=["POST"])
-@perm_required(PERM_DEVICES)
-def api_ledger_add():
-    """新增一条账号。"""
-    row, err = ledger.add(request.json or {})
-    if err:
-        return jsonify({"ok": False, "error": err}), 400
-    return jsonify({"ok": True, "msg": "已新增", "account": row})
-
-
-@bp.route("/api/ledger/<acc_id>", methods=["PUT"])
-@perm_required(PERM_DEVICES)
-def api_ledger_update(acc_id):
-    """改一条账号。"""
-    row, err = ledger.update(acc_id, request.json or {})
-    if err:
-        code = 404 if "不存在" in err else 400
-        return jsonify({"ok": False, "error": err}), code
-    return jsonify({"ok": True, "msg": "已保存", "account": row})
-
-
-@bp.route("/api/ledger/<acc_id>", methods=["DELETE"])
-@perm_required(PERM_DEVICES)
-def api_ledger_delete(acc_id):
-    """删一条账号（删掉之后任务就取不到这个号了）。"""
-    if not ledger.delete(acc_id):
-        return jsonify({"ok": False, "error": "记录不存在或删除失败"}), 404
-    return jsonify({"ok": True, "msg": "已删除"})
-
-
-@bp.route("/api/ledger/import", methods=["POST"])
-@perm_required(PERM_DEVICES)
-def api_ledger_import():
-    """从表格粘贴文本批量导入。
-
-    请求：{"text": "设备号\\t手机号\\t…\\nA01\\t…", "delimiter": "\\t",
-           "mode": "skip|overwrite", "dry_run": true}
-    dry_run=true 只解析+判重、**一个字节都不写** —— 界面默认先预览再导入。
-    返回逐行结果（line/action/device_name/douyin_id/nickname/error/warns）+ 汇总。
-    """
-    data = request.json or {}
-    text = data.get("text") or ""
-    if not text.strip():
-        return jsonify({"ok": False, "error": "粘贴的内容是空的"}), 400
-    delim = data.get("delimiter") or "\t"
-    if delim == "tab":
-        delim = "\t"
-    mode = data.get("mode") or "skip"
-    dry_run = bool(data.get("dry_run"))
-    try:
-        rows, errors = ledger.parse_paste(text, delim)
-    except Exception as e:
-        _log.warning(f"账号台账解析失败: {e}")
-        return jsonify({"ok": False, "error": f"解析失败: {str(e)[:120]}"}), 400
-    if not rows:
-        return jsonify({"ok": True, "counts": {"total": 0, "added": 0, "updated": 0,
-                                              "skipped": 0, "failed": 0},
-                        "rows": [], "errors": errors, "mode": mode, "dry_run": dry_run,
-                        "msg": "没有可导入的行"})
-    try:
-        result = ledger.import_rows(rows, mode=mode, dry_run=dry_run)
-    except Exception as e:
-        _log.warning(f"账号台账导入失败: {e}")
-        return jsonify({"ok": False, "error": str(e)[:120]}), 503
-    result["errors"] = errors
-    result["msg"] = ("预览完成（未写入）" if dry_run else "导入完成")
-    return jsonify({"ok": True, **result})
-
-
-# ================== API：Tailscale 管理（仅管理员） ==================
 # 通过 Tailscale 官方 API v2 管理 tailnet 设备（列表/改名/授权/密钥不过期/删除/生成 auth key）。
 # 设备 IP 由 tailnet 自动分配，API 无法修改，列表只读展示。
 

web/video_plan_api.py

@@ -1,4 +1,4 @@
-"""视频发布计划 API（「账号 → 发布计划」页）。
+"""视频发布计划 API（「发布计划」页）。
 
 数据在 `video_plan` 表、服务层 `core/video_plan.py`；任务侧怎么自动发布见
 `tasks/generic/task.py` 的 `_exec_publish_video`（本文件的「立即发布」调的是同一段逻辑）。
@@ -22,9 +22,11 @@ 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:
@@ -42,7 +44,8 @@ def api_vp_upload_video():
 def api_vp_upload_titles():
     """上传标题：`{text, dry_run}`；也接受 multipart 的 txt 文件（字段名 file）。
 
-    每行 `标题内容_手机号_日期_编号`（编号可省略、标题里可以有下划线）；`#` 开头的行忽略。
+    每行 `标题 || 正文_名字_日期_编号`（`||` 后面是正文、可省略；编号可省略、标题里可以有下划线）；
+    `#` 开头的行**只有认不出名字/日期时才当注释**（`#话题` 开头的标题照收）。
     """
     if request.files.get("file"):
         raw = request.files["file"].stream.read()
@@ -64,7 +67,7 @@ def api_vp_upload_titles():
 @bp.route("/api/video_plan/timeline")
 @perm_required(PERM_DEVICES)
 def api_vp_timeline():
-    """时间线：?range=today|week|all &from=&to=&status=&account_id=&q=&limit="""
+    """时间线：?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()
@@ -77,7 +80,6 @@ def api_vp_timeline():
         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(),
-                       account_id=(request.args.get("account_id") or "").strip(),
                        q=(request.args.get("q") or "").strip(),
                        limit=int(request.args.get("limit") or 500))
     return jsonify({"ok": True, **data})
@@ -104,11 +106,13 @@ def api_vp_one(pid):
             return jsonify({"ok": False, "error": "计划不存在"}), 404
         return jsonify({"ok": True, "msg": "已删除（素材文件一并删除）"})
     data = request.json or {}
-    if "title" in data:
-        row, err = vp.set_title(pid, data.get("title") 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:
-            return jsonify({"ok": False, "error": err}), 400 if "太长" in err else 404
-        return jsonify({"ok": True, "msg": "标题已改", "plan": row})
+            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
 
 
@@ -127,94 +131,142 @@ def api_vp_video(pid):
     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 说清"先去切号"。
     """
-    import threading
     row = vp.get_plan(pid)
     if not row:
         return jsonify({"ok": False, "error": "计划不存在"}), 404
-    # 地址现查（设备名 → 当前地址）：**不能用计划行里的快照** —— 设备换 IP 后快照就是错的，
-    # 而且台账是粘贴导入的老记录可能压根没存上快照（实测踩过：设备池里明明有 A01，
-    # 却因为快照为空点不动按钮）。快照只作为兜底。
-    from core import ledger
-    serial = ledger.serial_of(row.get("device_name") or "") or (row.get("serial") or "")
-    if not serial:
-        return jsonify({"ok": False,
-                        "error": f"找不到设备『{row.get('device_name') or '?'}』的地址 ——"
-                                 f"确认「工具 → 设备池」里有这台设备且已连接"}), 400
-    if row.get("device_name") and not row.get("serial"):
-        vp.set_serial(pid, serial)      # 顺手把空快照补上（自愈，免得下次又踩）
     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
-    from tasks.generic.publish_flow import run_push
-    t = threading.Thread(target=run_push, args=(serial, pid), daemon=True)
-    t.start()
-    _log.info(f"推送素材到手机 video_plan {pid}（{row['phone']} {row['release_date']}）")
-    return jsonify({"ok": True,
-                    "msg": "已开始推送到手机（推完状态会变成「已推送到手机」，"
-                           "之后你在手机上发；发完点「标记已发布」）"})
+    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 _serial_for_plan(row):
-    """这条计划要推给哪台设备：**设备名现查**（设备换 IP 后快照是错的），快照兜底。"""
-    from core import ledger
-    return (ledger.serial_of(row.get("device_name") or "") or (row.get("serial") or "")).strip()
+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():
-    """**一键推送**：把某天（默认今天）所有「待发布/失败」的计划推到各自的手机上。
-
-    并发口径：**每台设备一个线程、设备内串行**（同一个手机同时推两个文件会互相干扰：
-    两条 adb push 抢带宽 + 两条 `content call scan_file` 抢索引），设备之间并行。
-
-    立刻返回受理条数（推送是后台跑的）——进度与结果看时间线的状态徽章/
-    「已推送·相册可见」标记。
-    """
-    import threading
-    from core import ledger
-    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,
-                        "msg": f"{date} 没有待推送的计划（有标题的才推）"})
-    by_dev, no_dev = {}, []
-    for row in rows:
-        serial = (ledger.serial_of(row.get("device_name") or "") or (row.get("serial") or "")).strip()
-        (by_dev.setdefault(serial, []) if serial else no_dev).append(row)
-    by_dev.pop("", None)                    # 兜底：空 key 不该出现
-    if not by_dev:
-        return jsonify({"ok": False, "error": f"{len(rows)} 条计划都没绑上设备地址 ——"
-                                              f"到「工具 → 设备池」确认设备在线"}), 400
-
-    from tasks.generic.publish_flow import push_one
-
-    def _push_device(serial, plans):
-        for row in plans:
-            try:
-                push_one(serial, row)
-            except Exception as e:
-                _log.warning(f"一键推送 {row.get('id')} 异常: {e}")
-
-    for serial, plans in by_dev.items():
-        threading.Thread(target=_push_device, args=(serial, plans), daemon=True).start()
-    _log.info(f"一键推送 {date}：{len(rows)} 条 → {len(by_dev)} 台设备"
-              f"（没绑设备的 {len(no_dev)} 条已跳过）")
-    return jsonify({"ok": True, "count": len(rows), "devices": len(by_dev),
-                    "no_device": len(no_dev),
-                    "msg": f"已开始推送 {len(rows)} 条（{len(by_dev)} 台设备，每台串行）——"
-                           f"推完状态会变成「已推送·相册可见/相册未见」，刷新看结果"})
+    """老入口（前端旧版本还可能在调）：语义与 `push_by_account` 一致 —— 都按名字找设备。"""
+    return _push_plans_by_account()
 
 
 @bp.route("/api/video_plan/<pid>/mark", methods=["POST"])
@@ -418,14 +470,14 @@ def api_vp_task_adopt(job_id):
         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` 里还有去重有效期、抢占等通用参数，
@@ -487,17 +539,15 @@ 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(),
-                    device=(request.args.get("device") or "").strip(),
-                    phone=(request.args.get("phone") or "").strip())
+                    name=(request.args.get("name") or "").strip())
     if (request.args.get("format") or "") == "csv":
         buf = io.StringIO()
         w = csv.writer(buf)
-        w.writerow(["发布日期", "设备号", "手机号", "账号名称", "抖音号",
-                    "编号", "标题", "分享链接", "发布时间"])
+        # 按**名字**导出（手机号/抖音号随台账停用一起下线；由谁发的看 posted_device_name）
+        w.writerow(["发布日期", "名字", "编号", "标题", "正文", "分享链接", "发布时间"])
         for r in rows:
-            w.writerow([r["release_date"], r["device_name"], r["phone"], r["nickname"],
-                        r["douyin_id"], r["seq"], r["title"], r["share_url"],
-                        r["published_at"]])
+            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")

web_server.py

@@ -120,9 +120,6 @@ device_battery.init_app(app)
 # 去重账本（跨设备幂等）：绑 app 供任务线程/Web/清理任务自推 context
 from core import dedup
 dedup.init_app(app)
-# 账号台账：绑 app 供任务线程（条件判断取号）/ Web / 设备端身份页自推 context
-from core import ledger
-ledger.init_app(app)
 # 视频发布计划：绑 app 供任务线程（发布步骤）/ Web / 清理 job 自推 context
 from core import video_plan
 video_plan.init_app(app)