feat(发布计划): 改按名字发（文件名名字_日期_编号）+ 账号管理整页下线 + 自动切号一轮发完

发布计划不再绑设备、不再依赖账号台账：上传文件名 `名字_日期_编号`（标题行 `标题 || 正文_名字_日期_编号`），运行时读本机当前抖音昵称取计划；靠循环块「一轮把本机待发的号跑完」自动切号，一直发到发完。 · 解析/配对换键：右锚定认名字（不许含下划线、不许纯数字 —— 不合法直接拒收并说清原因），删掉三处"手机号必须命中台账"的校验，加索引 ix_video_plan_name_date（启动时补建） · 新步骤三个：读本机账号名字 / 切换账号（**按名字点控件**、切完回读校验、遇登录页停本设备）/ 循环本机待发的号（试过不回头、跑一轮没进展就换号、停止·超时·上限三个干净出口） · 发布骨架改 18 步：读名字 → 校验账号（cmp_source=account_target）→ 推送（**推送前重读昵称核对**） → 抖音流程 → 标记结果；push_release 的 account 默认 name · 账号管理整页下线：删 core/ledger.py（serial_of 迁到 core/device_pool.py）、6 个 /api/ledger*、「账号」页与 ledger.js、设备池「账号」列、设备端账号块；发布计划升为一级页签； device_account 表与 42 行历史数据保留、仍在备份清单内（**停用不等于删数据**） · 人工入口「按名字找设备」：新增 core/account_probe.py（只读探测、跳过在跑任务的设备） + POST /api/video_plan/push_by_account，没设备登着的号逐条报出来；推送时把"实际是谁发的"写进 posted_serial / posted_device_name · 通知：新增 task.account.switch_failed / task.account.need_login · schema v12（posted_*）/ v13（device.cur_account_name / cur_name_at） · 文档同步：TASK_DEV / API / DATA_MODEL / ARCHITECTURE / NOTIFY / DEVICE_AGENT / DEPLOY / DEVELOPMENT / README / .env.example（两个抖音控件选择器抓一次填 .env） · 新增 scripts/tests/：6 套用例 + run_all.py（临时库 + 假设备，不碰真实数据、不连真机）
2026-10-12 09:02:40 +08:00
parent 75bee21ffb
commit beda0f3779
37 changed files with 2615 additions and 1747 deletions
@@ -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
@@ -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）。
@@ -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)}
@@ -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（不做外键）
-    phone = db.Column(db.String(32), default="", index=True)        # 配对键（冗余存：账号删了也留痕）
-    device_name = db.Column(db.String(80), default="", index=True)  # 设备号快照（聚合/下发免 join）
-    nickname = db.Column(db.String(80), default="")                 # 账号名称快照（时间线卡片直接显示）
-    douyin_id = db.Column(db.String(64), default="")                # 抖音号快照
-    serial = db.Column(db.String(120), default="")                  # 地址快照
+    account_id = db.Column(db.String(32), default="", index=True)   # 老台账账号 id（已停用，保留列）
+    phone = db.Column(db.String(32), default="", index=True)        # 老台账手机号快照（已停用，保留列）
+    device_name = db.Column(db.String(80), default="", index=True)  # 设备号快照（**已不写入**；实际由谁发的看 posted_device_name）
+    nickname = db.Column(db.String(80), default="")                 # **识别键**：上传文件名里的名字（= 抖音昵称）
+    douyin_id = db.Column(db.String(64), default="")                # 抖音号快照（已停用，保留列）
+    serial = db.Column(db.String(120), default="")                  # 地址快照（已停用，保留列）
    release_date = db.Column(db.String(10), default="", index=True)  # "YYYY-MM-DD"（纯日期，等值比较）
    seq = db.Column(db.Integer, default=1)                          # 编号，从 1 起（不用 0 表示"无"）
    seq_auto = db.Column(db.Boolean, default=True)                  # 编号是自动分配出来的（界面要提示）
@@ -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():
@@ -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"],
@@ -59,7 +59,7 @@ NEED_SELECTOR = ("click", "long_click", "wait_el", "swipe_until", "if_el")
 # 需要包名的步骤类型
 NEED_PACKAGE = ("open_app", "stop_app")
 # 需要非空 children 的容器
