Merge branch 'dev'——发布计划按名字发 + 账号管理整页下线 + 自动切号 + 图片

.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/Camera/`、触发相册刷新、把标题写进剪贴板），**抖音里怎么发由你自己在任务里写步骤**（步骤顺序：`读取本机账号名字` → `条件判断`校验 → `推送发布视频` → 你的发布步骤 → `标记发布结果`；页顶部有**「发布任务」**块可一键建好骨架 + 看下次运行/启停，`输入文字` 那一步可以选**取值来源＝计划标题/正文**自动填文案并回读校验）；发完可抓作品的**分享链接**存下来（平台不长期囤视频，链接才是长期资产，也方便后续铺评论：可一键复制、按日期/名字导出 CSV）。状态区分"**可重试**"（推送阶段失败，还没到抖音）与"**结果未知、需人工确认**"（推送之后出的岔子，绝不自动重发）（见 [DATA_MODEL.md](doc/DATA_MODEL.md) §2.11、[TASK_DEV.md](doc/TASK_DEV.md) §4.7） |
-| **视频发布计划** | 「账号 → 发布计划」页：批量上传视频（文件名 `手机号_日期_编号`）与标题 txt → 自动按 (手机号,日期,编号) 配对到台账账号 → **按日期的时间线**看每天谁要发、发到哪一步。**平台只负责把素材推到手机**（推到 `/sdcard/DCIM/rp/`、触发相册刷新、把标题写进剪贴板），**抖音里怎么发由你自己在任务里写步骤**（步骤顺序：`推送发布视频` → 你的发布步骤 → `标记发布结果`；「发布计划」页顶部有**「发布任务」**块可一键建好骨架 + 看下次运行/启停，`输入文字` 那一步可以选**取值来源＝计划标题**自动填文案并回读校验）；发完可抓作品的**分享链接**存下来（平台不长期囤视频，链接才是长期资产，也方便后续铺评论：可一键复制、按日期/账号导出 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,557 +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))]:
-            # name 恒空串：账号名称已停用（设备端 APK 仍会解析这个字段，
-            # 直接删 key 有解析失败的风险，所以留空串）
-            item = {"name": "", "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:
-                # 账号名称（nickname）**不再收录**：界面上已经去掉这一列，
-                # 老表格粘进来也不报错，只是这一列的值被忽略（库里的历史值不动）
-                if field == "nickname":
-                    continue
-                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,12 +526,12 @@ 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（不做外键）
+    account_id = db.Column(db.String(32), default="", index=True)   # 老台账账号 id（已停用，保留列）
-    phone = db.Column(db.String(32), default="", index=True)        # 配对键（冗余存：账号删了也留痕）
+    phone = db.Column(db.String(32), default="", index=True)        # 老台账手机号快照（已停用，保留列）
-    device_name = db.Column(db.String(80), default="", index=True)  # 设备号快照（聚合/下发免 join）
+    device_name = db.Column(db.String(80), default="", index=True)  # 设备号快照（**已不写入**；实际由谁发的看 posted_device_name）
-    nickname = db.Column(db.String(80), default="")                 # 账号名称快照（时间线卡片直接显示）
+    nickname = db.Column(db.String(80), default="")                 # **识别键**：上传文件名里的名字（= 抖音昵称）
-    douyin_id = db.Column(db.String(64), default="")                # 抖音号快照
+    douyin_id = db.Column(db.String(64), default="")                # 抖音号快照（已停用，保留列）
-    serial = db.Column(db.String(120), 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)                  # 编号是自动分配出来的（界面要提示）
@@ -540,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)
@@ -550,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):
@@ -566,6 +580,8 @@ class VideoPlan(db.Model):
                 "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 ""}
 
@@ -603,6 +619,10 @@ SCHEMA_MIGRATIONS = [
     (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）
@@ -633,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)
@@ -648,6 +675,7 @@ def init_db(app):
         _sync_columns()
         _migrate_schema()
         _ensure_unique_indexes()
+        _ensure_plain_indexes()
         _ensure_default_admin()
         _migrate_old_json()
 
@@ -780,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）")
+                              f"（可用：空/manual/release/account_target）")
-            if cmp_src == "group" and not (params.get("cmp_group") or "").strip():
-                warnings.append(f"{here}: 候选值来源是「按设备分组」，但没填分组名 —— 取不到号")
             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,20 +275,24 @@ def validate_steps(steps, depth=1, path="steps", errors=None, warnings=None,
                               f"（当前 min={lo!r} max={hi!r}）")
 
         if stype == "input_text":
-            mode = params.get("mode", "random")
+            # 文案来自「发布计划」（`text_source` 不是 manual）时 texts/fixed_text **都不参与输入** ——
-            if mode not in ("random", "fixed"):
+            # 别按"手填"的规则要求候选文案（发布任务骨架里那两步就是这么配的：
-                errors.append(f"{here}.params.mode: 必须是 random 或 fixed"
+            # mode 留默认、内容由计划给，靠 `release_title`/`release_body` 现取）
-                              f"（当前 {mode!r}）")
+            if str(params.get("text_source") or "manual").strip() == "manual":
-            elif mode == "fixed":
+                mode = params.get("mode", "random")
-                if not str(params.get("fixed_text") or "").strip():
+                if mode not in ("random", "fixed"):
-                    errors.append(f"{here}.params.fixed_text: mode=fixed 时不能为空")
+                    errors.append(f"{here}.params.mode: 必须是 random 或 fixed"
-            else:
+                                  f"（当前 {mode!r}）")
-                texts = params.get("texts")
+                elif mode == "fixed":
-                if not isinstance(texts, str) or not texts.strip():
+                    if not str(params.get("fixed_text") or "").strip():
-                    errors.append(f"{here}.params.texts: mode=random 时必须给候选"
+                        errors.append(f"{here}.params.fixed_text: mode=fixed 时不能为空")
-                                  "文案（换行分隔，如 \"你好\\n不错\"）")
+                else:
-                elif len([t for t in texts.split("\n") if t.strip()]) > MAX_TEXTS:
+                    texts = params.get("texts")
-                    errors.append(f"{here}.params.texts: 候选文案最多 {MAX_TEXTS} 条")
+                    if not isinstance(texts, str) or not texts.strip():
+                        errors.append(f"{here}.params.texts: mode=random 时必须给候选"
+                                      "文案（换行分隔，如 \"你好\\n不错\"）")
+                    elif len([t for t in texts.split("\n") if t.strip()]) > MAX_TEXTS:
+                        errors.append(f"{here}.params.texts: 候选文案最多 {MAX_TEXTS} 条")
 
         if stype == "clipboard":
             if not str(params.get("text") or "").strip():

core/video_plan.py

@@ -1,13 +1,13 @@
 """视频发布计划：批量上传 → 自动配对 → 时间线 → 自动发布 → 存分享链接。
 
 **它解决什么**（用户场景）：人员在网页上批量传视频与标题 txt，文件名里写着
-`手机号_日期_编号`，标题行写着 `标题_手机号_日期_编号`。平台把它们自动配到台账里的账号上，
+`名字_日期_编号`（名字 = 抖音上的昵称），标题行写着 `标题 || 正文_名字_日期_编号`。
-排成一张发布计划；到发布日期由任务把视频推到手机相册、走抖音发布流程、回写状态，
+平台把它们排成一张发布计划；到发布日期由任务把视频推到手机相册、走抖音发布流程、回写状态，
 **发布后抓作品的分享链接存进来**（平台不长期囤视频，链接才是长期资产
 —— 后续铺评论也是靠这个链接去打开视频）。
 
 **三个使用方**：
-  1. web「账号 → 发布计划」页（`web/video_plan_api.py`）—— 上传/时间线/单条操作/导出链接
+  1. web「发布计划」页（`web/video_plan_api.py`）—— 上传/时间线/单条操作/导出链接
   2. 任务步骤「发布视频」（`tasks/generic/task.py` 的 `_exec_publish_video`）—— 取计划、占位、回写
   3. 每日清理 job（`web_server.py`）—— 僵尸回收 + 过期行/孤儿文件清理
 
@@ -20,7 +20,7 @@
     `post`/`verify` 阶段失败或超时 = **可能已经发出去了** → `unknown`（**绝不自动重试**，
     人工到抖音确认后再裁决）。把"不知道自己发没发"当成"知道自己没发"，就是重复发布的来源。
 
-DB 访问自建 app context（照 `core/dedup.py` / `core/ledger.py` 的 `_ctx()`），调用方不用关心。
+DB 访问自建 app context（照 `core/dedup.py` 的 `_ctx()`），调用方不用关心。
 """
 import hashlib
 import os
@@ -31,7 +31,7 @@ import uuid
 
 from config import VIDEO_DIR
 from core.logger import get_logger
-from core.models import db, DeviceAccount, VideoPlan
+from core.models import db, VideoPlan
 
 _log = get_logger("core.video_plan")
 
@@ -58,7 +58,12 @@ STAGE_STATUS = {"push": ST_FAILED, "scan": ST_FAILED,
                 "post": ST_UNKNOWN, "verify": ST_UNKNOWN,
                 STAGE_MANUAL: ST_UNKNOWN}
 
+# 素材扩展名：**视频 + 图片**（图片就是抖音的"图文"，发布流程一样：相册里点第一个）。
+# 扩展名必须一路带到手机上 —— 抖音是按扩展名/MIME 判断这是视频还是图片的，
+# 给图片起个 .mp4 的名字，相册里就成了一段坏视频。
 VIDEO_EXTS = (".mp4", ".mov", ".mkv", ".avi", ".3gp", ".flv", ".wmv", ".m4v", ".ts", ".webm")
+IMAGE_EXTS = (".jpg", ".jpeg", ".png", ".webp", ".heic")
+MEDIA_EXTS = VIDEO_EXTS + IMAGE_EXTS
 MAX_TITLE_LEN = 100           # 超过就拒收（**不静默截断**：截断会发出错文案，用户看不见）
 MAX_BODY_LEN = 1000           # 正文上限（抖音文案框放得下 1000 字；同样不截断，超了拒收）
 MAX_ATTEMPTS = 3              # 尝试上限，超了不再自动取（人工确认后重试可清零）
@@ -66,10 +71,20 @@ ZOMBIE_MINUTES = 30           # 占位行超过这么久没动静 → 按 stage
 VIDEO_KEEP_DAYS = 7           # 平台素材：抓到分享链接后再留这么多天
 PLAN_KEEP_DAYS = 90           # 过期（未发布/失败）的计划行保留这么多天
 
+# 名字（抖音昵称）没有固定形态 → 只靠"位置"认（紧挨日期的那一段），所以形态上只做三条限制：
+# 不能空、不能含 `_`（那是分段符号）、不能是纯数字（会和日期/编号撞车）。
+NAME_MAX_LEN = 40
+# 只在"名字段看着像老格式的手机号"时用来给一句更有用的提示（老文件 `手机号_日期_编号`
+# 会被当成"名字=手机号"→ 报"名字不能是纯数字"，太含糊）
 _PHONE_RE = re.compile(r"^1\d{10}$")
 _DATE8_RE = re.compile(r"^\d{8}$")
 _SEQ_RE = re.compile(r"^\d{1,3}$")
 _URL_RE = re.compile(r"https?://v\.douyin\.com/[A-Za-z0-9_\-]+")
+# 从昵称控件文本里挑名字时要跳过的"标签行"（**整行相等**才算，前缀不算 ——
+# 「关注我领福利」这种昵称不能被误跳过）；抖音号那行必须是 `抖音号：/ID：` 带分隔符的形式
+_NAME_LABELS = {"编辑资料", "编辑名片", "点击编辑", "点击编辑资料", "抖音号", "抖音ID",
+                "关注", "粉丝", "获赞", "作品", "喜欢", "私密", "IP属地"}
+_NAME_ID_RE = re.compile(r"^抖音(号|ID)\s*[:：]")
 _SAFE_RE = re.compile(r"[^0-9A-Za-z_\-.一-鿿]+")
 
 _app = None
@@ -110,132 +125,148 @@ def parse_date8(s):
     return f"{t.tm_year:04d}-{t.tm_mon:02d}-{t.tm_mday:02d}"
 
 
+def clean_account_name(text):
+    """从昵称控件的文本里取出"名字"（纯函数）。
+
+    抖音「我」页的昵称控件，抓到的可能只有昵称，也可能是**整块资料的文本**
+    （多行，混着「编辑资料」「抖音号：xxx」「关注/粉丝/获赞」）。规则：
+    按行切，取**第一个非空行**；如果那一行整行就是个标签（`编辑资料`/`关注`…）或
+    `抖音号：…`，就继续往下找，直到拿到一条不是标签的；找不到 → 返回 `""`
+    （= **读不到名字**，调用方按"没有这个号"处理，绝不当成某个名字去发）。
+
+    **不在名字内部做任何加工**：名字里的空格、表情、数字原样保留 ——
+    台账里有 `有牛奶面包  你吃吗？` 这种带双空格的昵称，按空格切会把名字切坏。
+    """
+    if not text:
+        return ""
+    for line in str(text).replace("\r", "\n").split("\n"):
+        s = line.strip()
+        if not s or s in _NAME_LABELS or _NAME_ID_RE.match(s):
+            continue
+        return s
+    return ""
+
+
+def name_error(seg):
+    """名字片段的合法性检查：合法返回 ""，不合法返回给人看的原因。
+
+    三条限制都来自"名字只能靠**位置**认"这件事 —— 空名字、含 `_`（分段符号本身）、
+    纯数字（会和日期/编号撞车）都会让 `名字_日期_编号` 切不出唯一解。
+    其余一律放行：汉字/字母/数字混排、名字**内部**的空格、表情都可以（不做额外限制，
+    抖音昵称能起什么名字，这里就认什么）。
+    """
+    s = (seg or "").strip()
+    if not s:
+        return "名字是空的"
+    if "_" in s:
+        return "名字里不能有下划线（下划线是文件名各段的隔开符号）"
+    if _PHONE_RE.match(s):
+        return (f"这一段（{s}）是手机号 —— 文件名第一段要填**抖音上的名字**，"
+                f"格式是 名字_日期_编号（现在不认手机号了）")
+    if s.isdigit():
+        return f"名字不能是纯数字（{s} 会被当成日期/编号）—— 请填抖音上的昵称"
+    if len(s) > NAME_MAX_LEN:
+        return f"名字太长（{len(s)} 字 > {NAME_MAX_LEN} 字上限）"
+    return ""
+
+
 def parse_video_name(filename):
-    """视频文件名 `手机号_日期_编号` → (meta, error)。
+    """素材文件名 `名字_日期_编号` → (meta, error)。**视频和图片同一套规则**。
 
-    meta = {"phone","date","seq"|None,"seq_given"}；error 是给人看的拒收原因。
+    meta = {"name","date","seq"|None,"seq_given"}；error 是给人看的拒收原因。
 
-    **按形态认，不按位置切**：手机号 11 位、日期 8 位、编号 1-3 位 —— 三个长度区间
+    **右锚定**：从最右边往前认 可省编号(1-3 位) → 日期(8 位) → **紧挨着日期的那一段就是名字**。
-    互不相交，所以永远不会有一段同时匹配两种角色。按位置硬切的话，用户把顺序写反、
+    为什么不再"按形态扫全部分段"（手机号那套）：手机号有固定形态（11 位、1 开头），
-    或文件名带下载站前缀时，会解析出一个**错误的手机号**；而它若恰好命中台账里
+    名字没有 —— 长度任意、可以带数字和汉字，只有"日期前一段"这个位置是确定的。
-    另一个账号，就**不报错**，静默地把 A 号的视频排给 B 号。
+    代价是名字里不能有下划线：**明确拒收并说清原因**，而不是猜一个可能错的名字
+    （猜错就是把 A 号的视频静默排给 B 号）。
     """
     name = (filename or "").strip()
     if not name:
         return None, "文件名为空"
     stem, ext = os.path.splitext(name)
-    if ext.lower() not in VIDEO_EXTS:
+    if ext.lower() not in MEDIA_EXTS:
-        return None, f"不是视频文件（支持 {'/'.join(e.lstrip('.') for e in VIDEO_EXTS)}）"
+        return None, (f"不是视频/图片文件（支持 "
+                      f"{'/'.join(e.lstrip('.') for e in MEDIA_EXTS)}）")
     parts = [p.strip() for p in stem.split("_")]
     if len(parts) < 2:
-        return None, "文件名格式不对，应为 手机号_日期_编号（编号可省略）"
+        return None, "文件名格式不对，应为 名字_日期_编号（编号可省略，如 小王_20260912.mp4）"
-
+    if len(parts) >= 3 and _SEQ_RE.match(parts[-1]) and _DATE8_RE.match(parts[-2]):
-    phone = date = seq = None
+        seq, date8, name_parts = int(parts[-1]), parts[-2], parts[:-2]
-    leftovers = []
+    elif _DATE8_RE.match(parts[-1]):
-    for p in parts:
+        seq, date8, name_parts = None, parts[-1], parts[:-1]
-        if not p:
+    else:
-            leftovers.append(p)
+        return None, (f"文件名格式不对：`{stem}` 的结尾既不是日期（8 位数字，如 20260912），"
-            continue
+                      f"也不是「日期_编号」—— 应为 名字_日期_编号")
-        if _PHONE_RE.match(p):
+    d = parse_date8(date8)
-            if phone is not None:
+    if not d:
-                return None, f"文件名里有多个手机号（{phone}、{p}）"
+        return None, f"日期 {date8} 不是合法日期（应为 20260912 这种 8 位）"
-            phone = p
+    if len(name_parts) != 1:
-        elif _DATE8_RE.match(p):
+        return None, (f"名字里不能有下划线：`{stem}` 里日期前面有 {len(name_parts)} 段 ——"
-            if date is not None:
+                      f"应为 名字_日期_编号")
-                return None, f"文件名里有多个日期（{date}、{p}）"
+    err = name_error(name_parts[0])
-            d = parse_date8(p)
+    if err:
-            if not d:
+        return None, err
-                return None, f"日期 {p} 不是合法日期（应为 20260912 这种 8 位）"
+    return {"name": name_parts[0], "date": d, "seq": seq, "seq_given": seq is not None}, ""
-            date = d
-        elif _SEQ_RE.match(p):
-            if seq is not None:
-                return None, f"文件名里有多个编号（{seq}、{p}）"
-            seq = int(p)
-        else:
-            leftovers.append(p)
-    if leftovers:
-        return None, f"文件名里有多余片段 {'_'.join(leftovers)} —— 应为 手机号_日期_编号"
-    if not phone:
-        return None, "文件名里找不到手机号（11 位、1 开头）"
-    if not date:
-        return None, "文件名里找不到发布日期（8 位，如 20260912）"
-    return {"phone": phone, "date": date, "seq": seq, "seq_given": seq is not None}, ""
 
 
 def parse_title_line(line):
-    """标题行 → (meta, error)。**两种写法都认**，标题里都可以带下划线。
+    """标题行 → (meta, error)。格式只有一种：`标题 || 正文_名字_日期_编号`。
 
-    **一行里可以有标题和正文**：`标题 || 正文 _手机号_日期_编号`（用 `||` 分隔，
+    **一行里可以有标题和正文**：用 `||` 分隔（标题/正文里常带下划线，所以不能再用下划线分列），
-    因为标题/正文里常带下划线；只切第一处，正文里再出现 `||` 原样保留）。
+    只切**第一处**，正文里再出现 `||` 原样保留；没写 `||` 就是只有标题；
-    没写 `||` 就是只有标题（老文件照收）；` || 正文_…` 这种只有正文也行。
+    ` || 正文_…` 这种"只有正文"也行（标题留空）。
 
-    ① 标题在前（推荐，右锚定）：
+    名字**右锚定**，和视频文件名同一套规则（末尾可省编号 → 日期 → **紧挨日期的那一段是名字**）；
-         A) 标题内容_手机号_日期_编号   B) 标题内容_手机号_日期
+    名字之前剩下的整段（下划线连回去）就是「标题 || 正文」——
-    ② 手机号在前（左锚定，跟视频文件名同序 —— "文件名去掉扩展名 + 标题"）：
+    所以标题/正文里可以随便带下划线，**只有名字不能带**（`name_error` 统一把关）。
-         C) 手机号_日期_编号_标题       D) 手机号_日期_标题
+    与视频文件名的差别：视频名里"名字前面多出段"要**拒收**（那里不该有内容），
+    标题行里则**都算文案**（`标题_带_下划线_小王_20260912` → 名字是最后的 `小王`，前面整段都是标题）。
 
-    为什么**先右后左**：右锚定是主格式（标题里带下划线也不会错配）。
+    为什么砍掉老的「名字在前」（`名字_日期_编号_标题`）写法：键从手机号换成名字后，
-    左锚定的四种里先试带编号的 C（`手机号_日期_1_标题` —— 那个 `1` 当编号，
+    `小王_20260912_1` 这种一行会有两种解释（`1` 是编号还是标题的开头？），
-    不当标题的开头），保证同一行永远只有一种解释。
+    只留一种写法，解析结果就没有歧义了。名字写错/漏写会在配到计划行时被**明确拒收**
-
+    （"名字 X 没有对应的视频"），不会静默发出一条文不对题的文案。
-    什么时候两种都不会误判：右锚定要求"倒数第 3/2 段是手机号"，左锚定要求
-    "第 1 段是手机号、第 2 段是日期" —— 一行同时满足两边时（例如 `手机号_日期_1`）
-    右锚定先命中，且标题为空会被下面的校验拒掉，不会静默发出一条错文案。
     """
     t = (line or "").strip()
     if not t:
         return None, "空行"
     parts = t.split("_")
-    phone = date = seq = None
+    if len(parts) >= 3 and _SEQ_RE.match(parts[-1]) and _DATE8_RE.match(parts[-2]):
-    title_parts = None
+        seq, date8, rest = int(parts[-1]), parts[-2], parts[:-2]
-    # ① 右锚定：先试带编号的，再试不带编号的
+    elif len(parts) >= 2 and _DATE8_RE.match(parts[-1]):
-    if len(parts) >= 4 and _SEQ_RE.match(parts[-1]) \
+        seq, date8, rest = None, parts[-1], parts[:-1]
-            and _DATE8_RE.match(parts[-2]) and _PHONE_RE.match(parts[-3]):
-        seq = int(parts[-1])
-        phone, date8, title_parts = parts[-3], parts[-2], parts[:-3]
-    elif len(parts) >= 3 and _DATE8_RE.match(parts[-1]) and _PHONE_RE.match(parts[-2]):
-        phone, date8, title_parts = parts[-2], parts[-1], parts[:-2]
-    # ② 左锚定（手机号在前，跟视频文件名同序）：同样先试带编号的
-    elif len(parts) >= 4 and _PHONE_RE.match(parts[0]) and _DATE8_RE.match(parts[1]) \
-            and _SEQ_RE.match(parts[2]):
-        phone, date8, seq = parts[0], parts[1], int(parts[2])
-        title_parts = parts[3:]
-    elif len(parts) >= 3 and _PHONE_RE.match(parts[0]) and _DATE8_RE.match(parts[1]):
-        # `手机号_日期_1` 这种"只有编号、没有标题"要**拒掉**，不能被当成标题"1"
-        # （静默生成一条标题是"1"的文案，比拒收危险得多；标题真是纯数字就用"标题在前"的写法）
-        if len(parts) == 3 and _SEQ_RE.match(parts[2]):
-            return None, ("只有手机号/日期/编号、没有标题文字 ——"
-                          "标题是纯数字的话请用「标题_手机号_日期」写法")
-        phone, date8, title_parts = parts[0], parts[1], parts[2:]
     else:
-        return None, ("格式不对，应为「标题内容_手机号_日期_编号」"
+        return None, ("格式不对，应为「标题 || 正文_名字_日期_编号」"
-                      "或「手机号_日期_编号_标题」（编号都可省略）")
+                      "（编号可省略；日期是 8 位数字，如 20260912）")
     d = parse_date8(date8)
     if not d:
         return None, f"日期 {date8} 不是合法日期（应为 20260912 这种 8 位）"
-    date = d
+    name = (rest[-1] or "").strip()
-    raw = "_".join(title_parts).strip()
+    err = name_error(name)
-    # 「标题 || 正文」：用 `||` 分隔（标题/正文里常带下划线，所以不能再用下划线分列）。
+    if err:
-    # 只切第一处：正文自己再出现 `||` 也原样保留。没写 `||` 就是只有标题（老文件照收）。
+        return None, err
+    raw = "_".join(rest[:-1]).strip()
+    # 「标题 || 正文」：只切第一处；没写 `||` 就是只有标题（正文留空）
     title, body = raw, ""
     if "||" in raw:
         title, body = (x.strip() for x in raw.split("||", 1))
     if not title and not body:
-        return None, "缺标题/正文内容（只有手机号/日期/编号，没有文字）"
+        return None, "缺标题/正文内容（只有名字/日期/编号，没有文字）"
     if len(title) > MAX_TITLE_LEN:
         return None, f"标题太长（{len(title)} 字 > {MAX_TITLE_LEN} 字上限），请改短或拆成两条"
     if len(body) > MAX_BODY_LEN:
         return None, f"正文太长（{len(body)} 字 > {MAX_BODY_LEN} 字上限），请改短或拆成两条"
-    return {"title": title, "body": body, "phone": phone, "date": date,
+    return {"title": title, "body": body, "name": name, "date": d,
             "seq": seq, "seq_given": seq is not None}, ""
 
 
 def parse_titles_text(text):
     """标题 txt 全文 → (rows, errors)。空行跳过；`#` 开头**只有认不出标题行时**才算注释。
 
