feat(发布计划): 标题行两种写法都认 + 行首 # 不再无条件当注释

一、标题行解析（core/video_plan.parse_title_line）
- 原来只认「标题内容_手机号_日期_编号」（右锚定）。现在**两种都认**：
   ① 标题内容_手机号_日期_编号        （推荐，右锚定 —— 标题里带下划线也不会错配）
   ② 手机号_日期_编号_标题            （左锚定，跟视频文件名同序 = "文件名去掉扩展名 + 标题"）
  两种里都**先试带编号的**，保证同一行永远只有一种解释；编号都可省略。
- 新拒收一条：`手机号_日期_1`（只有编号、没标题）**直接拒** ——
  不能把它当标题"1"（静默生成一条标题是"1"的文案，比拒收危险得多）；
  标题真是纯数字的用写法①。

二、`#` 开头的行（parse_titles_text）
- 原来是"以 `#` 开头就整行忽略" → **`#中秋快乐_...` 这种正常标题会被静默丢掉**。
- 改成**先按标题行解析，解析得出就当标题；解析不出且以 `#` 开头才算注释**。
  `# 这是注释` 照样忽略，`#话题` 开头的标题照收（`#` 保留在标题里）。

三、其它
- 文案同步：上传标题面板/帮助文案、doc/API.md 的 upload_titles 语义（两种写法、`#` 规则、拒收条件）
- 测试：新增 8 条（两种写法 × 带/不带编号 × 标题含下划线与 #话题、只有编号要拒收、整段注释与报错）

.env.example

@@ -108,6 +108,14 @@ TAILSCALE_API_KEY=请填写Tailscale_API_key
 # 设置后不启动 cron 调度器（跑测试脚本时避免真实触发任务、占用设备）
 # DISABLE_SCHEDULER=1
 
+# 视频发布计划的素材目录（默认 data/videos）。
+# **自动化测试必须指到临时目录**，否则测试传的视频会落进用户真实数据目录。
+# DATA_VIDEO_DIR=/tmp/videos_test
+
+# 单次上传体积上限（MB，默认 2048）。
+# ⚠ 必须大于「应用管理」里最大的 APK（实测有 336MB 的包），否则 APK 上传会被一起卡死。
+# MAX_UPLOAD_MB=2048
+
 
 # ==============================================================================
 # 已废弃的历史配置（STF 已从代码层摘除，下列键代码不再使用，保留仅为兼容旧 .env）

.gitignore

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

README.md

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

config.py

@@ -87,6 +87,14 @@ DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
 # APK 文件存储目录（应用管理功能）
 APK_DIR = os.path.join(DATA_DIR, "apks")
 
+# 视频发布计划的素材目录（发布计划功能）。**支持 env 覆盖**，理由同下面三个：
+# 自动化测试必须把素材目录指到临时位置，否则测试上传的视频会落进用户真实数据目录。
+VIDEO_DIR = _env("DATA_VIDEO_DIR", "") or os.path.join(DATA_DIR, "videos")
+
+# 单次请求体上限（字节）。**必须大于现有 APK 上传的最大包**（实测 336MB），
+# 否则「应用管理」的 APK 上传会被一起卡死。默认 2GiB：一个视频 + 余量。
+MAX_CONTENT_LENGTH = int(_env("MAX_UPLOAD_MB", "2048")) * 1024 * 1024
+
 # ================== 系统数据备份（导出/导入） ==================
 # 导出 zip 与恢复前快照存放；导入暂存目录；待下次启动生效的恢复目录
 # （运行时产物，不入 git，见 .gitignore data/backups 等）

core/clipboard_helper.py

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

core/ledger.py

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

core/models.py

@@ -436,6 +436,141 @@ class DoneMark(db.Model):
     )
 
 
+class DeviceAccount(db.Model):
+    """账号台账：一台设备上登录着哪些账号（「账号」页）。
+
+    要解决的问题（用户场景）：一台手机登好几个抖音号、十几台手机四五十个号，
+    账号信息散在一张电子表格里 —— 换 IP、加号、想查"这台登的是哪几个号"都要翻表。
+    这里把台账落进平台：web 能查能改（支持从表格粘贴导入），
+    手机端 Agent 的「身份大字页」顺带显示本机账号，任务的「条件判断」
+    也可以直接从台账取号（不用再把号一个个手写进 cmp_value）。
+
+    ⚠ **`douyin_id` 是纯号（`35377983067`），而元素原文是 `抖音号：35377983067`。**
+    - 当条件判断的**比对值**可以 ✓（运算符用「包含」，纯号是子串）
+    - **绝不能当去重身份** ✗ —— `done_mark.identity` 存的是元素原文、逐字算 key，
+      格式不一致会让去重**静默失效**（见 `core/dedup.py`）。
+
+    `device_name` 是设备号（平台设备名，如 A01）；`serial` 是**录入时的地址快照**，
+    设备换 IP 或改名后，台账靠任一侧都能找回来（见 `core/ledger.for_device`）。
+    同一抖音号不允许两条 —— 唯一性由服务层保证（号可能为空，DB 层要做
+    "部分唯一索引"三处方言适配，人工维护的几十条不值当）。
+    """
+    __tablename__ = "device_account"
+    id = db.Column(db.String(32), primary_key=True)                 # uuid 前 8 位
+    device_name = db.Column(db.String(80), default="", index=True)  # 设备号（平台设备名）
+    serial = db.Column(db.String(120), default="")                  # 录入时的地址快照
+    phone = db.Column(db.String(32), default="", index=True)        # 手机号
+    nickname = db.Column(db.String(80), default="")                 # 账号名称
+    douyin_id = db.Column(db.String(64), default="", index=True)    # 抖音号（纯号，不带前缀）
+    registered_at = db.Column(db.String(20), default="")            # 注册时间（原样存文本）
+    sim_in_device = db.Column(db.Boolean, default=False)            # 卡在机内（空=否）
+    can_post_video = db.Column(db.Boolean, default=False)           # 可发视频（空=否）
+    bio = db.Column(db.Text, default="")                            # 简介
+    note = db.Column(db.Text, default="")                           # 备注
+    created_at = db.Column(db.String(20), default="")
+    updated_at = db.Column(db.String(20), default="")
+
+    def to_dict(self):
+        return {"id": self.id, "device_name": self.device_name or "",
+                "serial": self.serial or "", "phone": self.phone or "",
+                "nickname": self.nickname or "", "douyin_id": self.douyin_id or "",
+                "registered_at": self.registered_at or "",
+                "sim_in_device": bool(self.sim_in_device),
+                "can_post_video": bool(self.can_post_video),
+                "bio": self.bio or "", "note": self.note or "",
+                "created_at": self.created_at or "", "updated_at": self.updated_at or ""}
+
+    def __repr__(self):
+        return f"<DeviceAccount {self.device_name} {self.nickname}>"
+
+
+class VideoPlan(db.Model):
+    """视频发布计划：账号 × 发布日期 × 编号 → 一个视频素材 + 一条标题 + 发布结果。
+
+    一条记录 = **一个账号在某天要发的一个视频**（素材与计划天然 1:1，所以不拆两张表；
+    但上传是分两步的 —— 先视频后标题或反过来 —— 靠 `status` 的 `pending` 态兜住）。
+
+    **状态机**（这是本表的灵魂，不要简化）：
+
+    | status | 含义 |
+    |---|---|
+    | `pending` | 有视频、还没标题 |
+    | `ready` | 素材齐，等发布日期 |
+    | `pushing` | 已原子占位，正在把视频推到手机 |
+    | `publishing` | 已推到手机，正在走抖音发布流程 |
+    | `done` | 发布成功（终态） |
+    | `failed` | 失败在 `push`/`scan` 阶段 —— 还没碰抖音，**可安全重试** |
+    | `unknown` | 失败在 `post`/`verify` 阶段 —— **可能已经发出去了，绝不自动重试**，要人工裁决 |
+    | `skipped` | 人工跳过（终态） |
+
+    ⚠ **`failed` 与 `unknown` 必须分开**：把"不知道自己发没发"混成"知道自己没发"，
+    就是重复发布的来源。`stage` 记录失败发生在哪一步，是这两者互相转换的唯一依据。
+
+    **唯一性**：`(phone, release_date, seq)` 由服务层（`core/video_plan.py`）保证，
+    **不加 DB 唯一索引** —— `seq` 从 1 起、没有"空值"可言，做部分唯一索引要写三处方言适配
+    （见 §唯一索引那段注释与 `_ensure_unique_indexes`），收益不匹配；违反的代价只是
+    低频人工上传产生的重复行，可见、可删。
+
+    **分享链接**：发布成功后抓作品的分享链接存 `share_url` —— 平台**不长期囤视频**
+    （存不下），链接才是长期资产，也方便后续拿它去铺评论。
+    """
+    __tablename__ = "video_plan"
+    id = db.Column(db.String(32), primary_key=True)                 # uuid 前 8 位
+    account_id = db.Column(db.String(32), default="", index=True)   # → 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="")                  # 地址快照
+    release_date = db.Column(db.String(10), default="", index=True)  # "YYYY-MM-DD"（纯日期，等值比较）
+    seq = db.Column(db.Integer, default=1)                          # 编号，从 1 起（不用 0 表示"无"）
+    seq_auto = db.Column(db.Boolean, default=True)                  # 编号是自动分配出来的（界面要提示）
+    title = db.Column(db.Text, default="")                          # 文案
+    video_file = db.Column(db.String(120), default="")              # 平台落盘文件名（不含绝对路径）
+    video_name = db.Column(db.String(200), default="")              # 原始上传名（排查用）
+    video_size = db.Column(db.Integer, default=0)
+    video_sha1 = db.Column(db.String(40), default="")               # 内容指纹（重复上传的判据）
+    status = db.Column(db.String(16), default="", index=True)
+    stage = db.Column(db.String(16), default="")                    # push/scan/post/verify（决定 failed vs unknown）
+    attempts = db.Column(db.Integer, default=0)                     # 尝试次数（超上限不再自动取）
+    published_at = db.Column(db.String(20), default="")
+    share_url = db.Column(db.String(300), default="")               # 作品分享链接（发布后抓取）
+    link_at = db.Column(db.String(20), default="")                  # 抓到链接的时刻
+    video_deleted_at = db.Column(db.String(20), default="")         # 平台素材文件何时被清理
+    push_verify = db.Column(db.String(16), default="")              # 推送后的相册校验：ok=进索引 / no_index=没进 / nofile=文件不在
+    push_remote = db.Column(db.String(200), default="")             # 推到手机上的绝对路径（删它/排查用）
+    last_error = db.Column(db.String(500), default="")
+    note = db.Column(db.Text, default="")
+    created_at = db.Column(db.String(20), default="", index=True)
+    updated_at = db.Column(db.String(20), default="")
+
+    __table_args__ = (
+        db.Index("ix_video_plan_date_status", "release_date", "status"),
+        db.Index("ix_video_plan_acct_date", "account_id", "release_date"),
+        db.Index("ix_video_plan_phone_slot", "phone", "release_date", "seq"),
+        db.Index("ix_video_plan_file", "video_file"),
+    )
+
+    def to_dict(self):
+        return {"id": self.id, "account_id": self.account_id or "",
+                "phone": self.phone or "", "device_name": self.device_name or "",
+                "nickname": self.nickname or "", "douyin_id": self.douyin_id or "",
+                "serial": self.serial or "", "release_date": self.release_date or "",
+                "seq": int(self.seq or 1), "seq_auto": bool(self.seq_auto),
+                "title": self.title or "", "video_file": self.video_file or "",
+                "video_name": self.video_name or "", "video_size": int(self.video_size or 0),
+                "video_sha1": self.video_sha1 or "", "status": self.status or "",
+                "stage": self.stage or "", "attempts": int(self.attempts or 0),
+                "published_at": self.published_at or "", "share_url": self.share_url or "",
+                "link_at": self.link_at or "", "video_deleted_at": self.video_deleted_at or "",
+                "push_verify": self.push_verify or "", "push_remote": self.push_remote or "",
+                "last_error": self.last_error or "", "note": self.note or "",
+                "created_at": self.created_at or "", "updated_at": self.updated_at or ""}
+
+    def __repr__(self):
+        return f"<VideoPlan {self.phone} {self.release_date} #{self.seq} {self.status}>"
+
+
 class AgentConversation(db.Model):
     """AI 控制台会话：整个消息序列以 JSON 存在一行里（单会话几十 KB，够用）。"""
     __tablename__ = "agent_conversation"
@@ -461,6 +596,10 @@ SCHEMA_MIGRATIONS = [
     (5, "设备池：device 表新增 fingerprint 列（设备指纹 ro.serialno，换 IP 后认领回原记录）", None),
     (6, "自动发现：pending_device 表新增 fingerprint 列（扫描时读取，用于提示是已有设备换了 IP）", None),
     (7, "去重账本：done_mark 表（跨设备幂等的「已做过」标记，唯一索引 scope_key）", None),
+    (8, "账号台账：device_account 表（设备号/手机号/账号名称/抖音号/注册时间/卡在机内/可发视频/简介/备注）", None),
+    (9, "视频发布计划：video_plan 表（账号×发布日期×编号 → 素材 + 标题 + 发布状态 + 分享链接）", None),
+    (10, "视频发布计划：video_plan 新增 push_verify（推送后相册校验：ok/no_index/nofile）"
+         "与 push_remote（手机上的绝对路径，删它/排查用）", None),
 ]
 
 # 当前 schema 版本（备份/恢复用它判断新旧，也写进 app_meta.schema_version）

core/notify_events.py

@@ -111,6 +111,17 @@ EVENTS = [
        ["serial", "device_name", "selector", "miss_count"],
        "某选择器连续 10 次未命中——任务可能显示成功但什么都没做", agg_window=0,
        recommend=True),