-NEED_CHILDREN = ("loop", "group")
+NEED_CHILDREN = ("loop", "group", "foreach_account")

 # 有副作用的动作关键词：命中的步骤在 AI 通道只给 warning（人工复核），不拦
 DESTRUCTIVE_HINTS = ("评论", "发送", "发布", "投稿", "转发", "分享到",
@@ -226,19 +226,17 @@ def validate_steps(steps, depth=1, path="steps", errors=None, warnings=None,
            # 所以在这里拦住，别让 AI 草稿悄悄变成"永远不命中"
            cmp_op = (params.get("cmp_op") or "").strip()
            cmp_src = (params.get("cmp_source") or "").strip()
-            if cmp_src not in ("", "manual", "device", "all", "group"):
+            if cmp_src not in ("", "manual", "release", "account_target"):
                errors.append(f"{here}.params.cmp_source: 不支持的候选值来源 {cmp_src!r}"
-                              f"（可用：空/manual/device/all/group）")
-            if cmp_src == "group" and not (params.get("cmp_group") or "").strip():
-                warnings.append(f"{here}: 候选值来源是「按设备分组」，但没填分组名 —— 取不到号")
+                              f"（可用：空/manual/release/account_target）")
            if cmp_op:
                from tasks.generic.task import CMP_OPS
                if cmp_op not in CMP_OPS:
                    errors.append(f"{here}.params.cmp_op: 不支持的比对运算符 {cmp_op!r}"
                                  f"（可用：{'、'.join(CMP_OPS)}）")
                elif not str(params.get("cmp_value") or "").strip() \
-                        and cmp_src not in ("device", "all", "group"):
-                    # 候选值来自台账时允许手填留空（台账取号就够）；
+                        and cmp_src not in ("release", "account_target"):
+                    # 候选值来自发布计划 / 本次要发的名字时，允许手填留空（候选由平台给）；
                    # 其余情况仍要求填值，否则永远不命中
                    errors.append(f"{here}.params.cmp_value: 选了文本比对"
                                  f"（{cmp_op}）就必须填比对的值，否则永远不命中")
@@ -277,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")
-            if mode not in ("random", "fixed"):
-                errors.append(f"{here}.params.mode: 必须是 random 或 fixed"
-                              f"（当前 {mode!r}）")
-            elif mode == "fixed":
-                if not str(params.get("fixed_text") or "").strip():
-                    errors.append(f"{here}.params.fixed_text: mode=fixed 时不能为空")
-            else:
-                texts = params.get("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} 条")
+            # 文案来自「发布计划」（`text_source` 不是 manual）时 texts/fixed_text **都不参与输入** ——
+            # 别按"手填"的规则要求候选文案（发布任务骨架里那两步就是这么配的：
+            # mode 留默认、内容由计划给，靠 `release_title`/`release_body` 现取）
+            if str(params.get("text_source") or "manual").strip() == "manual":
+                mode = params.get("mode", "random")
+                if mode not in ("random", "fixed"):
+                    errors.append(f"{here}.params.mode: 必须是 random 或 fixed"
+                                  f"（当前 {mode!r}）")
+                elif mode == "fixed":
+                    if not str(params.get("fixed_text") or "").strip():
+                        errors.append(f"{here}.params.fixed_text: mode=fixed 时不能为空")
+                else:
+                    texts = params.get("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():
@@ -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")

@@ -66,10 +66,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,15 +120,61 @@ 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 位 —— 三个长度区间
-    互不相交，所以永远不会有一段同时匹配两种角色。按位置硬切的话，用户把顺序写反、
-    或文件名带下载站前缀时，会解析出一个**错误的手机号**；而它若恰好命中台账里
-    另一个账号，就**不报错**，静默地把 A 号的视频排给 B 号。
+    **右锚定**：从最右边往前认 可省编号(1-3 位) → 日期(8 位) → **紧挨着日期的那一段就是名字**。
+    为什么不再"按形态扫全部分段"（手机号那套）：手机号有固定形态（11 位、1 开头），
+    名字没有 —— 长度任意、可以带数字和汉字，只有"日期前一段"这个位置是确定的。
+    代价是名字里不能有下划线：**明确拒收并说清原因**，而不是猜一个可能错的名字
+    （猜错就是把 A 号的视频静默排给 B 号）。
    """
    name = (filename or "").strip()
    if not name:
@@ -128,114 +184,83 @@ def parse_video_name(filename):
        return None, f"不是视频文件（支持 {'/'.join(e.lstrip('.') for e in VIDEO_EXTS)}）"
    parts = [p.strip() for p in stem.split("_")]
    if len(parts) < 2:
-        return None, "文件名格式不对，应为 手机号_日期_编号（编号可省略）"
-
-    phone = date = seq = None
-    leftovers = []
-    for p in parts:
-        if not p:
-            leftovers.append(p)
-            continue
-        if _PHONE_RE.match(p):
-            if phone is not None:
-                return None, f"文件名里有多个手机号（{phone}、{p}）"
-            phone = p
-        elif _DATE8_RE.match(p):
-            if date is not None:
-                return None, f"文件名里有多个日期（{date}、{p}）"
-            d = parse_date8(p)
-            if not d:
-                return None, f"日期 {p} 不是合法日期（应为 20260912 这种 8 位）"
-            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}, ""
+        return None, "文件名格式不对，应为 名字_日期_编号（编号可省略，如 小王_20260912.mp4）"
+    if len(parts) >= 3 and _SEQ_RE.match(parts[-1]) and _DATE8_RE.match(parts[-2]):
+        seq, date8, name_parts = int(parts[-1]), parts[-2], parts[:-2]
+    elif _DATE8_RE.match(parts[-1]):
+        seq, date8, name_parts = None, parts[-1], parts[:-1]
+    else:
+        return None, (f"文件名格式不对：`{stem}` 的结尾既不是日期（8 位数字，如 20260912），"
+                      f"也不是「日期_编号」—— 应为 名字_日期_编号")
+    d = parse_date8(date8)
+    if not d:
+        return None, f"日期 {date8} 不是合法日期（应为 20260912 这种 8 位）"
+    if len(name_parts) != 1:
+        return None, (f"名字里不能有下划线：`{stem}` 里日期前面有 {len(name_parts)} 段 ——"
+                      f"应为 名字_日期_编号")
+    err = name_error(name_parts[0])
+    if err:
+        return None, err
+    return {"name": name_parts[0], "date": d, "seq": seq, "seq_given": seq is not None}, ""


 def parse_title_line(line):
-    """标题行 → (meta, error)。**两种写法都认**，标题里都可以带下划线。
+    """标题行 → (meta, error)。格式只有一种：`标题 || 正文_名字_日期_编号`。

-    **一行里可以有标题和正文**：`标题 || 正文 _手机号_日期_编号`（用 `||` 分隔，
-    因为标题/正文里常带下划线；只切第一处，正文里再出现 `||` 原样保留）。
-    没写 `||` 就是只有标题（老文件照收）；` || 正文_…` 这种只有正文也行。
+    **一行里可以有标题和正文**：用 `||` 分隔（标题/正文里常带下划线，所以不能再用下划线分列），
+    只切**第一处**，正文里再出现 `||` 原样保留；没写 `||` 就是只有标题；
+    ` || 正文_…` 这种"只有正文"也行（标题留空）。

-    ① 标题在前（推荐，右锚定）：
-         A) 标题内容_手机号_日期_编号   B) 标题内容_手机号_日期
-    ② 手机号在前（左锚定，跟视频文件名同序 —— "文件名去掉扩展名 + 标题"）：
-         C) 手机号_日期_编号_标题       D) 手机号_日期_标题
+    名字**右锚定**，和视频文件名同一套规则（末尾可省编号 → 日期 → **紧挨日期的那一段是名字**）；
+    名字之前剩下的整段（下划线连回去）就是「标题 || 正文」——
+    所以标题/正文里可以随便带下划线，**只有名字不能带**（`name_error` 统一把关）。
+    与视频文件名的差别：视频名里"名字前面多出段"要**拒收**（那里不该有内容），
+    标题行里则**都算文案**（`标题_带_下划线_小王_20260912` → 名字是最后的 `小王`，前面整段都是标题）。

-    为什么**先右后左**：右锚定是主格式（标题里带下划线也不会错配）。
-    左锚定的四种里先试带编号的 C（`手机号_日期_1_标题` —— 那个 `1` 当编号，
-    不当标题的开头），保证同一行永远只有一种解释。
-
-    什么时候两种都不会误判：右锚定要求"倒数第 3/2 段是手机号"，左锚定要求
-    "第 1 段是手机号、第 2 段是日期" —— 一行同时满足两边时（例如 `手机号_日期_1`）
-    右锚定先命中，且标题为空会被下面的校验拒掉，不会静默发出一条错文案。
+    为什么砍掉老的「名字在前」（`名字_日期_编号_标题`）写法：键从手机号换成名字后，
+    `小王_20260912_1` 这种一行会有两种解释（`1` 是编号还是标题的开头？），
+    只留一种写法，解析结果就没有歧义了。名字写错/漏写会在配到计划行时被**明确拒收**
+    （"名字 X 没有对应的视频"），不会静默发出一条文不对题的文案。
    """
    t = (line or "").strip()
    if not t:
        return None, "空行"
    parts = t.split("_")
-    phone = date = seq = None
-    title_parts = None
-    # ① 右锚定：先试带编号的，再试不带编号的
-    if len(parts) >= 4 and _SEQ_RE.match(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:]
+    if len(parts) >= 3 and _SEQ_RE.match(parts[-1]) and _DATE8_RE.match(parts[-2]):
+        seq, date8, rest = int(parts[-1]), parts[-2], parts[:-2]
+    elif len(parts) >= 2 and _DATE8_RE.match(parts[-1]):
+        seq, date8, rest = None, parts[-1], parts[:-1]
    else:
-        return None, ("格式不对，应为「标题内容_手机号_日期_编号」"
-                      "或「手机号_日期_编号_标题」（编号都可省略）")
+        return None, ("格式不对，应为「标题 || 正文_名字_日期_编号」"
+                      "（编号可省略；日期是 8 位数字，如 20260912）")
    d = parse_date8(date8)
    if not d:
        return None, f"日期 {date8} 不是合法日期（应为 20260912 这种 8 位）"
-    date = d
-    raw = "_".join(title_parts).strip()
-    # 「标题 || 正文」：用 `||` 分隔（标题/正文里常带下划线，所以不能再用下划线分列）。
-    # 只切第一处：正文自己再出现 `||` 也原样保留。没写 `||` 就是只有标题（老文件照收）。
+    name = (rest[-1] or "").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 +297,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"}]。
-    规则：手机号在台账里 0 条或 ≥2 条 → 整组拒收；同侧编号重复 → 两条都拒收；
+    返回 (pairs, rejected)：pairs=[{"video","title","name","date","seq","seq_auto"}]。
+    规则：**名字就是账号**（不再查任何台账）；同侧编号重复 → 两条都拒收；
    没编号的视频填空位；**没编号的标题按号升序配到"还没有标题的视频"上**
    （即"第 1 个视频配第 1 条标题"，与逐条上传时 `import_titles()` 的行为一致 ——
      两处必须是同一套规则，不然批量路径与日常路径会给出不同结果）；
@@ -290,7 +314,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 +326,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
-        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
+        name, date = key
        taken = set(db_taken.get(key) or set())
        # 显式编号：先占位，同侧重复 → 两条都拒收
        for side in ("video", "title"):
@@ -341,7 +357,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 +367,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 +376,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 +448,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,14 +540,15 @@ def build_release_steps():
    "等抖音号出现"必然超时，最后显示成一句误导人的"账号不符"。
    屏幕亮着时冷启动 5 秒就出底部栏。

-    **平台能保证的步骤都填好了**（推送 / 填标题 / 标记 + 账号校验），
+    **平台能保证的步骤都填好了**（读名字 / 推送 / 填标题 / 标记 + 账号校验），
    抖音里的点击步骤只给出**空选择器的占位**（标签写清楚该抓哪个），
    因为那些是混淆 id / 结构 xpath，写死了改版就废 —— 执行时会明确提示
    "selector_value 为空，请抓取元素"，不会静默跳过。

-    唯一预填了选择器的是底部「+」入口（`descriptionContains=拍摄`）与
-    「我」（`descriptionContains=我`），因为这两条我在真机上实测过、
-    且是按描述定位、跨版本相对稳。
+    预填了选择器的只有底部「+」入口（`descriptionContains=拍摄`）与
+    「我」（`descriptionContains=我`），因为这两条在真机上实测过、
+    且是按描述定位、跨版本相对稳。**「我」页面上的昵称控件留空待抓**
+    （`read_account_name` 与守卫都用它，抓一次两处都填）。
    """
    def sid(name):
        return f"step_rel_{name}_{uuid.uuid4().hex[:6]}"
@@ -490,27 +558,51 @@ def build_release_steps():
                "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("⑤ 推送发布视频")),
-        clk("open", "⑥ 点击抖音底部「+」（实测可用；改版了重新抓）",
+        dict(build_push_step("⑦ 推送发布视频")),
+        clk("open", "⑧ 点击抖音底部「+」（实测可用；改版了重新抓）",
            "descriptionContains", "拍摄"),
-        clk("album", "⑦ 点击「相册」（没命中的话用抓取元素选它）"),
-        clk("video", "⑧ 点击第一个视频（刚推的排最前；抓一次就行）"),
-        clk("next", "⑨ 点击「下一步」"),
-        clk("input", "⑩ 点击输入框（抖音发布页的文案框）"),
+        clk("album", "⑨ 点击「相册」（没命中的话用抓取元素选它）"),
+        clk("video", "⑩ 点击第一个视频（刚推的排最前；抓一次就行）"),
+        clk("next", "⑪ 点击「下一步」"),
+        clk("input", "⑫ 点击标题框（抖音发布页的文案框）"),
        {"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", "⑭ 点击正文框（发布页的正文框）"),
        {"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", "⑭ 点击「发布」"),
-        dict(build_mark_step("⑮ 标记发布结果（成功走这里；失败分支再放一个 result=failed）")),
+        clk("publish", "⑯ 点击「发布」"),
+        dict(build_mark_step("⑰ 标记发布结果（成功走这里；失败分支再放一个 result=failed）")),
+    ]
+    # 循环体：切号 → 读名字 → 校验 → 推送 → 发布 → 标记。
+    # `switch_account` 自己会先看"当前是不是已经是目标"（第一个号不用切），
+    # 也会处理"本机没登这个号"（直接跳过、不重试）。
+    loop_body = [
+        dict(build_switch_step("③ 切换账号（切到本次要发的那个名字；已在该号则直接过）")),
+        dict(build_read_name_step("④ 读取本机当前账号名字（昵称控件选择器待抓）")),
+        {"id": sid("check"), "type": "if_el",
+         "label": "⑤ 校验账号：当前登的是不是这次要发的那个名字",
+         "params": {"selector_type": "xpath",
+                    "selector_value": "",
+                    "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": "账号不符/读不到：本条跳过（不发）",
+                              "params": {"title": "发布跳过：账号不符",
+                                         "message": "设备 {device} 当前登的不是要发的号"
+                                                    "（或读不到昵称），本条已跳过、没发出去",
+                                         "level": "warning"}}]}},
    ]
    return [
        {"id": sid("light"), "type": "screen_on", "label": "⓪ 亮屏",
@@ -518,23 +610,9 @@ def build_release_steps():
        {"id": sid("openapp"), "type": "open_app", "label": "① 打开抖音（等「首页」出来）",
         "params": {"package": "com.ss.android.ugc.aweme", "home_feature": "首页",
                    "wait_home": True, "probability": 100}},
-        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": "④ 校验账号：当前登录的是不是这条计划要发的号",
-         "params": {"selector_type": "xpath",
-                    "selector_value": "//*[contains(@text,'抖音号')]",
-                    "timeout": 8, "cmp_op": "包含", "cmp_source": "release",
-                    "cmp_value": "", "cmp_group": "",
-                    "ident_type": "text", "ident_value": "",
-                    "then": publish_flow_steps,
-                    "else": [{"id": sid("else"), "type": "notify",
-                              "label": "账号不符：本条跳过（不发）",
-                              "params": {"title": "发布跳过：账号不符",
-                                         "message": "设备 {device} 当前登录的不是要发的号"
-                                                    "（计划：见「账号 → 发布计划」），本条已跳过",
-                                         "level": "warning"}}]}},
+        # 一轮把本机待发的号跑完：数据源是**计划表**（谁还有待发内容谁就在里面），
+        # 不需要任何账号维护；停止/超时/上限三个出口见 `_exec_foreach_account`
+        dict(build_foreach_step(loop_body, "② 循环本机待发的号（一直切号发，直到发完）")),
    ]


@@ -554,21 +632,10 @@ def safe_name(name):


 # ================== DB 服务区 ==================
-def accounts_by_phone():
-    """{手机号: [账号 dict, ...]}（配对用；同号多账号要能看出来）。"""
+def taken_slots(name, date):
+    """该名字该日期已占用的编号集合（分两批上传时不能从 1 重号）。"""
    with _ctx():
-        out = {}
-        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,
+        rows = VideoPlan.query.filter(VideoPlan.nickname == name,
                                      VideoPlan.release_date == date).all()
        return {int(r.seq or 1) for r in rows}

@@ -622,39 +689,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"]
-    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
+    acct, date = meta["name"], meta["date"]
    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 +717,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", ""),
-                        phone=phone, device_name=acc.get("device_name", ""),
-                        nickname=acc.get("nickname", ""), douyin_id=acc.get("douyin_id", ""),
-                        serial=acc.get("serial", ""), release_date=date, seq=seq,
+        row = VideoPlan(id=uuid.uuid4().hex[:8], account_id="",
+                        phone="", device_name="", nickname=acct, douyin_id="",
+                        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 +734,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 +763,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"]
-            item = {"line": m.get("_line", 0), "phone": phone, "date": date,
+            acct, date = m["name"], m["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:
-                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,
+            q = VideoPlan.query.filter(VideoPlan.nickname == acct,
                                       VideoPlan.release_date == date)
            if m["seq_given"]:
                row = q.filter(VideoPlan.seq == int(m["seq"])).first()
@@ -735,9 +779,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 +835,12 @@ def _sync_content_status(row):
        row.status = ST_PENDING


-def set_title(plan_id, title, body=None):
-    """人工改标题 /（可选）正文，改完按"有没有内容"切 pending/ready。
+def set_title(plan_id, title, body=None, nickname=None):
+    """人工改标题 /（可选）正文 /（可选）**名字**，改完按"有没有内容"切 pending/ready。

    `body=None` = **不动正文**（老调用方语义不变）；传空串 = 清掉正文。
+    `nickname` = 改**识别键**（文件名写错了、或抖音上改了名时的**唯一补救手段**）——
+    同样走 `name_error` 那把尺子（不许含下划线/不许纯数字），不合法直接拒收。
    """
    title = (title or "").strip()
    if len(title) > MAX_TITLE_LEN:
@@ -803,6 +849,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 +862,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 +902,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 +914,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 +922,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 +965,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 +973,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"]:
-                    today_devs.add(r["device_name"])
+                if r["nickname"]:
+                    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 +983,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 +1011,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 +1019,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:
-            query = query.filter(VideoPlan.device_name == device)
-        if phone:
-            query = query.filter(VideoPlan.phone == phone)
-        rows = query.order_by(VideoPlan.release_date, VideoPlan.device_name,
+        if name:
+            query = query.filter(VideoPlan.nickname == name)
+        rows = query.order_by(VideoPlan.release_date, VideoPlan.nickname,
                              VideoPlan.seq).all()
        return [r.to_dict() for r in rows]


 # ================== 发布：取计划 / 占位 / 回写 ==================
-def take_for_device(phones, date, limit=1, retry_failed=True):
-    """本机某天可发的计划行（按发布日期、编号升序）。`phones` = 这台设备上账号的手机号。"""
-    if not phones:
+# 取计划的**口径只在这两个内部函数里定义一次**（按列 + 日期 + 状态 + 尝试次数 + 排序）。
+# 口径分叉 = 同一个号被发两遍 或 永远发不出去，所以不许在别处再写一套 where。
+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 +1045,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 rows[0] if rows else None
+    return _peek(VideoPlan.nickname, names, date)
+
+
+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` 找不到上一步时的兜底）。"""
-    if not phones:
-        return None
+    return _last_pushed(VideoPlan.phone, phones)
+
+
+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)))
-               .filter(VideoPlan.status == ST_PUSHING)
-               .order_by(VideoPlan.updated_at.desc()).first())
-        return row.to_dict() if row else None
+        q = (VideoPlan.query
+             .filter(VideoPlan.nickname != "")
+             .filter(VideoPlan.release_date <= date)
+             .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 +1175,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 +1189,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 +1205,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()