-    ⚠ 顺序是"先当标题解析、再当注释"：`#中秋快乐_19286456013_20260929` 是一条**正常标题**
+    ⚠ 顺序是"先当标题解析、再当注释"：`#中秋快乐_小王_20260929` 是一条**正常标题**
     （`#话题` 本来就长这样），过去的写法会把整行当注释**静默丢掉**。现在只有像
-    `# 这是注释` 这种解析不出手机号/日期的行才按注释忽略。
+    `# 这是注释` 这种解析不出名字/日期的行才按注释忽略。
     """
     rows, errors = [], []
     lines = (text or "").replace("\r\n", "\n").replace("\r", "\n").split("\n")
@@ -272,15 +303,14 @@ def assign_slot(explicit_seq, taken):
     return next_free_slot(taken)
 
 
-def pair_slots(videos, titles, accounts_by_phone, db_taken=None):
+def pair_slots(videos, titles, db_taken=None):
-    """批量配对的**语义参考实现**（纯函数）：把一批视频与一批标题配成 (账号,日期,编号)。
+    """批量配对的**语义参考实现**（纯函数）：把一批视频与一批标题配成 (名字,日期,编号)。
 
     videos / titles：`parse_video_name` / `parse_title_line` 的返回（可带 "ref" 标识来源）
-    accounts_by_phone：{手机号: [账号 dict, ...]}
+    db_taken：{(名字,日期): {已用编号}} —— 分两批上传时不能从 1 重号
-    db_taken：{(手机号,日期): {已用编号}} —— 分两批上传时不能从 1 重号
 
-    返回 (pairs, rejected)：pairs=[{"video","title","phone","date","seq","seq_auto"}]。
+    返回 (pairs, rejected)：pairs=[{"video","title","name","date","seq","seq_auto"}]。
-    规则：手机号在台账里 0 条或 ≥2 条 → 整组拒收；同侧编号重复 → 两条都拒收；
+    规则：**名字就是账号**（不再查任何台账）；同侧编号重复 → 两条都拒收；
     没编号的视频填空位；**没编号的标题按号升序配到"还没有标题的视频"上**
     （即"第 1 个视频配第 1 条标题"，与逐条上传时 `import_titles()` 的行为一致 ——
       两处必须是同一套规则，不然批量路径与日常路径会给出不同结果）；
@@ -290,7 +320,7 @@ def pair_slots(videos, titles, accounts_by_phone, db_taken=None):
     db_taken = db_taken or {}
 
     def _key(m):
-        return (m.get("phone") or "", m.get("date") or "")
+        return (m.get("name") or "", m.get("date") or "")
 
     def _reject(side, meta, reason):
         rejected.append({"side": side, "ref": meta.get("ref") or meta.get("title")
@@ -302,15 +332,7 @@ def pair_slots(videos, titles, accounts_by_phone, db_taken=None):
             buckets.setdefault(_key(m), {}).setdefault(side, []).append(m)
 
     for key, sides in buckets.items():
-        phone, date = key
+        name, date = key
-        accs = accounts_by_phone.get(phone) or []
-        if len(accs) != 1:
-            reason = (f"手机号 {phone} 不在账号台账里" if not accs
-                      else f"手机号 {phone} 在台账里对应 {len(accs)} 个账号，无法确定是哪个")
-            for side in ("video", "title"):
-                for m in sides.get(side, []):
-                    _reject(side, m, reason)
-            continue
         taken = set(db_taken.get(key) or set())
         # 显式编号：先占位，同侧重复 → 两条都拒收
         for side in ("video", "title"):
@@ -341,7 +363,7 @@ def pair_slots(videos, titles, accounts_by_phone, db_taken=None):
         vmap = {}
         for m in vids:
             s = int(m["seq"]) if m.get("seq_given") else assigned.get(id(m))
-            vmap[s] = {"video": m, "title": None, "phone": phone, "date": date,
+            vmap[s] = {"video": m, "title": None, "name": name, "date": date,
                        "seq": s, "seq_auto": not m.get("seq_given")}
         # 标题 → 槽位：有编号的精确对；没编号的填进还没配到标题的槽位（按号升序）
         free_slots = sorted(vmap.keys())
@@ -351,7 +373,7 @@ def pair_slots(videos, titles, accounts_by_phone, db_taken=None):
                 if s in vmap and vmap[s]["title"] is None:
                     vmap[s]["title"] = m
                 else:
-                    _reject("title", m, f"编号 {s} 没有对应的视频（该账号 {date} 没有这条）")
+                    _reject("title", m, f"编号 {s} 没有对应的视频（该名字 {date} 没有这条）")
             else:
                 s = assigned.get(id(m))
                 if s in vmap and vmap[s]["title"] is None:
@@ -360,13 +382,13 @@ def pair_slots(videos, titles, accounts_by_phone, db_taken=None):
                     # 号被别的标题占了 → 退到第一个还没标题的槽位
                     target = next((x for x in free_slots if vmap[x]["title"] is None), None)
                     if target is None:
-                        _reject("title", m, f"没有对应视频（该账号 {date} 的视频都有标题了）")
+                        _reject("title", m, f"没有对应视频（该名字 {date} 的视频都有标题了）")
                     else:
                         vmap[target]["title"] = m
                 else:
-                    _reject("title", m, f"没有对应视频（该账号 {date} 没有视频）")
+                    _reject("title", m, f"没有对应视频（该名字 {date} 没有视频）")
         pairs.extend(vmap.values())
-    pairs.sort(key=lambda p: (p["date"], p["phone"], p["seq"]))
+    pairs.sort(key=lambda p: (p["date"], p["name"], p["seq"]))
     return pairs, rejected
 
 
@@ -432,14 +454,65 @@ def _has_type(steps, want):
 
 
 def build_push_step(label="推送发布视频（平台）"):
-    """「推送发布视频」步骤（骨架与「给已有任务插一步」共用这一处定义）。"""
+    """「推送发布视频」步骤（骨架与「给已有任务插一步」共用这一处定义）。
+
+    `account=name`（默认）= 用**本次要发的那个名字**（`_vars` 里的目标/刚读到的名字）取计划，
+    并且**推送前会再读一次屏幕上的昵称核对**；`account=phone` 是老路径（手填手机号）。
+    """
     return {"id": f"step_rel_push_{uuid.uuid4().hex[:6]}", "type": "push_release",
             "label": label,
-            "params": {"date_source": "today", "fixed_date": "", "account": "device",
+            "params": {"date_source": "today", "fixed_date": "", "account": "name",
                        "account_phone": "", "album_dir": "/sdcard/DCIM/Camera",
                        "to_clipboard": True, "retry_failed": True, "max_same_run": 1}}
 
 
+def build_read_name_step(label="读取本机账号名字（平台）", selector_value=None):
+    """「读取本机账号名字」步骤（骨架与"给已有任务插一步"共用）。
+
+    `selector_value=None` = 用 `config.DOUYIN_NAME_SELECTOR_VALUE`（**抓一次填 .env**，
+    与「按名字找设备」的实时探测共用同一处配置）；显式传值则用它。
+    两者都为空 = **还没抓**：执行器会明确报"请抓取元素"，绝不会猜一个名字去发。
+    """
+    from config import DOUYIN_NAME_SELECTOR_TYPE, DOUYIN_NAME_SELECTOR_VALUE
+    sel = DOUYIN_NAME_SELECTOR_VALUE if selector_value is None else selector_value
+    return {"id": f"step_rel_name_{uuid.uuid4().hex[:6]}", "type": "read_account_name",
+            "label": label,
+            "params": {"selector_type": DOUYIN_NAME_SELECTOR_TYPE or "xpath",
+                       "selector_value": sel,
+                       "timeout": 8, "on_missing": "fail", "probability": 100}}
+
+
+def build_switch_step(label="切换账号（切到本次要发的那个名字）"):
+    """「切换账号」步骤。
+
+    `switch_selector_value` 取 `config.DOUYIN_SWITCH_SELECTOR_VALUE`（**抓一次填 .env**）：
+    进「账号切换」列表那一下；留空则这一步会报"请抓取元素"并跳过（不会瞎点）。
+    """
+    from config import DOUYIN_SWITCH_SELECTOR_TYPE, DOUYIN_SWITCH_SELECTOR_VALUE
+    return {"id": f"step_rel_sw_{uuid.uuid4().hex[:6]}", "type": "switch_account",
+            "label": label,
+            "params": {"target": "var:target_name", "target_value": "",
+                       "switch_selector_type": DOUYIN_SWITCH_SELECTOR_TYPE or "xpath",
+                       "switch_selector_value": DOUYIN_SWITCH_SELECTOR_VALUE,
+                       "name_selector_type": "", "name_selector_value": "",
+                       "me_selector_type": "descriptionContains", "me_selector_value": "我",
+                       "timeout": 8, "verify": True, "max_attempts": 2,
+                       "on_login_page": "stop", "probability": 100}}
+
+
+def build_foreach_step(children=None, label="循环本机待发的号（一轮跑完，一直切到发完）"):
+    """「循环本机待发的号」容器步骤（`foreach_account`）—— 发布骨架的最外层。
+
+    数据源是**计划表**（`pending_names`）：谁还有待发内容谁就被选中，
+    所以"本机该发哪些号"不需要任何账号维护。
+    """
+    return {"id": f"step_rel_fe_{uuid.uuid4().hex[:6]}", "type": "foreach_account",
+            "label": label,
+            "params": {"date_source": "today", "fixed_date": "", "retry_failed": True,
+                       "max_accounts": 0, "children": list(children or []),
+                       "probability": 100}}
+
+
 def build_mark_step(label="标记发布结果（平台）"):
     """「标记发布结果」步骤（同上，共用一处定义）。"""
     return {"id": f"step_rel_mark_{uuid.uuid4().hex[:6]}", "type": "mark_release",
@@ -473,69 +546,94 @@ def build_release_steps():
     "等抖音号出现"必然超时，最后显示成一句误导人的"账号不符"。
     屏幕亮着时冷启动 5 秒就出底部栏。
 
-    **平台能保证的步骤都填好了**（推送 / 填标题 / 标记 + 账号校验），
+    **平台能保证的步骤都填好了**（读名字 / 推送 / 填标题 / 标记 + 账号校验），
     抖音里的点击步骤只给出**空选择器的占位**（标签写清楚该抓哪个），
     因为那些是混淆 id / 结构 xpath，写死了改版就废 —— 执行时会明确提示
     "selector_value 为空，请抓取元素"，不会静默跳过。
 
-    唯一预填了选择器的是底部「+」入口（`descriptionContains=拍摄`）与
+    预填了选择器的：底部「+」入口（`descriptionContains=拍摄`）、
-    「我」（`descriptionContains=我`），因为这两条我在真机上实测过、
+    「我」（`descriptionContains=我`）、以及**昵称控件与「切换账号」入口**（后者来自 `.env`，
-    且是按描述定位、跨版本相对稳。
+    `config.DOUYIN_NAME_SELECTOR_VALUE` / `DOUYIN_SWITCH_SELECTOR_VALUE`）——
+    这些都在真机上实测过（40.6.0，见 doc/research/U2_ELEMENT_SELECTORS.md §七）。
+    `.env` 没填时骨架里那两处就是空的，执行时会明确提示"请抓取元素"，不会静默跳过。
     """
     def sid(name):
         return f"step_rel_{name}_{uuid.uuid4().hex[:6]}"
 
