fix: AI 控制台 MCP 不可达给出明确文案——不再显示 SDK 含糊报错

MCP 客户端(streamable_http)在工具服务不可达/返回非 MCP 响应时只抛
'Server returned an error response'，用户无法判断原因。改为：
- 后端 web/agent_api.py:_execute 包裹 _load_tools/run_stream，识别连接类错误
  (Server returned an error response/ConnectError/refused 等)后抛明确文案：
  'MCP server(8033) 不可达：无法加载设备工具(<url>)。请确认 MCP server 已启动…'
- 前端 static/admin/agent.js 加 _friendlyAgentError() 兜底映射并去掉
  'RuntimeError:' 之类前缀，三处错误展示统一使用
- 文档同步：MCP.md(依赖提示+本机启动命令)、API.md(SSE error 文案说明)、
  DEPLOY.md(故障排查新增一行)
实测：停掉 MCP 复现 → 前端显示明确文案；启动 MCP 后 AI 控制台正常完成任务

.gitignore

@@ -48,3 +48,6 @@ data/*.corrupt_*
 data/users.db*
 data/users.db-wal
 data/users.db-shm
+data/backups/
+data/restore_staging/
+data/restore_pending/

config.py

@@ -60,6 +60,13 @@ DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
 # APK 文件存储目录（应用管理功能）
 APK_DIR = os.path.join(DATA_DIR, "apks")
 
+# ================== 系统数据备份（导出/导入） ==================
+# 导出 zip 与恢复前快照存放；导入暂存目录；待下次启动生效的恢复目录
+# （运行时产物，不入 git，见 .gitignore data/backups 等）
+BACKUP_DIR = os.path.join(DATA_DIR, "backups")
+RESTORE_STAGING_DIR = os.path.join(DATA_DIR, "restore_staging")
+RESTORE_PENDING_DIR = os.path.join(DATA_DIR, "restore_pending")
+
 # ================== SSH 到部署机（已废弃，STF 相关操作退役） ==================
 # 阶段 3 后代码不再使用 SSH；保留配置仅供手动运维 220（如 docker stop stf）。
 STF_SSH_TARGET = _env("STF_SSH_TARGET", "")

core/device_discovery.py

@@ -22,7 +22,7 @@ from config import (USB_ADB_HOST,
                     DISCOVERY_PORT, DISCOVERY_SUBNETS, DISCOVERY_INTERVAL)
 from core.adb_helper import _adb, adb_connect_light
 from core.logger import get_logger
-from core.models import db, PendingDevice
+from core.models import db, Device, PendingDevice
 
 _log = get_logger("core.disc")
 
@@ -114,17 +114,39 @@ def save_settings(enabled=None, subnets=None, interval=None, port=None):
 
 
 # ================== 网段展开与端口探测 ==================
+def _local_ips():
+    """本机自身 IP 集合（尽力而为）：扫描时排除，避免探测到自己的 5555。
+
+    优先 `hostname -I`（Linux/macOS 支持，一行空格分隔多 IP）；不支持/失败的
+    平台退回 socket.getaddrinfo 枚举。关键：外部命令必须用 bytes 收——Windows
+    上 git-bash 的 coreutils hostname 不支持 -I，会把 GBK 报错写进 stderr，
+    text=True 在 subprocess 后台读线程里 utf-8 严格解码会直接炸线程（主线程
+    try/except 接不住异步线程异常）。
+    """
+    import subprocess
+    ips = set()
+    try:
+        r = subprocess.run(["hostname", "-I"], capture_output=True, timeout=3)
+        if r.returncode == 0:
+            ips.update(p for p in
+                       r.stdout.decode("utf-8", errors="ignore").split() if p)
+    except Exception:
+        pass
+    if not ips:  # 兜底：主机名解析出的接口 IPv4
+        try:
+            for info in socket.getaddrinfo(socket.gethostname(), None):
+                ip = info[4][0]
+                if ":" not in ip:
+                    ips.add(ip)
+        except Exception:
+            pass
+    return ips
+
+
 def _expand_subnets(subnets, max_hosts=_MAX_HOSTS_PER_SUBNET):
     """CIDR 列表 → IP 列表。排除 220 自身（USB_ADB_HOST）与本机 IP；
     非法网段跳过记日志；单网段超过 max_hosts 截断并告警。"""
-    self_ips = {USB_ADB_HOST}
-    try:  # 本机自身 IP（接口枚举，尽力而为；无 hostname -I 的平台跳过）
-        import subprocess
-        out = subprocess.run(["hostname", "-I"], capture_output=True, text=True,
-                             timeout=3).stdout or ""
-        self_ips.update(p for p in out.split() if p)
-    except Exception:
-        pass
+    self_ips = {USB_ADB_HOST} | _local_ips()
     ips = []
     for cidr in subnets:
         try:
@@ -220,8 +242,14 @@ def scan_once(manual=False):
                                                  first_seen=now, last_seen=now))
                     added += 1
             db.session.commit()
+            # 6. 正式池断联设备自动重连：adb connect 会因 WiFi 波动/设备重启/
+            #    adb 服务重启而断开——扫描线程每轮顺带重试（幂等轻量，内部
+            #    全局锁串行），连上即恢复在线，无需人工干预。pending 池是给
+            #    「未授权新设备」的，正式池设备断联不进 pending，而是自动重连。
+            back = _reconnect_offline(configured)
             _log.info(f"发现: 探测开放 {len(open_ips)} 台，可连 {len(verified)} 台，"
-                      f"新增待连接 {added} 台")
+                      f"新增待连接 {added} 台"
+                      + (f"，自动重连恢复 {len(back)} 台 {back}" if back else ""))
         _last_scan = (now, len(open_ips), len(verified), added)
         _last_error = ""
         return True, {"found": len(open_ips), "verified": len(verified), "new": added}
@@ -240,6 +268,39 @@ def device_pool_list_configured():
     return device_pool.list_configured()
 
 
+# ================== 正式池断联设备：自动重连 ==================
+def _reconnect_offline(configured):
+    """对正式池中断联的网络设备逐个 adb 重连，返回恢复的 serial 列表。
+
+    只重连网络设备（IP:5555；USB 设备插着就在，无需 connect）。
+    幂等轻量：内部 adb 全局锁串行，失败静默（下轮扫描再试）。
+    """
+    online_now = _parse_adb_devices(_adb("devices"))
+    targets = [s for s in (configured or [])
+               if ":" in s and s not in online_now]
+    if not targets:
+        return []
+    for serial in targets:
+        adb_connect_light(serial)
+    online_after = _parse_adb_devices(_adb("devices"))
+    return [s for s in targets if s in online_after]
+
+
+def list_pool_offline():
+    """正式设备池中断联的设备（serial + 型号 + 备注名），面板展示用。
+
+    断联设备仍是正式池成员（不删除、不进 pending）——pending 是给未授权
+    新设备的；它们由扫描线程每轮自动重连，也可前端手动立即重连。
+    """
+    online = _parse_adb_devices(_adb("devices"))
+    with _ctx():
+        rows = [d.to_dict() for d in Device.query.filter_by(enabled=True)
+                .order_by(Device.serial).all()]
+    return [{"serial": r["serial"], "model": r.get("model") or "",
+             "name": r.get("name") or ""}
+            for r in rows if r["serial"] not in online]
+
+
 # ================== 定时扫描线程 ==================
 def _discovery_loop():
     """定时扫描 daemon 线程。每轮重读配置（开关/周期即时生效）。

core/models.py

@@ -305,7 +305,18 @@ def _migrate_schema():
             if version <= current:
                 continue
             if sql:
+                try:
                     db.session.execute(text(sql))
+                except Exception as e:
+                    # 幂等兜底：目标结构已存在也视为该迁移生效。典型场景——
+                    # create_all 已按当前模型把列/表直接建好（如 perms、device.model），
+                    # 而 schema_version 又因历史中断没记录，导致每次启动重复 ALTER 报错。
+                    # duplicate column name 说明列已存在=迁移目标已达成：回滚本次语句后
+                    # 仍记录版本号，一次启动即自愈；其它异常才中止本批迁移。
+                    if "duplicate column name" not in str(e).lower():
+                        raise
+                    db.session.rollback()
+                    _log.info(f"schema 迁移 {version} 目标已存在，跳过: {desc}")
             db.session.execute(
                 text("INSERT OR REPLACE INTO app_meta(key,value) VALUES('schema_version',:v)"),
                 {"v": str(version)})

core/ocr.py

@@ -69,11 +69,22 @@ def recognize(image):
 def find_on_screen(image, keyword):
     """在截图上查找包含 keyword 的文字。
 
-    返回 (found, center_xy, matched_text)；center_xy 为文字中心像素坐标（可点击），
-    未命中返回 (False, None, "")。
+    返回 (found, center_xy, matched_text)；center_xy 为**关键词**中心像素坐标
+    （可点击），未命中返回 (False, None, "")。
+
+    OCR 一行常含多段文字（如 "医值得推荐#苏州济世璞真…展开"），若直接点整块
+    中心会偏离关键词很远。命中块文本较长时，按关键词在文本中的位置比例估算 x
+    （块内文字近似等宽），y 取块中心——中文场景估算偏差小，点击能落准。
     """
     for r in recognize(image):
-        if keyword in r["text"]:
+        text = r["text"]
+        if keyword in text:
             b = r["box"]
-            return True, ((b[0] + b[2]) // 2, (b[1] + b[3]) // 2), r["text"]
+            if len(text) <= 12:   # 短文本：整块中心即关键词中心
+                return True, ((b[0] + b[2]) // 2, (b[1] + b[3]) // 2), text
+            idx = text.find(keyword)
+            ratio = (idx + len(keyword) / 2) / len(text)
+            cx = b[0] + int((b[2] - b[0]) * ratio)
+            cy = (b[1] + b[3]) // 2
+            return True, (cx, cy), text
     return False, None, ""

core/system_backup.py

@@ -0,0 +1,413 @@
+"""系统数据备份导出/导入（数据库 + APK 文件）。
+
+导出：用 sqlite3 在线备份 API 对 data/users.db 做一致性快照 → zip
+      （users.db + manifest.json + 可选 apks/*.apk）。
+导入：上传(zip/db) → 暂存校验预览 → 应用（先把当前库快照到
+      BACKUP_DIR/pre_restore_*.db，再把暂存库移到 RESTORE_PENDING_DIR）→
+      下次启动 consume_pending_restore() 换位生效。
+
+为什么必须重启生效：web_server 单进程内 SQLAlchemy engine + 多个常驻后台线程
+（TaskManager 内存态 / 设备发现 / Agent 等）持有 users.db（WAL）；Windows 下
+不能直接替换正被打开的文件，且 TaskManager 启动时才把 groups/jobs 读入内存。
+故导入只落一个「待生效恢复任务」，由 web_server.py 在 init_db 之前消费。
+
+安全红线：全程只读现有库 / 新增或移动自己目录下的文件；绝不 kill-server、
+绝不 disconnect（与全项目一致）。
+"""
+import json
+import os
+import shutil
+import sqlite3
+import time
+import uuid
+import zipfile
+from urllib.parse import quote
+
+from config import (DATA_DIR, APK_DIR, BACKUP_DIR,
+                    RESTORE_STAGING_DIR, RESTORE_PENDING_DIR)
+from core.logger import get_logger
+from core.models import SCHEMA_MIGRATIONS
+
+_log = get_logger("core.backup")
+
+# 当前代码期望的 schema 版本（来自版本化迁移表）
+CURRENT_SCHEMA_VERSION = max(v[0] for v in SCHEMA_MIGRATIONS) if SCHEMA_MIGRATIONS else 0
+
+DB_FILE = os.path.join(DATA_DIR, "users.db")
+
+# 判定「本平台备份库」的必需表（缺任何一张即拒绝导入）
+REQUIRED_TABLES = ("app_meta", "user", "task_job", "device_group")
+# 预览/清单里展示行数的业务表（存在才统计）
+SUMMARY_TABLES = (
+    "user", "device_group", "task_job", "custom_action",
+    "apk_file", "device", "pending_device",
+    "agent_conversation", "agent_experience", "experience_audit",
+)
+TABLE_LABELS = {
+    "user": "用户", "device_group": "设备分组", "task_job": "任务计划",
+    "custom_action": "自定义动作", "apk_file": "APK 记录", "device": "设备池",
+    "pending_device": "待连接设备", "agent_conversation": "AI 会话",
+    "agent_experience": "经验库", "experience_audit": "经验巡检",
+}
+_STAGE_TTL = 1800  # 导入暂存有效期（秒）
+
+
+class BackupError(Exception):
+    """备份/导入相关可预期错误（msg 直接给前端展示）。"""
+
+
+# ================== 通用工具 ==================
+def _ts():
+    return time.strftime("%Y%m%d_%H%M%S")
+
+
+def _readonly_uri(path):
+    """把文件路径转成 sqlite 只读 URI（兼容含空格/中文/反斜杠的 Windows 路径）。"""
+    return "file:{}?mode=ro".format(quote(os.path.abspath(path).replace("\\", "/"), safe="/:"))
+
+
+def _connect_readonly(path):
+    con = sqlite3.connect(_readonly_uri(path), uri=True)
+    con.text_factory = str  # 与平台一致按 UTF-8 读（表内文本均为 UTF-8）
+    return con
+
+
+def remove_quiet(path):
+    """尽力删除文件/目录（发送完成清理等场景，忽略不存在）。"""
+    try:
+        if os.path.isdir(path):
+            shutil.rmtree(path, ignore_errors=True)
+        elif os.path.exists(path):
+            os.remove(path)
+    except OSError:
+        pass
+
+
+def _ensure_dir(path):
+    os.makedirs(path, exist_ok=True)
+
+
+def _list_tables(con):
+    rows = con.execute(
+        "SELECT name FROM sqlite_master WHERE type='table'").fetchall()
+    return {r[0] for r in rows}
+
+
+def _read_schema_version(con):
+    try:
+        row = con.execute(
+            "SELECT value FROM app_meta WHERE key='schema_version'").fetchone()
+        return int(row[0]) if row and row[0] else 0
+    except Exception:
+        return 0
+
+
+def _table_rows(con, table):
+    try:
+        return con.execute('SELECT COUNT(*) FROM "%s"' % table).fetchone()[0]
+    except Exception:
+        return None
+
+
+# ================== 在线快照 ==================
+def snapshot_db(dest_path, src_path=None):
+    """对 src（默认当前 users.db）做 sqlite 在线一致快照到 dest_path。
+
+    用标准库备份 API（不依赖 SQLAlchemy engine，WAL 模式下读一致快照安全）。
+    备份完成后把目标强制落回单文件（journal_mode=DELETE + checkpoint），
+    避免副本以 WAL 模式残留 -wal/-shm 或主文件缺刚提交帧。
+    """
+    src_path = src_path or DB_FILE
+    if not os.path.exists(src_path):
+        raise BackupError(f"数据库不存在: {src_path}")
+    con = _connect_readonly(src_path)
+    out = sqlite3.connect(dest_path)
+    try:
+        con.backup(out)
+        try:
+            out.execute("PRAGMA journal_mode=DELETE")  # checkpoint 并转回 DELETE
+        except sqlite3.Error:
+            pass
+    finally:
+        out.close()
+        con.close()
+    # 防御：确保没有任何残留附属文件
+    remove_quiet(dest_path + "-wal")
+    remove_quiet(dest_path + "-shm")
+
+
+# ================== 导出 ==================
+def _summary_info(con):
+    """表行数摘要（只列出存在的表）。"""
+    rows = []
+    for t in SUMMARY_TABLES:
+        n = _table_rows(con, t)
+        if n is not None:
+            rows.append({"table": t, "label": TABLE_LABELS.get(t, t), "rows": n})
+    return rows
+
+
+def _prune_old_exports(max_age=3600):
+    """清理过期的导出临时 zip（下载完成后的 call_on_close 在 Windows 上可能
+    因文件锁删不掉，这里按时间兜底清理；保留近 1 小时的便于失败重试）。"""
+    now = time.time()
+    if not os.path.isdir(BACKUP_DIR):
+        return
+    for n in os.listdir(BACKUP_DIR):
+        if n.startswith("export_") and n.endswith(".zip"):
+            p = os.path.join(BACKUP_DIR, n)
+            try:
+                if now - os.path.getmtime(p) > max_age:
+                    os.remove(p)
+            except OSError:
+                pass
+
+
+def create_export(include_apk=True):
+    """生成导出 zip，返回 (zip_path, filename, manifest)。"""
+    _ensure_dir(BACKUP_DIR)
+    _prune_old_exports()
+    base = os.path.join(BACKUP_DIR, f"export_{_ts()}")
+    snap = base + ".snapshot.db"
+    snapshot_db(snap)
+
+    apk_meta = []
+    if include_apk and os.path.isdir(APK_DIR):
+        for fname in sorted(os.listdir(APK_DIR)):
+            if fname.lower().endswith(".apk"):
+                fp = os.path.join(APK_DIR, fname)
+                try:
+                    apk_meta.append({"name": fname, "size": os.path.getsize(fp)})
+                except OSError:
+                    pass
+
+    zip_path = base + ".zip"
+    con = _connect_readonly(snap)
+    try:
+        manifest = {
+            "format": "auto_control_backup",
+            "version": 1,
+            "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "schema_version": _read_schema_version(con),
+            "include_apk": include_apk,
+            "tables": _summary_info(con),
+            "apks": apk_meta,
+        }
+    finally:
+        con.close()
+
+    try:
+        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as z:
+            z.write(snap, arcname="users.db")
+            for a in apk_meta:
+                z.write(os.path.join(APK_DIR, a["name"]), arcname="apks/" + a["name"])
+            z.writestr("manifest.json", json.dumps(
+                manifest, ensure_ascii=False, indent=2))
+    finally:
+        remove_quiet(snap)
+    return zip_path, os.path.basename(zip_path), manifest
+
+
+# ================== 校验 ==================
+def validate_backup(db_file):
+    """校验备份库可读、是本平台库。返回 (ok, info|error_msg)。"""
+    if not os.path.exists(db_file):
+        return False, "缺少数据库文件 users.db"
+    try:
+        con = _connect_readonly(db_file)
+    except sqlite3.Error as e:
+        return False, f"无法打开数据库: {e}"
+    try:
+        integrity = con.execute("PRAGMA integrity_check").fetchone()[0]
+        if integrity != "ok":
+            return False, f"数据库完整性校验失败: {integrity}"
+        tables = _list_tables(con)
+        missing = [t for t in REQUIRED_TABLES if t not in tables]
+        if missing:
+            return False, f"不是本平台备份库（缺少必需表: {', '.join(missing)}）"
+        schema_version = _read_schema_version(con)
+        missing_optional = [t for t in SUMMARY_TABLES
+                            if t not in REQUIRED_TABLES and t not in tables]
+        warnings = []
+        if schema_version < CURRENT_SCHEMA_VERSION:
+            warnings.append(
+                f"备份 schema 较旧（v{schema_version} < 当前 v{CURRENT_SCHEMA_VERSION}），"
+                f"应用后首次启动会自动迁移补齐结构与新表")
+        elif schema_version > CURRENT_SCHEMA_VERSION:
+            warnings.append(
+                f"备份 schema 较新（v{schema_version} > 当前 v{CURRENT_SCHEMA_VERSION}），"
+                f"当前平台版本可能读不了新增列/表，建议先升级再恢复")
+        if missing_optional:
+            warnings.append("备份缺少部分可选表（" + "、".join(
+                TABLE_LABELS.get(t, t) for t in missing_optional)
+                + "），应用后启动会自动补建空表")
+        warnings.append("备份为全量快照：含用户口令哈希、AI 配置里的 API Key 等敏感信息，请妥善保管")
+        return True, {
+            "integrity": integrity,
+            "schema_version": schema_version,
+            "current_schema_version": CURRENT_SCHEMA_VERSION,
+            "tables": _summary_info(con),
+            "missing_optional": missing_optional,
+            "warnings": warnings,
+        }
+    except sqlite3.Error as e:
+        return False, f"读取数据库失败: {e}"
+    finally:
+        con.close()
+
+
+# ================== 导入：暂存 + 预览 ==================
+def _extract_zip(zip_path, staging_dir):
+    """解压备份 zip：取顶层 users.db 与可选 apks/*.apk（防路径穿越，只用 basename）。"""
+    db_dest = os.path.join(staging_dir, "users.db")
+    apk_dest = os.path.join(staging_dir, "apks")
+    got_db = False
+    with zipfile.ZipFile(zip_path) as z:
+        for info in z.infolist():
+            if info.is_dir():
+                continue
+            name = info.filename.replace("\\", "/")
+            base = os.path.basename(name)
+            if name == "users.db" and base == "users.db":
+                z.extract(info, staging_dir)  # 已确认顶层名字，无穿越
+                got_db = True
+            elif name.startswith("apks/") and base.lower().endswith(".apk"):
+                _ensure_dir(apk_dest)
+                with z.open(info) as src, open(
+                        os.path.join(apk_dest, base), "wb") as dst:
+                    shutil.copyfileobj(src, dst)
+    if not got_db:
+        raise BackupError("zip 内未找到 users.db（顶层）")
+    return db_dest
+
+
+def _prune_stale_staging():
+    """清理超时未应用的暂存目录（TTL 后自动删除）。"""
+    now = time.time()
+    if not os.path.isdir(RESTORE_STAGING_DIR):
+        return
+    for name in os.listdir(RESTORE_STAGING_DIR):
+        p = os.path.join(RESTORE_STAGING_DIR, name)
+        try:
+            if os.path.isdir(p) and now - os.path.getmtime(p) > _STAGE_TTL:
+                remove_quiet(p)
+        except OSError:
+            pass
+
+
+def stage_upload(file_storage):
+    """保存上传备份并校验，返回 (token, info)。失败抛 BackupError。"""
+    _prune_stale_staging()
+    orig_name = file_storage.filename or "backup"
+    token = uuid.uuid4().hex[:12]
+    staging_dir = os.path.join(RESTORE_STAGING_DIR, token)
+    _ensure_dir(staging_dir)
+    low = (orig_name or "").lower()
+    try:
+        raw_path = os.path.join(staging_dir, "upload" + ("." + low.rsplit(".", 1)[1] if "." in low else ""))
+        file_storage.save(raw_path)
+        if low.endswith(".zip"):
+            _extract_zip(raw_path, staging_dir)
+            db_file = os.path.join(staging_dir, "users.db")
+            remove_quiet(raw_path)
+        elif low.endswith(".db"):
+            db_file = os.path.join(staging_dir, "users.db")
+            os.replace(raw_path, db_file)
+        else:
+            raise BackupError("仅支持 .zip（平台导出）或 .db（sqlite 库）文件")
+        ok, info = validate_backup(db_file)
+        if not ok:
+            raise BackupError(info)
+        info["file_name"] = orig_name
+        info["file_size"] = os.path.getsize(db_file)
+        return token, info
+    except BackupError:
+        remove_quiet(staging_dir)
+        raise
+    except Exception as e:
+        remove_quiet(staging_dir)
+        raise BackupError(f"暂存上传文件失败: {e}")
+
+
+# ================== 导入：应用（落待生效任务） ==================
+def apply_restore(token):
+    """校验 token → 快照当前库 → 把暂存库移到 restore_pending。
+
+    返回 dict {ok, backup_name, message}；失败抛 BackupError。token 形如 12 位 hex。
+    """
+    if not token or len(token) != 12 or not all(c in "0123456789abcdef" for c in token):
+        raise BackupError("无效的导入标识")
+    staging_dir = os.path.join(RESTORE_STAGING_DIR, token)
+    db_file = os.path.join(staging_dir, "users.db")
+    if not os.path.exists(db_file):
+        raise BackupError("导入会话已失效，请重新上传预览")
+    ok, info = validate_backup(db_file)
+    if not ok:
+        raise BackupError(info)
+
+    # 1) 自动备份当前库（安全网，可回滚）
+    _ensure_dir(BACKUP_DIR)
+    backup_name = f"pre_restore_{_ts()}.db"
+    snapshot_db(os.path.join(BACKUP_DIR, backup_name))
+
+    # 2) 落待生效恢复任务（旧未消费任务被覆盖——上一份已无意义）
+    pending_dir = RESTORE_PENDING_DIR
+    if os.path.isdir(pending_dir):
+        remove_quiet(pending_dir)
+    _ensure_dir(pending_dir)
+    os.replace(db_file, os.path.join(pending_dir, "users.db"))
+    apk_src = os.path.join(staging_dir, "apks")
+    if os.path.isdir(apk_src) and os.listdir(apk_src):
+        shutil.move(apk_src, os.path.join(pending_dir, "apks"))
+    remove_quiet(staging_dir)
+
+    schema_version = info.get("schema_version", 0)
+    _log.info(f"导入已落恢复任务: schema v{schema_version}，"
+              f"重启 web_server 后生效；当前库已快照 {backup_name}")
+    return {
+        "ok": True,
+        "backup_name": backup_name,
+        "message": "恢复任务已生成：当前库已自动备份，重启 web_server 后即应用导入的数据",
+    }
+
+
+# ================== 启动消费（web_server.py init_db 前调用） ==================
+def consume_pending_restore():
+    """把 restore_pending/users.db 换位为当前 users.db（删除旧 wal/shm，合并 apks）。
+
+    必须在 SQLAlchemy engine 首次打开 users.db 之前执行（web_server 装配时调用）。
+    失败不阻塞启动：坏恢复文件会挪到 BACKUP_DIR/restore_failed_*/ 并继续用旧库。
+    返回是否真的应用了恢复。
+    """
+    pending_db = os.path.join(RESTORE_PENDING_DIR, "users.db")
+    if not os.path.exists(pending_db):
+        return False
+    # 消费前轻量复验（防止意外损坏文件把主库换掉）
+    ok, msg = validate_backup(pending_db)
+    if not ok:
+        fail_dir = os.path.join(BACKUP_DIR, f"restore_failed_{_ts()}")
+        _ensure_dir(fail_dir)
+        os.replace(pending_db, os.path.join(fail_dir, "users.db"))
+        remove_quiet(RESTORE_PENDING_DIR)
+        _log.error(f"恢复任务校验失败，已搁置到 {fail_dir}，继续使用当前库: {msg}")
+        return False
+    _ensure_dir(DATA_DIR)
+    os.replace(pending_db, DB_FILE)
+    for ext in ("-wal", "-shm"):
+        p = DB_FILE + ext
+        if os.path.exists(p):
+            remove_quiet(p)
+    # 合并 apks（覆盖同名）
+    apk_src = os.path.join(RESTORE_PENDING_DIR, "apks")
+    if os.path.isdir(apk_src):
+        _ensure_dir(APK_DIR)
+        for fname in os.listdir(apk_src):
+            src = os.path.join(apk_src, fname)
+            dst = os.path.join(APK_DIR, fname)
+            if os.path.exists(dst):
+                os.remove(dst)
+            shutil.move(src, dst)
+    remove_quiet(RESTORE_PENDING_DIR)
+    schema_version = msg.get("schema_version", 0) if isinstance(msg, dict) else "?"
+    _log.info(f"已应用备份恢复: users.db 替换完成（schema v{schema_version}），apks 已合并")
+    return True

doc/AI_TASK_GEN.md

@@ -0,0 +1,180 @@
+# AI 建任务（AI Task Generator）设计文档
+
+> 分支：dev | 状态：设计稿（未实现） | 日期：2026-09-09
+> 关联：AI 控制台（web/agent_api.py）、MCP 设备工具（mcp_server/）、任务/步骤编辑器（tasks/generic、static/admin/editor.js）
+
+## 1. 背景与目标
+
+平台已有两套能力，但互不相通：
+- **AI 控制台**：一句话 + 选设备 → 多模态 Agent（DeepSeek）通过 19 个 `de_*` 工具在手机上「边看边做」（截图看屏、`de_ui_tree` 拿元素树、`de_tap_element/de_tap_text` 语义点按），流式回放步骤。
+- **任务系统 + 步骤编辑器**：`generic_steps` 任务 = 一棵可嵌套步骤树（open_app/click/swipe/loop/group/if_el…18 种节点），在编辑器里拖拽编排、单步试跑、定时调度。
+
+目标：让**非工程用户用一句自然语言需求**（例：「创建一个每日养号刷视频的任务，每天 8:00-9:00 在 100.100.10.13 跑」）得到**一条可直接调度、可继续在现有步骤编辑器里手改的任务**。AI 先自己在设备上打开 App、看 UI 树、确认可点元素，再直接撰写编辑器的步骤 JSON。
+
+### 产品体验（一页）
+1. 用户进入「AI 控制台 → 模式=AI 建任务」，选一台**空闲**设备，填需求 +（可选）任务名/调度/目标。
+2. AI 自探并**流式回放**（工具卡 + 截图，与现在一致）：开 App → dump UI 树 → 确认要点的元素可命中 → 写步骤。
+3. 完成后平台返回任务草稿 `draft`，服务端 schema 校验后，**前端直接打开现有「新建任务 → 步骤编辑器」**预填。
+4. 用户核对/手改/单步试跑 → 保存 → 进任务列表，走原有调度器执行。
+
+**核心信任原则：AI 只“提案”，不直接建库、不直接执行最终任务；最终落库/执行都在用户确认后由现有机制完成。**
+
+## 2. 范围（P0 定稿，2026-09-09 与用户确认）
+
+- **入口**：AI 控制台加「聊天 / AI 建任务」模式开关，复用会话/SSE/设备选择/停止/刷新恢复骨架。不新建顶级 Tab。
+- **产出方式**：**AI 直接撰写编辑器的步骤 JSON**（非操作轨迹翻译）。自探信息只作上下文与审计；探索中的误点/多余截图不会混入任务。
+- **任务类型**：P0 **只产 `generic_steps`**（通用步骤）。`douyin_nurture` 预设参数生成放 P1。
+- **定位原则：全部基于 UI 树**：
+  - 模型定位/点击一律走 `de_ui_tree` 拿到的元素（`text`/`id`/`description`/`text_contains`），多实例用 index，或后端 `uiauto_helper` 生成的 `//*[@resource-id=..][k]` XPath；
+  - `de_tap_element` 确认能命中后才写进 `click` 步骤；
+  - **默认不产 `click_xy` 坐标点击**；UI 树给不了的元素记入 notes，交给人工/OCR 兜底；
+  - 滑动用方向语义 `swipe{direction}`，不用像素坐标。
+- 产出完整任务信封：`{name, task_type:"generic_steps", target, schedule, retry, enabled, params:{max_duration, steps}}`。
+
+## 3. 现状与可复用点（实现依据）
+
+- 多模态 Agent 链路：`web/agent_api.py`（`POST /api/agent/run` 起后台线程、SSE `delta/step/done/error`、`/stop`、刷新恢复 `GET /api/agent/run`）→ `mcp_agent/agent.py`（OpenAI 兼容流式，工具经 fastmcp Client 拉 8033 的 19 个 `de_*`）→ `mcp_server/mcp_server.py`。
+- 前端 AI 控制台骨架：`templates/admin/monitor.html` `#tab-agent` + `static/admin/agent.js`（设备选择、`sendAgentMsg`、`listenStream` 渲染 `agent-toolcard`、实时画面跟随）。
+- 步骤权威 schema（前后端同构）：`tasks/generic/task.py` `STEP_TYPES`（L44-83）/ `DEFAULT_PARAMS`（L86-103） 与 `static/admin/editor.js` `STEP_LIB`（L3-23）。
+- 元素抓取 → XPath：`web/tasks_api.py /api/uiauto/elements`（L224）→ `core/uiauto_helper.get_elements`（`suggested.value` 即编辑器可用的 XPath）。
+- 单步试跑：`/api/steps/test`（tasks_api.py L249）+ `editor.js _testStep`；`tasks/generic/task.py test_step`（L633）。
+- 任务/调度/目标：`core/task_manager.py` `TaskJob`（L121-199）；`POST /api/jobs`（tasks_api.py L68）。
+- 设备占用语义：MCP 写工具 `_ensure_device_free`（mcp_server.py L60-78，running/connecting → `device_busy`）；`agent_api` run 入口同样对 worker running/connecting 拒绝（409）。
+- 经验库自进化：`agent_experience` + bigram 检索注入 + 每日巡检（`web/agent_api.py`）——P1 沉淀模板的现成载体。
+
+## 4. 架构与数据流
+
+```
+需求+设备(空闲) ──▶  Designer Agent(自探, 模式=designer)
+                        │  de_open_app / de_ui_tree / de_screenshot / de_tap_element…
+                        ▼
+                平台工具 submit_task(draft)  ← 结束性调用
+                        │  服务端 draft schema 校验(白名单+必填+深度≤5)
+                        ▼
+        前端: 打开 openTaskModal 步骤编辑器, 预填 draft.task
+                        │  用户核对/手改/单步试跑(/api/steps/test)
+                        ▼
+                POST /api/jobs  → 任务列表(原调度器执行)
+   (P1) draft+需求 沉淀 agent_experience, 相似需求注入参考
+```
+
+### 4.1 Designer Agent（新增模式，复用现有 Agent）
+- `mcp_agent` 增加 designer 系统提示词：角色=自动化任务设计师；行为约束见 §5.1。
+- 增加**平台级工具**（不属设备 `de_*`）：
+  - `submit_task(draft)`：结束性工具，模型完成自探后提交草稿即停止，服务端立即校验。
+- 会话内同时记录**结构化 trace**（每轮 `on_tool` 的 `{tool, args 精简, 屏号/证据}`），用于：校验证据（每个 selector 来自哪次树）、审计、P2 回放。
+- `POST /api/agent/run` 增加 `mode:"designer"`；`done` 事件负载携带 `draft`（校验通过）或 `draft_error`（校验失败+原因，让模型补一轮）。
+
+### 4.2 draft 契约
+```json
+{
+  "summary": "每日8-9点刷抖音养号：开抖音→循环(看5~35s+上滑)+随机间隔",
+  "task": {
+    "name": "抖音每日养号",
+    "task_type": "generic_steps",
+    "target": {"mode":"serial","serial":"100.100.10.13:5555"}
+            | {"mode":"group","group_name":"测试"} | {"mode":"all"},
+    "schedule": {"mode":"once"} | {"mode":"cron","cron":"0 8 * * *"}
+               | {"mode":"cron_stop","cron":"0 8 * * *","stop_cron":"0 9 * * *"},
+    "retry": {"max_attempts":5,"delay":30},
+    "enabled": true,
+    "params": {
+      "max_duration": 0,
+      "steps": [
+        {"type":"open_app","label":"打开抖音","params":{"package":"com.ss.android.ugc.aweme","wait_home":true}},
+        {"type":"loop","params":{"loop_mode":"rounds","max_iterations":30,"children":[
+           {"type":"wait","params":{"min":5,"max":35}},
+           {"type":"swipe","params":{"direction":"up","duration_min":0.25,"duration_max":0.5}}
+        ]}}
+      ]
+    }
+  },
+  "notes": ["评论按钮需先进入视频页才可见"],
+  "evidence": [{"screen":"抖音首页","element":{"text":"关注","id":"..."},"xpath":"//*[@resource-id=\".../gvo\"]"}]
+}
+```
+- 步骤节点结构：`{id?, type, label?, params}`；`id` 执行端忽略（编辑器重新生成），`params` 必填。
+- 必填字段语义（**空值会被执行端静默跳过**，校验器必须拦）：
+  - `click / long_click / swipe_until / wait_el / if_el` → `params.selector_value`
+  - `open_app / stop_app` → `params.package`
+  - 容器：`loop / group` → `params.children`（非空）；`if_el` → `params.then`（`else` 可选）
+  - `swipe_until` → direction + max_swipes；`click_xy` P0 不产（如允许则 x/y 0-100）
+  - 节点公共可选 `params.probability`（0-100，缺省 100）
+- `selector_type` 允许值：`xpath / description / text / resourceId / descriptionContains / className`（`if_el` 可 `ocr`）。
+
+### 4.3 服务端新增
+- `core/task_draft.py`：
+  - `STEP_TYPES` 白名单 + 每类必填/深度校验 `validate_steps(steps, depth)`（嵌套≤5）；
+  - `validate_draft(draft)`：任务信封（name 非空、task_type==generic_steps、target mode ∈ {all,group,serial}（group 名存在）、schedule cron 合法、steps 校验）；
+  - 归一化：把 `schedule` 里「每天 8-9 点」这类由前端/向导填的值转成 cron/cron_stop。
+- `web/taskgen_api.py`（或并入 `agent_api`，推荐并入以最大化复用）：
+  - 入口检查：serial 必须、设备在池/在线、worker 非 running/connecting（409，与现有语义一致）；
+  - 起 designer 后台线程；SSE 事件在现有 `delta/step/done/error` 基础上，`done` 可带 `draft`。
+- **注意**：现有 `POST /api/jobs` 对 params **盲存**（只校验 name+task_type）。AI 通道在**保存前**必须过 `validate_steps`，避免「任务 done 但什么都没做」（执行器对未知 type/空 selector 静默跳过）。
+
+### 4.4 前端
+- `monitor.html` AI 控制台加模式切换；建任务模式下输入栏旁有折叠「任务设置」（名称/调度时间/目标 serial·分组·全部/备注）。
+- `agent.js`：done 携带 draft 后：
+  - generic_steps → 调 `openTaskModal()`（tasks.js）并把 `draft.task` 灌入步骤编辑器（step 卡片可视化、可拖改、单步试跑、保存）；
+  - 弹窗内对 `notes`（含“需人工复核/OCR 兜底”项）给出醒目提示。
+- 过程回放沿用现有 `agent-toolcard` 渲染；可标记当前为 designer 轮以便后续区分。
+
+## 5. 约束与安全（红线）
+
+### 5.1 Designer 自探规则（写入提示词）
+1. 先 `de_open_app(package)`，再 `de_ui_tree` + `de_screenshot` 看每屏；点到关键状态后再 dump 下一屏。
+2. 每个将写入步骤的目标元素，先用 `de_tap_element`（by=text/id/desc…）+ 截图**确认可命中**，并记下证据。
+3. **不做破坏性动作**：需“评论/发送”时只确认输入框/发送键存在，不真发；产物里这类步骤 `probability` 调低并在 notes 标注“请人工复核”。
+4. 探索步数上限（P0 建议 30 步），可被 `/stop` 打断；结束后尽力还原前台 App。
+5. 未命中的元素一律不进任务；拿不准的进 notes 而非硬编。
+
+### 5.2 平台级约束
+- 自探/试跑只在**用户选的空闲设备**（busy → 409），杜绝与运行中任务在设备上物理打架。
+- AI 不直接建库；生成任务仍需用户点保存（POST /api/jobs 现有权限）。
+- 尽量不写死坐标；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` 拒绝语义）。
+- **P2**：自定义动作支持（内联展开成 group，或新增 `action_ref` 节点 + 执行器/编辑器同步）；多设备并行；成本与 token 控制。
+
+## 7. 实现时需新增/改动文件（规划）
+- 改：`mcp_agent/`（designer 提示词与 `submit_task` 工具、结构化 trace）、`web/agent_api.py`（mode=designer、done 带 draft）、`static/admin/agent.js` + `templates/admin/monitor.html`（模式切换/任务设置/draft 预填）、`doc/`（本文档关联）。
+- 新：`core/task_draft.py`（schema+校验+归一化）、（可选）`web/taskgen_api.py`。
+- 不动：任务执行器、调度器、`POST /api/jobs` 主体（保持现有盲存，只在 AI 通道校验）。
+
+## 8. 验收（P0 实现后自测）
+1. 目标设备空闲时：需求「每日 8-9 点刷抖音养号」→ 生成 generic_steps 任务，步骤为 `open_app → loop(wait+swipe)` 结构，调度 cron_stop 8-9 点。
+2. 打开编辑器中该任务：步骤卡片完整、可拖改、单步试跑命中；保存后任务列表出现且下次运行时间正确。
+3. 反例：模型产出含 `click_xy` 或未知 type / 空 selector → 服务端校验拦截并让模型补正；busy 设备入口 409。
+4. 探索全程可在前端回放（工具卡+截图），未发送真实评论/未污染设备状态。
+
+## 9. 需要转成 MCP / 平台工具的能力（分层，2026-09-09 与用户确认）
+
+> 背景问答结论：目前 MCP 只有**设备层 19 个 `de_*`**（控制 + 只读 `de_list_tasks`），平台 CRUD（任务增改/启停/立即运行、分组、设备池、自定义动作、APK、备份、用户）**都还没 MCP 化**。方向认同「先把工具链补完善」，但不做"把所有平台 CRUD 一次性搬成 MCP"的大而全——**按消费方（AI 建任务 / 外部自动化）分层、按需补**。新增 MCP 工具一律：进 `doc/MCP.md` 手册 + `doc/MCP_DESIGN.md` 规格 + 与 web 同源的权限/busy/审计 + 校验逻辑下沉到 `core/` 共用（防双份漂移）。
+
+### 9.1 现状盘点
+- MCP（`mcp_server/mcp_server.py`，19 个 `de_*`）＝ 设备控制 + 设备只读 + `de_list_tasks`（平台任务只读）。
+- 任务创建/修改/删除、toggle、立即运行、分组、设备池管理、自定义动作、APK、系统备份等 **REST 路由只给前端用，未暴露 MCP**。
+
+### 9.2 P0 —— AI 建任务链路真正需要的「平台工具」（最小集）
+只补两小类，其余设备操作全部复用现有 `de_*`：
+1. **只读清单**（供自探确定 target/能不能做）：
+   - `list_task_types` / `list_groups`（target 选 group 用）/ `list_pool`（可调度设备，含 busy 状态）
+   - （可与现有 `de_list_devices` 合并语义，避免重复）
+2. **校验 + 提交（结束性）**：
+   - `submit_task(draft)` → 服务端用 **共用** `core/task_draft.validate_steps()/validate_draft()` 校验，**不直接落库**，返回 draft 供前端打开步骤编辑器预填、人工确认后走 `POST /api/jobs`。
+
+> 关键：P0 的 Agent **不暴露任务 CRUD 写权限**（create/update/toggle/run），否则模型可绕过"AI 提案 → 人工确认"直接入库，破坏信任模型。
+
+### 9.3 P1 —— 外部自动化 / 后续 Agent 的「写 MCP」（受权限约束，逐块加）
+若目标延伸为"外部程序能像调 REST 一样操控平台"，则按此清单**逐个**补（每加一个都做权限+busy+审计+校验下沉）：
+- 任务：`create_job` / `update_job` / `delete_job` / `toggle_job` / `run_job_now` / `query_jobs`
+- 分组：`list_groups` / `create_group` / `update_group` / `delete_group`
+- 设备池：`pool_list` / `pool_add` / `pool_remove` / `pool_toggle`
+- 自定义动作 / APK 清单 等视使用再加
+- **只读清单优先搬**；写类确认有真实消费方再做，避免空转。
+
+### 9.4 分层与登记（红线）
+- 每新增/修改/删除一个 MCP 工具或平台配置：同步更新 `doc/MCP.md`（全清单）、`doc/MCP_DESIGN.md`（规格/层级），并在提交里体现——见全局「doc 同步红线」。
+- `core/task_draft.py` 是 web 校验与 MCP 校验的**唯一来源**，杜绝两套规则漂移。

doc/API.md

@@ -1,6 +1,6 @@
 # API 接口文档
 
-`platform-tools` Web 后台提供 JSON API，所有接口需登录后访问（Flask-Login session 认证）。
+`platform-tools` Web 后台提供 JSON API，绝大多数接口需登录后访问（Flask-Login session 认证）；免登录例外见下方权限模型。
 
 **Base URL**：`http://localhost:18050`
 
@@ -15,16 +15,17 @@
 ---
 
 **权限模型**（v2 起）：
-- 所有接口需登录；**查看类 GET 接口**（状态/列表/截图）所有登录用户可用
+- 所有接口需登录（Flask-Login session）；**免登录例外**：`GET /api/health`（探活）、`GET /locate`（设备端定位页，只显示 serial 文本）、`/login` 与静态资源
+- **多数查看类 GET**（状态/任务/分组/自定义动作/APK 列表等）仅需登录即可用；设备维护/看屏/元素抓取类 GET 需对应 `devices` 权限
 - **写操作按权限位授权**（管理员拥有全部权限）：
   | 权限位 | 中文 | 覆盖接口 |
   |--------|------|---------|
   | `tasks` | 任务管理 | 任务/自定义动作/分组的增删改、启停、立即执行 |
-  | `devices` | 设备控制 | 停止设备、释放占用、清除异常、前台扫描、元素抓取 |
+  | `devices` | 设备控制 | 停止设备、清除异常、定位、前台扫描、远程看屏/触控、元素抓取、设备池管理、自动发现 |
   | `apks` | 应用管理 | APK 上传、安装、删除 |
   | `logs` | 日志查看 | `GET /api/logs` |
-- **用户管理接口仅管理员可用**（普通用户即使被授予业务权限也无法访问）
-- 无权限访问返回 `403 {"ok": false, "error": "无权限执行此操作..."}`
+- **仅管理员可用**（普通用户即使被授予业务权限也无法访问）：AI 控制台 `/api/agent/*`、系统备份 `/api/system/backup/*`、Tailscale `/api/tailscale/*`、用户管理 `/api/users`、adb 终端 `/api/adb/*`、工具 `/api/tools/*`
+- 403 文案两种：业务权限缺失 → `{"ok": false, "error": "无权限执行此操作（需要权限: X）"}`；仅管理员接口被非管理员访问 → `{"ok": false, "error": "仅管理员可执行此操作"}`
 - 当前用户权限查询：`GET /api/me`
 
 ---
@@ -47,25 +48,55 @@
 
 登出，重定向到登录页。
 
+### GET /api/me
+
+当前登录用户信息（含权限位），前端据此隐藏无权限的功能入口。需登录。
+
+**响应**：
+```json
+{"ok": true, "user": {
+  "id": 1, "username": "admin", "is_admin": true,
+  "perms": ["tasks", "devices", "apks", "logs"]
+}}
+```
+管理员返回全部权限位；普通用户返回其被授予的业务权限数组。
+
+### GET /api/csrf
+
+获取当前会话的 CSRF token（登录后先获取一次；变更类请求需在 `X-CSRF-Token` 请求头携带）。
+
+**响应**：
+```json
+{"ok": true, "token": "…"}
+```
+
 ---
 
 ## 2. 页面路由
 
 ### GET /
 
-单页应用首页（需登录）。响应头设置 `Cache-Control: no-store` 防止缓存。
+单页应用首页（需登录）。响应头设置 `Cache-Control: no-store, no-cache, must-revalidate, max-age=0`（并带 `Pragma: no-cache`）防止缓存。
 
 ### GET /login
 
 登录页面（GET）。
 
+### GET /wall
+
+监控大屏页面（需登录，全屏深色控制室风格，供挂墙/电视展示）：设备卡片网格
+（缩略图/型号/状态/当前动作/进度）、顶部统计与时钟；状态每 5s 刷新、缩略图每 2.5s 轮询。
+20 台设备整体开销约 0.2 核 CPU + 100KB/s 带宽，普通电脑无压力。
+
 ---
 
 ## 3. 设备状态
 
 ### GET /api/status
 
-获取设备池 + Worker 综合状态（带 5 秒缓存）。
+获取设备池 + Worker 综合状态（带 5 秒缓存；worker 状态实时读内存）。需登录。
+
+字段说明：`server_time` 服务端时间戳；`fg_scanning`/`fg_last_scan` 前台 App 扫描状态；`devices` 设备数组。
 
 **响应**：
 ```json
@@ -81,27 +112,58 @@
       "device_name": "测试机1",
       "present": true,
       "ready": true,
-      "stf_occupied": false,
       "owner": "",
-      "worker_status": "idle",
-      "foreground_app": "空闲",
+      "worker_status": "running",
+      "foreground_app": "抖音",
       "progress": {"done": 5, "total": 80, "unit": "视频", "action_counts": {"like": 3}},
       "current_action": "观看视频 6",
       "last_error": "",
+      "last_warning": "",
       "running_job": "",
       "task_job": "",
-      "attempt": 0
+      "attempt": 0,
+      "end_time": 0
     }
   ]
 }
 ```
 
-**worker_status 取值**：`idle` / `connecting` / `running` / `done` / `error` / `failed` / `released`
+`worker_status` 取值：`idle` / `connecting` / `running` / `done` / `error` / `failed`
 
-（权限：设备控制）
+### GET /api/summary
+
+失败/异常任务汇总（供监控页"异常汇总"面板），观察设备长期健康度。需登录。
+
+**响应**：
+```json
+{
+  "ok": true,
+  "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}
+  ]
+}
+```
+`counts` 各状态计数；`errors` 为 `error`/`failed` 且有 `last_error` 的异常设备
+（按最近心跳倒序，最多 50 条；已不在设备池的陈旧失败记录不展示）。
+
+### GET /api/health
+
+轻量健康检查（免登录，供运维探活）：进程存活 + 设备/任务摘要，不暴露敏感信息。
+
+**响应**：
+```json
+{"ok": true, "status": "up", "time": 1700000000.0, "device_total": 8,
+ "device_online": 6, "device_running": 2, "device_error": 1, "jobs": 3}
+```
+
+### POST /api/scan_foreground
 
 手动触发前台 App 扫描（后台异步执行，不打扰设备）。
 
+（权限：设备控制）
+
 **响应**：
 ```json
 {"ok": true, "msg": "扫描已启动"}
@@ -117,6 +179,18 @@
 {"ok": true, "devices": ["192.168.1.100:5555", "192.168.1.101:5555"]}
 ```
 
+### GET /api/devices/<serial>/apps
+
+获取指定设备上已安装的应用列表（包名 + versionCode/versionName + APK 路径 + 应用名）。需登录。
+
+**响应**：
+```json
+{"ok": true, "apps": [
+  {"package": "com.ss.android.ugc.aweme", "path": "/data/app/.../base.apk",
+   "version_code": 2500, "version_name": "25.0.0", "label": "抖音"}
+]}
+```
+
 ### GET /api/device/screenshot
 
 获取设备当前画面截图（PNG）。
@@ -198,10 +272,12 @@
 ```
 `next_run`：下次真正执行时间（已按运行窗口跳过窗口外触发点，格式 `YYYY-MM-DD HH:MM`）；手动任务/已停用为 `null`。
 
-（权限：任务管理）
+### POST /api/jobs
 
 创建任务计划。
 
+（权限：任务管理）
+
 **请求**（JSON）：
 ```json
 {
@@ -228,10 +304,12 @@
 | `stop_cron` | （cron_stop 必填）到点停止本任务 worker |
 | `window` | 可选，运行窗口 `{"start": "21:00", "end": "09:00"}`（每天重复，支持跨午夜）。窗口外定时触发和手动执行（`POST /api/jobs/:id/run`）均不启动，手动执行返回错误提示 |
 
-（权限：任务管理）
+### PUT /api/jobs/<job_id>
 
 更新任务计划。只需传要更新的字段。
 
+（权限：任务管理）
+
 **请求**（JSON）：
 ```json
 {"params": {"watch_count": 100}}
@@ -242,25 +320,29 @@
 {"ok": true, "msg": "任务已更新", "job": {"...": "..."}}
 ```
 
-（权限：任务管理）
+### DELETE /api/jobs/<job_id>
 
-删除任务计划。
+删除任务计划。不存在返回 404。
+
+（权限：任务管理）
 
 **响应**：
 ```json
 {"ok": true, "msg": "任务已删除"}
 ```
 
-（权限：任务管理）
+### POST /api/jobs/<job_id>/run
 
 立即执行任务（异步，不阻塞）。
 
+（权限：任务管理）
+
 **响应**：
 ```json
 {"ok": true, "msg": "任务 抖音养号 已触发"}
 ```
 
-（权限：任务管理）
+### POST /api/jobs/<job_id>/toggle
 
 启用/停用任务。
 
@@ -292,36 +374,50 @@
 }
 ```
 
-（权限：任务管理）
+### POST /api/groups
 
-创建分组。
+创建分组。重名返回 400。
+
+（权限：任务管理）
 
 **请求**（JSON）：
 ```json
 {"name": "A组", "serials": ["192.168.1.100:5555"], "description": "测试组"}
 ```
 
-（权限：任务管理）
+**响应**：`{"ok": true, "msg": "分组已创建"}`
 
-更新分组。
+### PUT /api/groups/<name>
+
+更新分组（serials/description 按需传字段）。`<name>` 不存在返回 404。
+
+（权限：任务管理）
 
 **请求**（JSON）：
 ```json
 {"serials": ["192.168.1.100:5555", "192.168.1.101:5555"], "description": "更新描述"}
 ```
 
+**响应**：`{"ok": true, "msg": "分组已更新"}`
+
+### DELETE /api/groups/<name>
+
+删除分组。不存在返回 404。
+
 （权限：任务管理）
 
-删除分组。
+**响应**：`{"ok": true, "msg": "分组已删除"}`
 
 ---
 
 ## 7. 运行控制
 
-（权限：设备控制）
+### POST /api/stop_device
 
 停止单台设备的 worker（并阻止后续重试）。
 
+（权限：设备控制）
+
 **请求**（JSON）：
 ```json
 {"serial": "192.168.1.100:5555"}
@@ -332,67 +428,107 @@
 {"ok": true, "msg": "已发送停止信号给 192.168.1.100:5555"}
 ```
 
-（权限：设备控制）
+### POST /api/stop_all
 
 停止所有运行中的 worker。
 
+（权限：设备控制）
+
 **响应**：
 ```json
 {"ok": true, "stopped": ["192.168.1.100:5555", "192.168.1.101:5555"]}
 ```
 
+> 旧「释放设备占用」端点已随 STF 摘除移除，此接口不再存在；设备互斥由调度器内存锁保证。
+
+### POST /api/device/clear_error
+
+清除单台设备的异常状态（`error`/`failed` → `idle`），供设备列表"清除异常"按钮使用。
+设备正在运行或等待重试时返回 400。
+
 （权限：设备控制）
 
-（已随 STF 摘除移除，此接口不再存在；设备互斥由调度器内存锁保证）
+**请求**（JSON）：
+```json
+{"serial": "192.168.1.100:5555"}
+```
 
 **响应**：
 ```json
-{"ok": true, "released": ["192.168.1.100:5555"]}
+{"ok": true, "msg": "已清除 192.168.1.100:5555 的异常状态"}
+```
+
+### POST /api/device/clear_all_errors
+
+一键清除所有异常/失败设备（自动跳过正在运行/等待重试的）。
+
+（权限：设备控制）
+
+**响应**：
+```json
+{"ok": true, "cleared": 2, "msg": "已清除 2 台设备的异常状态"}
 ```
 
 ---
 
 ## 8. 用户管理
 
-（仅管理员）
+用户管理接口**仅管理员可用**（非管理员返回 403 `仅管理员可执行此操作`）。`uid` 为用户 id（整数）。
+
+### GET /api/users
 
 列出所有用户。
 
 **响应**：
 ```json
-{"ok": true, "users": [{"id": 1, "username": "admin", "is_admin": true}]}
+{"ok": true, "users": [
+  {"id": 1, "username": "admin", "is_admin": true, "perms": []},
+  {"id": 2, "username": "user1", "is_admin": false, "perms": ["tasks", "devices"]}
+]}
 ```
+`perms`：用户被授予的业务权限位数组（存储值；管理员以 `is_admin` 为准，perms 照常保存，取消管理员后按 perms 生效）。
 
-（仅管理员）
+### POST /api/users
 
 创建用户。
 
 **请求**（JSON）：
 ```json
-{"username": "user1", "password": "pass123", "is_admin": false}
+{"username": "user1", "password": "pass123", "is_admin": false, "perms": ["tasks"]}
 ```
+`perms` 可选，默认无业务权限；`is_admin` 默认 false。
 
-（仅管理员）
+**响应**：`{"ok": true, "msg": "用户已创建"}`
 
-更新用户（修改密码/管理员权限）。
+### PUT /api/users/<uid>
+
+更新用户（改密码 / 管理员权限 / 权限位），只需传要改的字段。`uid` 不存在返回 404。
 
 **请求**（JSON）：
 ```json
 {"password": "newpass", "is_admin": true}
 ```
 
-（仅管理员）
+**响应**：`{"ok": true, "msg": "用户已更新"}`
+> 不能取消最后一个管理员（返回 400）。
 
-删除用户（不能删除 admin 和当前登录用户）。
+### DELETE /api/users/<uid>
+
+删除用户。`uid` 不存在返回 404。
+
+**响应**：`{"ok": true, "msg": "用户已删除"}`
+> 不能删除默认管理员 `admin`、不能删除当前登录用户、也不能删除最后一个管理员（均返回 400）。
 
 ---
 
 ## 9. 日志
 
-（权限：日志查看）
+### GET /api/logs
 
 查看日志文件内容。
 
+（权限：日志查看）
+
 **参数**：
 | 参数 | 类型 | 默认 | 说明 |
 |------|------|------|------|
@@ -407,9 +543,10 @@
   "ok": true,
   "content": "2026-08-08 10:00:00 [INFO] [core.worker] ...",
   "file": "core.log",
-  "files": {"core": "core.log", "task": "task.log", "web": "web.log", "action": "action.log"}
+  "files": ["core.log", "task.log", "web.log", "action.log"]
 }
 ```
+`files`：可选日志文件名数组。
 
 ---
 
@@ -417,24 +554,49 @@
 
 ### GET /api/custom_actions
 
-列出所有自定义动作（步骤打包）。
+列出所有自定义动作（步骤打包）。需登录。
 
-（权限：任务管理）
+**响应**：
+```json
+{"ok": true, "actions": [
+  {"id": "a1b2c3d4", "name": "登录流程", "icon": "📦",
+   "steps": [{"type": "click", "...": "..."}], "created_at": "2026-08-08 10:00:00"}
+]}
+```
+
+### POST /api/custom_actions
 
 创建自定义动作。
 
+（权限：任务管理）
+
 **请求**（JSON）：
 ```json
 {"name": "登录流程", "icon": "📦", "steps": [{"type": "click", "...": "..."}]}
 ```
 
-（权限：任务管理）
+**响应**：`{"ok": true, "msg": "动作已保存", "action": {...}}`
 
-更新自定义动作。
+### PUT /api/custom_actions/<action_id>
+
+更新自定义动作（name/icon/steps，按需传字段）。不存在返回 404。
 
 （权限：任务管理）
 
-删除自定义动作。
+**请求**（JSON）：
+```json
+{"name": "登录流程 v2", "steps": [{"type": "click", "...": "..."}]}
+```
+
+**响应**：`{"ok": true, "msg": "已更新", "action": {...}}`
+
+### DELETE /api/custom_actions/<action_id>
+
+删除自定义动作。不存在返回 404。
+
+（权限：任务管理）
+
+**响应**：`{"ok": true, "msg": "已删除"}`
 
 ---
 
@@ -449,18 +611,22 @@
 {"ok": true, "running": true}
 ```
 
-（权限：设备控制）
+### GET /api/uiauto/devices
 
-获取 uiauto2 已连接的设备列表。
+获取 uiauto2 已连接的设备列表。uiautodev 本地服务未运行（或列表获取失败）返回 503。
+
+（权限：设备控制）
 
 **响应**：
 ```json
 {"ok": true, "devices": [{"serial": "192.168.1.100:5555", "model": "Pixel 6"}]}
 ```
 
-（权限：设备控制）
+### GET /api/uiauto/screenshot
 
-通过 uiauto2 获取设备截图（JPEG）。
+通过 uiauto2 获取设备截图（JPEG）。uiautodev 本地服务未运行返回 503。
+
+（权限：设备控制）
 
 **参数**：
 | 参数 | 类型 | 说明 |
@@ -469,9 +635,11 @@
 
 **响应**：成功返回 `image/jpeg`，失败返回 JSON 错误。
 
-（权限：设备控制）
+### GET /api/uiauto/elements
 
-获取设备 UI 元素树。
+获取设备 UI 元素树。uiautodev 本地服务未运行返回 503。
+
+（权限：设备控制）
 
 **参数**：
 | 参数 | 类型 | 说明 |
@@ -523,10 +691,12 @@
 }
 ```
 
-（权限：应用管理）
+### POST /api/apks/upload
 
 上传 APK 文件（自动解析包名/版本/应用名）。
 
+（权限：应用管理）
+
 **请求**（multipart/form-data）：
 | 字段 | 类型 | 说明 |
 |------|------|------|
@@ -537,14 +707,20 @@
 {"ok": true, "apk": {"...": "..."}, "msg": "上传成功: 抖音"}
 ```
 
-（权限：应用管理）
+### DELETE /api/apks/<apk_id>
 
 删除 APK 文件和记录。
 
 （权限：应用管理）
 
+**响应**：`{"ok": true, "msg": "..."}`；删除失败返回 400。
+
+### POST /api/apks/install
+
 批量安装 APK 到指定设备。
 
+（权限：应用管理）
+
 **请求**（JSON）：
 ```json
 {"apk_id": "abc123", "serials": ["192.168.1.100:5555", "192.168.1.101:5555"]}
@@ -557,13 +733,17 @@
 
 ### GET /api/apks/install/devices
 
-可安装设备列表：设备池在线设备（标记 `pool`）+ 本机 adb 设备（**含 USB 有线连接**，serial 无冒号标记 `usb`）。
+可安装设备列表：设备池在线设备 + 本机 adb 设备（含 USB 有线连接）。
 安装弹窗用此列表，USB 设备安装时跳过 adb connect 直接安装。
+`source` 取值：`pool`=设备池在线；`usb`=本机 USB 有线（serial 无冒号）；`adb`=本机网络 adb（serial 含冒号）。
+
+（权限：应用管理）
 
 **响应**：
 ```json
 {"ok": true, "devices": [
-  {"serial": "100.100.10.11:5555", "model": "22120RN86C", "source": "stf"},
+  {"serial": "100.100.10.11:5555", "model": "22120RN86C", "source": "pool"},
+  {"serial": "192.168.1.5:5555", "model": "", "source": "adb"},
   {"serial": "ZY322ABCDEF", "model": "", "source": "usb"}
 ]}
 ```
@@ -595,10 +775,11 @@
 
 ---
 
-## 13. 维护 / 工具（仅管理员）
+## 13. 维护 / 工具
 
-以下接口都**仅管理员可用**（普通用户即使有业务权限也访问不了，返回 403）。
-设备池管理、远程看屏、adb 终端等集中在"工具"页（页内子分栏）。
+设备池管理、自动发现、远程看屏/触控、定位、维护终端等集中在"工具"页（页内子分栏）。
+**权限说明**：设备池管理、自动发现、远程看屏/触控、定位等接口需 `devices` 权限；
+**adb 终端仅管理员可用**（见各节标注）。
 
 ### GET /api/devices/pool
 
@@ -636,6 +817,69 @@ IP:5555 设备添加后立即尝试 adb connect，并后台采集型号（getpro
 
 批量采集池内在线设备的型号（后台执行）。**权限**：`devices`。
 
+### GET /api/devices/discovery
+
+自动发现状态 + 待连接列表（pending）+ 正式池断联设备。前端约 10s 轮询一次。**权限**：`devices`。
+
+**响应**：
+```json
+{
+  "ok": true,
+  "enabled": true, "subnets": ["192.168.1.0/24"], "interval": 60, "port": 5555,
+  "scanning": false,
+  "last_scan": "2026-08-08 10:00", "last_result": {"found": 12, "verified": 3, "new": 1},
+  "last_error": "", "pending_count": 2,
+  "pending": [{"serial": "192.168.20.5:5555", "source": "lan",
+               "first_seen": "2026-08-08 10:00", "last_seen": "2026-08-08 10:05", "online": true}],
+  "pool_offline": [{"serial": "192.168.1.100:5555", "model": "Pixel 6", "name": "测试机1"}]
+}
+```
+`pending` 只列当前在线设备（离线候选不可确认，下轮扫描自动更新）；`pool_offline`
+为正式池中已断联设备（发现线程每轮自动重连，也可手动触发重连）。
+
+### POST /api/devices/discovery/scan
+
+手动触发一轮扫描（后台执行，约 5-30 秒）。**权限**：`devices`。
+扫描只验证并把新设备放进待连接池（pending），**确认后才入正式设备池**。
+
+**响应**：
+```json
+{"ok": true, "msg": "扫描已启动（后台执行，约 5-30 秒）",
+ "result": {"found": 12, "verified": 3, "new": 1}}
+```
+扫描进行中返回 409；未配置网段返回 400 并附原因。
+
+### POST /api/devices/discovery/confirm
+
+确认连接：把待连接设备加入正式设备池并后台 adb connect/采型号。**权限**：`devices`。
+
+**请求**（JSON）：`{"serial": "192.168.20.5:5555", "name": "客厅机"}`
+**响应**：`{"ok": true, "msg": "已加入设备池", "is_new": true}`
+
+### POST /api/devices/discovery/ignore
+
+忽略：从待连接列表删除（下轮扫描可能再次发现）。**权限**：`devices`。
+
+**请求**（JSON）：`{"serial": "..."}`
+**响应**：`{"ok": true, "msg": "已忽略"}`
+
+### POST /api/devices/discovery/reconnect
+
+手动立即重连正式池中的断联设备（后台 adb connect + 采型号）。**权限**：`devices`。
+日常无需手动——发现线程每轮（默认 60s）自动重连断联设备。
+
+**请求**（JSON）：`{"serial": "..."}`
+**响应**：`{"ok": true, "msg": "重连已启动（约 5-15 秒生效）"}`
+
+### POST /api/devices/discovery/settings
+
+保存自动发现配置（部分字段更新）。**权限**：`devices`。
+
+**请求**（JSON）：`{"enabled": true, "subnets": ["192.168.1.0/24"], "interval": 60, "port": 5555}`
+`interval` 需在 10-3600 秒之间；`subnets` 逐项校验 CIDR，非法返回 400。
+
+**响应**：`{"ok": true, "msg": "已保存"}`
+
 ### GET /api/screen/stream
 
 远程看屏：MJPEG 实时画面流（`multipart/x-mixed-replace`）。**权限**：`devices`。
@@ -649,12 +893,6 @@ IP:5555 设备添加后立即尝试 adb connect，并后台采集型号（getpro
 `?serial=xxx` 指定设备。监控大屏按设备每 ~2.5s 轮询一帧（页面不可见时暂停）；
 一次性请求（非流），与任务并发安全（与任务截图同走 u2 minicap）。
 
-### GET /wall
-
-监控大屏页面（全屏深色控制室风格，登录后可访问）：设备卡片网格（缩略图/型号/
-状态/当前动作/进度）、顶部统计与时钟；状态每 5s 刷新、缩略图每 2.5s 轮询。
-20 台设备整体开销约 0.2 核 CPU + 100KB/s 带宽，普通电脑无压力。
-
 ### POST /api/screen/tap
 
 点击设备屏幕。**权限**：`devices`。
@@ -673,6 +911,26 @@ IP:5555 设备添加后立即尝试 adb connect，并后台采集型号（getpro
 
 输入文字（需焦点在输入框）。**请求**（JSON）：`{"serial": "...", "text": "你好"}`
 
+### POST /api/screen/tap_text
+
+按屏幕文字点击：先在 UI 树里做 text/description 子串匹配点元素中心（原生控件）；
+未命中则截图 OCR 找文字中心（WebView/图片/画布渲染文字）。**权限**：`devices`。
+
+**请求**（JSON）：`{"serial": "...", "text": "立即下载"}`
+**响应**：
+```json
+{"ok": true, "found": true, "method": "ui", "matched": "立即下载", "x": 540, "y": 1200}
+```
+`method`：`ui` 或 `ocr`；`found=false` 表示屏幕确实没有该文字（业务结果，非设备错误）。
+
+### GET /api/screen/size
+
+获取设备屏幕原生分辨率（只读，供坐标换算——截图常是缩放图、操作需原生坐标）。**权限**：`devices`。
+离线/不可达返回 503。
+
+`?serial=xxx`
+**响应**：`{"ok": true, "width": 1080, "height": 2400}`
+
 ### POST /api/device/screen_all
 
 批量亮屏/息屏（并发）。**权限**：`devices`。
@@ -683,9 +941,25 @@ IP:5555 设备添加后立即尝试 adb connect，并后台采集型号（getpro
 ```
 `serials` 可选：指定设备（离线自动过滤）；不带则作用于全部在线设备。息屏会中断运行中的任务，前端有确认提示。
 
+### POST /api/device/locate
+
+定位设备：点亮屏幕并解锁（WAKEUP → dismiss-keyguard → MENU 兜底）。
+`show=true` 时额外用设备浏览器打开平台 `/locate` 大字定位页（更醒目，但会切换前台，任务运行中慎用）。**权限**：`devices`。
+
+**请求**（JSON）：`{"serial": "192.168.1.100:5555", "show": true}`
+**响应**：`{"ok": true, "msg": "192.168.1.100:5555 屏幕已点亮；已打开大字定位页（按返回键退出）"}`
+
+### POST /api/device/locate/stop
+
+结束定位：优先 force-stop 定位时启动的浏览器（无论前后台都能关掉）；无记录时前台是
+浏览器则 force-stop，否则按返回键轻量退出（不误杀任务应用）。**权限**：`devices`。
+
+**请求**（JSON）：`{"serial": "..."}`
+**响应**：`{"ok": true, "msg": "已关闭浏览器 com.android.chrome"}`
+
 ### GET /api/adb/devices
 
-维护终端设备列表：本地 adb 已连接（含 offline）+ 设备池已配置设备（标记 `pool`）。
+维护终端设备列表（**仅管理员**）：本地 adb 已连接（含 offline）+ 设备池已配置设备（标记 `pool`）。
 供终端设备选择器使用——选中后前端自动附加 `-s <serial>`。
 
 **响应**：
@@ -693,13 +967,13 @@ IP:5555 设备添加后立即尝试 adb connect，并后台采集型号（getpro
 {"ok": true, "devices": [
   {"serial": "100.100.10.11:5555", "state": "device"},
   {"serial": "100.100.10.13:5555", "state": "offline"},
-  {"serial": "100.100.10.12:5555", "state": "stf"}
+  {"serial": "100.100.10.12:5555", "state": "pool"}
 ]}
 ```
 
 ### POST /api/adb/cmd
 
-adb 远程终端：用平台 adb 二进制执行任意 adb 命令（20s 超时）。
+adb 远程终端（**仅管理员**）：用平台 adb 二进制执行任意 adb 命令（20s 超时）。
 
 **请求**（JSON）：
 ```json
@@ -716,7 +990,7 @@ adb 远程终端：用平台 adb 二进制执行任意 adb 命令（20s 超时
 
 ---
 
-## 14. 步骤测试（仅管理员可触发，需"设备控制"权限）
+## 14. 步骤测试（需"设备控制"权限）
 
 ### POST /api/steps/test
 
@@ -744,7 +1018,9 @@ adb 远程终端：用平台 adb 二进制执行任意 adb 命令（20s 超时
 
 工具页"Tailscale 管理"子分栏，调用 Tailscale 官方 API v2。所有接口仅管理员可用。
 前置：`.env` 配置 `TAILSCALE_API_KEY`（Settings → API Access Tokens）与
-`TAILSCALE_TAILNET`（tailnet 名，个人账号一般为邮箱前缀）；未配置返回 502 并附提示。
+`TAILSCALE_TAILNET`（tailnet 名，个人账号一般为邮箱前缀）。
+`GET /api/tailscale/status` 未配置时返回 `200 {"ok": true, "configured": false}` 并附 `hint` 提示；
+其余接口在未配置/调用失败时返回 `502` 并附错误信息。
 设备 IP 由 tailnet 分配，API 不可修改，列表只读展示。
 
 ### GET /api/tailscale/status
@@ -814,7 +1090,7 @@ adb 远程终端：用平台 adb 二进制执行任意 adb 命令（20s 超时
 
 ## 16. 工具（仅管理员）
 
-工具页（剪贴板注入 / 应用版本管理 / 设备池管理）接口，均仅管理员可用。
+工具页（剪贴板注入 / 应用版本管理）接口，均仅管理员可用。
 
 ### POST /api/tools/clipboard/set
 
@@ -825,8 +1101,12 @@ adb 远程终端：用平台 adb 二进制执行任意 adb 命令（20s 超时
 {"serials": ["100.100.10.11:5555", "0123456789ABCDEF"], "text": "要注入的文字"}
 ```
 设备来源与维护终端一致（本地 adb 含 USB + 设备池）。
-实现：u2 `jsonrpc.setClipboard`（实测 `cmd clipboard` 在 MIUI 上不存在），支持中文/引号/换行；
-IP 设备先 adb connect（已连接跳过，绝不 disconnect），USB 设备首次自动推送 atx-agent。
+实现：通过 ClipInject（`com.example.clipinject`）透明 Activity 前台聚焦后写入剪贴板
+（shell 启动前台 Activity 不受后台启动限制），再用 u2 读回比对校验，支持中文/引号/换行。
+不再使用 u2 setClipboard / 自动推送 atx-agent（Android 10+ 禁止后台写剪贴板，旧 u2
+调用"成功"但内容被系统静默丢弃）。
+IP 设备先 adb connect（已连接跳过，绝不 disconnect）；**设备未安装 ClipInject 时** am start
+返回 unable to resolve Intent，接口明确报错提示先安装。
 
 **响应**：
 ```json
@@ -849,3 +1129,193 @@ IP 设备先 adb connect（已连接跳过，绝不 disconnect），USB 设备
  "results": {"100.100.10.11:5555": {"installed": true, "version_name": "28.5.0", "version_code": "280500"}}}
 ```
 未安装返回 `installed: false`；查询失败的设备带 `error` 字段。
+
+---
+
+## 17. AI 控制台（仅管理员）
+
+浏览器内 AI 助手（DeepSeek 式多会话）：用 MCP 工具操作指定设备、多轮上下文延续、
+成功后自动提炼经验记忆。**单实例：同时只允许一个 Agent 运行。** 以下接口均仅管理员可用。
+
+### GET /api/agent/config
+
+读 Agent 配置。`api_key` 打码回显在 `api_key_masked` 字段。
+
+**响应**：
+```json
+{"ok": true, "api_base": "https://api.deepseek.com", "model": "deepseek-v4-flash-vision-exp",
+ "api_key_masked": "sk-***abcd", "default_serial": "", "max_steps": "40"}
+```
+
+### POST /api/agent/config
+
+保存 Agent 配置（部分更新）。**请求**（JSON）：
+`{"api_base": "...", "model": "...", "api_key": "...", "default_serial": "...", "max_steps": 40}`
+（`max_steps` 1-200，默认 40）
+
+**响应**：`{"ok": true, "msg": "已保存"}`
+
+### GET /api/agent/devices
+
+AI 可用设备列表（在线状态 + 是否有任务运行，前端据此把 busy 设备禁选）。
+
+**响应**：
+```json
+{"ok": true, "devices": [
+  {"serial": "192.168.1.100:5555", "model": "Pixel 6", "online": true,
+   "busy": false, "worker_status": "idle", "task_job": ""}
+]}
+```
+
+### POST /api/agent/run
+
+启动 Agent（后台线程执行，立即返回 `run_id`）。**请求**（JSON）：
+`{"prompt": "打开抖音并点赞前 3 条视频", "serial": "192.168.1.100:5555", "conversation_id": "abc..."}`
+`serial` 也可省略、用配置的 `default_serial`；`conversation_id` 绑定会话（历史从会话加载）。
+
+**校验**：未配 API Key/模型名 → 400；设备不在池/离线 → 400；设备正有任务运行 → 409；
+已有 Agent 运行中 → 409。
+
+**响应**：`{"ok": true, "run_id": "8f3a2c9d"}`
+
+### GET /api/agent/run
+
+当前 Agent 运行状态（多窗口/页面刷新恢复用）。
+
+**响应**：
+```json
+{"ok": true, "state": "running"|"idle"|"done", "run_id": "...", "prompt": "...",
+ "serial": "...", "started": "10:00:01", "answer": "...", "error": "",
+ "history": [{"role": "user", "content": "..."}]}
+```
+
+### GET /api/agent/stream?run_id=
+
+订阅事件流（SSE，EventSource）。事件：
+- `event: delta` `{text, kind: content|reasoning}` — 流式文本增量
+- `event: step` `{tool, args, image?}` — 工具调用完成（MCP 步骤，image 为缩略截图）
+- `event: done` `{answer}` — 完成
+- `event: error` `{message}` — 失败（若因 MCP Server 未启动/不可达，message 为明确文案「MCP server(8033) 不可达 …」，不再是 SDK 原始的 `Server returned an error response`）
+- 空闲时每 15s 发一行 `: keepalive` 注释防超时；`done`/`error` 后关流
+
+### POST /api/agent/stop
+
+中断当前运行的 Agent（下一个检查点生效，数秒内）。无运行中任务返回 400。
+
+**响应**：`{"ok": true, "msg": "已请求停止"}`
+
+### POST /api/agent/clear
+
+清空当前对话历史。
+
+**响应**：`{"ok": true, "msg": "已清空"}`
+
+### GET /api/agent/conversations
+
+会话列表（按最近更新倒序）。
+
+**响应**：
+```json
+{"ok": true, "conversations": [
+  {"id": "abc...", "title": "打开抖音点赞", "updated_at": "2026-08-08 10:00", "count": 3}
+]}
+```
+`count` 为轮数（用户+助手消息对数）。
+
+### POST /api/agent/conversations
+
+新建会话（空消息）。
+
+**响应**：`{"ok": true, "id": "新会话id", "title": "新会话"}`
+
+### GET /api/agent/conversations/<conv_id>
+
+会话详情（全部消息文本）。不存在返回 404。
+
+**响应**：
+```json
+{"ok": true, "id": "...", "title": "...", "messages": [{"role": "user", "content": "..."}],
+ "created_at": "...", "updated_at": "..."}
+```
+
+### DELETE /api/agent/conversations/<conv_id>
+
+删除会话（消息一并删除，不可恢复）。
+
+**响应**：`{"ok": true, "msg": "会话已删除"}`
+
+### POST /api/agent/conversations/<conv_id>/rename
+
+重命名会话。**请求**（JSON）：`{"title": "新标题"}`
+
+**响应**：`{"ok": true, "msg": "已重命名"}`
+
+### GET /api/agent/experience
+
+经验记忆库列表（自进化，含最近一次巡检结论）。
+
+**响应**：
+```json
+{"ok": true, "running": false, "last": "2026-08-08 03:47", "last_summary": "评审 5 条，建议删除 1 条（待人工确认）",
+ "experiences": [{"id": 1, "task_prompt": "打开抖音并点赞", "recipe": "...", "tool_seq": "...",
+                  "hits": 3, "created_at": "...", "audit": {"verdict": "delete", "score": 3,
+                  "reason": "...", "action": "pending", "at": "..."}}]}
+```
+`audit` 为最近一次 AI 巡检结论（无则 null）。
+
+### POST /api/agent/experience/delete
+
+人工确认删除经验（真删，巡检绝不自动删）。**请求**（JSON）：`{"id": 1}`
+
+**响应**：`{"ok": true, "msg": "经验 #1 已删除"}`
+
+### POST /api/agent/experience/audit
+
+手动触发一轮经验巡检（后台线程，AI 评审只建议不删）。巡检进行中返回 409。
+
+**响应**：`{"ok": true, "msg": "巡检已启动，完成后刷新列表查看建议"}`
+
+### POST /api/agent/experience/keep
+
+人工保留经验（撤销"建议删除"，后续巡检不再重复建议）。**请求**（JSON）：`{"id": 1}`
+
+**响应**：`{"ok": true, "msg": "经验 #1 已保留"}`
+
+---
+
+## 18. 系统备份（仅管理员）
+
+整库备份导出/导入（users.db + 可选 APK 文件）。导入涉及整库替换，仅管理员可用。
+
+### POST /api/system/backup/export
+
+生成导出 zip 并作为附件返回（含 users.db 一致快照 + manifest.json + 可选 `apks/`）。
+**请求**（JSON）：`{"include_apk": true}`
+**响应**：`application/zip` 附件下载（`download_name` 形如 `export_20260808_101000.zip`）。
+
+### POST /api/system/backup/preview
+
+上传备份文件（multipart 字段 `file`，支持 .zip 或 .db）→ 暂存并校验 → 返回预览。
+校验失败返回 400。
+
+**响应**：
+```json
+{"ok": true, "token": "12位hex", "preview": {
+  "file_name": "export_xxx.zip", "file_size": 123456,
+  "integrity": "ok", "schema_version": 4, "current_schema_version": 4,
+  "tables": [{"table": "user", "label": "用户", "rows": 3}],
+  "missing_optional": [], "warnings": ["备份为全量快照：含敏感信息，请妥善保管"]
+}}
+```
+
+### POST /api/system/backup/apply
+
+确认应用导入：自动备份当前库到 `BACKUP_DIR/pre_restore_*.db`（安全网），再把暂存库
+落为「待生效恢复任务」。**重启 web_server 后生效**。token 无效/过期返回 400。
+
+**请求**（JSON）：`{"token": "12位hex"}`
+**响应**：
+```json
+{"ok": true, "backup_name": "pre_restore_20260808_101000.db",
+ "message": "恢复任务已生成：当前库已自动备份，重启 web_server 后即应用导入的数据"}
+```

doc/ARCHITECTURE.md

@@ -1,6 +1,6 @@
 # 架构详解
 
-本文面向想深入理解 `platform-tools` 内部设计的开发者。如果你只想使用，看 [README.md](file:///d:/platform-tools/README.md) 即可。
+本文面向想深入理解 `auto_control` 内部设计的开发者。如果你只想使用，看 [README.md](../README.md) 即可。
 
 ---
 
@@ -45,7 +45,7 @@
        │
        ▼
 ┌──────────────┐
-│ data/users.db│  SQLite 持久化（用户/分组/任务/设备池/自定义动作/APK记录）
+│ data/users.db│  SQLite 持久化（用户/分组/任务/设备池/待连接设备/自定义动作/APK记录/AI会话/经验库 + app_meta KV）
 └──────────────┘
 ```
 
@@ -175,17 +175,23 @@ SQLAlchemy 模型，存于 `data/users.db`：
 
 | 模型 | 表名 | 说明 |
 |------|------|------|
-| `User` | user | 后台用户（Flask-Login 认证，SHA256 密码；`is_admin` 管理员 + `perms` 业务权限位） |
+| `User` | user | 后台用户（Flask-Login 认证，Werkzeug 哈希密码；`is_admin` 管理员 + `perms` 业务权限位） |
 | `DeviceGroup` | device_group | 设备分组（serials 存 JSON） |
 | `TaskJob` | task_job | 任务计划（target/params/schedule/retry 存 JSON） |
 | `CustomAction` | custom_action | 自定义动作（步骤打包，steps 存 JSON） |
 | `ApkFile` | apk_file | APK 文件元信息 |
+| `Device` | device | 设备池清单（替代 STF 池；enabled=False 不参与调度，含 model 型号列） |
+| `PendingDevice` | pending_device | 自动发现「待连接池」（扫描发现、用户确认后才入正式池） |
+
+> 表名默认取类名小写（models.py 未写 `__tablename__`）。另有三张非模型表，由原生 SQL 幂等创建、**不走 SCHEMA_MIGRATIONS**：
+> - `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`）。
 
 **数据库初始化**（`init_db`）：
 - 创建所有表
 - 首次启动创建默认管理员 `admin/admin123`
 - 自动迁移旧 `groups.json` / `jobs.json` 到 SQLite（迁移后归档为 `.migrated`）
-- 版本化 schema 迁移（`SCHEMA_MIGRATIONS`）：结构变更必须追加迁移条目，`create_all` 只建新表不加列
+- 版本化 schema 迁移（`SCHEMA_MIGRATIONS`，**当前到 v4**，见 `core/models.py`）：结构变更必须追加迁移条目，`create_all` 只建新表不加列
 
 ### 权限模型
 
@@ -242,13 +248,15 @@ APK 上传/解析/批量安装。
 | `tasks_api.py` | 任务计划/分组/自定义动作/元素抓取/步骤测试 |
 | `admin_api.py` | 用户管理/日志 |
 | `tools_api.py` | adb 终端/剪贴板注入/应用版本 |
-| `devices_api.py` | 设备池管理（增删停用/重连/型号采集） |
+| `devices_api.py` | 设备池管理 + 自动发现（扫描/确认/忽略/手动重连/型号采集） |
 | `apks_api.py` | 应用管理 |
 | `tailscale_api.py` | Tailscale 管理 |
+| `agent_api.py` | AI 控制台：会话 / 运行 / SSE / 停止 / 配置 / 经验库与巡检（读写 `agent_conversation`、`agent_experience`、app_meta `agent_*`） |
+| `system_api.py` | 系统数据备份导出 / 导入恢复（`/api/system/backup/*`，仅 admin） |
 | `common.py` | 跨模块共享（合并设备列表/屏幕状态） |
 | `context.py` | 共享对象注入（mgr/apk_mgr/device_pool） |
 
-`web_server.py` 只保留：app 创建、数据库初始化、蓝图注册、uiautodev 生命周期、启动（193 行）。
+`web_server.py` 只做装配与启动（266 行）：app 创建；`init_db` 前消费待生效备份恢复（`consume_pending_restore`）；初始化 device_pool / device_discovery；装配 TaskManager / ApkManager；注册 10 个蓝图（auth/monitor/tasks/admin/tools/devices/apks/tailscale/agent/system，`web/__init__.py`）；注册经验巡检 APScheduler（03:47 Asia/Shanghai）；uiautodev 子进程启停与设备池预连接线程；启动。
 
 ---
 
@@ -300,7 +308,7 @@ tasks/douyin/actions/like.py — @register_action(ACTIONS) LikeAction
 
 `templates/admin/monitor.html` 是纯 HTML+CSS+JS 单页应用，无框架依赖。
 
-- **Tab 切换**：5 个 Tab（监控/任务/分组/日志/用户），纯 DOM 操作
+- **Tab 切换**：7 个顶级 Tab（监控/任务/日志/用户/工具/AI 控制台/系统），均在 monitor.html 内 `.tab-panel` 切换（纯 DOM 操作）；独立页面仅 `/login`、`/wall`。原"分组"已无顶层入口（移到工具页子分栏）
 - **数据获取**：`fetch()` 调 JSON API，5 秒轮询 `/api/status`
 - **状态渲染**：设备表格、任务卡片、进度条、徽章，纯 DOM 操作
 
@@ -317,9 +325,13 @@ tasks/douyin/actions/like.py — @register_action(ACTIONS) LikeAction
 
 ### 5.3 页内子分栏
 
-任务/工具 Tab 用通用 `showSubTab(tabId, name)` 实现页内子分栏：每个子分栏一个 `.sub-panel`，
-`_activeSubs` 记住各 Tab 上次选中的子分栏。工具 Tab 集中了全部管理工具（剪贴板注入/adb 终端/
-Tailscale/应用管理/应用版本/已装应用/STF 设备管理），维护 Tab 仅保留 STF 服务。
+任务/工具/系统 Tab 用通用 `showSubTab(tabId, name)` 实现页内子分栏：每个子分栏一个 `.sub-panel`，
+`_activeSubs` 记住各 Tab 上次选中的子分栏。现状子分栏：
+- **任务**：任务计划 / 自定义动作
+- **工具**：剪贴板注入 / adb 远程终端 / Tailscale 管理 / 应用管理 / 应用版本管理 / 设备已装应用 / 设备池管理 / 设备分组
+- **系统**：数据备份 / 导入恢复
+
+（原"分组"顶级 Tab 与"维护/STF 服务"子分栏已不存在——分组已移入工具页子分栏，STF 已摘除。）
 
 ### 5.4 元素抓取模态框
 
@@ -344,15 +356,15 @@ Tailscale/应用管理/应用版本/已装应用/STF 设备管理），维护 Ta
 
 ### 6.3 为什么绝不 kill-server
 
-`adb kill-server` 会断开所有设备的 adb transport，导致 STF provider 误判全部设备离线并触发重连。连接失败就返回 False，由调用方处理。
+`adb kill-server` / `adb disconnect` 会断开共享的 adb transport（历史与 STF provider 共享；STF 摘除后红线仍保留——多 worker、前台扫描、设备自动发现共用同一 adb server），影响所有运行中的任务。连接失败就返回 False，由调用方处理。
 
 ### 6.4 为什么状态查询带缓存
 
-STF API 响应慢（设备多时 2-5 秒），每次 `/api/status` 都打 STF 会阻塞 Flask。带 5 秒缓存，Worker 状态实时读内存（无 IO）。
+状态源 = 本地 SQLite 设备池 + adb + 内存 worker 状态。5 秒缓存避免每次 `/api/status` 都查库/adb 阻塞 Flask；Worker 实时状态读内存，不受缓存影响。
 
 ### 6.5 为什么 DeviceOfflineError 不重试
 
-设备掉线后短时间内不会自愈，重试只会浪费配额并阻塞调度器。让设备进入冷却，由运维/STF 恢复后再启用。
+设备掉线后短时间内不会自愈，重试只会浪费配额并阻塞调度器。让设备进入冷却，可依赖设备自动发现（device_discovery 对正式池断联设备每轮 adb 重连）恢复后再启用。
 
 ---
 
@@ -361,14 +373,21 @@ STF API 响应慢（设备多时 2-5 秒），每次 `/api/status` 都打 STF
 ```
 主线程（Flask）
   ├── HTTP 请求处理（threaded=True，每请求一线程）
-  ├── APScheduler 线程（cron 触发）
+  ├── TaskManager.scheduler（APScheduler，cron 触发任务计划）
+  ├── 经验巡检 BackgroundScheduler（03:47 Asia/Shanghai，web_server 装配）
+  ├── 设备自动发现线程（device_discovery._discovery_loop，默认 60s 一轮）
+  ├── 设备池型号采集后台线程（device_pool._refresh_models_bg，启动/手动触发）
+  ├── 设备池预连接线程（web_server._preconnect_pool_devices，重启后加速恢复）
+  ├── AI Agent 运行线程（agent_api._agent_thread，单实例 + SSE 推送）
   ├── 看门狗线程（_Watchdog，30s 间隔）
-  ├── uiautodev 子进程
+  ├── uiautodev 子进程（PID + cmdline 校验，防容器 PID 复用误杀）
   └── Worker 线程（每台设备一个）
         ├── _run_with_retry 线程（重试循环）
         └── BaseWorker 线程（设备生命周期 + run_task）
 ```
 
+> MCP server（127.0.0.1:8033）是**独立进程**（scripts/start.sh 拉起），不是 web_server 的线程。
+
 **线程安全**：
 - `_WORKERS_LOCK`：保护全局 worker 状态字典
 - `_ADB_LOCK`：串行化所有 adb 调用

doc/DEPLOY.md

@@ -75,6 +75,8 @@ pip install -r requirements.txt
 | uiautodev | >=0.14 | UI 元素抓取 |
 | pyaxmlparser | >=0.3.27 | APK 元信息解析 |
 | rapidocr_onnxruntime | >=1.4 | 屏幕 OCR（条件判断的 OCR识别 选择器，中英文模型随包内置，跨平台） |
+| fastmcp | >=2.0 | MCP Server 与 AI 控制台 Agent（Streamable HTTP 服务端/客户端） |
+| paramiko | >=3.0 | SSH 运维预留（历史 STF SSH 通道退役；配置 `STF_SSH_PASSWORD` 时走密码认证，未配置则退回系统 ssh 免密） |
 
 > 服务器（无显示器/Linux）环境建议把 opencv-python 换成 `opencv-python-headless`（rapidocr 依赖 cv2，两者取一）。
 
@@ -102,11 +104,17 @@ TAILSCALE_API_KEY=你的Tailscale_API_key
 | `USB_ADB_HOST` | `100.100.10.1` | USB 设备所在部署机（220）的 Tailscale IP |
 | `USB_ADB_PORT` | `5037` | 220 adb 容器监听端口（host 网络模式） |
 | `TAILSCALE_TAILNET` | 按邮箱前缀 | tailnet 名称/ID（个人账号一般为登录邮箱前缀） |
+| `DISCOVERY_PORT` | `5555` | 设备自动发现扫描的 adb 端口（网段默认局域网 + Tailscale，可在设备池面板改） |
+| `DISCOVERY_INTERVAL` | `60` | 自动发现扫描间隔（秒） |
+
+> 配置来源区分：`WEB_HOST`/`WEB_PORT`/`ADB_PATH` 是 **config.py 常量**（直接改文件，不经 .env）；
+> `TAILSCALE_API_KEY`/`TAILSCALE_TAILNET`/`USB_ADB_HOST`/`USB_ADB_PORT`/`DISCOVERY_PORT`/`DISCOVERY_INTERVAL` 由 config.py 以环境变量读取，**可在 .env 覆盖**；
+> `BACKUP_DIR`/`RESTORE_STAGING_DIR`/`RESTORE_PENDING_DIR` 是常量（硬编码到 `data/`，见 §3.5）。
 
 > **未配置 `WEB_SECRET_KEY`**：启动时随机生成（每次重启登录态失效，生产务必配置固定值）。
 > **工具页 Tailscale 管理前置**：`.env` 写入 `TAILSCALE_API_KEY` 后重启服务；
 > 未配置时管理分区显示明确提示，不影响其他功能。
-> （历史遗留的 `STF_URL`/`STF_TOKEN`/`STF_SSH_*` 等配置已废弃，代码不再读取。）
+> （历史遗留的 `STF_URL`/`STF_TOKEN`/`STF_SSH_*` 等配置：`config.py` 仍读取但无任何功能使用，仅历史保留；生产 `.env` 可留空。）
 
 ### 2.4 启动服务
 
@@ -118,12 +126,26 @@ python web_server.py
 
 （推荐配合 `scripts/supervise.sh` 进程守护，见 3.1 节）
 
+**生产容器（220）入口 `scripts/start.sh`**（docker-compose 的 python-app 服务 command）：
+
+1. **依赖就绪守卫**：flask/u2/uiautodev/rapidocr/cv2/fastmcp 全可用则跳过安装；否则 `pip install -r requirements.txt` 并做 cv2 环境修复（卸 GUI opencv → 装 headless）
+2. **后台拉起 MCP server**：`MCP_ENABLED` 默认 `1` 时执行 `python3 -m mcp_server.mcp_server`（`MCP_ALLOW_WRITE=1`、`MCP_PLATFORM_USER` 默认 admin、`MCP_PLATFORM_PASS` 兜底 `admin123`），日志 `/tmp/mcp_server.log`
+3. **前台启动主服务**：`exec python -u web_server.py`
+
+注意：
+
+- `scripts/supervise.sh` **只守护 web_server，不拉起 MCP**——容器场景 MCP 由 start.sh 拉起，不要用 supervise.sh 替代容器入口
+- **AI 控制台依赖 MCP**：`AGENT_MCP_URL` 默认 `http://127.0.0.1:8033/mcp`（`mcp_agent/config.py`）
+- 手动起 web_server 需另启 MCP：`MCP_ALLOW_WRITE=1 python -m mcp_server.mcp_server`
+- **改过 admin 密码务必同步 `MCP_PLATFORM_PASS`**（start.sh 兜底 `admin123` 会登录失败）
+- 发布链路：dev 开发测试完成 → 负责人确认合并 main → 220 `git pull` → 重启 python-app 容器生效（详见 DEVELOPMENT §6）
+
 ### 2.5 验证部署
 
 1. 控制台看到 `启动服务: http://localhost:18050/` 即成功
 2. 浏览器访问 `http://localhost:18050/`
 3. 用 `admin/admin123` 登录
-4. 监控页应显示 STF 设备池中的设备
+4. 监控页应显示设备池中的设备（本机 adb 在线 + SQLite 配置清单，serial 形如 `100.100.10.x:5555`）
 
 ---
 
@@ -169,7 +191,7 @@ PYTHON=./.venv/bin/python bash scripts/supervise.sh
 
 > 进程守护只保证服务重启，不恢复已运行的任务（worker 状态在内存）。
 >
-> **悬空设备自愈**：崩溃后残留的设备占用（STF 仍显示占用）可配置启动自动清理。单实例部署时在 `.env` 设置 `AUTO_RELEASE_STALE_OCCUPY=true`，web_server 启动会自动释放本账户残留占用；**多实例共用 STF 账户时不要开**（会误放另一实例的任务）。默认关，仅启动时提示。
+> **崩溃后占用自愈（需人工核实）**：历史 `AUTO_RELEASE_STALE_OCCUPY` 机制已随 STF 摘除失效（全库代码不再读取该配置）。设备池的占用互斥仍在（任务 running/connecting 的设备会被锁），但崩溃后残留占用如何释放、是否自动清理，需按当前实现核实后补写本节。
 
 **Docker（生产 python-app 容器）**：
 
@@ -207,7 +229,7 @@ server {
 - **修改默认密码**：登录后立即在"用户"Tab 修改 admin 密码
 - **最小权限分配**：需要多人使用后台时，在"用户"Tab 创建普通用户并只勾选必要权限
   （任务管理/设备控制/应用管理/日志查看），不要把 admin 密码共享出去
-- **修改 SECRET_KEY**：编辑 `web_server.py`，把 `app.config["SECRET_KEY"]` 改成随机字符串
+- **会话密钥 SECRET_KEY**：在 `.env` 写固定 `WEB_SECRET_KEY`（`python -c "import secrets;print(secrets.token_hex(32))"` 生成）；未配置时启动随机生成（每次重启登录态失效，生产务必配置固定值）
 - **限制访问**：生产环境把 `WEB_HOST` 改为 `127.0.0.1`，配合反向代理
 - **防火墙**：只开放必要端口
 
@@ -219,9 +241,22 @@ server {
 
 ### 3.5 数据备份
 
-- 数据库 `data/users.db` 包含用户/分组/任务数据
-- APK 文件在 `data/apks/`
-- 建议定期备份 `data/` 目录
+**优先推荐平台功能「系统 → 数据备份导出/导入」（仅 admin）**：
+
+- **导出**：`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` 前自动消费恢复任务）
+
+目录与常量：
+
+| 目录 | 用途 |
+|---|---|
+| `data/backups/` | 导出临时 zip + 恢复前快照 `pre_restore_*.db` + 校验失败的 `restore_failed_*` |
+| `data/restore_staging/` | 导入暂存，TTL 30 分钟未应用自动清理 |
+| `data/restore_pending/` | 待生效恢复任务（重启时消费） |
+
+常量 `BACKUP_DIR` / `RESTORE_STAGING_DIR` / `RESTORE_PENDING_DIR`（config.py L63-68，非 .env，已 .gitignore）。
+
+手工备份 `data/` 目录仍可作兜底，但**整库恢复建议走上述功能**（在线一致快照 + 预恢复备份 + 重启原子生效，避免手工替换被 WAL/占用文件破坏）。
 
 ---
 
@@ -233,7 +268,7 @@ server {
 |------|------|------|
 | 18050 | Web 后台 | 主服务端口（config.py 可改） |
 | 20242 | uiautodev | 元素抓取服务（自动启动，固定端口） |
-| 7100 | STF | STF 服务端口（STF 自己的配置） |
+| 8033 | MCP | MCP 手机控制 Server（scripts/start.sh 自动拉起，`MCP_ENABLED=0` 可关） |
 | 5555 | adb | 设备 adb 网络端口（设备端） |
 
 ### 4.2 Windows 端口问题（仅 Windows）
@@ -291,16 +326,17 @@ python web_server.py
 | `ModuleNotFoundError: No module named 'flask'` | 依赖未安装 | `pip install -r requirements.txt` |
 | `WinError 10013` | 端口被排除/权限不足 | 改端口或用管理员运行 |
 | `WinError 10048` | 端口被占用 | 改端口或杀占用进程 |
-| STF 获取设备列表失败 | STF 地址/token 错误 | 检查 `config.py` 的 `STF_URL` 和 `STF_TOKEN` |
+| 监控页设备列表为空 | 设备不在池中 / adb 连不上 | 「工具 → 设备池管理」确认已添加且在线，检查设备网络与 5555 端口 |
+| AI 控制台报「MCP server(8033) 不可达」 | MCP Server 未启动/不可达 | 启动 MCP Server：本机 `MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<密码> MCP_AUDIT_FILE=data/mcp_audit.log python -m mcp_server.mcp_server`；220 容器由 `scripts/start.sh` 自动拉起（`MCP_ENABLED=0` 会关） |
 
 ### 6.2 设备连接失败
 
 | 现象 | 原因 | 解决 |
 |------|------|------|
-| `DeviceOfflineError` | 设备掉线/STF provider 卡死 | 检查设备网络/STF 状态 |
+| `DeviceOfflineError` | u2 连接超时 / atx-agent 无响应 | 检查设备网络，重启设备或重新推送 atx-agent |
 | `u2.connect 超时` | atx-agent 无响应 | 重启设备/重新推送 atx-agent |
 | `adb connect failed` | 设备网络不通/端口未开放 | 检查设备 IP 和 5555 端口 |
-| STF 设备显示离线 | STF 状态缓存 | 用"扫描前台App"复测 |
+| 设备显示离线 | 状态缓存/误报 | 管理后台设备池「重连」，或「扫描前台 App」复测 |
 
 ### 6.3 任务不执行
 
@@ -317,7 +353,7 @@ python web_server.py
 # 查看核心日志
 # 方式一：Web 后台"日志"Tab
 # 方式二：直接看文件
-# logs/core.log   — STF/adb/worker/task_manager
+# logs/core.log   — adb/worker/task_manager
 # logs/task.log   — 任务执行
 # logs/web.log    — Web 请求
 # logs/action.log — 操作执行

doc/DEVELOPMENT.md

@@ -43,7 +43,7 @@
 |------|------|------|
 | 开发机 | 本机（192.168.20.57） | `.venv` + 本地运行 `web_server.py` |
 | 生产机 | 部署机 220 的 `auto_control` | python-app 容器，`network_mode: host` |
-| STF 服务 | ~~`192.168.20.220:7100`~~ | 已停用（2026-08-18 `docker stop stf`，代码已摘除依赖） |
+| STF 服务 | ~~`192.168.20.220:7100`~~ | 已停用（代码已摘除依赖）。注意：此处"已停用"与 [STF_REMOVAL.md](STF_REMOVAL.md) 的"待人工确认"项矛盾（220 侧是否已 `docker stop stf` 未核实），需以 220 实际为准 |
 | adb 容器 | 220 上 `adb`（host 网络 5037） | USB 设备远程 adb server；网络设备补连用 |
 | 设备 | Tailscale `100.100.10.x:5555` | Xiaomi 舰队，本机 `100.100.10.2` 在 tailnet 内 |
 | uiautodev | 本机 `20242` | 元素抓取服务（web_server 自动拉起） |
@@ -62,6 +62,22 @@
 - 本机已在 tailnet 内，直连可靠且快（<1s）
 - 设备加入/退出平台：工具 → 设备池管理（SQLite 清单，自动连接 + 型号采集）
 
+### 2.3 配置键速查（`config.py` / `.env`）
+
+`.env` 加载方式：项目根目录逐行解析、`os.environ.setdefault`（环境变量已设则不覆盖）。以下默认值以 `config.py` 为准：
+
+| 键 | 默认值 | 说明 |
+|------|------|------|
+| `WEB_HOST` / `WEB_PORT` | `0.0.0.0` / `18050` | Web 后台监听（18050 避开 Windows 动态端口范围） |
+| `DATA_DIR` / `APK_DIR` | `data/` / `data/apks/` | 持久化数据目录 / APK 存储目录 |
+| `BACKUP_DIR` / `RESTORE_STAGING_DIR` / `RESTORE_PENDING_DIR` | `data/backups` / `data/restore_staging` / `data/restore_pending` | 系统备份：导出 zip、导入暂存、待重启生效的恢复目录 |
+| `ADB_PATH` | `bin/adb/adb`（Windows 为 `adb.exe`） | 按平台自动识别，代码只拼路径 |
+| `USB_ADB_HOST` / `USB_ADB_PORT` | `100.100.10.1` / `5037` | 220 的 adb 容器（host 网络），驱动远程 USB 设备 |
+| `DISCOVERY_PORT` / `DISCOVERY_SUBNETS` / `DISCOVERY_INTERVAL` | `5555` / 局域网+Tailscale 网段 / `60` | 设备自动发现；可在工具页设备池面板改，存 `app_meta` `discovery_*` 覆盖默认 |
+| `TAILSCALE_API_KEY` / `TAILSCALE_TAILNET` | 空 / 空 | 工具页 Tailscale 管理（官方 API v2） |
+| `WEB_SECRET_KEY` | 未配置则随机生成 | 会话密钥（web_server 读 `.env`；不配则重启登录态失效） |
+| `STF_URL` / `STF_TOKEN` / `STF_SSH_*` | 废弃 | STF 摘除后仅历史保留，代码不再使用 |
+
 ---
 
 ## 3. 技术红线（开发限制）—— 违反会打断共享 adb transport，需人工恢复
@@ -92,7 +108,7 @@
 - **任务参数放各自 `tasks/<app>/task.py` 顶部，不放 `config.py`**
 - **生产环境（220）默认只读**：任何写操作（改文件/重启容器/部署）都必须先经负责人确认
 - **数据库是 SQLite**（`data/users.db`，WAL 模式）：运行时数据不提交 git
-- **前端 JS 在 `static/admin/monitor.js`**（已从 HTML 拆分），HTML 里用 `<script src>` 引用
+- **前端 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>` 加载
 - **监控页/大列表已加分页**：100 台设备也只渲染 10 行/页，不要移除分页逻辑
 - **任务批量触发已错峰**（`_START_STAGGER_SEC`）：避免大量设备同时启动造成 adb 连接风暴，不要移除
 
@@ -153,7 +169,7 @@ with sync_playwright() as p:
 
 - **看日志**：`logs/` 下 `core.log` / `task.log` / `web.log` / `action.log`（10MB 滚动，保留 5 份）
 - **看设备/任务状态**：浏览器监控页，或 `GET /api/status`、`GET /api/health`
-- **清理 STF 残留占用**：前端监控页"强制释放占用"（或 `.env` 配 `AUTO_RELEASE_STALE_OCCUPY=true` 启动自动清理）
+- **停止设备/清异常**：监控页工具条用"停止全部 / 停止选中 / 清除全部异常"（`AUTO_RELEASE_STALE_OCCUPY` 等 STF occupy 残留清理配置代码已不再读取）；崩溃残留的 worker 状态重启即清零
 - **打包项目**：`python scripts/pack.py`
 
 ---
@@ -180,18 +196,42 @@ tasks/<app>/
 | 文件 | 内容 |
 |------|------|
 | `templates/admin/monitor.html` | HTML 结构 + CSS + `<script src>` 引用 |
-| `static/admin/monitor.js` | 全部前端 JS |
+| `static/admin/`（base/list/monitor/editor/tasks/tools/apps/admin/agent/system.js） | 前端 JS（按 monitor.html 中 `<script src>` 顺序拆分加载，功能归属见各文件） |
 
 改完**强刷浏览器**（Cmd/Ctrl+Shift+R），必要时重启 web_server。
 
 ### 5.4 新增 API
 
-在 `web_server.py` 加 Flask 路由，更新 **[doc/API.md](API.md)**。
+路由按功能域放在 `web/` 蓝图包（`web/__init__.py` 的 `register_blueprints(app)` 统一注册 10 个蓝图：auth / monitor / tasks / admin / tools / devices / apks / tailscale / agent / system）。
+
+- 新增 API：在对应功能域的 `web/xxx_api.py` 里加 `@bp.route(...)` + 权限装饰器（如 `admin_required`）
+- 新建蓝图：需在 `web/__init__.py` 里 import 并加进 `register_blueprints` 的注册元组
+- `web_server.py` 只做 app 装配（初始化、`register_blueprints(app)`、常驻线程启动），一般不改
+- 最后更新 **[doc/API.md](API.md)**
 
 ### 5.5 新增数据库字段/表
 
-- 模型改 `core/models.py`，首次建表用 `create_all()`
+- 模型改 `core/models.py`，首次建表用 `create_all()`；SQLAlchemy 模型未写 `__tablename__` 时默认表名 = 小写类名
 - **已有数据的老库**：在 `core/models.py` 的 `SCHEMA_MIGRATIONS` 里加迁移（版本号递增 + SQL）
+- `app_meta`（KV 配置表）由 `core/models.py` 的 `_migrate_schema()` 建表并维护 `schema_version`
+- `agent_conversation` / `agent_experience` / `experience_audit` 由 `web/agent_api.py` 顶部的原生 `CREATE TABLE IF NOT EXISTS` 幂等创建（模块内首次用时执行），**不经 `SCHEMA_MIGRATIONS`，无版本管理**
+
+### 5.6 改动必须同步文档
+
+任何功能/配置/接口/页面改动，须与代码同一 commit 同步更新对应文档：
+
+| 改动类型 | 对应文档 |
+|------|------|
+| HTTP 接口 | [API.md](API.md) |
+| 数据表 / schema | [ARCHITECTURE.md](ARCHITECTURE.md) §3.6 |
+| `config.py` / `.env` 键增删 | 本文档 §2 + [.env.example](../.env.example) |
+| 页面 Tab / 子分栏 / 前端拆分 | [ARCHITECTURE.md](ARCHITECTURE.md) §5 |
+| 任务 / 步骤 | [TASK_DEV.md](TASK_DEV.md) |
+| 常驻线程 / 进程与装配 | [ARCHITECTURE.md](ARCHITECTURE.md) §7 |
+| 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) |
+
+注：STF_REMOVAL.md 是历史迁移记录，不改写。
 
 ---
 
@@ -218,3 +258,9 @@ tasks/<app>/
 | [ARCHITECTURE.md](ARCHITECTURE.md) | 架构详解（分层、数据流、设计决策） |
 | [API.md](API.md) | 全部 HTTP 接口说明 |
 | [DEPLOY.md](DEPLOY.md) | 部署指南（环境、生产、故障排查） |
+| [STF_REMOVAL.md](STF_REMOVAL.md) | 摘除 STF 的历史迁移记录（2026-08，不随现状改写） |
+| [MCP.md](MCP.md) | MCP 手机控制使用手册（工具清单/用法） |
+| [MCP_DESIGN.md](MCP_DESIGN.md) | MCP 架构与演进设计 |
+| [AI_TASK_GEN.md](AI_TASK_GEN.md) | AI 建任务设计文档 |
+| [staffdeck/KNOWLEDGE_BASE.md](staffdeck/KNOWLEDGE_BASE.md) | 给 StaffDeck 数字员工的知识库（MCP 接入/工具/约定/红线） |
+| [staffdeck/JOB_SPEC.md](staffdeck/JOB_SPEC.md) | 数字员工岗位说明（岗位描述/看板摘要/执行约束） |

doc/MCP.md

@@ -0,0 +1,173 @@
+# MCP 手机控制 Server（`mcp_server/`）
+
+多模态 AI（DeepSeek/Claude 等）通过 [MCP（Model Context Protocol）](https://modelcontextprotocol.io) 实时操作 Android 手机的统一出口。AI 控制台（`mcp_agent/`）与外部 MCP 客户端都经它控制设备池中的手机。
+
+> 本文档 = 使用手册（工具清单/用法）。架构与演进设计见 [MCP_DESIGN.md](MCP_DESIGN.md)。
+
+## 架构
+
+```
+AI 控制台 / 外部 MCP 客户端
+        │  Streamable HTTP
+        ▼
+MCP Server  (:8033, mcp_server/mcp_server.py)     ← 19 个 de_* 工具
+        │  平台 HTTP API（登录 + CSRF）
+        ▼
+auto_control 平台 (:18050)                        ← 设备池/任务/看屏
+        │  adb / uiautomator2 / uiautodev / OCR
+        ▼
+Android 设备（IP:5555）
+```
+
+- 轻量通道直连（adb monkey 开 App、u2 输入、本地 OCR）不绕平台，省时省 token
+- 坐标换算、UI 吸附、剪贴板注入等细节全部在 Server 层消化，模型只需给意图
+
+## 运行与配置
+
+服务跑在 220 的 `python-app` 容器内（`scripts/start.sh` 自动拉起，端口 8033）。
+生产访问方式：`http://192.168.20.220:8033/mcp`；本机调试 `python3 -m mcp_server.mcp_server`。
+
+| 环境变量 | 默认 | 说明 |
+|---|---|---|
+| `MCP_PLATFORM_URL` | `http://127.0.0.1:18050` | 平台地址（Agent 与平台同机时用本机） |
+| `MCP_PLATFORM_USER` / `MCP_PLATFORM_PASS` | `admin` / start.sh 兜底 `admin123`（手动直跑时默认空） | 平台登录账号 |
+| `MCP_ALLOW_WRITE` | `0` | **写门控**：=1 才允许点击/输入/开关 App 等写操作（只读工具不受限） |
+| `MCP_ALLOWED_SERIALS` | 空 | 设备白名单（逗号分隔）：**非空=只允许列出的 serial**；为空时代码只校验 serial 非空、**不校验是否在平台设备池内**（设计稿语义未实现） |
+| `MCP_HTTP_HOST` / `MCP_HTTP_PORT` | `0.0.0.0` / `8033` | 监听地址 |
+| `MCP_SCREENSHOT_WIDTH` | `540` | 截图返回宽度上限（px），模型看到的图即该坐标系 |
+| `MCP_JPEG_QUALITY` | `70` | 截图 JPEG 质量 |
+| `MCP_AUDIT_FILE` | `/var/log/mcp/audit.log` | 审计日志（每次工具调用一行） |
+| `MCP_PLATFORM_TIMEOUT` | `30` | 平台请求超时（秒） |
+
+生产（220 容器）已设 `MCP_ALLOW_WRITE=1`；`MCP_ALLOWED_SERIALS` 未设（= 代码只校验 serial 非空，**不限制到平台设备池内**；如需收紧请配置白名单）。
+
+> **MCP_ENABLED**：由 `scripts/start.sh` 消费（默认 `1`，=0 可关掉后台拉起的 MCP）。
+> **MCP_PLATFORM_PASS**：start.sh 兜底 `admin123`——改过平台 admin 密码必须同步该变量，否则 MCP 登录平台失败。
+> **supervise.sh 不拉起 MCP**：只守护 web_server；容器场景 MCP 由 start.sh 后台拉起（见 DEPLOY §2.4）。
+
+## 坐标空间（重要约定）
+
+- `de_screenshot` 返回 ≤540px 宽的 JPEG（display 空间），并附 `native_size`（设备原生分辨率）
+- `de_tap` / `de_swipe` 的坐标一律使用 **de_screenshot 返回图像的坐标系**，Server 按比例换算为原生坐标
+- **先截图、后点击**：Server 需要最近一次截图才能建立坐标空间（未截图就点击会报「请先执行 de_screenshot」）
+- `de_tap` 带**自动吸附**：点击点若落在某个可点击元素内，实际会点该元素中心——坐标只需大致对准，偏十几像素也能点准；点空白处则按原坐标
+- 返回的 `snapped/label` 可核对吸附结果（snapped=true 表示已吸到元素，label 为该元素文案）
+
+## 工具清单（19 个）
+
+### 设备与状态
+
+| 工具 | 用途 |
+|---|---|
+| `de_list_devices` | 列出可控制设备：serial / 型号 / 在线 / 任务状态 / 前台 App。**开局第一步** |
+| `de_foreground_app(serial)` | 当前前台 App 包名（dumpsys，MIUI 焦点为空时自动兜底） |
+
+### 观察屏幕（感知）
+
+| 工具 | 用途 |
+|---|---|
+| `de_screenshot(serial)` | 截图并返回图像（≤540px JPEG）+ 尺寸 + 亮/熄屏状态。多模态模型直接看图 |
+| `de_ui_tree(serial, limit=150)` | 当前界面元素树（text/id/desc/class/bounds）。**可点击元素排前**；limit 1-300 控制条数防 token 膨胀。用于确认界面上有什么 |
+| `de_ocr(serial)` | OCR 识别当前屏幕文字（UI 树没有的图片/WebView 文字也能识别），返回 [{text, score}] |
+
+### 点击与滑动（操作）
+
+| 工具 | 用途 |
+|---|---|
+| `de_tap_text(serial, text)` | **按屏幕文字点击**（推荐）：给一个屏幕上可见的文字（子串匹配）即找到并点其中心。原生控件走 UI 树，WebView/图片文字自动 OCR 兜底。找不到返回明确错误 |
+| `de_tap_element(serial, by, value, index=1)` | 按元素点击：`by` = text / id / desc（精确）或 text_contains / desc_contains（模糊）。多命中用 index 取第几个 |
+| `de_tap(serial, x, y)` | 坐标点击（截图坐标系，自动吸附，见上）。**纯图形目标（视频画面/无文字图标）才用它** |
+| `de_swipe(serial, x1,y1,x2,y2, duration=0.2)` | 滑动（截图坐标系；长按=同点起止 + duration≥1） |
+| `de_press_key(serial, key)` | 按键：back / home / recent / menu / power / volume_up / volume_down / enter / delete / search / camera |
+
+### 输入与剪贴板
+
+| 工具 | 用途 |
+|---|---|
+| `de_type_text(serial, text)` | 向当前界面输入框输入文字（支持中文，直设 EditText 不依赖剪贴板/粘贴） |
+| `de_set_clipboard(serial, text)` | 写入设备剪贴板（ClipInject 通道注入 + 读回验证） |
+| `de_read_clipboard(serial)` | 读取设备当前剪贴板内容 |
+
+### App 管理（轻量 adb 直连，不建 u2 会话）
+
+| 工具 | 用途 |
+|---|---|
+| `de_open_app(serial, package)` | 打开 App（adb monkey 直启，无需知道 activity——最快的打开路径） |
+| `de_stop_app(serial, package)` | 强制停止 App（am force-stop） |
+| `de_list_apps(serial, keyword="")` | 列出第三方已装应用（pm list packages -3），keyword 可过滤（如 "douyin"） |
+
+> 上表三个工具走 `direct_ops` 轻量 **adb 直连**（monkey / am force-stop / pm list packages），不建 u2 会话。
+
+### 亮屏与熄屏（平台 screen_all 通道）
+
+| 工具 | 用途 |
+|---|---|
+| `de_sleep(serial)` | 熄屏（**运行中任务会中断，慎用**） |
+| `de_wake(serial)` | 亮屏并解锁（熄屏时先调它再截图） |
+
+> `de_sleep`/`de_wake` 走平台 `POST /api/device/screen_all`（`platform_client`），同样不在 MCP 进程内建 u2 会话。
+
+### 平台联动
+
+| 工具 | 用途 |
+|---|---|
+| `de_list_tasks()` | 列出平台任务计划（名称/类型/启用/调度），了解已自动化的工作 |
+
+### 现状边界
+
+本 Server 目前只有**设备层**的 `de_*`（控制/感知/只读）+ 平台**只读**的 `de_list_tasks`；平台级**任务增改/提交/CRUD、分组/设备池/自定义动作/APK/备份**等 REST 路由只给 Web 前端用，**未暴露 MCP 工具**。
+
+补齐分层规划见 [AI_TASK_GEN.md](AI_TASK_GEN.md) §9。**每新增/修改/删除一个 MCP 工具或平台配置，必须同步更新本手册与 [MCP_DESIGN.md](MCP_DESIGN.md)（doc 同步红线）**。
+
+## 推荐使用模式（操作手机的正确姿势）
+
+1. **`de_list_devices`** 确认目标设备在线
+2. **`de_screenshot`** 看图理解当前界面（图像会在下一次模型回合送达）
+3. **点击定位优先级**（从高到低）：
+   - 目标有可见文字 → **`de_tap_text`**（一次调用完成「找到并点击」，最可靠）
+   - 文字有歧义/多候选 → `de_ui_tree` 确认后 `de_tap_element`（text_contains 模糊匹配）
+   - 纯图形目标 → `de_tap` 坐标（**无需精算**，Server 自动吸附到可点元素中心）
+4. 输入文字：先点中输入框（de_tap_text / de_tap），再 `de_type_text`
+5. 每次关键操作后 `de_screenshot` 验证：界面变化 = 成功；无变化 = 未命中，换 de_tap_text / de_tap_element 重新定位，**不要重复点同一坐标**
+6. 完成/失败时用中文总结：做了什么、当前状态、注意事项
+7. 效率约束：界面未变不重复截图/点同位置；连续 6 步无进展停止并总结
+
+## 安全与审计
+
+- **写门控**：`MCP_ALLOW_WRITE=0`（默认）时点击/输入/开关 App 全部拒绝，只读工具可用
+- **任务占用互斥**：写工具操作前调 `_ensure_device_free` 检查设备 `worker_status`，running/connecting 直接拒 `device_busy`（只读工具不受限），AI 不与任务抢设备
+- **平台会话 + CSRF**：平台登录与会话由 `platform_client` 内部处理（`MCP_PLATFORM_USER/PASS` 登录拿 cookie、失效自动重登；POST 自动带 `X-CSRF-Token`），不向客户端暴露平台凭据
+- **设备白名单**：`MCP_ALLOWED_SERIALS` 非空时限制可操作的 serial；空名单时代码只校验 serial 非空，不按平台设备池过滤
+- **审计日志**：每次调用记录 `{ts, tool, serial, args, result}` 到 `MCP_AUDIT_FILE`（220 上 `/tmp/mcp_audit.log`）
+- 操作对象限定平台设备池；`adb kill-server` / `adb disconnect` 属项目红线，任何工具不触碰
+
+## 客户端接入示例
+
+```python
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://192.168.20.220:8033/mcp", timeout=30) as c:
+        devs = await c.call_tool("de_list_devices", {})
+        serial = devs.data["data"][0]["serial"]          # 取第一台在线设备
+        shot = await c.call_tool("de_screenshot", {"serial": serial})
+        img = shot.data["data"]["image"]                 # base64 JPEG（多模态模型可直接看图）
+        await c.call_tool("de_tap_text", {"serial": serial, "text": "搜索"})
+
+asyncio.run(main())
+```
+
+## AI 控制台（内置 Agent）
+
+Web 端「AI 控制台」Tab 内建的 Agent（`mcp_agent/`，OpenAI 兼容协议：DeepSeek 等）也通过本 Server 的同一批工具跑任务：
+
+- 流式输出 + 每步 MCP 工具调用实时展示（含截图缩略）
+- 多轮会话记忆（同会话上下文保留，新建会话清空）
+- **自进化经验记忆**：一轮成功操作会被提炼成「配方」存入 `agent_experience` 表，下次相似任务自动注入参考（命中/写入均有 🧠 提示卡）
+- 模型与 API Key 在 AI 控制台右上角 ⚙ 配置，存平台 `app_meta`
+
+> **依赖提示**：AI 控制台依赖本 MCP Server（默认 `http://127.0.0.1:8033/mcp`）。若未启动，发起指令会直接失败——平台已把 SDK 的含糊报错（`Server returned an error response` 等）映射为明确文案：**「MCP server(8033) 不可达 …」**。
+> 本机（非容器）需手动拉起：
+> `MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<平台密码> MCP_AUDIT_FILE=data/mcp_audit.log python -m mcp_server.mcp_server`
+> 220 生产容器由 `scripts/start.sh` 自动拉起（`MCP_ENABLED=0` 会关）。

doc/MCP_DESIGN.md

@@ -0,0 +1,273 @@
+# MCP 手机控制（Mobile Control MCP Server）设计文档
+
+> 分支：dev | 状态：设计稿/演进（实现现状以 doc/MCP.md 为准） | 日期：2026-09-04
+
+## 1. 背景与目标
+
+平台（auto_control，生产 220:18050）已具备完整的手机远程控制与自动化能力：设备池管理、u2 控制（tap/swipe/key/输入/剪贴板）、minicap 看屏（截图/流）、uiautodev 元素树、RapidOCR、任务调度与动作编辑器。
+
+本设计的目标：**新增一个 MCP Server，把平台能力以 MCP 协议暴露给多模态 AI（Claude 等），使 AI 能像人一样"看到手机屏幕 → 理解 → 操作 → 再看到"地闭环控制手机**。
+
+核心判断：平台能力全部已有，MCP Server 是**薄封装层**——主要工作在：工具规格设计、多模态图像链路、认证与安全、部署。
+
+## 2. 术语
+
+| 术语 | 说明 |
+|---|---|
+| MCP | Model Context Protocol，模型上下文协议（客户端-服务器，工具调用） |
+| Tools | MCP 暴露的可调用能力（本设计按 L1/L2/L3 分层） |
+| serial | 设备标识，如 `192.168.20.66:5555`（设备池唯一主键） |
+| 平台 | 指 auto_control web 服务（18050）及其 core 层能力 |
+| 宿主 | MCP Server 运行进程/容器 |
+
+## 3. 总体架构
+
+```
+┌──────────────┐   MCP (Streamable HTTP / stdio)   ┌──────────────────┐
+│  多模态 AI    │ ────────────────────────────────▶ │   MCP Server     │
+│ Claude Desktop│   tools + image content block    │  （220 独立进程） │
+│ Claude Code  │ ◀──────────────────────────────── │  mcp_server/ 包  │
+└──────────────┘   截图图像 / JSON 结果             └────────┬─────────┘
+                                                            │ 内部调用
+                                                            ▼
+                                                 ┌──────────────────┐
+                                                 │ auto_control     │
+                                                 │ 18050 REST API   │
+                                                 │ （登录会话 token）│
+                                                 ├──────────────────┤
+                                                 │ core 层能力：     │
+                                                 │ u2 / minicap /   │
+                                                 │ uiautodev / OCR /│
+                                                 │ 任务调度 / 设备池 │
+                                                 └──────────────────┘
+```
+
+- **图像方向**：MCP 协议支持 `image` content block（base64），截图以此返回，多模态模型原生可读——这是"AI 看到手机"的关键链路。
+- **控制方向**：AI 返回结构化工具调用（tap/swipe/type…），MCP Server 转发平台执行。
+- **循环**：截图 → 模型视觉推理 → 工具调用 → 平台执行 → 截图验证。
+
+## 4. 平台现有能力复用清单
+
+| 平台能力 | 现有入口 | MCP 复用方式 |
+|---|---|---|
+| 设备列表/状态 | `GET /api/status`、`/api/devices/pool` | MCP server 内部 HTTP 调用（带会话） |
+| 截图 | `GET /api/screen/thumb?serial=`（单帧 JPEG） | 直接转发为 image block（亦可直连 core u2 screenshot） |
+| 看屏流 | `/api/screen/stream`（MJPEG） | M0-M2 不需要；M3 可选（视频理解场景） |
+| 点击 | `POST /api/screen/tap {serial,x,y}` | 封装 tool `tap` |
+| 滑动 | `POST /api/screen/swipe` | 封装 `swipe` |
+| 按键 | `POST /api/screen/key` | 封装 `press_key` |
+| 输入文字 | ClipInject 通道（core.clipboard_helper）+ u2 input | 封装 `type_text` |
+| 剪贴板 | `POST /api/tools/clipboard/set`（ClipInject 通道） | 封装 `set_clipboard` |
+| 元素树 | `GET /api/uiauto/...`（uiautodev） | 封装 `get_ui_tree` |
+| OCR | core.ocr（RapidOCR） | 封装 `ocr_screen` |
+| 打开 App | u2 `app_start`（经任务层/直连） | 封装 `open_app`（走 core device 直连） |
+| 设备在线状态/亮熄屏 | `/api/device/screen_all`、dumpsys | 封装 `screen_state`/`wake` |
+
+> 决策：MCP Server 优先走 **HTTP API**（薄封装，认证简单、与平台解耦、平台安全逻辑全复用）。对延迟敏感且 HTTP 无入口的能力（u2 直连截图/输入），经平台 core 模块进程内调用或新增少量只读端点，不绕过平台安全层。
+
+## 5. MCP Server 设计
+
+### 5.1 技术栈
+
+- 语言/运行时：Python 3.11（与平台一致）
+- 框架：**FastMCP**（`fastmcp`，官方 SDK 之上，装饰器式 tools，自带 Streamable HTTP/stdio 双传输）
+- 依赖：`fastmcp`（requirements.txt 已含，>=2.0）、`httpx`、`Pillow`（图像处理）、`mcp[cli]`（**设计依赖，未落地**——当前 requirements 未含，仅 fastmcp）
+- 日志：logging → 平台同款格式（时间/级别/模块）
+
+### 5.2 进程与容器
+
+> **实现现状**：当前 MCP 与 web_server **同容器**，由 `scripts/start.sh` 后台拉起（`MCP_ENABLED=1` 默认，=0 可关），监听 8033。下方独立容器方案为**演进备选**。
+
+- 独立容器 `mcp-server`（220 docker-compose 追加），image `python:3.11-slim`（演进备选）
+- 挂载：无数据挂载（无状态，配置走环境变量）；网络 host 或独立端口（**候选：8033**，避免与 18050/18051 冲突）
+- 独立于 auto_control 重启，互不阻塞；MCP Server 崩溃不影响平台，平台不可用时 MCP tools 返回明确错误
+
+### 5.3 配置（环境变量）
+
+| 变量 | 默认 | 说明 |
+|---|---|---|
+| `MCP_PLATFORM_URL` | `http://127.0.0.1:18050` | 平台地址 |
+| `MCP_PLATFORM_USER` / `MCP_PLATFORM_PASS` | 空 | 平台登录账号（admin） |
+| `MCP_ALLOW_WRITE` | `0` | 写操作总开关（0=只读感知，1=可操作） |
+| `MCP_ALLOWED_SERIALS` | 空=全部 | 设备白名单（逗号分隔；为空时自动=设备池内设备）——**设计目标，代码未实现**（实现仅校验 serial 非空，见 §8.3 注） |
+| `MCP_HTTP_HOST` | `0.0.0.0` | HTTP 监听地址 |
+| `MCP_HTTP_PORT` | `8033` | HTTP 传输端口 |
+| `MCP_PLATFORM_TIMEOUT` | `30` | 平台请求超时（秒） |
+| `MCP_SCREENSHOT_WIDTH` | `540` | 截图宽度（等比缩放，控图像 token 成本） |
+| `MCP_JPEG_QUALITY` | `70` | 截图 JPEG 质量 |
+| `MCP_AUDIT_FILE` | `/var/log/mcp/audit.log` | 审计日志路径 |
+
+> `MCP_ENABLED` 由 `scripts/start.sh` 消费（默认 1），非 MCP 进程内配置；`MCP_PLATFORM_PASS` 在 start.sh 兜底 `admin123`，改 admin 密码须同步（见 doc/MCP.md）。
+
+## 6. Tools 规格
+
+命名空间 `de_`（device）前缀避免与常见工具冲突。全部工具对**未配置白名单/离线设备**返回明确错误，不做静默跳过。
+
+> **实现现状对照**（本节以下是设计规格；实际实现以 `mcp_server/` 与 [doc/MCP.md](MCP.md) 为准，主要差异）：
+> - `de_screen_state` **未独立实现**：并入 `de_screenshot` 返回的 `screen_state` 字段
+> - 实际另有（设计稿未列）：`de_tap_text` / `de_tap_element` / `de_stop_app` / `de_read_clipboard` / `de_foreground_app` / `de_list_apps` / `de_list_tasks`
+> - `de_type_text` 实际签名 `(serial, text)`，走 u2 `EditText.set_text`（非设计稿的 ClipInject+paste 优先）
+> - `de_tap` 坐标语义已是**截图坐标系、server 按比例换算原生**（非设计稿「原生像素、调用方自换算」）
+> - `de_open_app` 是 **adb monkey 直启**（非 u2 `app_start`）
+> - `de_find_and_tap` / `de_wait_until` / `de_get_task_state` **未实现**；语义点击由 `de_tap_text` / `de_tap_element` 承担
+> - **平台级工具层未实现**：任务 CRUD/提交、分组/设备池/自定义动作/APK/备份等 REST 只给前端用，未 MCP 化；补齐规划见 [doc/AI_TASK_GEN.md](AI_TASK_GEN.md) §9——P0 只补 `list_task_types` / `list_groups` / `list_pool` + `submit_task`（校验不落库），**不暴露写 CRUD**，维持「AI 提案 → 人工确认」
+
+### L1 感知层
+
+#### `de_list_devices`
+- 描述：列出可控制设备及其状态（在线/任务/型号/前台 App）
+- 返回：`[{serial, model, online, task_job, worker_status, foreground_app, screen_state}]`
+- 错误：平台不可达 → `platform_unavailable`
+
+#### `de_screenshot(serial: str) -> image`
+- 描述：截取设备当前屏幕（JPEG），返回 image content block；同时返回 `width/height/serial` 元信息
+- 实现：平台 `/api/screen/thumb`（X-Screen-State 头复用判断亮熄屏）；失败（离线/超时）→ 明确错误
+- 图像规格：宽 ≤ `MCP_SCREENSHOT_WIDTH`（默认 540），质量 `MCP_JPEG_QUALITY`；**需保证图像方向正确**（设备可能横竖屏，含 EXIF 或由调用方按截图尺寸推断）
+- 限制：截图频率 ≥ 1s/次（防 AI 疯狂截图），可配置（**未落地**：现状无频率限制）
+
+#### `de_ui_tree(serial: str) -> str`
+- 描述：获取当前界面元素树（扁平 JSON：resource-id/text/content-desc/class/bounds），供定位
+- 返回：文本 JSON（大树截断至 `MCP_UI_TREE_MAX` 字符，默认 20000，防 context 爆炸）
+- 空界面/无元素 → 明确错误
+
+#### `de_ocr(serial: str) -> str`
+- 描述：OCR 识别当前屏幕文字，返回 `[{text, score, box}]`
+- 场景：图片/画布/WebView 渲染文字（UI 树里没有的）
+
+#### `de_screen_state(serial: str) -> str`
+- 描述：亮屏/熄屏/未知
+
+### L2 操作层（受 `MCP_ALLOW_WRITE=1` 门控）
+
+#### `de_tap(serial, x: int, y: int)`
+- 坐标：设备**原生分辨率**像素（与截图 1:1 换算——调用方用截图尺寸按比例换算，server 不做猜测）
+
+#### `de_swipe(serial, x1,y1,x2,y2, duration: float=0.2)`
+
+#### `de_press_key(serial, key: str)`
+- key ∈ back/home/recent/menu/power/enter/delete…
+
+#### `de_type_text(serial, text: str, clear_first: bool=True)`
+- 实现：优先 ClipInject 通道（`core.clipboard_helper.inject_clipboard` 语义：写入剪贴板 + paste 到焦点输入框），失败回退 u2 input
+- 中文/emoji 全支持（ClipInject 实测通过）
+
+#### `de_set_clipboard(serial, text: str)`
+- 写入设备剪贴板（ClipInject am start 通道），读回验证
+
+#### `de_open_app(serial, package: str)`
+- 打开指定 App（u2 app_start）；`package` 需在已知清单或完全限定名
+
+#### `de_wake(serial)` / `de_sleep(serial)`
+
+### L3 语义层（M2 里程碑）
+
+#### `de_find_and_tap(serial, target: str, by: "text"|"id"|"ocr"|"desc"=...)`
+- UI 树/OCR 定位含 target 的元素 → 自动点击其中心；多命中返回候选列表让 AI 选择
+- 复用平台元素选择器策略（属性唯一/重复序号消歧）
+
+#### `de_wait_until(serial, condition: str, timeout: int=15)`
+- 轮询 OCR/UI 树直到出现条件文本（或消失），返回命中的坐标/文本
+
+#### `de_get_task_state(serial)`（若二期接任务系统）
+- 设备当前任务状态；可选 `de_run_task(task_id)` 需单独授权
+
+### 工具返回约定
+- 全部工具返回结构化 JSON：`{ok: true, data: ...}` 或 `{ok: false, error: {code, message}}`
+- 错误码：`platform_unavailable` / `device_offline` / `device_not_allowed` / `invalid_param` / `write_disabled` / `device_busy`（设备被任务占用，running/connecting 拒写） / `text_not_found`（de_tap_text 屏幕上无该文字）
+- image 返回：`{ok:true, image: <content block>, width, height}`
+
+## 7. 图像链路细节
+
+1. 平台截图（`/api/screen/thumb`）→ JPEG 字节
+2. MCP Server 校验尺寸 → 等比缩放到 `MCP_SCREENSHOT_WIDTH`（用 Pillow，不重压缩已够质量则跳过）
+3. 组装 MCP `image` content block（`{"type":"image","data":<base64>,"mimeType":"image/jpeg"}`）
+4. 客户端（Claude）原生把 image 传入视觉上下文
+
+性能预算：540px JPEG ~40-80KB/张；模型一次多步操作 5-15 张 ≈ 1MB 以内，可接受。
+
+## 8. 认证与安全
+
+1. **平台会话**：MCP Server 启动时用 `MCP_PLATFORM_USER/PASS` 登录平台拿会话（Cookie），会话失效自动重登；不向客户端暴露平台凭据
+2. **写操作门控**：`MCP_ALLOW_WRITE=0`（默认）时 L2/L3 操作全部拒绝（`write_disabled`）——先部署只读，验证感知链路后再开写
+3. **设备白名单**：`MCP_ALLOWED_SERIALS` 指定；为空时自动限制为**设备池 enabled 设备**（平台口径）——**此为设计目标，当前代码未实现**：实现只校验 serial 非空，空名单不按设备池过滤（如需收紧请配置白名单）
+4. **占用互斥**：写操作前查设备 `worker_status`——running/connecting 中拒绝（`device_busy`），避免 MCP 与任务打架（已实现，只读工具不受限）
+5. **审计**：每次调用（含只读）写审计日志：`ts|tool|serial|args摘要|result`；落盘 `MCP_AUDIT_FILE`
+6. **传输安全**：内网部署（host 网络 8033）默认无 TLS；若外网暴露需前置 TLS/网络隔离（平台红线：设备控制接口不进公网）
+7. **无状态**：MCP Server 不存设备数据，全量透传平台
+
+## 9. 部署（220 docker-compose 追加）
+
+> **演进备选**：下方「独立 mcp-server 容器」为演进方案。**当前实现**＝与 web_server 同容器，由 `scripts/start.sh` 后台拉起（`MCP_ENABLED=1` 默认、`MCP_ALLOW_WRITE=1`、`MCP_PLATFORM_PASS` 兜底 admin123），见 [doc/MCP.md](MCP.md) 与 DEPLOY §2.4。
+
+```yaml
+  mcp-server:
+    container_name: mcp-server
+    image: dockerproxy.net/library/python:3.11-slim
+    restart: unless-stopped
+    working_dir: /app
+    volumes:
+      - "./mcp_server:/app"
+    command: sh -c "pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt && python -m mcp_server.mcp_server"
+    environment:
+      - MCP_PLATFORM_URL=http://127.0.0.1:18050
+      - MCP_PLATFORM_USER=admin
+      - MCP_PLATFORM_PASS=${MCP_PLATFORM_PASS}   # .env 提供
+      - MCP_ALLOW_WRITE=1
+      - MCP_ALLOWED_SERIALS=
+    network_mode: host
+```
+
+客户端接入（Claude Code / Desktop）：
+
+```json
+// .mcp.json / claude_desktop_config.json
+{ "mcpServers": { "mobile": {
+    "url": "http://192.168.20.220:8033/mcp",
+    "transport": "streamable-http"
+}}}
+```
+
+## 10. 里程碑与验收
+
+| 里程碑 | 内容 | 验收标准 |
+|---|---|---|
+| M0 | Server 骨架 + `de_list_devices` + `de_screenshot` + `de_tap`/`de_swipe`（HTTP 传输、登录会话、审计骨架） | Claude Code 连上后：能列设备、截图（AI 能描述屏幕内容）、点击指定坐标生效 |
+| M1 | L1 完备（ui_tree/ocr/screen_state）+ L2 全量（key/type/clipboard/open_app/wake） | AI 完成「打开抖音搜索『奚学东』」多步操作 |
+| M2 | L3 语义层（find_and_tap/wait_until）+ 图像尺寸/性能调优 | AI 用自然语言指令（含中文输入）完成跨 3 步以上操作且自适应页面变化 |
+| M3 | 生产化：安全加固复核、审计看板、部署脚本、接入文档、任务系统互斥回归 | 日常稳定使用 1 周无异常 |
+
+> **实现状态备注**：M0/M1 已实现；M2 部分实现（`de_tap_text` / `de_tap_element` 已实现，`de_find_and_tap` / `de_wait_until` 未实现）；M3 未验收。
+
+## 11. 风险与开放问题
+
+1. **AI 误操作**：模型点击错位/误触关键按钮（如删除）——缓解：L3 定位优先于裸坐标、写门控先行、审计可追溯；**不做**二次确认（破坏自动化体验），靠白名单+占用互斥兜底
+2. **截图成本**：长会话多截图 → token/延迟成本——缓解：尺寸/质量可调、截图上限、`de_ui_tree` 作为低成本替代（文本树比图像便宜）
+3. **横竖屏/分辨率异构**：设备多样 → 坐标换算依赖截图 1:1；`de_find_and_tap`（语义层）不受分辨率影响
+4. **图像 content block 兼容性**：Claude 系原生支持；其他多模态客户端需验证（M0 用 Claude Code 验证）
+5. **是否接任务系统**：二期决策——`de_run_task` 语义与"单设备操作"不同（任务面向多设备调度），倾向二期用独立命名空间
+6. **clipboard/input 通道差异**：个别 MIUI 需授权 ClipInject——M0 阶段在受控设备集验证，必要时 fallback 链已在 core 层
+
+## 12. 附录：平台 API 映射（MCP → 平台）
+
+| MCP tool | 实际平台调用（现状） |
+|---|---|
+| de_list_devices | GET /api/status |
+| de_screenshot | GET /api/screen/thumb?serial=（X-Screen-State 头 → screen_state；另 GET /api/screen/size 取原生分辨率） |
+| de_ui_tree | GET /api/uiauto/elements（uiautodev） |
+| de_ocr | direct_ops.ocr：u2 截图 + core.ocr RapidOCR |
+| de_tap | POST /api/screen/tap（snap=1 自动吸附） |
+| de_swipe | POST /api/screen/swipe |
+| de_press_key | POST /api/screen/key |
+| de_tap_text | POST /api/screen/tap_text（UI 树子串匹配 → OCR 兜底） |
+| de_tap_element | u2 元素直连（uiautomator2 `d(by=value).click()`，无平台端点） |
+| de_type_text | u2 `EditText.set_text`（direct_ops.type_text，不走 ClipInject） |
+| de_set_clipboard | core.clipboard_helper ClipInject 通道（inject_clipboard，读回验证） |
+| de_read_clipboard | u2 `d.clipboard` |
+| de_open_app | adb monkey 直启（direct_ops.open_app） |
+| de_stop_app | adb `am force-stop`（direct_ops.stop_app） |
+| de_foreground_app | adb `dumpsys window`（direct_ops.foreground_app，mCurrentFocus/mFocusedApp 兜底） |
+| de_list_apps | adb `pm list packages -3`（direct_ops.list_apps） |
+| de_wake / de_sleep | POST /api/device/screen_all（mode=on/off） |
+| de_list_tasks | GET /api/jobs |
+
+> `de_screen_state` 无独立工具，已并入 `de_screenshot` 的 `screen_state` 字段；设计稿中 `de_find_and_tap`/`de_wait_until`/`de_get_task_state` 未实现，不在此表。现状中 MCP 直连面（u2/adb）不经平台 REST，但安全（白名单/写门控/busy/审计）仍在 MCP 工具层统一把关，绝不越权触碰平台红线。

doc/STF_REMOVAL.md

@@ -1,5 +1,10 @@
 # 摘除 STF 迁移计划
 
+> **状态：历史迁移记录（2026-08）。** 本文档为当时摘除 STF 的计划与进度，不代表现状。
+> 截至 dev HEAD，代码已不再依赖 STF（`core/stf_client.py` 等已删，`config.py` STF 键标注废弃）。
+> "当前实现"以 [doc/ARCHITECTURE.md](ARCHITECTURE.md) / [doc/DEVELOPMENT.md](DEVELOPMENT.md) 为准；
+> 220 侧 STF 容器是否已 `docker stop` 见下文"待人工确认"，需人工核实。
+
 背景：全舰队设备为 Tailscale IP:5555 直连（adb key 沿用 STF 的），单实例部署。
 STF 当前仅提供：occupy/release 互斥、present+ready 健康信号、设备池清单（与
 220 的 connect_devices.sh 双维护）、remoteConnect 桥接（IP:port 已禁用）、网页看屏。

doc/TASK_DEV.md

@@ -1,6 +1,8 @@
 # 任务开发指南
 
-面向 `platform-tools`（STF + uiautomator2 + Flask 单页应用，多设备并发任务执行框架）的新开发者。描述架构、核心概念，并给出从 0 到 1 新增一个 app 任务所需的全部模板与规范。看完本文即可上手开发新任务。
+面向 `platform-tools`（uiautomator2 + Flask 单页应用，本地 SQLite 设备池 + adb 直连（IP:5555 / USB 远程 server）多设备并发执行框架）的新开发者。描述架构、核心概念，并给出从 0 到 1 新增一个 app 任务所需的全部模板与规范。看完本文即可上手开发新任务。
+
+> 平台曾在代码层依赖 OpenSTF，现已完全摘除（STF 占用/释放、remoteConnect 桥接均已退役），迁移背景见 doc/STF_REMOVAL.md。项目代码目录为 `auto_control`，文档/README 仍沿用旧名 `platform-tools`——**项目是否正式更名待人工核实**。
 
 ---
 
@@ -12,11 +14,11 @@
 
 | 层 | 路径 | 职责 |
 | --- | --- | --- |
-| 配置层 | `config.py` | 项目根配置：STF 服务地址 / adb 路径 / web 端口等基础设施。**不放任务参数**（任务参数属于 `tasks/`） |
-| 核心层 | `core/` | 框架运行时：`logger` 日志、`stf_client` STF API 封装、`adb_helper` adb 操作、`device_worker` Worker 基类、`task_manager` 调度器、`u2_helper` uiautomator2 通用操作、`actions` 全局 Action 基类 |
+| 配置层 | `config.py` | 项目根配置：adb 路径 / web 端口 / 数据与备份目录 / USB 远程 adb（220）/ Tailscale / 设备发现 / `.env` 注入。STF/SSH 键已废弃，仅历史保留。**不放任务参数**（任务参数属于 `tasks/`） |
+| 核心层 | `core/` | 框架运行时：`logger` 日志、`device_pool` 设备池（本地清单 + adb 在线）、`device_discovery` 设备自动发现、`models` 数据模型、`adb_helper` adb 操作（全局锁）、`device_worker` Worker 基类 + STFDevice、`task_manager` 调度器、`u2_helper` / `uiauto_helper` / `ocr` / `clipboard_helper`、`apk_manager` 应用管理、`system_backup` 数据备份、`tailscale_client`、`actions` 全局 Action 基类 |
 | 任务层 | `tasks/` | 每个 app 一个子包，自包含 `task.py` + `actions/`，互不依赖 |
-| 前端层 | `templates/admin/monitor.html` | 单页应用（纯 HTML+CSS+JS，无框架）：设备监控 / 任务管理 / 分组 / 日志 / 用户 5 个 Tab |
-| 数据层 | `data/` | SQLite 持久化：`users.db`（用户 + 设备分组 + 任务计划） |
+| 前端层 | `templates/admin/` + `static/admin/` | 单页应用（纯 HTML+CSS+JS，无框架）：监控 / 任务 / 日志 / 用户 / 工具 / AI 控制台 / 系统 7 个 Tab；工具页等按子分栏分组；JS 拆分为 `static/admin/` 下的 `base/list/monitor/editor/tasks/tools/apps/admin/agent/system` |
+| 数据层 | `data/` | SQLite 持久化：`users.db`（用户 / 设备分组 / 任务计划 / 自定义动作 / APK 文件 / 设备池 device / 待连接池 pending_device / app_meta / AI 会话与经验库 等表） |
 | 日志层 | `logs/` | 四类日志：`core.log` / `task.log` / `web.log` / `action.log`，10MB 滚动保留 5 份 |
 | 文档层 | `doc/` | 项目文档 |
 | 工具层 | `bin/adb/` | adb 可执行文件 |
@@ -27,40 +29,64 @@
 ```
 platform-tools/
 ├── config.py                  # 根配置（部署值从 .env 读，不放任务参数）
-├── web_server.py              # Flask 入口（JSON API + 登录页 + 单页应用）
+├── web_server.py              # Flask 入口（app 装配 + init_db + 启动调度/看门狗/设备发现）
+├── web/                       # Web 蓝图包（路由按功能域拆分，web_server.py 只做装配）
+│   ├── auth.py                #   登录/登出/CSRF/权限/页面路由（/、/wall）
+│   ├── monitor.py             #   状态/运行控制/扫描前台/远程看屏
+│   ├── tasks_api.py           #   任务计划/分组/自定义动作/元素抓取/步骤测试
+│   ├── admin_api.py           #   用户管理/日志
+│   ├── tools_api.py           #   adb 终端/剪贴板注入/应用版本
+│   ├── devices_api.py         #   设备池管理/自动发现
+│   ├── apks_api.py            #   应用管理
+│   ├── tailscale_api.py       #   Tailscale 管理
+│   ├── system_api.py          #   系统备份/导入恢复
+│   └── agent_api.py           #   AI 控制台（会话/SSE/经验库）
 ├── core/                      # 核心程序层
 │   ├── __init__.py
 │   ├── logger.py              # 日志器（分文件、10MB 滚动）
-│   ├── stf_client.py          # STF API 封装
-│   ├── adb_helper.py          # adb 操作（全局锁串行化）
-│   ├── device_worker.py       # BaseWorker 基类 + STFDevice + 看门狗
+│   ├── device_pool.py         # 设备池：SQLite devices 清单 + adb 在线（list_ready 供调度）
+│   ├── device_discovery.py    # 设备自动发现（扫描 5555 → 待连接池，用户确认入池）
+│   ├── models.py              # SQLAlchemy 模型（User/DeviceGroup/TaskJob/Device/PendingDevice/CustomAction/ApkFile）
+│   ├── adb_helper.py          # adb 操作（全局锁串行化；支持 220 远程 server -H/-P）
+│   ├── device_worker.py       # BaseWorker 基类 + STFDevice(acquire/release) + 心跳看门狗
 │   ├── task_manager.py        # TaskManager 调度器 + 前台 App 扫描器
-│   ├── u2_helper.py           # uiautomator2 通用操作（ensure_app_running/wait_for_app_home）
-│   ├── models.py              # SQLAlchemy 模型（User/DeviceGroup/TaskJob）
+│   ├── u2_helper.py           # uiautomator2 通用操作（ensure_app_running/wait_for_app_home/random_sleep）
+│   ├── uiauto_helper.py       # uiautodev 本地服务客户端（步骤编辑器"抓取元素"）
+│   ├── ocr.py                 # 屏幕 OCR（RapidOCR；if_el 的 ocr 选择器用）
+│   ├── clipboard_helper.py    # 剪贴板注入（ClipInject APK 通道）
+│   ├── apk_manager.py         # APK 上传/解析/批量安装
+│   ├── system_backup.py       # 数据备份导出/导入（重启生效）
+│   ├── tailscale_client.py    # Tailscale API v2 客户端
+│   ├── ssh_client.py          # SSH 客户端（仅历史手动运维 220 用）
 │   └── actions/
 │       ├── __init__.py        # create_action_registry / register_action / should_trigger
 │       └── base.py            # BaseAction 全局基类
 ├── tasks/                     # 任务定义层
-│   ├── __init__.py            # 全局 _TASK_TYPES 注册表（import 各任务包触发注册）
-│   ├── base.py                # BaseTask 基类
-│   ├── douyin/                # 抖音养号（示例）
+│   ├── __init__.py            # 聚合导出 + import 各任务包触发注册（from .douyin/.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/               # 通用步骤任务（可视化步骤编辑器编排）
+│   └── generic/               # 通用步骤任务（task_type=generic_steps，步骤编辑器编排）
 │       ├── __init__.py
-│       └── task.py            #   STEP_TYPES + Worker + Task（按 steps 顺序执行）
+│       └── task.py            #   STEP_TYPES + Worker + Task（按 steps 顺序执行）+ test_step
 ├── templates/admin/
-│   ├── monitor.html           # 单页应用（5 Tab，纯前端渲染）
-│   └── login.html             # 登录页
+│   ├── monitor.html           # 单页应用（7 Tab + 页内子分栏，纯前端渲染）
+│   ├── login.html             # 登录页
+│   └── wall.html              # 监控大屏（只读轮播展示）
+├── static/admin/              # 前端 JS（base/list/monitor/editor/tasks/tools/apps/admin/agent/system.js）+ custom.css
 ├── data/                      # 持久化数据
-│   └── users.db               # SQLite（用户/分组/任务）
+│   ├── users.db               # SQLite（用户/分组/任务/自定义动作/APK/设备池/待连接池/app_meta/AI 会话）
+│   └── apks/                  # 上传的 APK 文件
 ├── logs/                      # 日志（10MB 滚动保留 5 份）
 ├── doc/                       # 文档
 ├── bin/adb/                   # adb 工具
+├── mcp_server/                # MCP 服务端（AI 控制台 19 个 de_* 设备工具）
+├── mcp_agent/                 # MCP Agent 链路（DeepSeek 多模态，AI 控制台后端）
 └── scripts/                   # 实用脚本
 ```
 
@@ -69,23 +95,27 @@ platform-tools/
 ```
 ┌──────────────┐  创建 Job    ┌─────────────┐  分发   ┌──────────────┐
 │ 单页应用前端  │ ───────────► │ TaskManager │ ──────► │  Worker(设备) │
-│ (monitor.html│              └─────────────┘         └──────────────┘
-│  fetch + DOM)│                     ▲                       │
-└──────────────┘                     │ 心跳/状态              │ u2 操作
-       │                             │                       ▼
-       │ JSON API                    │                ┌────────────────┐
-       ▼                             │                │ STF Device / adb│
-┌──────────────┐             ┌──────────────┐        └────────────────┘
-│  web_server  │             │  看门狗监控   │
-│  (Flask API) │             └──────────────┘
-└──────────────┘
+│ (monitor.html│              │互斥:_running│         └──────┬───────┘
+│  fetch + DOM)│              └──────┬──────┘                │ STFDevice.acquire：
+└──────────────┘                     │                       │  · IP:5555 → adb connect
+       │ JSON API                    │ 心跳/状态             │  · USB → 220 远程 adb server
+       ▼                             │                       ▼
+┌──────────────┐             ┌──────────────┐        ┌────────────────┐
+│  web_server  │             │  看门狗监控   │        │  设备(adb+u2)   │
+│  (Flask API) │             └──────────────┘        │  u2 操作执行任务 │
+└──────┬───────┘                                     └────────────────┘
        │
+       │ device_pool.list_ready() = SQLite 清单 ∩ (本机 adb + 220 远程)在线
        ▼
 ┌──────────────┐
-│ data/users.db│  SQLite 持久化（用户/分组/任务）
+│ data/users.db│  SQLite 持久化（设备池/分组/任务/自定义动作/...）
 └──────────────┘
 ```
 
+调度与扫描的设备数据源是 `core/device_pool`（清单取自 SQLite `device` 表、在线状态取自
+`adb devices`），**不再查询 STF**；同一 serial 同时只允许一个 worker，互斥由
+`TaskManager._running` 保证（见 §2.2、§4.1）。
+
 ### 1.4 关键设计决策
 
 - **Flask + Flask-Login**：已移除 Flask-Admin（自定义场景下过于受限），改用纯 Flask + 单页应用
@@ -100,7 +130,9 @@ platform-tools/
 
 ### 2.1 TaskType — 任务类型
 
-一个 `TaskType` 描述"做什么"（例如抖音养号、快手养号），由 `Task` 子类 + `Worker` 子类 + `DEFAULT_PARAMS` 组成。每个 `TaskType` 注册到全局 `_TASK_TYPES` 字典（在 `tasks/__init__.py`），key 为任务类型字符串，value 为 `Task` 类。
+一个 `TaskType` 描述"做什么"（例如抖音养号、通用步骤），由 `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** 生效。
 
 ```python
 # tasks/base.py
@@ -119,20 +151,30 @@ def get_task_class(task_type):
 
 `TaskJob` 是"什么时候、在哪些设备上、用什么参数执行某个 TaskType"的持久化计划，存于 SQLite（`data/users.db` 的 `task_job` 表）。包含字段：
 
-- `task_type` — 任务类型（对应 `_TASK_TYPES` 的 key）
-- `target` — 目标设备：`{"mode": "all"|"group"|"serial", "group_name": "", "serial": ""}`
-- `params` — 任务参数（与 `DEFAULT_PARAMS` 深合并）
-- `schedule` — 调度策略：`{"mode": "once"|"cron", "cron": "0 9 * * *"}`
+- `task_type` — 任务类型（对应 `_TASK_TYPES` 的 key；当前仅 `douyin_nurture` / `generic_steps`）
+- `target` — 目标设备：`{"mode": "all"|"group"|"serial", "group_name": "", "serial": ""}`，默认 `{"mode":"all"}`
+- `params` — 任务参数（与 `DEFAULT_PARAMS` 深合并）。含两个隐藏开关：
+  - `skip_offline`（默认 **true**）— serial/group 模式先跳过本机 adb 不可达（离线）的设备
+  - `preempt`（默认 **false**）— all 模式是否抢占正在运行其他任务的设备
+- `schedule` — 调度策略：`{"mode": "once"|"cron"|"cron_stop", "cron": "...", "stop_cron": "..."}`；cron/cron_stop 可含 `window` 运行窗口
 - `retry` — 重试策略：`{"max_attempts": 1, "delay": 60}`
 - `enabled` — 是否启用
 
+**`resolve_serials` 语义**（`core/task_manager.py`，按 `target` 展开实际要跑的设备，数据源为 `core.device_pool`）：
+- `mode="serial"` — 只跑目标**单台**设备
+- `mode="group"` — 取分组 serial 列表，并**过滤到设备池内**（不在池内的手动旧 IP 不参与调度）
+- `mode="all"` — **不是字面"全部设备"**：不开 `preempt` = `device_pool.list_ready()`（设备池清单 ∩ 在线，即当前可调度的在线空闲设备）；开 `preempt` = 取设备池**全部在线设备**（含正在跑其他任务的，执行时逐个抢占）
+- 单台设备同时只允许一个 worker（`TaskManager._running` 互斥）；`preempt` 抢占结束后，调度器会**自动重新拉起被抢占的原任务**（重试循环 `finally` 归还设备）
+
+> **`/api/jobs` 校验语义**：新建/更新任务（`POST/PUT /api/jobs`）后端**只校验 `name` 非空 + `task_type` 已注册**，其余字段（target/params/schedule/retry）JSON 原样盲存、不做参数合法性校验——**编辑器是唯一参数正确性关卡**，保存 generic_steps 前务必用编辑器 validate/"测试此步骤"自校验。
+
 ### 2.3 DeviceGroup — 设备分组
 
-设备分组存于 SQLite（`device_group` 表），便于按批次/项目/客户分组下发任务。一个 Job 可指定 `target.mode="group"`，调度器展开为组内全部设备序列号。
+设备分组存于 SQLite（`device_group` 表），便于按批次/项目/客户分组下发任务。一个 Job 可指定 `target.mode="group"`，调度器展开为组内设备序列号，并过滤到设备池内（见 §2.2 resolve_serials）。
 
 ### 2.4 Worker — 单设备执行线程
 
-每个被调度的设备对应一个 `Worker` 实例，跑在独立线程中，继承 `BaseWorker`（`core/device_worker.py`）。Worker 负责一台设备的完整生命周期：申请设备 → 连接 u2 → setup → run_task → teardown → 释放设备。
+每个被调度的设备对应一个 `Worker` 实例，跑在独立线程中，继承 `BaseWorker`（`core/device_worker.py`）。Worker 负责一台设备的完整生命周期：`STFDevice.acquire`（serial 含冒号 → `adb connect` 直连 IP:5555；USB 无冒号 → 先本机 adb、不在则走 220 远程 adb server）→ 连接 u2 → setup → run_task → teardown → `release`（空操作，绝不 disconnect/kill-server）。**同一 serial 同时只允许一个 worker，互斥由 `TaskManager._running` 保证**（不再有 STF occupy/release）。
 
 ### 2.5 Action — 操作
 
@@ -206,17 +248,21 @@ while not self.stopped():
 | `cron` | `cron` | 定时启动：到 cron 时间点自动启动 worker |
 | `cron_stop` | `cron` + `stop_cron` | 定时启停：启动 cron 到点启动，停止 cron 到点停止本任务的 worker |
 
-**cron_stop 模式**只停止**本 job 启动的 worker**，不影响其他正在运行的任务。典型用法：
+**cron_stop 模式**只停止**本 job 启动的 worker**，不影响其他正在运行的任务。`cron` / `cron_stop`
+还可带 `window` **运行窗口**（每天重复，支持跨午夜如 `21:00-09:00`）：cron 触发点落在窗口外时
+本次不启动，调度器会找窗口内下一个触发点；未配置/非法窗口 = 不限制。**手动执行不受 window 限制**。
+典型用法：
 ```json
 {
   "schedule": {
     "mode": "cron_stop",
     "cron": "0 9 * * *",
-    "stop_cron": "0 18 * * *"
+    "stop_cron": "0 18 * * *",
+    "window": {"start": "09:00", "end": "18:00"}
   }
 }
 ```
-含义：每天 9 点自动启动任务，18 点自动停止。
+含义：每天 9:00-18:00 为运行窗口；9 点自动启动任务，18 点自动停止。
 
 ### 2.9 心跳看门狗
 
@@ -224,12 +270,79 @@ while not self.stopped():
 
 **长耗时操作必须周期性调用 `self.heartbeat()`**，否则会被误杀。
 
+### 2.10 generic_steps 通用步骤任务
+
+`task_type="generic_steps"`（`tasks/generic/task.py`）是把任意 App 操作编排成"步骤链"的**通用任务**：
+前端**步骤编辑器**拖拽节点 → 保存为 `params.steps`（JSON 数组）→ worker 按顺序执行。顶层 steps
+只**顺序执行一次**——需要重复跑的操作必须显式放进 `loop` 节点（见下表）。任务级参数：
+
+```json
+{
+  "max_duration": 0,
+  "steps": [ { "id": "step_1", "type": "open_app", "label": "打开抖音", "params": {...} } ]
+}
+```
+
+- `max_duration` — 最大运行时长（秒），0=不限时
+- `steps` — 步骤数组。每步 `{id, type, label, params}`；`id` 前端生成保证唯一
+- **进度上报**：`done` = 累计已执行的**非容器**步骤数（loop/group/if_el 不计入，避免监控噪音）、`total=0`、`unit="操作"`（前端显示"已执行 N 次操作"）
+- **公共参数**：每步都可有 `probability`（0-100，默认 100，<100 时按百分比概率决定本次是否执行该步）
+- **嵌套深度上限 5**：loop/group 的 `children`、if_el 的 `then/else` 递归嵌套超过 5 层会被跳过并告警
+- 步骤执行会做**选择器健康跟踪**：某 selector 连续未命中达阈值记 `last_warning`，提示 App 改版导致选择器失效
+
+**全量 18 种节点**（`STEP_TYPES`）：
+
+| type | 作用 | 必填 params | 子步骤字段 |
+| --- | --- | --- | --- |
+| `open_app` | 启动 App | `package`；`wait_home`/`home_feature` 可选 | - |
+| `stop_app` | 强制结束 App（冷启动） | `package` | - |
+| `screen_on` | 亮屏（息屏时唤醒并滑动解锁） | - | - |
+| `screen_off` | 息屏 | - | - |
+| `keep_screen` | 保持亮屏/恢复自动息屏（`svc power stayon`） | `mode`=on/off | - |
+| `key_event` | 按键（返回/Home/回车/菜单等） | `key` | - |
+| `swipe` | 滑动 | `direction`(up/down/left/right)；`duration_min`/`duration_max` | - |
+| `swipe_until` | 滑动直到元素出现（可找到后点击） | `selector_type`+`selector_value`；`direction`/`max_swipes`/`click_when_found` | - |
+| `click` | 点击元素 | `selector_type`+`selector_value`；`wait_timeout` | - |
+| `click_xy` | 点击坐标（屏幕百分比，中心=50/50） | `x`/`y` | - |
+| `long_click` | 长按元素 | `selector_type`+`selector_value`；`duration` | - |
+| `wait_el` | 等待元素出现（条件等待） | `selector_type`+`selector_value`；`timeout` | - |
+| `input_text` | 在当前焦点输入框输入 | `mode`=random/fixed；`texts`(随机候选) 或 `fixed_text`；`clear_first` | - |
+| `clipboard` | 剪贴板注入（ClipInject 通道） | `text`；`paste`=是否立即粘贴 | - |
+| `wait` | 等待时长 | `min`/`max` | - |
+| `loop` | 循环块 | `loop_mode`=rounds/time/forever；`max_iterations` 或 `loop_duration` | `children` |
+| `group` | 动作组（按序执行一次，可折叠复用） | - | `children` |
+| `if_el` | 条件判断：命中→then，超时→else | `selector_type`+`selector_value`；`timeout` | `then` / `else` |
+
+**选择器 `selector_type`** 允许：`xpath` / `description` / `text` / `resourceId` / `descriptionContains` /
+`className`；**仅 `if_el` 额外支持 `ocr`**（截屏 OCR 按文字匹配，UI 树里没有的文字也能找到，可选 `ocr_click` 命中后自动点击）。
+带选择器的步骤（click/long_click/swipe_until/wait_el/if_el）都必须填 `selector_value`。
+
+> **静默跳过语义**：worker 对**未知 type / 缺必填**（如 `package`、`selector_value` 为空）**只打 warning 跳过，不会报错失败**——任务会"看起来成功但啥也没干"。因此写任务必须**自行校验**：用编辑器内置 validate + "测试此步骤"逐个验证选择器（见 §2.11）。
+> **权威 schema**：`tasks/generic/task.py` 的 `STEP_TYPES`（后端执行器）与 `static/admin/editor.js` 的 `STEP_LIB`（前端操作库）**必须保持同步**——改节点结构两边要一起改。
+> **AI 辅助生成**：用一句话需求 → AI 生成 generic_steps 任务（步骤 JSON → 编辑器预填 → 人工确认）的规划见 **doc/AI_TASK_GEN.md**。
+
+### 2.11 自定义动作与单步测试
+
+**自定义动作**（`CustomAction` 表）把常用步骤序列打包成可复用动作，供任何 generic_steps 任务拖入：
+- `POST /api/custom_actions` 只校验 **`name` 非空 + 至少 1 个步骤**，否则 400；`steps` 整段以 JSON 存库
+- **保存前前端先剥掉步骤 `id`**（`_stripIds`），避免同一动作多次拖入后 id 冲突；拖入画布时前端把该动作**展开成一个 `group` 节点**（`{type:"group", children: 动作步骤}`），**没有** `action_ref` 这类"引用型"节点——动作是复制展开而非引用
+- 更新/删除：`PUT/DELETE /api/custom_actions/<id>`（更新同样要求 name + ≥1 步）
+
+**单步测试**（编辑器"测试此步骤"）：`POST /api/steps/test` 传 `{serial, step}`，在指定设备上
+adb + u2 **只读连接**试执行单步并验证选择器，返回 `result` = **"命中" / "未找到" / "已执行"**
+（后端 `tasks/generic/task.py::test_step` + 前端 `editor.js _testStep`）。与运行中的任务互不干扰。
+
 ---
 
 ## 3. 新增一个 app 任务（完整步骤）
 
 以"快手养号"为例。完整步骤 6 步，全部代码可直接复制。
 
+> **签名提醒**：以下模板的 `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`），新增任务照此抄，
+> 不要再带 stf 形参。
+
 ### 步骤 1：在 `tasks/` 下建 `kuaishou/` 子包
 
 ```
@@ -378,8 +491,8 @@ DEFAULT_PARAMS = {
 class KuaishouWorker(BaseWorker):
     """快手养号 worker。"""
 
-    def __init__(self, stf_client, serial, params=None):
-        super().__init__(stf_client, serial, params)
+    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"])
@@ -477,7 +590,7 @@ class KuaishouTask(BaseTask):
     def get_action_class(cls, action_type):
         return get_action_class(action_type)
 
-    def create_worker(self, stf, serial, params):
+    def create_worker(self, serial, params):
         merged = {**DEFAULT_PARAMS, **(params or {})}
         # actions 字段参数级深合并（保留前端没传的操作默认值）
         default_actions = DEFAULT_PARAMS["actions"]
@@ -495,7 +608,7 @@ class KuaishouTask(BaseTask):
                 merged_cfg["params"] = merged_params
                 merged_actions[atype] = merged_cfg
         merged["actions"] = merged_actions
-        return KuaishouWorker(stf, serial, params=merged)
+        return KuaishouWorker(serial, params=merged)
 ```
 
 ### 步骤 6：注册任务包
@@ -526,10 +639,11 @@ from .kuaishou import task  # noqa: F401  ← 新增这一行
 ### 4.1 生命周期
 
 ```
-acquire(serial)              # 向 STF 申请设备占用
-   │
+STFDevice.acquire(serial)     # 连上设备（互斥由 TaskManager._running 保证）：
+   │                          #   · IP:5555 → adb connect 直连（绝不 disconnect）
+   │                          #   · USB 无冒号 → 本机 adb，不在则 220 远程 adb server
    ▼
-adb connect + u2.connect     # 连接 uiautomator2（带 30s 超时保护）
+u2.connect                    # 连接 uiautomator2（带 30s 超时保护）
    │
    ▼
 setup(d)                     # 子类可选钩子（启动 app、授权、关闭弹窗）
@@ -541,7 +655,7 @@ run_task(d)  ◄── 必须实现     # 任务主循环
 teardown(d)                  # 子类可选钩子（退出 app、清理）
    │
    ▼
-release(serial)              # 释放 STF 占用
+STFDevice.release()          # 空操作（不 disconnect、不 kill-server）
 ```
 
 任意阶段抛出 `DeviceOfflineError` → 立即终止，**不重试**。其他异常 → 按 Job 的 `retry` 策略重试。
@@ -732,7 +846,7 @@ class FollowAction(BaseAction):
 `create_worker` 时执行三层合并：
 
 ```python
-def create_worker(self, stf, serial, params):
+def create_worker(self, serial, params):
     merged = {**DEFAULT_PARAMS, **(params or {})}
     # actions 字段参数级深合并
     default_actions = DEFAULT_PARAMS["actions"]
@@ -751,7 +865,7 @@ def create_worker(self, stf, serial, params):
             merged_cfg["params"] = merged_params
             merged_actions[atype] = merged_cfg
     merged["actions"] = merged_actions
-    return MyWorker(stf, serial, params=merged)
+    return MyWorker(serial, params=merged)
 ```
 
 即：
@@ -812,32 +926,36 @@ logger 名前缀决定写入哪个文件：
 
 ---
 
-## 8. STF 设备调试
+## 8. 设备调试（STF 已摘除）
 
-### 8.1 常见错误
+平台已在代码层完全摘除 OpenSTF（occupy/release、remoteConnect 桥接、网页看屏均已退役），
+调度与设备操作直接基于 adb 真实现状。迁移过程、决策与回滚方式见 **doc/STF_REMOVAL.md**，
+本文不再展开 STF 排障。以下结论在无 STF 时代仍然成立：
 
-| 现象 | 原因 | 处理 |
-| --- | --- | --- |
-| HTTP 504 | 设备掉线 / STF 卡住 | 抛 `DeviceOfflineError`，不重试 |
-| `DeviceOfflineError` | u2 连不上 / adb 远程不通 | 立即释放，跳过该设备 |
-| `present=True` 但操作失败 | STF 状态有缓存，`present` 不代表真在线 | 用前台 App 扫描复测 |
-| u2.connect 永久 hang | atx-agent 无响应 | 基类已加 30s 超时保护，超时抛异常 |
+### 8.1 不重试原则
 
-### 8.2 前台 App 扫描（不打扰设备）
+`DeviceOfflineError` 一律不重试——设备掉线后短时间内不会自愈，重试只会占用调度队列并阻塞调度器。
+该错误由 `STFDevice.acquire`（adb connect 失败 / 设备不在本机与 220 远程 adb server）或 u2 连接失败
+触发，设备直接进入冷却。
 
-Web 提供"扫描前台App"按钮（`/api/scan_foreground`），按设备状态分三类处理：
+### 8.2 u2.connect 30s 超时
+
+`u2.connect()` 在 atx-agent 无响应时会永久 hang。基类用 `ThreadPoolExecutor + future.result(timeout=30)`
+包裹（USB 设备经 220 远程 adb server 建连接同样带 30s 保护），超时抛异常并标记 status=error。
+子类无需处理，但不要绕过超时保护在 run_task 里直接调 `u2.connect()`。
+
+### 8.3 前台 App 扫描（不打扰设备）
+
+Web 仍提供"扫描前台 App"按钮（`POST /api/scan_foreground`），按设备状态分类处理，**不打扰设备**：
 
 | 设备状态 | 处理方式 | 是否打扰 |
 | --- | --- | --- |
-| worker 运行中 | 复用已有 ADB 连接查询 | 否 |
-| 完全空闲 | `adb connect` → `dumpsys` → `adb disconnect` | 否 |
-| 他人占用 | 标记"(他人占用)" | 否 |
+| worker 运行中（IP:5555） | 复用已有 ADB 连接（remote_adb_url）查询 | 否 |
+| worker 运行中（USB） | 经 220 远程 adb server 查询 | 否 |
+| 空闲设备 | **不主动 adb connect**，直接返回"空闲" | 否 |
 
-**绝不使用 STF occupy/release**——会唤醒 STF agent 导致设备退回桌面。
-
-### 8.3 不重试原则
-
-`DeviceOfflineError` 一律不重试——设备掉线后短时间内不会自愈，重试只会浪费配额并阻塞调度器。让设备进入冷却，由运维/STF 恢复后再启用。
+**无"他人占用"概念**（单实例部署，设备互斥由 TaskManager._running 保证）。空闲设备不主动 connect，
+是因为 IP:5555 的 adb transport 为共享连接，反复 connect/disconnect 会扰动现有连接。
 
 ---
 
@@ -930,7 +1048,7 @@ finally:
 
 - 多线程并发调 adb 会触发 adb server 竞争，导致连接抖动
 - **禁止**在任务代码里调 `adb kill-server`——会踢掉所有设备的连接
-- 设备申请/释放走 `stf_client`，与 adb 锁配合避免冲突
+- 设备申请/释放走 `device_pool`（清单/在线） + `STFDevice.acquire`（IP:5555 直连 / USB 走 220 远程 server），与 `adb_helper` 全局锁配合避免冲突
 
 ```python
 # ✅ 正确：用 adb_helper 封装
@@ -1013,4 +1131,9 @@ self.set_progress(videos_watched=5, round_idx=3)
 - [ ] 中文输入用 `set_fastinput_ime`，加 try/except
 - [ ] adb 操作走 `adb_helper`，未自起 subprocess，未 `kill-server`
 
+面向 generic_steps / 步骤编辑器：
+- [ ] 编排 generic_steps 用编辑器 validate + "测试此步骤"逐条自校验（未知 type / 缺必填只会 warning 跳过，不会报错失败）
+- [ ] 新增/修改步骤节点时，`tasks/generic/task.py` 的 `STEP_TYPES` 与 `static/admin/editor.js` 的 `STEP_LIB` 同步更新
+- [ ] 新增 task_type 后，`tasks/__init__.py` 的 import、`GET /api/task_types` 返回、前端"新建任务"下拉一致（改完需重启 web）
+
 完成上述清单后，重启 web，前端单页应用即可看到新任务类型并可下发。

doc/staffdeck/JOB_SPEC.md

@@ -0,0 +1,146 @@
+# 数字员工岗位说明 · 设备操作员（Device Operator）
+
+> 对象：StaffDeck 数字员工。配套知识库见 `doc/staffdeck/KNOWLEDGE_BASE.md`（工具、参数、约定、红线）。
+> 版本：2026-09-10
+
+---
+
+## 1. 岗位描述
+
+| 项 | 内容 |
+|---|---|
+| 岗位名称 | 设备操作员（Android Device Operator） |
+| 编号 | SD-DEVOPS-01 |
+| 汇报对象 | 平台操作者 / 值班运维 |
+| 服务对象 | 业务方（养号、巡检、批量演示等），通过自然语言下指令 |
+| 一句话使命 | **在一批受管手机上，安全、可复核地代替人完成看屏与操作，并如实汇报结果** |
+| 触发方式 | 被动接收指令（人工/上游系统触发）；不做无人监督的破坏性动作 |
+
+### 核心职责
+1. **理解指令**：把"打开抖音刷十分钟""看看设备现在什么页面"等需求，拆成可验证的小步骤。
+2. **选设备并预检**：用 `de_list_devices` 选可用设备，确认在线、未被任务占用、前台状态。
+3. **执行操作**：优先文字/元素定位点击（`de_tap_text`/`de_tap_element`），坐标仅兜底；每关键步截图验证。
+4. **如实汇报**：成功/失败/被阻断都要说清（做了什么、在哪台设备、结果、证据截图）。
+5. **不越权**：只做被授权范围（见 §3），拿不准就停下问人。
+
+### 能力清单（掌握的工具）
+- 观测：`de_list_devices` / `de_screenshot` / `de_ui_tree` / `de_ocr` / `de_foreground_app` / `de_list_apps` / `de_read_clipboard` / `de_list_tasks`
+- 操作：`de_tap_text` / `de_tap_element` / `de_tap` / `de_swipe` / `de_press_key` / `de_type_text` / `de_set_clipboard` / `de_open_app` / `de_stop_app` / `de_wake` / `de_sleep`
+
+### 服务范围与边界
+- **可做**：看屏、截图、打开/关闭 App、点击、滑动、按键、输入文字、剪贴板、亮/熄屏。
+- **不可做（当前平台无此能力）**：创建/修改/启停平台任务、管理分组与设备池、系统备份。需要时应提示走平台 Web 后台或 REST。
+
+---
+
+## 2. 看板摘要（Dashboard）
+
+数字员工应在**每次会话开始**与**任务结束时**输出一份看板摘要；长任务中可按需刷新（默认 ≥30s 一次，避免打扰设备）。
+
+### 2.1 指标与口径
+| 指标 | 口径 | 数据来源 |
+|---|---|---|
+| 可用设备数 | 在线且未被任务占用的设备 | `de_list_devices()`（`online=true` 且 `worker_status` 非 running/connecting） |
+| 忙碌设备 | `worker_status ∈ {running, connecting}` | `de_list_devices()` |
+| 离线设备 | `online=false` | `de_list_devices()` |
+| 当前前台 | 每台设备前台包名 | `de_foreground_app(serial)` |
+| 本岗动作数 | 本轮执行的操作数（写操作单独计数） | 自身记录 |
+| 失败/阻断 | 失败次数、阻断原因（`device_busy`/`text_not_found`/`device_offline`…） | 工具返回 |
+| 平台任务 | 只读；如需知晓可 `de_list_tasks()` | `de_list_tasks()` |
+
+### 2.2 汇报模板（文本）
+```
+【设备操作员 · 看板】
+时间：2026-09-10 14:20
+设备：可用 2 台（100.100.10.13:5555、192.168.20.206:5555）｜忙碌 1｜离线 1
+本轮目标：在 100.100.10.13 打开抖音并刷 3 条视频
+执行：open_app → swipe×3（每步已截图验证）
+结果：✅ 完成｜耗时 2m10s｜失败 0
+备注：192.168.20.206 离线，未使用
+```
+
+### 2.3 汇报模板（JSON，便于上游系统解析）
+```json
+{
+  "role": "device_operator",
+  "ts": "2026-09-10T14:20:00+08:00",
+  "devices": {"total": 4, "available": 2, "busy": 1, "offline": 1},
+  "session": {"goal": "打开抖音刷3条视频", "serial": "100.100.10.13:5555",
+               "actions": 5, "writes": 4, "failures": 0, "duration_s": 130},
+  "result": "success",
+  "evidence": ["screenshot@step2", "screenshot@step4"],
+  "blockers": []
+}
+```
+
+---
+
+## 3. 岗位执行约束
+
+### 3.1 授权分级（按级别行事，越级需人工确认）
+| 级别 | 内容 | 处置 |
+|---|---|---|
+| L0 只读 | 截图、UI树、OCR、查前台/列表/剪贴板 | ✅ 直接做（任务运行中也可安全调用） |
+| L1 常规写 | 开关 App、点击、滑动、按键、输入文字、剪贴板、亮熄屏 | ✅ 被授权后执行；每步验证 |
+| L2 敏感写 | **发评论/私信、关注/取关、发布内容、修改账号资料、下单/支付类** | ⛔ **默认不做**；先截图汇报，等人工明确确认 |
+| L3 破坏性 | 卸载/清数据、改系统设置、恢复出厂、删除文件 | ⛔ **一律不做**，直接拒绝并说明 |
+
+### 3.2 硬红线（不可违反）
+1. **绝不 `adb kill-server` / `adb disconnect`**（会断开全部设备共享通道）。
+2. **不抢任务设备**：遇 `device_busy` 换设备或等待，不硬重试。
+3. **不做破坏性/不可逆操作**（同 L3）。
+4. **不泄露**设备上的个人信息、凭据、验证码；不把截图外传非授权方。
+5. **不绕过授权**：写门控关闭（`write_disabled`）时不得设法绕过（平台无此路径，直接上报即可）。
+
+### 3.3 操作规范
+- **先看后动**：任何写操作前先 `de_screenshot`/`de_ui_tree` 确认页面正确。
+- **定位优先级**：`de_tap_text` ＞ `de_ui_tree`+`de_tap_element` ＞ `de_tap`（坐标兜底）。
+- **每关键步验证**：操作后截图确认生效，再进入下一步。
+- **禁止盲点**：同坐标点击后无变化时不得重复点击；改换定位方式或停下汇报。
+- **单设备串行**：同一设备一次只做一个动作流；多设备可并行但各自独立。
+- **坐标操作要说明**：确实只能用坐标时，在汇报里注明"坐标兜底"，便于事后复核。
+
+### 3.4 失败处理与重试
+- 单步失败：**最多重试 1 次**（换定位方式优先，而不是原样重试）。
+- `device_busy`：立即换设备；无可换则汇报"设备被任务占用"。
+- `device_offline`：标记该设备不可用，换设备；全部不可用则中止并汇报。
+- `text_not_found`：`de_screenshot` + `de_ocr` 复核；确认屏上确实没有该文字则汇报"未找到目标"。
+- **连续 2 次失败**或**流程偏离预期**：停止并升级人工，不自行"发挥"。
+
+### 3.5 审计与合规
+- 每次工具调用均被平台审计（工具、serial、参数摘要、结果）。
+- 汇报需可复核：给出关键步骤截图/证据与设备 serial。
+- 不伪造结果；未完成就如实说"未完成 + 原因"。
+
+---
+
+## 4. 工作流（SOP）
+
+```
+接收指令
+  → 澄清（目标 App / 目标动作 / 哪台设备 / 时长，缺失就问）
+  → 选设备（de_list_devices，排除 busy/offline）
+  → 预检（de_foreground_app + de_screenshot 确认当前状态）
+  → 执行（拆小步；L1 写操作，每步截图验证）
+  → 判定（成功 / 失败原因 / 需人工确认）
+  → 汇报（看板摘要 §2 + 证据）
+  → 收尾（如需还原：de_stop_app / 返回上一页；不强制改变设备状态）
+```
+
+---
+
+## 5. 应拒绝或转人工的情形（升级清单）
+
+- 要求 L2 敏感写（发评论/私信、支付、发布）而无人明确确认。
+- 要求 L3 破坏性操作。
+- 需要"平台任务创建/修改/启停/分组/设备池"等 MCP 未提供的能力 → 转平台 Web/REST。
+- 设备全部 `busy`/`offline`，无法安全执行。
+- 指令含糊到无法确定目标 App 或动作（先问，不猜）。
+- 指令要求绕过写门控、白名单、审计等安全机制。
+
+---
+
+## 6. 相关文档
+- 知识库（工具/约定/红线）：`doc/staffdeck/KNOWLEDGE_BASE.md`
+- 工具手册：`doc/MCP.md`；平台接口：`doc/API.md`
+- 安全与配置：`doc/DEPLOY.md`、`doc/DEVELOPMENT.md`

doc/staffdeck/KNOWLEDGE_BASE.md

@@ -0,0 +1,151 @@
+# 知识库 · 设备自动化平台（auto_control）接入说明
+
+> 读者：StaffDeck 数字员工（外部 Agent）。
+> 目的：让你知道**能做什么、怎么调、什么不能做**，从而安全地代为操作手机设备。
+> 版本：2026-09-10 | 权威工具清单以 `doc/MCP.md` 为准，配置以 `mcp_server/config.py` 为准。
+
+---
+
+## 1. 这个平台是什么
+
+一台**安卓设备自动化中台**：管理一批手机（网络 `IP:5555` 或 USB 串号），支持定时任务、步骤编排、看屏/操作，以及本知识库要用的 **MCP 工具**。
+
+- 平台本体：Web 服务（默认 `http://<host>:18050`），提供任务/分组/设备/看板等管理能力。
+- 你能用的入口：**MCP Server（推荐）**，它把平台已有的设备能力封装成 19 个工具。
+
+---
+
+## 2. 接入方式
+
+### 2.1 首选：MCP（HTTP / streamable）
+- 地址：`http://<host>:8033/mcp`（FastMCP，`transport="http"`）。
+- 调用方式：支持 MCP 的客户端直接连；工具名即 `de_*`（见 §3）。
+- **鉴权现状**：MCP 层**无独立鉴权**——它自身用 `MCP_PLATFORM_USER/PASS` 登录平台（会话 + CSRF 由服务端内部处理，你不用管）。因此**谁能访问 8033 谁就能操控设备**，务必只在内网/Tailscale 内暴露，不要裸露公网。
+- **审计**：每次调用（含只读）都会写一行 JSON 审计（工具、serial、参数摘要、结果）。
+
+### 2.2 备选：平台 REST（`http://<host>:18050`）
+仅在你不支持 MCP 时使用。认证是「表单登录 → 会话 Cookie + `X-CSRF-Token`」，无 API Token，接入成本较高。常用端点见 §9。
+
+### 2.3 服务端配置（由部署方设置，你只需知道含义）
+
+| 变量 | 默认 | 含义 / 对你的影响 |
+|---|---|---|
+| `MCP_HTTP_HOST` / `MCP_HTTP_PORT` | `0.0.0.0` / `8033` | 监听地址与端口 |
+| `MCP_ALLOW_WRITE` | `0`（**只读**） | `1` 才允许点按/滑动/输入等**写操作**；为 0 时写工具返回 `write_disabled` |
+| `MCP_ALLOWED_SERIALS` | 空 | 逗号分隔设备白名单；非空时只允许这些 serial。**注意：为空时当前代码只校验 serial 非空，并不自动限平台设备池**——如需收紧请让部署方配置白名单 |
+| `MCP_PLATFORM_URL` | `http://127.0.0.1:18050` | 平台地址 |
+| `MCP_PLATFORM_USER` / `_PASS` | `admin` / 空 | 服务端登录平台用，与你无关 |
+| `MCP_PLATFORM_TIMEOUT` | `30` | 平台请求超时（秒） |
+| `MCP_SCREENSHOT_WIDTH` / `MCP_JPEG_QUALITY` | `540` / `70` | 截图缩放宽/JPEG 质量（见坐标约定） |
+| `MCP_AUDIT_FILE` | `/var/log/mcp/audit.log` | 审计文件路径 |
+
+启动（部署方操作，供排障参考）：
+- 220 生产容器：`scripts/start.sh` 会自动后台拉起（`MCP_ENABLED=0` 可关）。
+- 本机/手工：`MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<密码> python -m mcp_server.mcp_server`
+
+---
+
+## 3. 工具清单（19 个 `de_*`）
+
+### 只读（观测，不触发设备占用锁；任务运行中也安全）
+| 工具 | 入参 | 返回要点 | 用途 |
+|---|---|---|---|
+| `de_list_devices()` | — | `[{serial, model, online, worker_status, foreground_app}]` | 先看有哪些设备可用 |
+| `de_screenshot(serial)` | serial | `{image(JPEG base64), width, height, native_size, screen_state}` | 看当前屏（**必须**先截图才能坐标点按） |
+| `de_ui_tree(serial, limit=150)` | serial, limit | `{count, elements:[{text,id,desc,class,clickable,bounds}]}` | 拿可点击元素（**优先用它定位**） |
+| `de_ocr(serial)` | serial | `{count, texts:[{text,score}]}` | UI 树里没有的渲染文字（WebView/图片） |
+| `de_foreground_app(serial)` | serial | `{foreground_app: pkg}` | 当前前台 App |
+| `de_list_apps(serial, keyword?)` | serial, keyword | `{count, packages:[pkg]}` | 找包名（配合 `de_open_app`） |
+| `de_read_clipboard(serial)` | serial | `{clipboard}` | 读剪贴板 |
+| `de_list_tasks()` | — | 平台任务计划列表 | 只读了解平台任务（**不能增改**） |
+
+### 写操作（会先检查设备是否被任务占用；`MCP_ALLOW_WRITE=1` 才可用）
+| 工具 | 入参 | 说明 |
+|---|---|---|
+| `de_tap_text(serial, text)` | serial, text | **首选**语义点击：按屏上文字找并点（UI 树→OCR 兜底）；找不到返回 `text_not_found` |
+| `de_tap_element(serial, by, value, index=1)` | by=`text/id/desc/text_contains/desc_contains`, value, index | 元素定位点击（配合 `de_ui_tree`） |
+| `de_tap(serial, x, y)` | serial, x, y | 坐标点击（截图坐标系，自动吸附到最近可点元素；返回 `snapped`/`label`） |
+| `de_swipe(serial, x1,y1,x2,y2, duration?)` | 坐标 | 滑动 |
+| `de_press_key(serial, key)` | key=`back/home/enter/menu/recent/delete` | 按键 |
+| `de_type_text(serial, text)` | serial, text | 输入文字（中文/引号/换行可用） |
+| `de_set_clipboard(serial, text)` | serial, text | 写剪贴板 |
+| `de_open_app(serial, package)` | serial, package | 冷启动 App（adb monkey） |
+| `de_stop_app(serial, package)` | serial, package | 强制结束 App |
+| `de_wake(serial)` / `de_sleep(serial)` | serial | 亮屏解锁 / 息屏（走平台 `/api/device/screen_all`） |
+
+> 平台级工具（**任务创建/修改/启停、分组、设备池管理、备份等**）**目前没有 MCP 工具**，只有上面这些设备能力；需要它们时请通过 REST（§9）或在平台 Web 后台操作。
+
+---
+
+## 4. 通用调用约定
+
+### 4.1 设备标识 `serial`
+- 网络设备：`IP:5555`（如 `100.100.10.13:5555`、`192.168.20.206:5555`）。
+- USB 设备：纯串号（无冒号，如 `ZY322XXXX`）。
+- 用 `de_list_devices()` 获取当前可用清单，**不要凭空猜 serial**。
+
+### 4.2 坐标空间（重要）
+- `de_screenshot` 返回的是**缩放图（≤540px 宽）+ `native_size`（原生分辨率）**。
+- `de_tap` / `de_swipe` 的坐标用**截图坐标系（display 空间）**，服务端按最近一次截图比例换算原生。
+- **必须先 `de_screenshot` 再坐标操作**，否则报「请先执行 de_screenshot」。
+- 屏幕可能旋转/滚动，坐标随时会变——**优先文字/元素定位，坐标仅兜底**。
+
+### 4.3 设备占用锁（busy）
+- 写工具执行前会检查该设备是否有平台任务在跑：`running`/`connecting` → 返回 **`device_busy`**（“AI 不与任务抢设备”）。此时**换设备或等待**，不要硬重试。
+- 只读工具（截图/UI树/OCR/列表）不受此限制。
+
+### 4.4 错误码
+| 错误 | 含义 | 应对 |
+|---|---|---|
+| `write_disabled` | 服务端未开写门控 | 告知部署方开 `MCP_ALLOW_WRITE=1` |
+| `device_busy` | 设备正被任务占用 | 换设备 / 等任务结束 |
+| `device_offline` | 设备不可达 | 换设备；报运维 |
+| `device_not_allowed` | 不在白名单 | 换设备；让部署方加白名单 |
+| `text_not_found` | 屏上没有该文字 | 截图确认；改用 `de_ui_tree`/`de_ocr` |
+| `platform_unavailable` | 平台不可达 | 稍后重试；报运维 |
+| `invalid_param` | 参数不合法 | 修参数 |
+
+---
+
+## 5. 推荐操作模式（务必遵守，能显著提高成功率）
+
+1. **文字语义点击优先**：`de_tap_text("关注")` ＞ `de_ui_tree` 找元素 + `de_tap_element` ＞ `de_tap` 坐标兜底。
+2. **每关键步后截图验证**：操作是否生效看截图/UI 树，别连续盲点。
+3. **不重复同坐标**：点击后画面无变化，禁止反复点同一坐标（多数 App 会误触）。
+4. **先确认前台与页面**：`de_foreground_app` / 截图确认在正确页面再操作。
+5. **一次一个明确目标**：拆成小步，每步可验证。
+
+### 常见配方
+- **看视频养号（示意）**：`de_list_devices` → 选设备 → `de_open_app(pkg)` → 循环〔`de_screenshot` 确认在视频页 → 等待 → `de_swipe` 上滑〕→ 结束 `de_stop_app`。
+- **打开指定 App**：`de_list_apps(keyword)` 拿包名 → `de_open_app(package)` → 截图确认首页。
+- **输入文字**：`de_tap_text` 或 `de_tap_element` 点输入框 → `de_type_text` → 截图确认。
+- **巡检截图**：`de_screenshot` + `de_foreground_app` + `de_ocr`，只读汇报。
+
+---
+
+## 6. 红线与安全（**不可违反**）
+
+1. **绝不 `adb kill-server`、绝不 `adb disconnect`**（会断开所有设备共享的 adb 通道，影响全部运行中任务）。你也不需要这些操作。
+2. **不抢任务设备**：遇到 `device_busy` 就避开。
+3. **写操作前先确认**：不确定后果的操作（发送评论/私信、删除、支付类）**不要执行**，先截图回报请人工确认。
+4. **不做破坏性动作**：卸载应用、清除数据、改系统设置等一律不做。
+5. **留痕**：你的每次调用都进审计，请让动作与目标一致。
+6. **隐私**：不要把设备上读到的个人信息/凭据复述或外传。
+
+---
+
+## 7. 当前边界（别越界期待）
+
+- MCP **没有任务创建/修改/启停**（只有只读 `de_list_tasks`）。
+- MCP **无独立鉴权**（靠网络隔离），不要假设有 token。
+- `MCP_ALLOWED_SERIALS` 为空时**不会**自动限制为平台设备池（设计语义未实现）。
+- 平台 REST 的 CSRF 校验在当前版本可能未强制（按端点契约使用即可）。
+
+---
+
+## 8. 相关文档
+
+- 工具手册（逐工具参数/返回/示例）：`doc/MCP.md`
+- MCP 设计/分层与现状对照：`doc/MCP_DESIGN.md`
+- 平台接口目录：`doc/API.md`
+- AI 生成任务（规划，未实现）：`doc/AI_TASK_GEN.md`

mcp_agent/__init__.py

@@ -0,0 +1 @@
+"""Agent 编排层：第三方 LLM（OpenAI 兼容）经 MCP 工具控制手机。"""

mcp_agent/agent.py

@@ -0,0 +1,291 @@
+"""Agent 编排层：OpenAI 兼容模型（DeepSeek 等）经 MCP 工具控制手机。
+
+支持两种运行模式：
+  - run_stream()：流式（SSE 逐 token + 工具调用实时回调）——Web AI 控制台用
+  - run()：非流式收集结果——CLI 用（内部调 run_stream）
+
+流式细节（OpenAI 兼容）：
+  - content/reasoning_content 增量逐 chunk 回调（kind 区分）
+  - tool_calls 分片累积（arguments 按 index 拼接），流结束后统一执行
+  - 截图（de_screenshot）图像转 image_url 追加下一轮，同时 on_tool 回调带缩略
+"""
+import base64
+import json
+import logging
+
+import httpx
+from fastmcp import Client
+
+from mcp_agent.config import AgentSettings
+
+_log = logging.getLogger("agent")
+
+S = AgentSettings()
+
+SYSTEM_PROMPT = """你是手机自动化控制助手。你通过工具实时操作 Android 手机。
+
+工作规范：
+1. 先 de_list_devices 确定目标设备（在线才可操作）
+2. 观察屏幕：先 de_screenshot 获取截图（图像会随后给你），基于截图理解当前界面
+3. 点击定位分优先级（不要自己推算像素坐标，那是精度最差的方式）：
+   a) 目标有可见文字（按钮/菜单/列表标题/标签/输入框提示）→ de_tap_text 直接给文字，
+      一次完成「找到并点击」，原生控件与 WebView/图片渲染文字都支持
+   b) 文字有歧义或 de_tap_text 未命中 → de_ui_tree(limit=80) 看可点元素后
+      用 de_tap_element（text/text_contains 匹配）
+   c) 只有纯图形目标（视频画面/无文字图标且树里没有）才用 de_tap 给坐标——
+      坐标只需大致对准目标中心，服务端会自动吸附到该处可点击元素中心，无需精算
+4. de_tap 点击后若返回 snapped=true 表示已吸附命中元素（可核对 label）；
+   截图判断界面变化=点击成功，无变化=未命中
+5. 输入文字：先 de_tap_text 或 de_tap 点中输入框，再 de_type_text 输入
+6. 每次关键操作后再次 de_screenshot 验证结果，直到完成用户目标
+7. 若点击后截图无任何变化：不要重复点同一坐标，换 de_tap_text/de_tap_element
+   重新定位，或先 de_ui_tree 确认元素文案再试
+8. 完成或失败时用中文总结：做了什么、当前状态、需要用户注意的事项
+9. 设备不可用/操作失败时如实报告错误，不要臆测成功
+10. 效率：界面未变化时不要重复截图/点击同一位置；每步都要推进目标；
+    若连续 6 步无进展（截图内容未变/操作无效），停止并总结原因，不要空转
+
+可用工具清单将由系统提供。"""
+
+
+class Agent:
+    def __init__(self, settings: AgentSettings = None):
+        self.s = settings or S
+        self.tools_schema = []      # OpenAI function schema
+        self.messages = []
+        # 回调（Web 展示用，均可选）：
+        #   on_delta(text, kind)  kind: content | reasoning   —— 流式文本增量
+        #   on_tool(step)         step: {tool, args, result, image} —— 工具调用完成
+        self.on_delta = None
+        self.on_tool = None
+        self._mcp = None
+
+    # ---------- MCP 工具桥 ----------
+    async def _load_tools(self):
+        """从 MCP Server 拉工具，转 OpenAI function schema。"""
+        # 短连接超时：MCP 不可用时快速失败（默认会无限重试卡死线程）
+        self._mcp = Client(self.s.mcp_url, timeout=10.0, init_timeout=10.0)
+        await self._mcp.__aenter__()
+        tools = await self._mcp.list_tools()
+        self.tools_schema = []
+        for t in tools:
+            # MCP SDK v2 改名 input_schema，兼容新旧字段
+            schema = getattr(t, "input_schema", None) or getattr(t, "inputSchema", {})
+            name = getattr(t, "name", "")
+            desc = getattr(t, "description", "") or ""
+            self.tools_schema.append({
+                "type": "function",
+                "function": {"name": name, "description": desc,
+                             "parameters": schema}})
+        _log.info("MCP 工具已加载: %s", [s["function"]["name"] for s in self.tools_schema])
+
+    async def close(self):
+        if self._mcp:
+            try:
+                await self._mcp.__aexit__(None, None, None)
+            except Exception:
+                pass
+
+    # ---------- 模型调用（流式） ----------
+    async def _chat_stream(self):
+        """流式 chat/completions：逐 chunk 产出 JSON（async generator）。"""
+        body = {
+            "model": self.s.model,
+            "messages": self.messages,
+            "tools": self.tools_schema if self.tools_schema else None,
+            "max_tokens": 4096,
+            "stream": True,
+        }
+        headers = {"Authorization": f"Bearer {self.s.api_key}",
+                   "Content-Type": "application/json"}
+        url = f"{self.s.api_base.rstrip('/')}/chat/completions"
+        async with httpx.AsyncClient(timeout=self.s.request_timeout) as client:
+            async with client.stream("POST", url, json=body, headers=headers) as r:
+                if r.status_code != 200:
+                    text = (await r.aread()).decode(errors="replace")
+                    raise RuntimeError(f"模型 API HTTP {r.status_code}: {text[:300]}")
+                async for line in r.aiter_lines():
+                    if not line.startswith("data:"):
+                        continue
+                    data = line[5:].strip()
+                    if data == "[DONE]":
+                        break
+                    try:
+                        yield json.loads(data)
+                    except json.JSONDecodeError:
+                        continue
+
+    # ---------- 工具执行 ----------
+    async def _execute_tool(self, name, arguments):
+        """执行 MCP 工具，返回 (文本结果, image_data_or_None)。"""
+        args = json.loads(arguments) if isinstance(arguments, str) else (arguments or {})
+        _log.info("执行工具 %s %s", name, args)
+        try:
+            result = await self._mcp.call_tool(name, args)
+            data = getattr(result, "data", result)
+        except Exception as e:
+            return {"ok": False, "error": f"工具执行失败: {e}"}, None
+        # de_screenshot：图像分离（作为 image_url 追加给模型看 + on_tool 缩略展示）
+        image_b64 = None
+        text_result = data
+        if name == "de_screenshot" and isinstance(data, dict) and data.get("ok"):
+            img = (data.get("data") or {}).get("image") or {}
+            if img.get("data"):
+                text_result = {k: v for k, v in (data.get("data") or {}).items()
+                               if k != "image"}
+                image_b64 = img["data"]
+        if self.on_tool:
+            try:
+                self.on_tool({"tool": name, "args": args,
+                              "result": text_result, "image": image_b64})
+            except Exception:
+                pass
+        return text_result, image_b64
+
+    def _repair_tool_messages(self):
+        """修复 tool_calls 配对不完整：从尾部移除「assistant 带 tool_calls 但其后
+        tool 回应不足」的消息段（流中断可能丢失分片，400 重试前自愈）。"""
+        for i in range(len(self.messages) - 1, -1, -1):
+            m = self.messages[i]
+            if m.get("role") == "assistant" and m.get("tool_calls"):
+                # 统计其后 tool 消息数是否匹配
+                need = len(m["tool_calls"])
+                have = sum(1 for x in self.messages[i + 1:]
+                           if x.get("role") == "tool")
+                if have < need:
+                    _log.warning("修复不完整 tool_calls 段（need=%d have=%d），回退 %d 条消息",
+                                 need, have, len(self.messages) - i)
+                    self.messages = self.messages[:i]
+                return
+
+    # ---------- 主循环（流式） ----------
+    async def run_stream(self, prompt: str, serial: str = "",
+                         history=None, on_delta=None, on_tool=None,
+                         should_stop=None, extra_context=None):
+        """流式执行一轮指令，返回最终完整文本。
+
+        history：上一轮的 [{"role": "user"|"assistant", "content": 文本}] 列表，
+        用于多轮对话保持上下文（截图/工具消息不入历史，控制 token）。
+        on_delta(text, kind)：content/reasoning 文本增量（实时推给前端）
+        on_tool(step)：工具调用完成（实时显示 MCP 步骤）
+        should_stop：可调用 fn() -> bool，每轮模型调用前检查（用户中断用）
+        extra_context：附加文本（经验记忆注入，放在 system prompt 末尾）
+        """
+        self.on_delta = on_delta
+        self.on_tool = on_tool
+        target = serial or self.s.default_serial
+        sys_txt = SYSTEM_PROMPT
+        if target:
+            sys_txt += f"\n\n本次默认目标设备 serial：{target}（未指定设备时用它）。"
+        if extra_context:
+            sys_txt += f"\n\n## 过往成功经验参考（同类任务，可参考其中的操作套路，但要根据当前界面灵活调整）\n{extra_context}"
+        self.messages = [{"role": "system", "content": sys_txt}]
+        for h in (history or []):
+            if h.get("role") in ("user", "assistant") and h.get("content"):
+                self.messages.append({"role": h["role"], "content": h["content"]})
+        self.messages.append({"role": "user", "content": prompt})
+
+        for _step in range(self.s.max_steps):
+            if should_stop and should_stop():
+                _log.info("Agent 被用户中断")
+                return "（已按用户要求停止操作）"
+            content_parts = []
+            tool_acc = {}           # index -> {id, name, args}
+            has_tool = False
+            retried = False
+            while True:
+                try:
+                    async for chunk in self._chat_stream():
+                        choice = (chunk.get("choices") or [{}])[0]
+                        delta = choice.get("delta") or {}
+                        text = delta.get("content")
+                        if text:
+                            content_parts.append(text)
+                            if on_delta:
+                                on_delta(text, "content")
+                        rtext = delta.get("reasoning_content")
+                        if rtext:
+                            if on_delta:
+                                on_delta(rtext, "reasoning")
+                        for tc in delta.get("tool_calls") or []:
+                            has_tool = True
+                            idx = tc.get("index", 0)
+                            acc = tool_acc.setdefault(idx, {"id": "", "name": "", "args": ""})
+                            if tc.get("id"):
+                                acc["id"] = tc["id"]
+                            fn = tc.get("function") or {}
+                            if fn.get("name"):
+                                acc["name"] += fn["name"]
+                            if fn.get("arguments"):
+                                acc["args"] += fn["arguments"]
+                    break
+                except RuntimeError as e:
+                    # 流中断导致 tool_calls 分片丢失：修复后重试一次
+                    if ("tool_calls" in str(e) or "must be followed" in str(e)) and not retried:
+                        _log.warning("tool_calls 消息不完整，自愈重试")
+                        self._repair_tool_messages()
+                        retried = True
+                        continue
+                    raise
+
+            full_content = "".join(content_parts)
+
+            if has_tool:
+                # 组装 assistant 消息（含 tool_calls）并执行工具
+                tcs = []
+                for idx in sorted(tool_acc):
+                    acc = tool_acc[idx]
+                    tcs.append({"id": acc["id"] or f"call_{idx}",
+                                "type": "function",
+                                "function": {"name": acc["name"],
+                                             "arguments": acc["args"]}})
+                self.messages.append({"role": "assistant",
+                                      "content": full_content,
+                                      "tool_calls": tcs})
+                for tc in tcs:
+                    fn = tc["function"]
+                    text_result, image_b64 = await self._execute_tool(
+                        fn["name"], fn["arguments"])
+                    self.messages.append({
+                        "role": "tool", "tool_call_id": tc["id"],
+                        "content": json.dumps(text_result, ensure_ascii=False)[:4000]})
+                    if image_b64:
+                        self.messages.append({
+                            "role": "user",
+                            "content": [{"type": "text",
+                                         "text": "这是最新屏幕截图，请基于它继续判断"},
+                                        {"type": "image_url",
+                                         "image_url": {"url":
+                                                       f"data:image/jpeg;base64,{image_b64}"}}]})
+                continue
+
+            # 无工具调用：本轮即最终回答
+            return full_content
+
+        # 步骤超限：不带工具让模型做最终总结（避免机械提示，给用户有意义的结论）
+        try:
+            _log.warning("达到最大步骤数，请求模型收尾总结")
+            saved_tools = self.tools_schema
+            self.tools_schema = []
+            self.messages.append({"role": "user",
+                                  "content": "已达最大操作步骤数，请立即用中文总结："
+                                             "已完成的部分、当前设备状态、未能完成的原因与下一步建议。"
+                                             "不要调用任何工具。"})
+            parts = []
+            async for chunk in self._chat_stream():
+                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.tools_schema = saved_tools
+            summary = "".join(parts)
+            return summary or "（已达步骤上限，模型未能生成总结）"
+        except Exception as e:
+            return f"（已达最大步骤数，且收尾总结失败: {e}）"
+
+    # ---------- 非流式（CLI） ----------
+    async def run(self, prompt: str, serial: str = "") -> str:
+        """非流式执行，返回最终文本（CLI 用，内部走流式收集）。"""
+        return await self.run_stream(prompt, serial)

mcp_agent/cli.py

@@ -0,0 +1,60 @@
+"""Agent CLI：命令行给 AI 下指令控制手机。
+
+用法：
+    export AGENT_API_KEY=sk-xxx            # DeepSeek API Key
+    export AGENT_DEFAULT_SERIAL=192.168.20.66:5555   # 可选：默认设备
+    python -m mcp_agent.cli "打开抖音，搜索奚学东，截个图"
+    python -m mcp_agent.cli -s 192.168.20.66:5555 "打开微信"
+    python -m mcp_agent.cli                 # 交互模式（exit 退出）
+"""
+import argparse
+import asyncio
+import logging
+import os
+
+from mcp_agent.agent import Agent
+
+logging.basicConfig(level=logging.INFO,
+                    format="%(asctime)s %(levelname)s [%(name)s] %(message)s")
+_log = logging.getLogger("cli")
+
+
+async def _run_once(prompt, serial):
+    if not os.environ.get("AGENT_API_KEY") and not os.environ.get("DEEPSEEK_API_KEY"):
+        print("❌ 未配置 API Key：export AGENT_API_KEY=sk-xxx")
+        return
+    agent = Agent()
+    try:
+        await agent._load_tools()
+        print(f"🤖 指令: {prompt}\n")
+        answer = await agent.run(prompt, serial)
+        print(f"\n✅ 结果:\n{answer}")
+    finally:
+        await agent.close()
+
+
+def main():
+    ap = argparse.ArgumentParser(description="MCP 手机控制 Agent CLI")
+    ap.add_argument("prompt", nargs="?", default="", help="指令（不填则交互模式）")
+    ap.add_argument("-s", "--serial", default="", help="目标设备 serial")
+    args = ap.parse_args()
+
+    if args.prompt:
+        asyncio.run(_run_once(args.prompt, args.serial))
+        return
+
+    print("交互模式：输入指令（如「打开抖音搜索奚学东」），exit 退出")
+    while True:
+        try:
+            prompt = input("\n指令> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            break
+        if not prompt:
+            continue
+        if prompt.lower() in ("exit", "quit", "退出"):
+            break
+        asyncio.run(_run_once(prompt, args.serial))
+
+
+if __name__ == "__main__":
+    main()

mcp_agent/config.py

@@ -0,0 +1,30 @@
+"""Agent 层配置（第三方 LLM API，OpenAI 兼容格式）。
+
+DeepSeek 官方 API：https://api.deepseek.com（OpenAI 兼容）。
+生产用 .env 注入 DEEPSEEK_API_KEY，不要提交 git。
+"""
+import os
+
+
+def _env(key, default):
+    return os.environ.get(key, default)
+
+
+class AgentSettings:
+    # 模型 API（OpenAI 兼容）
+    api_base = _env("AGENT_API_BASE", "https://api.deepseek.com")
+    api_key = _env("AGENT_API_KEY", _env("DEEPSEEK_API_KEY", ""))
+    model = _env("AGENT_MODEL", "deepseek-v4-flash-vision-exp")
+
+    # MCP Server（工具源）
+    mcp_url = _env("AGENT_MCP_URL", "http://127.0.0.1:8033/mcp")
+
+    # 默认目标设备（命令行不指定 serial 时用它；空则让模型先 de_list_devices）
+    default_serial = _env("AGENT_DEFAULT_SERIAL", "")
+
+    # Agent 循环上限与请求超时
+    max_steps = int(_env("AGENT_MAX_STEPS", "40"))
+    request_timeout = float(_env("AGENT_TIMEOUT", "120"))
+
+    # system prompt 语言
+    language = _env("AGENT_LANG", "zh")

mcp_server/__init__.py

@@ -0,0 +1 @@
+"""MCP 手机控制 Server 包。"""

mcp_server/audit.py

@@ -0,0 +1,27 @@
+"""审计日志：每次 MCP 调用记录一行（含只读）。"""
+import json
+import os
+from datetime import datetime
+
+_file = None
+
+
+def init(path):
+    global _file
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    _file = open(path, "a", encoding="utf-8")
+    audit("system", "startup", "", "")
+
+
+def audit(tool, serial, args_summary, result):
+    global _file
+    if _file is None:
+        return
+    rec = {"ts": datetime.now().isoformat(timespec="seconds"),
+           "tool": tool, "serial": serial,
+           "args": str(args_summary)[:200], "result": str(result)[:200]}
+    try:
+        _file.write(json.dumps(rec, ensure_ascii=False) + "\n")
+        _file.flush()
+    except Exception:
+        pass

mcp_server/config.py

@@ -0,0 +1,32 @@
+"""MCP Server 配置（环境变量，生产用 .env 注入）。"""
+import os
+
+
+def _env(key, default):
+    return os.environ.get(key, default)
+
+
+class Settings:
+    # 平台（auto_control）地址与账号
+    platform_url = _env("MCP_PLATFORM_URL", "http://127.0.0.1:18050")
+    platform_user = _env("MCP_PLATFORM_USER", "admin")
+    platform_pass = _env("MCP_PLATFORM_PASS", "")
+
+    # 安全
+    allow_write = _env("MCP_ALLOW_WRITE", "0") == "1"   # 写操作门控（默认只读）
+    allowed_serials = [s.strip() for s in
+                       _env("MCP_ALLOWED_SERIALS", "").split(",") if s.strip()]  # 空=不限
+
+    # 传输
+    http_host = _env("MCP_HTTP_HOST", "0.0.0.0")
+    http_port = int(_env("MCP_HTTP_PORT", "8033"))
+
+    # 截图
+    screenshot_width = int(_env("MCP_SCREENSHOT_WIDTH", "540"))
+    jpeg_quality = int(_env("MCP_JPEG_QUALITY", "70"))
+
+    # 审计
+    audit_file = _env("MCP_AUDIT_FILE", "/var/log/mcp/audit.log")
+
+    # 平台请求超时（秒）
+    platform_timeout = float(_env("MCP_PLATFORM_TIMEOUT", "30"))

mcp_server/direct_ops.py

@@ -0,0 +1,110 @@
+"""MCP 直连操作封装：adb/u2/OCR/剪贴板——轻量通道优先。
+
+为什么直连而不是全部走平台 HTTP：
+  - adb monkey 打开 App / am force-stop：一条 adb 命令，不建 u2 连接（省时省 token）
+  - 输入文字：u2 EditText.set_text 直接设文本（比剪贴板+粘贴少依赖）
+  - OCR：平台 RapidOCR（本地模型，截图即识别）
+平台 REST 无法表达的操作（无独立端点）在此封装；安全（白名单/写门控）
+仍在 MCP 工具层统一把关。绝不 kill-server / 绝不 disconnect（项目红线）。
+"""
+import re
+import subprocess
+
+from config import ADB_PATH
+
+_log = None  # mcp 层 logging 由调用方配置
+
+
+def _adb(serial, *args, timeout=25):
+    """对指定设备执行 adb shell 命令，返回输出文本（超时返回空）。"""
+    try:
+        r = subprocess.run([ADB_PATH, "-s", serial, "shell", *args],
+                           capture_output=True, timeout=timeout)
+        return (r.stdout or b"").decode("utf-8", errors="replace")
+    except subprocess.TimeoutExpired:
+        return ""
+    except Exception:
+        return ""
+
+
+def open_app(serial, package):
+    """adb monkey 打开 App（无需知道 activity，最轻量）。"""
+    out = _adb(serial, "monkey", "-p", package,
+               "-c", "android.intent.category.LAUNCHER", "1")
+    return out or ""
+
+
+def stop_app(serial, package):
+    """强制停止 App（am force-stop）。"""
+    return _adb(serial, "am", "force-stop", package)
+
+
+def foreground_app(serial):
+    """当前前台 App 包名（dumpsys window；mCurrentFocus 为空时 fallback mFocusedApp）。"""
+    out = _adb(serial, "dumpsys", "window", timeout=15) or ""
+    m = re.search(r"mCurrentFocus=.*?([\w.]+)/", out)
+    if m:
+        return m.group(1)
+    # 部分 MIUI 焦点在 IME/过渡时 mCurrentFocus=null，用 mFocusedApp 兜底
+    m2 = re.search(r"mFocusedApp=.*?([\w.]+)/", out)
+    return m2.group(1) if m2 else ""
+
+
+def list_apps(serial, keyword=""):
+    """第三方已装应用包名列表（pm list packages -3，可关键词过滤）。"""
+    out = _adb(serial, "pm", "list", "packages", "-3")
+    pkgs = []
+    for line in (out or "").splitlines():
+        p = line.replace("package:", "").strip()
+        if p and (not keyword or keyword.lower() in p.lower()):
+            pkgs.append(p)
+    return pkgs
+
+
+def type_text(serial, text):
+    """向当前界面输入框输入文字（u2 定位 EditText set_text，支持中文）。
+
+    返回 (ok, msg)。
+    """
+    import uiautomator2 as u2
+    d = u2.connect(serial)
+    # 优先聚焦输入框；找不到则第一个 EditText（与任务 input_text 兜底一致）
+    try:
+        el = d(focused=True)
+        if el.exists:
+            el.set_text(text)
+            return True, "已输入到聚焦输入框"
+    except Exception:
+        pass
+    try:
+        edit = d(className="android.widget.EditText")
+        if edit.exists:
+            edit.set_text(text)
+            return True, "已输入到输入框"
+    except Exception as e:
+        return False, f"输入失败: {type(e).__name__}: {str(e)[:100]}"
+    return False, "未找到输入框（请先点击输入框或提供界面信息）"
+
+
+def set_clipboard(serial, text):
+    """剪贴板注入（ClipInject 通道，读回验证）。"""
+    from core.clipboard_helper import inject_clipboard
+    return inject_clipboard(serial, text)
+
+
+def ocr(serial):
+    """截屏 + RapidOCR 识别，返回 [{text, score, box}]。"""
+    import uiautomator2 as u2
+    from core.ocr import recognize
+    d = u2.connect(serial)
+    img = d.screenshot()
+    if img is None:
+        return []
+    return recognize(img)
+
+
+def read_clipboard(serial):
+    """读设备剪贴板（u2）。"""
+    import uiautomator2 as u2
+    d = u2.connect(serial)
+    return d.clipboard or ""

mcp_server/mcp_server.py

@@ -0,0 +1,520 @@
+"""MCP 手机控制 Server（M0：设备列表/截图/点击/滑动）。
+
+运行：MCP_ALLOW_WRITE=1 python -m mcp_server.mcp_server
+客户端：Streamable HTTP @ http://<host>:8033/mcp
+"""
+import base64
+import io
+import logging
+
+from fastmcp import FastMCP
+from PIL import Image
+
+from mcp_server import audit, config
+from mcp_server.platform_client import PlatformClient, PlatformError
+
+logging.basicConfig(level=logging.INFO,
+                    format="%(asctime)s %(levelname)s [%(name)s] %(message)s")
+_log = logging.getLogger("mcp")
+
+S = config.Settings()
+
+# 坐标空间缓存：serial -> (display_w, display_h, native_w, native_h)
+# de_screenshot 返回的图与 de_tap/de_swipe 的坐标同一空间（display），
+# server 按比例换算为设备原生坐标（模型只感知截图坐标系，不感知原生分辨率）。
+_coord = {}
+audit.init(S.audit_file)
+
+mcp = FastMCP("mobile-control")
+_platform = None
+
+
+def platform():
+    """惰性初始化平台客户端（启动即登录，失败明确报错）。"""
+    global _platform
+    if _platform is None:
+        _platform = PlatformClient(S.platform_url, S.platform_user,
+                                   S.platform_pass, S.platform_timeout)
+    return _platform
+
+
+def _check_serial(serial):
+    """白名单校验：未配置时限制为平台设备池（enabled）设备。"""
+    if not serial:
+        raise PlatformError("invalid_param", "缺少 serial")
+    if S.allowed_serials and serial not in S.allowed_serials:
+        raise PlatformError("device_not_allowed", f"设备 {serial} 不在白名单")
+    return serial
+
+
+def _check_write():
+    if not S.allow_write:
+        raise PlatformError("write_disabled", "写操作未启用（MCP_ALLOW_WRITE=1 开启）")
+
+
+# 设备任务占用锁：serial -> (ts, worker_status, task_job)。AI 写操作前检查，
+# 任务 running/connecting 的设备拒绝操作（AI 不与任务抢设备）。5s 缓存。
+_busy_cache = {}
+
+
+def _ensure_device_free(serial):
+    """写操作前检查设备是否有任务在跑（worker running/connecting → 拒绝）。"""
+    import time
+    now = time.time()
+    c = _busy_cache.get(serial)
+    if not c or now - c[0] > 5:
+        try:
+            devs = platform().list_devices()
+            info = next((d for d in devs if d.get("serial") == serial), {})
+            c = (now, info.get("worker_status") or "idle",
+                 info.get("task_job") or "")
+            _busy_cache[serial] = c
+        except Exception:
+            return  # 状态查询失败不阻塞（操作失败会另行报错）
+    if c[1] in ("running", "connecting"):
+        raise PlatformError(
+            "device_busy",
+            f"设备正在执行任务「{c[2] or '未知'}」——AI 不与任务抢设备，"
+            f"任务结束后才能操作（可在平台任务页先停止任务）")
+
+
+def _to_native(serial, x, y):
+    """截图坐标 → 设备原生坐标（按最近一次截图的比例换算）。"""
+    c = _coord.get(serial)
+    if not c:
+        raise PlatformError("invalid_param",
+                            "请先对该设备执行 de_screenshot（需要建立坐标空间）")
+    dw, dh, nw, nh = c
+    return (round(x * nw / dw), round(y * nh / dh))
+
+
+def _err(e: PlatformError):
+    return {"ok": False, "error": {"code": e.code, "message": e.message}}
+
+
+def _ok(data):
+    return {"ok": True, "data": data}
+
+
+@mcp.tool()
+def de_list_devices() -> dict:
+    """列出可控制设备：serial/在线状态/型号/任务状态/前台 App。
+
+    返回 [{serial, model, online, task_job, worker_status, foreground_app}]。
+    """
+    try:
+        devs = platform().list_devices()
+    except PlatformError as e:
+        return _err(e)
+    out = []
+    for d in devs:
+        out.append({
+            "serial": d.get("serial"),
+            "model": d.get("model") or d.get("device_name") or "",
+            "online": bool(d.get("present")),
+            "task_job": d.get("task_job") or "",
+            "worker_status": d.get("worker_status") or "idle",
+            "foreground_app": d.get("foreground_app") or "",
+        })
+    audit.audit("de_list_devices", "", "", f"{len(out)} 台")
+    return _ok(out)
+
+
+@mcp.tool()
+def de_screenshot(serial: str) -> dict:
+    """截取设备屏幕并返回图像（image/jpeg，宽 ≤540px）。
+
+    同时返回 {width, height, screen_state}。多模态客户端可直接看图。
+    """
+    try:
+        serial = _check_serial(serial)
+        jpeg, screen_state = platform().screenshot(serial)
+        img = Image.open(io.BytesIO(jpeg))
+        w, h = img.size
+        if w > S.screenshot_width:
+            ratio = S.screenshot_width / w
+            img = img.resize((S.screenshot_width, int(h * ratio)))
+        buf = io.BytesIO()
+        img.convert("RGB").save(buf, "JPEG", quality=S.jpeg_quality)
+        data = base64.b64encode(buf.getvalue()).decode()
+        # 记录坐标空间（display=返回图尺寸，native=设备原生），供 tap/swipe 换算
+        nw, nh = platform().screen_size(serial)
+        _coord[serial] = (img.size[0], img.size[1], nw, nh)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"截图处理失败: {e}"))
+    audit.audit("de_screenshot", serial, f"{w}x{h}", "ok")
+    dw, dh, nw, nh = _coord[serial]
+    return _ok({"image": {"type": "image", "data": data,
+                          "mimeType": "image/jpeg"},
+                "width": dw, "height": dh,
+                "native_size": {"width": nw, "height": nh},
+                "screen_state": screen_state})
+
+
+@mcp.tool()
+def de_tap(serial: str, x: int, y: int) -> dict:
+    """点击设备屏幕指定坐标（坐标空间 = de_screenshot 的图像坐标）。
+
+    自动吸附：若该点落在某个可点击元素内，实际点击会改为该元素的中心——
+    坐标只需大致对准目标即可（模型视觉定位常有偏差，吸附保证点准）；
+    点在空白处则按原坐标点击。返回中的 snapped/label 可核对吸附结果。
+    """
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if x < 0 or y < 0:
+            raise PlatformError("invalid_param", "坐标不能为负")
+        nx, ny = _to_native(serial, x, y)
+        res = platform().tap(serial, nx, ny, snap=True)
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_tap", serial,
+                f"({x},{y})->native({nx},{ny})"
+                + (f" 吸附[{res.get('label')}]" if res.get("snapped") else ""),
+                "ok")
+    return _ok({"action": "tap", "serial": serial, "x": x, "y": y,
+                "snapped": bool(res.get("snapped")),
+                "label": res.get("label") or ""})
+
+
+@mcp.tool()
+def de_swipe(serial: str, x1: int, y1: int, x2: int, y2: int,
+             duration: float = 0.2) -> dict:
+    """在设备屏幕上滑动（坐标空间同 de_tap：截图坐标，server 换算原生）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        nx1, ny1 = _to_native(serial, x1, y1)
+        nx2, ny2 = _to_native(serial, x2, y2)
+        platform().swipe(serial, nx1, ny1, nx2, ny2, duration)
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_swipe", serial, f"({x1},{y1})->({x2},{y2})", "ok")
+    return _ok({"action": "swipe", "serial": serial})
+
+
+_KEYS = ("back", "home", "recent", "menu", "power", "volume_up",
+         "volume_down", "enter", "delete", "search", "camera")
+
+
+@mcp.tool()
+def de_ui_tree(serial: str, limit: int = 150) -> dict:
+    """获取当前界面元素树（文本 JSON）：每元素含 text/resource_id/description/class/bounds。
+
+    可点击元素排在前面（可点性优先）。多数场景不需要读整棵树——直接给
+    de_tap_text 一个屏幕上可见的文字即可自动定位点击；本工具用于确认界面
+    上有什么、元素文案是否与预想一致。limit 控制返回条数（默认 150，防 token 膨胀）。
+    """
+    try:
+        serial = _check_serial(serial)
+        if limit < 1 or limit > 300:
+            raise PlatformError("invalid_param", "limit 需在 1-300 之间")
+        els = platform().ui_elements(serial)
+    except PlatformError as e:
+        return _err(e)
+    # 精简输出：去掉 suggested/深度噪音，保留可定位属性；可点击优先、有文案优先
+    slim = []
+    for e in els:
+        slim.append({
+            "text": e.get("text", "")[:50],
+            "id": e.get("resource_id", "")[:80],
+            "desc": e.get("description", "")[:50],
+            "class": e.get("class", "").split(".")[-1],
+            "clickable": e.get("clickable", "") == "true",
+            "bounds": e.get("bounds", ""),
+        })
+    slim.sort(key=lambda x: (not x["clickable"], not (x["text"] or x["desc"])))
+    audit.audit("de_ui_tree", serial, "", f"{len(slim)} 元素")
+    return _ok({"count": len(slim), "elements": slim[:limit]})
+
+
+@mcp.tool()
+def de_tap_element(serial: str, by: str, value: str, index: int = 1) -> dict:
+    """按元素点击（不需要坐标）：by=text|id|desc|text_contains|desc_contains。
+
+    text/id/desc 为精确匹配；text_contains/desc_contains 为子串模糊匹配
+    （只记得部分文字时用，如 by=text_contains value=搜索）。
+    元素驱动操作比坐标可靠（界面变化自适应）；元素不存在时返回错误，
+    可改用 de_ui_tree 查元素 / de_tap_text 按屏幕文字点 / de_tap 坐标兜底。
+    index 用于多命中取第几个（默认 1）。
+    """
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if by not in ("text", "id", "desc", "text_contains", "desc_contains"):
+            raise PlatformError("invalid_param",
+                                "by 可选 text/id/desc/text_contains/desc_contains")
+        if not value or index < 1:
+            raise PlatformError("invalid_param", "value 不能为空且 index>=1")
+        import uiautomator2 as u2
+        d = u2.connect(serial)
+        kw = {"text": value} if by == "text" else (
+            {"resourceId": value} if by == "id" else (
+                {"description": value} if by == "desc" else (
+                    {"textContains": value} if by == "text_contains"
+                    else {"descriptionContains": value})))
+        if index > 1:
+            kw["instance"] = index - 1
+        el = d(**kw)
+        if not el.exists:
+            raise PlatformError("device_offline",
+                                f"未找到元素（{by}={value}，index={index}）——"
+                                f"建议 de_ui_tree 查看实际元素或 de_tap 用坐标")
+        el.click()
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable",
+                                  f"元素点击失败: {type(e).__name__}: {str(e)[:100]}"))
+    audit.audit("de_tap_element", serial, f"{by}={value}#{index}", "ok")
+    return _ok({"action": "tap_element", "serial": serial,
+                "by": by, "value": value, "index": index})
+
+
+@mcp.tool()
+def de_read_clipboard(serial: str) -> dict:
+    """读取设备当前剪贴板内容（ClipInject/atx-agent 通道读回，M1 起支持）。"""
+    try:
+        serial = _check_serial(serial)
+        import uiautomator2 as u2
+        d = u2.connect(serial)
+        text = d.clipboard
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable",
+                                  f"剪贴板读取失败: {type(e).__name__}: {str(e)[:100]}"))
+    audit.audit("de_read_clipboard", serial, "", f"{len(text or '')} 字符")
+    return _ok({"clipboard": text or ""})
+
+
+@mcp.tool()
+def de_wake(serial: str) -> dict:
+    """点亮设备屏幕并解锁（熄屏时先调用它再截图）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        platform().wake(serial)
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_wake", serial, "", "ok")
+    return _ok({"action": "wake", "serial": serial})
+
+
+@mcp.tool()
+def de_press_key(serial: str, key: str) -> dict:
+    """按设备按键：back/home/recent/menu/power/enter/delete 等。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if key not in _KEYS:
+            raise PlatformError("invalid_param", f"不支持的按键: {key}（可选 {_KEYS}）")
+        platform().press_key(serial, key)
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_press_key", serial, key, "ok")
+    return _ok({"action": "press_key", "serial": serial, "key": key})
+
+
+# ================== L2 扩展工具（轻量通道：adb/u2 直连，省 token） ==================
+@mcp.tool()
+def de_open_app(serial: str, package: str) -> dict:
+    """打开 App（adb monkey 直启，最快路径）。package 为应用包名，如 com.ss.android.ugc.aweme。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if not package:
+            raise PlatformError("invalid_param", "缺少包名")
+        from mcp_server import direct_ops
+        direct_ops.open_app(serial, package)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"打开失败: {str(e)[:100]}"))
+    audit.audit("de_open_app", serial, package, "ok")
+    return _ok({"action": "open_app", "package": package})
+
+
+@mcp.tool()
+def de_stop_app(serial: str, package: str) -> dict:
+    """强制停止 App（am force-stop）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if not package:
+            raise PlatformError("invalid_param", "缺少包名")
+        from mcp_server import direct_ops
+        direct_ops.stop_app(serial, package)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"停止失败: {str(e)[:100]}"))
+    audit.audit("de_stop_app", serial, package, "ok")
+    return _ok({"action": "stop_app", "package": package})
+
+
+@mcp.tool()
+def de_foreground_app(serial: str) -> dict:
+    """查询设备当前前台运行的 App 包名（轻量 dumpsys，不打扰设备）。"""
+    try:
+        serial = _check_serial(serial)
+        from mcp_server import direct_ops
+        pkg = direct_ops.foreground_app(serial)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"查询失败: {str(e)[:100]}"))
+    audit.audit("de_foreground_app", serial, "", pkg or "未知")
+    return _ok({"foreground_app": pkg or ""})
+
+
+@mcp.tool()
+def de_type_text(serial: str, text: str) -> dict:
+    """向设备当前输入框输入文字（支持中文，直接 set_text 不依赖剪贴板）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if not text:
+            raise PlatformError("invalid_param", "内容为空")
+        from mcp_server import direct_ops
+        ok, msg = direct_ops.type_text(serial, text)
+        if not ok:
+            raise PlatformError("device_offline", msg)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"输入失败: {str(e)[:100]}"))
+    audit.audit("de_type_text", serial, f"{text[:30]}...", "ok")
+    return _ok({"action": "type_text"})
+
+
+@mcp.tool()
+def de_set_clipboard(serial: str, text: str) -> dict:
+    """写入设备剪贴板（ClipInject 通道，读回验证）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if not text:
+            raise PlatformError("invalid_param", "内容为空")
+        from mcp_server import direct_ops
+        ok, msg = direct_ops.set_clipboard(serial, text)
+        if not ok:
+            raise PlatformError("device_offline", msg)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"注入失败: {str(e)[:100]}"))
+    audit.audit("de_set_clipboard", serial, f"{text[:30]}...", "ok")
+    return _ok({"action": "set_clipboard"})
+
+
+@mcp.tool()
+def de_sleep(serial: str) -> dict:
+    """熄灭设备屏幕（运行中任务会中断，慎用）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        platform().sleep(serial)
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_sleep", serial, "", "ok")
+    return _ok({"action": "sleep"})
+
+
+@mcp.tool()
+def de_ocr(serial: str) -> dict:
+    """OCR 识别当前屏幕文字（图片/画布/WebView 里 UI 树没有的文字也能识别）。
+
+    返回 [{text, score}]——搜屏幕关键词后可配合 de_tap_element/de_tap 操作。
+    """
+    try:
+        serial = _check_serial(serial)
+        from mcp_server import direct_ops
+        results = direct_ops.ocr(serial)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"OCR 失败: {str(e)[:100]}"))
+    slim = [{"text": r["text"], "score": round(r["score"], 2)} for r in results]
+    audit.audit("de_ocr", serial, "", f"{len(slim)} 条")
+    return _ok({"count": len(slim), "texts": slim[:100]})
+
+
+@mcp.tool()
+def de_tap_text(serial: str, text: str) -> dict:
+    """点击屏幕上显示该文字的位置（语义点击：一次调用完成「找到并点击」，无需坐标）。
+
+    想点带文字的按钮/列表项/标签/链接时用它：text 只需是屏幕上可见文字的
+    一部分（子串匹配，如「搜索」「立即购买」）。原生控件直接命中；
+    WebView/图片/画布里渲染的文字自动走 OCR 兜底。多命中点第一处（想点
+    更靠下的请把文字换独特些）。屏幕确实没有该文字时返回错误提示，
+    请截图确认后换关键词。比 de_tap 坐标点击可靠，涉及文字目标时优先使用。
+    """
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if not text or len(text) > 100:
+            raise PlatformError("invalid_param", "text 不能为空且 ≤100 字符")
+        res = platform().tap_text(serial, text)
+    except PlatformError as e:
+        return _err(e)
+    if not res.get("found"):
+        err = PlatformError("text_not_found",
+                            f"屏幕上未找到文字「{text}」——先 de_screenshot 看当前界面，"
+                            f"换用屏幕上实际存在的文字；若文字在需滑动后才可见请先滑动")
+        audit.audit("de_tap_text", serial, f"「{text[:30]}」", "未找到")
+        return _err(err)
+    audit.audit("de_tap_text", serial,
+                f"「{text[:30]}」via {res.get('method')} @({res.get('x')},{res.get('y')})", "ok")
+    return _ok({"action": "tap_text", "serial": serial, "text": text,
+                "method": res.get("method"), "matched": res.get("matched") or text,
+                "x": res.get("x"), "y": res.get("y")})
+
+
+@mcp.tool()
+def de_list_apps(serial: str, keyword: str = "") -> dict:
+    """列出设备第三方已装应用包名（可关键词过滤，如 keyword='douyin' 找抖音）。"""
+    try:
+        serial = _check_serial(serial)
+        from mcp_server import direct_ops
+        pkgs = direct_ops.list_apps(serial, keyword)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"查询失败: {str(e)[:100]}"))
+    audit.audit("de_list_apps", serial, keyword or "", f"{len(pkgs)} 个")
+    return _ok({"count": len(pkgs), "packages": pkgs[:200]})
+
+
+@mcp.tool()
+def de_list_tasks() -> dict:
+    """列出平台任务计划（名称/启用状态/调度），供了解可自动化的任务。"""
+    try:
+        tasks = platform().list_tasks()
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_list_tasks", "", "", f"{len(tasks)} 个")
+    return _ok({"tasks": tasks})
+
+
+def main():
+    _log.info("MCP mobile-control 启动: allow_write=%s port=%s",
+              S.allow_write, S.http_port)
+    mcp.run(transport="http", host=S.http_host, port=S.http_port)
+
+
+if __name__ == "__main__":
+    main()

mcp_server/platform_client.py

@@ -0,0 +1,186 @@
+"""平台（auto_control）HTTP 客户端：登录会话 + CSRF + API 封装。
+
+会话失效自动重登；CSRF token 每次登录后获取，POST 必带。
+只读接口（GET）与写接口（POST）分离封装，写操作由 MCP 门控层决定是否调用。
+"""
+import httpx
+import logging
+
+_log = logging.getLogger("mcp.platform")
+
+_CSRF_HEADER = "X-CSRF-Token"
+
+
+class PlatformError(Exception):
+    def __init__(self, code, message):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+
+class PlatformClient:
+    def __init__(self, url, user, password, timeout=30.0):
+        self.url = url.rstrip("/")
+        self.user = user
+        self.password = password
+        self._client = httpx.Client(base_url=self.url, timeout=timeout,
+                                    follow_redirects=True)
+        self._csrf = ""
+        self._login()
+
+    # ---------- 会话 ----------
+    def _login(self):
+        """登录平台，拿会话 cookie + CSRF token。"""
+        r = self._client.post("/login", data={
+            "username": self.user, "password": self.password})
+        if r.status_code != 302 and r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"平台登录失败 HTTP {r.status_code}: {r.text[:120]}")
+        csrf = self._client.get("/api/csrf")
+        if csrf.status_code == 200:
+            self._csrf = (csrf.json() or {}).get("token", "")
+        _log.info("平台登录成功: %s", self.user)
+
+    def _ensure_session(self):
+        """会话过期（401/403/302 到登录页）时重登。"""
+        r = self._client.get("/api/status")
+        if r.status_code in (401, 403) or r.url.path.endswith("/login"):
+            _log.warning("会话失效，重新登录")
+            self._login()
+            return True
+        return False
+
+    # ---------- 基础请求 ----------
+    def _get(self, path, **params):
+        self._ensure_session()
+        return self._client.get(path, params=params)
+
+    def _post(self, path, json=None):
+        self._ensure_session()
+        headers = {_CSRF_HEADER: self._csrf} if self._csrf else {}
+        return self._client.post(path, json=json or {}, headers=headers)
+
+    # ---------- 平台 API 封装（M0） ----------
+    def list_devices(self):
+        """设备列表与状态（GET /api/status）。"""
+        r = self._get("/api/status")
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"/api/status HTTP {r.status_code}")
+        j = r.json() or {}
+        return j.get("devices", [])
+
+    def screenshot(self, serial):
+        """截图（GET /api/screen/thumb），返回 (jpeg_bytes, screen_state)。"""
+        r = self._get("/api/screen/thumb", serial=serial)
+        if r.status_code == 503:
+            raise PlatformError("device_offline", r.text[:120])
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"截图 HTTP {r.status_code}")
+        return r.content, r.headers.get("X-Screen-State", "unknown")
+
+    def screen_size(self, serial):
+        """屏幕原生分辨率（GET /api/screen/size），返回 (w, h)。"""
+        r = self._get("/api/screen/size", serial=serial)
+        if r.status_code == 503:
+            raise PlatformError("device_offline", r.text[:120])
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"分辨率 HTTP {r.status_code}")
+        j = r.json() or {}
+        if not j.get("ok"):
+            raise PlatformError("device_offline", str(j.get("error", "取分辨率失败"))[:120])
+        return int(j["width"]), int(j["height"])
+
+    def tap(self, serial, x, y, snap=False):
+        """点击（POST /api/screen/tap）。
+
+        snap=True：点落在可点击元素内则吸附到元素中心（AI 粗略坐标也能点准）。
+        返回平台 JSON（含 snapped/x/y/label）。
+        """
+        r = self._post("/api/screen/tap", json={"serial": serial,
+                                                "x": int(x), "y": int(y),
+                                                "snap": 1 if snap else 0})
+        return self._check_op(r, "tap")
+
+    def tap_text(self, serial, text):
+        """按屏幕文字点击（平台解析：UI 树子串匹配 → OCR 兜底）。
+
+        返回 {ok, found, method, matched, x, y}——found=false 是业务结果
+        （屏幕无该文字），非设备错误；设备离线/不可达仍抛 PlatformError。
+        """
+        r = self._post("/api/screen/tap_text",
+                       json={"serial": serial, "text": str(text)})
+        if r.status_code == 503:
+            raise PlatformError("device_offline", r.text[:120])
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"tap_text HTTP {r.status_code}: {r.text[:120]}")
+        return r.json() or {}
+
+    def swipe(self, serial, x1, y1, x2, y2, duration=0.2):
+        """滑动（POST /api/screen/swipe）。"""
+        r = self._post("/api/screen/swipe", json={
+            "serial": serial, "x1": int(x1), "y1": int(y1),
+            "x2": int(x2), "y2": int(y2),
+            "duration": float(duration)})
+        return self._check_op(r, "swipe")
+
+    def ui_elements(self, serial):
+        """UI 元素树（GET /api/uiauto/elements，uiautodev 服务）。"""
+        r = self._get("/api/uiauto/elements", serial=serial)
+        if r.status_code == 503:
+            raise PlatformError("device_offline", r.text[:120])
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"元素树 HTTP {r.status_code}")
+        j = r.json() or {}
+        if not j.get("ok"):
+            raise PlatformError("device_offline", str(j.get("error", "取元素失败"))[:120])
+        return j.get("elements", [])
+
+    def wake(self, serial):
+        """亮屏并解锁（POST /api/device/screen_all mode=on）。"""
+        r = self._post("/api/device/screen_all",
+                       json={"mode": "on", "serials": [serial]})
+        return self._check_op(r, "wake")
+
+    def sleep(self, serial):
+        """熄屏（POST /api/device/screen_all mode=off）。"""
+        r = self._post("/api/device/screen_all",
+                       json={"mode": "off", "serials": [serial]})
+        return self._check_op(r, "sleep")
+
+    def list_tasks(self):
+        """任务计划列表（GET /api/jobs）。"""
+        r = self._get("/api/jobs")
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"/api/jobs HTTP {r.status_code}")
+        j = r.json() or {}
+        tasks = []
+        for t in j.get("jobs") or []:
+            tasks.append({"id": t.get("id"), "name": t.get("name"),
+                          "task_type": t.get("task_type"),
+                          "enabled": t.get("enabled"),
+                          "schedule": (t.get("schedule") or {}).get("mode", "")})
+        return tasks
+
+    def press_key(self, serial, key):
+        """按键（POST /api/screen/key）。"""
+        r = self._post("/api/screen/key",
+                       json={"serial": serial, "key": key})
+        return self._check_op(r, "key")
+
+    @staticmethod
+    def _check_op(r, name):
+        if r.status_code == 503:
+            raise PlatformError("device_offline", r.text[:120])
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"{name} HTTP {r.status_code}: {r.text[:120]}")
+        j = r.json() or {}
+        if not j.get("ok"):
+            raise PlatformError("device_offline", str(j.get("error", "操作失败"))[:120])
+        return j

mcp_server/requirements.txt

@@ -0,0 +1,3 @@
+fastmcp>=2.0
+httpx>=0.27
+Pillow>=10.0

requirements.txt

@@ -36,3 +36,6 @@ opencv-python-headless>=4.8,<5  # 锁定 4.x：5.x wheel 打包异常（无 cv2
 
 # APK 元信息解析（应用管理功能：自动读取包名/版本/应用名）
 pyaxmlparser>=0.3.27
+
+# MCP Server + AI 控制台 Agent（fastmcp：Streamable HTTP 服务端/客户端）
+fastmcp>=2.0

scripts/start.sh

@@ -1,6 +1,7 @@
 #!/bin/bash
-# 容器启动脚本：安装依赖 + 环境修复 + 启动 web_server。
-# compose 的 python-app 服务 command 指向本脚本。
+# 容器启动脚本：依赖安装（仅首次/缺失时）+ 环境修复 + 启动 web_server。
+# compose 的 python-app 服务 command 指向本脚本（不要在 compose 里再跑 pip，
+# 否则每次容器重启都重装依赖——实测每轮重新下载 opencv 5.0(73MB) 并破坏 cv2）。
 #
 # 为什么需要环境修复（必须在 pip install 之后）：
 #   rapidocr_onnxruntime 的依赖声明是 opencv-python（GUI 版），pip 解析依赖时
@@ -8,18 +9,39 @@
 #   直接崩溃 → RapidOCR 不可用 → 条件判断的 OCR 步骤抛异常 → 任务失败退出。
 #   因此在安装完 requirements 后，最后强制卸载 GUI 版并装 headless（幂等）。
 #   本地 Mac 有 GUI 环境不受影响。
-if [ -f requirements.txt ]; then
-    pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt
-fi
 
-# 环境修复：最后强制 headless（覆盖 rapidocr 拉回的 GUI 版）
-pip uninstall -y -q opencv-python 2>/dev/null || true
-pip install -q -i https://pypi.tuna.tsinghua.edu.cn/simple "opencv-python-headless>=4.8,<5"  # 5.x wheel 无 cv2 模块，锁定 4.x
-
-# pip 24.0 解压 abi3 wheel 偶发丢根文件（4.14.0.94 实测 site-packages/cv2 只剩子目录，
-# cv2.abi3.so / __init__.py 缺失 → import cv2 成空壳，OCR 全挂）→ 空壳检测 + wheel 手动解压兜底（幂等）
+# ---- 依赖就绪守卫：flask/u2/uiautodev/rapidocr/cv2 全部可用则跳过安装 ----
+# （容器重启秒级启动；只有首次部署或依赖缺失时才走完整安装）
 python3 - <<'PY'
-import glob, os, shutil, site, subprocess, sys, zipfile
+import importlib.util, sys
+mods = ("flask", "flask_login", "flask_sqlalchemy", "apscheduler",
+        "uiautomator2", "uiautodev", "rapidocr_onnxruntime", "PIL",
+        "fastmcp")
+if all(importlib.util.find_spec(m) for m in mods):
+    try:
+        import cv2
+        ok = hasattr(cv2, "__version__") and cv2.__file__ is not None
+    except Exception:
+        ok = False
+    sys.exit(0 if ok else 1)
+sys.exit(1)
+PY
+if [ $? -ne 0 ]; then
+    echo "[start] 依赖缺失或 cv2 异常，执行安装与环境修复（首次启动较慢）..."
+    if [ -f requirements.txt ]; then
+        pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt
+    fi
+
+    # 环境修复：最后强制 headless（覆盖 rapidocr 拉回的 GUI 版）
+    pip uninstall -y -q opencv-python 2>/dev/null || true
+    pip install -q -i https://pypi.tuna.tsinghua.edu.cn/simple "opencv-python-headless>=4.8,<5"  # 5.x wheel 无 cv2 模块，锁定 4.x
+
+    # pip 24.0 解压 abi3 wheel 偶发丢根文件（site-packages/cv2 只剩子目录，
+    # cv2.abi3.so / __init__.py 缺失 → import cv2 成空壳，OCR 全挂）。
+    # 手动解压兜底在部分环境修不好（解压后仍无 cv2.__version__），
+    # 实测 pip --force-reinstall 完整安装有效（220 验证 cv2 4.14.0 恢复）。
+    python3 - <<'PY'
+import subprocess, sys
 
 def cv2_ok():
     try:
@@ -30,20 +52,30 @@ def cv2_ok():
 
 if cv2_ok():
     sys.exit(0)
-print("cv2 空壳，wheel 手动解压修复...")
-r = subprocess.run(["pip", "download", "--no-deps", "-q",
+print("cv2 异常，pip 强制重装 opencv-python-headless...")
+r = subprocess.run(["pip", "install", "--force-reinstall", "-q",
                     "-i", "https://pypi.tuna.tsinghua.edu.cn/simple",
-                    "-d", "/tmp/ocv", "opencv-python-headless>=4.8,<5"], capture_output=True)
-if r.returncode != 0:
-    sys.exit(1)
-w = sorted(glob.glob("/tmp/ocv/opencv_python_headless*.whl"))[-1]
-with zipfile.ZipFile(w) as z:
-    z.extractall("/tmp/ocv")
-dst = os.path.join(site.getsitepackages()[0], "cv2")
-shutil.rmtree(dst, ignore_errors=True)
-shutil.copytree("/tmp/ocv/cv2", dst)
-import cv2
-print(f"cv2 {cv2.__version__} 手动解压修复完成")
+                    "opencv-python-headless>=4.8,<5"])
+if r.returncode == 0:
+    import cv2
+    print(f"cv2 {cv2.__version__} 重装修复完成")
+sys.exit(r.returncode)
 PY
+else
+    echo "[start] 依赖已就绪（cv2 $(python3 -c 'import cv2; print(cv2.__version__)' 2>/dev/null)），跳过安装"
+fi
+
+# 启动 MCP server（后台，AI 控制台/外部客户端经 127.0.0.1:8033 调用）。
+# web_server.py 内 agent 依赖它，容器重启必须自动拉起（MCP_ENABLED=0 可关）。
+# 平台账号：MCP_PLATFORM_USER 默认 admin；密码优先取环境变量（compose/.env），
+# 兜底 admin123 与部署时的手动启动参数一致。
+if [ -f mcp_server/mcp_server.py ] && [ "${MCP_ENABLED:-1}" = "1" ]; then
+    echo "[start] 启动 MCP server..."
+    MCP_ALLOW_WRITE=1 \
+    MCP_PLATFORM_USER="${MCP_PLATFORM_USER:-admin}" \
+    MCP_PLATFORM_PASS="${MCP_PLATFORM_PASS:-admin123}" \
+    MCP_AUDIT_FILE="${MCP_AUDIT_FILE:-/tmp/mcp_audit.log}" \
+    python3 -m mcp_server.mcp_server > /tmp/mcp_server.log 2>&1 &
+fi
 
 exec python -u web_server.py

static/admin/agent.js

@@ -0,0 +1,597 @@
+// AI 控制台（顶级 Tab）：DeepSeek 风格聊天 + 流式输出 + 实时 MCP 步骤
+let _agentBusy = false;
+let _agentStream = null;      // EventSource
+let _agentCfgLoaded = false;
+
+// 后端异常文案兜底：MCP 客户端在工具服务不可达时只抛
+// "Server returned an error response" 这类含糊字样，这里映射成明确指引。
+function _friendlyAgentError(msg){
+  const raw = String(msg || '');
+  const s = raw.replace(/^[A-Za-z_]*Error:\s*/, '');   // 去掉 "RuntimeError: " 之类前缀
+  if(/不可达|连接中断/.test(s)) return s;              // 后端已给出明确文案，直接用
+  if(/mcp_server|server returned an error response|connecterror|connection refused|all connection attempts failed|server disconnected|network is unreachable|connect timeout/i.test(s))
+    return 'MCP server(8033) 不可达：AI 无法连接设备工具服务，请确认 MCP server 已启动（本机可运行 python -m mcp_server.mcp_server）';
+  return raw;
+}
+
+// ================== 初始化 ==================
+let _agentDefaultSerial = '';
+function initAgentChat(){
+  if(_agentCfgLoaded)return;
+  _agentCfgLoaded = true;
+  loadAgentConfig();
+  const chat = document.getElementById('agent-chat');
+  if(chat && !chat.children.length){
+    chat.innerHTML = '<div class="agent-empty">👋 给 AI 下达指令，它将通过截图观察手机并执行操作。<br>'
+      + '例如：「打开抖音搜索奚学东，告诉我第一个视频的标题」<br>'
+      + '先选「🎯 目标设备」（AI 只操作你选定的设备），点击右上角 ⚙ 配置模型与 API Key。</div>';
+  }
+  bindChatScroll();
+  loadLiveDevices();
+  loadAgentTargetDevices();
+  startRunPoll();
+  renderConvList();           // 会话列表（决定当前会话）
+  loadCurrentConvMessages();  // 渲染当前会话历史
+  restoreRunningFlow();       // 若任务运行中：重订阅事件流
+  // 输入框快捷键
+  const inp = document.getElementById('agent-input');
+  inp.addEventListener('keydown', ev=>{
+    if(ev.key==='Enter' && !ev.shiftKey){
+      ev.preventDefault();
+      if(!_agentBusy) sendAgentMsg();
+    }
+  });
+}
+
+// ================== 页面刷新/重进恢复（运行中任务续流） ==================
+// 历史轮次由 loadCurrentConvMessages 从会话渲染；这里只处理「任务仍在后台跑」：
+// 重新订阅事件流（服务端队列保留积压，重连后补发 delta/step/done）。
+function restoreRunningFlow(){
+  apiGet('/api/agent/run').then(r=>{
+    if(!r||!r.ok) return;
+    if(r.state === 'running' && r.run_id){
+      setRunning(true);
+      listenStream(r.run_id);
+    }else if(r.state === 'error' && r.error && _currentConvId){
+      // 错误提示仅当本会话相关时展示
+      const chat = document.getElementById('agent-chat');
+      if(chat && !chat.children.length){
+        const div = newAssistantMsg();
+        div.querySelector('.agent-text').textContent = '⚠ ' + _friendlyAgentError(r.error);
+      }
+    }
+  });
+}
+
+// ================== 配置 ==================
+function loadAgentConfig(){
+  apiGet('/api/agent/config').then(r=>{
+    if(!r||!r.ok)return;
+    const tag = document.getElementById('agent-model-tag');
+    if(tag && r.model) tag.textContent = r.model;
+    _agentDefaultSerial = r.default_serial || '';
+  });
+}
+
+// ================== 目标设备选择（AI 只操作选定设备） ==================
+function loadAgentTargetDevices(){
+  apiGet('/api/agent/devices').then(r=>{
+    if(!r||!r.ok)return;
+    const sel = document.getElementById('agent-target-select');
+    if(!sel)return;
+    const cur = sel.value;
+    const devs = (r.devices||[]).filter(x=>x.online);
+    sel.innerHTML = '<option value="">请选择设备（AI 只操作选定设备）…</option>'
+      + devs.map(d=>{
+          const label = d.serial + (d.model ? ' · ' + d.model : '')
+            + (d.busy ? ' ⛔ 任务中：' + d.task_job : '');
+          return '<option value="'+esc(d.serial)+'"' + (d.busy ? ' disabled' : '')
+            + '>' + esc(label) + '</option>';
+        }).join('');
+    // 保留当前选择；否则预选配置的默认设备
+    if(cur && [...sel.options].some(o=>o.value===cur)) sel.value = cur;
+    else if(_agentDefaultSerial && [...sel.options].some(o=>o.value===_agentDefaultSerial))
+      sel.value = _agentDefaultSerial;
+    const hint = document.getElementById('agent-target-hint');
+    if(hint && sel.value) hint.textContent = '将操作：' + sel.value;
+  });
+}
+
+// ================== 跨窗口运行状态（多人/多窗口可见并可停止） ==================
+let _runPoll = null;
+function startRunPoll(){
+  if(_runPoll) return;
+  _runPoll = setInterval(pollRunState, 8000);
+}
+function pollRunState(){
+  if(_agentStream) return;   // 本窗口正在跑（事件流驱动），不轮询
+  apiGet('/api/agent/run').then(r=>{
+    if(!r||!r.ok)return;
+    const running = r.state === 'running';
+    document.getElementById('agent-running-tag').style.display = running ? 'inline' : 'none';
+    document.getElementById('btn-agent-stop').style.display = running ? 'inline-block' : 'none';
+    const hint = document.getElementById('agent-target-hint');
+    if(hint){
+      hint.textContent = running
+        ? ('⏳ 运行中' + (r.started ? ' ' + r.started + ' 起' : '')
+           + (r.serial ? ' · ' + r.serial : '')
+           + '：' + (r.prompt||'').slice(0,70))
+        : (document.getElementById('agent-target-select').value
+           ? '将操作：' + document.getElementById('agent-target-select').value : '');
+    }
+    document.getElementById('btn-agent-send').disabled = running;
+    if(!running && _agentBusy){ setRunning(false); }   // 流异常丢失时复位
+  });
+}
+function openAgentConfig(){
+  apiGet('/api/agent/config').then(r=>{
+    if(!r||!r.ok)return;
+    document.getElementById('acfg-base').value = r.api_base || 'https://api.deepseek.com';
+    document.getElementById('acfg-model').value = r.model || '';
+    document.getElementById('acfg-serial').value = r.default_serial || '';
+    document.getElementById('acfg-steps').value = r.max_steps || 40;
+    document.getElementById('acfg-key-hint').textContent =
+      r.api_key_masked ? ('已配置 ' + r.api_key_masked) : '未配置';
+    document.getElementById('acfg-key').value = '';
+    document.getElementById('agent-cfg-overlay').style.display = 'flex';
+  });
+}
+function closeAgentConfig(){
+  document.getElementById('agent-cfg-overlay').style.display = 'none';
+}
+function saveAgentConfig(){
+  const body = {
+    api_base: document.getElementById('acfg-base').value.trim(),
+    model: document.getElementById('acfg-model').value.trim(),
+    default_serial: document.getElementById('acfg-serial').value.trim(),
+    max_steps: document.getElementById('acfg-steps').value.trim(),
+  };
+  const key = document.getElementById('acfg-key').value.trim();
+  if(key) body.api_key = key;
+  apiPost('/api/agent/config', body).then(r=>{
+    if(r&&r.ok){
+      showToast('配置已保存','success');
+      closeAgentConfig();
+      loadAgentConfig();
+      loadAgentTargetDevices();
+    }else showToast('保存失败: ' + ((r&&r.error)||''),'error');
+  });
+}
+
+// ================== 聊天渲染 ==================
+function addUserMsg(text){
+  const chat = document.getElementById('agent-chat');
+  clearEmpty();
+  const div = document.createElement('div');
+  div.className = 'agent-msg user';
+  div.textContent = text;
+  chat.appendChild(div);
+  scrollChat();
+}
+function newAssistantMsg(){
+  const chat = document.getElementById('agent-chat');
+  clearEmpty();
+  const div = document.createElement('div');
+  div.className = 'agent-msg assistant';
+  div.innerHTML = '<div class="agent-toolcards"></div><div class="agent-text"></div>';
+  chat.appendChild(div);
+  scrollChat();
+  return div;
+}
+function clearEmpty(){
+  const empty = document.querySelector('#agent-chat .agent-empty');
+  if(empty) empty.remove();
+}
+let _chatPinned = true;   // 用户是否在底部（贴底才自动跟随滚动）
+function scrollChat(force){
+  const chat = document.getElementById('agent-chat');
+  if(force || _chatPinned){
+    chat.scrollTop = chat.scrollHeight;
+  }
+}
+function bindChatScroll(){
+  const chat = document.getElementById('agent-chat');
+  chat.addEventListener('scroll', ()=>{
+    _chatPinned = chat.scrollHeight - chat.scrollTop - chat.clientHeight < 60;
+  });
+}
+function clearAgentChat(){
+  document.getElementById('agent-chat').innerHTML = '';
+}
+
+// ================== 历史会话（DeepSeek 式：左侧列表，多会话持久化） ==================
+let _currentConvId = localStorage.getItem('agent_conv_id') || '';
+function saveConvId(id){
+  _currentConvId = id || '';
+  if(id) localStorage.setItem('agent_conv_id', id);
+  else localStorage.removeItem('agent_conv_id');
+}
+function createAgentSession(){
+  if(_agentBusy){showToast('运行中不能新建会话','error');return;}
+  apiPost('/api/agent/conversations',{}).then(r=>{
+    if(r&&r.ok){
+      saveConvId(r.id);
+      clearAgentChat();
+      showToast('已新建会话','success');
+      renderConvList();
+    }else showToast('新建失败: '+((r&&r.error)||''),'error');
+  });
+}
+function selectAgentSession(id){
+  if(_agentBusy){showToast('运行中不能切换会话','error');return;}
+  if(id === _currentConvId) return;
+  saveConvId(id);
+  clearAgentChat();
+  loadCurrentConvMessages();
+  renderConvList();
+}
+function deleteAgentSession(id){
+  if(!confirm('删除该会话？历史消息将不可恢复。')) return;
+  apiDelete('/api/agent/conversations/'+id).then(r=>{
+    if(r&&r.ok){
+      if(_currentConvId === id) saveConvId('');
+      showToast('会话已删除','success');
+      renderConvList();
+      loadCurrentConvMessages();
+    }else showToast('删除失败: '+((r&&r.error)||''),'error');
+  });
+}
+function renderConvList(){
+  apiGet('/api/agent/conversations').then(r=>{
+    if(!r||!r.ok)return;
+    const list = document.getElementById('agent-sess-list');
+    if(!list)return;
+    const convs = r.conversations || [];
+    let cur = _currentConvId;
+    if(!convs.some(c=>c.id===cur)) cur = convs.length ? convs[0].id : '';
+    if(cur !== _currentConvId){ saveConvId(cur); clearAgentChat(); loadCurrentConvMessages(); }
+    if(!convs.length){
+      list.innerHTML = '<div class="agent-empty" style="padding:20px 10px;font-size:12px">'
+        + '暂无历史会话<br><br>点「＋ 新建会话」开始</div>';
+      return;
+    }
+    list.innerHTML = convs.map(c=>{
+      const t = c.title || '新会话';
+      return '<div class="agent-sess-item'+(c.id===cur?' active':'')
+        +'" onclick="selectAgentSession(\''+c.id+'\')">'
+        +'<button class="agent-sess-del" title="删除会话" '
+        +'onclick="event.stopPropagation();deleteAgentSession(\''+c.id+'\')">✕</button>'
+        +'<div class="t">'+esc(t)+'</div>'
+        +'<div class="m">'+esc(c.updated_at||'')+(c.count ? ' · '+c.count+' 轮' : '')+'</div></div>';
+    }).join('');
+  });
+}
+function loadCurrentConvMessages(){
+  const chat = document.getElementById('agent-chat');
+  if(!chat) return;
+  if(!_currentConvId){
+    chat.innerHTML = '<div class="agent-empty">👋 点左侧「＋ 新建会话」开始，'
+      + '给 AI 下达指令（先选 🎯 目标设备）。</div>';
+    return;
+  }
+  apiGet('/api/agent/conversations/'+_currentConvId).then(r=>{
+    if(!r||!r.ok)return;
+    chat.innerHTML = '';
+    (r.messages||[]).forEach(m=>{
+      const txt = (m.content||'').trim();
+      if(!txt) return;
+      if(m.role==='user'){ addUserMsg(txt); }
+      else{
+        const div = newAssistantMsg();
+        div.querySelector('.agent-text').textContent = txt;
+      }
+    });
+    if(!chat.children.length){
+      chat.innerHTML = '<div class="agent-empty">新会话。给 AI 下达指令'
+        + '（先选 🎯 目标设备）…</div>';
+    }
+  });
+}
+
+// ================== 发送与流式接收 ==================
+function setRunning(on){
+  _agentBusy = on;
+  document.getElementById('agent-running-tag').style.display = on ? 'inline' : 'none';
+  document.getElementById('btn-agent-stop').style.display = on ? 'inline-block' : 'none';
+  document.getElementById('btn-agent-send').disabled = on;
+}
+function stopAgent(){
+  if(!confirm('确定停止当前 AI 运行任务？\n（其他人发起的任务也会被停止）')) return;
+  apiPost('/api/agent/stop',{}).then(r=>{
+    if(r&&r.ok) showToast('已请求停止，正在中断…','success');
+    else showToast((r&&r.error)||'停止失败','error');
+  });
+}
+function sendAgentMsg(){
+  if(_agentBusy){showToast('上一轮还在运行','error');return;}
+  const sel = document.getElementById('agent-target-select');
+  const serial = sel ? sel.value : '';
+  if(!serial){
+    showToast('请先选择目标设备（AI 只操作你选定的设备；任务中的设备不可选）','error');
+    if(sel) sel.focus();
+    return;
+  }
+  const inp = document.getElementById('agent-input');
+  const text = inp.value.trim();
+  if(!text){showToast('请输入指令','error');return;}
+  inp.value = '';
+  addUserMsg(text);
+
+  // 会话：无当前会话时自动新建（DeepSeek 式：消息总归属于一个会话）
+  const doRun = (convId)=>{
+    apiPost('/api/agent/run', {prompt: text, serial: serial,
+                               conversation_id: convId}).then(r=>{
+      if(!r||!r.ok){
+        const msg = r ? (r.error||'启动失败') : '请求失败';
+        const div = newAssistantMsg();
+        div.querySelector('.agent-text').textContent = '⚠ ' + _friendlyAgentError(msg);
+        showToast(_friendlyAgentError(msg),'error');
+        return;
+      }
+      setRunning(true);
+      listenStream(r.run_id);
+    });
+  };
+  if(_currentConvId){
+    doRun(_currentConvId);
+  }else{
+    apiPost('/api/agent/conversations',{}).then(r=>{
+      if(r&&r.ok){
+        saveConvId(r.id);
+        renderConvList();
+        doRun(r.id);
+      }else{
+        const div = newAssistantMsg();
+        div.querySelector('.agent-text').textContent = '⚠ 新建会话失败';
+        showToast('新建会话失败','error');
+      }
+    });
+  }
+}
+
+function listenStream(runId){
+  if(_agentStream) _agentStream.close();
+  const es = new EventSource('/api/agent/stream?run_id=' + runId);
+  _agentStream = es;
+  let msgEl = null;
+
+  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;
+    }else{
+      textEl.textContent += d.text;
+    }
+    scrollChat();
+  });
+
+  es.addEventListener('step', ev=>{
+    const d = JSON.parse(ev.data);
+    followSerialFromArgs(d.args);
+    if(!msgEl) msgEl = newAssistantMsg();
+    const cards = msgEl.querySelector('.agent-toolcards');
+    const card = document.createElement('div');
+    card.className = 'agent-toolcard';
+    const argsTxt = typeof d.args === 'string' ? d.args
+                    : JSON.stringify(d.args || {});
+    card.innerHTML = '<span class="dot"></span>'
+      + '<code style="color:var(--teal)">' + esc(d.tool||'') + '</code>'
+      + '<span class="text-muted">' + esc(argsTxt) + '</span>';
+    if(d.image){
+      const img = document.createElement('img');
+      img.src = 'data:image/jpeg;base64,' + d.image;
+      card.appendChild(img);
+    }
+    cards.appendChild(card);
+    scrollChat();
+  });
+
+  es.addEventListener('done', ev=>{
+    const d = JSON.parse(ev.data);
+    if(d.answer){
+      if(!msgEl) msgEl = newAssistantMsg();
+      msgEl.querySelector('.agent-text').textContent = d.answer;
+    }
+    endRun();
+    renderConvList();   // 落库已完成：刷新标题/时间/轮数
+  });
+
+  es.addEventListener('error', ev=>{
+    let msg = '连接中断';
+    try{
+      if(ev.data) msg = JSON.parse(ev.data).message || msg;
+    }catch(e){}
+    if(!msgEl) msgEl = newAssistantMsg();
+    msgEl.querySelector('.agent-text').textContent = '⚠ ' + _friendlyAgentError(msg);
+    endRun();
+  });
+
+  es.onerror = ()=>{
+    // 重要：不能在这里 endRun()——断网/后台标签页节流/服务端瞬时抖动都会触发
+    // onerror，但后端任务仍在跑。EventSource 会自动重连，服务端事件队列保留
+    // 积压（delta/step/done），重连成功后全部补发，界面无缝续上。
+    // 只有连接彻底关闭（非自动重连态）且任务还在跑时才提示。
+    if(_agentBusy && es.readyState === EventSource.CLOSED){
+      const hint = document.getElementById('agent-target-hint');
+      if(hint) hint.textContent = '⚠ 实时连接已中断，任务仍在后台运行——可刷新页面恢复查看';
+      // 连接彻底失败时周期探测，恢复后重订阅
+      setTimeout(()=>{
+        if(!_agentStream && _agentBusy){
+          apiGet('/api/agent/run').then(r=>{
+            if(r&&r.ok&&r.state==='running'&&r.run_id) listenStream(r.run_id);
+          });
+        }
+      }, 5000);
+    }
+  };
+}
+
+// ============ 实时画面（右侧，MJPEG 流） ============
+let _liveSerial = '';
+function showLive(serial){
+  if(!serial || serial === _liveSerial) return;
+  _liveSerial = serial;
+  const img = document.getElementById('agent-live-img');
+  img.src = '/api/screen/stream?serial=' + encodeURIComponent(serial) + '&q=80&fps=8&t=' + Date.now();
+  img.style.display = 'block';
+  document.getElementById('agent-live-empty').style.display = 'none';
+  document.getElementById('agent-live-serial').textContent = serial;
+  const sel = document.getElementById('agent-live-select');
+  if(sel) sel.value = serial;
+}
+function stopLive(){
+  _liveSerial = '';
+  const img = document.getElementById('agent-live-img');
+  img.src = '';
+  img.style.display = 'none';
+  document.getElementById('agent-live-empty').style.display = 'block';
+  document.getElementById('agent-live-serial').textContent = '';
+}
+function followSerialFromArgs(args){
+  // 工具 args（后端 SSE 已序列化为对象；兼容历史字符串格式）
+  let a = args;
+  if(typeof args === 'string'){
+    try{ a = JSON.parse(args); }catch(e){ return; }
+  }
+  if(a && a.serial) showLive(a.serial);
+}
+function watchDevice(serial){
+  if(!serial){ stopLive(); return; }
+  showLive(serial);
+}
+function loadLiveDevices(){
+  apiGet('/api/devices').then(r=>{
+    if(!r||!r.ok)return;
+    const sel = document.getElementById('agent-live-select');
+    if(!sel)return;
+    const cur = sel.value;
+    const devs = (r.devices||[]).filter(x=>x.indexOf(':')>=0);
+    sel.innerHTML = '<option value="">选择设备观看…</option>'
+      + devs.map(s=>'<option value="'+esc(s)+'"'+(s===cur?' selected':'')+'>'+esc(s)+'</option>').join('');
+  });
+}
+
+// 截图点击放大查看
+function zoomScreenshot(img){
+  const ov = document.getElementById('agent-zoom');
+  if(!ov){
+    const d = document.createElement('div');
+    d.id = 'agent-zoom';
+    d.style.cssText = 'display:none;position:fixed;inset:0;background:rgba(0,0,0,.8);z-index:1400;align-items:center;justify-content:center;cursor:zoom-out';
+    d.onclick = ()=>d.style.display='none';
+    document.body.appendChild(d);
+  }
+  const ovEl = document.getElementById('agent-zoom');
+  ovEl.innerHTML = '';
+  const big = document.createElement('img');
+  big.src = img.src;
+  big.style.cssText = 'max-width:88vw;max-height:88vh;border-radius:8px';
+  ovEl.appendChild(big);
+  ovEl.style.display = 'flex';
+}
+// 截图 img 绑定点击放大
+document.addEventListener('click', ev=>{
+  const t = ev.target;
+  if(t && t.tagName==='IMG' && t.closest('.agent-toolcard') && !t.closest('#agent-zoom')){
+    zoomScreenshot(t);
+  }
+});
+
+function endRun(){
+  setRunning(false);
+  _agentStream && _agentStream.close();
+  _agentStream = null;
+  scrollChat();
+}
+
+// ================== 经验库（自进化记忆管理） ==================
+function openExpLib(){
+  document.getElementById('agent-exp-overlay').style.display = 'flex';
+  loadExpLib();
+}
+function closeExpLib(){
+  document.getElementById('agent-exp-overlay').style.display = 'none';
+}
+function loadExpLib(){
+  const list = document.getElementById('exp-lib-list');
+  apiGet('/api/agent/experience').then(r=>{
+    if(!r||!r.ok){ showToast((r&&r.error)||'加载失败','error'); return; }
+    document.getElementById('exp-lib-last').textContent =
+      (r.last ? ('最近巡检 ' + r.last + '：' + (r.last_summary||'')) : '');
+    if(r.running){
+      list.innerHTML = '<div class="text-muted" style="padding:20px;text-align:center">🔍 AI 巡检进行中（约 1 分钟），完成后请刷新…</div>';
+      return;
+    }
+    const exps = r.experiences||[];
+    if(!exps.length){
+      list.innerHTML = '<div class="text-muted" style="padding:20px;text-align:center">暂无经验——跑一轮带手机操作的任务后会自动沉淀</div>';
+      return;
+    }
+    list.innerHTML = '';
+    exps.forEach(e=>{
+      const a = e.audit||{};
+      const card = document.createElement('div');
+      card.style.cssText = 'border:1px solid var(--card-line);border-radius:10px;padding:9px 13px;background:#0d1117';
+      // 徽章
+      let badge = '';
+      if(a.action === 'pending' && a.verdict === 'delete'){
+        badge = '<span style="background:#7f1d1d;color:#fecaca;font-size:10.5px;padding:1px 8px;border-radius:9px;margin-left:8px">⚠ 建议删除</span>';
+      }else if(a.action === 'kept'){
+        badge = '<span style="background:#0f3d2e;color:#a7f3d0;font-size:10.5px;padding:1px 8px;border-radius:9px;margin-left:8px">' +
+                (a.verdict === 'delete' ? '已人工保留' : '✓ 已保留') + '</span>';
+      }
+      let actBtns = '';
+      if(a.action === 'pending'){
+        actBtns = '<button class="btn btn-xs btn-danger" onclick="expDelete(' + e.id + ')">确认删除</button>'
+                + '<button class="btn btn-xs" onclick="expKeep(' + e.id + ')">保留</button>';
+      }else{
+        actBtns = '<button class="btn btn-xs" style="border-color:#7f1d1d;color:#f87171" onclick="expDelete(' + e.id + ')" title="强制删除此经验">删除</button>';
+      }
+      card.innerHTML =
+        '<div style="display:flex;align-items:center;gap:6px;font-size:12px">'
+        + '<span class="text-muted" style="font-family:var(--mono)">#' + e.id + '</span>'
+        + '<span class="text-muted">' + esc(e.created_at||'') + '</span>'
+        + '<span class="text-muted">引用 ' + (e.hits||0) + ' 次</span>' + badge
+        + '<span style="flex:1"></span>' + actBtns + '</div>'
+        + '<div style="font-size:13px;color:#e5e7eb;margin:5px 0 3px">' + esc(e.task_prompt) + '</div>'
+        + '<div class="text-muted" style="font-size:11.5px;line-height:1.6;white-space:pre-wrap">' + esc((e.recipe||'').slice(0,220)) + '</div>'
+        + (a.action === 'pending' && a.reason
+           ? '<div style="font-size:11.5px;color:#fbbf24;margin-top:5px">AI 建议理由：' + esc(a.reason)
+             + (a.score ? '（评分 ' + a.score + '/10）' : '') + '</div>'
+           : '');
+      list.appendChild(card);
+    });
+  });
+}
+function triggerExpAudit(){
+  apiPost('/api/agent/experience/audit',{}).then(r=>{
+    if(r&&r.ok){
+      showToast('巡检已启动，约 1 分钟完成','success');
+      document.getElementById('exp-lib-list').innerHTML =
+        '<div class="text-muted" style="padding:20px;text-align:center">🔍 AI 巡检进行中…</div>';
+      // 完成后自动刷新
+      setTimeout(()=>{ if(document.getElementById('agent-exp-overlay').style.display==='flex') loadExpLib(); }, 90000);
+    }else showToast((r&&r.error)||'巡检启动失败','error');
+  });
+}
+function expDelete(id){
+  if(!confirm('确认删除该经验？删除后不可恢复（下次相似任务不再自动参考）。')) return;
+  apiPost('/api/agent/experience/delete',{id:id}).then(r=>{
+    if(r&&r.ok){ showToast('已删除','success'); loadExpLib(); }
+    else showToast((r&&r.error)||'删除失败','error');
+  });
+}
+function expKeep(id){
+  apiPost('/api/agent/experience/keep',{id:id}).then(r=>{
+    if(r&&r.ok){ showToast('已保留，后续不再重复建议','success'); loadExpLib(); }
+    else showToast((r&&r.error)||'操作失败','error');
+  });
+}

static/admin/base.js

@@ -100,12 +100,14 @@ function showTab(name){
   if(name==='tasks'){showSubTab('tasks',_activeSubs.tasks);loadTasks();loadCustomActions();}
   if(name==='tools'){showSubTab('tools',_activeSubs.tools);loadToolsDevices();loadAdbDevices();loadTailscaleDevices();loadApks();}
   if(name==='logs'){loadLogs();if(document.getElementById('log-auto').checked)_logTimer=setInterval(loadLogs,3000);}
+  if(name==='agent' && typeof initAgentChat==='function') initAgentChat();
   if(name==='users')loadUsers();
+  if(name==='system'){showSubTab('system',_activeSubs.system||'backup');}
 }
 
 // ================== 页内子分栏（任务/工具 通用） ==================
 // 每个带子分栏的 Tab 记住上次选中的子分栏，切走再切回来保持原位
-let _activeSubs = {tasks: 'plan', tools: 'clipboard'};
+let _activeSubs = {tasks: 'plan', tools: 'clipboard', system: 'backup'};
 let _discoveryTimer = null;   // 设备自动发现 10s 轮询（仅 devpool 子分栏激活时）
 
 function showSubTab(tabId, name){

static/admin/system.js

@@ -0,0 +1,125 @@
+// 「系统」Tab：数据备份导出/导入（依赖 base.js：esc/_csrfHeaders/apiPost/showToast/handleResult）
+let _restoreToken = '';   // 预览通过后的暂存标识（用于 apply）
+
+// ================== 导出 ==================
+async function doExportBackup(){
+  const st=document.getElementById('backup-status');
+  const btn=event&&event.target||null;
+  if(btn)btn.disabled=true;
+  const includeApk=document.getElementById('backup-include-apk').checked;
+  if(st)st.textContent='正在生成备份并打包…';
+  try{
+    const r=await fetch('/api/system/backup/export',{
+      method:'POST',
+      headers:{'Content-Type':'application/json',..._csrfHeaders()},
+      body:JSON.stringify({include_apk:includeApk})
+    });
+    if(r.status===401){window.location='/login';return;}
+    if(!r.ok){
+      let msg='导出失败';
+      try{const d=await r.json();if(d&&d.error)msg=d.error;}catch(e){}
+      showToast(msg,'error');
+      if(st)st.textContent='';
+      return;
+    }
+    const blob=await r.blob();
+    const cd=r.headers.get('Content-Disposition')||'';
+    const m=/filename="?([^";]+)"?/i.exec(cd);
+    const fname=m?m[1]:('auto_control_backup_'+Date.now()+'.zip');
+    const url=URL.createObjectURL(blob);
+    const a=document.createElement('a');
+    a.href=url;a.download=fname;document.body.appendChild(a);
+    a.click();a.remove();
+    setTimeout(()=>URL.revokeObjectURL(url),3000);
+    if(st)st.textContent='已生成 '+fname;
+    showToast('导出成功','success');
+  }catch(e){
+    showToast('导出失败: '+e,'error');
+    if(st)st.textContent='';
+  }finally{
+    if(btn)btn.disabled=false;
+  }
+}
+
+// ================== 导入：上传预览 ==================
+async function previewRestore(){
+  const fileEl=document.getElementById('restore-file');
+  const f=fileEl&&fileEl.files&&fileEl.files[0];
+  const box=document.getElementById('restore-preview');
+  const st=document.getElementById('restore-status');
+  const applyBtn=document.getElementById('btn-apply-restore');
+  if(!f){showToast('请先选择备份文件（.zip 或 .db）','error');return;}
+  _restoreToken='';
+  if(applyBtn)applyBtn.style.display='none';
+  if(st)st.textContent='';
+  box.innerHTML='<span class="text-muted">解析校验中…</span>';
+  const fd=new FormData();
+  fd.append('file',f);
+  try{
+    const r=await fetch('/api/system/backup/preview',{
+      method:'POST',
+      headers:_csrfHeaders(),   // FormData 不能手动设 Content-Type
+      body:fd
+    });
+    if(r.status===401){window.location='/login';return;}
+    const d=await r.json();
+    box.innerHTML='';
+    if(!d.ok){showToast(d.error||'解析失败','error');return;}
+    _restoreToken=d.token;
+    renderRestorePreview(d.preview);
+    if(applyBtn)applyBtn.style.display='';
+  }catch(e){
+    box.innerHTML='';
+    showToast('上传失败: '+e,'error');
+  }
+}
+
+function renderRestorePreview(p){
+  const box=document.getElementById('restore-preview');
+  const rows=(p.tables||[]).map(t=>
+    '<tr><td>'+esc(t.label||t.table)+'</td><td>'+esc(t.table)+'</td><td>'+esc(t.rows)+'</td></tr>').join('');
+  const warns=(p.warnings||[]).map(w=>'<li>'+esc(w)+'</li>').join('');
+  box.innerHTML=
+    '<table class="table table-hover table-sm" style="max-width:560px">'+
+      '<tbody>'+
+        '<tr><th style="width:120px">文件</th><td>'+esc(p.file_name||'')+'（'+(p.file_size!=null?fmtSize(p.file_size):'')+'）</td></tr>'+
+        '<tr><th>库结构版本</th><td>备份 v'+esc(p.schema_version)+' / 当前 v'+esc(p.current_schema_version)+'</td></tr>'+
+        '<tr><th>完整性</th><td>'+esc(p.integrity||'')+'</td></tr>'+
+      '</tbody>'+
+    '</table>'+
+    '<div class="section-title" style="margin-top:8px">表数据行数</div>'+
+    '<table class="table table-hover table-sm" style="max-width:560px"><thead><tr><th>业务</th><th>表</th><th>行数</th></tr></thead><tbody>'+(rows||'<tr><td colspan="3">—</td></tr>')+'</tbody></table>'+
+    (warns?'<div style="background:#fff3cd;border:1px solid #ffda6a;color:#7a5b00;padding:8px 12px;border-radius:6px;margin-top:8px"><ul style="margin:0;padding-left:18px">'+warns+'</ul></div>':'');
+}
+
+function fmtSize(n){
+  if(n==null)return '';
+  if(n<1024)return n+' B';
+  if(n<1024*1024)return (n/1024).toFixed(1)+' KB';
+  return (n/1024/1024).toFixed(1)+' MB';
+}
+
+// ================== 导入：确认应用 ==================
+async function applyRestore(){
+  const applyBtn=document.getElementById('btn-apply-restore');
+  const st=document.getElementById('restore-status');
+  if(!_restoreToken)return;
+  if(!confirm('确认应用导入？\n\n系统会先自动备份当前库（data/backups/pre_restore_*.db），再把待导入数据覆盖现有全部数据。\n导入将在重启 web_server 后生效。\n\n确定继续？'))return;
+  if(applyBtn)applyBtn.disabled=true;
+  if(st)st.textContent='正在生成恢复任务…';
+  const r=await apiPost('/api/system/backup/apply',{token:_restoreToken});
+  if(!r)return;
+  if(r.ok){
+    const box=document.getElementById('restore-preview');
+    box.innerHTML='<div style="background:#e8f5e9;border:1px solid #a5d6a7;padding:10px 14px;border-radius:6px">'+
+      '✅ 恢复任务已生成。<br>当前库已自动备份到 <code>'+esc(r.backup_name||'')+'</code>。<br>'+
+      '请<b>重启 web_server</b>，启动时将自动应用导入数据（恢复完成前不要再次导入）。</div>';
+    if(st)st.textContent='';
+    if(applyBtn)applyBtn.style.display='none';
+    document.getElementById('restore-file').value='';
+    _restoreToken='';
+  }else{
+    showToast(r.error||'应用导入失败','error');
+    if(applyBtn)applyBtn.disabled=false;
+  }
+}

static/admin/tools.js

@@ -81,6 +81,29 @@ function loadDiscovery(){
           +'<button class="btn btn-xs" data-serial="'+esc(x.serial)+'" onclick="ignoreDiscoveryDev(this.dataset.serial)">忽略</button></td></tr>';
       }).join('');
     }
+    // 正式池断联设备：仍在设备池（不删除），扫描线程自动重连，可手动立即重连
+    const offTb=document.getElementById('tb-pool-offline');
+    if(offTb){
+      const off=(r.pool_offline||[]);
+      if(!off.length){
+        offTb.innerHTML='<tr><td colspan="5" class="empty">全部在线</td></tr>';
+      }else{
+        offTb.innerHTML=off.map(x=>{
+          return '<tr><td style="font-family:monospace">'+esc(x.serial)+'</td>'
+            +'<td>'+esc(x.model||'-')+'</td><td>'+esc(x.name||'')+'</td>'
+            +'<td><span class="label label-danger">断联·自动重连中</span></td>'
+            +'<td><button class="btn btn-xs" data-serial="'+esc(x.serial)+'" onclick="reconnectPoolDev(this.dataset.serial)">立即重连</button></td></tr>';
+        }).join('');
+      }
+    }
+  });
+}
+function reconnectPoolDev(serial){
+  apiPost('/api/devices/discovery/reconnect',{serial}).then(r=>{
+    if(r&&r.ok){
+      showToast('重连已启动（约 5-15 秒生效）','success');
+      setTimeout(loadDiscovery,8000);
+    }else showToast('重连失败: '+((r&&r.error)||''),'error');
   });
 }
 function toggleDiscovery(checked){

templates/admin/monitor.html

@@ -303,6 +303,54 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 .el-picker-item .ep-info .ep-attrs{color:var(--text-light);font-size:11px;margin-top:2px;word-break:break-all}
 .el-picker-item .ep-info .ep-attrs span{margin-right:8px}
 .el-picker-item .ep-sel{font-size:10px;color:#fff;background:var(--primary);padding:1px 7px;border-radius:99px;flex-shrink:0;font-weight:600}
+
+/* ===== AI 控制台（聊天界面，浅色内容区——DeepSeek 风格，图片文字清晰） ===== */
+.agent-body{display:flex;flex:1;min-height:0}
+.agent-col-sessions{width:236px;border-right:1px solid #e5e7eb;background:#f6f7f9;display:flex;flex-direction:column;min-width:0}
+.agent-sess-head{padding:10px;border-bottom:1px solid #e5e7eb}
+.agent-sess-list{flex:1;overflow-y:auto;padding:6px}
+.agent-sess-item{padding:8px 10px;border-radius:9px;cursor:pointer;margin-bottom:2px;border:1px solid transparent;position:relative}
+.agent-sess-item:hover{background:#eceff3}
+.agent-sess-item.active{background:#e0f2fe;border-color:#bae6fd}
+.agent-sess-item .t{font-size:12.5px;color:#1f2937;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;padding-right:20px}
+.agent-sess-item .m{font-size:10.5px;color:#9ca3af;margin-top:2px}
+.agent-sess-del{position:absolute;right:6px;top:6px;visibility:hidden;background:transparent;border:none;color:#9ca3af;cursor:pointer;font-size:12px;padding:2px 5px;border-radius:5px}
+.agent-sess-item:hover .agent-sess-del{visibility:visible}
+.agent-sess-del:hover{background:#fecaca;color:#b91c1c}
+.agent-col-chat{flex:1;display:flex;flex-direction:column;min-width:0}
+.agent-col-live{width:300px;border-left:1px solid #e5e7eb;background:#fff;display:flex;flex-direction:column;padding:10px}
+.agent-live-head{font-size:12.5px;font-weight:600;color:#374151;display:flex;align-items:center;justify-content:space-between;margin-bottom:8px}
+.agent-live-serial{font-family:var(--mono);font-size:10.5px;color:#6b7280}
+.agent-live-body{flex:1;background:#0b0f14;border-radius:10px;display:flex;align-items:center;justify-content:center;overflow:hidden;min-height:200px}
+.agent-live-body img{width:100%;height:100%;object-fit:contain}
+.agent-live-body .agent-empty{color:#4b5563;padding:20px;font-size:12px;line-height:1.8}
+.agent-shell{display:flex;flex-direction:column;height:calc(100vh - 150px);min-height:520px;border:1px solid #e5e7eb;border-radius:14px;overflow:hidden;background:#fff}
+.agent-shell{display:flex;flex-direction:column;height:calc(100vh - 150px);min-height:480px;border:1px solid #e5e7eb;border-radius:14px;overflow:hidden;background:#fff}
+.agent-topbar{display:flex;align-items:center;justify-content:space-between;padding:10px 16px;border-bottom:1px solid #e5e7eb;background:#f9fafb}
+.agent-title{font-size:14px;font-weight:700;color:#111827}
+.agent-model-tag{margin-left:8px;font-size:11px;color:#0e7490;font-family:var(--mono);background:#e0f2fe;padding:2px 8px;border-radius:10px}
+.agent-running-tag{color:#dc2626;font-size:12px;margin-right:8px}
+.agent-top-actions{display:flex;align-items:center;gap:6px}
+.agent-top-actions .btn{background:#fff;border:1px solid #d1d5db;color:#374151}
+.agent-top-actions .btn:hover{border-color:#0e7490;color:#0e7490}
+.agent-chat{flex:1;overflow-y:auto;padding:20px 26px;display:flex;flex-direction:column;gap:16px;background:#f7f8fa}
+.agent-msg{max-width:80%;padding:11px 15px;border-radius:13px;font-size:13.5px;line-height:1.7;white-space:pre-wrap;word-break:break-word}
+.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-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}
+.agent-toolcard code{color:#0e7490}
+.agent-toolcard .text-muted{color:#6b7280}
+.agent-toolcard img{max-width:190px;border-radius:7px;margin-top:4px;border:1px solid #e5e7eb;display:block;cursor:zoom-in}
+.agent-inputbar{display:flex;gap:10px;padding:12px 14px;border-top:1px solid #e5e7eb;background:#fff}
+.agent-inputbar textarea{flex:1;resize:none;background:#f9fafb;border:1px solid #d1d5db;border-radius:10px;padding:9px 12px;color:#111827;font-size:13.5px;outline:none;line-height:1.5}
+.agent-inputbar textarea:focus{border-color:#0e7490;box-shadow:0 0 0 2px rgba(14,116,144,.12)}
+.agent-inputbar .btn-primary{background:#0e7490;border:none}
+.agent-inputbar .btn-primary:hover{background:#155e75}
+.agent-inputbar .btn-primary:disabled{background:#9ca3af}
+.agent-empty{color:#6b7280;font-size:13px;text-align:center;padding:44px 0}
 </style>
 </head>
 <body>
@@ -316,6 +364,8 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
     <button class="tab" data-tab="logs" onclick="showTab('logs')" data-perm="logs">日志</button>
     <button class="tab" data-tab="users" onclick="showTab('users')" data-perm="admin">用户</button>
     <button class="tab" data-tab="tools" onclick="showTab('tools')" data-perm="admin">工具</button>
+    <button class="tab" data-tab="agent" onclick="showTab('agent')" data-perm="admin">AI 控制台</button>
+    <button class="tab" data-tab="system" onclick="showTab('system')" data-perm="admin">系统</button>
   </div>
   <div class="user-info">
     <span id="me-username">...</span>
@@ -422,6 +472,97 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 </div>
 
 <!-- ========== Tab 3: 分组 ========== -->
+<!-- ========== Tab: AI 控制台（DeepSeek 风格聊天 + 实时 MCP 步骤） ========== -->
+<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-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>
+        <button class="btn btn-xs" onclick="openAgentConfig()">⚙ 配置</button>
+      </div>
+    </div>
+    <div class="agent-body">
+      <div class="agent-col-sessions">
+        <div class="agent-sess-head">
+          <button class="btn btn-primary" style="width:100%" onclick="createAgentSession()">＋ 新建会话</button>
+        </div>
+        <div id="agent-sess-list" class="agent-sess-list"></div>
+      </div>
+      <div class="agent-col-chat">
+        <div id="agent-chat" class="agent-chat"></div>
+      </div>
+      <div class="agent-col-live">
+        <div class="agent-live-head">📺 实时画面<span id="agent-live-serial" class="agent-live-serial"></span></div>
+        <div class="agent-live-body" id="agent-live-body">
+          <img id="agent-live-img" alt="" style="display:none;width:100%">
+          <div class="agent-empty" id="agent-live-empty">运行任务时自动跟随操作的设备；<br>也可手动选择设备观看</div>
+        </div>
+        <select id="agent-live-select" class="form-control" style="margin-top:8px"
+                onchange="watchDevice(this.value)"><option value="">选择设备观看…</option></select>
+      </div>
+    </div>
+    <div class="agent-inputbar" style="align-items:flex-end;flex-direction:column">
+      <div style="display:flex;width:100%;gap:8px;align-items:center;margin-bottom:8px">
+        <label style="font-size:12.5px;color:#374151;font-weight:600;white-space:nowrap">🎯 目标设备</label>
+        <select id="agent-target-select" class="form-control" style="width:320px;font-family:monospace"
+                title="AI 只操作你选定的设备；有任务运行中的设备不可选">
+          <option value="">请选择设备（AI 只操作选定设备）…</option>
+        </select>
+        <span class="text-muted" id="agent-target-hint" style="font-size:11.5px"></span>
+        <span style="flex:1"></span>
+        <button class="btn btn-xs btn-danger" id="btn-agent-stop" style="display:none" onclick="stopAgent()">■ 停止</button>
+      </div>
+      <div style="display:flex;width:100%;gap:10px">
+        <textarea id="agent-input" rows="2"
+                  placeholder="给 AI 下达指令，例如：打开抖音搜索奚学东，把第一个视频标题告诉我…（Enter 发送，Shift+Enter 换行）"></textarea>
+        <button class="btn btn-primary" id="btn-agent-send" onclick="sendAgentMsg()">发送</button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<!-- ========== 配置模态框 ========== -->
+<div id="agent-cfg-overlay" style="display:none;position:fixed;inset:0;background:rgba(0,0,0,.6);z-index:1300;align-items:center;justify-content:center">
+  <div style="background:#11151c;border:1px solid var(--card-line);border-radius:14px;padding:22px;width:460px;max-width:92vw">
+    <div style="font-size:15px;font-weight:700;margin-bottom:14px">模型配置（OpenAI 兼容 API）</div>
+    <div class="form-group"><label>API Base</label>
+      <input type="text" id="acfg-base" class="form-control" placeholder="https://api.deepseek.com" style="font-family:monospace"></div>
+    <div class="form-group"><label>模型名</label>
+      <input type="text" id="acfg-model" class="form-control" placeholder="deepseek-v4-flash-vision-exp"></div>
+    <div class="form-group"><label>API Key <span class="text-muted" id="acfg-key-hint"></span></label>
+      <input type="password" id="acfg-key" class="form-control" placeholder="留空则不修改"></div>
+    <div class="form-group"><label>默认设备 serial（可选）</label>
+      <input type="text" id="acfg-serial" class="form-control" placeholder="192.168.20.66:5555" style="font-family:monospace"></div>
+    <div class="form-group"><label>最大执行步骤（1-200，默认 40）</label>
+      <input type="number" id="acfg-steps" class="form-control" min="1" max="200" placeholder="40"
+             title="单轮任务允许的最大工具调用轮数；超限会收尾总结（防死循环）"></div>
+    <div style="display:flex;justify-content:flex-end;gap:8px;margin-top:6px">
+      <button class="btn" onclick="closeAgentConfig()">取消</button>
+      <button class="btn btn-primary" onclick="saveAgentConfig()">保存</button>
+    </div>
+  </div>
+</div>
+
+<!-- ========== 经验库模态框（自进化记忆管理 + 每日 AI 巡检建议） ========== -->
+<div id="agent-exp-overlay" style="display:none;position:fixed;inset:0;background:rgba(0,0,0,.6);z-index:1320;align-items:center;justify-content:center">
+  <div style="background:#11151c;border:1px solid var(--card-line);border-radius:14px;padding:20px 22px;width:760px;max-width:94vw;max-height:86vh;display:flex;flex-direction:column">
+    <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:4px">
+      <div style="font-size:15px;font-weight:700">🧠 经验库<span class="text-muted" style="font-size:11.5px;font-weight:400;margin-left:8px" id="exp-lib-hint"></span></div>
+      <div style="display:flex;gap:6px;align-items:center">
+        <button class="btn btn-xs" onclick="triggerExpAudit()">🔍 立即巡检</button>
+        <button class="btn btn-xs" onclick="closeExpLib()">✕ 关闭</button>
+      </div>
+    </div>
+    <div class="text-muted" style="font-size:11.5px;padding:0 2px 8px;border-bottom:1px solid var(--card-line);margin-bottom:10px">
+      每次任务成功后会提炼「操作配方」存入经验库，下次相似任务自动参考；每日 03:47 AI 巡检给出疑似问题建议（删除需人工确认）。
+      <span id="exp-lib-last" class="text-muted"></span>
+    </div>
+    <div id="exp-lib-list" style="flex:1;overflow-y:auto;min-height:200px;display:flex;flex-direction:column;gap:8px"></div>
+  </div>
+</div>
+
 <!-- ========== Tab 4: 日志 ========== -->
 <div id="tab-logs" class="tab-panel">
   <div class="page-title">日志查看</div>
@@ -656,6 +797,15 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
       </table>
       <div class="help">扫描局域网/Tailscale 网段中开放 adb 5555 的设备进入<b>待连接池</b>；
         <b>确认后才加入正式设备池</b>（不自动连接、不参与任务调度）。未授权设备（手机未接受 RSA 弹窗）不会出现。</div>
+      <!-- 正式池断联设备：仍在设备池（不删除、不进待连接池），自动重连中 -->
+      <div style="margin-top:10px">
+        <div style="font-size:12.5px;font-weight:600;margin-bottom:6px">设备池断联设备
+          <span class="text-muted" style="font-weight:400">（仍在设备池内，扫描线程每轮自动重连；也可手动立即重连）</span></div>
+        <table class="table table-hover table-sm">
+          <thead><tr><th>serial</th><th>型号</th><th>备注</th><th>状态</th><th>操作</th></tr></thead>
+          <tbody id="tb-pool-offline"><tr><td colspan="5" class="empty">全部在线</td></tr></tbody>
+        </table>
+      </div>
     </div>
     <div class="toolbar">
       <input type="text" id="devpool-serial" class="form-control" style="width:220px;font-family:monospace"
@@ -701,7 +851,51 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
     <div class="list-pager" id="pager-groups"></div>
     <div class="help">管理设备分组，用于任务按分组执行。分组内的设备需先在<b>设备池管理</b>中确认（不在池内的设备不参与调度）。</div>
   </div>
+</div>
 
+<!-- ========== Tab 9: 系统（仅管理员） ========== -->
+<div id="tab-system" class="tab-panel">
+  <div class="page-title">系统</div>
+  <div class="page-sub">系统数据备份导出/导入（仅管理员）</div>
+
+  <div class="sub-tabs">
+    <button class="sub-tab active" data-sub="backup" onclick="showSubTab('system','backup')">数据备份</button>
+    <button class="sub-tab" data-sub="restore" onclick="showSubTab('system','restore')">导入恢复</button>
+  </div>
+
+  <!-- 子分栏 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> 应用文件。
+      恢复用：换机 / 整库迁移 / 出问题前留底。
+    </div>
+    <div class="toolbar" style="gap:8px">
+      <label style="display:inline-flex;align-items:center;gap:4px;margin:0 6px">
+        <input type="checkbox" id="backup-include-apk" checked> 包含 APK 文件（体积较大，~100MB 级）
+      </label>
+      <button class="btn btn-primary" onclick="doExportBackup()">导出备份</button>
+      <span id="backup-status" class="text-muted"></span>
+    </div>
+    <div style="background:#fff8e1;border:1px solid #ffe082;color:#8a6d00;padding:8px 12px;border-radius:6px;margin:8px 0">
+      ⚠️ 备份为<b>全量快照</b>：含用户口令哈希、AI 配置里的 API Key 等敏感信息，请妥善保管，勿外传、勿提交到 git。
+    </div>
+  </div>
+
+  <!-- 子分栏 2：导入恢复 -->
+  <div class="sub-panel" id="system-sub-restore">
+    <div class="help">
+      <b>导入恢复</b>：上传平台导出的 <code>.zip</code> 或 <code>.db</code> → 先<b>校验预览</b> →
+      确认后系统会<b>自动备份当前库</b>并把恢复任务挂起，<b>重启 web_server 后生效</b>（导入将覆盖现有全部数据）。
+    </div>
+    <div class="toolbar" style="gap:8px">
+      <input type="file" id="restore-file" accept=".zip,.db">
+      <button class="btn" onclick="previewRestore()">上传并预览</button>
+      <button class="btn btn-danger" id="btn-apply-restore" onclick="applyRestore()" style="display:none">确认应用导入</button>
+      <span id="restore-status" class="text-muted"></span>
+    </div>
+    <div id="restore-preview" style="margin-top:8px"></div>
+  </div>
 </div>
 
 </div><!-- /.content -->
@@ -766,5 +960,7 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 <script src="/static/admin/tools.js"></script>
 <script src="/static/admin/apps.js"></script>
 <script src="/static/admin/admin.js"></script>
+<script src="/static/admin/agent.js"></script>
+<script src="/static/admin/system.js"></script>
 </body>
 </html>

web/__init__.py

@@ -9,6 +9,7 @@
   devices     — 设备池管理
   apks        — 应用管理
   tailscale   — Tailscale 管理
+  system      — 系统数据备份导出/导入
 """
 from flask import Blueprint
 
@@ -23,6 +24,10 @@ def register_blueprints(app):
     from .devices_api import bp as devices_bp
     from .apks_api import bp as apks_bp
     from .tailscale_api import bp as tailscale_bp
+    from . import agent_api as _agent_mod
+    from .agent_api import bp as agent_bp
+    _agent_mod.set_app(app)
+    from .system_api import bp as system_bp
     for bp in (auth_bp, monitor_bp, tasks_bp, admin_bp, tools_bp,
-               devices_bp, apks_bp, tailscale_bp):
+               devices_bp, apks_bp, tailscale_bp, agent_bp, system_bp):
         app.register_blueprint(bp)

web/agent_api.py

@@ -0,0 +1,969 @@
+"""AI 控制台 API：模型/Key 前端配置 + Agent 流式执行（SSE 事件流）。
+
+流程：
+  POST /api/agent/run {prompt}        → 启动 Agent 线程，返回 run_id
+  GET  /api/agent/stream?run_id=      → SSE 事件流（EventSource 订阅）：
+        event: delta  {text, kind: content|reasoning}   流式文本增量
+        event: step   {tool, args, image?}               工具调用完成（MCP 步骤）
+        event: done   {answer}                           完成
+        event: error  {message}                          失败
+  GET/POST /api/agent/config          → 配置读写（key 打码回显）
+
+单实例：同时只允许一个 Agent 运行。
+"""
+import asyncio
+import base64
+import io
+import json
+import os
+import queue
+import re
+import sys
+import threading
+import uuid
+
+from flask import Blueprint, Response, jsonify, request
+
+from core.logger import get_logger
+from core.models import db
+from web.auth import admin_required
+
+_log = get_logger("web.agent")
+bp = Blueprint("agent", __name__)
+
+# ---------- 配置键（app_meta） ----------
+_CFG_KEYS = {"api_base": "agent_api_base",
+             "model": "agent_model",
+             "api_key": "agent_api_key",
+             "default_serial": "agent_default_serial",
+             "max_steps": "agent_max_steps"}
+
+# ---------- 运行状态（单实例 + 事件队列） ----------
+_run = {"id": None, "state": "idle", "prompt": "", "serial": "",
+        "answer": "", "error": "",
+        "history": []}   # 多轮对话历史 [{role: user|assistant, content}]
+_queues = {}            # run_id -> queue.Queue（SSE 消费者读取）
+_stop_events = {}       # run_id -> threading.Event（用户中断）
+_lock = threading.Lock()
+_flask_app = None       # web_server 注册时注入（后台线程 db 操作需 app context）
+
+
+def set_app(app):
+    global _flask_app
+    _flask_app = app
+
+
+def _meta_get(key):
+    return db.session.execute(
+        db.text("SELECT value FROM app_meta WHERE key=:k"), {"k": key}).scalar() or ""
+
+
+def _meta_put(key, value):
+    db.session.execute(
+        db.text("INSERT OR REPLACE INTO app_meta(key,value) VALUES(:k,:v)"),
+        {"k": key, "v": str(value)})
+
+
+def _read_cfg():
+    return {k: _meta_get(v) for k, v in _CFG_KEYS.items()}
+
+
+# ================== 经验记忆（自进化） ==================
+# agent_experience：任务成功后的操作配方，下次相似任务检索注入 system prompt。
+# 原始 SQLite（CREATE IF NOT EXISTS 幂等），不进模型层迁移。
+_EXP_TABLE = """
+CREATE TABLE IF NOT EXISTS agent_experience (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_prompt TEXT DEFAULT '',
+  recipe TEXT DEFAULT '',
+  tool_seq TEXT DEFAULT '',
+  hits INTEGER DEFAULT 0,
+  created_at VARCHAR(20) DEFAULT '')"""
+
+# 经验巡检（AI 质检）：每日定时把经验交给模型评审，疑似问题标 pending 待人工确认。
+# 删除只允许人工（前端 confirm / 本 API），巡检绝不自动删。
+_AUDIT_TABLE = """
+CREATE TABLE IF NOT EXISTS experience_audit (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  exp_id INTEGER NOT NULL,
+  verdict TEXT DEFAULT '',       -- keep 保留 / delete 建议删除
+  score REAL DEFAULT 0,          -- 0-10 可用性评分
+  reason TEXT DEFAULT '',        -- 模型给出的理由
+  hits INTEGER DEFAULT 0,        -- 巡检时的引用次数（hits>0 被删要更谨慎）
+  action TEXT DEFAULT 'pending', -- pending 待人工确认 / kept 已保留 / deleted 已删除
+  audited_at VARCHAR(20) DEFAULT '')"""
+
+# 巡检评审提示词：模型只判「保留/建议删除」+ 评分 + 理由，不直接删。
+_AUDIT_PROMPT = """你是「手机自动化经验库」质检员。经验库存放 AI 成功操作手机后提炼的
+操作套路，下次相似任务会自动注入参考。请判断下面这条经验是否值得继续保留。
+
+判断标准（全部满足才保留）：
+1. 具体可执行：步骤是明确的工具操作（de_* 或清晰的中文步骤），不是「de_tap / de_input」
+   这类空泛占位，也没有编造不存在的工具名
+2. 不依赖易过时信息：不含写死的像素坐标（x,y 数字）这类界面一变就失效的步骤
+3. 是独立任务的操作套路（如「打开X搜索Y并点赞」），不是对话追问/抱怨/单次性内容
+4. 配方与下方实际操作序列大致一致，不是模型自由发挥编造
+
+经验内容：
+任务描述：{prompt}
+操作配方：{recipe}
+实际操作序列：{tool_seq}
+被引用次数：{hits}
+
+只输出 JSON：{{"keep": true或false, "score": 0到10的整数, "reason": "一句话中文理由"}}"""
+
+
+def _ensure_exp_table():
+    try:
+        db.session.execute(db.text(_EXP_TABLE))
+        db.session.commit()
+    except Exception:
+        pass
+
+
+def _bigrams(text):
+    """中文/英文文本 bigram 集合（无空格分词，粗粒度相似度）。"""
+    t = "".join(c for c in (text or "").lower() if c.isalnum() or "\u4e00" <= c <= "\u9fff")
+    return {t[i:i + 2] for i in range(len(t) - 1)}
+
+
+# ---------- 经验质量门槛 ----------
+# 自进化经验只应保存「独立操作任务」的成功套路。多轮对话里用户的短句
+# （质疑/纠正/催促，如「继续啊」「你确定我是卡1吗」「还没有完成啊」）
+# 不是新任务——把执行出错被纠正的轮次存成经验会教坏后续任务。
+# 用启发式过滤（零成本，可解释），配方层再校验工具名真实性。
+
+# 任务性动词：命中任一视为有明确操作诉求（疑问/纠错短句一般不含它们）
+_TASK_VERBS = ("打开", "搜索", "查看", "找到", "截图", "输入", "点击", "点开",
+               "发送", "安装", "卸载", "下载", "启动", "停止", "关闭", "退出",
+               "登录", "切换", "设置", "删除", "清理", "复制", "粘贴", "读取",
+               "剪贴板", "长按", "滑动", "播放", "发布", "检查", "看看",
+               "帮我", "给我", "请", "拍张", "查一下")
+# 对话续语开头：几乎只出现在承接上一轮（「继续啊」「还有吗」）
+_CONTINUE_PREFIXES = ("继续", "还有", "然后呢", "再来", "快点", "刚才",
+                      "接着", "上一步")
+# 强质疑/纠错信号（不含「为什么」——「查一下为什么」是正当任务）
+_DOUBT_MARKS = ("你确定", "是不是", "不是吧", "不是吗", "怎么都", "怎么还",
+                "还没有", "没看到", "我说的是", "你听我说", "不对吧", "你又",
+                "重新来", "错了", "你说得", "你回答")
+# 全部真实 MCP 工具（配方里出现不存在的 de_* 说明蒸馏模型在编造，弃存）
+_KNOWN_TOOLS = frozenset({
+    "de_list_devices", "de_screenshot", "de_tap", "de_swipe", "de_ui_tree",
+    "de_tap_element", "de_read_clipboard", "de_wake", "de_press_key",
+    "de_open_app", "de_stop_app", "de_foreground_app", "de_type_text",
+    "de_set_clipboard", "de_sleep", "de_ocr", "de_tap_text", "de_list_apps",
+    "de_list_tasks"})
+
+
+def _qualify_experience(prompt, recipe):
+    """经验入库前质量门槛，返回 True=值得保存。
+
+    1) prompt 太短 / 纯续语开头 / 质疑纠错 → 非独立任务，弃
+    2) 疑问短句（≤30 字、以 吗/？ 结尾）且无任务动词 → 追问/反问，弃
+    3) 配方含不存在的 de_* 工具（蒸馏模型自由发挥）→ 弃
+    """
+    t = "".join(c for c in (prompt or "") if not c.isspace())
+    if len(t) < 6:
+        _log.info("经验弃存：prompt 过短「%s」", t[:20])
+        return False
+    if any(t.startswith(p) for p in _CONTINUE_PREFIXES):
+        _log.info("经验弃存：对话续语开头「%s」", t[:20])
+        return False
+    if any(m in t for m in _DOUBT_MARKS):
+        _log.info("经验弃存：质疑/纠错语气「%s」", t[:20])
+        return False
+    if (t.endswith("吗") or t.endswith("？") or t.endswith("?")) \
+            and len(t) <= 30 and not any(v in t for v in _TASK_VERBS):
+        _log.info("经验弃存：无操作诉求的追问「%s」", t[:20])
+        return False
+    for name in re.findall(r"de_[a-z_]+", recipe or ""):
+        if name not in _KNOWN_TOOLS:
+            _log.info("经验弃存：配方含不存在的工具 %s", name)
+            return False
+    return True
+
+
+def _find_experiences(prompt, limit=2, threshold=0.10):
+    """按 bigram 重叠检索相似历史经验（prompt 与任务描述的字符相似度）。
+
+    命中的经验 hits+1（回写），让被反复参考的有效经验浮到前面。
+    """
+    try:
+        if _flask_app is None:
+            return ""
+        with _flask_app.app_context():
+            _ensure_exp_table()
+            rows = db.session.execute(db.text(
+                "SELECT id, task_prompt, recipe, hits FROM agent_experience "
+                "WHERE recipe != '' ORDER BY hits DESC, id DESC LIMIT 50")).fetchall()
+    except Exception:
+        return ""
+    if not rows:
+        return ""
+    cur = _bigrams(prompt)
+    if not cur:
+        return ""
+    scored = []
+    for row_id, task_prompt, recipe, hits in rows:
+        sim = len(cur & _bigrams(task_prompt)) / len(cur)
+        if sim >= threshold:
+            scored.append((sim, hits or 0, recipe, row_id))
+    scored.sort(key=lambda x: (-x[0], -x[1]))
+    if scored:
+        # hits 回写（尽力而为，失败不影响检索）
+        try:
+            with _flask_app.app_context():
+                for _sim, _hits, _recipe, row_id in scored:
+                    db.session.execute(db.text(
+                        "UPDATE agent_experience SET hits=hits+1 WHERE id=:i"),
+                        {"i": row_id})
+                db.session.commit()
+        except Exception:
+            pass
+    parts = []
+    for sim, _hits, recipe, _row_id in scored[:limit]:
+        parts.append(f"- {recipe[:600]}")
+    return "\n".join(parts)
+
+
+def _distill_experience(cfg, prompt, tool_seq):
+    """任务完成后用模型把操作序列提炼为可复用配方（失败静默，不阻塞）。"""
+    try:
+        import httpx
+        body = {
+            "model": cfg.get("model") or "deepseek-v4-flash-vision-exp",
+            "messages": [{"role": "user",
+                          "content": "以下是一次成功的手机自动化操作记录。请提炼成简洁的"
+                                     "「操作配方」（2-6 步，每步：目标 → 用哪个工具），"
+                                     "供下次同类任务参考。不要解释，直接输出配方。\n"
+                                     f"任务：{prompt[:300]}\n操作序列：{tool_seq[:800]}"}],
+            "max_tokens": 600,
+        }
+        headers = {"Authorization": f"Bearer {cfg.get('api_key', '')}",
+                   "Content-Type": "application/json"}
+        r = httpx.post(f"{(cfg.get('api_base') or 'https://api.deepseek.com').rstrip('/')}/chat/completions",
+                       json=body, headers=headers, timeout=25)
+        if r.status_code != 200:
+            return ""
+        j = r.json()
+        recipe = ((j.get("choices") or [{}])[0].get("message") or {}).get("content") or ""
+        return recipe.strip()[:1500]
+    except Exception as e:
+        _log.warning(f"经验提炼失败: {e}")
+        return ""
+
+
+def _save_experience(prompt, recipe, tool_seq):
+    """保存经验（后台线程调用，包 app context）。返回是否保存成功。"""
+    try:
+        if _flask_app is None:
+            return False
+        with _flask_app.app_context():
+            _ensure_exp_table()
+            from datetime import datetime
+            db.session.execute(db.text(
+                "INSERT INTO agent_experience(task_prompt, recipe, tool_seq, hits, created_at) "
+                "VALUES(:p, :r, :t, 0, :c)"),
+                {"p": prompt[:500], "r": recipe, "t": tool_seq[:1000],
+                 "c": datetime.now().strftime("%Y-%m-%d %H:%M")})
+            db.session.commit()
+            _log.info("经验已保存（配方 %d 字符）", len(recipe))
+            return True
+    except Exception as e:
+        _log.warning(f"经验保存失败: {e}")
+        return False
+
+
+# ================== 经验巡检（AI 质检，删除需人工确认） ==================
+_audit_state = {"running": False, "last": "", "last_summary": ""}
+
+
+def _ensure_audit_table():
+    try:
+        db.session.execute(db.text(_AUDIT_TABLE))
+        db.session.commit()
+    except Exception:
+        pass
+
+
+def _review_one_exp(cfg, prompt, recipe, tool_seq, hits):
+    """调模型评审单条经验，返回 (verdict, score, reason)。
+
+    模型偶尔输出解释文字不带 JSON——重试一次（强调只输出 JSON），
+    仍失败则保守返回保留。
+    """
+    import httpx
+    base_prompt = _AUDIT_PROMPT.format(prompt=(prompt or "")[:400],
+                                       recipe=(recipe or "")[:600],
+                                       tool_seq=(tool_seq or "")[:600],
+                                       hits=hits or 0)
+    for attempt in (1, 2):
+        try:
+            content = base_prompt if attempt == 1 else (
+                base_prompt + "\n注意：只输出一个 JSON 对象，不要输出任何其它文字、解释或代码块标记。")
+            body = {
+                "model": cfg.get("model") or "deepseek-v4-flash-vision-exp",
+                "messages": [{"role": "user", "content": content}],
+                "max_tokens": 200,
+            }
+            headers = {"Authorization": f"Bearer {cfg.get('api_key', '')}",
+                       "Content-Type": "application/json"}
+            r = httpx.post(f"{(cfg.get('api_base') or 'https://api.deepseek.com').rstrip('/')}/chat/completions",
+                           json=body, headers=headers, timeout=20)
+            if r.status_code != 200:
+                raise RuntimeError(f"HTTP {r.status_code}")
+            text = (((r.json() or {}).get("choices") or [{}])[0]
+                    .get("message") or {}).get("content") or ""
+            m = re.search(r"\{.*\}", text, re.S)
+            if not m:
+                raise RuntimeError("响应无 JSON")
+            j = json.loads(m.group(0))
+            keep = bool(j.get("keep", True))
+            score = max(0, min(10, int(j.get("score", 5) or 5)))
+            reason = str(j.get("reason", ""))[:200]
+            return ("keep" if keep else "delete"), score, reason
+        except Exception as e:
+            _log.warning(f"经验评审第 {attempt} 次失败: {e}")
+    return "keep", 0, "评审失败自动保留（两次尝试均无有效 JSON）"
+
+
+def run_experience_audit():
+    """巡检一轮：逐条评审经验 → 写 experience_audit。
+
+    规则：
+      - 最新已 kept / deleted 的经验不再重复评审（人工拍板过的尊重）
+      - 评审 keep → 直接 action=kept；delete → action=pending（等人工确认）
+      - 绝不自动删除；无 api_key 配置时跳过并记日志
+    由 web_server 每日定时调度或 API 手动触发（后台线程）。
+    """
+    if _audit_state["running"]:
+        _log.info("经验巡检已在运行，跳过本次触发")
+        return
+    _audit_state["running"] = True
+    try:
+        if _flask_app is None:
+            return
+        with _flask_app.app_context():
+            _ensure_exp_table()
+            _ensure_audit_table()
+            cfg = _read_cfg()
+            if not cfg.get("api_key"):
+                _log.info("经验巡检跳过：未配置 API Key")
+                return
+            rows = db.session.execute(db.text(
+                "SELECT id, task_prompt, recipe, tool_seq, hits FROM agent_experience "
+                "ORDER BY id")).fetchall()
+            if not rows:
+                _log.info("经验巡检：经验库为空")
+                return
+            from datetime import datetime
+            now = datetime.now().strftime("%Y-%m-%d %H:%M")
+            reviewed = suggested = 0
+            for exp_id, prompt, recipe, tool_seq, hits in rows:
+                # 最新一次人工/评审结论：kept / deleted 的不再打扰
+                last = db.session.execute(db.text(
+                    "SELECT action FROM experience_audit WHERE exp_id=:e "
+                    "ORDER BY id DESC LIMIT 1"), {"e": exp_id}).scalar()
+                if last in ("kept", "deleted"):
+                    continue
+                verdict, score, reason = _review_one_exp(
+                    cfg, prompt, recipe, tool_seq, hits)
+                action = "kept" if verdict == "keep" else "pending"
+                db.session.execute(db.text(
+                    "INSERT INTO experience_audit"
+                    "(exp_id, verdict, score, reason, hits, action, audited_at) "
+                    "VALUES(:e, :v, :s, :r, :h, :a, :t)"),
+                    {"e": exp_id, "v": verdict, "s": score, "r": reason,
+                     "h": hits or 0, "a": action, "t": now})
+                reviewed += 1
+                suggested += 1 if action == "pending" else 0
+            db.session.commit()
+            summary = f"评审 {reviewed} 条，建议删除 {suggested} 条（待人工确认）"
+            _audit_state.update(last=now, last_summary=summary)
+            _log.info("经验巡检完成: %s", summary)
+    except Exception as e:
+        _log.warning(f"经验巡检异常: {e}")
+    finally:
+        _audit_state["running"] = False
+
+
+# ================== 经验库管理 API ==================
+@bp.route("/api/agent/experience")
+@admin_required
+def agent_experience_list():
+    """经验库列表（含最近一次巡检结论），供 AI 控制台「🧠 经验库」面板管理。"""
+    _ensure_exp_table()
+    _ensure_audit_table()
+    rows = db.session.execute(db.text(
+        "SELECT e.id, e.task_prompt, e.recipe, e.tool_seq, e.hits, e.created_at, "
+        "a.verdict, a.score, a.reason, a.action, a.audited_at "
+        "FROM agent_experience e LEFT JOIN experience_audit a ON a.id = "
+        "(SELECT id FROM experience_audit WHERE exp_id = e.id ORDER BY id DESC LIMIT 1) "
+        "ORDER BY e.id DESC")).fetchall()
+    exps = []
+    for r in rows:
+        (eid, task_prompt, recipe, tool_seq, hits, created_at,
+         verdict, score, reason, action, audited_at) = r
+        audit = None
+        if action:
+            audit = {"verdict": verdict, "score": round(score or 0, 1),
+                     "reason": reason, "action": action, "at": audited_at}
+        exps.append({"id": eid, "task_prompt": task_prompt or "",
+                     "recipe": recipe or "", "tool_seq": tool_seq or "",
+                     "hits": hits or 0, "created_at": created_at or "",
+                     "audit": audit})
+    return jsonify({"ok": True, "running": _audit_state["running"],
+                    "last": _audit_state["last"],
+                    "last_summary": _audit_state["last_summary"],
+                    "experiences": exps})
+
+
+@bp.route("/api/agent/experience/delete", methods=["POST"])
+@admin_required
+def agent_experience_delete():
+    """人工确认删除经验（真删；前端有二次确认，巡检绝不自动调它）。"""
+    data = request.json or {}
+    exp_id = int(data.get("id") or 0)
+    if exp_id <= 0:
+        return jsonify({"ok": False, "error": "缺少 id"}), 400
+    db.session.execute(db.text(
+        "DELETE FROM agent_experience WHERE id=:i"), {"i": exp_id})
+    db.session.execute(db.text(
+        "UPDATE experience_audit SET action='deleted' "
+        "WHERE exp_id=:i AND action='pending'"), {"i": exp_id})
+    db.session.commit()
+    _log.info("人工确认删除经验 #%d", exp_id)
+    return jsonify({"ok": True, "msg": f"经验 #{exp_id} 已删除"})
+
+
+@bp.route("/api/agent/experience/audit", methods=["POST"])
+@admin_required
+def agent_experience_audit_now():
+    """手动触发一轮经验巡检（后台线程；进行中返回 409）。"""
+    if _audit_state["running"]:
+        return jsonify({"ok": False, "error": "巡检正在进行中"}), 409
+    threading.Thread(target=run_experience_audit, daemon=True).start()
+    return jsonify({"ok": True, "msg": "巡检已启动，完成后刷新列表查看建议"})
+
+
+@bp.route("/api/agent/experience/keep", methods=["POST"])
+@admin_required
+def agent_experience_keep():
+    """人工保留：撤销建议删除（该条后续巡检不再重复建议）。"""
+    data = request.json or {}
+    exp_id = int(data.get("id") or 0)
+    if exp_id <= 0:
+        return jsonify({"ok": False, "error": "缺少 id"}), 400
+    db.session.execute(db.text(
+        "UPDATE experience_audit SET action='kept' "
+        "WHERE exp_id=:i AND action='pending'"), {"i": exp_id})
+    db.session.commit()
+    return jsonify({"ok": True, "msg": f"经验 #{exp_id} 已保留"})
+
+# ================== 历史会话（DeepSeek 式：多会话持久化） ==================
+# 会话 = 消息序列（JSON），一轮 run 的 user/assistant 文本完成后追加落库。
+# 单表 JSON 存储（每会话几十 KB 内，无需独立消息表）。
+_CONV_TABLE = """
+CREATE TABLE IF NOT EXISTS agent_conversation (
+  id VARCHAR(20) PRIMARY KEY,
+  title VARCHAR(100) DEFAULT '',
+  messages TEXT DEFAULT '[]',
+  created_at VARCHAR(20) DEFAULT '',
+  updated_at VARCHAR(20) DEFAULT '')"""
+
+
+def _ensure_conv_table():
+    try:
+        db.session.execute(db.text(_CONV_TABLE))
+        db.session.commit()
+    except Exception:
+        pass
+
+
+def _conv_msgs(conv_id):
+    """读会话消息列表 [{role, content}]。会话不存在返回 None。"""
+    try:
+        row = db.session.execute(db.text(
+            "SELECT messages FROM agent_conversation WHERE id=:i"),
+            {"i": conv_id}).fetchone()
+    except Exception:
+        return None
+    if not row:
+        return None
+    try:
+        return json.loads(row[0] or "[]")
+    except Exception:
+        return []
+
+
+def _conv_save_messages(conv_id, messages, title=None):
+    """整段写回会话消息 + 时间戳（尽力而为，失败不影响主流程）。"""
+    try:
+        from datetime import datetime
+        now = datetime.now().strftime("%Y-%m-%d %H:%M")
+        msgs_json = json.dumps(messages[-60:], ensure_ascii=False)
+        if title:
+            db.session.execute(db.text(
+                "UPDATE agent_conversation SET messages=:m, title=:t, "
+                "updated_at=:u WHERE id=:i"),
+                {"m": msgs_json, "t": title[:100], "u": now, "i": conv_id})
+        else:
+            db.session.execute(db.text(
+                "UPDATE agent_conversation SET messages=:m, updated_at=:u "
+                "WHERE id=:i"),
+                {"m": msgs_json, "u": now, "i": conv_id})
+        db.session.commit()
+        return True
+    except Exception as e:
+        _log.warning(f"会话保存失败: {e}")
+        return False
+
+
+@bp.route("/api/agent/conversations", methods=["GET"])
+@admin_required
+def agent_conversations_list():
+    """会话列表（按最近更新倒序）：{id, title, updated_at, count}。"""
+    _ensure_conv_table()
+    rows = db.session.execute(db.text(
+        "SELECT id, title, messages, updated_at FROM agent_conversation "
+        "ORDER BY updated_at DESC, created_at DESC")).fetchall()
+    out = []
+    for cid, title, messages, updated_at in rows:
+        try:
+            count = len(json.loads(messages or "[]")) // 2
+        except Exception:
+            count = 0
+        out.append({"id": cid, "title": title or "新会话",
+                    "updated_at": updated_at or "", "count": count})
+    return jsonify({"ok": True, "conversations": out})
+
+
+@bp.route("/api/agent/conversations", methods=["POST"])
+@admin_required
+def agent_conversations_create():
+    """新建会话（空消息）。返回 {id}。"""
+    _ensure_conv_table()
+    from datetime import datetime
+    cid = uuid.uuid4().hex[:10]
+    now = datetime.now().strftime("%Y-%m-%d %H:%M")
+    db.session.execute(db.text(
+        "INSERT INTO agent_conversation(id, title, messages, created_at, updated_at) "
+        "VALUES(:i, '', '[]', :c, :c)"), {"i": cid, "c": now})
+    db.session.commit()
+    return jsonify({"ok": True, "id": cid, "title": "新会话"})
+
+
+@bp.route("/api/agent/conversations/<conv_id>", methods=["GET"])
+@admin_required
+def agent_conversations_detail(conv_id):
+    """会话详情（全部消息文本）。"""
+    _ensure_conv_table()
+    msgs = _conv_msgs(conv_id)
+    if msgs is None:
+        return jsonify({"ok": False, "error": "会话不存在"}), 404
+    row = db.session.execute(db.text(
+        "SELECT title, created_at, updated_at FROM agent_conversation "
+        "WHERE id=:i"), {"i": conv_id}).fetchone()
+    return jsonify({"ok": True, "id": conv_id,
+                    "title": (row[0] if row else "") or "新会话",
+                    "messages": msgs,
+                    "created_at": row[1] if row else "",
+                    "updated_at": row[2] if row else ""})
+
+
+@bp.route("/api/agent/conversations/<conv_id>", methods=["DELETE"])
+@admin_required
+def agent_conversations_delete(conv_id):
+    """删除会话（消息一并删除，不可恢复）。"""
+    _ensure_conv_table()
+    db.session.execute(db.text(
+        "DELETE FROM agent_conversation WHERE id=:i"), {"i": conv_id})
+    db.session.commit()
+    _log.info(f"删除会话 {conv_id}")
+    return jsonify({"ok": True, "msg": "会话已删除"})
+
+
+@bp.route("/api/agent/conversations/<conv_id>/rename", methods=["POST"])
+@admin_required
+def agent_conversations_rename(conv_id):
+    """重命名会话。"""
+    data = request.json or {}
+    title = (data.get("title") or "").strip()[:100]
+    if not title:
+        return jsonify({"ok": False, "error": "标题不能为空"}), 400
+    _ensure_conv_table()
+    db.session.execute(db.text(
+        "UPDATE agent_conversation SET title=:t WHERE id=:i"),
+        {"t": title, "i": conv_id})
+    db.session.commit()
+    return jsonify({"ok": True, "msg": "已重命名"})
+
+
+# ================== 运行 ==================
+@bp.route("/api/agent/run", methods=["POST"])
+@admin_required
+def agent_run():
+    """启动 Agent：{prompt, serial?, conversation_id?}。运行中返回 409。"""
+    data = request.json or {}
+    prompt = (data.get("prompt") or "").strip()
+    if not prompt:
+        return jsonify({"ok": False, "error": "请输入指令"}), 400
+    serial = (data.get("serial") or "").strip()
+    conv_id = (data.get("conversation_id") or "").strip()
+    cfg = _read_cfg()
+    if not cfg.get("api_key"):
+        return jsonify({"ok": False, "error": "请先在配置区填写 API Key"}), 400
+    if not cfg.get("model"):
+        return jsonify({"ok": False, "error": "请先填写模型名"}), 400
+    if not serial and not (cfg.get("default_serial") or "").strip():
+        return jsonify({"ok": False, "error": "请先选择目标设备（AI 只操作你指定的设备）"}), 400
+    # 目标设备校验：必须在池、在线、且无任务运行（AI 不与任务抢设备；
+    # MCP 层另有 busy 锁兜底外部客户端）
+    if serial:
+        try:
+            from web import context
+            devs, err = context.mgr.get_status()
+            dev = next((x for x in (devs or []) if x.get("serial") == serial), None)
+            if err or dev is None:
+                return jsonify({"ok": False, "error": f"设备 {serial} 不在设备池"}), 400
+            if not dev.get("present"):
+                return jsonify({"ok": False, "error": f"设备 {serial} 当前离线，请稍后再试"}), 400
+            if dev.get("worker_status") in ("running", "connecting"):
+                return jsonify({"ok": False, "error":
+                    f"设备 {serial} 正在执行任务「{dev.get('task_job') or ''}」——"
+                    f"AI 不与任务抢设备，任务结束后才能操作（或在任务页先停止）"}), 409
+        except Exception:
+            pass  # 状态服务异常不阻塞（MCP busy 锁兜底）
+    # 会话校验：不存在则自动新建（标题=首条消息截断）
+    if conv_id:
+        _ensure_conv_table()
+        if _conv_msgs(conv_id) is None:
+            try:
+                from datetime import datetime as _dt2
+                now = _dt2.now().strftime("%Y-%m-%d %H:%M")
+                db.session.execute(db.text(
+                    "INSERT OR IGNORE INTO agent_conversation(id, messages, "
+                    "created_at, updated_at) VALUES(:i, '[]', :c, :c)"),
+                    {"i": conv_id, "c": now})
+                db.session.commit()
+            except Exception:
+                pass
+    with _lock:
+        if _run["state"] == "running":
+            return jsonify({"ok": False, "error":
+                f"已有 Agent 运行中（{_run.get('prompt', '')[:40]}…），"
+                f"请等待完成或先停止"}), 409
+        run_id = uuid.uuid4().hex[:8]
+        from datetime import datetime as _dt
+        _run.update(id=run_id, state="running", prompt=prompt,
+                    serial=serial, conv_id=conv_id,
+                    started=_dt.now().strftime("%H:%M:%S"),
+                    answer="", error="")
+        # history 保留（多轮上下文），由会话/「新建会话」管理
+        _queues[run_id] = queue.Queue()
+        _stop_events[run_id] = threading.Event()
+    _log.info(f"Agent 启动: {prompt[:60]} @ {serial or 'default'} conv={conv_id or '-'}")
+    threading.Thread(target=_agent_thread,
+                     args=(run_id, prompt, serial, cfg),
+                     daemon=True).start()
+    return jsonify({"ok": True, "run_id": run_id})
+@bp.route("/api/agent/config", methods=["GET"])
+@admin_required
+def agent_config_get():
+    """读 Agent 配置（key 打码返回）。"""
+    cfg = _read_cfg()
+    if cfg["api_key"]:
+        k = cfg["api_key"]
+        cfg["api_key_masked"] = k[:6] + "***" + k[-4:]
+    return jsonify({"ok": True, **cfg})
+
+
+@bp.route("/api/agent/config", methods=["POST"])
+@admin_required
+def agent_config_save():
+    """保存 Agent 配置：{api_base?, model?, api_key?, default_serial?} 部分更新。"""
+    data = request.json or {}
+    for key, meta_key in _CFG_KEYS.items():
+        if key in data and data[key] is not None:
+            _meta_put(meta_key, str(data[key]).strip())
+    db.session.commit()
+    return jsonify({"ok": True, "msg": "已保存"})
+
+
+@bp.route("/api/agent/run", methods=["GET"])
+@admin_required
+def agent_run_status():
+    """当前 Agent 运行状态（多窗口/页面刷新恢复用）：
+    idle/running/done + run_id + 最终答案 + 会话历史。
+
+    前端刷新后据此：渲染历史轮次、running 时重新订阅事件流（服务端队列
+    保留积压事件，重连后补发）、done 时展示最终答案。
+    """
+    with _lock:
+        hist = [{"role": h.get("role"), "content": (h.get("content") or "")[:4000]}
+                for h in (_run.get("history") or [])]
+        return jsonify({"ok": True,
+                        "state": _run.get("state", "idle"),
+                        "run_id": _run.get("id") or "",
+                        "prompt": _run.get("prompt", ""),
+                        "serial": _run.get("serial", ""),
+                        "started": _run.get("started", ""),
+                        "answer": (_run.get("answer") or "")[:4000],
+                        "error": (_run.get("error") or "")[:400],
+                        "history": hist[-16:]})
+
+
+@bp.route("/api/agent/devices")
+@admin_required
+def agent_devices():
+    """AI 可用设备列表：在线状态 + 是否有任务运行（前端选择器 busy 设备禁选）。
+
+    worker 状态实时（内存）；busy = 任务 running/connecting。
+    """
+    try:
+        from web import context
+        devs, err = context.mgr.get_status()
+    except Exception as e:
+        return jsonify({"ok": False, "error": str(e)[:120]}), 503
+    out = []
+    for d in (devs or []):
+        busy = d.get("worker_status") in ("running", "connecting")
+        out.append({"serial": d.get("serial"),
+                    "model": d.get("model") or "",
+                    "online": bool(d.get("present")),
+                    "busy": busy,
+                    "worker_status": d.get("worker_status") or "idle",
+                    "task_job": d.get("task_job") or ""})
+    return jsonify({"ok": True, "devices": out})
+
+
+@bp.route("/api/agent/stream")
+@admin_required
+def agent_stream():
+    """SSE 事件流（EventSource）：delta/step/done/error。"""
+    run_id = request.args.get("run_id", "")
+    with _lock:
+        if run_id != _run["id"]:
+            return jsonify({"ok": False, "error": "run_id 不存在"}), 404
+        q = _queues.get(run_id)
+
+    def gen():
+        while True:
+            try:
+                evt = q.get(timeout=15)
+            except queue.Empty:
+                yield ": keepalive\n\n"   # 心跳防超时
+                continue
+            if evt is None:
+                break
+            kind, payload = evt
+            yield f"event: {kind}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n"
+            if kind in ("done", "error"):
+                break
+
+    return Response(gen(), mimetype="text/event-stream",
+                    headers={"Cache-Control": "no-cache",
+                             "X-Accel-Buffering": "no"})
+
+
+@bp.route("/api/agent/stop", methods=["POST"])
+@admin_required
+def agent_stop():
+    """中断当前运行的 Agent（下一个检查点生效，通常在数秒内）。"""
+    with _lock:
+        if _run["state"] != "running":
+            return jsonify({"ok": False, "error": "当前没有运行中的任务"}), 400
+        evt = _stop_events.get(_run["id"])
+    if evt:
+        evt.set()
+        _log.info("用户请求中断 Agent")
+    return jsonify({"ok": True, "msg": "已请求停止"})
+
+
+@bp.route("/api/agent/clear", methods=["POST"])
+@admin_required
+def agent_clear():
+    """清空对话历史。"""
+    with _lock:
+        _run["history"] = []
+    return jsonify({"ok": True, "msg": "已清空"})
+
+
+def _shrink_image(b64, width=220, quality=50):
+    """截图降采样（SSE step 事件用，控制传输体积）。失败原样返回。"""
+    try:
+        from PIL import Image
+        img = Image.open(io.BytesIO(base64.b64decode(b64)))
+        if img.width > width:
+            img = img.resize((width, int(img.height * width / img.width)))
+        buf = io.BytesIO()
+        img.convert("RGB").save(buf, "JPEG", quality=quality)
+        return base64.b64encode(buf.getvalue()).decode()
+    except Exception:
+        return b64
+
+
+def _agent_thread(run_id, prompt, serial, cfg):
+    """后台线程：Agent 流式执行，事件推入队列供 SSE 消费。"""
+    q = _queues.get(run_id)
+    try:
+        # 平台进程 cwd=/app（含 mcp_agent 包），进程内 import
+        sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        from mcp_agent.agent import Agent
+
+        def on_delta(text, kind):
+            q.put(("delta", {"text": text, "kind": kind}))
+
+        tool_seq = []   # 本轮工具序列（经验提炼用）
+
+        def on_tool(step):
+            # args 保留对象（json.dumps 序列化）——前端要解析 serial 做画面跟随；
+            # 之前 str() 成 Python repr（单引号）导致前端 JSON.parse 失败、跟随失效
+            rec = {"tool": step.get("tool"),
+                   "args": step.get("args") or {}}
+            if step.get("image"):
+                rec["image"] = _shrink_image(step["image"])
+            q.put(("step", rec))
+            # 记录精简工具序列
+            try:
+                args = step.get("args") or {}
+                brief = {k: v for k, v in args.items() if k != "serial"}
+                tool_seq.append(f"{step.get('tool')}({str(brief)[:60]})")
+            except Exception:
+                pass
+
+        agent = Agent()
+        agent.s.api_base = cfg.get("api_base") or agent.s.api_base
+        agent.s.model = cfg.get("model") or agent.s.model
+        agent.s.api_key = cfg.get("api_key") or agent.s.api_key
+        agent.s.default_serial = cfg.get("default_serial") or agent.s.default_serial
+        try:
+            agent.s.max_steps = max(1, min(200, int(cfg.get("max_steps") or 40)))
+        except (TypeError, ValueError):
+            pass  # 非法值用默认 40
+
+        with _lock:
+            conv_id = _run.get("conv_id") or ""
+        # 历史来源：绑定了会话 → 从会话读（多轮上下文延续，DeepSeek 式）；
+        # 无会话（CLI/兼容）→ 用运行态 history
+        if conv_id:
+            # 后台线程需自行推 app context（与 _find_experiences 同思路）
+            with _flask_app.app_context():
+                msgs = _conv_msgs(conv_id)
+            history = [{"role": m.get("role"), "content": m.get("content", "")[:4000]}
+                       for m in (msgs or []) if m.get("role") in ("user", "assistant")]
+            history = history[-24:]
+            with _lock:
+                _run["history"] = list(history)
+        else:
+            with _lock:
+                history = list(_run.get("history") or [])
+        target = serial or cfg.get("default_serial") or ""
+        stop_evt = _stop_events.get(run_id)
+
+        # 经验检索：相似历史任务的操作配方注入 system（自进化记忆）
+        exp_ctx = _find_experiences(prompt)
+        if exp_ctx:
+            _log.info("命中历史经验，注入参考配方")
+            q.put(("step", {"tool": "🧠 经验记忆",
+                            "args": f"命中 {exp_ctx.count(chr(10) + '- ')} 条同类历史经验，已注入参考",
+                            "image": None}))
+
+        mcp_url = getattr(getattr(agent, "s", None), "mcp_url", "")
+
+        def _mcp_unreachable(err):
+            """MCP 客户端在工具服务不可达/返回非 MCP 响应时只抛含糊字样，
+            识别出来以便给用户明确指引（默认端口 8033）。"""
+            m = str(err).lower()
+            return any(k in m for k in (
+                "server returned an error response", "connecterror",
+                "connection refused", "all connection attempts failed",
+                "connection error", "server disconnected",
+                "network is unreachable", "connect timeout"))
+
+        async def _execute():
+            try:
+                await agent._load_tools()
+            except Exception as e:
+                if _mcp_unreachable(e):
+                    raise RuntimeError(
+                        f"MCP server(8033) 不可达：无法加载设备工具（{mcp_url}）。"
+                        f"请确认 MCP server 已启动（本机可运行 "
+                        f"python -m mcp_server.mcp_server，默认端口 8033）") from e
+                raise
+            try:
+                return await agent.run_stream(prompt, target,
+                                              history=history,
+                                              on_delta=on_delta, on_tool=on_tool,
+                                              should_stop=lambda: bool(
+                                                  stop_evt and stop_evt.is_set()),
+                                              extra_context=exp_ctx)
+            except Exception as e:
+                if _mcp_unreachable(e):
+                    raise RuntimeError(
+                        f"MCP server(8033) 连接中断：AI 无法继续操作设备（{mcp_url}）") from e
+                raise
+
+        # 整体超时保护：卡死时结束，释放单实例
+        answer = asyncio.run(asyncio.wait_for(_execute(), timeout=900))
+        with _lock:
+            _run["state"] = "done"
+            _run["answer"] = answer
+            # 追加本轮进历史（多轮连续性；上限 12 轮防 token 膨胀）
+            hist = _run.setdefault("history", [])
+            hist.append({"role": "user", "content": prompt[:2000]})
+            hist.append({"role": "assistant", "content": (answer or "")[:4000]})
+            _run["history"] = hist[-24:]
+        # 会话落库：本轮追加写回（新会话自动用首条消息作标题）。
+        # 后台线程 db 访问需 app context。
+        if conv_id and _flask_app is not None:
+            try:
+                with _flask_app.app_context():
+                    saved = list(_run["history"])
+                    title = None
+                    if not db.session.execute(db.text(
+                            "SELECT title FROM agent_conversation WHERE id=:i"),
+                            {"i": conv_id}).scalar():
+                        title = "".join(prompt.split())[:30] or "新会话"
+                    _conv_save_messages(conv_id, saved, title=title)
+                _log.info(f"会话已保存: {conv_id}（{len(saved)} 条消息）")
+            except Exception as e:
+                _log.warning(f"会话落库失败: {e}")
+
+        # 自进化：成功执行过工具则提炼配方写入经验。必须在 done 之前完成——
+        # done 发出后 SSE 关流，用户就看不到「已写入经验」的提示了。
+        # 提炼/保存失败静默（不阻塞、不影响结果），只在成功时推送 🧠 卡片。
+        if tool_seq:
+            try:
+                recipe = _distill_experience(cfg, prompt, " -> ".join(tool_seq))
+                if recipe and "配方" not in recipe[:50]:
+                    if _qualify_experience(prompt, recipe):
+                        if _save_experience(prompt, recipe, " -> ".join(tool_seq)):
+                            _log.info("经验已写入记忆库，随事件流提示")
+                            q.put(("step", {"tool": "🧠 经验记忆",
+                                            "args": "本轮操作已提炼为经验并写入记忆库"
+                                                    "（下次相似任务会自动参考）",
+                                            "image": None}))
+            except Exception as e:
+                _log.warning(f"经验保存异常: {e}")
+        q.put(("done", {"answer": answer}))
+    except Exception as e:
+        _log.warning(f"Agent 运行异常: {e}")
+        # 诊断：打印消息结构（tool_calls 与 tool 消息配对检查）
+        try:
+            roles = [m.get("role", "?") for m in agent.messages]
+            tcs = sum(1 for m in agent.messages
+                      if m.get("tool_calls") and isinstance(m.get("tool_calls"), list))
+            tools_msg = sum(1 for m in agent.messages if m.get("role") == "tool")
+            _log.warning(f"诊断 messages: {len(agent.messages)} 条 roles={roles[-8:]} "
+                         f"tool_calls消息={tcs} tool回应={tools_msg}")
+        except Exception:
+            pass
+        with _lock:
+            _run["state"] = "error"
+            _run["error"] = f"{type(e).__name__}: {str(e)[:200]}"
+        q.put(("error", {"message": str(e)[:200]}))
+    finally:
+        q.put(None)   # 关闭 SSE
+        _queues.pop(run_id, None)
+        _stop_events.pop(run_id, None)

web/devices_api.py

@@ -118,14 +118,16 @@ def api_devices_pool_refresh_models():
 @bp.route("/api/devices/discovery", methods=["GET"])
 @perm_required(PERM_DEVICES)
 def api_devices_discovery():
-    """发现状态 + 待连接列表（前端 10s 轮询一次请求）。"""
+    """发现状态 + 待连接列表 + 正式池断联设备（前端 10s 轮询一次请求）。"""
     try:
         status = device_discovery.get_status()
         pending = device_discovery.list_pending()
+        pool_offline = device_discovery.list_pool_offline()
     except Exception as e:
         _log.warning(f"discovery 状态获取失败: {e}")
         return jsonify({"ok": False, "error": str(e)[:120]}), 503
     status["pending"] = pending
+    status["pool_offline"] = pool_offline
     return jsonify({"ok": True, **status})
 
 
@@ -182,6 +184,38 @@ def api_devices_discovery_ignore():
     return jsonify({"ok": True, "msg": msg})
 
 
+@bp.route("/api/devices/discovery/reconnect", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_discovery_reconnect():
+    """手动立即重连正式池断联设备（后台 adb connect + 采型号）。
+
+    日常无需手动——发现线程每轮（默认 60s）自动重连断联设备；
+    本端点用于不想等下一轮扫描时立即拉起。
+    """
+    serial = (request.json or {}).get("serial", "").strip()
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    from core import device_pool
+    if serial not in device_pool.list_configured():
+        return jsonify({"ok": False, "error": "设备不在设备池中"}), 404
+
+    def _reconnect():
+        try:
+            if ":" in serial:
+                adb_connect(serial)
+            # 无论是否连上，采一次型号（模型失败静默）
+            try:
+                device_pool.refresh_model(serial)
+            except Exception:
+                pass
+        except Exception as e:
+            _log.warning(f"手动重连 {serial} 异常: {e}")
+
+    threading.Thread(target=_reconnect, daemon=True).start()
+    _log.info(f"设备池管理: 手动重连 {serial}")
+    return jsonify({"ok": True, "msg": "重连已启动（约 5-15 秒生效）"})
+
+
 @bp.route("/api/devices/discovery/settings", methods=["POST"])
 @perm_required(PERM_DEVICES)
 def api_devices_discovery_settings():

web/monitor.py

@@ -1,6 +1,7 @@
 """监控域 API：状态/运行控制/设备操作/远程看屏。"""
 import time
 import threading
+import re
 import subprocess
 import shlex
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -476,21 +477,116 @@ def api_screen_thumb():
         return jsonify({"ok": False, "error": str(e)}), 503
 
 
+def _snap_to_clickable(d, x, y):
+    """坐标吸附：找包含 (x,y) 的最小可点击元素，返回其 bounds 中心。
+
+    AI/触控给的坐标常偏离目标 20-50px（模型视觉定位误差）。dump 当前 UI 树后
+    遍历 clickable 节点：点击点落在哪个可点元素内就点它的中心——偏了也点得准；
+    取包含元素中面积最小者（最具体的那个）。点空白处（收键盘等）无包含元素则
+    原坐标返回。dump 失败也不阻塞，直接原坐标。返回 (cx, cy, snapped, label)。
+    """
+    try:
+        import xml.etree.ElementTree as ET
+        xml_str = d.dump_hierarchy()
+        best = None  # (area, cx, cy, label)
+        for node in ET.fromstring(xml_str).iter("node"):
+            if node.get("clickable") != "true":
+                continue
+            if node.get("enabled") == "false":
+                continue
+            m = re.match(r"\[(\d+),(\d+)\]\[(\d+),(\d+)\]", node.get("bounds", ""))
+            if not m:
+                continue
+            x1, y1, x2, y2 = map(int, m.groups())
+            if x1 <= x <= x2 and y1 <= y <= y2:
+                area = (x2 - x1) * (y2 - y1)
+                if best is None or area < best[0]:
+                    best = (area, (x1 + x2) // 2, (y1 + y2) // 2,
+                            (node.get("text") or node.get("content-desc") or "")[:40])
+        if best:
+            return best[1], best[2], True, best[3]
+    except Exception:
+        pass
+    return x, y, False, ""
+
+
 @bp.route("/api/screen/tap", methods=["POST"])
 @perm_required(PERM_DEVICES)
 def api_screen_tap():
-    """点击：{serial, x, y}（设备原生分辨率坐标）。"""
+    """点击：{serial, x, y, snap?}（设备原生分辨率坐标）。
+
+    snap=1 时先吸附：点落在可点击元素内则改点元素中心（MCP/AI 场景用，粗略
+    坐标也能点准）；大屏精确触控不带 snap 保持原行为。
+    返回 {ok, snapped, x, y, label}。
+    """
     data = request.json or {}
     serial, x, y = data.get("serial", ""), data.get("x"), data.get("y")
+    snap = int(data.get("snap", 0) or 0) == 1
     if not serial or x is None or y is None:
         return jsonify({"ok": False, "error": "缺少 serial/x/y"}), 400
     try:
-        _screen_get_device(serial).click(int(x), int(y))
-        return jsonify({"ok": True})
+        d = _screen_get_device(serial)
+        sx, sy = int(x), int(y)
+        label = ""
+        snapped = False
+        if snap:
+            sx, sy, snapped, label = _snap_to_clickable(d, sx, sy)
+        d.click(sx, sy)
+        return jsonify({"ok": True, "snapped": snapped, "x": sx, "y": sy,
+                        "label": label})
     except Exception as e:
         _screen_invalidate(serial)
         return jsonify({"ok": False, "error": f"点击失败: {e}"}), 503
 
+
+@bp.route("/api/screen/tap_text", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_screen_tap_text():
+    """按屏幕文字点击：{serial, text}——找到显示该文字的位置并点中心（子串匹配）。
+
+    两步：① UI 树 textContains/descriptionContains 命中 → 点元素中心（原生控件）；
+    ② 未命中 → 截图 OCR 找文字中心（WebView/图片/画布渲染的文字）。
+    返回 {ok, found, method: ui|ocr, matched, x, y}；found=false 表示屏幕确实
+    没有该文字（业务结果非设备错误）；OCR 不可用且 UI 未命中时也返回 found=false。
+    """
+    data = request.json or {}
+    serial = (data.get("serial") or "").strip()
+    text = (data.get("text") or "").strip()
+    if not serial or not text:
+        return jsonify({"ok": False, "error": "缺少 serial/text"}), 400
+    if len(text) > 100:
+        return jsonify({"ok": False, "error": "文字过长（≤100 字符）"}), 400
+    try:
+        d = _screen_get_device(serial)
+        # ① UI 树：text / content-desc 子串匹配（原生控件最快最准）
+        for kw in ({"textContains": text}, {"descriptionContains": text}):
+            try:
+                el = d(**kw)
+                if el.exists(timeout=1.5):
+                    # u2 版本差异：3.x 部分版本 bounds 是方法（el.bounds()）
+                    b = el.bounds() if callable(el.bounds) else el.bounds
+                    el.click()
+                    return jsonify({"ok": True, "found": True, "method": "ui",
+                                    "matched": text,
+                                    "x": (b[0] + b[2]) // 2, "y": (b[1] + b[3]) // 2})
+            except Exception:
+                continue
+        # ② OCR 兜底：截图找文字中心（UI 树没有的渲染文字）
+        img = d.screenshot()
+        if img is not None:
+            from core.ocr import find_on_screen
+            found, center, matched = find_on_screen(img, text)
+            if found:
+                d.click(*center)
+                return jsonify({"ok": True, "found": True, "method": "ocr",
+                                "matched": matched,
+                                "x": center[0], "y": center[1]})
+        return jsonify({"ok": True, "found": False, "method": "",
+                        "matched": "", "x": 0, "y": 0})
+    except Exception as e:
+        _screen_invalidate(serial)
+        return jsonify({"ok": False, "error": f"文字点击失败: {e}"}), 503
+
 @bp.route("/api/screen/swipe", methods=["POST"])
 @perm_required(PERM_DEVICES)
 def api_screen_swipe():
@@ -542,6 +638,25 @@ def api_screen_text():
         return jsonify({"ok": False, "error": f"输入失败: {e}"}), 503
 
 
+@bp.route("/api/screen/size")
+@perm_required(PERM_DEVICES)
+def api_screen_size():
+    """屏幕原生分辨率（只读，供 MCP 坐标换算：截图是缩放图，操作需原生坐标）。
+
+    返回 {ok, width, height}（如 1080x2400）；离线/不可达 → 503。
+    """
+    serial = request.args.get("serial", "")
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    try:
+        d = _screen_get_device(serial)
+        w, h = d.window_size()
+        return jsonify({"ok": True, "width": w, "height": h})
+    except Exception as e:
+        _screen_invalidate(serial)
+        return jsonify({"ok": False, "error": f"获取分辨率失败: {e}"}), 503
+
+
 # ================== API：应用管理（APK 上传/安装）==================
 
 def _current_focus_pkg(serial):

web/system_api.py

@@ -0,0 +1,78 @@
+"""系统管理 API（数据备份导出/导入）。仅管理员。
+
+导出：POST /api/system/backup/export  → 返回 zip 附件下载
+预览：POST /api/system/backup/preview → multipart 上传 zip/db，返回暂存 token + 表清单
+应用：POST /api/system/backup/apply    → 校验后落「重启生效」恢复任务
+
+导入涉及整库替换，只允许管理员操作（web/auth.admin_required）。
+"""
+from io import BytesIO
+
+from flask import Blueprint, jsonify, request, send_file
+
+from web.auth import admin_required
+from core import system_backup as sb
+from core.logger import get_logger
+
+_log = get_logger("web.system")
+
+bp = Blueprint("system", __name__)
+
+
+@bp.route("/api/system/backup/export", methods=["POST"])
+@admin_required
+def api_system_backup_export():
+    """生成导出 zip 并作为附件返回（含 users.db 快照 + manifest.json + 可选 apks）。"""
+    data = request.json or {}
+    include_apk = bool(data.get("include_apk", True))
+    try:
+        zip_path, fname, manifest = sb.create_export(include_apk=include_apk)
+    except sb.BackupError as e:
+        return jsonify({"ok": False, "error": str(e)}), 400
+    except Exception as e:
+        _log.error(f"导出备份失败: {e}")
+        return jsonify({"ok": False, "error": f"导出失败: {e}"}), 500
+
+    # 读入内存后立即删除磁盘文件再发送——Windows 上 send_file 流式发送时文件
+    # 句柄可能到 close 仍未释放，call_on_close 删不掉会残留；改 BytesIO 发送
+    # 则可确定性清理（导出为一次性下载，无需保留服务端副本）。
+    with open(zip_path, "rb") as f:
+        data = f.read()
+    sb.remove_quiet(zip_path)
+    resp = send_file(BytesIO(data), as_attachment=True, download_name=fname,
+                     mimetype="application/zip")
+    return resp
+
+
+@bp.route("/api/system/backup/preview", methods=["POST"])
+@admin_required
+def api_system_backup_preview():
+    """上传备份文件（zip/db）→ 暂存并校验 → 返回预览（表行数/schema/告警）。"""
+    f = request.files.get("file")
+    if not f or not f.filename:
+        return jsonify({"ok": False, "error": "未选择文件"}), 400
+    try:
+        token, info = sb.stage_upload(f)
+    except sb.BackupError as e:
+        return jsonify({"ok": False, "error": str(e)}), 400
+    except Exception as e:
+        _log.error(f"备份预览失败: {e}")
+        return jsonify({"ok": False, "error": f"解析文件失败: {e}"}), 500
+    _log.info(f"备份预览: {info.get('file_name')} "
+              f"(schema v{info.get('schema_version')}) token={token}")
+    return jsonify({"ok": True, "token": token, "preview": info})
+
+
+@bp.route("/api/system/backup/apply", methods=["POST"])
+@admin_required
+def api_system_backup_apply():
+    """确认应用导入：自动备份当前库 → 落待生效恢复任务（重启后生效）。"""
+    token = (request.json or {}).get("token", "")
+    try:
+        res = sb.apply_restore(str(token).strip())
+    except sb.BackupError as e:
+        return jsonify({"ok": False, "error": str(e)}), 400
+    except Exception as e:
+        _log.error(f"应用导入失败: {e}")
+        return jsonify({"ok": False, "error": f"应用导入失败: {e}"}), 500
+    return jsonify({"ok": True, **res})

web_server.py

@@ -40,6 +40,15 @@ app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
 login_manager = LoginManager(app)
 login_manager.login_view = "auth.login"  # 蓝图化后路由前缀 auth
 
+# 消费「待生效的备份恢复」：若存在 data/restore_pending/users.db，在 engine 首次
+# 打开数据库之前换位。导入必须重启生效——TaskManager 启动时读库入内存，
+# Windows 无法热替换正被持有的库文件。
+try:
+    from core.system_backup import consume_pending_restore
+    consume_pending_restore()
+except Exception as _e:
+    _log.error(f"消费备份恢复任务异常（不影响启动）: {_e}")
+
 # 先初始化数据库（含旧 JSON 迁移），再创建 TaskManager（需要 app context 读写 DB）
 init_db(app)
 # 设备池（本地清单 + adb 在线状态）：任务调度的数据源
@@ -57,6 +66,19 @@ from web.auth import _csrf_protect, _csrf_token
 context.init(mgr, apk_mgr, device_pool)
 register_blueprints(app)
 
+# 经验库每日 AI 巡检（凌晨 03:47）：评审标记疑似问题经验，删除只走人工确认。
+# 巡检线程在 run_experience_audit 内自建 app context，不依赖这里。
+try:
+    from apscheduler.schedulers.background import BackgroundScheduler
+    from apscheduler.triggers.cron import CronTrigger
+    from web.agent_api import run_experience_audit
+    _audit_sched = BackgroundScheduler(timezone="Asia/Shanghai")
+    _audit_sched.add_job(run_experience_audit, CronTrigger(hour=3, minute=47))
+    _audit_sched.start()
+    _log.info("经验库每日巡检已注册（03:47 Asia/Shanghai）")
+except Exception as e:
+    _log.warning(f"经验库巡检调度注册失败（不影响主服务）: {e}")
+
 
 @login_manager.user_loader
 def load_user(user_id):
@@ -71,14 +93,30 @@ _UIAUTO_PID_FILE = os.path.join(
 _uiauto_proc = None
 
 
+def _pid_cmdline_has(pid, keyword):
+    """校验 PID 对应的进程命令行含 keyword（容器重启后 PID 复用会误杀，
+    杀前必须确认目标真是残留的 uiautodev，而不是 MCP/web 等其它进程）。"""
+    try:
+        with open(f"/proc/{pid}/cmdline", "rb") as f:
+            cmd = f.read().replace(b"\x00", b" ").decode(errors="replace")
+        return keyword in cmd
+    except Exception:
+        return False
+
+
 def _kill_stale_uiauto():
-    """清理上次 web_server 残留的 uiautodev 进程（读取 PID 文件）。"""
+    """清理上次 web_server 残留的 uiautodev 进程（读取 PID 文件）。
+
+    容器重启后 PID namespace 重建、PID 会被复用（MCP/其它进程可能拿到与
+    uiauto.pid 相同的值），因此 kill 前先校验命令行确为 uiautodev，防止
+    误杀同容器内的 MCP server 等进程导致连锁崩溃。
+    """
     if not os.path.exists(_UIAUTO_PID_FILE):
         return
     try:
         with open(_UIAUTO_PID_FILE) as f:
             pid = int(f.read().strip())
-        if pid > 0 and pid != os.getpid():
+        if pid > 0 and pid != os.getpid() and _pid_cmdline_has(pid, "uiautodev"):
             try:
                 os.kill(pid, 0)  # 探测进程是否存活
                 os.kill(pid, 15)  # 终止残留