chore: 去掉 generic_steps 的默认步骤 + 重试失败带上真实原因

- tasks/generic/task.py：DEFAULT_PARAMS 只留 max_duration，**不再内置示例步骤** （步骤只能由前端编辑器产出；此前默认的"打开抖音→循环看视频"只有后端在用，编辑器新建任务本来就是空的，等于埋了个和界面不一致的隐性默认值） - 空步骤不再静默空跑：worker 立即抛错「通用步骤任务没有可执行步骤…」，设备表「最近错误」能看到（此前会走完 0 步当成功） - core/task_manager.py：重试耗尽的 last_error 现在带上最后一次的真实失败原因，不再只有"重试N次失败"（用户看不到为什么失败）；max_attempts=1 显示"执行失败" 而非费解的"重试1次失败"；长度截断 200 字符 - 文档：TASK_DEV §2.10 说明无默认步骤 + 空步骤会报错；API.md 的 task_types 示例改 default_params={"max_duration":0}，POST /api/jobs 补「steps 要一起传」提示自测（全通过）：default_params 无 steps；无步骤任务真跑一次 → 设备错误信息完整含原因；有步骤任务（wait 1s）真跑一次 → status=done 无错误；临时任务验完已删，任务集合复原
chore: 删除抖音养号任务类型，平台只保留 generic_steps
2026-09-10 21:50:18 +08:00 · 2026-09-10 21:43:08 +08:00 · 2026-09-10 21:15:23 +08:00 · 2026-09-10 21:03:41 +08:00 · 2026-09-10 18:22:20 +08:00
31 changed files with 739 additions and 620 deletions
@@ -2,7 +2,7 @@

 基于 **uiautomator2 + Flask + 自建设备池** 的 Android 多设备自动化任务执行平台（已摘除 OpenSTF 依赖）。

-提供 Web 管理后台，支持多设备并发任务执行、定时调度、设备分组管理、设备池管理（新增/停用/删除/型号采集）、APK 批量安装、网页远程看屏（MJPEG 实时流 + 触控）、UI 元素抓取等功能。内置抖音养号任务和通用步骤任务，可扩展任意 App 的自动化操作。
+提供 Web 管理后台，支持多设备并发任务执行、定时调度、设备分组管理、设备池管理（新增/停用/删除/型号采集）、APK 批量安装、网页远程看屏（MJPEG 实时流 + 触控）、UI 元素抓取等功能。内置通用步骤任务（可视化步骤编辑器编排，覆盖任意 App 的操作），可扩展专属任务类型。

 ---

@@ -105,8 +105,7 @@ platform-tools/
 ├── tasks/                       # 任务定义层（每个 App 一个子包）
 │   ├── __init__.py              #   全局任务注册表
 │   ├── base.py                  #   BaseTask 基类 + @register_task 装饰器
-│   ├── douyin/                  #   抖音养号任务
-│   └── generic/                 #   通用步骤任务（可视化编辑器编排）
+│   └── generic/                 #   通用步骤任务（可视化编辑器编排，当前唯一任务类型）
 │       └── task.py              #     步骤执行引擎（open_app/click/swipe/if_el...）
 │
 ├── templates/admin/             # 前端页面
@@ -183,8 +182,7 @@ Worker.run_task（执行业务逻辑）

 | 任务类型 | task_type | 说明 |
 |---------|-----------|------|
-| 抖音养号 | `douyin_nurture` | 自动看视频 + 随机点赞，被退出自动重连 |
-| 通用步骤 | `generic_steps` | 可视化步骤编辑器编排流程，支持循环/点击/滑动等 |
+| 通用步骤 | `generic_steps` | 可视化步骤编辑器编排流程，支持循环/点击/滑动/条件/OCR 等 |

 ### TaskJob — 任务计划

@@ -192,9 +190,9 @@ Worker.run_task（执行业务逻辑）

 | 字段 | 说明 | 示例 |
 |------|------|------|
-| `task_type` | 任务类型 | `"douyin_nurture"` |
+| `task_type` | 任务类型 | `"generic_steps"` |
 | `target` | 目标设备 | `{"mode": "all"}` 或 `{"mode": "group", "group_name": "A组"}` 或 `{"mode": "serial", "serial": "192.168.1.100:5555"}` |
-| `params` | 任务参数（与默认值深合并） | `{"watch_count": 50, "actions": {"like": {"params": {"rate": 0.5}}}}` |
+| `params` | 任务参数（与默认值深合并） | `{"max_duration": 0, "steps": [{"type": "open_app", "params": {"package": "com.ss.android.ugc.aweme"}}]}` |
 | `schedule` | 调度策略 | `{"mode": "once"}` 或 `{"mode": "cron", "cron": "0 9 * * *"}` 或 `{"mode": "cron_stop", "cron": "0 9 * * *", "stop_cron": "0 18 * * *"}` |
 | `retry` | 重试策略 | `{"max_attempts": 3, "delay": 60}` |
 | `enabled` | 是否启用 | `true` |