+    def _name_sel():
+        """昵称控件的选择器（`config` 里抓一次填一次）—— 「读名字」和「校验账号」
+        **必须是同一个控件**，否则校验那步会永远不命中（等于跳过整个发布流程）。"""
+        from config import DOUYIN_NAME_SELECTOR_TYPE, DOUYIN_NAME_SELECTOR_VALUE
+        return (DOUYIN_NAME_SELECTOR_TYPE or "xpath", DOUYIN_NAME_SELECTOR_VALUE)
+
     def clk(name, label, sel_type="", sel_val=""):
         return {"id": sid(name), "type": "click", "label": label,
                 "params": {"selector_type": sel_type or "xpath", "selector_value": sel_val,
                            "wait_timeout": 8, "probability": 100}}
 
-    # 命中（当前登录的就是这条计划要发的号）才走发布流程；未命中走 else 只发通知。
+    # 命中（当前登的就是这次要发的那个名字）才走发布流程；未命中走 else 只发通知。
-    # 账号校验用**现成的「条件判断」+ 候选值来源=发布计划**，平台不自作主张读账号。
+    # 账号校验用**现成的「条件判断」+ 候选值来源=本次要发的名字**（`account_target`）：
+    # 候选值取自 `_vars`（循环设的目标名字，或刚读到的名字），元素原文取昵称控件。
+    # **只用「包含」，绝不能用「不等于」** —— 读不到名字时候选为空，
+    # "空 != 候选"会命中，把"读不到"误判成"可以发"。
     publish_flow_steps = [
-        dict(build_push_step("⑤ 推送发布视频")),
+        dict(build_push_step("⑧ 推送发布视频")),
-        clk("open", "⑥ 点击抖音底部「+」（实测可用；改版了重新抓）",
+        clk("open", "⑨ 点击抖音底部「+」（实测可用；改版了重新抓）",
             "descriptionContains", "拍摄"),
-        clk("album", "⑦ 点击「相册」（没命中的话用抓取元素选它）"),
+        clk("album", "⑩ 点击「相册」（没命中的话用抓取元素选它）"),
-        clk("video", "⑧ 点击第一个视频（刚推的排最前；抓一次就行）"),
+        clk("video", "⑪ 点击第一个视频（刚推的排最前；抓一次就行）"),
-        clk("next", "⑨ 点击「下一步」"),
+        clk("next", "⑫ 点击「下一步」"),
-        clk("input", "⑩ 点击输入框（抖音发布页的文案框）"),
+        clk("input", "⑬ 点击标题框（抖音发布页的标题框：hint「添加标题」）"),
         {"id": sid("title"), "type": "input_text",
-         "label": "⑪ 填标题（自动取这一条计划的标题，会回读校验）",
+         "label": "⑭ 填标题（自动取这一条计划的标题，会回读校验）",
          "params": {"text_source": "release_title", "release_topics": "",
                     "clear_first": True, "mode": "random", "texts": "", "fixed_text": ""}},
-        clk("body", "⑫ 点击正文输入框（发布页的文案框）"),
+        clk("body", "⑮ 点击正文框（发布页的描述框：hint「添加作品描述」）"),
         {"id": sid("bodytxt"), "type": "input_text",
-         "label": "⑬ 填正文（自动取这一条计划的正文，会回读校验）",
+         "label": "⑯ 填正文（自动取这一条计划的正文，会回读校验）",
          "params": {"text_source": "release_body", "release_topics": "",
                     "clear_first": True, "mode": "random", "texts": "", "fixed_text": ""}},
-        clk("publish", "⑭ 点击「发布」"),
+        clk("publish", "⑰ 点击「发布」"),
-        dict(build_mark_step("⑮ 标记发布结果（成功走这里；失败分支再放一个 result=failed）")),
+        dict(build_mark_step("⑱ 标记发布结果（成功走这里；失败分支再放一个 result=failed）")),
     ]
-    return [
+    # 循环体：切号 → 读名字 → 校验 → 推送 → 发布 → 标记。
-        {"id": sid("light"), "type": "screen_on", "label": "⓪ 亮屏",
+    # `switch_account` 自己会先看"当前是不是已经是目标"（第一个号不用切），
-         "params": {"probability": 100}},
+    # 也会处理"本机没登这个号"（直接跳过、不重试）。
-        {"id": sid("openapp"), "type": "open_app", "label": "① 打开抖音（等「首页」出来）",
+    loop_body = [
-         "params": {"package": "com.ss.android.ugc.aweme", "home_feature": "首页",
+        dict(build_switch_step("④ 切换账号（切到本次要发的那个名字；已在该号则直接过）")),
-                    "wait_home": True, "probability": 100}},
+        dict(build_read_name_step("⑤ 读取本机当前账号名字")),
-        clk("me", "② 点击「我」（实测可用；改版了重新抓）", "descriptionContains", "我"),
-        {"id": sid("wait"), "type": "wait", "label": "③ 等「我」页加载出来",
-         "params": {"min": 3, "max": 5, "vary_pace": False, "probability": 100}},
         {"id": sid("check"), "type": "if_el",
-         "label": "④ 校验账号：当前登录的是不是这条计划要发的号",
+         "label": "⑥ 校验账号：当前登的是不是这次要发的那个名字",
-         "params": {"selector_type": "xpath",
+         "params": {"selector_type": _name_sel()[0],
-                    "selector_value": "//*[contains(@text,'抖音号')]",
+                    "selector_value": _name_sel()[1],
-                    "timeout": 8, "cmp_op": "包含", "cmp_source": "release",
+                    "timeout": 8, "cmp_op": "包含", "cmp_source": "account_target",
                     "cmp_value": "", "cmp_group": "",
                     "ident_type": "text", "ident_value": "",
                     "then": publish_flow_steps,
                     "else": [{"id": sid("else"), "type": "notify",
-                              "label": "账号不符：本条跳过（不发）",
+                              "label": "账号不符/读不到：本条跳过（不发）",
                               "params": {"title": "发布跳过：账号不符",
-                                         "message": "设备 {device} 当前登录的不是要发的号"
+                                         "message": "设备 {device} 当前登的不是要发的号"
-                                                    "（计划：见「账号 → 发布计划」），本条已跳过",
+                                                    "（或读不到昵称），本条已跳过、没发出去",
                                          "level": "warning"}}]}},
     ]
+    return [
+        {"id": sid("light"), "type": "screen_on", "label": "⓪ 亮屏",
+         "params": {"probability": 100}},
+        # **先强杀再冷启动**（2026-10-12 实测踩出来的）：抖音可能停在**发布页/编辑页/别人的
+        # 视频页**（上一轮没发出去、或人手动停在那儿），`open_app` 只会把它拉到前台、
+        # 还是那一页 —— 那一页**没有底部「我」页签**，切号第一步就失败，整轮什么都不发。
+        # 冷启动保证起来是「首页」。
+        {"id": sid("stopapp"), "type": "stop_app",
+         "label": "① 结束抖音（冷启动，保证起来停在「首页」）",
+         "params": {"package": "com.ss.android.ugc.aweme", "probability": 100}},
+        {"id": sid("openapp"), "type": "open_app", "label": "② 打开抖音（等「首页」出来）",
+         "params": {"package": "com.ss.android.ugc.aweme", "home_feature": "首页",
+                    "wait_home": True, "probability": 100}},
+        # 一轮把本机待发的号跑完：数据源是**计划表**（谁还有待发内容谁就在里面），
+        # 不需要任何账号维护；停止/超时/上限三个出口见 `_exec_foreach_account`
+        dict(build_foreach_step(loop_body, "③ 循环本机待发的号（一直切号发，直到发完）")),
+    ]
 
 
 def extract_share_url(text):
@@ -554,21 +652,10 @@ def safe_name(name):
 
 
 # ================== DB 服务区 ==================
-def accounts_by_phone():
+def taken_slots(name, date):
-    """{手机号: [账号 dict, ...]}（配对用；同号多账号要能看出来）。"""
+    """该名字该日期已占用的编号集合（分两批上传时不能从 1 重号）。"""
     with _ctx():
-        out = {}
+        rows = VideoPlan.query.filter(VideoPlan.nickname == name,
-        for r in DeviceAccount.query.all():
-            p = (r.phone or "").strip()
-            if p:
-                out.setdefault(p, []).append(r.to_dict())
-        return out
-
-
-def taken_slots(phone, date):
-    """该账号该日期已占用的编号集合（分两批上传时不能从 1 重号）。"""
-    with _ctx():
-        rows = VideoPlan.query.filter(VideoPlan.phone == phone,
                                       VideoPlan.release_date == date).all()
         return {int(r.seq or 1) for r in rows}
 
@@ -622,39 +709,25 @@ def store_video(file_storage):
 
 
 def upload_video(file_storage, order=None, replace=False):
-    """上传单个视频 → 解析 → 配对 → 落库。返回给接口用的 dict。
+    """上传单个视频 → 解析名字 → 落库。返回给接口用的 dict。
 
-    幂等：同槽位已有行时 —— `sha1` 相同 → skip；不同 → **拒收**（除非 `replace=True`）。
+    **名字就是账号**（抖音昵称），不查任何台账：`名字_日期_编号` 里的名字原样写进
+    `video_plan.nickname`，运行时按这个名字找设备、取计划。
+
+    幂等：同一 (名字, 日期, 编号) 已有行时 —— `sha1` 相同 → skip；不同 → **拒收**（除非 `replace=True`）。
     """
     name = getattr(file_storage, "filename", "") or ""
     meta, err = parse_video_name(name)
     if err:
         return {"ok": False, "name": name, "error": err}
-    phone, date = meta["phone"], meta["date"]
+    acct, date = meta["name"], meta["date"]
-    accs = accounts_by_phone().get(phone) or []
-    if not accs:
-        return {"ok": False, "name": name,
-                "error": f"手机号 {phone} 不在「账号」台账里（先在台账登记这个号，或改文件名）"}
-    if len(accs) > 1:
-        return {"ok": False, "name": name,
-                "error": f"手机号 {phone} 在台账里对应 {len(accs)} 个账号（"
-                         f"{'、'.join(a['device_name'] for a in accs)}），无法确定是哪个"}
-    acc = accs[0]
-    if not acc.get("serial"):
-        # 台账是粘贴导入的老记录时可能没存上地址快照（导入那一刻设备池里没匹配上）——
-        # 现查一次补上，别把空快照带进计划行（发布时要用"当前地址"）
-        try:
-            from core import ledger as _ledger
-            acc = dict(acc, serial=_ledger.serial_of(acc.get("device_name") or ""))
-        except Exception:
-            pass
     try:
         with _ctx():
-            taken = taken_slots(phone, date)
+            taken = taken_slots(acct, date)
             # 文件名里**写了编号就认它**（哪怕这个号已被占 —— 那正是"重复上传/要覆盖"
             # 的场景，交给下面的 sha1 判据处理）；没写编号才自动排到空位
             seq = int(meta["seq"]) if meta["seq_given"] else next_free_slot(taken)
-            old = VideoPlan.query.filter(VideoPlan.phone == phone,
+            old = VideoPlan.query.filter(VideoPlan.nickname == acct,
                                          VideoPlan.release_date == date,
                                          VideoPlan.seq == seq).first()
             existed = old.to_dict() if old else None
@@ -664,17 +737,16 @@ def upload_video(file_storage, order=None, replace=False):
                 # 同一份内容：库里的行用的就是同一个（内容寻址）文件，
                 # **绝不能删**它 —— 删了这个已引用的文件就没了
                 return {"ok": True, "name": name, "action": "skip", "plan": existed,
-                        "msg": f"{phone} {date} 编号{seq} 已经传过这个文件了（跳过）"}
+                        "msg": f"{acct} {date} 编号{seq} 已经传过这个文件了（跳过）"}
             if not replace:
                 _remove_video_file(rel)     # 内容不同 → 这是刚写的新文件，没人引用，删掉
                 return {"ok": False, "name": name,
                         "error": f"该槽位已有视频 {existed['video_name']}（编号{seq}）——"
                                  f"要换先删掉它，或在结果里点「覆盖」"}
             delete_plan(existed["id"])          # 覆盖：删旧行与旧文件（旧内容若与新内容同，不会被删）
-        row = VideoPlan(id=uuid.uuid4().hex[:8], account_id=acc.get("id", ""),
+        row = VideoPlan(id=uuid.uuid4().hex[:8], account_id="",
-                        phone=phone, device_name=acc.get("device_name", ""),
+                        phone="", device_name="", nickname=acct, douyin_id="",
-                        nickname=acc.get("nickname", ""), douyin_id=acc.get("douyin_id", ""),
+                        serial="", release_date=date, seq=seq,
-                        serial=acc.get("serial", ""), release_date=date, seq=seq,
                         seq_auto=not meta["seq_given"], video_file=rel,
                         video_name=name[:200], video_size=size, video_sha1=digest,
                         status=ST_PENDING, created_at=_now(), updated_at=_now())
@@ -682,11 +754,11 @@ def upload_video(file_storage, order=None, replace=False):
             db.session.add(row)
             db.session.commit()
             out = row.to_dict()
-        _log.info(f"发布计划新增：{phone} {date} 编号{seq} {name}（{size} 字节）"
+        _log.info(f"发布计划新增：{acct} {date} 编号{seq} {name}（{size} 字节）"
                   f"{'覆盖' if existed else ''}")
         return {"ok": True, "name": name, "action": "replace" if existed else "add",
                 "plan": out,
-                "msg": f"已录入：{acc.get('device_name')} / {date} / 编号{seq}"
+                "msg": f"已录入：{acct} / {date} / 编号{seq}"
                        f"（{'待标题' if not (existed or {}).get('title') else '取旧标题'}）"}
     except Exception as e:
         _log.warning(f"视频上传失败: {e}")
@@ -711,23 +783,15 @@ def import_titles(text, dry_run=False):
     rows, errors = parse_titles_text(text)
     counts = {"total": len(rows) + len(errors), "attached": 0, "skipped": 0,
               "rejected": len(errors)}
-    out = [{"line": e["line"], "phone": "", "date": "", "seq": 0, "title": "",
+    out = [{"line": e["line"], "name": "", "date": "", "seq": 0, "title": "",
             "action": "reject", "error": e["reason"]} for e in errors]
     with _ctx():
-        accs = accounts_by_phone()
         for m in rows:
-            phone, date = m["phone"], m["date"]
+            acct, date = m["name"], m["date"]
-            item = {"line": m.get("_line", 0), "phone": phone, "date": date,
+            item = {"line": m.get("_line", 0), "name": acct, "date": date,
                     "seq": m.get("seq") or 0, "title": m["title"],
                     "action": "", "error": ""}
-            if len(accs.get(phone) or []) != 1:
+            q = VideoPlan.query.filter(VideoPlan.nickname == acct,
-                item["action"] = "reject"
-                item["error"] = (f"手机号 {phone} 不在账号台账里" if not accs.get(phone)
-                                 else f"手机号 {phone} 在台账里对应多个账号")
-                out.append(item)
-                counts["rejected"] += 1
-                continue
-            q = VideoPlan.query.filter(VideoPlan.phone == phone,
                                        VideoPlan.release_date == date)
             if m["seq_given"]:
                 row = q.filter(VideoPlan.seq == int(m["seq"])).first()
@@ -735,9 +799,9 @@ def import_titles(text, dry_run=False):
                 row = (q.filter(VideoPlan.title == "").order_by(VideoPlan.seq).first())
             if not row:
                 item["action"] = "reject"
-                item["error"] = (f"该账号 {date} 没有编号 {m['seq']} 的视频"
+                item["error"] = (f"该名字 {date} 没有编号 {m['seq']} 的视频"
                                  if m["seq_given"] else
-                                 f"该账号 {date} 没有待配标题的视频（请先上传视频）")
+                                 f"该名字 {date} 没有待配标题的视频（请先上传视频）")
                 out.append(item)
                 counts["rejected"] += 1
                 continue
@@ -791,10 +855,12 @@ def _sync_content_status(row):
         row.status = ST_PENDING
 
 
-def set_title(plan_id, title, body=None):
+def set_title(plan_id, title, body=None, nickname=None):
-    """人工改标题 /（可选）正文，改完按"有没有内容"切 pending/ready。
+    """人工改标题 /（可选）正文 /（可选）**名字**，改完按"有没有内容"切 pending/ready。
 
     `body=None` = **不动正文**（老调用方语义不变）；传空串 = 清掉正文。
+    `nickname` = 改**识别键**（文件名写错了、或抖音上改了名时的**唯一补救手段**）——
+    同样走 `name_error` 那把尺子（不许含下划线/不许纯数字），不合法直接拒收。
     """
     title = (title or "").strip()
     if len(title) > MAX_TITLE_LEN:
@@ -803,6 +869,12 @@ def set_title(plan_id, title, body=None):
         body = (body or "").strip()
         if len(body) > MAX_BODY_LEN:
             return None, f"正文太长（上限 {MAX_BODY_LEN} 字）"
+    new_name = None
+    if nickname is not None:
+        new_name = (nickname or "").strip()
+        err = name_error(new_name)
+        if err:
+            return None, f"名字不对：{err}"
     with _ctx():
         row = VideoPlan.query.get(plan_id)
         if not row:
@@ -810,6 +882,8 @@ def set_title(plan_id, title, body=None):
         row.title = title
         if body is not None:
             row.body = body
+        if new_name is not None:
+            row.nickname = new_name
         _sync_content_status(row)
         row.updated_at = _now()
         db.session.commit()
@@ -848,7 +922,7 @@ def delete_plan(plan_id, delete_file=True):
     return True
 
 
-def list_plans(date_from="", date_to="", status="", account_id="", q="", limit=500):
+def list_plans(date_from="", date_to="", status="", q="", limit=500):
     """时间线用：按日期区间/状态/账号/关键词取行（按日期、设备号、编号排序）。"""
     with _ctx():
         query = VideoPlan.query
@@ -860,8 +934,6 @@ def list_plans(date_from="", date_to="", status="", account_id="", q="", limit=5
             want = [s for s in status.split(",") if s in STATUSES]
             if want:
                 query = query.filter(VideoPlan.status.in_(want))
-        if account_id:
-            query = query.filter(VideoPlan.account_id == account_id)
         if q:
             like = f"%{q.strip()}%"
             query = query.filter(db.or_(VideoPlan.phone.like(like),
@@ -870,14 +942,14 @@ def list_plans(date_from="", date_to="", status="", account_id="", q="", limit=5
                                         VideoPlan.nickname.like(like),
                                         VideoPlan.douyin_id.like(like),
                                         VideoPlan.device_name.like(like)))
-        rows = (query.order_by(VideoPlan.release_date, VideoPlan.device_name,
+        rows = (query.order_by(VideoPlan.release_date, VideoPlan.nickname,
                                VideoPlan.seq).limit(max(1, min(int(limit or 500), 5000))).all())
         return [r.to_dict() for r in rows]
 
 
-def timeline(date_from="", date_to="", status="", account_id="", q="", limit=500):
+def timeline(date_from="", date_to="", status="", q="", limit=500):
     """时间线数据：按日期分组的卡片 + 顶部统计 + 磁盘。"""
-    rows = list_plans(date_from, date_to, status, account_id, q, limit)
+    rows = list_plans(date_from, date_to, status, q, limit)
     days = {}
     today = _today()
     for r in rows:
@@ -913,7 +985,7 @@ def stats(rows=None):
            "unknown": 0, "skipped": 0, "pushing": 0, "publishing": 0,
            "today_ready": 0, "today_done": 0,
            "today_devices": 0, "published_today": 0, "overdue": 0, "no_link": 0}
-    today_devs = set()
+    today_names = set()          # 今天要发的**号**（计划不绑设备了，"几个号"才是有意义的量）
     for r in rows:
         st = r["status"]
         if st in out:
@@ -921,8 +993,8 @@ def stats(rows=None):
         if r["release_date"] == today:
             if st in (ST_PENDING, ST_READY, ST_PUSHING, ST_PUBLISHING, ST_FAILED):
                 out["today_ready"] += 1
-                if r["device_name"]:
+                if r["nickname"]:
-                    today_devs.add(r["device_name"])
+                    today_names.add(r["nickname"])
             if st == ST_DONE:
                 out["today_done"] += 1
         elif r["release_date"] < today and st in (ST_PENDING, ST_READY, ST_FAILED):
@@ -931,7 +1003,9 @@ def stats(rows=None):
             out["published_today"] += 1
         if st == ST_DONE and not r["share_url"]:
             out["no_link"] += 1
-    out["today_devices"] = len(today_devs)
+    # 键名保留 `today_devices`（前端在用）：口径已改成"今天要发的**名字**个数" ——
+    # 计划不再绑设备，"几台设备"没有意义，"几个号"才是用户看的那个数
+    out["today_devices"] = len(today_names)
     return out
 
 
@@ -957,7 +1031,7 @@ def disk_info():
             "videos_count": count}
 
 
-def links(date_from="", date_to="", device="", phone=""):
+def links(date_from="", date_to="", name=""):
     """已发布作品的分享链接（导出 CSV / 界面展示用）。"""
     with _ctx():
         query = VideoPlan.query.filter(VideoPlan.share_url != "")
@@ -965,24 +1039,24 @@ def links(date_from="", date_to="", device="", phone=""):
             query = query.filter(VideoPlan.release_date >= date_from)
         if date_to:
             query = query.filter(VideoPlan.release_date <= date_to)
-        if device:
+        if name:
-            query = query.filter(VideoPlan.device_name == device)
+            query = query.filter(VideoPlan.nickname == name)
-        if phone:
+        rows = query.order_by(VideoPlan.release_date, VideoPlan.nickname,
-            query = query.filter(VideoPlan.phone == phone)
-        rows = query.order_by(VideoPlan.release_date, VideoPlan.device_name,
                               VideoPlan.seq).all()
         return [r.to_dict() for r in rows]
 
 
 # ================== 发布：取计划 / 占位 / 回写 ==================
-def take_for_device(phones, date, limit=1, retry_failed=True):
+# 取计划的**口径只在这两个内部函数里定义一次**（按列 + 日期 + 状态 + 尝试次数 + 排序）。
-    """本机某天可发的计划行（按发布日期、编号升序）。`phones` = 这台设备上账号的手机号。"""
+# 口径分叉 = 同一个号被发两遍 或 永远发不出去，所以不许在别处再写一套 where。
-    if not phones:
+def _take(column, values, date, limit=1, retry_failed=True):
+    """按某一列（`nickname` / 老路径的 `phone`）取候选行 —— **只读，不占位**（占位是 `claim()`）。"""
+    if not values:
         return []
     want = [ST_READY] + ([ST_FAILED] if retry_failed else [])
     with _ctx():
         rows = (VideoPlan.query
-                .filter(VideoPlan.phone.in_(list(phones)))
+                .filter(column.in_(list(values)))
                 .filter(VideoPlan.release_date <= date)
                 .filter(VideoPlan.status.in_(want))
                 .filter(VideoPlan.attempts < MAX_ATTEMPTS)
@@ -991,25 +1065,103 @@ def take_for_device(phones, date, limit=1, retry_failed=True):
         return [r.to_dict() for r in rows]
 
 
-def peek_for_device(phones, date):
+def _peek(column, values, date):
+    rows = _take(column, values, date, limit=1)
+    return rows[0] if rows else None
+
+
+def _last_pushed(column, values):
+    if not values:
+        return None
+    with _ctx():
+        row = (VideoPlan.query.filter(column.in_(list(values)))
+               .filter(VideoPlan.status == ST_PUSHING)
+               .order_by(VideoPlan.updated_at.desc()).first())
+        return row.to_dict() if row else None
+
+
+def take_for_name(names, date, limit=1, retry_failed=True):
+    """**本机某天可发的计划行（主路径：按名字）**，按 `(发布日期, 编号)` 升序。
+
+    名字 = 上传文件名里的名字 = 抖音昵称；运行时的顺序是「读当前账号名 → 用它取计划」。
+    队列口径：`发布日期 <= date`（**过期会补发、未来的不发**）、`status ∈ (ready, failed)`、
+    `attempts < 3`。
+    """
+    return _take(VideoPlan.nickname, names, date, limit, retry_failed)
+
+
+def peek_for_name(names, date):
     """本机**下一条将要推送**的计划（只看不占位）——条件判断的"候选值来源=发布计划"用它。
 
     为什么用"下一条"而不是"已推送的那条"：账号校验要放在**推送之前**
     （号不对就不该推），那时候还没占位、也没有 `_last_release`。
     """
-    rows = take_for_device(phones, date, limit=1)
+    return _peek(VideoPlan.nickname, names, date)
-    return rows[0] if rows else None
+
+
+def last_pushed_for_name(names):
+    """本机最近一条"已推到手机、还没标记结果"的计划（`mark_release` 找不到上一步时的兜底）。"""
+    return _last_pushed(VideoPlan.nickname, names)
+
+
+def take_for_device(phones, date, limit=1, retry_failed=True):
+    """老路径：按**手机号**取（账号台账停用后不再被骨架使用，留着给还在传 phones 的老任务）。"""
+    return _take(VideoPlan.phone, phones, date, limit, retry_failed)
+
+
+def peek_for_device(phones, date):
+    return _peek(VideoPlan.phone, phones, date)
 
 
 def last_pushed_for_device(phones):
-    """本机最近一条"已推到手机、还没标记结果"的计划（`mark_release` 找不到上一步时的兜底）。"""
+    return _last_pushed(VideoPlan.phone, phones)
-    if not phones:
+
-        return None
+
+def pending_names(date="", retry_failed=True, names=None, limit=0):
+    """**现在还有待发内容的名字**，按最早 `(发布日期, 编号)` 排序。
+
+    `foreach_account` 的"本机该发哪些号"就靠它 —— **直接由计划表回答**：
+    谁还有待发内容谁就在列表里，不需要任何台账/账号维护。查库不读屏，
+    所以已经发完的号根本不会被选中（省掉一次切号）。
+
+    每个名字只返回一条（该名字下**最早**的那条待发计划），给循环按先后顺序挑号用。
+    `names` 传了就只在这些名字里挑（本机"已登录的号"用它做交集）。
+    """
+    date = date or _today()
+    want = [ST_READY] + ([ST_FAILED] if retry_failed else [])
     with _ctx():
-        row = (VideoPlan.query.filter(VideoPlan.phone.in_(list(phones)))
+        q = (VideoPlan.query
-               .filter(VideoPlan.status == ST_PUSHING)
+             .filter(VideoPlan.nickname != "")
-               .order_by(VideoPlan.updated_at.desc()).first())
+             .filter(VideoPlan.release_date <= date)
-        return row.to_dict() if row else None
+             .filter(VideoPlan.status.in_(want))
+             .filter(VideoPlan.attempts < MAX_ATTEMPTS))
+        if names:
+            q = q.filter(VideoPlan.nickname.in_([n for n in names if n]))
+        # 名字做第三排序键：同日期同编号时给个**确定的**先后（不然每轮顺序会变）
+        rows = q.order_by(VideoPlan.release_date, VideoPlan.seq, VideoPlan.nickname).all()
+        out, seen = [], set()
+        for r in rows:
+            n = r.nickname or ""
+            if not n or n in seen:
+                continue
+            seen.add(n)
+            out.append({"name": n, "release_date": r.release_date,
+                        "seq": r.seq, "plan_id": r.id})
+        return out[:int(limit)] if limit else out
+
+
+def pending_count(name, date="", retry_failed=True):
+    """某个名字现在还有几条待发（`foreach_account` 内层靠它判断"这个号还有没有得发"）。"""
+    if not name:
+        return 0
+    date = date or _today()
+    want = [ST_READY] + ([ST_FAILED] if retry_failed else [])
+    with _ctx():
+        return (VideoPlan.query
+                .filter(VideoPlan.nickname == name)
+                .filter(VideoPlan.release_date <= date)
+                .filter(VideoPlan.status.in_(want))
+                .filter(VideoPlan.attempts < MAX_ATTEMPTS).count())
 
 
 def claim(plan_id, status=ST_PUSHING, stage="push"):
@@ -1043,12 +1195,12 @@ def pushable_plans(date="", limit=0, retry_failed=True):
         sts = [ST_READY] + ([ST_FAILED] if retry_failed else [])
         q = q.filter(VideoPlan.status.in_(sts))
         q = q.filter(VideoPlan.attempts < MAX_ATTEMPTS)
-        q = q.order_by(VideoPlan.device_name, VideoPlan.seq)
+        q = q.order_by(VideoPlan.nickname, VideoPlan.seq)
         rows = q.limit(limit).all() if limit else q.all()
         return [r.to_dict() for r in rows]
 
 
-def mark_pushed(plan_id, remote="", verify=""):
+def mark_pushed(plan_id, remote="", verify="", serial="", device_name=""):
     """推送完成：状态留在 `pushing`（= 已推到手机、等人/用户的步骤去发），阶段置 `manual`。
 
     阶段置 `manual` 是为了僵尸回收时的语义正确：**再出岔子只能算"结果未知"**，
@@ -1057,6 +1209,9 @@ def mark_pushed(plan_id, remote="", verify=""):
     `verify` = 相册校验结果（`ok` 进索引 / `no_index` 没进 / `nofile` 文件不在），
     **单独存一列**而不是混进 last_error：文件推上去了就不是失败，
     但"相册里看不到它"必须能在界面上看见（后面的步骤要点它）。
+
+    `serial`/`device_name` = **实际推到哪里**（写进 `posted_*`）：计划不绑设备了，
+    "这条最后是谁发的"只能由推送时那一台现场记 —— 排查"发到哪台机器去了"全靠它。
     """
     with _ctx():
         row = VideoPlan.query.get(plan_id)
@@ -1070,6 +1225,10 @@ def mark_pushed(plan_id, remote="", verify=""):
             row.push_remote = remote[:200]
         if verify:
             row.push_verify = verify[:16]
+        if serial:
+            row.posted_serial = serial[:120]
+        if device_name:
+            row.posted_device_name = device_name[:80]
         row.updated_at = _now()
         db.session.commit()
 

doc/API.md

@@ -139,13 +139,7 @@
 | 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}`） |
+| POST | `/api/video_plan/upload_video` | D | 上传单个素材（**视频或图片**，文件名 `名字_日期_编号`）→ 解析名字 + 入计划 |
-| 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_titles` | D | 上传标题（txt 文本或文件）→ 配到已有计划行 |
 | GET | `/api/video_plan/timeline` | D | 发布计划时间线（按日期分组的卡片 + 统计 + 磁盘） |
 | GET | `/api/video_plan/stats` | 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 | 一键新建标准发布任务（骨架 17 步：亮屏 → 打开抖音 → 校验账号 → 推送 → 抖音点击 → 填标题 → 填正文 → 标记） |
+| 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_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,body,action,error}], msg}`；**一行里可带正文**：`标题 || 正文 _手机号_日期_编号`（`||` 分隔，正文可省，只切第一处）；**两种写法都认**：标题在前（推荐，右锚定，标题里可带下划线）或 `手机号_日期_编号_标题 || 正文`（左锚定，跟视频文件名同序），**编号都可省略**；标题里可以有 `#话题`；空行忽略，`#` 开头的行**只有认不出手机号/日期时**才当注释；拒收条件：手机号不在台账/命中多个、日期不合法、标题为空或 >100 字、该槽位已有标题、没有对应视频 |
+| `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=&account_id=&q=&limit=` | `{ok, days:[{date,weekday,total,done,plans:[…]}], stats, disk, today}` |
+| `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/<id>/push` | — | **把素材推到手机**（只推送、不发布）：**按名字找设备**（实时探测哪台在线设备登着这条计划的名字）→ 推文件 → 触发相册刷新 → 标题写进剪贴板；已推送/结果未知 → 409；没有设备登着这个名字 → **400 + 人话原因**（先去切号） |
-| `POST /api/video_plan/push_all` | `{date?, retry_failed?}` | **一键推送**：某天（默认今天）`ready`/`failed` 且未超尝试上限的计划，**按设备分组**推（每台设备一个线程、设备内串行；设备间并行）。返回 `{ok,count,devices,no_device,msg}`；没绑上设备地址的条数单独在 `no_device` 里报出来。全部设备都解析不到 → 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"}` | 一键新建：骨架 **17 步**（亮屏 → 打开抖音(等首页) → 点「我」→ `if_el(cmp_source=release)` 校验账号 → then: `push_release` → 「+」(预填 `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` |
+| `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()`（内存+库一起改） |
+| `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`（实时探测在 `core/account_probe.py`）；上传前把队列**按文件名排序**并让用户确认解析结果（顺序 = "无编号按顺序配"的依据）。就地编辑只放常用字段（名字/目标/时间/启停/逐步参数 + 抓取元素），更复杂的编排走「打开通用编辑器」→ `openTaskModal`；步骤路径里 `then/else/children` 在**步骤的 params 下**（`_rpWalk`），走错这一层会把分支当数组下标用 |
-| `release.js` | 发布计划页（时间线按日期分组 / 多选视频**串行**上传 + 逐文件进度与结果 / 标题+正文 txt 上传（`标题 || 正文 _手机号_日期_编号`，**不显示账号名称、只显示抖音号**）/ 推送到手机 + **一键推送**（当天全部）、相册校验徽章与裁决 / 链接复制与导出 CSV / **发布任务的就地编辑**） | 服务层 `core/video_plan.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

@@ -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；任务「条件判断」的取号来源、设备端身份页显示用） |
+| 16 | `device_account` | **已停用**：账号台账（见 §2.10；2026-10-12 起页面/接口/任务依赖全部下线，**表和 42 行历史数据保留、仍在备份内**，可回滚） |
-| 17 | `video_plan` | 视频发布计划：账号 × 发布日期 × 编号 → 素材 + 标题 + 发布状态 + 分享链接（见 §2.11） |
+| 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,44 +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`）
+⚠️ 历史提醒：`douyin_id` 是纯号，**绝不能当去重身份**（`done_mark.identity` 存的是元素原文、
-2. **任务的「条件判断」取号** —— `if_el` 的 `cmp_source`（`device` 本机 / `all` 全部 / `group` 按设备分组），
+逐字算 key，格式不一致会让去重静默失效）—— 这是当年 `cmp_source` 取号的边界，
-   见 [TASK_DEV.md](TASK_DEV.md) §4.2
+现在候选值来自"本次要发的名字"，同理不得拿去填 `ident_value`。
-3. **手机端 Agent 的身份大字页** —— 平台推 `accounts_b64`（见 [DEVICE_AGENT.md](DEVICE_AGENT.md) §5.2）
 
-⚠️ **`douyin_id` 是纯号，绝不能当去重身份**：`done_mark.identity` 存的是**元素原文**
+这张表**仍在整库备份内**（§6 派生规则）—— 停用不等于删数据。
-（`抖音号：35377983067`）、逐字算 key，格式不一致会让去重**静默失效**。
-它只做"比对用的候选值"（运算符用「包含」时纯号是子串）。
 
-**唯一性在应用层**（`core/ledger`）：同一抖音号不允许两条。没做成 DB 唯一索引的理由：
+### 2.11 `video_plan` — 视频发布计划（**一个名字**在某天要发的一个视频）
-抖音号可能为空，DB 级要写"部分唯一索引"（§4.2 那套 SQLite `WHERE` + MySQL 虚拟生成列），
-而台账是人工维护的几十条 —— 三处方言适配不划算。
 
-这张表**自动进整库备份**（§6 派生规则）。
+「发布计划」页维护；服务层 `core/video_plan.py`，接口 `/api/video_plan/*`（见 [API.md](API.md) §2.14），
-
-### 2.11 `video_plan` — 视频发布计划（一个账号在某天要发的一个视频）
-
-「账号 → 发布计划」页维护；服务层 `core/video_plan.py`，接口 `/api/video_plan/*`（见 [API.md](API.md) §2.14），
 任务步骤「发布视频」按它自动发布（见 [TASK_DEV.md](TASK_DEV.md) §4.7）。
-**素材文件**落在 `data/videos/YYYY-MM/`（文件名 `{sha1[:12]}_{安全原名}`，内容寻址），**不进整库备份**（§6）。
+**素材文件（视频/图片）**落在 `data/videos/YYYY-MM/`（文件名 `{sha1[:12]}_{安全原名}`，内容寻址），**不进整库备份**（§6）。
 
 | 列 | 类型 | 说明 |
 |----|------|------|
 | `id` | String(32) PK | uuid 前 8 位 |
-| `account_id` / `phone` | String(32) | 台账行 id（**不做外键**）/ 配对键（冗余存：账号删了也留痕） |
+| `nickname` | String(80) | **识别键**：上传文件名里的**名字**（= 抖音昵称）。运行时就按它取计划、找设备/账号 |
-| `device_name` / `nickname` / `douyin_id` / `serial` | String | 账号与设备快照（时间线卡片直接显示，免 join） |
+| `account_id` / `phone` / `douyin_id` / `device_name` / `serial` | String | **已停用**（老台账快照，保留列不再写入）：账号 id / 手机号 / 抖音号 / 设备号 / 地址 |
 | `release_date` | String(10) index | **`2026-09-12`** 纯日期（等值比较走索引） |
 | `seq` / `seq_auto` | Integer / Boolean | 编号从 **1** 起（不用 0 表示"无"）；`seq_auto`=号是自动分配的 |
 | `title` | Text | **标题**（发布页的「标题」框；标题 txt 配对写入） |
-| `body` | Text | **正文/文案**（发布页的文案框，可带 `#话题`）—— 标题 txt 一行里用 `||` 分隔：`标题 || 正文 _手机号_日期_编号`；**标题与正文都为空的行不会被发布** |
+| `body` | Text | **正文/文案**（发布页的文案框，可带 `#话题`）—— 标题 txt 一行里用 `||` 分隔：`标题 || 正文_名字_日期_编号`；**标题与正文都为空的行不会被发布** |
-| `video_file` / `video_name` / `video_size` / `video_sha1` | 各自 | 落盘相对路径 / 原始名 / 大小 / 内容指纹（重复上传判据） |
+| `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` | | 失败原因 / 人工备注 / 时间 |
 
 **状态机**（本表的灵魂，别简化）：
@@ -276,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)` 账号视角 ·
+**索引**：`(release_date,status)` 时间线主查询 · `(nickname,release_date)` **按名字取计划/查重**（主路径）·
-`(phone,release_date,seq)` 配对/幂等 · `(video_file)` 清理时反查引用。
+`(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**，
+- 身份页 extras（`name`/`ip`/`serial`/`server`/`close`）是**平台单向下发**：设备端多收/少收
-  设备端忽略它时行为必须与旧版逐字一致（只是大字页少一块内容）。也**不**走
+  都不影响旧行为。（2026-10-12：账号台账下线，原先顺带下发的 `accounts_b64` 已不再发送 ——
-  `bootstrap`：身份页由平台用 adb 推，加进 bootstrap 没人用还会让契约多一处要同步。
+  设备端收到"没有这个 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`）负责在编辑器里呈现这些字段。
 
@@ -131,14 +131,18 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 | 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)、`verify`(True)、`max_attempts`(2)、`on_login_page`(stop) | — | **只在本机已登录过的号之间切**：当前已是目标→直接成功；否则点「我」→ 点切换入口 → **在列表里按名字找控件点击**（**禁 `[N]` 序号**：序号型会随界面变形错位）→ 等重载 → **回读校验**。列表里没这个名字 = 本机没登这个号 → 立刻 False（不重试、不算故障）。停在登录/验证码页 → 通知 + 默认停本设备（平台不做登录/滑块）。见 §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`→设备名 匹配） |
+| `account_target` | **本次要发的那个名字**：循环块设的目标名字优先，没有就用「读取本机账号名字」刚读到的|
-| `all` | 全部台账 |
+| `release` | **本机当前发布计划**要发的那个名字：优先本次运行里「推送发布视频」刚取到的那条；还没有就**看**下一条待发的（只看不占位） |
-| `group` | 某个**设备分组**内所有设备的号（分组名填在 `cmp_group`） |
-| `release` | **本机当前发布计划**要发的那个号：优先本次运行里「推送发布视频」刚取到的那条；还没有就**看**下一条待发的（只看不占位）。候选值是**抖音号 + 账号名称**两个（任一命中即可） |
 
-#### `release`：发布前先确认"登的是要发的那个号"（一台手机登好几个号时必配）
+#### `account_target`：发布前先确认"登的是要发的那个号"（一台手机登好几个号时必配）
 
-一台手机可能登着好几个号，发布前必须确认当前抖音登的就是这条计划要发的号 ——
+一台手机可能登着好几个号，发布前必须确认当前抖音登的就是**这次要发的**那个号 ——
-就在发布流程**最前面**放一个条件判断（`cmp_source=release` + `包含`），命中了才走发布，
+就在发布流程**最前面**放一个条件判断（`cmp_source=account_target` + `包含`），
-没命中走 `else`（发通知/跳过）。这样"发错号"变成"这条跳过"，而不是把 A 号的视频发到 B 号上。
+命中了才走发布，没命中走 `else`（发通知/跳过）。这样"发错号"变成"这条跳过"，
+而不是把 A 号的视频发到 B 号上。
 
-- 比对的元素原文：抖音「我」页面上的那一行（如 `//*[contains(@text,'抖音号')]`）——
+- 比对的元素原文 = **昵称控件**（和「读取本机账号名字」用**同一个选择器**，抓一次两处都填）；
-  `cmp_source=release` 给的候选值包含**抖音号**，所以 `包含` 就能命中。
+  候选值是名字，所以用 **`包含`**。
-- 命中判据是**候选值里任一被元素原文包含**；两个候选值（抖音号、昵称）是刻意的：
+- **读不到名字 → 候选为空 → 这一步永远走 `else`**（日志会写明"没读到本次要发的名字"）。
-  有的界面只显示昵称。
+  这是故意的：**读不到名字 = 不知道现在登的是谁 = 不发**。
-- **本机没有待发计划 → 候选为空 → 这一步永远走 `else`**（日志会写明"本机没有待发的发布计划"），
+- ⚠ **绝不能用「不等于」**：读不到名字时候选为空，`不等于` 对空候选算**命中**，
-  不会把不该发的号发出去。
+  会把"读不到"误判成"可以发"。
+- **与手填值是合并（OR）**，不是二选一：平台给的候选 + 你补的值，任一命中即可
+  （平台的候选取不到时手填值仍然生效，不会把任务直接打哑）。
+- 「推送发布视频」自己**还会再核对一次**（推送前重读昵称，见 §4.7），所以就算这个条件判断
+  没画，也不会发错号 —— 条件是给"要先看一眼再决定"的场景用的。
 
-- **与手填值是合并（OR）**，不是二选一：台账里的号 + 你补的一个号，任一命中即可。
+> ⚠ **比对用的候选值绝不能拿去填「去重」的身份元素**（`ident_value`）：
-  更重要的是 —— **台账取不到号时手填值仍然生效**，台账没维护好不会把任务直接打哑。
-- 取到 0 个号时**日志会写明原因**（如"设备名对不上"）：
-  候选为空会让这一步**永远走 `else` 分支**，而任务本身照样"跑完了"。
-  编辑器保存时也会为此报警告，请到「账号」页核对设备号。
-- 比对运算符仍要选：台账里是**纯号**（`35377983067`），元素原文是
-  `抖音号：35377983067` → 用 **`包含`**。（要整段一模一样才用 `等于`。）
-
-> ⚠ **台账的纯号只能当"比对用的候选值"，绝不能拿去填「去重」的身份元素**（`ident_value`）：
 > 去重身份存的是**元素原文**、逐字算 key（`core/dedup.py` 的 `build_key`），
-> 格式不一致（`35377983067` vs `抖音号：35377983067`）会让**检查与记账算出两个不同的
+> 格式不一致（`小王` vs `昵称：小王`）会让**检查与记账算出两个不同的 key → 去重静默失效**
-> key → 去重静默失效**（重复评论，而且日志看不出问题）。
+> （重复评论，而且日志看不出问题）。去重身份继续用「抓取元素」抓到的那个账号元素即可。
-> 去重身份继续用「抓取元素」抓到的那个账号元素即可。
 
 ### 4.3 公共参数
 
@@ -464,35 +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]  →  [推送发布视频]  →  [你自己写的发布步骤…]  →  [标记发布结果]
+[读取本机账号名字] → [条件判断 account_target] → [推送发布视频] → [你的发布步骤…] → [标记发布结果]
- 当前登的是要发的号吗？             push_release        打开抖音→点+→相册→选视频       mark_release
+ read_account_name    登的是要发的号吗？            push_release     打开抖音→点+→相册→选视频   mark_release
- 不是 → else：发通知（本条跳过）                        →下一步→粘贴标题→发布          result=published 放成功分支
+                       不是/读不到 → else：通知跳过                   →下一步→填标题→填正文→发布  published 放成功分支
-                                                                                 result=failed 放失败分支
+                                                                                            failed 放失败分支
 ```
 
-**先校验账号再发**（一台手机登好几个号时必配）：放在最前面的条件判断用
+**先读名字、再校验、最后才发**（一台手机登好几个号时必配）：
-`cmp_source=release`（候选值 = 本机要发的那条计划的**抖音号/账号名称**，见 §4.2），
+
-元素原文取抖音「我」页面上的 `//*[contains(@text,'抖音号')]`，运算符 `包含`；
+- 「读取本机账号名字」：读抖音「我」页面上的**昵称控件**（选择器抓一次填进 `.env` 的 `DOUYIN_NAME_SELECTOR_VALUE`），
-没命中就走 `else` —— **宁可不发，也不发错号**。
+  清洗后的名字进运行期变量（见 §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)`（**done/skipped 永不入队**）、`attempts < 3` 的行，
    按 `(发布日期, 编号)` 升序取最早的 —— 即"按顺序发没发过的"
-③ **原子占位**：UPDATE … SET status='pushing' WHERE id=? AND status IN ('ready','failed')
+   （名字从哪来：「读取本机账号名字」读到的，或循环块设的目标名字，见 `_release_scope`）
+② **原子占位**：UPDATE … SET status='pushing' WHERE id=? AND status IN ('ready','failed')
    ← **幂等的唯一判据**（多设备/任务重跑不会把同一条推两遍）
-④ adb push → {album_dir}/{计划id}.mp4（默认 /sdcard/DCIM/Camera）→ 校验**大小**（按 ls -l 的大小列比）
+③ adb push → {album_dir}/{计划id}.mp4（默认 /sdcard/DCIM/Camera）→ 校验**大小**（按 ls -l 的大小列比）
-⑤ **touch 一下**把手机上这个文件的 mtime 改成"现在" + 清掉同一计划在旧目录里的副本
+④ **touch 一下**把手机上这个文件的 mtime 改成"现在" + 清掉同一计划在旧目录里的副本
-⑥ 触发媒体扫描 → **按路径**校验它真的进了相册索引 → 把标题写进手机剪贴板（供「粘贴」用）
+⑤ 触发媒体扫描 → **按路径**校验它真的进了相册索引 → 把标题写进手机剪贴板（供「粘贴」用）
 ```
 
 **为什么是 `DCIM/Camera`、为什么要 touch**（都是实测踩出来的）：
@@ -548,7 +584,7 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 - **你的发布步骤里，文案要用「粘贴」**（推送时标题已进剪贴板）；如果非要用「输入文字」，
   记得后面加一步**回读校验**（读输入框的 text）—— 抖音的 EditText 有时不吃 `send_keys`，
   不校验就可能发出一篇空文案而每一步都显示成功。
-- **不靠 `done_mark` 判重**：去重账本的 identity 是元素原文，与 `(手机号,日期,编号)` 两套 key
+- **不靠 `done_mark` 判重**：去重账本的 identity 是元素原文，与 `(名字,日期,编号)` 两套 key
   语义不同，混用会静默失效。
 - **任务状态 ≠ 发布结果**：`_exec_steps` 不检查步骤结果，**标记失败不会让任务失败** ——
   「这次发布的真相」以计划行的 `status` 为准（计划页看得到），并会推

doc/research/U2_ELEMENT_SELECTORS.md

@@ -172,3 +172,61 @@
 `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
+- ⚠ **第一次实现踩的坑**：把"进列表"后的等待写成**固定 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,211 @@
+# -*- 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}
+
+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,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}}
@@ -478,9 +481,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">'+
         [['','不比对（只看元素在不在）'],['等于','等于'],['不等于','不等于'],['包含','包含'],['不包含','不包含']]
@@ -488,28 +491,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','按设备分组'],
+        [['','手填（默认）'],['account_target','本次要发的名字（读名字/循环块给的）'],
-         ['release','本机当前发布计划（要发的那个号）']]
+         ['release','本机当前发布计划（要发的那条）']]
           .map(function(o){return '<option value="'+o[0]+'"'+((p.cmp_source||'')===o[0]?' selected':'')+'>'+o[1]+'</option>';}).join('')+
         '</select><div class="help">'+(p.cmp_source==='release'
-          ? '取<b>本机下一条要发的发布计划</b>的抖音号 + 账号名称（推送前校验"当前登录的是不是要发的号"就用它）'
+          ? '取<b>本机下一条要发的发布计划</b>的<b>名字</b>（推送前校验"当前登的是不是要发的号"就用它）'
-          : '台账在「账号」页维护')+'</div></div>'+
+          : (p.cmp_source==='account_target'
-        (cmpSrc==='group'?
+             ? '取<b>本次要发的那个名字</b>（「读取本机账号名字」读到的，或循环块设的目标）。'
-          '<div class="form-group"><label>设备分组名</label>'+
+               +'<b>读不到名字时候选为空 → 不命中 → 走 else（不发）</b>，这是故意的'
-          '<input class="form-control" data-key="cmp_group" value="'+esc(p.cmp_group||'')+'" '+
+             : '手填要比对的文本；要用本机账号名就用上面的两个来源'))+'</div></div>'+
-          'placeholder="分组名（工具→设备分组）"></div>':'')+
+        // 候选值来自平台时**只隐藏、不删**这个输入框：_syncParams 是按 DOM 存在与否收集的，
-        // 选台账时**只隐藏、不删**这个输入框：_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>：这台设备在台账里登记的抖音号会作为候选，'
+        +(fromPlatform?'<br>候选值由平台给（上面选的来源），手填的值会<b>追加</b>在后面。':'')
-          +'手填的值<b>追加</b>在后面（台账取不到号时只用手填值，不会把任务打哑）。'
-          +'<br>⚠ 台账只提供<b>比对用的号</b>；<b>不要</b>把台账号填到「去重」的身份元素里'
-          +'（身份是元素原文、逐字比，格式不同会让去重静默失效）。':'')
         +'</div></div></div>';
       // 「去重」条件：身份元素用 ident_type/ident_value（主选择器那行只剩类型下拉）
       var identRow=isDedup?_selRowHtml(p,
@@ -857,7 +856,7 @@ var _stepEditor={
     var self=this;
     setTimeout(function(){self._renderCanvas();},0);
   },
-  // 条件判断：候选值来源切到台账时，把"比对的值"藏起来（按分组还要显示分组名输入框）
+  // 条件判断：候选值来源切到"平台给"（本次要发的名字 / 发布计划）时，把"比对的值"藏起来
   _cmpSourceChanged:function(sel){
     // 同 _condTypeChanged：先把 DOM 的值同步回 _steps，否则重渲染会吞掉刚改的东西
     this._syncFromDom();
@@ -981,17 +980,17 @@ var _stepEditor={
             warnings.push(name+' "'+label+'": 条件判断的选择器为空，会直接走"未找到"分支。');
           }
           var cmpSrcV=(s.params.cmp_source||'');
-          var fromLedger=(cmpSrcV==='device'||cmpSrcV==='all'||cmpSrcV==='group');
+          var fromPlatform=(cmpSrcV==='account_target'||cmpSrcV==='release');
-          // 候选值"从别处取"的那两档（台账 / 发布计划）：手填可以留空，别报"没填值"
+          // 候选值"平台给"的那两档（本次要发的名字 / 发布计划）：手填可以留空，别报"没填值"
-          var fromOther=(fromLedger||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){
+          if(cmpUsed&&cmpSrcV==='account_target'&&s.params.cmp_op){
-            warnings.push(name+' "'+label+'": 候选值来自台账 —— 台账里没有这台设备'
+            warnings.push(name+' "'+label+'": 候选值来自"本次要发的名字" —— 前面要有'
-              +'（或设备池里的设备名与台账「设备号」对不上）时会取不到号，'
+              +'「读取本机账号名字」步骤（或循环块设的目标名字），名字读不到时候选为空、'
-              +'这一步将永远走"未找到"分支。请到「账号」页核对设备号。');
+              +'这一步会走"未找到"分支。这是设计如此（读不到名字 = 不发）。');
           }
           if(cmpUsed&&cmpSrcV==='release'&&s.params.cmp_op){
             warnings.push(name+' "'+label+'": 候选值来自"本机当前发布计划" —— 本机没有待发的计划'

static/admin/ledger.js

@@ -1,297 +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="9" 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.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="9" 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 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.douyin_id || a.phone)) : '新增账号';
-  var h = '<div class="form-row">' +
-    _ledgerField('设备号', 'device_name', a && a.device_name, '如 A01（要和设备池里的设备名一致）') +
-    '<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.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>）' +
-    '（认不出的列会被忽略）。<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;备注&#10;A01&#9;13800000000&#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 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></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 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></tr></thead>' +
-    '<tbody>' + (rows || '<tr><td colspan="6" 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> 个'
+  el.innerHTML = '今天要发 <b>' + (s.today_ready || 0) + '</b> 条'
-    + '（' + (s.today_devices || 0) + ' 台） · 今天已发 <b>' + (s.today_done || 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,9 +97,10 @@ function renderReleaseTimeline() {
 }
 
 function rpCard(p) {
-  var acc = '<b>' + esc(p.device_name || '?') + '</b>　'
+  var acc = '<b>' + esc(p.nickname || '?') + '</b>'
-    + '<span class="text-muted" style="font-family:var(--mono)">'
+    + (p.posted_device_name
-    + esc(p.douyin_id || p.phone) + '</span>';
+        ? '　<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>' : '')
@@ -128,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>');
   }
@@ -137,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>'));
@@ -165,13 +166,13 @@ function renderReleaseTable() {
   setListPager('release', {
     data: function () { return _rpRows; },
     filter: function (p, kw) {
-      return ((p.device_name || '') + (p.phone || '') + (p.douyin_id || '')
+      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>'
+      return '<tr><td>' + esc(p.release_date) + '</td><td><b>' + esc(p.nickname || '-') + '</b></td>'
-        + '<td>' + esc(p.douyin_id || p.phone || '-') + '</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>'
@@ -181,7 +182,7 @@ function renderReleaseTable() {
         + 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="10" class="empty">这个范围里没有计划</td></tr>'
@@ -206,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 = '';
+  var date = '', seq = '', bad = '';
-  parts.forEach(function (p) {
+  if (parts.length >= 3 && _RP_SEQ.test(parts[parts.length - 1])
-    if (!p) { bad = '有空片段'; return; }
+      && _RP_DATE.test(parts[parts.length - 2])) {
-    if (_RP_PHONE.test(p)) { phone = phone || p; }
+    seq = parts.pop(); date = parts.pop();
-    else if (_RP_DATE.test(p)) { date = date || p; }
+  } else if (parts.length >= 2 && _RP_DATE.test(parts[parts.length - 1])) {
-    else if (_RP_SEQ.test(p)) { seq = seq || p; }
+    date = parts.pop();
-    else bad = bad || p;
+  } else {
-  });
+    bad = '结尾不是日期或「日期_编号」';
-  return { phone: phone, date: date, seq: seq, bad: bad,
+  }
-           ok: !!phone && !!date && !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) {
@@ -241,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>）。'
@@ -251,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>')
+        ? esc(c.name) + ' / ' + 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>';
+        : '<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>'
@@ -375,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> 或 <code>手机号_日期_编号_标题</code>（都认，编号可省，标题里可以有 <code>#话题</code>）；<br>没写编号的按顺序配到该账号当天还没标题的视频上。</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>';
@@ -403,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>';
@@ -415,25 +425,39 @@ function rpDoTitles(dry) {
 
 // ================== 单条操作 ==================
 function rpPushToDevice(id) {
-  if (!confirm('把这条的素材推到手机？\n\n只推送、不发布 —— 推完状态变「已推送到手机」，'
+  if (!confirm('把这条的素材推到手机？\n\n'
-    + '标题会同时写进手机剪贴板；之后由你（或你写的任务步骤）在手机上发布，发完点「标记已发布」。')) return;
+    + '平台会**按这条计划的名字找设备**：实时看哪台在线设备现在登着这个号，推给它。\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;
+    + '平台会**按名字找设备**：哪台在线设备现在登着这个号，就推给谁（同台设备串行推）。\n'
-  apiPost('/api/video_plan/push_all', {}).then(function (r) {
+    + '没有设备登着的号会列出来（先去那台设备上切号）。')) return;
-    if (r && r.ok) { showToast(r.msg || '已开始推送', 'success'); setTimeout(loadReleasePlan, 2000); }
+  apiPost('/api/video_plan/push_by_account', {}).then(function (r) {
-    else showToast((r && r.error) || '失败', 'error');
+    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');
+    }
   });
 }
 
@@ -485,10 +509,13 @@ 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];
-  document.getElementById('modal-title').textContent = '改标题 / 正文';
+  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>'
@@ -500,9 +527,10 @@ function rpEditTitle(id) {
 }
 
 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, { title: t, body: b }).then(function (r) {
+  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');
   });
@@ -671,7 +699,7 @@ function rpNewTargetChanged() {
   sel.innerHTML = html || '<option value="">（没有可选项）</option>';
 }
 
-// ============ 发布任务的**就地编辑**（就在「账号 → 发布计划」这一页，不跳任务页）============
+// ============ 发布任务的**就地编辑**（就在「发布计划」这一页，不跳任务页）============
 // 为什么单独做一套：发布任务的步骤是固定的那十几步，用通用编辑器（拖拽画布）编它要来回跳页，
 // 而这一页的人真正要干的只有一件事 —— **把抖音那几个空选择器抓一遍**。
 // 所以这里给一组紧凑表单：改名字/目标/时间/启停 + 逐步改参数（选择器带「抓取元素」）；
@@ -700,9 +728,33 @@ var _RP_FIELDS = {
                ['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'],
+                   ['verify', '切完回读校验（对不上就不发）', 'chk'],
+                   ['max_attempts', '最多试几次', 'num'],
+                   ['on_login_page', '遇到登录页', 'sel', [['stop', '停本设备（推荐）'],
+                                     ['continue', '记一句继续']]]],
   mark_release: [['result', '标记为什么结果', 'sel', [['published', '已发布（成功）'],
                   ['failed', '确认没发出去（可重试）'],
                   ['unknown', '拿不准（绝不自动重发）']]],
@@ -715,10 +767,9 @@ var _RP_FIELDS = {
           ['timeout', '超时(秒)', 'num'],
           ['cmp_op', '文本比对', 'sel', [['', '不比对（只看元素在不在）'], ['等于', '等于'],
                      ['不等于', '不等于'], ['包含', '包含'], ['不包含', '不包含']]],
-          ['cmp_source', '候选值来源', 'sel', [['', '手填'], ['device', '本机台账'],
+          ['cmp_source', '候选值来源', 'sel', [['', '手填'],
-                         ['all', '全部台账'], ['group', '按设备分组'],
+                         ['account_target', '本次要发的名字（读名字/循环块给的）'],
-                         ['release', '本机当前发布计划（要发的那个号）']]],
+                         ['release', '本机当前发布计划（要发的那条）']]],
-          ['cmp_group', '分组名（来源选"按设备分组"时填）', 'text'],
           ['cmp_value', '比对的值（一行一个，任一命中即可）', 'area']],
   mark_done: [['selector_type', '选择器类型', 'seltype'], ['selector_value', '选择器值', 'selval']],
   clipboard: [['text', '要放进剪贴板的文字', 'text']],

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(!r||!r.ok){tb.innerHTML='<tr><td colspan="8" class="empty">加载失败</td></tr>';return;}
-  // 账号台账：这台设备登记了几个号（顺手把明细也缓存下来，点开就弹）
-  if(typeof loadLedgerCounts==='function'){
-    try{ await loadLedgerCounts(); }catch(e){}
-  }
   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")
 
@@ -129,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, "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": "🏁",
@@ -254,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 内部标识，用来记"下次到点 / 上次命中"两个节奏
@@ -366,8 +385,8 @@ class GenericStepsWorker(BaseWorker):
             _log.warning(f"[{self.serial}] 未知步骤类型: {stype}")
             result, detail = "unknown", f"未知步骤类型: {stype}"
         self._record_step(step, result, detail, int((time.time() - t0) * 1000))
-        # 容器步骤（loop/group/if_el）不计入操作计数，避免监控显示噪音
+        # 容器步骤（loop/group/if_el/foreach_account）不计入操作计数，避免监控显示噪音
-        if stype not in ("loop", "group", "if_el"):
+        if stype not in ("loop", "group", "if_el", "foreach_account"):
             self._action_counts[label] = self._action_counts.get(label, 0) + 1
         elapsed = self.elapsed()
         # done=累计执行的操作次数（无固定总数），前端显示"已执行 N 次操作"
@@ -839,21 +858,25 @@ class GenericStepsWorker(BaseWorker):
         · 取 0 个号时**必须留痕**：候选为空 ⇒ 这一步永远走 else 分支，而任务本身
           "跑完了、显示成功"，不写日志就只能靠人猜。
         · ⚠ 这里产出的只是**比对用的文本**，绝不参与去重 identity：
-          身份是元素原文逐字算 key，台账里是纯号，格式不同会让去重静默失效
+          身份是元素原文逐字算 key，候选值格式不同（`小王` vs `昵称：小王`）会让
-          （见 core/ledger.py 顶部的警告）。
+          去重静默失效（见 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"):
+        elif source == "account_target":
-            ids, note = ledger.douyin_ids(
+            # 「本次要发的名字」= 循环块设的目标名字，没有就用刚读到的名字（见 _release_scope）。
-                source, serial=self.serial,
+            # ⚠ 读不到名字时候选**为空** → 永远不命中 → 走 else 分支（**不发**）。
-                device_name=(self.ctx or {}).get("device_name", ""),
+            #   这正是想要的：读不到名字 = 不知道现在登的是谁 = 不能发。
-                group=str(params.get("cmp_group") or "").strip())
+            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]
@@ -862,48 +885,404 @@ class GenericStepsWorker(BaseWorker):
                 f"[{self.serial}] 条件判断取号为空（来源 {source}）：{note}；手填候选 "
                 f"{len(manual)} 个 → "
                 + ("仅用手填值" if manual else "候选为空，这一步将永远不命中（走未找到分支）"))
-        where = "发布计划" if source == "release" else f"台账({source})"
+        where = "发布计划" if source == "release" else "本次要发的名字"
-        src_txt = (f"候选来自{where} {len(ids)} 个号" if ids
+        src_txt = (f"候选来自{where}：{'、'.join(ids)}" if ids
-                   else f"{where}取号为空：{note}")
+                   else f"{where}取不到：{note}")
         if manual:
             src_txt += f"，另加手填 {len(manual)} 个"
         return "\n".join(merged), src_txt
 
-    def _release_targets(self, params):
+    def _scope_name(self):
-        """推送/标记步骤共用的"取本机账号手机号"逻辑。返回 (phones, who)。"""
+        """本次要发的**名字**：循环块设的目标优先，其次刚读到的本机账号名字。取不到返回 ""。"""
-        from core import ledger
+        return ((self._vars.get("target_name") or "").strip()
-        phone = (params.get("account_phone") or "").strip()
+                or (self._vars.get("account_name") or "").strip())
-        if (params.get("account") or "device") == "phone" and phone:
+
-            return [phone], f"指定手机号 {phone}"
+    def _release_scope(self, params):
-        _, rows, note = ledger.resolve_device(
+        """推送/标记/输入文字共用的"这次发的是哪个号"。返回 `(mode, values, who)`。
-            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}）"
+        `account` 参数：
+          · `name`（默认）—— **本次要发的名字**（`_scope_name()`）。名字取不到时 values 为空，
+            调用方按"没有号"跳过：**绝不猜一个号去发**（读不到名字 = 不发）。
+          · `phone` —— 手填手机号（老任务兼容；账号台账已停用，新任务别再用这条）。
+
+        **这个口径只在这一处定义**（`push_release` / `mark_release` / `input_text` 都走它）：
+        分叉就会出现"推的是 A 号、标记的是 B 号"这种对不上的账。
+        """
+        mode = (params.get("account") or "name").strip().lower()
+        if mode == "phone":
+            phone = (params.get("account_phone") or "").strip()
+            return ("phone", [phone] if phone else [],
+                    f"指定手机号 {phone}" if phone else "没填手机号 → 跳过")
+        name = self._scope_name()
+        if not name:
+            return ("name", [],
+                    "没读到本机账号名字（前面要有「读取本机账号名字」，"
+                    "或由循环块设目标名字）→ 跳过")
+        return ("name", [name], f"名字『{name}』")
+
+    def _release_fetch(self, mode, values, date="", how="take", limit=1, retry_failed=True):
+        """按 scope 取计划。`how`：`take`=候选（**仍要 claim 占位**）/ `peek`=看下一条(不占位) /
+        `last`=最近一条"已推到手机、还没标记"的。"""
+        from core import video_plan as vp
+        if not values:
+            return [] if how == "take" else None
+        if mode == "phone":
+            if how == "peek":
+                return vp.peek_for_device(values, date)
+            if how == "last":
+                return vp.last_pushed_for_device(values)
+            return vp.take_for_device(values, date, limit=limit, retry_failed=retry_failed)
+        if how == "peek":
+            return vp.peek_for_name(values, date)
+        if how == "last":
+            return vp.last_pushed_for_name(values)
+        return vp.take_for_name(values, date, limit=limit, retry_failed=retry_failed)
+
+    def _verify_account_name(self, d, name):
+        """推送前**再读一次**手机屏幕上的昵称，核对是不是真的要发的那个名字。
+
+        返回 `(是否通过, 读到什么)`。**读不到 = 不通过**（宁可不发，也不发错号）。
+        没记录昵称选择器时返回 `(True, "")` —— 那种情况下前面必然已经校验过
+        （切号步骤切完会回读、读取名字步骤刚读过），这里不再重复读一次。
+
+        比对用**双向包含**：元素文本可能是 `小王`，也可能带前缀/后缀（`@小王`），
+        只要有一边包含另一边就算对上 —— 但空文本永远不算对上。
+        """
+        from core import video_plan as vp
+        sel_type, sel_val = self._vars.get("name_selector") or ("", "")
+        if not sel_val:
+            return True, ""
+        got = vp.clean_account_name(self._read_element_text(d, sel_type, sel_val))
+        if not got:
+            return False, ""
+        return (name in got or got in name), got
 
     def _release_candidates(self):
-        """条件判断的「候选值来源 = 发布计划」：本机要发的那条计划的 **抖音号 + 账号名称**。
+        """条件判断的「候选值来源 = 发布计划」：本机要发的那条计划的**名字**。
 
         优先用本次运行里「推送发布视频」已经拿到的那条（`_last_release`）；
         还没有就**看**下一条（peek，不占位）—— 这正是"推送前先校验账号对不对"的用法：
-        命中（当前登录的就是要发的那个号）→ 走 then 去推送/发布；未命中 → else 跳过并通知。
+        命中（当前登的就是要发的那个名字）→ 走 then 去推送/发布；未命中 → else 跳过并通知。
-
+        配「包含」运算符即可。
-        给两个候选值是刻意的：元素原文可能是 `抖音号：35377983067`，也可能只显示昵称，
-        两个都算命中（候选值之间是 OR）。配「包含」运算符即可。
         """
         from core import video_plan as vp
         plan = getattr(self, "_last_release", None)
         src = "本次已推送的那条"
         if not plan:
-            phones, _who = self._release_targets({})
+            mode, values, _who = self._release_scope({})
-            plan = vp.peek_for_device(phones, vp._today()) if phones else None
+            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]
+        cands = [c for c in (plan.get("nickname"),) if c]
-        note = (f"{src}计划的抖音号 {plan.get('douyin_id')}"
+        note = (f"{src}计划的名字『{plan.get('nickname')}』"
-                f"（{plan.get('nickname') or plan.get('phone')} "
+                f"（{plan.get('release_date')} #{plan.get('seq')}）")
-                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
+            # 等切换生效：切换会触发抖音**整体重启**（等于换了个号重新登录），十几秒才回到
+            # 「我」页是正常的（实测：整步跑了 77s，其中大部分就是在等它重启完）。而且重启后
+            # 落的地方**可能是信息流**（不是「我」页）—— 所以窗口放到 30s，并且**读不到就重新点
+            # 一次「我」**再读（踩过两次：窗口太短 → 明明切成功却判失败 → 整轮什么都不发）。
+            last_got = ""
+            vdeadline = time.time() + max(30.0, timeout)
+            while time.time() < vdeadline:
+                if self.stopped():
+                    return False
+                last_got = self._read_name_now(d, params)
+                if last_got == target:
+                    _log.info(f"[{self.serial}] 切换账号成功：『{target}』（第 {i} 次）")
+                    self.set_action(f"已切到『{target}』")
+                    self._vars["account_name"] = target
+                    return True
+                if not last_got:
+                    self._click_sel(d, me_type, me_val, timeout=1)
+                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):
         """推送发布视频：把本机某天待发的计划**推到手机相册**（**不发布**）。
 
@@ -911,10 +1290,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
@@ -922,21 +1304,30 @@ 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)
+        mode, values, who = self._release_scope(params)
-        if not phones:
+        if not values:
-            _log.warning(f"[{self.serial}] 推送发布视频：本机没有台账账号 → 跳过")
+            _log.warning(f"[{self.serial}] 推送发布视频：{who}")
-            self.set_action("本机没有台账账号 → 跳过")
+            self.set_action(f"跳过：{who}")
             return None
-        plans = vp.take_for_device(phones, date,
+        if mode == "name":
-                                   limit=int(params.get("max_same_run") or 1),
+            ok, got = self._verify_account_name(d, values[0])
-                                   retry_failed=params.get("retry_failed", True) is not False)
+            if not ok:
+                _log.warning(f"[{self.serial}] 推送发布视频：核对不过 —— 屏幕上是『{got or '读不到'}』，"
+                             f"要发的是『{values[0]}』**不推**（宁可不发，也不发错号）")
+                self.set_action(f"跳过：当前账号『{got or '读不到'}』≠ 要发的『{values[0]}』")
+                return None
+        plans = self._release_fetch(mode, values, date, how="take",
+                                    limit=int(params.get("max_same_run") or 1),
+                                    retry_failed=params.get("retry_failed", True) is not False)
         if not plans:
             _log.info(f"[{self.serial}] 推送发布视频：{who} 在 {date} 没有待推送的计划 → 跳过")
             self.set_action(f"{date} 没有待推送计划")
             return None
 
         opts = {"album_dir": (params.get("album_dir") or "").strip() or flow.ALBUM_DIR,
-                "to_clipboard": params.get("to_clipboard", True) is not False}
+                "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():
@@ -988,8 +1379,8 @@ class GenericStepsWorker(BaseWorker):
 
         plan = getattr(self, "_last_release", None)
         if not plan:
-            phones, _who = self._release_targets(params)
+            mode, values, _who = self._release_scope(params)
-            plan = vp.last_pushed_for_device(phones) if phones else None
+            plan = self._release_fetch(mode, values, how="last")
         if not plan:
             _log.warning(f"[{self.serial}] 标记发布结果：找不到对应的计划行 → 跳过"
                          f"（前面要先有一个「推送发布视频」步骤）")
@@ -1003,13 +1394,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}")
 
@@ -1327,6 +1720,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:
@@ -1398,15 +1863,15 @@ class GenericStepsWorker(BaseWorker):
             from core import video_plan as vp
             plan = getattr(self, "_last_release", None)
             if not plan:
-                phones, _who = self._release_targets(params)
+                mode, values, _who = self._release_scope(params)
-                plan = vp.last_pushed_for_device(phones) if phones else None
+                plan = self._release_fetch(mode, values, how="last")
             if plan:
                 text, _err = vp.build_caption(
                     plan, params.get("release_topics") or "",
                     key=RELEASE_TEXT_SOURCES[src])
                 self._last_release = self._last_release or plan
                 _log.info(f"[{self.serial}] 输入文字取计划{RELEASE_TEXT_SOURCES[src]}："
-                          f"{plan.get('douyin_id') or plan.get('phone')} "
+                          f"{plan.get('nickname')} "
                           f"{plan.get('release_date')} #{plan.get('seq')}")
             if not text:
                 _log.warning(f"[{self.serial}] 输入文字：本机没有可用的发布计划内容 → 跳过"

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,64 +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: 账号（台账） ========== -->
+<!-- ========== Tab: 发布计划 ========== -->
-<div id="tab-account" class="tab-panel">
+<div id="tab-plan" class="tab-panel">
-  <div class="page-title">账号</div>
+  <div class="page-title">发布计划</div>
-  <div class="page-sub">每台设备上登录的抖音账号（谁在哪台机器上、卡在不在机内、能不能发视频）</div>
+  <div class="page-sub">每个视频 = 一条计划：<b>文件名里的名字</b>（= 抖音昵称）+ 发布日期 + 编号，
+    到日子由任务推到手机、按名字找设备/账号发布（谁在机内、能不能发视频由运行时现场读名字判断）</div>
 
-  <div class="sub-tabs">
+  <div>
-    <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="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 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>
       <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()">
@@ -655,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>
 
@@ -681,7 +637,7 @@ 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>
         </tr></thead>
         <tbody id="tb-release"></tbody>
@@ -689,10 +645,10 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
     </details>
 
     <div class="help">
-      视频文件名规则 <code>手机号_日期_编号</code>（编号可省略，日期如 <code>20260912</code> 就是发布日期）；
+      素材文件名规则 <code>名字_日期_编号</code>（<b>名字 = 抖音上的昵称</b>；<b>视频、图片都行</b>，扩展名各带各的；编号可省略，日期如 <code>20260912</code> 就是发布日期）；
-      标题 txt 每行 <code>标题 || 正文 _手机号_日期_编号</code>（正文可省；也能写成 <code>手机号_日期_编号_标题 || 正文</code>）（<b>两种写法都认</b>，编号都可省略，标题里可以有下划线、可以有 <code>#话题</code>；<code>#</code> 开头的行<b>只要认得出手机号/日期就当标题</b>，认不出才当注释忽略）。
+      标题 txt 每行 <code>标题 || 正文_名字_日期_编号</code>（<code>||</code> 后面是正文、可省略；编号可省，标题/正文里可以有下划线、可以有 <code>#话题</code>；<code>#</code> 开头的行<b>只要认得出名字/日期就当标题</b>，认不出才当注释忽略）。
-      <b>手机号必须在「账号台账」里</b>，否则拒收。<br>
+      <b>名字里不能有下划线、不能是纯数字</b>（那样切不出名字来），不满足会直接拒收并说明原因。<br>
-      上传后自动按 (手机号, 日期, 编号) 配对：有编号按编号精确对，没编号按顺序配 ——
+      上传后自动按 (名字, 日期, 编号) 配对：有编号按编号精确对，没编号按顺序配 ——
       <b>没传标题的视频不会被推送</b>（先在计划页改标题或补传标题）。<br>
       <b>平台只负责把视频推到手机</b>（推到 <code>/sdcard/DCIM/Camera/</code>、把文件时间改成"现在"好排在相册最前、触发相册刷新并<b>按路径</b>校验进了索引、
       把标题写进手机剪贴板）；**抖音里怎么发由你在任务里自己写步骤** ——
@@ -703,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: 任务 ========== -->
@@ -1411,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>
@@ -1609,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]
-        # 本机账号台账（可选块）：身份页顺带显示"这台登的是哪几个号"。
+        # 账号台账块（`accounts_b64`）随账号管理一起下线了：身份页只显示
-        # **中文必须 base64**（§5.1：adb shell 直传中文/特殊字符会变形）；
+        # 名称/地址/平台地址这些设备信息。老版本 Agent 收到"没有这个 extra"照常显示。
-        # `_adb` 是 argv 形式、不过 shell，base64 里的 +/= 安全 —— 将来谁把
-        # 这里改成 shell=True 就会静默坏掉，别改。
-        # 台账里没有这台设备时**整个 extra 不发**（设备端"没有这个 extra"=
-        # 本来就没登记，跟"发了但解不开"能区分开），原因随响应体的 warn 回给操作者。
         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,8 +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()
@@ -65,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()
@@ -78,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})
@@ -105,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 or "body" in data:
+    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"))
+        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
+            bad = "太长" in err or "名字不对" in err
-        return jsonify({"ok": True, "msg": "标题/正文已改", "plan": row})
+            return jsonify({"ok": False, "error": err}), 400 if bad else 404
+        return jsonify({"ok": True, "msg": "标题/正文/名字已改", "plan": row})
     return jsonify({"ok": False, "error": "没有要改的字段"}), 400
 
 
@@ -128,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
+    matched, unmatched = _push_by_name([row])
-    t = threading.Thread(target=run_push, args=(serial, pid), daemon=True)
+    if unmatched:
-    t.start()
+        return jsonify({"ok": False, "error": unmatched[0]["reason"]}), 400
-    _log.info(f"推送素材到手机 video_plan {pid}（{row['phone']} {row['release_date']}）")
+    m = matched[0]
-    return jsonify({"ok": True,
+    _log.info(f"推送素材到手机 video_plan {pid}（{row.get('nickname')} "
-                    "msg": "已开始推送到手机（推完状态会变成「已推送到手机」，"
+              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):
+def _push_plans_by_account():
-    """这条计划要推给哪台设备：**设备名现查**（设备换 IP 后快照是错的），快照兜底。"""
+    """`push_by_account` / `push_all` 两个路由的公共实现（避免"调用另一个视图"）。"""
-    from core import ledger
+    data = request.json or {}
-    return (ledger.serial_of(row.get("device_name") or "") or (row.get("serial") or "")).strip()
+    date = (data.get("date") or "").strip() or vp._today()
+    rows = vp.pushable_plans(date, retry_failed=bool(data.get("retry_failed", True)))
+    if not rows:
+        return jsonify({"ok": True, "count": 0, "devices": 0, "matched": [],
+                        "unmatched": [],
+                        "msg": f"{date} 没有待推送的计划（有标题的才推）"})
+    matched, unmatched = _push_by_name(rows, data.get("serials") or None)
+    if not matched:
+        return jsonify({"ok": False, "count": 0, "devices": 0, "matched": [],
+                        "unmatched": unmatched,
+                        "error": "没有在线设备登着这些号：" +
+                                 "、".join(f"{u['name']}({u['count']}条)" for u in unmatched) +
+                                 " —— 先到设备上切号，或到「工具 → 设备池」确认设备在线"}), 400
+    _log.info(f"一键推送（按名字）{date}：{len(rows)} 条 → {len(matched)} 个名字"
+              f"（没设备登着的 {len(unmatched)} 个名字已跳过）")
+    return jsonify({"ok": True, "count": sum(m["count"] for m in matched),
+                    "devices": len({m["serial"] for m in matched}),
+                    "matched": matched, "unmatched": unmatched,
+                    "msg": f"已开始推送 {sum(m['count'] for m in matched)} 条"
+                           f"（{len(matched)} 个号）"
+                           + (f"；{len(unmatched)} 个名字没有在线设备登着，见明细"
+                              if unmatched else "")})
+
+
+@bp.route("/api/video_plan/push_by_account", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_vp_push_by_account():
+    """**按名字找设备**的批量推送（「一键推送」）：某天所有待推的计划，谁登着谁推。
+
+    立刻返回受理条数（推送在后台跑）——进度与结果看时间线的状态徽章 /
+    「已推送·相册可见」标记。**没设备登着的名字**在 `unmatched` 里逐条说明。
+    """
+    return _push_plans_by_account()
 
 
 @bp.route("/api/video_plan/push_all", methods=["POST"])
 @perm_required(PERM_DEVICES)
 def api_vp_push_all():
-    """**一键推送**：把某天（默认今天）所有「待发布/失败」的计划推到各自的手机上。
+    """老入口（前端旧版本还可能在调）：语义与 `push_by_account` 一致 —— 都按名字找设备。"""
-
+    return _push_plans_by_account()
-    并发口径：**每台设备一个线程、设备内串行**（同一个手机同时推两个文件会互相干扰：
-    两条 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"推完状态会变成「已推送·相册可见/相册未见」，刷新看结果"})
 
 
 @bp.route("/api/video_plan/<pid>/mark", methods=["POST"])
@@ -419,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` 里还有去重有效期、抢占等通用参数，
@@ -488,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(),
+                    name=(request.args.get("name") or "").strip())
-                    phone=(request.args.get("phone") 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"],
+            w.writerow([r["release_date"], r["nickname"], r["seq"], r["title"],
-                        r["douyin_id"], r["seq"], r["title"], r.get("body", ""),
+                        r.get("body", ""), r["share_url"], r["published_at"]])
-                        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)