+    _e("task.video.published", "视频已发布", "业务",
+       ["serial", "device_name", "model", "phone", "nickname", "release_date", "seq",
+        "title", "share_url"],
+       "「发布视频」步骤把某个账号的视频发出去了（share_url 是作品分享链接，"
+       "没抓到链接时为空——界面上会标「缺链接」）", agg_window=0, recommend=True),
+    _e("task.video.failed", "视频发布失败/结果未知", "业务",
+       ["serial", "device_name", "model", "phone", "nickname", "release_date", "seq",
+        "title", "msg"],
+       "「发布视频」步骤失败：推文件阶段失败=可重试；抖音那一步失败=**可能已经发出去了**，"
+       "要到计划页看状态并人工确认（平台不会自动重发）", agg_window=0,
+       agg_key=_BY_SERIAL, recommend=True),
 
     # ---------------- 设备 ----------------
     _e("device.online", "设备恢复在线", "设备",

core/system_backup.py

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

core/task_draft.py

@@ -225,12 +225,21 @@ def validate_steps(steps, depth=1, path="steps", errors=None, warnings=None,
             # 执行器对认不出的运算符是"一律不命中"，写错了会静默走 else，
             # 所以在这里拦住，别让 AI 草稿悄悄变成"永远不命中"
             cmp_op = (params.get("cmp_op") or "").strip()
+            cmp_src = (params.get("cmp_source") or "").strip()
+            if cmp_src not in ("", "manual", "device", "all", "group"):
+                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}: 候选值来源是「按设备分组」，但没填分组名 —— 取不到号")
             if cmp_op:
                 from tasks.generic.task import CMP_OPS
                 if cmp_op not in CMP_OPS:
                     errors.append(f"{here}.params.cmp_op: 不支持的比对运算符 {cmp_op!r}"
                                   f"（可用：{'、'.join(CMP_OPS)}）")
-                elif not str(params.get("cmp_value") or "").strip():
+                elif not str(params.get("cmp_value") or "").strip() \
+                        and cmp_src not in ("device", "all", "group"):
+                    # 候选值来自台账时允许手填留空（台账取号就够）；
+                    # 其余情况仍要求填值，否则永远不命中
                     errors.append(f"{here}.params.cmp_value: 选了文本比对"
                                   f"（{cmp_op}）就必须填比对的值，否则永远不命中")
                 elif (params.get("selector_type") or "xpath") == "screen":

doc/API.md

@@ -62,7 +62,9 @@
 
 ## 2. 接口总索引
 
-> 共 **107 条路由**。`鉴权` 列：`—` 无、`L` 登录、`T/D/A/G` = tasks/devices/apks/logs 权限位、`Admin` 仅管理员。
+> 本表列出全部业务路由（页面路由除外；同一路径的不同方法合并成一行）。
+> `鉴权` 列：`—` 无、`L` 登录、`T/D/A/G` = tasks/devices/apks/logs 权限位、`Admin` 仅管理员。
+> 想看实际注册了多少条：`python -c "from web_server import app; print(len([r for r in app.url_map.iter_rules() if r.rule.startswith('/api')]))"`。
 
 ### 2.1 auth（`web/auth.py`）
 
@@ -137,6 +139,27 @@
 | GET | `/api/done_marks?job=&limit=` | L | 去重记录列表 + 统计（`{marks, stats{total,devices,identities,today_devices,today_identities}}`） |
 | POST | `/api/done_marks/delete` | T | 删一条去重记录（`{id}`）→ 该设备/身份下次会重新执行 |
 | POST | `/api/done_marks/clear` | T | 清空某任务的全部去重记录（`{job}`）→ 整批重跑 |
+| GET | `/api/ledger?device=&q=&limit=` | D | 账号台账列表 + 统计（`{accounts, stats{total,devices,can_post_video,shown}, device_names}`） |
+| GET | `/api/ledger/by_device` | D | 按设备分组（`{devices:{设备号:{count,accounts[]}}, counts:{设备号:N}}`） |
+| POST | `/api/ledger` | D | 新增账号（抖音号重复 → 400） |
+| PUT | `/api/ledger/<acc_id>` | D | 改一条账号 |
+| DELETE | `/api/ledger/<acc_id>` | D | 删一条账号 |
+| POST | `/api/ledger/import` | D | 从表格粘贴文本批量导入（`dry_run=true` 只预览不写库） |
+| POST | `/api/video_plan/upload_video` | D | 上传单个视频素材（文件名 `手机号_日期_编号`）→ 解析 + 配对 + 入计划 |
+| POST | `/api/video_plan/upload_titles` | D | 上传标题（txt 文本或文件）→ 配到已有计划行 |
+| GET | `/api/video_plan/timeline` | D | 发布计划时间线（按日期分组的卡片 + 统计 + 磁盘） |
+| GET | `/api/video_plan/stats` | D | 今天要发/已发/待标题/过期未发 + 素材占用与磁盘余量 |
+| GET/PUT/DELETE | `/api/video_plan/<id>` | D | 单条计划：查看 / 改标题 / 删除（连素材文件） |
+| GET | `/api/video_plan/<id>/video` | D | 预览平台上的素材（文件清理后 → 410） |
+| POST | `/api/video_plan/<id>/push` | D | **把素材推到手机**（只推送、不发布；后台线程） |
+| POST | `/api/video_plan/push_all` | D | **一键推送**：某天（默认今天）所有待发布/失败的计划 → 各自手机（每台设备一个线程、设备内串行） |
+| POST | `/api/video_plan/<id>/mark` | D | 人工标记结果（`done`/`failed`/`unknown`，推完之后用） |
+| POST | `/api/video_plan/<id>/skip\|retry\|resolve` | D | 跳过 / 重试 / 裁决「结果未知」 |
+| GET | `/api/video_plan/links` | D | 已发布作品的分享链接（`format=csv` 导出，给铺评论用） |
+| GET | `/api/video_plan/tasks` | T | 可编辑的任务列表（全部通用步骤任务 + `is_release` 标记：状态/调度/下次运行 + 完整步骤） |
+| POST | `/api/video_plan/tasks` | T | 一键新建标准发布任务（骨架 15 步：亮屏 → 打开抖音 → 校验账号 → 推送 → 抖音点击 → 填标题 → 标记） |
+| GET/PUT | `/api/video_plan/tasks/<job_id>` | T | **发布任务的就地编辑**（就在「发布计划」页改名字/目标/时间/启停/步骤） |
+| POST | `/api/video_plan/tasks/<job_id>/adopt` | T | 给已有任务插上平台两步（推送放最前 / 标记放最后，自己的步骤不动） |
 
 ### 2.4 admin（`web/admin_api.py`）
 
@@ -482,6 +505,69 @@
 账本表与语义见 [DATA_MODEL.md](DATA_MODEL.md) §2.9；任务侧怎么用见
 [TASK_DEV.md](TASK_DEV.md) §4.6。
 
+### 账号台账（「账号」页）
+
+数据在 `device_account` 表（[DATA_MODEL.md](DATA_MODEL.md) §2.10），服务层 `core/ledger.py`，
+权限 `devices`。
+
+| 接口 | 请求 | 响应要点 |
+|------|------|---------|
+| `GET /api/ledger` | `?device=<设备号>&q=<搜索>&limit=500` | `{ok, accounts:[{id,device_name,serial,phone,nickname,douyin_id,registered_at,sim_in_device,can_post_video,bio,note,created_at,updated_at}], stats:{total,devices,can_post_video,shown}, device_names:["A01",…]}`。`q` 匹配抖音号/手机号/账号名 |
+| `GET /api/ledger/by_device` | — | `{ok, devices:{A01:{count,accounts:[…]}}, counts:{A01:4}}`（设备池"账号 N"列 + 点开看明细都用它，省一次请求） |
+| `POST /api/ledger` | 9 个字段（`device_name`/`douyin_id` 必填） | `{ok,msg,account}`；缺必填或抖音号重复 → **400** |
+| `PUT /api/ledger/<id>` | 局部字段 | `{ok,msg,account}`；不存在 → 404；抖音号撞车 → 400 |
+| `DELETE /api/ledger/<id>` | — | `{ok,msg}`；不存在 → 404 |
+| `POST /api/ledger/import` | `{"text":"…","delimiter":"\\t","mode":"skip\|overwrite","dry_run":true}` | `{ok, counts:{total,added,updated,skipped,failed}, rows:[{line,action,device_name,douyin_id,nickname,error,warns}], errors:[{line,reason}], mode, dry_run}` |
+
+**导入语义**（解析规则见 `core/ledger.parse_paste`）：
+
+- 分隔符默认 **Tab**（Excel 直接粘贴就是 Tab）；也支持 `|` 与 `,`。**不做"多个空格当分隔"**——
+  账号名里本来就有双空格（实测 `有牛奶面包  你吃吗？`）。
+- **带表头**时按列名映射（顺序随意、缺列留空、认不出的列忽略）；**不带表头**则按
+  设备号/手机号/账号名称/抖音号/注册时间/卡在机内/可发视频/简介/备注 的固定顺序。
+- 「卡在机内 / 可发视频」认 `是/有/1/true` → True，`否/空` → False；认不出的值按"否"处理
+  并在该行 `warns` 里留痕。
+- 抖音号非纯数字也会 `warns` 留痕（不拦）——它会让任务比对匹配不上。
+- `mode=skip`：库里有同号 → 跳过；`mode=overwrite`：**整行替换**（空单元格会覆盖掉原值）。
+- `dry_run=true` 走同一条解析+判重路径但**一个字节都不写**（界面默认先预览再导入）。
+- 缺设备号或抖音号的行会被跳过，并在 `errors` 里带行号说明。
+
+> ⚠ 台账里的抖音号是**纯号**，只当"比对用的候选值"；**不要**拿它填「去重」的身份元素
+> （身份是元素原文逐字算 key，格式不同会让去重**静默失效**）。
+
+### 视频发布计划（「账号 → 发布计划」页）
+
+表与状态机见 [DATA_MODEL.md](DATA_MODEL.md) §2.11，任务侧怎么自动发布见
+[TASK_DEV.md](TASK_DEV.md) §4.7；权限 `devices`。
+
+| 接口 | 请求 | 响应要点 |
+|------|------|---------|
+| `POST /api/video_plan/upload_video` | multipart `file`（单文件）+ `replace` | `{ok,name,action:add\|skip\|replace,plan,msg}`；解析/配对不通过 → **400 + `error`（人话原因）**。前端**逐文件串行**发（才能给每个文件一条进度与结果） |
+| `POST /api/video_plan/upload_titles` | `{text, dry_run}` 或 multipart `file`（txt） | `{ok, counts:{total,attached,skipped,rejected}, rows:[{line,phone,date,seq,title,action,error}], msg}`；**每行两种写法都认**：`标题内容_手机号_日期_编号`（推荐，右锚定，标题里可带下划线）或 `手机号_日期_编号_标题`（左锚定，跟视频文件名同序），**编号都可省略**；标题里可以有 `#话题`；空行忽略，`#` 开头的行**只有认不出手机号/日期时**才当注释；拒收条件：手机号不在台账/命中多个、日期不合法、标题为空或 >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/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>/video` | — | 素材预览（`send_file`，支持 Range）；文件已被清理 → **410** |
+| `POST /api/video_plan/<id>/push` | — | **把素材推到手机**（只推送、不发布）：推文件 → 触发相册刷新 → 标题写进剪贴板；已推送/结果未知 → 409。发布动作由你写在任务里（见 [TASK_DEV.md](TASK_DEV.md) §4.7） |
+| `POST /api/video_plan/push_all` | `{date?, retry_failed?}` | **一键推送**：某天（默认今天）`ready`/`failed` 且未超尝试上限的计划，**按设备分组**推（每台设备一个线程、设备内串行；设备间并行）。返回 `{ok,count,devices,no_device,msg}`；没绑上设备地址的条数单独在 `no_device` 里报出来。全部设备都解析不到 → 400 |
+| `POST /api/video_plan/<id>/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/tasks` | — | `{ok, tasks:[{id,name,enabled,mode,cron,next_run,target,steps,step_count,schedule,retry,is_release,has_push}], release_count, other_count}`：**全部通用步骤任务**（不止发布任务 —— 只列发布任务的话，手写的抖音发布流程会一条都不显示，人会以为"这页没有能改的地方"），界面按 `is_release`（有 `push_release` **或** `mark_release`，含嵌套）分两组。带完整 `steps` 是为**就地编辑**（抓选择器）；`step_count` 数的是**含嵌套**的总步数。权限 `T` |
+| `POST /api/video_plan/tasks` | `{"name","target":{"mode":"all\|group\|serial","group_name","serial"},"time":"10:00","enabled"}` | 一键新建：骨架 **15 步**（亮屏 → 打开抖音(等首页) → 点「我」→ `if_el(cmp_source=release)` 校验账号 → then: `push_release` → 「+」(预填 `descriptionContains=拍摄`) → 相册/第一个视频/下一步/输入框/发布（**空选择器占位**）→ `input_text(text_source=release_title)` → `mark_release`；else: `notify` 跳过）；**走 TaskManager 建**（内存+库一起更新，直接写库调度器不认）。⚠ `target` 分组键名是 **`group_name`**（写成 `group` 会静默解析出 0 台设备）；分组/单设备没给具体目标 → 400。权限 `T` |
+| `GET/PUT /api/video_plan/tasks/<job_id>` | `PUT {name?, time?, target?, steps?, enabled?}` | **发布任务的就地编辑**（「账号 → 发布计划」页里改，不用跳任务页）。只放开这几个字段，**没传的字段原样保留**；`steps` 整块替换但 `params` 里的通用参数（去重有效期、抢占…）**深合并保留**。校验：空名字/坏时间/`steps` 不是数组/什么都不传 → 400，未知任务 → 404。权限 `T`。底层仍是 `TaskManager.update_job()`（内存+库一起改） |
+| `POST /api/video_plan/tasks/<job_id>/adopt` | — | 给**已有任务**插上平台那两步：`push_release` 放最前、`mark_release` 放最后（**中间你自己的步骤一步不动**；位置理由见 `core.video_plan.insert_release_steps`）。只对「通用步骤」任务；没有步骤 → 400，已经有这两步 → 409，未知任务 → 404。权限 `T` |
+
+**逐文件上传的幂等**：同一 `(手机号,日期,编号)` 已有行时 —— 文件内容相同 → `action=skip`（不重复落盘）；
+内容不同 → **拒收**，前端给「覆盖」按钮（二次确认后带 `replace=1` 重传）。
+标题同理：同槽位已有别的标题 → 拒收（不静默覆盖，文案是发出去就改不了的东西）。
+
+> ⚠ 上传体积：`MAX_CONTENT_LENGTH`（默认 2GiB，`.env` 的 `MAX_UPLOAD_MB` 可调）**必须大于
+> 「应用管理」最大的 APK**（实测 336MB），否则 APK 上传会被一起卡死；超限返回 **JSON 413**。
+> 上反代时 nginx 那侧还要 `client_max_body_size`（见 [DEPLOY.md](DEPLOY.md) §6）。
+
 ---
 
 ## 6. 设备池与自动发现
@@ -719,7 +805,7 @@
 
 | 接口 | 请求 | 说明 |
 |------|------|------|
-| `POST /api/tools/clipboard/set` | `{"serials":[…],"text":"…"}` | ClipInject 通道写入并读回校验；serials 空或非列表 → 400 |
+| `POST /api/tools/clipboard/set` | `{"serials":[…],"text":"…"}` | 设备端 Agent 通道写入并读回校验（旧版独立 ClipInject 自动兜底）；serials 空或非列表 → 400 |
 | `POST /api/tools/appver` | `{"package":"com.xxx"}` | 并发查所有在线设备（≤10 并发）；包名须匹配 `^[A-Za-z0-9_.]+$` |
 
 ### Tailscale（全部 Admin）

doc/ARCHITECTURE.md

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

doc/DATA_MODEL.md

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

doc/DEPLOY.md

@@ -212,11 +212,16 @@ tail -20 logs/web.log                              # 无 ERROR/Traceback
 SUMMARY_TABLES = tuple(sorted(t.name for t in db.metadata.tables.values()))
 ```
 
-当前 15 张表：`app_meta` / `user` / `device_group` / `task_job` / `custom_action` /
+当前 17 张表：`app_meta` / `user` / `device_group` / `task_job` / `custom_action` /
 `apk_file` / `device` / `pending_device` / `agent_conversation` / `agent_experience` /
-`experience_audit` / `agent_action` / `device_install_log` / `task_step_log` / `done_mark`。
+`experience_audit` / `agent_action` / `device_install_log` / `task_step_log` / `done_mark` /
+`device_account`（账号台账）/ `video_plan`（视频发布计划）。
 完整说明见 [DATA_MODEL.md](DATA_MODEL.md) §6。
 
+> ⚠ **视频素材（`data/videos/`）不进备份包**（几十 GB 会把备份搞坏）：manifest 里有
+> `videos.included=false` 与数量/字节数，预览页也会提示 —— **素材要另外备份**。
+> 计划、发布状态与分享链接都在 `video_plan` 表里，随备份一起走。
+
 > ⚠️ `task_step_log`（任务步骤明细）是会持续增长的表：它按 `KEEP_DAYS`
 > （默认 14 天，见 `core/step_log.py`）自动清理，但备份包里会带上保留期内的全部行。
 > 设备多、任务密时导出 zip 会明显变大——需要更小的包就调小那个常量。
@@ -228,6 +233,10 @@ SUMMARY_TABLES = tuple(sorted(t.name for t in db.metadata.tables.values()))
 > 还需要手工做的只有：给新表补 `TABLE_LABELS` 的中文标签。
 > 导出侧有**覆盖自检**（登记表缺失 → `manifest.coverage_missing` + 日志告警）；
 > 导入侧有**反向自检**（备份含未登记表 → 预览告警）。
+>
+> **回滚注意事项**：把"含新表的备份"导回**旧版本代码**时，旧代码的 `SUMMARY_TABLES`
+> 里没有那张新表 → 导入预览会报 `extra_tables` 告警。**数据仍在快照里、不会丢**，
+> 属于预期行为（升级回新版即可正常识别）。
 
 ### 5.3 目录与手工备份
 
@@ -258,7 +267,13 @@ SUMMARY_TABLES = tuple(sorted(t.name for t in db.metadata.tables.values()))
 - **HTTPS/80 端口**：用 Nginx 反代
 
 ```nginx
-location / { proxy_pass http://127.0.0.1:18050; proxy_set_header Host $host; }
+location / {
+    proxy_pass http://127.0.0.1:18050;
+    proxy_set_header Host $host;
+    # ⚠ 必须加：nginx 默认 client_max_body_size 只有 1m，
+    # 不加的话「应用管理」传 APK（有 336MB 的包）和视频素材上传都会 413。
+    client_max_body_size 2048m;
+}
 ```
 
 ---

doc/DEVELOPMENT.md

@@ -140,6 +140,8 @@ MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<密码> \
 | `WEB_HOST` / `WEB_PORT` | `0.0.0.0` / `18050` | 硬编码 | 18050 避开 Windows 动态端口段 |
 | `DATA_DIR` / `APK_DIR` | `data/` / `data/apks/` | 代码计算 | |
 | `BACKUP_DIR` / `RESTORE_STAGING_DIR` / `RESTORE_PENDING_DIR` | `data/backups` / `data/restore_staging` / `data/restore_pending` | 代码计算 | 备份相关 |
+| `VIDEO_DIR` | `data/videos` | `DATA_VIDEO_DIR` | 视频发布计划的素材目录（**不进整库备份**；测试要指到临时目录） |
+| `MAX_CONTENT_LENGTH` | 2 GiB | `MAX_UPLOAD_MB` | 单次上传体积上限；**必须大于最大的 APK（实测 336MB）**，否则 APK 上传会被卡死 |
 | `DEPLOY_ENV` | `dev` | `.env` 可覆盖 | 声明这套配置连哪个环境的库；与库名绑定（dev→`auto_control_dev`，prod→`auto_control`），不符拒绝启动 |
 | `DB_HOST` / `DB_PORT` / `DB_USER` / `DB_PASSWORD` / `DB_NAME` | 空 / `3306` / 空 / 空 / 空 | `.env` 可覆盖 | MySQL 目标；`DB_HOST` 为空则回退 SQLite（**生产禁止静默回退**，需 `DB_ALLOW_SQLITE_FALLBACK=1`） |
 | `DB_CHARSET` / `DB_COLLATION` | `utf8mb4` / `utf8mb4_bin` | `.env` 可覆盖 | 排序规则必须用 `_bin`（逐码点比较，等价 SQLite 的大小写敏感语义） |
@@ -198,7 +200,7 @@ MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<密码> \
 | 页面结构 / 样式 / 引入脚本 | `templates/admin/monitor.html` |
 | 公共工具（API/权限/Toast/Tab） | `static/admin/base.js` |
 | 列表分页排序 | `static/admin/list.js` |
-| 各功能域逻辑 | `static/admin/{monitor,editor,tasks,tools,apps,admin,agent,system,markdown}.js` |
+| 各功能域逻辑 | `static/admin/{monitor,editor,tasks,tools,apps,admin,agent,system,markdown,dedup,ledger,release}.js` |
 
 新增 JS 模块：建文件 → 在 `monitor.html` 里按依赖顺序加 `<script src>` → 更新 [ARCHITECTURE.md](ARCHITECTURE.md) §6.3 与本文 §5.3。
 

doc/DEVICE_AGENT.md

@@ -192,8 +192,18 @@ adb -s <serial> shell am start -n <pkg>/.ClipActivity --es text_b64 <base64(UTF-
 
 - **必须 base64**：adb shell 直传中文/特殊字符会变形
 - 必须用**透明 Activity**（有焦点才能写剪贴板），写完**立即退出**
-- 平台判定失败的方式：`am start` 输出里有 `unable to resolve Intent` / `does not exist`
-  → 视为"设备未安装 Agent"
+- 平台判定失败的方式：`am start` 输出里有 `unable to resolve Intent` / `does not exist` /
+  `Error type 3` → 视为"这台设备没有这个通道"
+
+**平台按顺序试两个包**（`core/clipboard_helper.py` 的 `_CLIP_TARGETS`）：
+
+| 顺序 | 包 | 说明 |
+|---|---|---|
+| 1 | `com.example.deviceagent`（**本 Agent**） | 现在的标准通道；装了就只调它 |
+| 2 | `com.example.clipinject`（早期独立 APK） | 老设备上可能还残留 → 兜底；走这条会在日志里提示"建议装设备端 Agent" |
+
+两个都没有时报"设备未安装剪贴板注入通道：需要设备端 Agent"（不再只说 ClipInject，
+否则用户会去装那个已经不再分发的旧 APK）。**设备端无需为这条改动做任何事**。
 
 ### 5.2 设备身份显示（设备端已实现）
 
@@ -206,6 +216,51 @@ 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 点
@@ -239,6 +294,9 @@ adb -s <serial> shell am start -n <pkg>/.ConfigActivity \
 
 ## 6. 版本与兼容
 
+- **§5.2.1 的 `accounts_b64` 是"加字段"= 小版本**：`agent_api_version` **仍是 1**，
+  设备端忽略它时行为必须与旧版逐字一致（只是大字页少一块内容）。也**不**走
+  `bootstrap`：身份页由平台用 adb 推，加进 bootstrap 没人用还会让契约多一处要同步。
 - `agent_api_version`（当前 **1**）在每次 `bootstrap` 响应里返回
 - **设备端**：启动时对比自己实现的版本，不一致要在日志里明确记下来（不要静默）
 - **平台端**：

doc/MCP.md

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

doc/MCP_DESIGN.md

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

doc/NOTIFY.md

@@ -52,6 +52,7 @@ daemon 线程。所以：
 | 任务批次 | `task.batch.started` · `.finished` · `.no_device` · `.unknown_type` · `task.cron.stopped` |
 | 任务·单设备 | `task.device.success` · `.failed` · `.offline` · `.error` · `.retry` · `.stopped` · `.preempted` · `.preempt_timeout` · `.released` |
 | 业务 | `task.selector.invalid`（选择器连续 10 次未命中——"任务成功但什么都没做"的隐蔽故障） |
+| 业务 | `task.video.published`（视频发布成功，带作品分享链接）/ `task.video.failed`（发布失败**或结果未知**——结果未知意味着可能已经发出去了，要到计划页人工确认，平台不会自动重发） |
 | 业务·任务自己发 | `task.notify.custom`（步骤「发通知」）/ `task.patrol.hit`（任务「公共巡检」命中）——**标题正文由任务自己写**，见下 |
 | Worker | `worker.connected` · `.attempt.done` · `.attempt.error`（单次尝试级，噪音大，默认没人勾） |
 | 设备 | `device.online` · `.offline` · `.discovered` · `.claimed` · `device.heartbeat_timeout` · `device.battery.low` · `.battery.recovered` |

doc/README.md

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

doc/TASK_DEV.md

@@ -10,7 +10,7 @@
 
 - [1. 核心概念](#1-核心概念)
 - [2. 通用步骤任务 generic_steps](#2-通用步骤任务-generic_steps)
-- [3. 22 种步骤全表](#3-22-种步骤全表)（含 [3.1 步骤默认值与动作录制](#31-步骤默认值与动作录制任务--动作配置)）
+- [3. 24 种步骤全表](#3-24-种步骤全表)（含 [3.1 步骤默认值与动作录制](#31-步骤默认值与动作录制任务--动作配置)）
 - [4. 容器步骤与公共参数](#4-容器步骤与公共参数)（含 [4.5 公共巡检](#45-公共巡检任务级独立于步骤画布)）
 - [5. 选择器与元素定位](#5-选择器与元素定位)
 - [6. 自定义动作](#6-自定义动作)
@@ -109,7 +109,7 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 
 ---
 
-## 3. 22 种步骤全表
+## 3. 24 种步骤全表
 
 > 参数与默认值以 `tasks/generic/task.py` 为准；前端 `STEP_LIB`（`static/admin/editor.js`）负责在编辑器里呈现这些字段。
 
@@ -127,16 +127,18 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 | 10 | `click_xy` | 点击坐标 | — | `x`(50)、`y`(50) | — | **屏幕百分比**（0-100，会夹取），50/50 = 屏幕中心。无选择器时的兜底，**最脆的方式** |
 | 11 | `long_click` | 长按元素 | `selector_type`、`selector_value` | `duration`(1.0)、`wait_timeout`(2) | — | 先等元素出现再 `long_click` |
 | 12 | `wait_el` | 等待元素 | `selector_type`、`selector_value` | `timeout`(10) | — | 等元素出现（条件等待，优于固定 `wait`） |
-| 13 | `input_text` | 输入文字 | — | `mode`("random")、`texts`("你好\n有趣\n支持")、`fixed_text`("")、`clear_first`(True) | — | `mode="fixed"` 用 `fixed_text`，否则从 `texts` 按行随机选一条；**只负责输入，不负责定位输入框**（要先 click 输入框） |
-| 14 | `clipboard` | 剪贴板注入 | `text` | `paste`(True) | — | 走 ClipInject 通道（绕开 Android 10+ 后台写剪贴板限制）；`paste=true` 时再触发一次粘贴 |
+| 13 | `input_text` | 输入文字 | — | `mode`("random")、`texts`("你好\n有趣\n支持")、`fixed_text`("")、`clear_first`(True)、`text_source`("manual")、`release_topics`("") | — | `mode="fixed"` 用 `fixed_text`，否则从 `texts` 按行随机选一条；`text_source=release_title`（或 `release_title_topics`）时**取本机当前那条发布计划的标题**（配 `release_topics` 自动加话题），**并回读输入框校验**（不校验就可能发出一篇空文案）；**只负责输入，不负责定位输入框**（要先 click 输入框） |
+| 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 |
 | 17 | `group` | 动作组 | — | — | `children` | 子步骤**按序执行一次**（不循环）；自定义动作拖入画布就是展开成 group |
-| 18 | `if_el` | 条件判断 | `selector_type`、`selector_value`、`timeout`(3) | `ocr_click`(False)、`cmp_op`("")、`cmp_value`("")、`ident_type`/`ident_value`（去重身份） | `then` / `else` | 见 §4.2；条件类型除元素/OCR 外还支持 **屏幕状态**、**前台App**、**去重**（见 §4.6）；填 `cmp_op` 则改成**比元素的文本**（等于/不等于/包含/不包含，多值任一命中） |
+| 18 | `if_el` | 条件判断 | `selector_type`、`selector_value`、`timeout`(3) | `ocr_click`(False)、`cmp_op`("")、`cmp_value`("")、`cmp_source`("")、`cmp_group`("")、`ident_type`/`ident_value`（去重身份） | `then` / `else` | 见 §4.2；条件类型除元素/OCR 外还支持 **屏幕状态**、**前台App**、**去重**（见 §4.6）；填 `cmp_op` 则改成**比元素的文本**（等于/不等于/包含/不包含，多值任一命中），候选值还可以从**「账号」台账**取（`cmp_source` = device/all/group），或取**本机要发的那条发布计划**的抖音号/昵称（`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 |
+| 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 |
+| 24 | `mark_release` | 标记发布结果 | `result`(published/failed/unknown)、`why` | `capture_link`(True)、`delete_phone`(True)、`album_dir` | — | 放在**你自己发布流程的末尾**：把"发出去了没有"回写到计划行（成功时顺手抓作品分享链接、删手机上的素材）。拿不准就填 `unknown` —— 平台不会自动重发它。见 §4.7 |
 
 ### 3.2 录制手势：**纯录制、纯回放**（`core/gesture.py`）
 
@@ -283,6 +285,46 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
   走了 `else`，不是选择器失效，不该攒出「连续未命中」告警。
 - 读元素文本是**只读**操作（`get_text`，2 秒超时），不会点击或改动任何状态。
 
+#### 候选值从「账号」台账取号（`cmp_source` / `cmp_group`，可选）
+
+几十个号时手写 `cmp_value` 很累、而且换号要回来改。`cmp_source` 让候选值直接来自
+「账号」页的台账：
+
+| `cmp_source` | 取哪些号 |
+|---|---|
+| `""` / `manual`（默认） | 只用手填的 `cmp_value` —— **行为与以前完全一致** |
+| `device` | **本机台账**：这台设备在台账里登记的抖音号（靠 `serial`→设备名 匹配） |
+| `all` | 全部台账 |
+| `group` | 某个**设备分组**内所有设备的号（分组名填在 `cmp_group`） |
+| `release` | **本机当前发布计划**要发的那个号：优先本次运行里「推送发布视频」刚取到的那条；还没有就**看**下一条待发的（只看不占位）。候选值是**抖音号 + 账号名称**两个（任一命中即可） |
+
+#### `release`：发布前先确认"登的是要发的那个号"（一台手机登好几个号时必配）
+
+一台手机可能登着好几个号，发布前必须确认当前抖音登的就是这条计划要发的号 ——
+就在发布流程**最前面**放一个条件判断（`cmp_source=release` + `包含`），命中了才走发布，
+没命中走 `else`（发通知/跳过）。这样"发错号"变成"这条跳过"，而不是把 A 号的视频发到 B 号上。
+
+- 比对的元素原文：抖音「我」页面上的那一行（如 `//*[contains(@text,'抖音号')]`）——
+  `cmp_source=release` 给的候选值包含**抖音号**，所以 `包含` 就能命中。
+- 命中判据是**候选值里任一被元素原文包含**；两个候选值（抖音号、昵称）是刻意的：
+  有的界面只显示昵称。
+- **本机没有待发计划 → 候选为空 → 这一步永远走 `else`**（日志会写明"本机没有待发的发布计划"），
+  不会把不该发的号发出去。
+
+- **与手填值是合并（OR）**，不是二选一：台账里的号 + 你补的一个号，任一命中即可。
+  更重要的是 —— **台账取不到号时手填值仍然生效**，台账没维护好不会把任务直接打哑。
+- 取到 0 个号时**日志会写明原因**（如"设备名对不上"）：
+  候选为空会让这一步**永远走 `else` 分支**，而任务本身照样"跑完了"。
+  编辑器保存时也会为此报警告，请到「账号」页核对设备号。
+- 比对运算符仍要选：台账里是**纯号**（`35377983067`），元素原文是
+  `抖音号：35377983067` → 用 **`包含`**。（要整段一模一样才用 `等于`。）
+
+> ⚠ **台账的纯号只能当"比对用的候选值"，绝不能拿去填「去重」的身份元素**（`ident_value`）：
+> 去重身份存的是**元素原文**、逐字算 key（`core/dedup.py` 的 `build_key`），
+> 格式不一致（`35377983067` vs `抖音号：35377983067`）会让**检查与记账算出两个不同的
+> key → 去重静默失效**（重复评论，而且日志看不出问题）。
+> 去重身份继续用「抓取元素」抓到的那个账号元素即可。
+
 ### 4.3 公共参数
 
 | 参数 | 说明 |
@@ -375,21 +417,29 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
   "then": [{"type": "stop_self", "params": {"reason": "这个号今天已经评过了"}}],
   "else": [
     {"type": "click",  "params": {"selector_type": "text", "selector_value": "发送"}},
-    {"type": "mark_done", "params": {"selector_type": "resourceId",
-                                     "selector_value": "com.ss.android.ugc.aweme:id/506"}}
+    {"type": "mark_done", "params": {}}      // 身份留空 = 自动跟随上面检查用的身份
   ]}}
 ```
 
 **身份值**（去重的"谁"）＝ 身份元素读出来的文本（上例＝抖音号）。
-留空则该步骤用**设备 `serial`** 当身份（适合"一号一机"）。
+
+身份**只需在检查侧配一次**：
+
+| 位置 | 身份元素 | 结果 |
+|---|---|---|
+| 条件判断（去重） | 填账号元素 | 检查用这个身份 |
+| **记为已做** | **留空（推荐）** | **自动跟随上面检查刚解析出的身份** —— 检查与记账必然用同一个 key |
+| 记为已做 | 也填了 | 用自己填的；**与检查侧不一致时编辑器会告警** |
+| 记为已做 | 留空 + 任务里没有去重检查 | 退回**设备 `serial`** 当身份（"一号一机"场景） |
+
+> ⚠ 为什么把「留空 = 自动跟随」做成默认：检查与记账算的是同一个 key，
+> 两处各配一遍、一边填了一边忘了 → 两个 key → **去重静默失效**（最难查的那种 bug，
+> 现象是"去重没生效、还是重复做"）。编辑器保存时会告警「两处身份不一致」
+> 「有去重检查但没有记为已做」「有记为已做但没有去重检查」。
 
 **有效期**（去重多久算"新的一轮"）在**任务级**配一次：`dedup_reset` = `day`（默认，每天一次）
 / `all`（只做一次）/ `hours`（每 `dedup_hours` 小时）。任务编辑器顶部有「去重有效期」下拉。
 
-> ⚠ **为什么有效期和身份元素都强制"只配一处"**：检查与记账两边算的是同一个 key，
-> 一边填得不一样就会算出两个 key → **去重静默失效**（最难查的那种 bug）。
-> 编辑器保存时会直接告警：「身份元素不一致」「有去重检查但没有记为已做」等。
-
 **四条必须知道的语义**：
 
 | 情况 | 行为 | 为什么 |
@@ -412,6 +462,140 @@ from .generic import task  # 触发 @register_task（当前唯一任务类型）
 
 ---
 
+### 4.7 发布计划：平台推素材，发布流程你自己写（`push_release` + `mark_release`）
+
+数据与界面见 [DATA_MODEL.md](DATA_MODEL.md) §2.11 与「账号 → 发布计划」页。
+
+**分工**（这是刻意的设计）：**平台只管"素材到手机 + 状态记账"，抖音里怎么发由你画** ——
+因为发布流程跟账号、版本、界面都在变，写死在平台里改不动。
+
+```
+[条件判断 cmp_source=release]  →  [推送发布视频]  →  [你自己写的发布步骤…]  →  [标记发布结果]
+ 当前登的是要发的号吗？             push_release        打开抖音→点+→相册→选视频       mark_release
+ 不是 → else：发通知（本条跳过）                        →下一步→粘贴标题→发布          result=published 放成功分支
+                                                                                 result=failed 放失败分支
+```
+
+**先校验账号再发**（一台手机登好几个号时必配）：放在最前面的条件判断用
+`cmp_source=release`（候选值 = 本机要发的那条计划的**抖音号/账号名称**，见 §4.2），
+元素原文取抖音「我」页面上的 `//*[contains(@text,'抖音号')]`，运算符 `包含`；
+没命中就走 `else` —— **宁可不发，也不发错号**。
+
+**「推送发布视频」做六件事**（`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')
+   ← **幂等的唯一判据**（多设备/任务重跑不会把同一条推两遍）
+④ adb push → {album_dir}/{计划id}.mp4（默认 /sdcard/DCIM/Camera）→ 校验**大小**（按 ls -l 的大小列比）
+⑤ **touch 一下**把手机上这个文件的 mtime 改成"现在" + 清掉同一计划在旧目录里的副本
+⑥ 触发媒体扫描 → **按路径**校验它真的进了相册索引 → 把标题写进手机剪贴板（供「粘贴」用）
+```
+
+**为什么是 `DCIM/Camera`、为什么要 touch**（都是实测踩出来的）：
+
+- 相册（含抖音的选视频页）读的是 **MediaStore 索引**：`adb push` 只放文件、不进索引，
+  推完必须触发扫描，否则"推送成功但相册里没有"。
+- MIUI 会把自建子目录（`DCIM/rp`）归到「其他相册」，抖音的选视频页列不顺 —— 所以放官方相机目录。
+- 放 Camera 的代价：**用户自己拍的视频也在这个目录里** → "相册里第一个 = 刚推的那个"靠排序成立。
+  而 `adb push` 保留的是**本地文件的修改时间**（推一个 3 天前上传的素材 → 排在很后面，
+  "点第一个"就点到别的视频了）→ **推完必须 `touch`**，把 mtime 改成现在。
+- 同一个 plan id 在老目录里可能还留着副本（换目录后的残留）→ 推送时顺手按**精确路径**清掉，
+  并重扫让相册索引把那行去掉；不清的话相册里同一个视频出现两三份，点第一个可能点到死文件。
+- **校验必须比路径，不能只比文件名**：MediaStore 的 `_data` 返回的是
+  `/storage/emulated/0/dcim/rp/...`（目录部分被小写），而 `_indexed_paths()` 归一化后再比；
+  只比文件名会被"老副本在索引里"骗过去，判成"新文件已就绪"。
+- 校验结果落 `video_plan.push_verify`（`ok` / `no_index` / `nofile`）+ `push_remote`（手机上的绝对路径），
+  界面上标「已推送·相册可见 / 已推送·相册未见」——**文件推上去了 ≠ 相册里点得到它**，
+  这两件事必须分开显示。
+
+> ⚠ **uiautomator2 3.x 的 `d.shell()` 返回 `ShellResponse`（tuple 子类），不是 str**：
+> 直接 `'abc' in resp`（元组成员判断，恒 False）或 `resp.strip()`（没这方法）都会得到错误结果。
+> 实测踩过：推送的"文件大小校验"永远不通过（每次推送都被记成失败，而文件其实推上去了）、
+> "有没有进相册"永远报没进。取输出统一走 `publish_flow._sh(d, cmd)`。
+
+远程名用**计划 id**（唯一可识别）。老默认目录 `Movies/rp`、`DCIM/rp` 里的历史副本会被 `drop_old_copies()` 清掉。
+
+**「标记发布结果」**放在你的流程末尾：
+
+| `result` | 什么时候用 | 落库 |
+|---|---|---|
+| `published` | 确认发出去了 | `done`（顺手抓作品分享链接存进计划行、删手机上的素材） |
+| `failed` | 确认没发出去 | `failed`（**可重试**：下次任务会再推一次） |
+| `unknown` | 拿不准 | `unknown`（**绝不自动重发**，计划页标橙，人工裁决） |
+
+**阶段与状态的对应**（`core/video_plan.STAGE_STATUS`，本设计最要紧的一张表）：
+
+| 阶段 | 含义 | 落库 | 能不能自动重试 |
+|---|---|---|---|
+| `push` | 推文件到手机失败（还没碰抖音） | `failed` | ✅ 安全 |
+| `scan` | 媒体扫描 | `failed` | ✅ 同上 |
+| `manual` | **已推到手机**，后面归你/你的人管 | — | — |
+| `post` / `verify` | 推送之后出的岔子（你标记失败/未知） | `unknown` | ❌ **可能已经发出去了** |
+
+> ⚠ **`failed` 与 `unknown` 必须分开**：把"不知道自己发没发"当成"知道自己没发"，
+> 就是重复发布的来源。每日 04:41 的清理 job 会把卡住的占位按阶段降级
+> （`manual` 阶段 → `unknown`，不会降成"可重试"）—— 没有它，一条计划崩一次就永远卡住。
+
+**几条硬约束**（都是踩过的坑）：
+
+- **只删平台自己推的文件**（`{计划id}.mp4` 精确路径）。**绝不 `rm` 通配** —— 会删用户自己拍的东西。
+- **一次只推一个视频**（`max_same_run=1`）：这样"相册里第一个 = 我要发的那个"才成立；
+  要一次发多条，就重复"推送 + 你的发布步骤 + 标记"这一组。
+- **你的发布步骤里，文案要用「粘贴」**（推送时标题已进剪贴板）；如果非要用「输入文字」，
+  记得后面加一步**回读校验**（读输入框的 text）—— 抖音的 EditText 有时不吃 `send_keys`，
+  不校验就可能发出一篇空文案而每一步都显示成功。
+- **不靠 `done_mark` 判重**：去重账本的 identity 是元素原文，与 `(手机号,日期,编号)` 两套 key
+  语义不同，混用会静默失效。
+- **任务状态 ≠ 发布结果**：`_exec_steps` 不检查步骤结果，**标记失败不会让任务失败** ——
+  「这次发布的真相」以计划行的 `status` 为准（计划页看得到），并会推
+  `task.video.published` / `task.video.failed` 通知。
+
+**「发布计划」页顶部还有一块「发布任务」**（`GET/POST /api/video_plan/tasks`）：
+上面一组是**发布任务**（步骤里含「推送发布视频」**或**「标记发布结果」，含嵌套在条件/循环里的），
+下面「其它任务」折叠着**全部通用步骤任务** —— 都能就地编辑。
+列全部是刻意的：**手写的抖音发布流程**（自己点相册→输入框→发布，没有平台的 `push_release` 步骤）
+如果被筛掉，人打开这页只会看到"一键新建"，会以为"这页没有能改的地方"；
+这类任务行上会标「**缺平台推送步骤**」并给一个「**插上平台步骤**」按钮
+（`POST /api/video_plan/tasks/<id>/adopt`：推送放最前、标记放最后、**你原来的步骤一步不动**）。
+还支持**一键新建标准发布任务** ——
+骨架 **15 步**已经排好：
+
+```
+⓪ 亮屏  ① 打开抖音(等「首页」出来)  ② 点击「我」(desc 含"我")  ③ 等待 3~5s
+④ 条件判断  //*[contains(@text,'抖音号')] 包含 cmp_source=release
+   ├─ then（登的就是要发的号）⑤ 推送发布视频 ⑥ 点击「+」(desc 含"拍摄")
+   │        ⑦ 相册 ⑧ 第一个视频 ⑨ 下一步 ⑩ 输入框 ⑪ 输入文字(text_source=release_title)
+   │        ⑫ 点击「发布」 ⑬ 标记发布结果
+   └─ else（不是这个号 / 今天没有待发计划）⑭ 发通知"本条跳过"
+```
+
+> ⚠ **⓪ 亮屏 + ① 等「首页」是踩出来的，别删**：真机实测（2026-09-28，A01）——
+> **屏幕没亮就启动抖音，它会永远停在启动页**（`mCurrentFocus=splash.SplashActivity`、UI 树是空的），
+> 于是"点击我"必然 miss、"等抖音号出现"必然超时，最后报成一句误导人的"账号不符"。
+> 屏幕亮着时冷启动 5 秒就出底部栏。
+
+建好之后**就在「发布计划」这一块点「编辑」就地改**（名字/目标/每天几点/启停/逐步参数，
+选择器旁边就有「抓取元素」），把 5 个空选择器（相册/第一个视频/下一步/输入框/发布）抓一次就能跑 ——
+要加步骤、循环、自定义动作这些更复杂的编排，才走「打开通用编辑器」（跳任务页）——
+**抖音那几步故意不写死选择器**：混淆 id / 结构 xpath 改版就废，
+抓一次的成本远低于每次发版都改平台代码。②⑥ 两条预填的是**按描述定位**
+（`descriptionContains`，跨版本稳），一般不用改。
+
+**「输入文字」自动用标题**：`text_source=release_title` 会取**本机当前那条计划**的标题
+（`push_release` 同一次运行里传递；断档了就取最近一条"已推送到手机"的），
+`release_title_topics` 还能自动补话题；**取计划标题时会回读输入框校验**，
+不通过就改走剪贴板通道再验一次 —— 抖音的 EditText 有时不吃键盘输入，
+不校验的后果是"发出一篇空文案，而每一步都显示成功"。
+
+**抓分享链接**（`mark_release` 的 `capture_link=True`，或计划页人工点「标记已发布」时）：
+进「我 → 作品」第一条 → 分享 → 复制链接 → 读剪贴板 → 正则抠出 `v.douyin.com` 链接。
+**这一段仍是抖音 UI 流程**（按文字定位），抖音改版会失效 —— 失效时链接空着，
+计划页标"缺链接"、素材文件**不删**（链接与素材至少留一个），不影响"已发布"这个结论。
+
 ## 5. 选择器与元素定位
 
 ### 5.1 `selector_type` 支持的值

static/admin/base.js

@@ -102,6 +102,7 @@ function showTab(name){
   if(_monitorTimer){clearInterval(_monitorTimer);_monitorTimer=null;}
   if(_logTimer){clearInterval(_logTimer);_logTimer=null;}
   if(_discoveryTimer){clearInterval(_discoveryTimer);_discoveryTimer=null;}
+  if(typeof _rpTimer!=='undefined'&&_rpTimer){clearInterval(_rpTimer);_rpTimer=null;}
   // 按需加载数据
   if(name==='monitor'){loadMonitor();_monitorTimer=setInterval(loadMonitor,5000);}
   if(name==='tasks'){showSubTab('tasks',_activeSubs.tasks);loadTasks();loadCustomActions();
@@ -116,6 +117,7 @@ function showTab(name){
     showSubTab('agent', _activeSubs.agent||'chat');   // 聊天 / AI 建任务
     if(typeof initAgentChat==='function') initAgentChat();
   }
+  if(name==='account'){showSubTab('account',_activeSubs.account||'ledger');}
   if(name==='users')loadUsers();
   if(name==='system'){showSubTab('system',_activeSubs.system||'backup');}
 }
@@ -123,7 +125,7 @@ function showTab(name){
 // ================== 页内子分栏（任务/工具 通用） ==================
 // 每个带子分栏的 Tab 记住上次选中的子分栏，切走再切回来保持原位
 let _activeSubs = {tasks: 'plan', tools: 'clipboard', system: 'backup', agent: 'chat',
-                   logs: 'files'};
+                   logs: 'files', account: 'ledger'};
 let _discoveryTimer = null;   // 设备自动发现 10s 轮询（仅 devpool 子分栏激活时）
 
 function showSubTab(tabId, name){
@@ -137,6 +139,11 @@ 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

@@ -7,7 +7,7 @@ var STEP_LIB=[
   {type:'long_click',label:'长按元素',icon:'👆',cat:'interact',params:{selector_type:'xpath',selector_value:'',duration:1.0,wait_timeout:2}},
   {type:'swipe',label:'滑动',icon:'↕',cat:'interact',params:{direction:'up',duration_min:0.25,duration_max:0.50,distance_ratio:0.6,jitter:0.15,humanize:true}},
   {type:'swipe_until',label:'滑动直到元素',icon:'🔍',cat:'interact',params:{selector_type:'xpath',selector_value:'',direction:'up',max_swipes:8,click_when_found:true,duration_min:0.25,duration_max:0.50,distance_ratio:0.6,jitter:0.15,humanize:true}},
-  {type:'input_text',label:'输入文字',icon:'⌨',cat:'interact',params:{mode:'random',texts:'你好\n有趣\n支持',fixed_text:'',clear_first:true}},
+  {type:'input_text',label:'输入文字',icon:'⌨',cat:'interact',params:{mode:'random',texts:'你好\n有趣\n支持',fixed_text:'',clear_first:true,text_source:'manual',release_topics:''}},
   {type:'clipboard',label:'剪贴板注入',icon:'📋',cat:'interact',params:{text:'',paste:true}},
   {type:'key_event',label:'按键',icon:'⌨️',cat:'interact',params:{key:'back'}},
   {type:'open_app',label:'打开App',icon:'▶',cat:'screen',params:{package:'',wait_home:false,home_feature:''}},
@@ -19,7 +19,7 @@ var STEP_LIB=[
   {type:'wait_el',label:'等待元素',icon:'⏳',cat:'flow',params:{selector_type:'xpath',selector_value:'',timeout:10}},
   {type:'loop',label:'循环块',icon:'↻',cat:'flow',params:{loop_mode:'rounds',max_iterations:10,loop_duration:600,children:[]}},
   {type:'group',label:'动作组',icon:'📦',cat:'flow',params:{children:[]}},
-  {type:'if_el',label:'条件判断',icon:'❓',cat:'flow',params:{selector_type:'xpath',selector_value:'',timeout:3,ocr_click:false,cmp_op:'',cmp_value:'',ident_type:'text',ident_value:'',then:[],else:[]}},
+  {type:'if_el',label:'条件判断',icon:'❓',cat:'flow',params:{selector_type:'xpath',selector_value:'',timeout:3,ocr_click:false,cmp_op:'',cmp_value:'',cmp_source:'',cmp_group:'',ident_type:'text',ident_value:'',then:[],else:[]}},
   {type:'mark_done',label:'记为已做',icon:'✅',cat:'flow',params:{selector_type:'text',selector_value:''}},
   {type:'notify',label:'发通知',icon:'🔔',cat:'flow',params:{title:'',message:'',level:'info'}},
   {type:'stop_self',label:'停止本设备',icon:'⛔',cat:'flow',params:{reason:''}},
@@ -440,11 +440,23 @@ var _stepEditor={
       h+='<div class="help">批量发链接场景：先"点击元素"聚焦评论区输入框，再执行本步骤注入+粘贴；循环里依次更换注入内容即可逐个发</div>';
     }else if(step.type==='input_text'){
       const im=p.mode==='fixed'?'fixed':'random';
-      h+='<div class="form-group"><label>输入模式</label><select class="form-control" data-key="mode" onchange="_stepEditor._toggleInputMode(this)">'+
+      const tsrc=p.text_source||'manual';
+      const fromPlan=(tsrc!=='manual');
+      // 取值来源：默认手填（行为与以前一致）；也可以直接吃「发布计划」里那一条的标题
+      h+='<div class="form-group"><label>取值来源</label><select class="form-control" data-key="text_source" onchange="_stepEditor._inputSourceChanged(this)">'+
+        [['manual','手填 / 随机候选（默认）'],['release_title','发布计划这一条的标题'],['release_title_topics','发布计划标题 + 话题']]
+          .map(function(o){return '<option value="'+o[0]+'"'+(tsrc===o[0]?' selected':'')+'>'+o[1]+'</option>';}).join('')+
+        '</select><div class="help">选"发布计划"时，标题由前面的「推送发布视频」那一步取出来（同一次运行里传递；没取到会跳过并告警）—— 你就不用把同一句文案再抄一遍了</div></div>';
+      if(fromPlan){
+        h+='<div class="form-group" data-key-wrap="release_topics" style="display:'+(tsrc==='release_title_topics'?'block':'none')+'"><label>话题（逗号分隔，不带 # 会自动补）</label><input type="text" class="form-control" data-key="release_topics" value="'+esc(p.release_topics||'')+'" placeholder="如 苏州,日常"></div>';
+        h+='<div class="help" style="color:#f59e0b">取计划标题时<b>会回读输入框校验</b>：抖音的输入框有时不吃键盘输入，不校验就可能发出一篇空文案；校验不过会自动改走剪贴板粘贴再验一次</div>';
+      }
+      // 手填那两块：**只隐藏不删**（_syncParams 按 DOM 存在与否收集，删了会把用户填的值抹掉）
+      h+='<div class="form-group" style="display:'+(fromPlan?'none':'block')+'"><label>输入模式</label><select class="form-control" data-key="mode" onchange="_stepEditor._toggleInputMode(this)">'+
         '<option value="random"'+(im==='random'?' selected':'')+'>随机候选</option>'+
         '<option value="fixed"'+(im==='fixed'?' selected':'')+'>指定文字</option></select></div>';
-      h+='<div class="form-group" data-mode="random" style="display:'+(im==='random'?'block':'none')+'"><label>候选文字（每行一个，随机选一条）</label><textarea class="form-control" data-key="texts" rows="4" style="font-family:monospace;min-height:80px">'+esc(p.texts||'你好\n有趣\n支持')+'</textarea></div>';
-      h+='<div class="form-group" data-mode="fixed" style="display:'+(im==='fixed'?'block':'none')+'"><label>指定文字</label><input type="text" class="form-control" data-key="fixed_text" value="'+esc(p.fixed_text||'')+'"></div>';
+      h+='<div class="form-group" data-mode="random" style="display:'+((!fromPlan&&im==='random')?'block':'none')+'"><label>候选文字（每行一个，随机选一条）</label><textarea class="form-control" data-key="texts" rows="4" style="font-family:monospace;min-height:80px">'+esc(p.texts||'你好\n有趣\n支持')+'</textarea></div>';
+      h+='<div class="form-group" data-mode="fixed" style="display:'+((!fromPlan&&im==='fixed')?'block':'none')+'"><label>指定文字</label><input type="text" class="form-control" data-key="fixed_text" value="'+esc(p.fixed_text||'')+'"></div>';
       h+='<div class="form-group form-check"><input type="checkbox" data-key="clear_first" '+(p.clear_first!==false?'checked':'')+'><label>输入前先清空</label></div>';
       h+='<div class="help">需先用"点击元素"步骤定位到输入框，本步骤只负责输入文字</div>';
     }else if(step.type==='loop'){
@@ -464,16 +476,39 @@ 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 cmpRow=dyn?'':'<div class="form-row"><div class="form-group"><label>文本比对</label>'+
         '<select class="form-control" data-key="cmp_op">'+
         [['','不比对（只看元素在不在）'],['等于','等于'],['不等于','不等于'],['包含','包含'],['不包含','不包含']]
           .map(function(o){return '<option value="'+o[0]+'"'+((p.cmp_op||'')===o[0]?' selected':'')+'>'+o[1]+'</option>';}).join('')+
         '</select></div>'+
-        '<div class="form-group" style="grid-column:span 2"><label>比对的值（可多行，任一命中即可）</label>'+
+        '<div class="form-group"><label>候选值来源</label>'+
+        '<select class="form-control" data-key="cmp_source" onchange="_stepEditor._cmpSourceChanged(this)">'+
+        [['','手填（默认）'],['device','本机台账'],['all','全部台账'],['group','按设备分组'],
+         ['release','本机当前发布计划（要发的那个号）']]
+          .map(function(o){return '<option value="'+o[0]+'"'+((p.cmp_source||'')===o[0]?' selected':'')+'>'+o[1]+'</option>';}).join('')+
+        '</select><div class="help">'+(p.cmp_source==='release'
+          ? '取<b>本机下一条要发的发布计划</b>的抖音号 + 账号名称（推送前校验"当前登录的是不是要发的号"就用它）'
+          : '台账在「账号」页维护')+'</div></div>'+
+        (cmpSrc==='group'?
+          '<div class="form-group"><label>设备分组名</label>'+
+          '<input class="form-control" data-key="cmp_group" value="'+esc(p.cmp_group||'')+'" '+
+          'placeholder="分组名（工具→设备分组）"></div>':'')+
+        // 选台账时**只隐藏、不删**这个输入框：_syncParams 是按 DOM 存在与否收集的，
+        // 删了就等于把用户手填的值悄悄抹掉（同类坑见本文件 927 行附近的注释）
+        '<div class="form-group" style="grid-column:span 2'+(fromLedger?';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>——多个号的场景把号都列上。'+
-        '<b>逗号不当分隔符</b>，因为要比对的文本本身常带逗号</div></div></div>';
+        '<b>逗号不当分隔符</b>，因为要比对的文本本身常带逗号'
+        +(fromLedger?'<br><b>候选值来自台账</b>：这台设备在台账里登记的抖音号会作为候选，'
+          +'手填的值<b>追加</b>在后面（台账取不到号时只用手填值，不会把任务打哑）。'
+          +'<br>⚠ 台账只提供<b>比对用的号</b>；<b>不要</b>把台账号填到「去重」的身份元素里'
+          +'（身份是元素原文、逐字比，格式不同会让去重静默失效）。':'')
+        +'</div></div></div>';
       // 「去重」条件：身份元素用 ident_type/ident_value（主选择器那行只剩类型下拉）
       var identRow=isDedup?_selRowHtml(p,
         '<div class="help"><b>身份元素</b>：填"账号"那个元素（点「抓取元素」选，如抖音号那个 TextView）。'
@@ -507,12 +542,13 @@ var _stepEditor={
         true, true, isDedup?{hideValue:true}:null)+identRow;
     }else if(step.type==='mark_done'){
       h+=_selRowHtml(p,
-        '<div class="help">把<b>身份元素</b>的值记进平台「去重账本」（所有设备共享一份）。'
+        '<div class="help">把身份值记进平台「去重账本」（所有设备共享一份）。'
         +'放在动作<b>成功之后</b>——动作失败就不会记账，下次重跑还会重试这台设备。'
-        +'<br><b>留空 = 用本设备当身份</b>（一号一机时这样就行）。'
-        +'身份读不到时<b>不记账</b>（记一个空身份会把别的设备挡住）。'
-        +'<br>有效期在上方任务级的<b>「去重有效期」</b>里设。'
-        +'<br>配套的「条件判断 → 去重」放在动作<b>之前</b>，两边填<b>同一个身份元素</b>。</div>');
+        +'<br>✅ <b>留空 = 自动跟随上面「去重」检查的身份</b>（推荐）：'
+        +'检查与记账必须用<b>同一个身份字符串</b>，key 才算得到一起；'
+        +'两处各配一遍的话，一边填了另一边忘了去重就会失效。'
+        +'<br>没有前置去重检查、又留空时，退回用<b>本设备</b>当身份（一号一机场景）。'
+        +'<br>有效期在上方任务级的<b>「去重有效期」</b>里设。</div>');
     }
     // 共享：触发概率（所有步骤通用，0~100）
     h+='<div class="form-row" style="margin-top:8px"><div class="form-group"><label>触发概率(%)</label><input type="number" class="form-control" data-key="probability" value="'+(p.probability!=null?p.probability:100)+'" min="0" max="100"><div class="help">0~100，&lt;100 表示按概率执行（如 30=隔几次才触发一次，适合"偶尔点赞"）</div></div></div>';
@@ -813,6 +849,19 @@ var _stepEditor={
       g.style.display=g.dataset.lmode===mode?'block':'none';
     });
   },
+  // 输入文字：取值来源切到"发布计划"时，把手填那两块藏起来（话题输入框反过来显示）
+  _inputSourceChanged:function(sel){
+    this._syncFromDom();          // 同 _cmpSourceChanged：不先同步，重渲染会吞掉刚改的值
+    var self=this;
+    setTimeout(function(){self._renderCanvas();},0);
+  },
+  // 条件判断：候选值来源切到台账时，把"比对的值"藏起来（按分组还要显示分组名输入框）
+  _cmpSourceChanged:function(sel){
+    // 同 _condTypeChanged：先把 DOM 的值同步回 _steps，否则重渲染会吞掉刚改的东西
+    this._syncFromDom();
+    var self=this;
+    setTimeout(function(){self._renderCanvas();},0);
+  },
   // 条件判断：选择器类型切到 OCR 时显示"命中后点击"开关
   _condTypeChanged:function(sel){
     // 条件类型一变，"值"控件也要跟着换（元素值输入框 / 屏幕亮熄下拉 / 包名输入），
@@ -922,23 +971,42 @@ var _stepEditor={
             warnings.push(name+' "'+label+'": 录制手势还没有轨迹，执行时会被跳过。');
           }
         }else if(s.type==='if_el'){
-          if(!s.params.selector_value){
+          // 「去重」「屏幕状态」这两类条件**不用文本比对**（面板里那块是隐藏的）。
+          // 所以：① 留着旧 cmp_op/cmp_value 不该报警告（用户看不到、也清不掉，
+          // 只会每次保存都被打扰）；② 也别报"会被忽略"——那是设计如此。
+          var cmpUsed=(s.params.selector_type!=='screen'&&s.params.selector_type!=='dedup');
+          if(s.params.selector_type!=='dedup'&&!s.params.selector_value){
             warnings.push(name+' "'+label+'": 条件判断的选择器为空，会直接走"未找到"分支。');
           }
-          if(s.params.cmp_op&&!String(s.params.cmp_value||'').trim()){
+          var cmpSrcV=(s.params.cmp_source||'');
+          var fromLedger=(cmpSrcV==='device'||cmpSrcV==='all'||cmpSrcV==='group');
+          // 候选值"从别处取"的那两档（台账 / 发布计划）：手填可以留空，别报"没填值"
+          var fromOther=(fromLedger||cmpSrcV==='release');
+          if(cmpUsed&&s.params.cmp_op&&!String(s.params.cmp_value||'').trim()&&!fromOther){
             warnings.push(name+' "'+label+'": 选了"文本比对('+s.params.cmp_op+')"但没填比对的值，'
               +'执行时永远不命中（相当于每次都走"未找到时"分支）。');
           }
-          if(s.params.cmp_op&&s.params.selector_type==='screen'){
-            warnings.push(name+' "'+label+'": 屏幕状态没有文本可比，文本比对的设置会被忽略。');
+          if(cmpUsed&&fromLedger&&s.params.cmp_op){
+            warnings.push(name+' "'+label+'": 候选值来自台账 —— 台账里没有这台设备'
+              +'（或设备池里的设备名与台账「设备号」对不上）时会取不到号，'
+              +'这一步将永远走"未找到"分支。请到「账号」页核对设备号。');
+          }
+          if(cmpUsed&&cmpSrcV==='release'&&s.params.cmp_op){
+            warnings.push(name+' "'+label+'": 候选值来自"本机当前发布计划" —— 本机没有待发的计划'
+              +'时取不到号（这一步会走"未找到"分支）。这是设计如此（宁可不发、也不发错号），'
+              +'但请确认前面有「推送发布视频」步骤、且这条计划确实排到了本机。');
           }
           if(s.params.selector_type==='dedup'){
             hasDedupCheck=true;
-            var iv=(s.params.ident_value||'').trim();
-            if(iv)dedupIdents.push({where:name,type:s.params.ident_type||'text',value:iv});
+            // 空值也收进来：一边填了、另一边没填 = 两处身份不一致（去重会对不上），
+            // 必须报出来 —— 只收非空的话，这种最常见的不一致反而检测不到
+            dedupIdents.push({where:name,type:s.params.ident_type||'text',
+                              value:(s.params.ident_value||'').trim()});
           }
         }else if(s.type==='mark_done'){
           hasMarkDone=true;
+          // 留空 = 自动跟随去重检查的身份（执行器就是这么做的），所以**空值不参与比对**；
+          // 只有"填了、且和检查侧不一样"才是真问题
           var mv=(s.params.selector_value||'').trim();
           if(mv)dedupIdents.push({where:name,type:s.params.selector_type||'text',value:mv});
         }
@@ -959,11 +1027,14 @@ var _stepEditor={
     }
     if(dedupIdents.length>1){
       var first=dedupIdents[0];
+      var showId=function(x){ return x.value?('「'+x.value+'」'):'（留空 → 用设备当身份）'; };
       dedupIdents.slice(1).forEach(function(d){
         if(d.value!==first.value||d.type!==first.type){
-          warnings.push('去重的身份元素不一致：'+first.where+'用的是「'+first.value
-            +'」，而'+d.where+'用的是「'+d.value+'」——两边不一致会算出不同的 key，'
-            +'去重会静默失效。请改成同一个元素。');
+          warnings.push('去重两处的身份不一致：'+first.where+' 是 '+showId(first)
+            +'，而 '+d.where+' 是 '+showId(d)
+            +' —— 身份不一致会算出两个不同的 key，去重会失效'
+            +'（检查查不到记账 / 或者反过来，结果就是重复或漏做）。'
+            +'建议把「记为已做」的身份元素留空（自动跟随检查），或两处填成同一个元素。');
         }
       });
     }
@@ -1438,10 +1509,16 @@ var _stepEditor={
     }
     // 填入推荐选择器值，并切换选择器类型
     this._elTargetInput.value=el.suggested.value;
-    var sel=this._elTargetInput.closest('.sc-body').querySelector('[data-key="selector_type"]');
+    // 选择器类型下拉：通用编辑器里在同一个 .sc-body 内；别的编辑器（「发布计划」页的
+    // 步骤就地编辑）结构不同，取不到就跳过、交给下面的 _onFill 自己处理
+    var box=this._elTargetInput.closest('.sc-body');
+    var sel=box?box.querySelector('[data-key="selector_type"]'):null;
     if(sel)sel.value=el.suggested.type;
-    // 程序赋值不会触发 input 事件，手动同步回 _steps 防丢失
-    this._syncFromDom();
+    // 程序赋值不会触发 input 事件，手动同步防丢失。
+    // 默认同步回通用编辑器的 _steps；**别的编辑器用 _onFill 接管**
+    // （见 static/admin/release.js 的就地编辑），否则会同步到不相干的模型上
+    if(typeof this._onFill==='function')this._onFill(el, this._elTargetInput);
+    else this._syncFromDom();
     // 只关闭抓取元素弹窗，不影响任务编辑窗口
     closeElPicker();
     showToast('已填入: '+el.suggested.type+'='+el.suggested.value,'success');

static/admin/ledger.js

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

static/admin/tools.js

@@ -517,9 +517,13 @@ async function loadDevPool(){
   const tb=document.getElementById('tb-devpool');
   const status=document.getElementById('devpool-status');
   if(!tb)return;
-  tb.innerHTML='<tr><td colspan="8" class="empty">加载中...</td></tr>';
+  tb.innerHTML='<tr><td colspan="9" class="empty">加载中...</td></tr>';
   const r=await apiGet('/api/devices/pool');
-  if(!r||!r.ok){tb.innerHTML='<tr><td colspan="8" class="empty">加载失败</td></tr>';return;}
+  if(!r||!r.ok){tb.innerHTML='<tr><td colspan="9" 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')
@@ -552,6 +556,10 @@ 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> '+
@@ -561,7 +569,7 @@ async function loadDevPool(){
         '<button class="btn btn-xs" onclick="togglePoolDev(\''+esc(d.serial)+'\','+(!d.enabled)+')">'+(d.enabled?'停用':'启用')+'</button> '+
         '<button class="btn btn-xs btn-danger" onclick="removePoolDev(\''+esc(d.serial)+'\')">删除</button>'+
       '</td></tr>';
-  }).join('')||'<tr><td colspan="8" class="empty">设备池为空，添加第一台设备开始</td></tr>';
+  }).join('')||'<tr><td colspan="9" class="empty">设备池为空，添加第一台设备开始</td></tr>';
 }
 
 async function addPoolDev(){

tasks/generic/publish_flow.py

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

tasks/generic/task.py

@@ -41,7 +41,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
+from core import notifier, step_log, humanize, patrol, gesture, dedup, ledger
 
 _log = get_logger("task.generic")
 
@@ -102,7 +102,8 @@ STEP_TYPES = [
     {"type": "wait_el", "label": "等待元素", "icon": "⏳",
      "params": {"selector_type": "xpath", "selector_value": "", "timeout": 10}},
     {"type": "input_text", "label": "输入文字", "icon": "⌨",
-     "params": {"mode": "random", "texts": "你好\n有趣\n支持", "fixed_text": "", "clear_first": True}},
+     "params": {"mode": "random", "texts": "你好\n有趣\n支持", "fixed_text": "",
+                "clear_first": True, "text_source": "manual", "release_topics": ""}},
     {"type": "clipboard", "label": "剪贴板注入", "icon": "📋",
      "params": {"text": "", "paste": True}},
     {"type": "wait", "label": "等待", "icon": "⏱",
@@ -113,11 +114,19 @@ STEP_TYPES = [
      "params": {"children": []}},
     {"type": "if_el", "label": "条件判断", "icon": "❓",
      "params": {"selector_type": "xpath", "selector_value": "", "timeout": 3,
-                "cmp_op": "", "cmp_value": "",
+                "cmp_op": "", "cmp_value": "", "cmp_source": "", "cmp_group": "",
                 "ident_type": "text", "ident_value": "",
                 "then": [], "else": []}},
     {"type": "mark_done", "label": "记为已做", "icon": "✅",
      "params": {"selector_type": "text", "selector_value": ""}},
+    {"type": "push_release", "label": "推送发布视频", "icon": "📤",
+     "params": {"date_source": "today", "fixed_date": "",
+                "account": "device", "account_phone": "",
+                "album_dir": "/sdcard/DCIM/Camera", "to_clipboard": True,
+                "retry_failed": True, "max_same_run": 1}},
+    {"type": "mark_release", "label": "标记发布结果", "icon": "🏁",
+     "params": {"result": "published", "why": "", "capture_link": True,
+                "delete_phone": True, "album_dir": "/sdcard/DCIM/Camera"}},
     {"type": "notify", "label": "发通知", "icon": "🔔",
      "params": {"title": "", "message": "", "level": "info"}},
     {"type": "stop_self", "label": "停止本设备", "icon": "⛔",
@@ -231,6 +240,11 @@ class GenericStepsWorker(BaseWorker):
         self._path = []
         self._step_rows = 0        # 本次运行已记录的明细条数（封顶见 _record_step）
         self._step_capped = False
+        # 「去重」条件最近一次解析出的身份：`mark_done` 留空时复用它，
+        # 保证"检查"与"记账"用的是**同一个身份字符串**（否则 key 对不上、去重失效）
+        self._last_ident = ""
+        self._last_release = None      # 「推送发布视频」推的那条计划，供「标记发布结果」用
+        self._dedup_seen = False     # 本轮是否跑过「去重」检查（区分"没配"与"配了但没读到"）
         # 公共巡检（任务级配置，独立于步骤画布；见 core/patrol.py）：
         # _wid 内部标识，用来记"下次到点 / 上次命中"两个节奏
         self._watchers = []
@@ -679,6 +693,12 @@ class GenericStepsWorker(BaseWorker):
         timeout = float(params.get("timeout", 3))
         cmp_op = str(params.get("cmp_op") or "").strip()
         cmp_val = str(params.get("cmp_value") or "")
+        # 候选值可以来自「账号台账」（cmp_source）——这里只把 cmp_val 这个**字符串**
+        # 换掉来路，下面 762-780 的比对、候选计数、日志文案全自动跟着对
+        # （_cmp_hit 保持纯函数，不掺 DB）
+        src_note = ""
+        if cmp_op:
+            cmp_val, src_note = self._resolve_cmp_value(params, cmp_val)
         # 去重条件不用 selector_value（身份元素在 ident_value 里），所以别按"缺选择器"拦
         if not sel_val and sel_type != "dedup":
             _log.warning(f"[{self.serial}] if_el 缺少选择器，跳过")
@@ -693,11 +713,13 @@ class GenericStepsWorker(BaseWorker):
             # 去重条件：**这个身份在这个任务里做过了吗**（跨设备共享一份账本，
             # 见 core/dedup.py）。命中=做过 → 走 then 分支（通常放"跳过/停止/发通知"）。
             kind, hours = self._dedup_policy()
+            self._dedup_seen = True      # 供「记为已做」区分"没配检查"与"配了但没读到"
             ident = self._dedup_identity(d, params, "ident_type", "ident_value")
             if ident is None:
                 found = False   # 身份判定不了 → 当"没做过"，照常往下做（宁可重复不误拦）
                 detail = "去重：身份读不到，按未做过处理"
             else:
+                self._last_ident = ident      # 供后面「记为已做」复用（见 _exec_mark_done）
                 found = dedup.check(self.ctx.get("job_id", ""), ident, kind, hours)
                 detail = f"去重：身份『{ident}』{'做过' if found else '没做过'}（有效期 {kind}）"
         elif sel_type == "screen":
@@ -772,9 +794,16 @@ class GenericStepsWorker(BaseWorker):
                 detail = (f"采集到 '{got}' {cmp_op} {n_val} 个候选值 → "
                           f"{'符合' if hit else '不符合'}{extra}")
                 found = hit
-        elif cmp_op and sel_type in ("screen", "dedup"):
+        elif cmp_op and str(cmp_val or "").strip() and sel_type in ("screen", "dedup"):
+            # 只在**真的配了比对的值**时才提醒：从元素类切到「去重/屏幕状态」时
+            # 界面上那块是隐藏的，旧值会留在 params 里，那种残留每轮都刷警告没意义
             _log.warning(f"[{self.serial}] {sel_type} 没有文本可比，已忽略文本比对设置")
 
+        # 候选值来源（台账/手填）也要进日志与步骤明细：取 0 个号会让这一步
+        # **永远走 else 分支**，而任务照样"跑完了"——只有这里能看出原因
+        if src_note:
+            detail = f"{detail}；{src_note}" if detail else src_note
+
         if dynamic:
             _log.info(f"[{self.serial}] 条件判断 {detail} → {'命中' if found else '未命中'}")
         else:
@@ -789,6 +818,233 @@ class GenericStepsWorker(BaseWorker):
         self._exec_steps(d, branch, depth + 1)
         return found
 
+    def _resolve_cmp_value(self, params, manual_raw):
+        """「条件判断」的候选值 = 手填值 + 台账取号（合并，OR 语义）。
+
+        返回 (候选值文本, 给日志/步骤明细的来源说明)。
+
+        · **合并**而不是二选一：台账取空时手填值仍然生效（台账没维护好不会把任务
+          直接打哑）；"台账里的号 + 临时补一个"也是自然需求 —— split_cmp_values
+          与 `_cmp_hit` 本来就是多值 OR 语义。
+        · 取 0 个号时**必须留痕**：候选为空 ⇒ 这一步永远走 else 分支，而任务本身
+          "跑完了、显示成功"，不写日志就只能靠人猜。
+        · ⚠ 这里产出的只是**比对用的文本**，绝不参与去重 identity：
+          身份是元素原文逐字算 key，台账里是纯号，格式不同会让去重静默失效
+          （见 core/ledger.py 顶部的警告）。
+        """
+        source = str(params.get("cmp_source") or "").strip()
+        manual = split_cmp_values(manual_raw)
+        if source == "release":
+            # 「发布计划」：本机**下一条将要推送**的那条计划（推送前校验账号就靠它）。
+            # 候选值给两个：抖音号（纯号）+ 账号名称 —— 元素原文可能是
+            # `抖音号：35377983067`，也可能只显示昵称，两个都可命中（OR 语义）。
+            ids, note = self._release_candidates()
+        elif source in ("device", "all", "group"):
+            ids, note = ledger.douyin_ids(
+                source, serial=self.serial,
+                device_name=(self.ctx or {}).get("device_name", ""),
+                group=str(params.get("cmp_group") or "").strip())
+        else:
+            return manual_raw, ""          # 手填（默认）：行为与以前完全一致
+        merged = list(ids) + [v for v in manual if v not in ids]
+        if not ids:
+            _log.warning(
+                f"[{self.serial}] 条件判断取号为空（来源 {source}）：{note}；手填候选 "
+                f"{len(manual)} 个 → "
+                + ("仅用手填值" if manual else "候选为空，这一步将永远不命中（走未找到分支）"))
+        where = "发布计划" if source == "release" else f"台账({source})"
+        src_txt = (f"候选来自{where} {len(ids)} 个号" if ids
+                   else f"{where}取号为空：{note}")
+        if manual:
+            src_txt += f"，另加手填 {len(manual)} 个"
+        return "\n".join(merged), src_txt
+
+    def _release_targets(self, params):
+        """推送/标记步骤共用的"取本机账号手机号"逻辑。返回 (phones, who)。"""
+        from core import ledger
+        phone = (params.get("account_phone") or "").strip()
+        if (params.get("account") or "device") == "phone" and phone:
+            return [phone], f"指定手机号 {phone}"
+        _, rows, note = ledger.resolve_device(
+            serial=self.serial, device_name=(self.ctx or {}).get("device_name", ""))
+        return [r.get("phone") for r in rows if r.get("phone")], f"本机账号（{note}）"
+
+    def _release_candidates(self):
+        """条件判断的「候选值来源 = 发布计划」：本机要发的那条计划的 **抖音号 + 账号名称**。
+
+        优先用本次运行里「推送发布视频」已经拿到的那条（`_last_release`）；
+        还没有就**看**下一条（peek，不占位）—— 这正是"推送前先校验账号对不对"的用法：
+        命中（当前登录的就是要发的那个号）→ 走 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({})
+            plan = vp.peek_for_device(phones, vp._today()) if phones else None
+            src = "本机下一条待发"
+        if not plan:
+            return [], "本机没有待发的发布计划"
+        cands = [c for c in (plan.get("douyin_id"), plan.get("nickname")) if c]
+        note = (f"{src}计划的抖音号 {plan.get('douyin_id')}"
+                f"（{plan.get('nickname') or plan.get('phone')} "
+                f"{plan.get('release_date')} #{plan.get('seq')}）")
+        return cands, note
+
+    def _exec_push_release(self, d, params, depth=0):
+        """推送发布视频：把本机某天待发的计划**推到手机相册**（**不发布**）。
+
+        **平台只负责到这里**：推文件 + 触发相册刷新 + 把标题写进剪贴板；
+        抖音里怎么发（打开→点+→相册→选视频→下一步→粘贴标题→发布）由你在这条步骤
+        **后面自己画步骤**，最后放一个「标记发布结果」回写状态。
+
+        参数：`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 —— 一次运行推几条；**多条时「标记」只认最后一条**，要发多条就重复"推送+标记"两步)
+
+        返回 None=本机没有待推的（跳过）；True/False=至少推成一条/全失败。
+        """
+        from tasks.generic import publish_flow as flow
+        from core import video_plan as vp
+
+        date = ((params.get("fixed_date") or "").strip()
+                if params.get("date_source") == "fixed" else vp._today()) or vp._today()
+        phones, who = self._release_targets(params)
+        if not phones:
+            _log.warning(f"[{self.serial}] 推送发布视频：本机没有台账账号 → 跳过")
+            self.set_action("本机没有台账账号 → 跳过")
+            return None
+        plans = vp.take_for_device(phones, date,
+                                   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}
+        okN = badN = 0
+        for plan in plans:
+            if self.stopped():
+                break
+            self._last_release = plan          # 供后面的「标记发布结果」用
+            self.set_action(f"推送中：{plan.get('nickname') or plan['phone']} "
+                            f"{plan['release_date']} #{plan['seq']}")
+            ok, msg = flow.push_one(self.serial, plan, opts,
+                                    log=lambda s: _log.info(f"[{self.serial}] {s}"))
+            if ok:
+                okN += 1
+                # 相册校验结果**单独说一句**：文件上去了 ≠ 相册里点得到它，
+                # 后面那步"点相册里第一个"靠的就是索引（不写这句，出了问题只能猜）
+                row = vp.get_plan(plan["id"]) or {}
+                if row.get("push_verify") == "no_index":
+                    _log.warning(f"[{self.serial}] ⚠ 素材推上去了但**没进相册索引**"
+                                 f"（抖音选视频时可能看不到它）")
+            else:
+                badN += 1
+                self._notify_publish(plan, ok=False, msg=msg)
+        if okN and self._last_release:
+            lr = self._last_release
+            title = (lr.get("title") or "")[:20]
+            self.set_action(f"已推送到手机：{lr.get('nickname') or lr.get('phone')} "
+                            f"{lr['release_date']} #{lr['seq']}"
+                            + (f"（标题『{title}』已进剪贴板）" if title else "")
+                            + "；发完记得放「标记发布结果」")
+            _log.info(f"[{self.serial}] 已推到手机，标题『{title}』已进剪贴板 —— "
+                      f"后面用「粘贴」把它填进抖音，发完记得放一个「标记发布结果」")
+        else:
+            self.set_action(f"推送发布视频：成功 {okN} 条"
+                            + (f"，失败 {badN} 条" if badN else ""))
+        return okN > 0 if (okN or badN) else None
+
+    def _exec_mark_release(self, d, params, depth=0):
+        """标记发布结果：把"发出去了没有"回写到计划行（**你自己发布流程的最后一步**）。
+
+        参数：`result` = `published`(发出去了) / `failed`(没发出去，可重试) / `unknown`(不确定)
+        · `why` 失败原因（可选）· `capture_link`(True) 成功时顺带抓作品分享链接
+        · `delete_phone`(True) 成功/失败后删掉手机上的素材
+
+        放在你画布的**成功分支**里填 `published`、失败分支里填 `failed`；
+        拿不准有没有发出去就填 `unknown`（平台不会自动重发它）。
+        返回 True=标记成功 / False=发布失败 / None=找不到对应的计划（跳过）。
+        """
+        from tasks.generic import publish_flow as flow
+        from core import video_plan as vp
+        import uiautomator2 as u2
+
+        plan = getattr(self, "_last_release", None)
+        if not plan:
+            phones, _who = self._release_targets(params)
+            plan = vp.last_pushed_for_device(phones) if phones else None
+        if not plan:
+            _log.warning(f"[{self.serial}] 标记发布结果：找不到对应的计划行 → 跳过"
+                         f"（前面要先有一个「推送发布视频」步骤）")
+            self.set_action("没有可标记的计划")
+            return None
+
+        result = (params.get("result") or "published").strip().lower()
+        if result not in ("published", "failed", "unknown"):
+            _log.warning(f"[{self.serial}] 标记发布结果：result={result!r} 认不出 → 按 unknown 处理")
+            result = "unknown"
+        why = (params.get("why") or "").strip()
+
+        # 手机上的素材：先删再回写状态 —— 删失败不影响发布结论。
+        # 远程路径是**确定的**（{相册目录}/{计划id}.mp4），所以这里能直接算出来，
+        # 不用把"上次推到哪"存进库（存了还得担心不一致）
+        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")
+            except Exception as e:
+                _log.warning(f"[{self.serial}] 删手机素材失败（不影响标记）: {e}")
+
+        if result == "published":
+            url = ""
+            if params.get("capture_link", True) is not False:
+                try:
+                    dd = d or u2.connect(self.serial)
+                    url, lmsg = flow.capture_share_link(dd, self.serial)
+                    _log.info(f"[{self.serial}] 抓分享链接：{url or ('失败：' + lmsg)}")
+                except Exception as e:
+                    _log.warning(f"[{self.serial}] 抓分享链接异常: {e}")
+            vp.mark_done(plan["id"], share_url=url, msg=why)
+            self._notify_publish(dict(plan, share_url=url), ok=True, msg=why or "已标记发布成功")
+            self.set_action(f"已标记发布成功（{'链接 ' + url if url else '没抓到链接'}）")
+            return True
+        if result == "failed":
+            # **确认没发出去** → 直接落 `failed`（可重试），不能走 mark_failed('post')
+            # —— 那会落到"结果未知"、反而不敢重试。这里人是亲眼确认过的。
+            vp.set_status(plan["id"], vp.ST_FAILED, note=why or "人工标记：没发出去")
+            self._notify_publish(plan, ok=False, msg=why or "人工标记：没发出去")
+            self.set_action("已标记失败（下次任务会再推一次）")
+            return False
+        vp.mark_failed(plan["id"], "verify", why or "人工标记：结果不确定")
+        self._notify_publish(plan, ok=False, msg=why or "人工标记：结果不确定")
+        self.set_action("已标记「结果未知」（不会自动重发，需人工确认）")
+        return False
+
+    def _notify_publish(self, plan, ok, msg):
+        """发布结果推通知（notify 零 DB：字段都在计划行里，不查库）。"""
+        try:
+            notifier.notify("task.video.published" if ok else "task.video.failed",
+                            serial=self.serial,
+                            device_name=(self.ctx or {}).get("device_name", ""),
+                            model=(self.ctx or {}).get("model", ""),
+                            phone=plan.get("phone", ""),
+                            nickname=plan.get("nickname", ""),
+                            release_date=plan.get("release_date", ""),
+                            seq=plan.get("seq", 0),
+                            title=(plan.get("title") or "")[:60],
+                            share_url=plan.get("share_url", ""),
+                            msg=msg)
+        except Exception as e:
+            _log.warning(f"发布通知发送失败（不影响发布）：{e}")
+
     def _dedup_policy(self):
         """任务级去重有效期（`dedup_reset` / `dedup_hours`）→ (kind, hours)。
 
@@ -827,10 +1083,31 @@ class GenericStepsWorker(BaseWorker):
         **放在动作成功之后**：动作失败就不记账，下次重跑会重试该设备——
         拆成"检查在前、记账在后"两步，天然就是"成功才记账、失败不丢"。
         身份读不到时**不记账**（记一个空身份会把别人挡住）。
+
+        **身份留空 = 复用前面「去重」条件刚解析出的那个身份**（推荐这样配）：
+        检查与记账必须用**同一个身份字符串**，key 才算得到一起；让用户在两处各配一遍
+        元素，一旦不一致（填了一个、另一个忘了）去重就静默失效——这是最容易踩的坑，
+        所以默认行为改成"自动跟随上面的检查"。
         """
         kind, hours = self._dedup_policy()
-        ident = self._dedup_identity(d, params, "selector_type", "selector_value")
-        if ident is None:
+        if (params.get("selector_value") or "").strip():
+            ident = self._dedup_identity(d, params, "selector_type", "selector_value")
+        elif self._last_ident:
+            ident = self._last_ident
+            _log.info(f"[{self.serial}] 记为已做：复用上面去重检查的身份『{ident}』")
+        elif self._dedup_seen:
+            # 上面**跑了**去重检查、但身份读不到（元素没出来/页面没到）。
+            # 这时**绝不能**退回设备身份记一笔：那会在"什么都没做成"的情况下
+            # 把设备标成已做。不记 → 下次重跑会重试。
+            ident = None
+            _log.warning(f"[{self.serial}] 记为已做：上面去重检查没读到身份（页面没到？）"
+                         f"→ 本次不记账，下次重跑会重试")
+        else:
+            # 任务里根本没有前置去重检查、又没填身份元素 → 退回设备身份（一号一机场景）
+            ident = self.serial
+            _log.info(f"[{self.serial}] 记为已做：没填身份元素也没有前置去重检查 → "
+                      f"按设备身份记账（{ident}）")
+        if not ident:
             self.set_action("记为已做：身份读不到 → 本次不记（下次重跑会重试）")
             return True
         first = dedup.mark(self.ctx.get("job_id", ""), ident, kind, hours,
@@ -1094,17 +1371,46 @@ class GenericStepsWorker(BaseWorker):
         需先用"点击元素"步骤定位到输入框，本步骤只负责输入。
         mode=random: 从 texts（换行分隔）随机选一条
         mode=fixed:  输入 fixed_text
+
+        **`text_source`（可选）：文字从哪来**
+          · `manual`（默认）= 用上面的 mode（行为与以前完全一致）
+          · `release_title` = **本机当前那条发布计划的标题**（"推送发布视频"推的那条；
+            本机没有就取最近一条已推送的）· 配 `release_topics` 还能自动加话题
+        选发布计划来源时**会回读校验**（读输入框的 text）：不校验的后果是
+        "抖音不吃 send_keys → 发出一篇空文案，而每一步都显示成功"；
+        校验不过就自动改走剪贴板通道粘贴（设备端 Agent）再验一次。
         """
-        mode = params.get("mode", "random")
-        if mode == "fixed":
-            text = params.get("fixed_text", "")
-        else:
-            raw = params.get("texts", "")
-            candidates = [t.strip() for t in raw.splitlines() if t.strip()]
-            if not candidates:
-                _log.warning("input_text 无候选文字")
-                return
-            text = random.choice(candidates)
+        src = str(params.get("text_source") or "manual").strip()
+        text = ""
+        if src in ("release_title", "release_title_topics"):
+            from core import video_plan as vp
+            plan = getattr(self, "_last_release", None)
+            if not plan:
+                phones, _who = self._release_targets(params)
+                plan = vp.last_pushed_for_device(phones) if phones else None
+            if plan:
+                text, _err = vp.build_caption(
+                    plan, params.get("release_topics") or ""
+                    if src == "release_title_topics" else "")
+                self._last_release = self._last_release or plan
+                _log.info(f"[{self.serial}] 输入文字取计划标题："
+                          f"{plan.get('nickname') or plan.get('phone')} "
+                          f"{plan.get('release_date')} #{plan.get('seq')}")
+            if not text:
+                _log.warning(f"[{self.serial}] 输入文字：本机没有可用的发布计划标题 → 跳过"
+                             f"（前面要先有「推送发布视频」步骤）")
+                return None
+        if not text:
+            mode = params.get("mode", "random")
+            if mode == "fixed":
+                text = params.get("fixed_text", "")
+            else:
+                raw = params.get("texts", "")
+                candidates = [t.strip() for t in raw.splitlines() if t.strip()]
+                if not candidates:
+                    _log.warning("input_text 无候选文字")
+                    return
+                text = random.choice(candidates)
         if not text:
             return
         clear_first = params.get("clear_first", True)
@@ -1125,6 +1431,48 @@ class GenericStepsWorker(BaseWorker):
                     _log.warning(f"[{self.serial}] input_text 未找到输入框: {e}")
             except Exception as e2:
                 _log.warning(f"[{self.serial}] input_text 失败: {e2}")
+        # 取计划标题时**必须回读校验**：抖音的 EditText 有时不吃 send_keys，
+        # 不校验就可能发出一篇空文案而每一步都显示成功
+        if src in ("release_title", "release_title_topics"):
+            return self._verify_input(d, text, clear_first)
+        return None
+
+    def _verify_input(self, d, text, clear_first):
+        """回读输入框，确认文字真的进去了；不行就改走剪贴板通道再验一次。"""
+        def _read():
+            try:
+                el = d(className="android.widget.EditText")
+                if el.exists:
+                    return el.get_text(timeout=2) or ""
+            except Exception:
+                pass
+            return ""
+
+        for attempt in (1, 2):
+            got = _read()
+            if got and text[:12] in got:
+                return True
+            _log.warning(f"[{self.serial}] 文案回读不一致（第 {attempt} 次）："
+                         f"期望『{text[:20]}…』读到『{got[:20]}』")
+            if attempt == 1:
+                # 第 2 次改走剪贴板通道（设备端 Agent 写剪贴板 + 粘贴），中文不会变形
+                try:
+                    from core.clipboard_helper import inject_clipboard
+                    okc, msgc = inject_clipboard(self.serial, text, d=d)
+                    if okc:
+                        d.jsonrpc.pasteClipboard()
+                        time.sleep(1)
+                    else:
+                        _log.warning(f"[{self.serial}] 剪贴板兜底注入失败: {msgc}")
+                except Exception as e:
+                    _log.warning(f"[{self.serial}] 剪贴板兜底异常: {e}")
+                time.sleep(1)
+        got = _read()
+        if got and text[:12] in got:
+            return True
+        _log.warning(f"[{self.serial}] ⚠ 文案没填进去（读回『{got[:30]}』）——"
+                     f"接着发布就会发出空文案，这一步判失败")
+        return False
 
 
 @register_task

templates/admin/monitor.html

@@ -511,6 +511,7 @@ 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="users" onclick="showTab('users')" data-perm="admin">用户</button>
@@ -581,6 +582,133 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
   <div id="jobs-grid" class="jobs-grid"></div>
 </div>
 
+<!-- ========== Tab: 账号（台账） ========== -->
+<div id="tab-account" class="tab-panel">
+  <div class="page-title">账号</div>
+  <div class="page-sub">每台设备上登录的抖音账号（谁在哪台机器上、卡在不在机内、能不能发视频）</div>
+
+  <div class="sub-tabs">
+    <button class="sub-tab active" data-sub="ledger" onclick="showSubTab('account','ledger')">账号台账</button>
+    <button class="sub-tab" data-sub="plan" onclick="showSubTab('account','plan')">发布计划</button>
+  </div>
+
+  <!-- 子分栏 1：账号台账 -->
+  <div class="sub-panel active" id="account-sub-ledger">
+  <div class="toolbar">
+    <button class="btn btn-primary" onclick="openLedgerModal('')" data-perm="devices">新增账号</button>
+    <button class="btn" onclick="openLedgerImport()" data-perm="devices">粘贴导入</button>
+    <button class="btn" onclick="loadLedger()">刷新</button>
+    <select class="form-control" id="ledger-device" style="width:140px" onchange="ledgerDeviceChanged()">
+      <option value="">全部设备</option>
+    </select>
+    <input class="form-control list-search" id="search-ledger" placeholder="搜索设备号/账号名/抖音号/手机号...">
+    <span class="text-muted" id="ledger-stats"></span>
+  </div>
+
+  <table class="table">
+    <thead><tr>
+      <th data-sort="device_name" onclick="_lpSort('ledger','device_name')">设备号</th>
+      <th data-sort="nickname" onclick="_lpSort('ledger','nickname')">账号名称</th>
+      <th data-sort="douyin_id" onclick="_lpSort('ledger','douyin_id')">抖音号</th>
+      <th>手机号</th>
+      <th>注册时间</th>
+      <th>卡在机内</th>
+      <th>可发视频</th>
+      <th>简介</th>
+      <th>备注</th>
+      <th>操作</th>
+    </tr></thead>
+    <tbody id="tb-ledger"></tbody>
+  </table>
+  <div class="list-pager" id="pager-ledger"></div>
+
+  <div class="help">
+    这张台账有三个用处：① 人在机器旁时对照（手机端 Agent 的「身份大字页」也会显示本机账号）；
+    ② 任务的「条件判断」可以直接从这里取号（编辑器里把<b>候选值来源</b>选成「本机台账」，
+    就不用把几十个号手写进去）；③ 设备池里能看到每台登记了几个号。<br>
+    ⚠ 台账里的抖音号是<b>纯号</b>（如 <code>35377983067</code>），只当"比对用的候选值"。
+    <b>不要</b>拿它去填「去重」的身份元素 —— 身份比对的是元素原文
+    （<code>抖音号：35377983067</code>），格式不同会让去重<b>静默失效</b>。
+  </div>
+  </div><!-- /account-sub-ledger -->
+
+  <!-- 子分栏 2：视频发布计划 -->
+  <div class="sub-panel" id="account-sub-plan">
+    <div class="toolbar" style="flex-wrap:wrap">
+      <button class="btn btn-primary" onclick="document.getElementById('rp-video-input').click()"
+              data-perm="devices">上传视频</button>
+      <button class="btn" onclick="document.getElementById('rp-title-input').click()"
+              data-perm="devices">上传标题</button>
+      <button class="btn btn-primary" onclick="rpPushAll()" data-perm="devices"
+              title="把今天所有「待发布/失败」的计划按设备推到手机上（每台设备串行推）">一键推送（今天）</button>
+      <button class="btn" onclick="rpExportLinks()">导出链接 CSV</button>
+      <button class="btn" onclick="loadReleasePlan()">刷新</button>
+      <select class="form-control" id="rp-range" style="width:130px" onchange="rpRangeChanged()">
+        <option value="today">今天</option>
+        <option value="week">未来 7 天</option>
+        <option value="all">全部</option>
+      </select>
+      <select class="form-control" id="rp-status" style="width:150px" onchange="rpRangeChanged()">
+        <option value="">全部状态</option>
+        <option value="pending">待标题</option>
+        <option value="ready">待发布</option>
+        <option value="done">已发布</option>
+        <option value="failed,unknown">失败/未知</option>
+        <option value="skipped">已跳过</option>
+      </select>
+      <input class="form-control list-search" id="search-release" placeholder="搜索账号/抖音号/标题/文件名...">
+      <span class="text-muted" id="rp-stats"></span>
+    </div>
+
+    <!-- 发布任务：到点自动"推送 + 发视频"。素材（上面）与执行（这里）在同一页 -->
+    <div style="border:1px solid var(--border);border-radius:6px;padding:8px 10px;margin-bottom:10px">
+      <div style="display:flex;justify-content:space-between;align-items:center;gap:8px;flex-wrap:wrap">
+        <div><b>发布任务</b>
+          <span class="text-muted" style="font-size:12px">
+            到点自动跑：推送素材 → 你的抖音步骤 → 标记结果（抖音那几步的选择器要你自己抓一次）
+          </span></div>
+        <div style="white-space:nowrap">
+          <button class="btn btn-xs btn-primary" onclick="rpNewTask()" data-perm="tasks">一键新建发布任务</button>
+          <button class="btn btn-xs" onclick="loadReleaseTasks()">刷新</button>
+        </div>
+      </div>
+      <div id="rp-tasks" style="margin-top:6px"></div>
+    </div>
+
+    <div id="rp-timeline"></div>
+    <div class="list-pager" id="pager-release"></div>
+
+    <details style="margin-top:12px">
+      <summary style="cursor:pointer;color:var(--text-light)">明细表（与时间线同一份数据）</summary>
+      <table class="table table-sm" style="margin-top:8px">
+        <thead><tr>
+          <th>发布日期</th><th>设备号</th><th>账号</th><th>编号</th><th>视频文件</th>
+          <th>标题</th><th>状态</th><th>分享链接</th><th>操作</th>
+        </tr></thead>
+        <tbody id="tb-release"></tbody>
+      </table>
+    </details>
+
+    <div class="help">
+      视频文件名规则 <code>手机号_日期_编号</code>（编号可省略，日期如 <code>20260912</code> 就是发布日期）；
+      标题 txt 每行 <code>标题内容_手机号_日期_编号</code> 或 <code>手机号_日期_编号_标题</code>（<b>两种写法都认</b>，编号都可省略，标题里可以有下划线、可以有 <code>#话题</code>；<code>#</code> 开头的行<b>只要认得出手机号/日期就当标题</b>，认不出才当注释忽略）。
+      <b>手机号必须在「账号台账」里</b>，否则拒收。<br>
+      上传后自动按 (手机号, 日期, 编号) 配对：有编号按编号精确对，没编号按顺序配 ——
+      <b>没传标题的视频不会被推送</b>（先在计划页改标题或补传标题）。<br>
+      <b>平台只负责把视频推到手机</b>（推到 <code>/sdcard/DCIM/Camera/</code>、把文件时间改成"现在"好排在相册最前、触发相册刷新并<b>按路径</b>校验进了索引、
+      把标题写进手机剪贴板）；**抖音里怎么发由你在任务里自己写步骤** ——
+      步骤顺序是：<b>「推送发布视频」→ 你自己的发布步骤（打开抖音→点+→相册→选视频→下一步→粘贴标题→发布）→ 最后放一个「标记发布结果」</b>。<br>
+      计划页的「推送到手机」是同一件事的人工入口（推完你在手机上发，发完点「标记已发布」）。<br>
+      ⚠ 发布结果以<b>每行的状态</b>为准：<b>失败(可重试)</b>说明推送都没成功、可以再推；
+      <b>结果未知(需确认)</b>说明推送之后那一段出了岔子、<b>可能已经发出去了</b>，
+      要先到抖音里看一眼，再用「已发出 / 未发出」裁决（平台不会自动重发）。
+    </div>
+
+    <input type="file" id="rp-video-input" multiple accept="video/*" 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>
+
 <!-- ========== Tab 2: 任务 ========== -->
 <div id="tab-tasks" class="tab-panel">
   <div class="page-title">任务</div>
@@ -1284,6 +1412,7 @@ 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>
@@ -1481,5 +1610,7 @@ 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/__init__.py

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

web/device_agent_api.py

@@ -17,7 +17,9 @@
 
 管理端接口在文件后半段（`/api/agent-store/*`，走正常登录 + 权限）。
 """
+import base64
 import hmac
+import json
 import os
 import secrets
 import time
@@ -25,7 +27,7 @@ import time
 from flask import Blueprint, jsonify, request, send_file
 
 from config import APK_DIR
-from core import device_pool
+from core import device_pool, ledger
 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
@@ -317,6 +319,32 @@ def api_agent_show_info():
                 "--es", "server", server]
         if ip:
             args += ["--es", "ip", ip]
+        # 本机账号台账（可选块）：身份页顺带显示"这台登的是哪几个号"。
+        # **中文必须 base64**（§5.1：adb shell 直传中文/特殊字符会变形）；
+        # `_adb` 是 argv 形式、不过 shell，base64 里的 +/= 安全 —— 将来谁把
+        # 这里改成 shell=True 就会静默坏掉，别改。
+        # 台账里没有这台设备时**整个 extra 不发**（设备端"没有这个 extra"=
+        # 本来就没登记，跟"发了但解不开"能区分开），原因随响应体的 warn 回给操作者。
+        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 会把大字页开在锁屏**后面**，
     # 人看到的还是一片黑（实测踩过）——这正是原来"定位"按钮里的"点亮屏幕"那一步
@@ -339,7 +367,37 @@ def api_agent_show_info():
                         "error": "这台设备没装设备 Agent（com.example.deviceagent）——"
                                  "可以从「应用管理 → 设备端应用商店」装，或用扫码配置"}), 400
     _log.info("设备端 Agent %s: %s", "关闭身份页" if close else "打开身份页", serial)
-    return jsonify({"ok": True, "msg": "已关闭" if close else "已让设备显示身份信息"})
+    resp = {"ok": True, "msg": "已关闭" if close else "已让设备显示身份信息"}
+    if not close and warn:
+        resp["warn"] = warn          # 前端用 toast 提示（同二维码接口的 warn 惯例）
+    return jsonify(resp)
+
+
+# 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"])

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
+from core import device_battery, device_pool, device_discovery, ledger
 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,6 +445,109 @@ 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

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

web_server.py

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