@@ -306,23 +304,6 @@ self.set_progress(done=5, total=80, unit="视频",

 ## 任务系统

-### 抖音养号（douyin_nurture）
-
-自动观看抖音视频，按配置随机执行点赞操作。参数（在 `tasks/douyin/task.py` 顶部）：
-
-| 参数 | 默认值 | 说明 |
-|------|--------|------|
-| `watch_count` | 80 | 观看视频数量（0=不限，靠时长停止） |
-| `watch_min` / `watch_max` | 5.0 / 35.0 | 单视频观看时长范围（秒） |
-| `max_duration` | 0 | 最大运行时长（秒），0=不限时 |
-| `swipe_min` / `swipe_max` | 0.25 / 0.50 | 上滑手势时长范围（秒） |
-| `gap_min` / `gap_max` | 1.0 / 3.0 | 视频间隔时长范围（秒） |
-| `actions.like.enabled` | true | 是否启用点赞 |
-| `actions.like.params.rate` | 0.3 | 点赞概率（0~1） |
-| `actions.like.params.method` | by_element | 点赞方式：by_element(找红心) / double_click(双击) |
-
-终止条件（哪个先到就停）：`watch_count` 数量到 / `max_duration` 时长到 / 手动停止。
-
 ### 通用步骤（generic_steps）

 通过可视化步骤编辑器编排任务流程，worker 按步骤顺序执行。支持的步骤类型：
@@ -352,7 +333,8 @@ self.set_progress(done=5, total=80, unit="视频",

 ### 新增 App 任务

-参照 `tasks/douyin/` 结构，6 步即可新增一个 App 任务，详见 [doc/TASK_DEV.md](doc/TASK_DEV.md)。
+参照 `tasks/generic/` 结构，即可新增一个专属任务类型，详见 [doc/TASK_DEV.md](doc/TASK_DEV.md)。
+（注：当前平台只保留 `generic_steps` 一种类型；绝大多数 App 操作直接用步骤编辑器编排即可，不必新建类型。）

 ---

@@ -371,7 +353,7 @@ self.set_progress(done=5, total=80, unit="视频",

 ```python
 from core.logger import get_logger
-log = get_logger("task.douyin")    # 写入 task.log
+log = get_logger("task.generic")   # 写入 task.log
 log.info(f"[{self.serial}] 开始任务")
 ```

@@ -1,7 +1,7 @@
 """core 包：基础设施层。

-  config         — 全局配置常量（STF、adb 路径、养号参数）
+  config         — 全局配置常量（adb 路径、设备发现等）
  adb_helper     — adb 命令封装（并发安全）
-  device_worker  — 设备生命周期 + 养号 worker + 全局状态注册表
+  device_worker  — 设备生命周期 + 任务 worker 基类 + 全局状态注册表
  task_manager   — 任务管理框架（分组/计划/调度/重试/持久化）
 """
@@ -1,7 +1,7 @@
 """全局操作框架：所有 app 任务共用的 Action 基类与注册机制。

 为什么放这里：
-  抖音的点赞/评论 xpath 只适用抖音，留在 tasks/douyin/actions/。
+  某个 app 专属的 xpath 只适用那个 app，留在 tasks/<app>/actions/。
  但"操作"的抽象（BaseAction 接口、概率触发、注册机制）是通用的，
  放这里让所有 app 任务共享同一套操作开发范式。

@@ -3,11 +3,11 @@
 设计要点：
  1. BaseAction 定义统一接口：execute(d, params, worker) -> bool
  2. 每个 app 任务有自己的注册表（create_action_registry），
-     互不污染——抖音的 like 和快手的 like 各注册各的。
+     互不污染——A 应用的 like 和 B 应用的 like 各注册各的。
  3. 概率触发、状态上报等通用逻辑放这里，子类不重复写。
  4. ActionContext 封装执行上下文，方便扩展（传 d/worker/进度/计数器）。

-新增 app 专属操作步骤（照着 tasks/douyin/actions/like.py 抄）：
+新增 app 专属操作步骤（在 tasks/<app>/actions/ 下新建，参考该包已有实现）：

  1. 在 tasks/<app>/actions/ 下新建 my_action.py
  2. 写一个 BaseAction 子类，用 @register_action 装饰，实现 execute：
@@ -41,7 +41,7 @@ def get_logger(name="core"):
    """获取指定模块的 logger。

    name: 模块名（core/task/web/action），决定写哪个文件。
-          也可传子模块名如 "task.douyin"，会归到 task.log。
+          也可传子模块名如 "task.generic"，会归到 task.log。
    返回配置好的 logging.Logger。
    """
    if name in _LOGGERS:
@@ -128,7 +128,7 @@ class TaskJob(db.Model):
    """
    id = db.Column(db.String(32), primary_key=True)   # uuid 前 8 位
    name = db.Column(db.String(120), nullable=False)
-    task_type = db.Column(db.String(60), default="douyin_nurture")
+    task_type = db.Column(db.String(60), default="generic_steps")
    target = db.Column(db.Text, default='{"mode":"all"}')       # JSON
    params = db.Column(db.Text, default="{}")                    # JSON
    schedule = db.Column(db.Text, default='{"mode":"once"}')     # JSON
@@ -384,7 +384,7 @@ def _migrate_old_json():
                    del actions["comment"]
                    _log.info(f"迁移任务 {j.get('name')}: 已剔除废弃的 comment 配置")
                row = TaskJob(id=j["id"], name=j["name"],
-                              task_type=j.get("task_type", "douyin_nurture"),
+                              task_type=j.get("task_type", "generic_steps"),
                              enabled=j.get("enabled", True))
                row.set_target(j.get("target", {"mode": "all"}))
                row.set_params(params)
@@ -38,16 +38,21 @@ DB_FILE = os.path.join(DATA_DIR, "users.db")
 # 判定「本平台备份库」的必需表（缺任何一张即拒绝导入）
 REQUIRED_TABLES = ("app_meta", "user", "task_job", "device_group")
 # 预览/清单里展示行数的业务表（存在才统计）
+# ⚠️ 红线：**新增任何持久化表，必须同步登记到这里**——备份覆盖清单以此为准，
+#    漏登记的表在导出清单/预览里不可见（2026-09-10 动作库 agent_action 即因此
+#    被误判为"没有备份"：数据其实在 users.db 快照里，只是清单没列）。
 SUMMARY_TABLES = (
-    "user", "device_group", "task_job", "custom_action",
+    "app_meta", "user", "device_group", "task_job", "custom_action",
    "apk_file", "device", "pending_device",
-    "agent_conversation", "agent_experience", "experience_audit",
+    "agent_conversation", "agent_experience", "experience_audit", "agent_action",
 )
 TABLE_LABELS = {
+    "app_meta": "系统配置(app_meta)",
    "user": "用户", "device_group": "设备分组", "task_job": "任务计划",
    "custom_action": "自定义动作", "apk_file": "APK 记录", "device": "设备池",
    "pending_device": "待连接设备", "agent_conversation": "AI 会话",
    "agent_experience": "经验库", "experience_audit": "经验巡检",
+    "agent_action": "动作库",
 }
 _STAGE_TTL = 1800  # 导入暂存有效期（秒）

@@ -193,6 +198,13 @@ def create_export(include_apk=True):
            "tables": _summary_info(con),
            "apks": apk_meta,
        }
+        # 覆盖自检：登记在册的业务表若在快照里缺失（新增功能忘了登记 / 建表失败），
+        # 显式告警并写进 manifest——避免"以为备份了其实没有"（备份覆盖红线）。
+        _present = {t["table"] for t in manifest["tables"]}
+        _missing = [t for t in SUMMARY_TABLES if t not in _present]
+        if _missing:
+            manifest["coverage_missing"] = _missing
+            _log.warning(f"备份覆盖检查：以下登记表未纳入快照，请确认是否应备份: {_missing}")
    finally:
        con.close()

@@ -241,6 +253,12 @@ def validate_backup(db_file):
            warnings.append("备份缺少部分可选表（" + "、".join(
                TABLE_LABELS.get(t, t) for t in missing_optional)
                + "），应用后启动会自动补建空表")
+        # 反向自检：备份里有"未登记"的表 → 提醒把它纳入覆盖清单（红线）
+        extra_tables = sorted(t for t in tables
+                              if t not in SUMMARY_TABLES and not t.startswith("sqlite_"))
+        if extra_tables:
+            warnings.append("备份含未登记的其它表（" + "、".join(extra_tables)
+                            + "）——如属业务数据，请登记进 core/system_backup.py 的覆盖清单")
        warnings.append("备份为全量快照：含用户口令哈希、AI 配置里的 API Key 等敏感信息，请妥善保管")
        return True, {
            "integrity": integrity,
@@ -248,6 +266,7 @@ def validate_backup(db_file):
            "current_schema_version": CURRENT_SCHEMA_VERSION,
            "tables": _summary_info(con),
            "missing_optional": missing_optional,
+            "extra_tables": extra_tables,
            "warnings": warnings,
        }
    except sqlite3.Error as e:
@@ -1,9 +1,9 @@
 """通用任务管理框架：任务类型注册 + 设备分组 + 任务计划 + 定时调度 + 重试 + 持久化。

-设计目标：可扩展，未来加非抖音任务只需注册新的 Task 类。
+设计目标：可扩展——新增任务类型只需在 tasks/ 下注册新的 Task 类（见 doc/TASK_DEV.md）。

 核心概念：
-  TaskType  — 任务类型（如"抖音养号"），可注册，含默认参数和 worker 工厂
+  TaskType  — 任务类型（如"通用步骤"），可注册，含默认参数和 worker 工厂
  DeviceGroup — 设备分组，持久化到 SQLite（core.models.DeviceGroup）
  TaskJob   — 任务计划（类型+目标+参数+调度+重试），持久化到 SQLite（core.models.TaskJob）
  TaskManager — 统管调度器、分组、任务、运行实例、状态
@@ -121,7 +121,7 @@ class DeviceGroup:
 class TaskJob:
    """一个任务计划：什么任务、跑哪些设备、什么参数、何时跑、失败重试策略。"""

-    def __init__(self, job_id=None, name="", task_type="douyin_nurture",
+    def __init__(self, job_id=None, name="", task_type="generic_steps",
                 target=None, params=None, schedule=None, retry=None, enabled=True):
        self.id = job_id or uuid.uuid4().hex[:8]
        self.name = name
@@ -378,24 +378,22 @@ class TaskManager:
                for row in GroupRow.query.all():
                    g = DeviceGroup(row.name, row.get_serials(), row.description or "")
                    self.groups[g.name] = g
-                dirty = False  # 标记是否有任务参数需要写回
+                stale = []   # 任务类型已不存在（历史任务类型被删除）的任务
                for row in JobRow.query.all():
                    j = TaskJob(job_id=row.id, name=row.name, task_type=row.task_type,
                               target=row.get_target(), params=row.get_params(),
                               schedule=row.get_schedule(), retry=row.get_retry(),
                               enabled=row.enabled)
-                    # 数据规整：移除已废弃的 action 配置（如抖音的 comment 已删除）
-                    if j.task_type == "douyin_nurture":
-                        actions = j.params.get("actions", {})
-                        if "comment" in actions:
-                            del actions["comment"]
-                            row.set_params(j.params)
-                            dirty = True
-                            _log.info(f"任务 {j.name}({j.id}): 已移除废弃的 comment 配置")
+                    # 启动时告警：库里留着已删除的任务类型（如 douyin_nurture），
+                    # 这类任务跑不起来也不该静默——提示人工删除或改用现有类型。
+                    # 只告警不改数据（不自动删用户的任务）。
+                    if not get_task_class(j.task_type):
+                        stale.append(j)
                    self.jobs[j.id] = j
-                if dirty:
-                    db.session.commit()
-                    _log.info("已将规整后的任务参数写回数据库")
+                if stale:
+                    _log.warning(
+                        "以下任务的任务类型已不存在，无法执行，请在「任务」页删除或改用现有类型："
+                        + "；".join(f"{j.name}({j.id}, type={j.task_type})" for j in stale))
            _log.info(f"从数据库加载 {len(self.groups)} 个分组, {len(self.jobs)} 个任务")
        except Exception as e:
            _log.error(f"从数据库加载失败: {e}")
@@ -608,6 +606,11 @@ class TaskManager:
        job = self.jobs.get(job_id)
        if not job:
            return {"ok": False, "error": "任务不存在"}
+        # 任务类型已不存在（历史类型被删除）→ 明确报错，别只返回"已触发"然后线程里静默失败
+        if not get_task_class(job.task_type):
+            return {"ok": False, "error":
+                    f"任务类型 {job.task_type} 已不存在（该类型已被删除），"
+                    f"请删除此任务或改用现有类型"}
        # 在独立线程跑，不阻塞调用方
        t = threading.Thread(target=self._run_job, args=(job,), daemon=True)
        t.start()
@@ -754,7 +757,15 @@ class TaskManager:
                        time.sleep(delay)

            _log.error(f"{serial} 任务 {job.name} 重试耗尽，放弃")
-            _update_status(serial, status="failed", last_error=f"{job.name} 重试{max_attempts}次失败")
+            # 带上最后一次的真实失败原因——只写"重试N次失败"会让用户看不到为什么失败
+            # （worker 出错时已把原因写进 _WORKERS[serial]["last_error"]）
+            with _WORKERS_LOCK:
+                cause = (_WORKERS.get(serial, {}).get("last_error") or "").strip()
+            msg = (f"{job.name} 重试{max_attempts}次仍失败" if max_attempts > 1
+                   else f"{job.name} 执行失败")
+            if cause and cause != msg:
+                msg += f"：{cause}"
+            _update_status(serial, status="failed", last_error=msg[:200])
        finally:
            # 清除停止标志：整个重试循环结束（成功/失败/停止）后允许下次任务
            with self._lock:
@@ -23,7 +23,8 @@

 - **入口**：AI 控制台加「聊天 / AI 建任务」模式开关，复用会话/SSE/设备选择/停止/刷新恢复骨架。不新建顶级 Tab。
 - **产出方式**：**AI 直接撰写编辑器的步骤 JSON**（非操作轨迹翻译）。自探信息只作上下文与审计；探索中的误点/多余截图不会混入任务。
- **任务类型**：P0 **只产 `generic_steps`**（通用步骤）。`douyin_nurture` 预设参数生成放 P1。
+- **任务类型**：**只产 `generic_steps`**（通用步骤）——平台当前唯一的任务类型
+  （原 `douyin_nurture` 预设参数生成已随该类型删除，不再做）。
 - **定位原则：全部基于 UI 树**：
  - 模型定位/点击一律走 `de_ui_tree` 拿到的元素（`text`/`id`/`description`/`text_contains`），多实例用 index，或后端 `uiauto_helper` 生成的 `//*[@resource-id=..][k]` XPath；
  - `de_tap_element` 确认能命中后才写进 `click` 步骤；
@@ -134,8 +135,8 @@
 - 尽量不写死坐标；P0 默认禁 `click_xy`，产物以树元素定位为主。

 ## 6. 里程碑
- **P0（本设计主体）**：designer 模式 → 自探（UI 树定位）→ 直接撰写 generic_steps draft → 服务端 schema 校验 → 前端步骤编辑器预填确认保存。验收：一句话在真实设备上生成一条可调度的 generic_steps，步骤全部来自 UI 树且编辑器可打开。
- **P1**：`douyin_nurture` 参数预设生成（照 default_params 结构）；模板沉淀：把 draft+需求写入 `agent_experience`（新列存结构化 steps 或 JSON），相似需求注入参考；整链「演示试跑」（把 steps 在设备上以受控方式跑一遍并截图回报，需新增端点，复刻 `device_busy` 拒绝语义）。
+- **P0（本设计主体）**：designer 模式 → 自探（UI 树定位）→ 直接撰写 generic_steps draft → 服务端 schema 校验 → 前端步骤编辑器预填确认保存。验收：一句话在真实设备上生成一条可调度的 generic_steps，步骤全部来自 UI 树且编辑器可打开。（平台只剩 generic_steps 一种任务类型，与原规划一致）
+- **P1**：模板沉淀：把 draft+需求写入 `agent_experience`（新列存结构化 steps 或 JSON），相似需求注入参考；整链「演示试跑」（把 steps 在设备上以受控方式跑一遍并截图回报，需新增端点，复刻 `device_busy` 拒绝语义）。
  - **进展（2026-09-10）**：动作级沉淀已落地——`agent_action` 表 + 从**成功步骤**蒸馏"命名动作"（steps 用编辑器 schema、带元素定位、禁坐标）+ 执行前按名/别名召回注入（`web/agent_api.py`）。AI 建任务可直接把这些动作当作 generic_steps 的**预制件**复用。
 - **P2**：自定义动作支持（内联展开成 group，或新增 `action_ref` 节点 + 执行器/编辑器同步）；多设备并行；成本与 token 控制。

@@ -141,7 +141,7 @@
  "counts": {"total": 8, "running": 1, "done": 5, "error": 1, "failed": 1, "idle": 0},
  "errors": [
    {"serial": "192.168.1.100:5555", "model": "Pixel 6", "status": "failed",
-     "last_error": "重试3次失败", "task": "抖音养号", "attempt": 3, "updated": 1700000000.0}
+     "last_error": "重试3次失败", "task": "刷视频-上午", "attempt": 3, "updated": 1700000000.0}
  ]
 }
 ```
@@ -218,17 +218,11 @@
 {
  "ok": true,
  "task_types": [
-    {
-      "task_type": "douyin_nurture",
-      "name": "抖音养号",
-      "description": "自动观看抖音视频...",
-      "default_params": {"watch_count": 80, "...": "..."}
-    },
    {
      "task_type": "generic_steps",
      "name": "通用步骤",
      "description": "通过步骤编辑器编排...",
-      "default_params": {"steps": [...]}
+      "default_params": {"max_duration": 0}
    }
  ]
 }
@@ -265,13 +259,28 @@
 ```json
 {
  "ok": true,
-  "jobs": [{"id": "abc123", "name": "抖音养号", "task_type": "douyin_nurture",
-            "next_run": "2026-08-12 09:00", "...": "..."}],
+  "jobs": [{"id": "abc123", "name": "刷视频-上午", "task_type": "generic_steps",
+            "next_run": "2026-08-12 09:00",
+            "coverage": {"mode": "all", "total": 3,
+                         "serials": ["192.168.20.206:5555", "..."]},
+            "...": "..."}],
  "task_types": [...]
 }
 ```
 `next_run`：下次真正执行时间（已按运行窗口跳过窗口外触发点，格式 `YYYY-MM-DD HH:MM`）；手动任务/已停用为 `null`。

+`coverage`：**任务覆盖的设备**（监控页「任务运行概况」展示用，每次请求现算）。按 `target` 定义解析，
+不因设备当前是否空闲而变（在线/运行中由前端拿 `/api/status` 标注），也不做离线过滤、不写调度日志：
+
+| target.mode | coverage.serials |
+|------|------|
+| `all` | 设备池全部启用设备 |
+| `group` | 该分组的 serial ∩ 设备池启用设备（池外的手填 IP 不计入，与调度口径一致） |
+| `serial` | 仅该 serial（即使不在池中也照实返回） |
+
+> 口径差异：真正调度时走 `TaskJob.resolve_serials()`（`all` 取"池内∩在线"、并跳过离线设备）；
+> `coverage` 是**定义层**的覆盖面，供人看"这台任务管哪些设备"。POST/PUT 的 `job` 里同样带 `coverage`。
+
 ### POST /api/jobs

 创建任务计划。
@@ -281,10 +290,10 @@
 **请求**（JSON）：
 ```json
 {
-  "name": "抖音养号",
-  "task_type": "douyin_nurture",
+  "name": "刷视频-上午",
+  "task_type": "generic_steps",
  "target": {"mode": "all"},
-  "params": {"watch_count": 50, "actions": {"like": {"params": {"rate": 0.5}}}},
+  "params": {"max_duration": 0, "steps": [{"type": "open_app", "params": {"package": "com.ss.android.ugc.aweme"}}]},
  "schedule": {"mode": "cron", "cron": "0 */2 * * *"},
  "retry": {"max_attempts": 3, "delay": 60},
  "enabled": true
@@ -296,6 +305,10 @@
 {"ok": true, "msg": "任务已创建", "job": {"id": "abc123", "...": "..."}}
 ```

+> **`params.steps` 要一起传**：`generic_steps` 的执行内容全在 `params.steps`，后端**不提供默认步骤**、
+> 也不做参数校验（编辑器是参数正确性的唯一关卡）。不传 steps 的任务能建成功，但执行时会立即报错
+> 「通用步骤任务没有可执行步骤」，请在「任务」页用步骤编辑器补步骤。
+
 `schedule` 字段格式：
 | 字段 | 说明 |
 |------|------|
@@ -312,7 +325,7 @@

 **请求**（JSON）：
 ```json
-{"params": {"watch_count": 100}}
+{"params": {"max_duration": 1800}}
 ```

 **响应**：
@@ -339,7 +352,7 @@

 **响应**：
 ```json
-{"ok": true, "msg": "任务 抖音养号 已触发"}
+{"ok": true, "msg": "任务 刷视频-上午 已触发"}
 ```

 ### POST /api/jobs/<job_id>/toggle
@@ -1186,15 +1199,19 @@ AI 可用设备列表（在线状态 + 是否有任务运行，前端据此把 b
 ```json
 {"ok": true, "state": "running"|"idle"|"done", "run_id": "...", "prompt": "...",
 "serial": "...", "started": "10:00:01", "answer": "...", "error": "",
+ "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0, "calls": 0},
 "history": [{"role": "user", "content": "..."}]}
 ```

+`usage` 为本轮累计 token 用量（`calls` = 模型调用次数；运行中实时增长，失败也保留已花费的）。
+
 ### GET /api/agent/stream?run_id=

 订阅事件流（SSE，EventSource）。事件：
 - `event: delta` `{text, kind: content|reasoning}` — 流式文本增量
 - `event: step` `{tool, args, image?}` — 工具调用完成（MCP 步骤，image 为缩略截图）。另有三类伪卡片：`tool="🧠 经验记忆"` 表示命中任务级经验（args 形如「命中 N 条同类历史经验，已注入参考：<配方摘要>」）或本轮已写入经验库；`tool="🧠 动作经验"` 表示命中**可复用动作**（「命中 N 个可复用动作，已注入参考：<动作名>」，执行前注入）或本轮已沉淀动作（「已沉淀 N 个可复用动作」，含元素定位、禁坐标）
- `event: done` `{answer}` — 完成
+- `event: usage` `{prompt_tokens, completion_tokens, total_tokens, calls}` — **本轮累计** token 用量，每完成一次模型调用推一次（前端实时刷新计数与费用感）
+- `event: done` `{answer, usage}` — 完成（`usage` 同上一节，最终累计）
 - `event: error` `{message}` — 失败（若因 MCP Server 未启动/不可达，message 为明确文案「MCP server(8033) 不可达 …」，不再是 SDK 原始的 `Server returned an error response`）
 - 空闲时每 15s 发一行 `: keepalive` 注释防超时；`done`/`error` 后关流

@@ -1234,10 +1251,18 @@ AI 可用设备列表（在线状态 + 是否有任务运行，前端据此把 b

 **响应**：
 ```json
-{"ok": true, "id": "...", "title": "...", "messages": [{"role": "user", "content": "..."}],
+{"ok": true, "id": "...", "title": "...",
+ "messages": [{"role": "user", "content": "..."},
+              {"role": "assistant", "content": "...",
+               "usage": {"prompt_tokens": 0, "completion_tokens": 0,
+                         "total_tokens": 0, "calls": 0},
+               "reasoning": "模型推理链（≤6000 字符，可空）"}],
 "created_at": "...", "updated_at": "..."}
 ```

+> assistant 消息可带 `usage`（本轮 token 用量）与 `reasoning`（推理链，上限 `_REASONING_KEEP`=6000 字符）。
+> 两者**仅供前端展示/回看**，回灌模型上下文时只取 `role`/`content`（见 `_agent_thread`）。
+
 ### DELETE /api/agent/conversations/<conv_id>

 删除会话（消息一并删除，不可恢复）。
@@ -187,6 +187,8 @@ SQLAlchemy 模型，存于 `data/users.db`：
 > - `app_meta`（KV）：`_migrate_schema()` 内建表，存 `schema_version`、`discovery_*`、agent 配置 `agent_*` 等；
 > - `agent_conversation` / `agent_experience` / `experience_audit`：AI 控制台会话 / 任务级经验（配方）/ 经验巡检（`web/agent_api.py` 顶部 `CREATE TABLE IF NOT EXISTS`）。
 > - `agent_action`：**动作经验库**（命名动作 = 可复用单元，steps 用编辑器 schema 且带元素定位、禁坐标）；由任务成功后从**成功步骤**蒸馏，执行前按名字/别名召回并注入（`web/agent_api.py` `_distill_actions/_find_actions`）。
+>
+> **备份覆盖（红线）**：持久化表须登记进 `core/system_backup.py` 的 `SUMMARY_TABLES`（→ 导出清单/预览可见、覆盖自检生效），并同步 `doc/DEPLOY.md` §3.5；未登记的表在备份预览里不可见，会被误判为"没备份"。

 **数据库初始化**（`init_db`）：
 - 创建所有表
@@ -273,8 +275,7 @@ APK 上传/解析/批量安装。
 ```
 tasks/__init__.py
  ├── from .base import BaseTask, register_task, list_task_types, get_task_class
-  ├── from .douyin import task    # 触发 @register_task
-  └── from .generic import task   # 触发 @register_task
+  └── from .generic import task   # 触发 @register_task（当前唯一任务类型）
 ```

 `@register_task` 装饰器将 Task 类注册到全局 `_TASK_TYPES` 字典，key 为 `task_type` 字符串。
@@ -300,8 +301,11 @@ Job 下发时只传需要覆盖的字段，调度器做三层合并：

 ```
 core/actions/base.py           — BaseAction 全局基类 + should_trigger + register_action
-tasks/douyin/actions/base.py — ACTIONS = create_action_registry() + list/get 函数
-tasks/douyin/actions/like.py — @register_action(ACTIONS) LikeAction
+tasks/<app>/actions/base.py    — ACTIONS = create_action_registry() + list/get 函数
+tasks/<app>/actions/xxx.py     — @register_action(ACTIONS) XxxAction
+
+> 当前没有 App 专属任务包（只剩 `tasks/generic/`，步骤全走通用 STEP_TYPES，不建专属 action 表）；
+> 新增专属任务类型时按上面三行建 `tasks/<app>/actions/`。
 ```

 **循环导入坑**：`actions/__init__.py` 必须先 `from .base import ACTIONS`，再 `from . import like`。
@@ -318,6 +322,13 @@ tasks/douyin/actions/like.py — @register_action(ACTIONS) LikeAction
 - **数据获取**：`fetch()` 调 JSON API，5 秒轮询 `/api/status`
 - **状态渲染**：设备表格、任务卡片、进度条、徽章，纯 DOM 操作

+**监控页「任务运行概况」卡片（2026-09-10 收敛）**：每张卡片只保留两个操作——**执行任务**（`POST /api/jobs/:id/run`）
+与**停用任务/启用任务**（`POST /api/jobs/:id/toggle`，按当前状态切换文案）；原"编辑/删除"已移除
+（编辑与删除统一去「任务」Tab 操作，避免监控页误删）。卡片新增**覆盖设备**一行：设备清单来自
+`/api/jobs` 的 `coverage`（后端按 target 定义解析，见 [API.md](API.md) §5），在线/运行中状态由前端
+用已在手的 `/api/status` 数据标注成彩色 chip（在线=蓝、运行中=黄+⏳、离线或不在池=灰划线+✕，
+完整 serial 与型号放 tooltip）。
+
 ### 5.2 步骤编辑器

 `generic_steps` 任务的步骤编辑器（任务弹窗已加宽到 1000px）：
@@ -346,6 +357,19 @@ AI 控制台（顶级 Tab）右上角两个模态框，管理自进化记忆：
 - **🎬 动作库**：动作级经验（`agent_action`）——命名动作（可含 1~N 步）+ 编辑器 schema 步骤 + **元素定位（禁坐标）**；由任务成功后从**成功步骤**自动蒸馏，执行前按名/别名召回注入；面板支持查看/编辑/删除/手动新建（保存经服务端校验，坐标步骤被拒）。
 - **会话列表显示会话 ID**（前 8 位，等宽小字），点击即复制完整 ID——便于反馈问题时引用 `conv=<id>`。

+#### 5.4.1 回答渲染与 token（2026-09-10）
+
+| 能力 | 落点 | 说明 |
+|------|------|------|
+| **Markdown 渲染** | `static/admin/markdown.js`（`renderMarkdown()`） | 自研轻量渲染器，**不引 CDN**（生产 220 在内网）：标题/段落/软换行/粗斜体/删除线/行内代码/围栏代码块/有序无序列表（含嵌套）/引用/表格/分隔线/链接。**先 `esc()` 转义再套标记**，模型输出里的 HTML 只显示为文本（防注入） |
+| **推理链可折叠** | `agent.js` `_appendReasoning()` + `<details class="reasoning">` | 流式思考时自动展开、正文开始时自动收起；用户手动点过 `summary` 后不再自动改（`dataset.touched`）；摘要显示「思考过程（N 字）」 |
+| **token 显示** | `mcp_agent/agent.py` `_accumulate_usage()` + `agent_api` SSE `usage` 事件 | 每次模型调用完成后推**本轮累计**（`prompt/completion/total/calls`）；单条消息脚注 + 顶栏「本会话累计」（历史 + 运行中） |
+| **推理链/用量落库** | `_agent_thread` 把 `usage`、`reasoning` 写进会话 assistant 消息 | 刷新页面后仍可回看；**回灌模型上下文时只取 `role`/`content`**（不污染 token） |
+
+> **token 采集的兼容性**：请求带 `stream_options: {"include_usage": true}`，按「每次模型调用」取末尾 chunk 的 `usage` 累加（多轮工具调用会多次累加）。个别网关不认该参数会直接 **HTTP 400** → `_UsageUnsupported` 捕获后**自动关掉并重试一次**（`self._include_usage=False`），不影响主流程。
+>
+> **推理链体积**：只保留前 `_REASONING_KEEP`=6000 字符落库（会话消息上限 60 条），避免历史无限膨胀。
+
 > **蒸馏健壮性（2026-09-10）**：经验/动作靠**模型蒸馏**落库。推理型模型会把 token 预算烧在 `reasoning` 上，导致 `content` 为空或被截断（`finish_reason=length`）→ 早期只读 `content`，经验/动作被**静默丢弃**（"小红书·苏州饭店"案例）。现策略：
 > 1. 蒸馏调用**关闭推理**：`"thinking": {"type": "disabled"}`（该代理支持；实测关掉后 reasoning=0、正文正常，配方 3/3 合格）——这是关键修复；
 > 2. 配方用**纯文本问法**（不要放可照抄的占位示例，否则模型会原样当配方存下来）+ 质量门槛 `_recipe_ok`（过短/含省略号占位 → 丢弃并重试）；
@@ -246,6 +246,15 @@ server {
 - **导出**：`POST /api/system/backup/export` → 用 sqlite 在线备份 API 对 `data/users.db` 做一致快照，打包 zip（`users.db` + `manifest.json` + 可选 `apks/*.apk`）
 - **导入**：上传 zip/`.db` → 校验预览（完整性/必需表/schema 版本告警）→ 确认后自动把当前库快照到 `data/backups/pre_restore_*.db`（安全网可回滚）→ 落 `data/restore_pending/` → **重启 web_server 生效**（web_server 在 `init_db` 前自动消费恢复任务）

+**备份覆盖清单（红线）**：覆盖清单 = `core/system_backup.py` 的 `SUMMARY_TABLES`，当前包含
+`app_meta`(系统配置) / `user` / `device_group` / `task_job` / `custom_action` / `apk_file` / `device` /
+`pending_device` / `agent_conversation` / `agent_experience` / `experience_audit` / `agent_action`(动作库)。
+
+> **新增任何持久化表，必须同步登记进该清单**——否则导出清单/预览里看不到它，会被误判为"没有备份"
+> （2026-09-10 动作库 `agent_action` 即因此被误判：数据其实在 `users.db` 快照里，只是清单漏列）。
+> 导出侧有**覆盖自检**（登记表若缺失 → `manifest.coverage_missing` + 日志告警）；导入侧有**反向自检**
+> （备份含未登记表 → 预览告警提示登记）。
+
 目录与常量：

 | 目录 | 用途 |
@@ -108,7 +108,7 @@
 - **任务参数放各自 `tasks/<app>/task.py` 顶部，不放 `config.py`**
 - **生产环境（220）默认只读**：任何写操作（改文件/重启容器/部署）都必须先经负责人确认
 - **数据库是 SQLite**（`data/users.db`，WAL 模式）：运行时数据不提交 git
- **前端 JS 已拆分多文件**（均位于 `static/admin/`）：`monitor.html` 按 `base.js → list.js → monitor.js → editor.js → tasks.js → tools.js → apps.js → admin.js → agent.js → system.js` 的顺序用 `<script src>` 加载
+- **前端 JS 已拆分多文件**（均位于 `static/admin/`）：`monitor.html` 按 `base.js → markdown.js → list.js → monitor.js → editor.js → tasks.js → tools.js → apps.js → admin.js → agent.js → system.js` 的顺序用 `<script src>` 加载（`markdown.js` 提供 `renderMarkdown()`，AI 控制台回答渲染用；依赖 `base.js` 的 `esc()`，故排在其后、agent.js 之前）
 - **监控页/大列表已加分页**：100 台设备也只渲染 10 行/页，不要移除分页逻辑
 - **任务批量触发已错峰**（`_START_STAGGER_SEC`）：避免大量设备同时启动造成 adb 连接风暴，不要移除

@@ -176,9 +176,11 @@ with sync_playwright() as p:

 ## 5. 常见开发任务

-### 5.1 新增 App 任务
+### 5.1 新增 App 任务类型

-参照 `tasks/douyin/` 结构，详见 **[doc/TASK_DEV.md](TASK_DEV.md)**（6 步模板）。
+参照 `tasks/generic/` 结构，详见 **[doc/TASK_DEV.md](TASK_DEV.md)**（6 步模板）。
+注意：当前平台**只保留 `generic_steps` 一种任务类型**；大多数 App 操作直接用步骤编辑器
+编排即可，不必新增任务类型。

 ```
 tasks/<app>/
@@ -196,7 +198,7 @@ tasks/<app>/
 | 文件 | 内容 |
 |------|------|
 | `templates/admin/monitor.html` | HTML 结构 + CSS + `<script src>` 引用 |
-| `static/admin/`（base/list/monitor/editor/tasks/tools/apps/admin/agent/system.js） | 前端 JS（按 monitor.html 中 `<script src>` 顺序拆分加载，功能归属见各文件） |
+| `static/admin/`（base/markdown/list/monitor/editor/tasks/tools/apps/admin/agent/system.js） | 前端 JS（按 monitor.html 中 `<script src>` 顺序拆分加载，功能归属见各文件；`markdown.js` = 轻量 Markdown 渲染器，AI 控制台回答用） |

 改完**强刷浏览器**（Cmd/Ctrl+Shift+R），必要时重启 web_server。

@@ -231,20 +233,42 @@ tasks/<app>/
 | MCP 工具 | [MCP.md](MCP.md) 与 [MCP_DESIGN.md](MCP_DESIGN.md) |
 | 对外接入 / 数字员工知识库 | [staffdeck/KNOWLEDGE_BASE.md](staffdeck/KNOWLEDGE_BASE.md) 与 [staffdeck/JOB_SPEC.md](staffdeck/JOB_SPEC.md) |

+> **备份覆盖红线（2026-09-10 新增）**：**新增任何持久化表**（业务数据）时，必须同步把它登记进
+> `core/system_backup.py` 的 `SUMMARY_TABLES`（并在 `TABLE_LABELS` 给中文名）+ 更新
+> [DEPLOY.md](DEPLOY.md) §3.5 的覆盖清单。理由：清单漏登记 → 导出预览看不到该表 → 会被误判为
+> "没有备份"（动作库 `agent_action` 就踩过）。导出侧有覆盖自检、导入侧有未登记表反向告警。
+
 注：STF_REMOVAL.md 是历史迁移记录，不改写。

 ---

-## 6. 发布流程
+## 6. 发布流程（团队约定，2026-09-10 更新）

-详见 **[doc/DEPLOY.md](DEPLOY.md)**。摘要：
+**每个改动都走分支，确认后再并 dev；dev 整体就绪后才并 main 上生产。**

-1. dev 开发测试完成
-2. 负责人确认 → 合并到 main
-3. 负责人确认 → 生产 220 `git pull`
-4. 重启 python-app 容器生效
+```
+① 本机新建分支          fix/xxx 或 feat/xxx（从 dev 切出）
+② 分支上开发 + 自测     本机跑通（服务/接口/页面）
+③ 交负责人确认          ★ 未经确认不合 dev
+④ 合并到 dev            确认通过后（fast-forward 或 merge）
+⑤ dev 整体就绪          dev 上功能齐全、验证完毕
+⑥ 合并到 main           ★ 负责人确认后
+⑦ 生产 220 部署         git pull → 重启 python-app 容器 → 验证
+```

-**发布前检查**：生产容器 adb key、依赖、数据库迁移。
+**生产 220 部署（目录 `/mnt/data/openstf/auto_control`，容器 `python-app` 挂到 `/app`）**：
+
+```bash
+cd /mnt/data/openstf/auto_control
+git fetch origin && git checkout main && git pull --ff-only origin main
+docker restart python-app          # 入口 scripts/start.sh：依赖守卫 → 拉起 MCP → exec web_server
+# 验证：curl -s http://127.0.0.1:18050/api/health ; ss -ltnp | grep -E ':(18050|8033|20242)'
+```
+
+**发布前检查**：生产容器 adb key、依赖（新增依赖看 `requirements.txt`）、数据库迁移（`create_all` 自动补新表）、
+以及"新增持久化表是否已登记进备份覆盖清单"（见 §5.6 红线）。
+
+**数据迁移**：用平台自带「系统 → 数据备份导出/导入」；导入后需**重启容器**才生效（见 [DEPLOY.md](DEPLOY.md) §3.5）。

 ---

@@ -62,18 +62,13 @@ platform-tools/
 │       ├── __init__.py        # create_action_registry / register_action / should_trigger
 │       └── base.py            # BaseAction 全局基类
 ├── tasks/                     # 任务定义层
-│   ├── __init__.py            # 聚合导出 + import 各任务包触发注册（from .douyin/.generic import task）
+│   ├── __init__.py            # 聚合导出 + import 各任务包触发注册（from .generic import task）
 │   ├── base.py                # BaseTask 基类 + _TASK_TYPES + register_task/list_task_types/get_task_class
-│   ├── douyin/                # 抖音养号（task_type=douyin_nurture，示例）
-│   │   ├── __init__.py
-│   │   ├── task.py            #   DEFAULT_PARAMS + Worker + Task + @register_task
-│   │   └── actions/
-│   │       ├── __init__.py    #   先 from .base import ACTIONS，再 from . import like
-│   │       ├── base.py        #   ACTIONS = create_action_registry()
-│   │       └── like.py        #   @register_action(ACTIONS) LikeAction
-│   └── generic/               # 通用步骤任务（task_type=generic_steps，步骤编辑器编排）
+│   └── generic/               # 通用步骤任务（task_type=generic_steps，当前唯一任务类型）
 │       ├── __init__.py
 │       └── task.py            #   STEP_TYPES + Worker + Task（按 steps 顺序执行）+ test_step
+│
+│   # 新增专属任务类型时：按同样结构建 <app>/（见 §6「新增任务类型」的骨架）
 ├── templates/admin/
 │   ├── monitor.html           # 单页应用（7 Tab + 页内子分栏，纯前端渲染）
 │   ├── login.html             # 登录页
@@ -130,9 +125,9 @@ platform-tools/

 ### 2.1 TaskType — 任务类型

-一个 `TaskType` 描述"做什么"（例如抖音养号、通用步骤），由 `Task` 子类 + `Worker` 子类 + `DEFAULT_PARAMS` 组成。每个 `TaskType` 注册到全局 `_TASK_TYPES` 字典，key 为任务类型字符串，value 为 `Task` 类。
+一个 `TaskType` 描述"做什么"（例如通用步骤、某个 App 的专属养号流程），由 `Task` 子类 + `Worker` 子类 + `DEFAULT_PARAMS` 组成。每个 `TaskType` 注册到全局 `_TASK_TYPES` 字典，key 为任务类型字符串，value 为 `Task` 类。

-> **注册位置**：`_TASK_TYPES` 及 `register_task` / `list_task_types` / `get_task_class` **定义在 `tasks/base.py`**；`tasks/__init__.py` 只做两件事——`from .base import ...` 聚合导出，以及 `from .douyin/.generic import task` 触发各任务包注册。**当前已注册的 task_type 仅 `douyin_nurture` 与 `generic_steps`**，前端"新建任务"下拉来自 `GET /api/task_types`。新增 task_type 需在 `tasks/` 下建子包、用 `@register_task` 装饰，并在 `tasks/__init__.py` 加 `from .xxx import task`，然后**重启 web** 生效。
+> **注册位置**：`_TASK_TYPES` 及 `register_task` / `list_task_types` / `get_task_class` **定义在 `tasks/base.py`**；`tasks/__init__.py` 只做两件事——`from .base import ...` 聚合导出，以及 `from .generic import task` 触发各任务包注册。**当前已注册的 task_type 只有 `generic_steps`（通用步骤）**，前端"新建任务"下拉来自 `GET /api/task_types`。新增 task_type 需在 `tasks/` 下建子包、用 `@register_task` 装饰，并在 `tasks/__init__.py` 加 `from .xxx import task`，然后**重启 web** 生效。

 ```python
 # tasks/base.py
@@ -151,7 +146,7 @@ def get_task_class(task_type):

 `TaskJob` 是"什么时候、在哪些设备上、用什么参数执行某个 TaskType"的持久化计划，存于 SQLite（`data/users.db` 的 `task_job` 表）。包含字段：

- `task_type` — 任务类型（对应 `_TASK_TYPES` 的 key；当前仅 `douyin_nurture` / `generic_steps`）
+- `task_type` — 任务类型（对应 `_TASK_TYPES` 的 key；当前仅 `generic_steps`，新建任务不传时默认就是它）
 - `target` — 目标设备：`{"mode": "all"|"group"|"serial", "group_name": "", "serial": ""}`，默认 `{"mode":"all"}`
 - `params` — 任务参数（与 `DEFAULT_PARAMS` 深合并）。含两个隐藏开关：
  - `skip_offline`（默认 **true**）— serial/group 模式先跳过本机 adb 不可达（离线）的设备
@@ -198,11 +193,11 @@ Worker 通过 `self.set_progress(**fields)` 上报进度，前端统一解析展

 **示例**：
 ```python
-# 抖音任务（有数量限制）
+# 有数量限制的任务
 self.set_progress(done=5, total=80, unit="视频",
                  action_counts={"like": 3}, elapsed=120)

-# 抖音任务（仅时长限制，无数量）
+# 仅时长限制（无数量）的任务
 self.set_progress(done=5, total=0, unit="视频",
                  action_counts={"like": 3}, elapsed=120)

@@ -285,6 +280,10 @@ while not self.stopped():

 - `max_duration` — 最大运行时长（秒），0=不限时
 - `steps` — 步骤数组。每步 `{id, type, label, params}`；`id` 前端生成保证唯一
+
+> **没有默认步骤**：`DEFAULT_PARAMS` 只含 `max_duration`，步骤只能由步骤编辑器产出
+> （新建任务时编辑器从零开始拖）。若任务的 `params.steps` 为空，worker 会**立即报错**
+> （设备「最近错误」显示"通用步骤任务没有可执行步骤…"），不会静默空跑。
 - **进度上报**：`done` = 累计已执行的**非容器**步骤数（loop/group/if_el 不计入，避免监控噪音）、`total=0`、`unit="操作"`（前端显示"已执行 N 次操作"）
 - **公共参数**：每步都可有 `probability`（0-100，默认 100，<100 时按百分比概率决定本次是否执行该步）
 - **嵌套深度上限 5**：loop/group 的 `children`、if_el 的 `then/else` 递归嵌套超过 5 层会被跳过并告警
@@ -346,7 +345,7 @@ adb + u2 **只读连接**试执行单步并验证选择器，返回 `result` = *

 > **签名提醒**：以下模板的 `Worker.__init__` / `Task.create_worker` **已去掉 `stf_client` / `stf`
 > 参数**——现行签名是 `BaseWorker.__init__(self, serial, params=None, daemon=True)`、
-> `Task.create_worker(self, serial, params)`（对照 `tasks/douyin/task.py`），新增任务照此抄，
+> `Task.create_worker(self, serial, params)`（对照 `tasks/generic/task.py`），新增任务照此抄，
 > 不要再带 stf 形参。

 ### 步骤 1：在 `tasks/` 下建 `kuaishou/` 子包
@@ -629,7 +628,6 @@ from . import task  # noqa: F401  触发 @register_task 注册
 ```python
 # tasks/__init__.py
 from .base import BaseTask, register_task, list_task_types, get_task_class
-from .douyin import task  # noqa: F401
 from .generic import task  # noqa: F401
 from .kuaishou import task  # noqa: F401  ← 新增这一行
 ```
@@ -1029,7 +1027,7 @@ from .base import ACTIONS, ...   # 1. 先建注册表
 from . import like               # 2. 再导入各 action，触发 @register_action
 ```

-`tasks/__init__.py` 同理：先 `from .base import BaseTask`，再 `from . import douyin`、`from . import generic`。
+`tasks/__init__.py` 同理：先 `from .base import BaseTask`，再 `from . import generic`（新增类型往下加）。

 ### 10.2 中文输入

@@ -1130,7 +1128,7 @@ self.set_progress(videos_watched=5, round_idx=3)
 - [ ] 长循环内周期性调用 `self.heartbeat()`
 - [ ] `tasks/<app>/actions/__init__.py` 先 `from .base import ACTIONS` 再导入各 action
 - [ ] 每个 Action 有 `action_type` / `name` / `default_params` / `execute`，返回 `True/False`
- [ ] `Task.create_worker` 做 actions 参数级深合并（照抄抖音模板）
+- [ ] `Task.create_worker` 做 actions 参数级深合并（照抄 `tasks/generic/task.py`）
 - [ ] `tasks/__init__.py` 已 `from .<app> import task` 注册
 - [ ] 日志用 `get_logger("task.<app>")` / `get_logger("action.<app>.<name>")`，无 `print`
 - [ ] 定位元素优先 `description` / `descriptionContains`，resourceId 多候选，xpath 用相对定位
@@ -8,6 +8,8 @@
  - content/reasoning_content 增量逐 chunk 回调（kind 区分）
  - tool_calls 分片累积（arguments 按 index 拼接），流结束后统一执行
  - 截图（de_screenshot）图像转 image_url 追加下一轮，同时 on_tool 回调带缩略
+  - token 用量：请求带 stream_options.include_usage，按「每次模型调用」累计，
+    on_usage 回调吐出累计值（Web 控制台展示）
 """
 import base64
 import json
@@ -22,6 +24,10 @@ _log = logging.getLogger("agent")

 S = AgentSettings()

+
+class _UsageUnsupported(RuntimeError):
+    """模型/网关不认 stream_options.include_usage（400/422 或报错点名该字段）——降级重试用。"""
+
 SYSTEM_PROMPT = """你是手机自动化控制助手。你通过工具实时操作 Android 手机。

 工作规范：
@@ -56,8 +62,15 @@ class Agent:
        # 回调（Web 展示用，均可选）：
        #   on_delta(text, kind)  kind: content | reasoning   —— 流式文本增量
        #   on_tool(step)         step: {tool, args, result, image} —— 工具调用完成
+        #   on_usage(usage)       usage: {prompt_tokens, completion_tokens,
+        #                                 total_tokens, calls} —— 累计 token 用量
        self.on_delta = None
        self.on_tool = None
+        self.on_usage = None
+        # 本轮累计用量（run_stream 开始时重置）
+        self.usage = {"prompt_tokens": 0, "completion_tokens": 0,
+                      "total_tokens": 0, "calls": 0}
+        self._include_usage = True   # 模型不认 stream_options 时自动置 False
        self._mcp = None

    # ---------- MCP 工具桥 ----------
@@ -88,7 +101,23 @@ class Agent:

    # ---------- 模型调用（流式） ----------
    async def _chat_stream(self):
-        """流式 chat/completions：逐 chunk 产出 JSON（async generator）。"""
+        """流式 chat/completions：逐 chunk 产出 JSON（async generator）。
+
+        默认要求服务端在末尾 chunk 带 usage（token 统计）；个别网关不认
+        `stream_options` 会直接 400，此时自动降级重试一次（不影响主流程）。
+        """
+        if self._include_usage:
+            try:
+                async for chunk in self._chat_stream_once(True):
+                    yield chunk
+                return
+            except _UsageUnsupported as e:
+                _log.warning("模型不支持 stream_options.include_usage，降级重试：%s", e)
+                self._include_usage = False
+        async for chunk in self._chat_stream_once(False):
+            yield chunk
+
+    async def _chat_stream_once(self, with_usage):
        body = {
            "model": self.s.model,
            "messages": self.messages,
@@ -96,6 +125,8 @@ class Agent:
            "max_tokens": 4096,
            "stream": True,
        }
+        if with_usage:
+            body["stream_options"] = {"include_usage": True}
        headers = {"Authorization": f"Bearer {self.s.api_key}",
                   "Content-Type": "application/json"}
        url = f"{self.s.api_base.rstrip('/')}/chat/completions"
@@ -103,6 +134,11 @@ class Agent:
            async with client.stream("POST", url, json=body, headers=headers) as r:
                if r.status_code != 200:
                    text = (await r.aread()).decode(errors="replace")
+                    # 本次开了 include_usage 却被打回（400/422，或报错里点名这个字段）
+                    # → 视作网关不支持，交给上层降级重试（401/余额等真错误照常抛出）
+                    if with_usage and (r.status_code in (400, 422)
+                                       or "stream_options" in text):
+                        raise _UsageUnsupported(text[:200])
                    raise RuntimeError(f"模型 API HTTP {r.status_code}: {text[:300]}")
                async for line in r.aiter_lines():
                    if not line.startswith("data:"):
@@ -115,6 +151,37 @@ class Agent:
                    except json.JSONDecodeError:
                        continue

+    # ---------- token 用量 ----------
+    @staticmethod
+    def _read_usage(raw):
+        """把一次模型调用返回的 usage 规整为 {prompt, completion, total}；无效返回 None。"""
+        if not isinstance(raw, dict):
+            return None
+        try:
+            pt = int(raw.get("prompt_tokens") or 0)
+            ct = int(raw.get("completion_tokens") or 0)
+            tt = int(raw.get("total_tokens") or 0) or (pt + ct)
+        except (TypeError, ValueError):
+            return None
+        if not (pt or ct or tt):
+            return None
+        return {"prompt_tokens": pt, "completion_tokens": ct, "total_tokens": tt}
+
+    def _accumulate_usage(self, raw):
+        """把一次模型调用的 usage 累加进本轮总量，并回调 on_usage（累计值）。"""
+        u = self._read_usage(raw)
+        if not u:
+            return
+        self.usage["prompt_tokens"] += u["prompt_tokens"]
+        self.usage["completion_tokens"] += u["completion_tokens"]
+        self.usage["total_tokens"] += u["total_tokens"]
+        self.usage["calls"] += 1
+        if self.on_usage:
+            try:
+                self.on_usage(dict(self.usage))
+            except Exception:
+                pass
+
    # ---------- 工具执行 ----------
    async def _execute_tool(self, name, arguments):
        """执行 MCP 工具，返回 (文本结果, image_data_or_None)。"""
@@ -161,7 +228,7 @@ class Agent:
    # ---------- 主循环（流式） ----------
    async def run_stream(self, prompt: str, serial: str = "",
                         history=None, on_delta=None, on_tool=None,
-                         should_stop=None, extra_context=None):
+                         should_stop=None, extra_context=None, on_usage=None):
        """流式执行一轮指令，返回最终完整文本。

        history：上一轮的 [{"role": "user"|"assistant", "content": 文本}] 列表，
@@ -170,9 +237,15 @@ class Agent:
        on_tool(step)：工具调用完成（实时显示 MCP 步骤）
        should_stop：可调用 fn() -> bool，每轮模型调用前检查（用户中断用）
        extra_context：附加文本（经验记忆注入，放在 system prompt 末尾）
+        on_usage(usage)：每完成一次模型调用回调一次（累计值，见 self.usage）
+
+        本轮累计 token 用量同时留在 self.usage（调用方可直接读）。
        """
        self.on_delta = on_delta
        self.on_tool = on_tool
+        self.on_usage = on_usage
+        self.usage = {"prompt_tokens": 0, "completion_tokens": 0,
+                      "total_tokens": 0, "calls": 0}
        target = serial or self.s.default_serial
        sys_txt = SYSTEM_PROMPT
        if target:
@@ -193,9 +266,13 @@ class Agent:
            tool_acc = {}           # index -> {id, name, args}
            has_tool = False
            retried = False
+            call_usage = None       # 本次模型调用的 usage（末尾 chunk 带）
            while True:
+                call_usage = None   # 重试时丢弃上一次（未完成）的用量
                try:
                    async for chunk in self._chat_stream():
+                        if chunk.get("usage"):
+                            call_usage = chunk["usage"]
                        choice = (chunk.get("choices") or [{}])[0]
                        delta = choice.get("delta") or {}
                        text = delta.get("content")
@@ -228,6 +305,7 @@ class Agent:
                        continue
                    raise

+            self._accumulate_usage(call_usage)
            full_content = "".join(content_parts)

            if has_tool:
@@ -272,13 +350,17 @@ class Agent:
                                             "已完成的部分、当前设备状态、未能完成的原因与下一步建议。"
                                             "不要调用任何工具。"})
            parts = []
+            call_usage = None
            async for chunk in self._chat_stream():
+                if chunk.get("usage"):
+                    call_usage = chunk["usage"]
                delta = (chunk.get("choices") or [{}])[0].get("delta") or {}
                text = delta.get("content")
                if text:
                    parts.append(text)
                    if on_delta:
                        on_delta(text, "content")
+            self._accumulate_usage(call_usage)
            self.tools_schema = saved_tools
            summary = "".join(parts)
            return summary or "（已达步骤上限，模型未能生成总结）"
@@ -120,6 +120,11 @@ function pollRunState(){
           ? '将操作：' + document.getElementById('agent-target-select').value : '');
    }
    document.getElementById('btn-agent-send').disabled = running;
+    // 运行中同步 token（本窗口没订阅事件流时也能看到进度）
+    if(running && !_agentStream && r.usage && r.usage.total_tokens){
+      _liveUsage = r.usage;
+      updateSessionTokens();
+    }
    if(!running && _agentBusy){ setRunning(false); }   // 流异常丢失时复位
  });
 }
@@ -173,11 +178,91 @@ function newAssistantMsg(){
  clearEmpty();
  const div = document.createElement('div');
  div.className = 'agent-msg assistant';
-  div.innerHTML = '<div class="agent-toolcards"></div><div class="agent-text"></div>';
+  // 结构：工具卡片 → 可折叠推理链 → 正文（Markdown）→ token 用量脚注
+  div.innerHTML =
+      '<div class="agent-toolcards"></div>'
+    + '<details class="reasoning" style="display:none"><summary>💭 思考过程</summary>'
+    +   '<div class="reasoning-text"></div></details>'
+    + '<div class="agent-text"></div>'
+    + '<div class="agent-usage" style="display:none"></div>';
  chat.appendChild(div);
  scrollChat();
  return div;
 }
+
+// ---------- 推理链（可折叠） ----------
+function _appendReasoning(msgEl, text){
+  const box = msgEl.querySelector('.reasoning');
+  if(!box) return;
+  const body = box.querySelector('.reasoning-text');
+  body.textContent += text;
+  box.querySelector('summary').textContent =
+    '💭 思考过程（' + body.textContent.length + ' 字）';
+  box.style.display = 'block';
+  _bindReasoning(box);
+  if(!box.open) box.open = true;      // 流式思考时展开，正文开始时自动收起
+}
+// 用户手动点过 summary 后不再自动收起/展开（尊重手动状态）
+function _bindReasoning(box){
+  const sum = box.querySelector('summary');
+  if(sum && !sum.dataset.bound){
+    sum.dataset.bound = '1';
+    sum.addEventListener('click', ()=>{ box.dataset.touched = '1'; });
+  }
+}
+
+// ---------- 正文 Markdown 渲染（渲染器见 markdown.js） ----------
+function _renderMd(msgEl){
+  const el = msgEl.querySelector('.agent-text');
+  if(el) el.innerHTML = renderMarkdown(msgEl._md || '');
+}
+function _scheduleMd(msgEl){
+  if(msgEl._mdRaf) return;            // 流式增量按帧合并渲染，避免每个 token 重排
+  msgEl._mdRaf = requestAnimationFrame(()=>{
+    msgEl._mdRaf = 0;
+    _renderMd(msgEl);
+    scrollChat();
+  });
+}
+
+// ---------- token 用量 ----------
+let _convUsage = {};    // 当前会话历史累计（读会话时算）
+let _liveUsage = {};    // 本轮运行中累计（SSE usage 事件）
+function _fmtInt(n){ return String(n || 0).replace(/\B(?=(\d{3})+(?!\d))/g, ','); }
+function _usageSum(a, b){
+  const o = {prompt_tokens:0, completion_tokens:0, total_tokens:0, calls:0};
+  [a, b].forEach(u=>{
+    if(!u) return;
+    o.prompt_tokens     += (u.prompt_tokens || 0);
+    o.completion_tokens += (u.completion_tokens || 0);
+    o.total_tokens      += (u.total_tokens || 0);
+    o.calls             += (u.calls || 0);
+  });
+  return o;
+}
+// 单条消息脚注
+function renderUsage(msgEl, u){
+  const el = msgEl.querySelector('.agent-usage');
+  if(!el) return;
+  if(!u || !u.total_tokens){ el.style.display = 'none'; return; }
+  el.style.display = 'block';
+  el.title = '输入 ' + _fmtInt(u.prompt_tokens) + ' + 输出 ' + _fmtInt(u.completion_tokens)
+           + ' = ' + _fmtInt(u.total_tokens) + ' tokens，共 ' + (u.calls || 0) + ' 次模型调用';
+  el.textContent = '🪙 ' + _fmtInt(u.total_tokens) + ' tokens'
+                 + '（↑' + _fmtInt(u.prompt_tokens) + ' ↓' + _fmtInt(u.completion_tokens)
+                 + ' · ' + (u.calls || 0) + ' 次调用）';
+}
+// 顶栏「本会话累计」= 已落库历史 + 运行中本轮
+function updateSessionTokens(){
+  const el = document.getElementById('agent-token-total');
+  if(!el) return;
+  const t = _usageSum(_convUsage, _liveUsage);
+  if(!t.total_tokens){ el.textContent = ''; el.title = ''; return; }
+  el.textContent = '🪙 本会话 ' + _fmtInt(t.total_tokens) + ' tokens';
+  el.title = '本会话累计：输入 ' + _fmtInt(t.prompt_tokens)
+           + ' + 输出 ' + _fmtInt(t.completion_tokens)
+           + ' = ' + _fmtInt(t.total_tokens) + ' tokens，共 ' + t.calls + ' 次模型调用';
+}
 function clearEmpty(){
  const empty = document.querySelector('#agent-chat .agent-empty');
  if(empty) empty.remove();
@@ -197,6 +282,9 @@ function bindChatScroll(){
 }
 function clearAgentChat(){
  document.getElementById('agent-chat').innerHTML = '';
+  _convUsage = {};    // 换会话：token 累计重新算
+  _liveUsage = {};
+  updateSessionTokens();
 }

 // ================== 历史会话（DeepSeek 式：左侧列表，多会话持久化） ==================
@@ -293,15 +381,26 @@ function loadCurrentConvMessages(){
  apiGet('/api/agent/conversations/'+_currentConvId).then(r=>{
    if(!r||!r.ok)return;
    chat.innerHTML = '';
+    _convUsage = {};
+    _liveUsage = {};
    (r.messages||[]).forEach(m=>{
      const txt = (m.content||'').trim();
-      if(!txt) return;
-      if(m.role==='user'){ addUserMsg(txt); }
-      else{
+      if(m.role==='user'){ if(txt) addUserMsg(txt); return; }
+      if(!txt && !m.reasoning && !(m.usage && m.usage.total_tokens)) return;
      const div = newAssistantMsg();
-        div.querySelector('.agent-text').textContent = txt;
+      if(txt){ div._md = txt; _renderMd(div); }
+      if(m.reasoning){
+        _appendReasoning(div, m.reasoning);
+        const box = div.querySelector('.reasoning');
+        _bindReasoning(box);
+        box.open = false;                 // 历史消息默认折叠推理链
+      }
+      if(m.usage){
+        renderUsage(div, m.usage);
+        _convUsage = _usageSum(_convUsage, m.usage);
      }
    });
+    updateSessionTokens();
    if(!chat.children.length){
      chat.innerHTML = '<div class="agent-empty">新会话。给 AI 下达指令'
        + '（先选 🎯 目标设备）…</div>';
@@ -379,21 +478,29 @@ function listenStream(runId){
  es.addEventListener('delta', ev=>{
    if(!msgEl) msgEl = newAssistantMsg();
    const d = JSON.parse(ev.data);
-    const textEl = msgEl.querySelector('.agent-text');
    if(d.kind === 'reasoning'){
-      let r = msgEl.querySelector('.reasoning');
-      if(!r){
-        r = document.createElement('div');
-        r.className = 'reasoning';
-        msgEl.insertBefore(r, textEl);
-      }
-      r.textContent += d.text;
+      _appendReasoning(msgEl, d.text || '');
    }else{
-      textEl.textContent += d.text;
+      // 正文开始 → 收起推理链（用户手动开过的保持原样）
+      const r = msgEl.querySelector('.reasoning');
+      if(r && r.open && !r.dataset.touched) r.open = false;
+      msgEl._md = (msgEl._md || '') + (d.text || '');
+      msgEl._mdPending = false;
+      _scheduleMd(msgEl);
    }
    scrollChat();
  });

+  // 每次模型调用完成 → 实时刷新 token 计数（本轮累计）
+  es.addEventListener('usage', ev=>{
+    if(!msgEl) msgEl = newAssistantMsg();
+    let d = {};
+    try{ d = JSON.parse(ev.data) || {}; }catch(e){}
+    _liveUsage = d;
+    renderUsage(msgEl, d);
+    updateSessionTokens();
+  });
+
  es.addEventListener('step', ev=>{
    const d = JSON.parse(ev.data);
    followSerialFromArgs(d.args);
@@ -417,10 +524,16 @@ function listenStream(runId){

  es.addEventListener('done', ev=>{
    const d = JSON.parse(ev.data);
-    if(d.answer){
+    if(d.answer || d.usage || !msgEl){
      if(!msgEl) msgEl = newAssistantMsg();
-      msgEl.querySelector('.agent-text').textContent = d.answer;
+      if(d.answer){ msgEl._md = d.answer; _renderMd(msgEl); }
+      if(d.usage) renderUsage(msgEl, d.usage);
    }
+    // 本轮用量并入会话累计（脚注已展示，顶栏不该因此变小），再清空「运行中」
+    _convUsage = _usageSum(_convUsage, _liveUsage);
+    _liveUsage = {};
+    updateSessionTokens();
+    scrollChat();
    endRun();
    renderConvList();   // 落库已完成：刷新标题/时间/轮数
  });
@@ -432,6 +545,7 @@ function listenStream(runId){
    }catch(e){}
    if(!msgEl) msgEl = newAssistantMsg();
    msgEl.querySelector('.agent-text').textContent = '⚠ ' + _friendlyAgentError(msg);
+    _liveUsage = {};            // 本轮可能已花费 token，但结果无效——不并入会话累计
    endRun();
  });

@@ -0,0 +1,163 @@
+// 轻量 Markdown 渲染（AI 控制台回答用）——不引外部库/CDN（生产 220 在内网）。
+// 安全：**先 esc() 转义，再套标记**——模型输出里的原始 HTML 只会以文本显示，
+//       不会变成可执行标签。
+// 支持：标题 / 段落 / 换行 / 粗体 / 斜体 / 删除线 / 行内代码 / 围栏代码块 /
+//       有序与无序列表（含一层以上嵌套）/ 引用 / 表格 / 分隔线 / 链接。
+// 依赖：esc()（base.js，本文件须在其后加载）
+
+// 行内代码占位符（控制字符，正文几乎不可能出现）
+const _MD_PH = '\u0001';
+
+function _mdInline(s){
+  const codes = [];
+  // 行内代码先摘出，避免其中的 ** * ~~ 被继续当标记解析
+  s = s.replace(/`([^`]+)`/g, (m, c)=>{
+    codes.push(c);
+    return _MD_PH + (codes.length - 1) + _MD_PH;
+  });
+  s = s.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
+       .replace(/~~([^~]+)~~/g, '<del>$1</del>')
+       .replace(/(^|[^*])\*([^*\n]+)\*/g, '$1<em>$2</em>')
+       .replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g,
+                '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>');
+  return s.replace(new RegExp(_MD_PH + '(\\d+)' + _MD_PH, 'g'),
+                   (m, i)=>'<code>' + codes[+i] + '</code>');
+}
+
+// 表格行 → 单元格数组
+function _mdCells(line){
+  return line.trim().replace(/^\|/, '').replace(/\|$/, '')
+             .split('|').map(c=>c.trim());
+}
+
+// 列表项递归渲染（缩进 = 层级；同类标记合并，类型变了外层另起一个列表）
+function _mdList(items, out, idx, indent){
+  const ordered = items[idx].ordered;
+  const tag = ordered ? 'ol' : 'ul';
+  out.push('<' + tag + ' class="md-list">');
+  while(idx < items.length && items[idx].indent >= indent){
+    const it = items[idx];
+    if(it.indent > indent) break;               // 更深缩进块由外层另起列表（避免非法嵌套）
+    if(it.ordered !== ordered) break;           // 同级但标记类型变了 → 交回外层
+    out.push('<li>' + _mdInline(esc(it.text)));
+    if(idx + 1 < items.length && items[idx + 1].indent > indent){
+      idx = _mdList(items, out, idx + 1, items[idx + 1].indent);
+      out.push('</li>');
+      continue;
+    }
+    out.push('</li>');
+    idx++;
+  }
+  out.push('</' + tag + '>');
+  return idx;
+}
+
+// 主入口：Markdown 文本 → HTML 字符串
+function renderMarkdown(src){
+  const lines = String(src == null ? '' : src).replace(/\r\n?/g, '\n').split('\n');
+  const out = [];
+  let para = [];
+  let i = 0;
+
+  const flushPara = ()=>{
+    if(!para.length) return;
+    out.push('<p>' + para.map(l=>_mdInline(esc(l))).join('<br>') + '</p>');
+    para = [];
+  };
+
+  while(i < lines.length){
+    const ln = lines[i];
+    let m;
+
+    // 围栏代码块 ```lang … ```
+    if(/^\s*```/.test(ln)){
+      flushPara();
+      const body = [];
+      i++;
+      while(i < lines.length && !/^\s*```/.test(lines[i])){ body.push(lines[i]); i++; }
+      if(i < lines.length) i++;                 // 跳过结束围栏
+      out.push('<pre class="md-code"><code>' + esc(body.join('\n')) + '</code></pre>');
+      continue;
+    }
+
+    // 表格：表头行 + 分隔行（|---|---|）
+    if(/^\s*\|.*\|\s*$/.test(ln) && i + 1 < lines.length
+       && /^\s*\|[\s:|-]+\|\s*$/.test(lines[i + 1])){
+      flushPara();
+      const head = _mdCells(ln);
+      i += 2;
+      const rows = [];
+      while(i < lines.length && /^\s*\|.*\|\s*$/.test(lines[i])){
+        rows.push(_mdCells(lines[i])); i++;
+      }
+      out.push('<table class="md-table"><thead><tr>'
+        + head.map(c=>'<th>' + _mdInline(esc(c)) + '</th>').join('') + '</tr></thead><tbody>'
+        + rows.map(r=>'<tr>' + r.map(c=>'<td>' + _mdInline(esc(c)) + '</td>').join('')
+                     + '</tr>').join('')
+        + '</tbody></table>');
+      continue;
+    }
+
+    // 标题 #~######
+    m = ln.match(/^\s{0,3}(#{1,6})\s+(.*)$/);
+    if(m){
+      flushPara();
+      const lv = m[1].length;
+      out.push('<h' + lv + ' class="md-h">' + _mdInline(esc(m[2])) + '</h' + lv + '>');
+      i++;
+      continue;
+    }
+
+    // 分隔线 --- / *** / ___
+    if(/^\s{0,3}([-*_])\s*(\1\s*){2,}$/.test(ln)){
+      flushPara(); out.push('<hr>'); i++; continue;
+    }
+
+    // 引用 >
+    if(/^\s{0,3}>\s?/.test(ln)){
+      flushPara();
+      const body = [];
+      while(i < lines.length && /^\s{0,3}>\s?/.test(lines[i])){
+        body.push(lines[i].replace(/^\s{0,3}>\s?/, '')); i++;
+      }
+      out.push('<blockquote class="md-quote">'
+        + body.map(l=>_mdInline(esc(l))).join('<br>') + '</blockquote>');
+      continue;
+    }
+
+    // 列表（- * + / 1. 1)）——含缩进续行
+    m = ln.match(/^(\s*)([-*+]|\d+[.)])\s+(.*)$/);
+    if(m){
+      flushPara();
+      const items = [];
+      while(i < lines.length){
+        const mm = lines[i].match(/^(\s*)([-*+]|\d+[.)])\s+(.*)$/);
+        if(!mm) break;
+        items.push({indent: mm[1].replace(/\t/g, '  ').length,
+                    ordered: /\d/.test(mm[2]), text: mm[3]});
+        i++;
+        // 紧跟的纯缩进行算上一条的续行
+        while(i < lines.length && /^\s+\S/.test(lines[i])
+              && !/^\s*([-*+]|\d+[.)])\s+/.test(lines[i])){
+          items[items.length - 1].text += ' ' + lines[i].trim();
+          i++;
+        }
+      }
+      let k = 0;
+      while(k < items.length){
+        const n = _mdList(items, out, k, items[k].indent);
+        if(n <= k) break;                        // 防死循环
+        k = n;
+      }
+      continue;
+    }
+
+    // 空行 = 段落分隔
+    if(!ln.trim()){ flushPara(); i++; continue; }
+
+    para.push(ln);
+    i++;
+  }
+  flushPara();
+  return out.join('');
+}
@@ -445,6 +445,34 @@ function fmtParams(params){
  return parts.join('');
 }

+// 任务覆盖的设备：后端给 serial 清单（coverage），这里用实时状态标注在线/运行中
+function _jobCoverageHtml(j){
+  const cov=j.coverage||{}, serials=cov.serials||[];
+  const st={};
+  if(_statusData)for(const d of (_statusData.devices||[]))st[d.serial]=d;
+  if(!serials.length){
+    return '<div class="job-cov"><span class="kv">覆盖设备 0 台</span>'
+      +'<span class="cov-note">该目标下暂无可调度设备（检查设备池/分组）</span></div>';
+  }
+  let onlineN=0,busyN=0;
+  const chips=serials.map(s=>{
+    const d=st[s]||{};
+    const online=!!d.present;
+    const busy=(d.worker_status==='running'||d.worker_status==='connecting');
+    if(online)onlineN++;
+    if(busy)busyN++;
+    const cls=busy?'running':(online?'online':'offline');
+    const title=s+(d.model?' · '+d.model:'')
+      +(busy?' · 任务中：'+(d.task_job||''):'')
+      +(online?'':' · 离线或不在设备池');
+    return '<span class="cov-chip '+cls+'" title="'+esc(title)+'">'
+      +esc(s.replace(/:5555$/,''))+(busy?' ⏳':'')+(online?'':' ✕')+'</span>';
+  }).join('');
+  return '<div class="job-cov"><span class="kv">覆盖 '+serials.length+' 台 · 在线 '+onlineN
+    +(busyN?' · 运行中 '+busyN:'')+'</span>'
+    +'<div class="cov-chips">'+chips+'</div></div>';
+}
+
 function renderJobCards(){
  const jobs=_jobsData||[];
  const running={};
@@ -470,12 +498,11 @@ function renderJobCards(){
        '<span class="kv">调度:'+esc(sched)+'</span>'+
        '<span class="kv">重试:'+esc(retry)+'</span></div>'+
        '<div style="margin-top:4px">'+fmtParams(j.params)+'</div>'+
+        _jobCoverageHtml(j)+
      '</div>'+
      '<div class="job-actions">'+
-        '<button class="btn btn-primary btn-xs" onclick="apiAction(\'/api/jobs/'+j.id+'/run\')">立即执行</button>'+
-        '<button class="btn btn-xs" onclick="apiAction(\'/api/jobs/'+j.id+'/toggle\',{enabled:'+(!j.enabled)+'})">'+(j.enabled?'停用':'启用')+'</button>'+
-        '<button class="btn btn-xs" onclick="openTaskModal(\''+j.id+'\')">编辑</button>'+
-        '<button class="btn btn-danger btn-xs" onclick="deleteTask(\''+j.id+'\')">删除</button>'+
+        '<button class="btn btn-primary btn-xs" onclick="apiAction(\'/api/jobs/'+j.id+'/run\')">执行任务</button>'+
+        '<button class="btn btn-xs" onclick="apiAction(\'/api/jobs/'+j.id+'/toggle\',{enabled:'+(!j.enabled)+'})">'+(j.enabled?'停用任务':'启用任务')+'</button>'+
      '</div>'+
    '</div>';
  }).join(''):'<div class="empty">暂无任务，到"任务"Tab 新建</div>';
@@ -69,7 +69,7 @@ function openTaskModal(jobId){
  // 任务编辑器含步骤编辑，加宽弹窗；关闭时在 closeModal 移除
  document.getElementById('modal-box').classList.add('wide-modal');

-  const j=job||{name:'',task_type:'douyin_nurture',enabled:true,target:{mode:'all'},params:{},schedule:{mode:'once'},retry:{max_attempts:1,delay:60}};
+  const j=job||{name:'',task_type:'generic_steps',enabled:true,target:{mode:'all'},params:{},schedule:{mode:'once'},retry:{max_attempts:1,delay:60}};
  const tt=_taskTypes.map(t=>'<option value="'+t.task_type+'"'+(t.task_type===j.task_type?' selected':'')+'>'+esc(t.name)+'</option>').join('');
  const gl=_groupsList.map(g=>'<option value="'+g.name+'"'+(g.name===j.target.group_name?' selected':'')+'>'+esc(g.name)+'</option>').join('');
  const dl=_devicesList.map(s=>'<option value="'+s+'"'+(s===j.target.serial?' selected':'')+'>'+esc(s)+'</option>').join('');
@@ -88,7 +88,7 @@ function openTaskModal(jobId){

  document.getElementById('modal-body').innerHTML=
    '<div class="form-row">'+
-      '<div class="form-group"><label>任务名</label><input type="text" class="form-control" id="f-name" value="'+esc(j.name)+'" placeholder="如：抖音养号-上午"></div>'+
+      '<div class="form-group"><label>任务名</label><input type="text" class="form-control" id="f-name" value="'+esc(j.name)+'" placeholder="如：刷视频-上午"></div>'+
      '<div class="form-group"><label>任务类型</label><select class="form-control" id="f-task_type" onchange="onTaskTypeChange()">'+tt+'</select></div>'+
    '</div>'+
    '<div class="form-group form-check"><input type="checkbox" id="f-enabled" '+(j.enabled?'checked':'')+'><label for="f-enabled">启用此任务</label></div>'+
@@ -7,7 +7,7 @@
 from .base import BaseTask, register_task, list_task_types, get_task_class

 # 导入所有任务包，触发 @register_task 注册
-from .douyin import task  # noqa: F401
+# 当前只有一个任务类型：generic_steps（通用步骤，前端步骤编辑器编排）
 from .generic import task  # noqa: F401

 __all__ = ["BaseTask", "register_task", "list_task_types", "get_task_class"]
@@ -12,7 +12,7 @@
        base.py       — 本任务的操作基类 + 注册器
        xxx.py        — 具体操作

-新增任务步骤（照着 tasks/douyin/ 抄即可）：
+新增任务步骤（照着 tasks/generic/ 抄即可）：

  1. 在 tasks/ 下新建 my_task/ 子包（文件夹 + __init__.py）
  2. 在 my_task/task.py 顶部写默认参数：
@@ -1,9 +0,0 @@
-"""抖音养号任务包。
-
-本包自包含：任务定义（task.py）+ 抖音专属操作（actions/）。
-抖音的点赞/评论 xpath 只适用于抖音，不放全局，避免和其他任务混淆。
-
-加新抖音操作：在 actions/ 下建 .py，继承本包 BaseAction + @register_action，
-在 actions/__init__.py import。
-"""
-from . import task  # noqa: F401  触发 @register_task 注册抖音任务
@@ -1,21 +0,0 @@
-"""抖音操作注册包。import 触发各操作注册。
-
-加新抖音操作：新建 xxx.py，在下面加一行 from . import xxx。
-注意：必须先从 base 导入 ACTIONS，再导入各操作模块，否则循环导入。
-"""
-# 先初始化注册表（base.py 里定义了 ACTIONS = create_action_registry()）
-from .base import (
-    BaseAction, register_action, create_action_registry,
-    list_actions, get_action, should_trigger,
-    ACTIONS,
-    list_action_types, get_action_class,
-)
-
-# 再导入各操作模块，触发 @register_action(ACTIONS) 注册
-from . import like  # noqa: F401
-
-__all__ = [
-    "BaseAction", "register_action", "create_action_registry",
-    "list_actions", "get_action", "should_trigger",
-    "ACTIONS", "list_action_types", "get_action_class",
-]
@@ -1,51 +0,0 @@
-"""抖音操作基类与注册机制。
-
-操作 = 抖音养号主循环里某个时机执行的一次具体行为（点赞/评论/关注等）。
-这里的注册表只对抖音任务生效，其他任务有自己的 actions 包。
-
-设计：抖音的 ACTIONS 注册表是独立的 dict，用 core.actions 的
-register_action(ACTIONS) 装饰器注册，和全局/其他 app 互不污染。
-
-新增抖音操作步骤（照着 like.py 抄）：
-
-  1. 在 tasks/douyin/actions/ 下新建 my_action.py
-  2. 写一个 BaseAction 子类，用 @register_action 装饰，实现 execute：
-
-       from core.actions import BaseAction, register_action, should_trigger
-       from . import ACTIONS  # 本任务注册表
-
-       @register_action(ACTIONS)
-       class MyAction(BaseAction):
-           action_type = "my_action"
-           name = "我的操作"
-           description = "做什么"
-           default_params = {"rate": 0.5}
-
-           def execute(self, d, params, worker):
-               if not should_trigger(params["rate"]):
-                   return False
-               # ... 用 d(xpath=...) / d(text=...) 操作
-               return True
-
-  3. 在 tasks/douyin/actions/__init__.py 加一行：from . import my_action
-
-  做完前端自动出现该操作的可勾选项。
-"""
-from core.actions import (
-    BaseAction, register_action, create_action_registry,
-    list_actions, get_action, should_trigger,
-)
-
-# 抖音专属操作注册表（独立 dict，不污染其他 app）
-ACTIONS = create_action_registry()
-
-
-# 兼容旧导入：tasks/douyin/actions/__init__.py 原来从这里导出
-def list_action_types():
-    """返回所有已注册抖音操作的元信息（供前端展示）。"""
-    return list_actions(ACTIONS)
-
-
-def get_action_class(action_type):
-    """按 action_type 取抖音操作类。"""
-    return get_action(ACTIONS, action_type)
@@ -1,108 +0,0 @@
-"""抖音点赞操作。
-
-两种方式：
-  by_element   — 用 xpath 找右侧红心按钮点击（相对定位，不依赖视频卡片序号）
-  double_click — 双击屏幕中央（需明确选择此方式，抖音"双击点赞"手势）
-
-by_element 找不到点赞按钮时**跳过本次，不点屏幕**（避免直播/无按钮页误触）。
-要适配新版本抖音：用 weditor 重新抓当前界面，调整下面定位逻辑。
-"""
-from core.actions import BaseAction, register_action, should_trigger
-from core.logger import get_logger
-from . import ACTIONS
-
-_log = get_logger("action.like")
-
-
-@register_action(ACTIONS)
-class LikeAction(BaseAction):
-    action_type = "like"
-    name = "点赞"
-    description = "看完视频后随机点赞（找红心按钮，找不到回退双击）"
-    default_params = {
-        "rate": 0.3,                 # 触发概率 0~1
-        "method": "by_element",      # by_element=找红心 | double_click=双击屏幕
-    }
-
-    def execute(self, d, params, worker):
-        rate = float(params.get("rate", 0.3))
-        if not should_trigger(rate):
-            return False
-        method = params.get("method", "by_element")
-        if method == "by_element":
-            if self._like_by_element(d):
-                worker.set_action("点赞(红心)")
-                return True
-            # 找不到点赞按钮：跳过本次，不点屏幕，避免误触（如直播/无点赞按钮的页面）
-            worker.set_action("点赞(未找到，跳过)")
-            return False
-        # 仅在明确选择 double_click 方式时才双击屏幕
-        ok = self._double_click_center(d)
-        if ok:
-            worker.set_action("点赞(双击)")
-        return ok
-
-    @staticmethod
-    def _like_by_element(d):
-        """找右侧操作栏红心按钮点击，成功返回 True。
-
-        定位优先级：description 精确 → descriptionContains 模糊 → resourceId → xpath
-        每种方式找到即点即返回，找不到继续下一种。全程记日志。
-        """
-        # 方式1：description 精确匹配（最稳，不依赖结构）
-        for desc in ("点赞", "未点赞", "like"):
-            el = d(description=desc)
-            if el.exists:
-                el.click()
-                _log.info(f"like 命中 description={desc}")
-                return True
-        # 方式2：descriptionContains 模糊匹配（适配不同版本文案）
-        for kw in ("赞", "like"):
-            el = d(descriptionContains=kw)
-            if el.exists:
-                el.click()
-                _log.info(f"like 命中 descriptionContains={kw}")
-                return True
-        # 方式3：resourceId 列表（扩充候选，覆盖更多抖音版本）
-        for rid in ("com.ss.android.ugc.aweme:id/aky",
-                    "com.ss.android.ugc.aweme:id/d-like-view-icon",
-                    "com.ss.android.ugc.aweme:id/h3r",
-                    "com.ss.android.ugc.aweme:id/dfz",
-                    "com.ss.android.ugc.aweme:id/c5w"):
-            el = d(resourceId=rid)
-            if el.exists:
-                el.click()
-                _log.info(f"like 命中 resourceId={rid}")
-                return True
-        # 方式4：xpath 相对定位——右侧操作栏 LinearLayout 的第一个 ImageView
-        # 定位思路：ViewPager 下当前 FrameLayout 里的 LinearLayout，
-        # 取其直接子 FrameLayout 里的第一个 ImageView（点赞在操作栏最上方）
-        try:
-            el = d.xpath(
-                '//androidx.viewpager.widget.ViewPager'
-                '/android.widget.FrameLayout'
-                '/com.bytedance.highperformanceview.layout.MeasureOnceRelativeLayout2'
-                '/com.bytedance.highperformanceview.layout.MeasureOnceRelativeLayout2'
-                '/android.widget.LinearLayout/android.widget.FrameLayout[2]'
-                '/android.widget.LinearLayout/android.widget.FrameLayout[1]'
-                '/android.widget.FrameLayout[1]/android.widget.ImageView'
-            )
-            if el.exists:
-                el.click()
-                _log.info("like 命中 xpath")
-                return True
-        except Exception as e:
-            _log.warning(f"like xpath 异常: {e}")
-        _log.info("like_by_element 全部失败，准备回退双击")
-        return False
-
-    @staticmethod
-    def _double_click_center(d):
-        """双击屏幕中央点赞。按屏幕尺寸算坐标，适配不同分辨率。"""
-        try:
-            info = d.info
-            w, h = info["displayWidth"], info["displayHeight"]
-            d.double_click(int(w * 0.5), int(h * 0.5))
-            return True
-        except Exception:
-            return False
@@ -1,269 +0,0 @@
-"""抖音养号任务定义。
-
-本文件自包含所有抖音养号参数（观看、滑动、操作等），不依赖 core 的业务配置。
-抖音专属操作（点赞/评论）在 actions/ 子包里，xpath 只适用于抖音。
-
-修改养号行为：改下面 DEFAULT_PARAMS 默认值，或通过前端任务参数覆盖。
-修改养号逻辑：改 DouyinNurtureWorker.run_task。
-加新抖音操作：在 actions/ 下建 .py，继承 BaseAction + @register_action。
-"""
-import time
-import random
-
-from tasks.base import BaseTask, register_task
-from .actions import list_action_types, get_action_class
-from core.device_worker import BaseWorker, _update_status
-from core.u2_helper import ensure_app_running, wait_for_app_home
-from core.logger import get_logger
-
-_log = get_logger("task.douyin")
-
-
-# ================== 抖音养号参数（本任务专属，写在这里） ==================
-DOUYIN_PKG = "com.ss.android.ugc.aweme"
-
-DEFAULT_PARAMS = {
-    # 观看
-    "watch_count": 80,        # 观看视频数量（0=不限数量，仅按 max_duration 终止）
-    "watch_min": 5.0,         # 单个视频最短观看秒数
-    "watch_max": 35.0,        # 单个视频最长观看秒数
-    # 运行时长终止（通用，0=不限时，按 watch_count 终止）
-    # 两个条件哪个先到就停；都为 0 则永不停止（需手动停止）
-    "max_duration": 0,        # 最大运行时长（秒），如 1800=30分钟，0=不限时
-    # 滑动
-    "swipe_min": 0.25,        # 上滑手势最短时长(秒)
-    "swipe_max": 0.50,        # 上滑手势最长时长(秒)
-    "gap_min": 1.0,           # 视频间隔最短秒数
-    "gap_max": 3.0,           # 视频间隔最长秒数
-    # 操作（每个操作有 enabled 开关 + 自身参数）
-    "actions": {
-        "like": {
-            "enabled": True,
-            "params": {"rate": 0.3, "method": "by_element"},
-        },
-    },
-}
-
-
-class DouyinNurtureWorker(BaseWorker):
-    """抖音养号 worker：看视频 + 按配置执行操作（点赞/评论等），被退出自动重连。
-
-    只需实现 run_task(d)，STF 占用/释放、u2 连接、异常、状态上报由基类处理。
-    操作参数优先级：任务 params.actions > 本文件 DEFAULT_PARAMS.actions。
-    """
-
-    def __init__(self, serial, params=None):
-        super().__init__(serial, params)
-        p = {**DEFAULT_PARAMS, **(self.params or {})}
-        self.watch_count = int(p["watch_count"])
-        self.watch_min = float(p["watch_min"])
-        self.watch_max = float(p["watch_max"])
-        # 通用运行时长终止（0=不限时）
-        self.max_duration = int(p.get("max_duration", 0))
-        self.swipe_min = float(p["swipe_min"])
-        self.swipe_max = float(p["swipe_max"])
-        self.gap_min = float(p["gap_min"])
-        self.gap_max = float(p["gap_max"])
-        # 操作配置：{action_type: {"enabled":bool, "params":{...}}}
-        self.actions_cfg = p.get("actions", {})
-        # 实例化所有启用的操作
-        self._actions = []
-        for atype, cfg in self.actions_cfg.items():
-            if not cfg.get("enabled"):
-                continue
-            cls = get_action_class(atype)
-            if cls:
-                self._actions.append(cls())
-        # 启动日志：打印终止条件 + 启用的 action，便于排查
-        stop_conds = []
-        if self.watch_count > 0:
-            stop_conds.append(f"数量={self.watch_count}")
-        if self.max_duration > 0:
-            stop_conds.append(f"时长={self.max_duration}s")
-        if not stop_conds:
-            stop_conds.append("无（需手动停止）")
-        _log.info(f"[{serial}] 终止条件: {', '.join(stop_conds)}")
-        if self._actions:
-            summary = ", ".join(
-                f"{a.action_type}(rate={self.actions_cfg.get(a.action_type, {}).get('params', {}).get('rate', '?')})"
-                for a in self._actions
-            )
-            _log.info(f"[{serial}] 启用操作: {summary}")
-        else:
-            _log.warning(f"[{serial}] 未启用任何操作，整个任务期间不会执行点赞")
-
-    def run_task(self, d):
-        """抖音养号主逻辑。d 是 u2.Device，已由基类连好。
-
-        终止条件（哪个先到就停）：
-          - watch_count > 0：看完指定数量视频
-          - max_duration > 0：达到最大运行时长
-          - 两者都为 0：永不停止，需手动停止
-        """
-        def is_home(d):
-            return (d(descriptionContains="拍摄").exists
-                    or d(descriptionContains="首页").exists)
-
-        # 启动运行时长计时（基类通用方法）
-        self._start_timer()
-
-        d.app_start(DOUYIN_PKG, wait=True)
-        if not wait_for_app_home(d, DOUYIN_PKG, is_home, timeout=40):
-            self.set_action("首页加载超时，继续尝试")
-
-        watched = 0
-        action_counts = {a.action_type: 0 for a in self._actions}
-        # 初始化通用进度上报
-        # total=0 时前端不显示百分比，只显示已看数量 + 运行时长
-        total = self.watch_count if self.watch_count > 0 else 0
-        self.set_progress(done=0, total=total, unit="视频",
-                          action_counts=action_counts)
-        while not self.stopped():
-            # 终止条件检查
-            if self.watch_count > 0 and watched >= self.watch_count:
-                break
-            if self.is_time_up():
-                _log.info(f"[{self.serial}] 达到最大运行时长 {self.max_duration}s，停止")
-                break
-
-            if not ensure_app_running(d, DOUYIN_PKG):
-                _update_status(self.serial, status="error",
-                               last_error="抖音连续重启失败，放弃该设备")
-                return
-            _update_status(self.serial, douyin_running=True, last_error="")
-
-            watch = random.uniform(self.watch_min, self.watch_max)
-            # 动作描述包含运行时长，便于前端观察
-            elapsed = self.elapsed()
-            time_info = f"，已运行 {elapsed//60}m{elapsed%60}s" if elapsed > 0 else ""
-            self.set_action(f"观看视频 {watched+1}，{watch:.0f}s{time_info}")
-            time.sleep(watch)
-
-            # 检测当前是否为可操作的正常视频页（有右侧操作栏 = 点赞/评论按钮）
-            # 营销广告、直播、异常页通常没有这些元素，直接滑过去不做操作
-            is_normal = self._is_normal_video(d)
-            if is_normal:
-                # 正常视频：执行所有启用的操作（看完视频后、滑动前）
-                if not self._actions:
-                    _log.info(f"[{self.serial}] 视频{watched+1}: 正常视频但无启用操作")
-                for action in self._actions:
-                    if self.stopped():
-                        break
-                    cfg = self.actions_cfg.get(action.action_type, {})
-                    params = {**action.default_params, **cfg.get("params", {})}
-                    rate = params.get("rate", "?")
-                    try:
-                        ok = action.execute(d, params, self)
-                        _log.info(f"[{self.serial}] 视频{watched+1}: {action.action_type} "
-                                  f"rate={rate} execute={ok}")
-                        if ok:
-                            action_counts[action.action_type] += 1
-                            time.sleep(random.uniform(0.5, 1.5))
-                    except Exception as e:
-                        _log.error(f"[{self.serial}] 视频{watched+1}: 操作 {action.action_type} "
-                                   f"异常: {e}")
-            else:
-                self.set_action(f"跳过广告/直播 {watched+1}")
-                _log.info(f"[{self.serial}] 视频{watched+1}: 非正常视频页，跳过操作")
-
-            if self.stopped():
-                break
-            d.swipe(500, 1000, 500, 300, random.uniform(self.swipe_min, self.swipe_max))
-            time.sleep(random.uniform(self.gap_min, self.gap_max))
-            watched += 1
-            # 上报通用进度（含运行时长，前端展示）
-            elapsed = self.elapsed()
-            self.set_progress(done=watched, total=total, unit="视频",
-                              action_counts=dict(action_counts),
-                              elapsed=elapsed)
-
-        # 终止原因汇总
-        stop_reason = ""
-        if self.stopped():
-            stop_reason = "（手动停止）"
-        elif self.is_time_up():
-            stop_reason = f"（达到时长 {self.max_duration}s）"
-        elif self.watch_count > 0 and watched >= self.watch_count:
-            stop_reason = f"（达到数量 {self.watch_count}）"
-        summary = f"完成 {watched} 个视频" + "".join(
-            f"，{k} {v}次" for k, v in action_counts.items() if v
-        ) + stop_reason
-        _update_status(self.serial, douyin_running=False, current_action=summary)
-
-    @staticmethod
-    def _is_normal_video(d):
-        """判断当前是否为可操作的正常视频页。
-
-        正常视频页右侧有操作栏（点赞/评论/分享按钮）。
-        营销广告、直播、异常页通常没有这些元素 → 返回 False，直接滑过去。
-        检测任一特征元素存在即认为是正常视频页。
-
-        定位优先级：description 精确 → descriptionContains 模糊 → resourceId 列表 → 兜底
-        每次返回 False 时记日志，便于定位"为什么操作没执行"。
-        """
-        try:
-            # 1. description 精确匹配（最稳）
-            for desc in ("点赞", "未点赞", "评论", "未评论"):
-                if d(description=desc).exists:
-                    return True
-            # 2. descriptionContains 模糊匹配（适配不同版本文案）
-            for kw in ("赞", "评论"):
-                if d(descriptionContains=kw).exists:
-                    return True
-            # 3. resourceId 列表（扩充候选，覆盖更多抖音版本）
-            for rid in ("com.ss.android.ugc.aweme:id/aky",
-                        "com.ss.android.ugc.aweme:id/akq",
-                        "com.ss.android.ugc.aweme:id/d-like-view-icon",
-                        "com.ss.android.ugc.aweme:id/d-comment-view-icon",
-                        "com.ss.android.ugc.aweme:id/h3r"):
-                if d(resourceId=rid).exists:
-                    return True
-            # 所有特征元素都没找到 → 非正常视频页（广告/直播/异常）
-            _log.info(f"_is_normal_video=False: 未找到点赞/评论特征元素")
-            return False
-        except Exception as e:
-            _log.warning(f"_is_normal_video 异常: {e}")
-            return False
-
-
-@register_task
-class DouyinNurtureTask(BaseTask):
-    """抖音养号：看视频 + 按配置执行操作（点赞/评论等），被退出自动重连。"""
-    task_type = "douyin_nurture"
-    name = "抖音养号"
-    description = "自动观看抖音视频，按配置执行点赞/评论等操作，被退出自动重连"
-    default_params = dict(DEFAULT_PARAMS)
-
-    @classmethod
-    def list_action_types(cls):
-        """返回本任务支持的抖音操作列表。"""
-        return list_action_types()
-
-    @classmethod
-    def get_action_class(cls, action_type):
-        """按 action_type 取抖音操作类。"""
-        return get_action_class(action_type)
-
-    def create_worker(self, serial, params):
-        merged = {**DEFAULT_PARAMS, **(params or {})}
-        # actions 字段深合并（参数级，保留前端没传的操作默认值）
-        # 确保即使前端只传 actions.like.enabled，like.params.rate 也能拿到默认 0.3
-        default_actions = DEFAULT_PARAMS["actions"]
-        merged_actions = params.get("actions", {}) if params else {}
-        for atype, dflt in default_actions.items():
-            if atype not in merged_actions:
-                # 前端完全没传这个操作 → 用默认
-                merged_actions[atype] = dflt
-            else:
-                # 前端传了 → 参数级深合并
-                cfg = merged_actions[atype]
-                merged_cfg = {}
-                for k in ("enabled", "params"):
-                    merged_cfg[k] = cfg.get(k, dflt.get(k))
-                # params 再深合并一层
-                merged_params = dict(dflt.get("params", {}))
-                merged_params.update(cfg.get("params", {}))
-                merged_cfg["params"] = merged_params
-                merged_actions[atype] = merged_cfg
-        merged["actions"] = merged_actions
-        return DouyinNurtureWorker(serial, params=merged)
@@ -1,6 +1,6 @@
 """通用步骤任务包。

 通过前端步骤编辑器编排任务流程，worker 按 steps 顺序执行。
-与 douyin_nurture 共存，互不影响。
+当前平台唯一的任务类型（task_type=generic_steps）。
 """
 from . import task  # noqa: F401  触发 @register_task 注册通用步骤任务
@@ -104,21 +104,8 @@ STEP_TYPES = [

 DEFAULT_PARAMS = {
    "max_duration": 0,          # 最大运行时长（秒），0=不限时
-    "steps": [                  # 默认示例：打开抖音→循环(看视频→滑动)
-        {
-            "id": "step_1", "type": "open_app", "label": "打开抖音",
-            "params": {"package": "com.ss.android.ugc.aweme", "wait_home": True, "home_feature": "拍摄"},
-        },
-        {
-            "id": "step_2", "type": "loop", "label": "循环看视频",
-            "params": {"max_iterations": 20, "children": [
-                {"id": "step_2_1", "type": "wait", "label": "观看视频",
-                 "params": {"min": 5.0, "max": 35.0}},
-                {"id": "step_2_2", "type": "swipe", "label": "上滑下一个",
-                 "params": {"direction": "up", "duration_min": 0.25, "duration_max": 0.50}},
-            ]},
-        },
-    ],
+    # 注意：**没有默认 steps**。步骤由前端步骤编辑器编排产出，新建任务时从零开始拖；
+    # 缺 steps 的任务执行时会明确报错（见 run_task），不会静默空跑。
 }


@@ -157,6 +144,10 @@ class GenericStepsWorker(BaseWorker):

    def run_task(self, d):
        """按 steps 顺序执行。loop 步骤递归执行其 children。"""
+        if not self.steps:
+            # 任务没配步骤（DEFAULT_PARAMS 不含默认步骤，步骤只能由编辑器产出）：
+            # 明确报错而不是"跑完 0 步"当成功——设备表/任务页会显示该错误
+            raise ValueError("通用步骤任务没有可执行步骤：请在「任务」页编辑该任务并添加步骤")
        self._start_timer()
        self.set_action("开始执行步骤链")
        self.set_progress(done=0, total=0, unit="操作",
@@ -167,7 +158,7 @@ class GenericStepsWorker(BaseWorker):
        finally:
            elapsed = self.elapsed()
            summary = f"完成步骤链，运行 {elapsed//60}m{elapsed%60}s"
-            _update_status(self.serial, douyin_running=False, current_action=summary)
+            _update_status(self.serial, current_action=summary)

    def _exec_steps(self, d, steps, depth=0):
        """执行步骤列表。depth 防止无限嵌套。"""
@@ -169,6 +169,14 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 .job-card .job-body{font-size:12px;color:var(--text-muted);margin-bottom:11px;line-height:1.65}
 .job-card .job-body .kv{display:inline-block;background:#faf9f5;border:1px solid var(--border);border-radius:6px;padding:1px 7px;margin:2px 3px 0 0;font-family:var(--mono);font-size:11px}
 .job-card .job-actions{display:flex;gap:6px;flex-wrap:wrap}
+/* 任务覆盖的设备（监控页任务概况） */
+.job-cov{margin-top:6px}
+.cov-chips{display:flex;flex-wrap:wrap;gap:4px;margin-top:4px}
+.cov-chip{font-family:var(--mono);font-size:11px;padding:1px 7px;border-radius:9px;border:1px solid;white-space:nowrap;cursor:default}
+.cov-chip.online{color:#0e7490;background:#e0f2fe;border-color:#bae6fd}
+.cov-chip.running{color:#b45309;background:#fef3c7;border-color:#fde68a}
+.cov-chip.offline{color:#9ca3af;background:#f3f4f6;border-color:#e5e7eb;text-decoration:line-through}
+.cov-note{font-size:11px;color:#94a3b8;margin-left:4px}

 /* 空状态 / 辅助文本 */
 .empty{text-align:center;padding:42px;color:var(--text-light);font-size:13px}
@@ -338,6 +346,32 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 .agent-msg.user{align-self:flex-end;background:#0e7490;color:#fff;border-bottom-right-radius:3px}
 .agent-msg.assistant{align-self:flex-start;background:#fff;border:1px solid #e5e7eb;border-bottom-left-radius:3px;color:#1f2937;box-shadow:0 1px 2px rgba(0,0,0,.04)}
 .agent-msg.assistant .reasoning{color:#6b7280;font-size:12.5px;border-left:3px solid #d1d5db;padding-left:10px;margin:8px 0}
+/* 推理链（可折叠） */
+.agent-msg.assistant details.reasoning{margin:6px 0 10px;background:#f9fafb;border:1px solid #eef0f3;border-radius:9px;padding:6px 10px}
+.agent-msg.assistant details.reasoning>summary{cursor:pointer;font-size:12px;color:#6b7280;font-weight:600;user-select:none;outline:none}
+.agent-msg.assistant details.reasoning>summary:hover{color:#0e7490}
+.agent-msg.assistant .reasoning-text{margin-top:6px;color:#6b7280;font-size:12.5px;line-height:1.7;white-space:pre-wrap;word-break:break-word;max-height:320px;overflow-y:auto}
+/* token 用量脚注 */
+.agent-usage{margin-top:8px;padding-top:7px;border-top:1px dashed #e5e7eb;font-size:11px;color:#9ca3af;font-family:var(--mono)}
+.agent-token-total{margin-left:8px;font-size:11px;color:#6b7280;font-family:var(--mono);background:#f3f4f6;padding:2px 8px;border-radius:10px}
+/* 正文 Markdown（.agent-msg 默认 pre-wrap，正文改由标签排版） */
+.agent-msg.assistant .agent-text{white-space:normal}
+.agent-text p{margin:0 0 8px}
+.agent-text p:last-child{margin-bottom:0}
+.agent-text .md-h{margin:12px 0 6px;font-weight:700;line-height:1.4}
+.agent-text h1.md-h{font-size:17px}.agent-text h2.md-h{font-size:16px}.agent-text h3.md-h{font-size:15px}
+.agent-text h4.md-h,.agent-text h5.md-h,.agent-text h6.md-h{font-size:13.5px}
+.agent-text .md-list{margin:0 0 8px;padding-left:22px}
+.agent-text .md-list li{margin:2px 0}
+.agent-text .md-code{background:#0f172a;color:#e2e8f0;border-radius:8px;padding:9px 12px;overflow-x:auto;font-size:12px;font-family:var(--mono);margin:8px 0;white-space:pre}
+.agent-text code{background:#f1f5f9;border:1px solid #e2e8f0;border-radius:4px;padding:0 4px;font-size:12px;font-family:var(--mono);color:#0f766e}
+.agent-text .md-code code{background:none;border:none;color:inherit;padding:0}
+.agent-text .md-quote{margin:8px 0;padding:2px 0 2px 11px;border-left:3px solid #d1d5db;color:#4b5563}
+.agent-text .md-table{border-collapse:collapse;margin:8px 0;font-size:12.5px;display:block;overflow-x:auto;max-width:100%}
+.agent-text .md-table th,.agent-text .md-table td{border:1px solid #e5e7eb;padding:5px 10px;text-align:left;white-space:nowrap}
+.agent-text .md-table th{background:#f3f4f6;font-weight:600}
+.agent-text hr{border:none;border-top:1px solid #e5e7eb;margin:12px 0}
+.agent-text a{color:#0e7490;text-decoration:underline;word-break:break-all}
 .agent-toolcards{display:flex;flex-direction:column;gap:5px;margin-bottom:9px}
 .agent-toolcard{display:flex;align-items:flex-start;gap:8px;background:#f3f4f6;border:1px solid #e5e7eb;border-radius:9px;padding:6px 11px;font-size:12px;font-family:var(--mono);color:#374151;flex-wrap:wrap}
 .agent-toolcard .dot{width:7px;height:7px;border-radius:50%;background:#10b981;flex:none;margin-top:5px}
@@ -476,7 +510,7 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 <div id="tab-agent" class="tab-panel">
  <div class="agent-shell">
    <div class="agent-topbar">
-      <div class="agent-title">🤖 AI 控制台<span id="agent-model-tag" class="agent-model-tag"></span></div>
+      <div class="agent-title">🤖 AI 控制台<span id="agent-model-tag" class="agent-model-tag"></span><span id="agent-token-total" class="agent-token-total" title=""></span></div>
      <div class="agent-top-actions">
        <span id="agent-running-tag" class="agent-running-tag" style="display:none">● 运行中</span>
        <button class="btn btn-xs" onclick="openExpLib()" title="查看/管理自进化经验库（每日 AI 巡检建议，删除需确认）">🧠 经验库</button>
@@ -885,9 +919,10 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
  <!-- 子分栏 1：数据备份 -->
  <div class="sub-panel active" id="system-sub-backup">
    <div class="help">
-      <b>导出</b>当前系统数据为 zip：含 <code>users.db</code>（用户 / 任务计划 / 设备分组 / 自定义动作 /
-      设备池 / AI 会话 / 经验库等全部表，SQLite 在线一致快照）+ 可选的 <code>apks/</code> 应用文件。
-      恢复用：换机 / 整库迁移 / 出问题前留底。
+      <b>导出</b>当前系统数据为 zip：含 <code>users.db</code> 在线一致快照（<b>全部业务表</b>：用户 / 任务计划 / 设备分组 /
+      自定义动作 / APK 记录 / 设备池 / 待连接设备 / AI 会话 / 经验库 / 经验巡检 / <b>动作库</b> / 系统配置）+ 可选的
+      <code>apks/</code> 应用文件。恢复用：换机 / 整库迁移 / 出问题前留底。
+      <br><span class="text-muted">清单见预览的「表数据行数」；新增持久化表须登记进备份覆盖清单（红线，见 doc/DEPLOY.md §3.5）。</span>
    </div>
    <div class="toolbar" style="gap:8px">
      <label style="display:inline-flex;align-items:center;gap:4px;margin:0 6px">
@@ -972,6 +1007,7 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14

 <!-- 前端模块（按依赖顺序加载：base → list → 页面模块 → admin(含初始化)） -->
 <script src="/static/admin/base.js"></script>
+<script src="/static/admin/markdown.js"></script>
 <script src="/static/admin/list.js"></script>
 <script src="/static/admin/monitor.js"></script>
 <script src="/static/admin/editor.js"></script>
@@ -5,7 +5,9 @@
  GET  /api/agent/stream?run_id=      → SSE 事件流（EventSource 订阅）：
        event: delta  {text, kind: content|reasoning}   流式文本增量
        event: step   {tool, args, image?}               工具调用完成（MCP 步骤）
-        event: done   {answer}                           完成
+        event: usage  {prompt_tokens, completion_tokens,
+                       total_tokens, calls}              本轮累计 token 用量
+        event: done   {answer, usage}                    完成
        event: error  {message}                          失败
  GET/POST /api/agent/config          → 配置读写（key 打码回显）

@@ -38,9 +40,13 @@ _CFG_KEYS = {"api_base": "agent_api_base",
             "default_serial": "agent_default_serial",
             "max_steps": "agent_max_steps"}

+# 推理链落库上限（字符）：只留够回看的量，避免会话消息无限膨胀
+_REASONING_KEEP = 6000
+
+
 # ---------- 运行状态（单实例 + 事件队列） ----------
 _run = {"id": None, "state": "idle", "prompt": "", "serial": "",
-        "answer": "", "error": "",
+        "answer": "", "error": "", "usage": {},
        "history": []}   # 多轮对话历史 [{role: user|assistant, content}]
 _queues = {}            # run_id -> queue.Queue（SSE 消费者读取）
 _stop_events = {}       # run_id -> threading.Event（用户中断）
@@ -1192,7 +1198,7 @@ def agent_run():
        _run.update(id=run_id, state="running", prompt=prompt,
                    serial=serial, conv_id=conv_id,
                    started=_dt.now().strftime("%H:%M:%S"),
-                    answer="", error="")
+                    answer="", error="", usage={})
        # history 保留（多轮上下文），由会话/「新建会话」管理
        _queues[run_id] = queue.Queue()
        _stop_events[run_id] = threading.Event()
@@ -1244,6 +1250,7 @@ def agent_run_status():
                        "started": _run.get("started", ""),
                        "answer": (_run.get("answer") or "")[:4000],
                        "error": (_run.get("error") or "")[:400],
+                        "usage": _run.get("usage") or {},
                        "history": hist[-16:]})


@@ -1345,9 +1352,22 @@ def _agent_thread(run_id, prompt, serial, cfg):
        sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
        from mcp_agent.agent import Agent

+        # 推理链（reasoning_content）累计——单纯流式展示会随页面刷新丢失，
+        # 落库后可在会话里折叠回看（只存文本，不回灌给模型）
+        reason_parts = []
+        reason_len = 0
+
        def on_delta(text, kind):
+            nonlocal reason_len
+            if kind == "reasoning" and reason_len < _REASONING_KEEP:
+                reason_parts.append(text)
+                reason_len += len(text)
            q.put(("delta", {"text": text, "kind": kind}))

+        def on_usage(usage):
+            """每次模型调用完成 → 推累计用量（前端实时刷新 token 计数）。"""
+            q.put(("usage", dict(usage)))
+
        tool_seq = []    # 本轮工具序列（任务级配方提炼用）
        tool_trace = []  # 结构化轨迹：{tool, args, result}（动作经验提炼用，判成败）

@@ -1451,7 +1471,8 @@ def _agent_thread(run_id, prompt, serial, cfg):
                                              on_delta=on_delta, on_tool=on_tool,
                                              should_stop=lambda: bool(
                                                  stop_evt and stop_evt.is_set()),
-                                              extra_context=recall_ctx)
+                                              extra_context=recall_ctx,
+                                              on_usage=on_usage)
            except Exception as e:
                if _mcp_unreachable(e):
                    raise RuntimeError(
@@ -1460,13 +1481,22 @@ def _agent_thread(run_id, prompt, serial, cfg):

        # 整体超时保护：卡死时结束，释放单实例
        answer = asyncio.run(asyncio.wait_for(_execute(), timeout=900))
+        usage = dict(getattr(agent, "usage", None) or {})
        with _lock:
            _run["state"] = "done"
            _run["answer"] = answer
-            # 追加本轮进历史（多轮连续性；上限 12 轮防 token 膨胀）
+            _run["usage"] = usage
+            # 追加本轮进历史（多轮连续性；上限 12 轮防 token 膨胀）。
+            # usage/reasoning 仅用于前端展示与落库，不进模型上下文（读回时只取 role/content）
            hist = _run.setdefault("history", [])
            hist.append({"role": "user", "content": prompt[:2000]})
-            hist.append({"role": "assistant", "content": (answer or "")[:4000]})
+            turn = {"role": "assistant", "content": (answer or "")[:4000]}
+            if usage:
+                turn["usage"] = usage
+            reason = "".join(reason_parts).strip()
+            if reason:
+                turn["reasoning"] = reason[:_REASONING_KEEP]
+            hist.append(turn)
            _run["history"] = hist[-24:]
        # 会话落库：本轮追加写回（新会话自动用首条消息作标题）。
        # 后台线程 db 访问需 app context。
@@ -1513,7 +1543,7 @@ def _agent_thread(run_id, prompt, serial, cfg):
                                    "image": None}))
            except Exception as e:
                _log.warning(f"经验保存异常: {e}")
-        q.put(("done", {"answer": answer}))
+        q.put(("done", {"answer": answer, "usage": usage}))
    except Exception as e:
        _log.warning(f"Agent 运行异常: {e}")
        # 诊断：打印消息结构（tool_calls 与 tool 消息配对检查）
@@ -1529,6 +1559,11 @@ def _agent_thread(run_id, prompt, serial, cfg):
        with _lock:
            _run["state"] = "error"
            _run["error"] = f"{type(e).__name__}: {str(e)[:200]}"
+            # 失败也保留已花费的 token（前端仍能展示本轮用量；agent 可能未建出来）
+            try:
+                _run["usage"] = dict(agent.usage or {})
+            except Exception:
+                pass
        q.put(("error", {"message": str(e)[:200]}))
    finally:
        q.put(None)   # 关闭 SSE
@@ -54,13 +54,47 @@ def _job_next_run(job):
    nr = context.mgr.next_run_of(job)
    return nr.strftime("%Y-%m-%d %H:%M") if nr else None

+def _job_coverage(job, configured):
+    """任务覆盖的设备（监控页「任务运行概况」展示用）。
+
+    与 TaskJob.resolve_serials 的差别：这里按 **target 定义**给出「这台任务会覆盖
+    哪些设备」，不因设备当前是否空闲而变（在线/运行中由前端拿实时状态标注），
+    也不做离线过滤、不写调度日志——它是每 5s 轮询的展示接口。
+    """
+    tgt = job.target or {}
+    mode = tgt.get("mode", "all")
+    try:
+        if mode == "serial":
+            serials = [tgt.get("serial") or ""]
+        elif mode == "group":
+            g = context.mgr.groups.get(tgt.get("group_name"))
+            serials = [s for s in (list(g.serials) if g else []) if s in configured]
+        else:
+            serials = sorted(configured)
+        serials = [s for s in serials if s]
+        return {"mode": mode, "serials": serials, "total": len(serials)}
+    except Exception as e:
+        _log.warning(f"任务「{job.name}」覆盖设备解析失败: {e}")
+        return {"mode": mode, "serials": [], "total": 0, "error": str(e)[:80]}
+
+
+def _configured_set():
+    """设备池清单（coverage 计算用，取一次给所有任务复用）。"""
+    try:
+        return set(device_pool.list_configured())
+    except Exception:
+        return set()
+
+
@bp.route("/api/jobs")
@login_required
 def api_jobs_list():
+    configured = _configured_set()
    jobs = []
    for j in context.mgr.jobs.values():
        d = j.to_dict()
        d["next_run"] = _job_next_run(j)
+        d["coverage"] = _job_coverage(j, configured)
        jobs.append(d)
    return jsonify({"ok": True, "jobs": jobs,
                    "task_types": list_task_types()})
@@ -72,7 +106,7 @@ def api_jobs_create():
    name = (data.get("name") or "").strip()
    if not name:
        return jsonify({"ok": False, "error": "任务名不能为空"}), 400
-    task_type = data.get("task_type", "douyin_nurture")
+    task_type = data.get("task_type", "generic_steps")
    if not get_task_class(task_type):
        return jsonify({"ok": False, "error": f"未知任务类型: {task_type}"}), 400
    job = context.mgr.add_job(
@@ -84,6 +118,7 @@ def api_jobs_create():
        enabled=data.get("enabled", True))
    d = job.to_dict()
    d["next_run"] = _job_next_run(job)
+    d["coverage"] = _job_coverage(job, _configured_set())
    return jsonify({"ok": True, "msg": "任务已创建", "job": d})

@bp.route("/api/jobs/<job_id>", methods=["PUT"])
@@ -102,6 +137,7 @@ def api_jobs_update(job_id):
    context.mgr.update_job(job_id, **fields)
    d = job.to_dict()
    d["next_run"] = _job_next_run(job)
+    d["coverage"] = _job_coverage(job, _configured_set())
    return jsonify({"ok": True, "msg": "任务已更新", "job": d})

@bp.route("/api/jobs/<job_id>", methods=["DELETE"])
Author	SHA1	Message	Date
butubb	f4b5316436	chore: 去掉 generic_steps 的默认步骤 + 重试失败带上真实原因 - tasks/generic/task.py：DEFAULT_PARAMS 只留 max_duration，不再内置示例步骤（步骤只能由前端编辑器产出；此前默认的"打开抖音→循环看视频"只有后端在用，编辑器新建任务本来就是空的，等于埋了个和界面不一致的隐性默认值） - 空步骤不再静默空跑：worker 立即抛错「通用步骤任务没有可执行步骤…」，设备表「最近错误」能看到（此前会走完 0 步当成功） - core/task_manager.py：重试耗尽的 last_error 现在带上最后一次的真实失败原因，不再只有"重试N次失败"（用户看不到为什么失败）；max_attempts=1 显示"执行失败" 而非费解的"重试1次失败"；长度截断 200 字符 - 文档：TASK_DEV §2.10 说明无默认步骤 + 空步骤会报错；API.md 的 task_types 示例改 default_params={"max_duration":0}，POST /api/jobs 补「steps 要一起传」提示自测（全通过）：default_params 无 steps；无步骤任务真跑一次 → 设备错误信息完整含原因；有步骤任务（wait 1s）真跑一次 → status=done 无错误；临时任务验完已删，任务集合复原	2026-09-10 21:50:18 +08:00
butubb	98cdc39224	chore: 删除抖音养号任务类型，平台只保留 generic_steps tasks/douyin/（task_type=douyin_nurture）整体删除，唯一任务类型是 generic_steps。所有默认值/文档/接口示例同步改成 generic_steps： - tasks/：删 douyin 包；__init__ 只注册 generic；base.py/generic 注释改为照 generic 抄 - 默认值：core/models.py（列默认 + 旧 JSON 迁移默认）、core/task_manager.py TaskJob、 web/tasks_api.py 建任务默认、static/admin/tasks.js 新建任务默认 - core/task_manager.py：去掉 douyin 专属的"清理废弃 comment 参数"迁移块，改为启动时告警仍残留已删类型的任务（只告警不改数据）；run_job_now 对已删类型直接返回明确错误，不再"报已触发、线程里静默失败" - 清理残留：douyin_running 状态位（无任何读取方）、core/__init__、core/actions/、 core/logger.py 注释里的抖音示例 - 文档：README（特性/目录树/类型表/参数表/示例）、TASK_DEV（目录树/注册说明/模板引用）、 ARCHITECTURE（注册示例/action 注册表示例）、API.md（task_types 与任务 JSON 示例）、 AI_TASK_GEN（P1 去掉 douyin 预设）、DEVELOPMENT - 注：示例里"抖音"作为App 名*（MCP 列应用、AI 建任务的需求举例）保留，与任务类型无关自测（全部通过）：类型列表只剩 generic_steps；建任务不传类型默认 generic_steps；传 douyin_nurture 被 400 拒；库里塞残留旧类型任务 → 启动日志告警 + 执行返回明确错误 + 不自动删用户数据；前端新建任务下拉 1 项且默认选中、界面建任务成功；监控页卡片两个按钮 + 覆盖设备正常。临时任务/数据验完已清理，任务集合复原。	2026-09-10 21:43:08 +08:00
butubb	86c65236a2	fix: 监控页任务概况去掉「编辑/删除」，只留执行/停用 + 显示覆盖设备监控页的任务卡片原来带「编辑」，但 openTaskModal 依赖 _taskTypes/_groupsList/ _devicesList，这三个列表只在任务 Tab 的 loadTasks() 里加载——从监控页直接点编辑，下拉框是空的（这就是"编辑有问题"）。按需求把编辑/删除从监控页移除（编辑统一去任务 Tab），每张卡片只留：执行任务 + 停用任务/启用任务。并给卡片加「覆盖设备」一行： - 后端 /api/jobs（含 POST/PUT 返回的 job）新增 coverage = {mode, serials, total}：按 target 定义解析（all=设备池全量 / group=分组∩设备池 / serial=该设备），不做离线过滤、不写调度日志（该接口每 5s 轮询），与调度用的 resolve_serials 口径差异已写入文档 - 前端用已在手的 /api/status 标注在线状态，渲染成彩色 chip：在线=蓝、运行中=黄+⏳、离线或不在池=灰划线+✕，完整 serial/型号放 tooltip - 文档：API.md §5 补 coverage 字段与三种模式口径、ARCHITECTURE §5.1 补卡片说明自测：coverage 三种模式端到端（含分组过滤池外 serial）全通过；Edge headless 验卡片（2 个按钮、无编辑/删除、chip 文案/样式/tooltip）全通过；离线分支与任务 Tab 编辑器回归通过	2026-09-10 21:15:23 +08:00
butubb	d40c867d6f	fix: 备份覆盖补全（动作库/系统配置入清单）+ 覆盖自检与未登记表告警；发布流程/红线文档更新问题（2026-09-10 用户反馈）：动作库"没有备份"。实测导出 zip 里 agent_action 数据其实在（导出是 users.db 全库快照），但清单/预览没列它 → 看起来像没备份。同类还有 app_meta。修复（core/system_backup.py）： - SUMMARY_TABLES 补 agent_action(动作库) 与 app_meta(系统配置) + 中文标签； - 导出侧覆盖自检：登记表若在快照缺失 → manifest.coverage_missing + 日志告警； - 导入侧反向自检：备份含未登记表 → 预览告警提示登记（extra_tables）； - 顶部注释写明新增持久化表必须登记（红线）。其余： - monitor.html：数据备份面板文案改为明列全部业务表 + 指引（预览见表行数 / 新增表须登记）； - doc/DEPLOY.md §3.5：新增「备份覆盖清单（红线）」小节（含清单与两侧自检说明）； - doc/DEVELOPMENT.md：§5.6 增「备份覆盖红线」；§6 发布流程重写为分支流程（本机建分支 → 用户确认 → 合 dev → dev 整体就绪 → 合 main → 220 部署，附部署命令）； - doc/ARCHITECTURE.md §3.6：补备份覆盖登记提示。实测：导出清单 12 表（含动作库 3 行、系统配置 8 行），coverage_missing 空；上传预览同样显示、 extra_tables 空。	2026-09-10 21:03:41 +08:00
butubb	4b5b836d31	feat: AI 控制台回答支持 Markdown 渲染 + 推理链可折叠 + token 用量显示 - markdown.js（新增，无 CDN 依赖）：轻量 Markdown 渲染（标题/列表含嵌套/表格/ 代码块/引用/链接…），先 esc() 转义再套标记，模型输出的 HTML 只当文本显示 - agent.js：回答改走 Markdown；推理链改为 <details> 可折叠（流式时展开、正文开始自动收起、手动点过后不再自动改）；单条消息 token 脚注 + 顶栏「本会话累计」 - monitor.html：消息结构加 .reasoning/.agent-usage、顶栏 token 徽标、md 相关样式，引入 markdown.js（base.js 之后、agent.js 之前） - mcp_agent/agent.py：请求带 stream_options.include_usage，按「每次模型调用」累计 usage（末尾 chunk），on_usage 回调吐累计值；网关不认该参数（400/422/点名）时自动降级重试一次 - web/agent_api.py：SSE 新增 usage 事件、done 带 usage；推理链与用量随会话落库（_REASONING_KEEP=6000 截断），回灌模型时只取 role/content - 文档：API.md（usage 事件/done/会话消息字段）、ARCHITECTURE §5.4.1、DEVELOPMENT 前端 JS 清单自测：假模型端点单测 3/3（正常/降级/多轮累加）；Edge headless 全链路 27 项全通过（真实 Flask+SSE+SQLite，含 XSS 转义、刷新后回看）；Markdown 渲染器 18 用例全通过	2026-09-10 18:22:20 +08:00