Upload 2 files

app.py

@@ -20,6 +20,7 @@ import requests
 from collections import defaultdict
 from datetime import datetime, timezone, timedelta
 from threading import Thread, Lock, Timer
+from concurrent.futures import ThreadPoolExecutor
 from urllib.parse import parse_qs, unquote
 from functools import wraps
 
@@ -34,7 +35,7 @@ from telebot import types, apihelper
 from telebot.apihelper import ApiTelegramException
 from flask import Flask, request, jsonify, send_file, Response
 from webdav4.client import Client as WebDAVClient
-from telethon import TelegramClient
+from telethon import TelegramClient, events
 from telethon.sessions import StringSession
 from telethon.extensions import html as tl_html
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
@@ -52,7 +53,7 @@ DAV_SUB_PATH = os.environ.get("WEBDAV_PATH", "").strip("/")
 FULL_WEBDAV_URL = f"{DAV_URL_BASE}/{DAV_SUB_PATH}/" if DAV_SUB_PATH else f"{DAV_URL_BASE}/"
 REMOTE_FILENAME = "tg_bot_data_v5.json"
 
-DATA = {"users": {}, "msg_map": {}, "backup_log": {}, "list_cache": {}, "admin_ids": [], "events": {}, "profiles": {}, "ch_meta": {}, "userbot": {}}
+DATA = {"users": {}, "msg_map": {}, "backup_log": {}, "list_cache": {}, "admin_ids": [], "events": {}, "profiles": {}, "ch_meta": {}, "userbot": {}, "ava_fp": {}, "ch_members": {}}
 data_lock = Lock()
 
 HTML_CACHE = {}
@@ -142,7 +143,10 @@ def load_data():
                 DATA["events"] = loaded_data.get("events", {})         # 🆕 持久化的事件流（每人最多 50 条）
                 DATA["profiles"] = loaded_data.get("profiles", {})     # 🆕 白名单成员的名字/头像缓存
                 DATA["ch_meta"] = loaded_data.get("ch_meta", {})       # 🆕 频道名称/头像缓存
+                DATA["ch_members"] = loaded_data.get("ch_members", {})  # 🆕 每个频道一份成员台账（实时累加）
+                DATA["ava_fp"] = loaded_data.get("ava_fp", {})       # 🆕 头像指纹台账（按来源分开记）
                 DATA["userbot"] = loaded_data.get("userbot", {})        # 🆕 /login 登录得到的 Session
+                DATA["userbot"].pop("joinlinks", None)   # 常驻邀请链接已下线：只用机器人自己那条主链接
             print(f"✅ 成功下载恢复云端数据！映射条数: {len(DATA['msg_map'])}")
         else:
             save_data(force=True)
@@ -564,6 +568,84 @@ def _avatar_key(raw):
 def _avatar_path(key):
     return os.path.join(AVATAR_DIR, f"{_avatar_key(key)}.jpg")
 
+# ===== 🆕 头像持久化：本地 avatar_cache 只是缓存，容器一重启就空了 ➜ 同一份镜像到 WebDAV =====
+# 以前重启后所有头像都要重新问 Telegram（get_file + 下文件，每个几百 ms 起，还常被掐 SSL），
+# 所以面板每次打开都是一排首字母。现在重启只从 WebDAV 拉回来，Telegram 只在换头像时才碰。
+DAV_AVATAR_DIR = "avatars"
+_dav_ava = {"dir": False}
+_dav_ava_miss = {}      # key ➜ 上次去云上找过但没有的时间（别反复问）
+
+def _dav_ava_remote(key):
+    return f"{DAV_AVATAR_DIR}/{_avatar_key(key)}.jpg"
+
+def _dav_ava_mkdir():
+    if _dav_ava["dir"]: return
+    try:
+        c = get_dav_client()
+        if not c.exists(DAV_AVATAR_DIR): c.mkdir(DAV_AVATAR_DIR)
+        _dav_ava["dir"] = True
+    except Exception as e: print(f"⚠️ WebDAV 头像目录: {str(e)[:60]}")
+
+def dav_ava_put(key):
+    """本地头像上云（后台跑，慢也挡不着任何请求）"""
+    p = _avatar_path(key)
+    if not os.path.exists(p): return
+    def work():
+        try:
+            _dav_ava_mkdir()
+            get_dav_client().upload_file(p, _dav_ava_remote(key), overwrite=True)
+            _dav_ava_miss.pop(_avatar_key(key), None)
+        except Exception as e: print(f"⚠️ 头像上云失败 {key}: {str(e)[:60]}")
+    Thread(target=work, daemon=True).start()
+
+def dav_ava_get(key):
+    """本地没有就从云上拉回来（重启后走这条，不必再问 Telegram）；返回本地是否已就位"""
+    k = _avatar_key(key); p = _avatar_path(k)
+    if os.path.exists(p): return True
+    if time.time() - float(_dav_ava_miss.get(k, 0) or 0) < 600: return False
+    try:
+        c = get_dav_client()
+        remote = _dav_ava_remote(k)
+        if not c.exists(remote):
+            _dav_ava_miss[k] = time.time(); return False
+        tmp = p + ".part"
+        c.download_file(remote, tmp)
+        os.replace(tmp, p)
+        return True
+    except Exception as e:
+        _dav_ava_miss[k] = time.time()
+        print(f"⚠️ 头像回源失败 {k}: {str(e)[:60]}")
+        return False
+
+def dav_ava_del(key):
+    """头像被本人删掉了：云上那份也一起清掉，别下次又拉回来"""
+    def work():
+        try: get_dav_client().remove(_dav_ava_remote(key))
+        except Exception: pass
+    _dav_ava_miss[_avatar_key(key)] = time.time()
+    Thread(target=work, daemon=True).start()
+
+def dav_ava_warm():
+    """启动预热：云上的头像一次性并行拉回本地，再把白名单成员的资料刷一遍
+    ➜ 用户打开面板时头像已经在本地，接口不用等 Telegram"""
+    got = 0
+    try:
+        c = get_dav_client()
+        if c.exists(DAV_AVATAR_DIR):
+            names = []
+            for it in (c.ls(DAV_AVATAR_DIR, detail=False) or []):
+                n = os.path.basename(str(it).rstrip("/"))
+                if n.endswith(".jpg"): names.append(n[:-4])
+            todo = [n for n in names if not os.path.exists(_avatar_path(n))][:300]
+            with ThreadPoolExecutor(max_workers=6) as ex:
+                got = sum(1 for r in ex.map(dav_ava_get, todo) if r)
+            print(f"🖼 头像预热：云上 {len(names)} 张，本地补齐 {got} 张")
+    except Exception as e: print(f"⚠️ 头像预热失败: {str(e)[:80]}")
+    for x in (sorted(ADMIN_IDS) + [str(y) for y in DATA.get("admin_ids", [])]):
+        try: refresh_profile_bg(x)
+        except Exception: pass
+    return got
+
 def _tl_run(coro, timeout=30):
     """在 Telethon 的事件循环里跑一个协程（同步线程调用用）"""
     if not TL_LOOP or not TL_CLIENT: return None
@@ -596,14 +678,55 @@ def _download_tg_file(file_path, tries=3, timeout=25):
             time.sleep(0.6 * (i + 1))
     raise RuntimeError(last)
 
+def _photo_uniq(photo):
+    """头像指纹：跟着下载用的那一档走（小图 160px，够 40px 的圆头像用，下载快得多）"""
+    return (getattr(photo, 'small_file_unique_id', None)
+            or getattr(photo, 'big_file_unique_id', None) or '')
+
+# ===== 🆕 头像指纹台账：换头像才下载，没换连 get_file 都不发 =====
+# 两个来源的指纹天生不一样（Bot API 是 file_unique_id，userbot 是 photo_id），混在一个字段里比
+# 就会「每次都像换了头像」➜ 白下一遍。所以按来源分开记，另外单独记 URL 版本号 v（只跟图片内容有关）。
+def _ava_led(key):
+    return DATA.setdefault("ava_fp", {}).setdefault(_avatar_key(key), {})
+
+def ava_have(key):
+    """图还在吗（本地没有会顺手从 WebDAV 拉回来）"""
+    return os.path.exists(_avatar_path(key)) or dav_ava_get(key)
+
+def ava_unchanged(key, src, fp, known=""):
+    """指纹对得上、图也还在 ➜ 返回沿用的 URL 版本号；返回空串代表要重新下"""
+    if not fp: return ""
+    led = _ava_led(key)
+    hit = str(fp) == str(led.get(src) or "")
+    if not hit and not (known and str(fp) == str(known)): return ""
+    if not ava_have(key): return ""
+    if not hit: return ava_mark(key, src, fp, known)   # 老数据只有一个 photo_uid：顺手补进台账
+    return str(led.get("v") or known or fp)
+
+def ava_mark(key, src, fp, ver=""):
+    """记下这次的来源指纹 + URL 版本号"""
+    led = _ava_led(key)
+    if fp: led[src] = str(fp)
+    led["v"] = str(ver or fp or "")
+    save_data_soon()
+    return led["v"]
+
+def ava_drop(key):
+    """头像被删了：本地、云上、台账一起清"""
+    try: os.remove(_avatar_path(key))
+    except Exception: pass
+    dav_ava_del(key)
+    DATA.setdefault("ava_fp", {}).pop(_avatar_key(key), None)
+
 def _save_avatar_from_bot(key, photo):
     """用 Bot API 下载头像；头像换了 file_unique_id 会变，据此判断要不要重新下载"""
-    fid = getattr(photo, 'big_file_id', None) or getattr(photo, 'small_file_id', None)
-    uniq = getattr(photo, 'big_file_unique_id', None) or getattr(photo, 'small_file_unique_id', None) or ''
+    fid = getattr(photo, 'small_file_id', None) or getattr(photo, 'big_file_id', None)
+    uniq = _photo_uniq(photo)
     if not fid: return ""
     f = bot.get_file(fid)
     raw = _download_tg_file(f.file_path, tries=2, timeout=15)
     with open(_avatar_path(key), 'wb') as fh: fh.write(raw)
+    dav_ava_put(key)      # 🆕 顺手镜像到 WebDAV，重启后就不用再下一遍
     # 版本号必须只跟「图片内容」有关：用时间戳会让 URL 每次都变，浏览器缓存直接失效
     return uniq or hashlib.md5(raw).hexdigest()[:12]
 
@@ -614,14 +737,19 @@ def _save_avatar_from_tl(key, entity):
     except Exception: return ""
     if not data: return ""
     with open(_avatar_path(key), 'wb') as fh: fh.write(data)
+    dav_ava_put(key)
     return hashlib.md5(data).hexdigest()[:12]
 
-def refresh_profile(uid, force=False, ttl=1800):
+def refresh_profile(uid, force=False, ttl=21600):
     """🆕 缓存白名单成员的名字与头像，换头像后自动跟着变"""
     uid = str(uid)
     prof = DATA.setdefault("profiles", {}).setdefault(uid, {})
     fresh = time.time() - float(prof.get("checked", 0) or 0) < ttl
-    if fresh and not force: return prof
+    # 本地图丢了（容器重启）就算还「新鲜」也得补：先从 WebDAV 回源，回得到就完事，不惊动 Telegram
+    if fresh and not force and prof.get("photo_uid") and not os.path.exists(_avatar_path(uid)):
+        if dav_ava_get(uid):
+            prof["has_avatar"] = True; return prof
+    elif fresh and not force: return prof
     prof["checked"] = int(time.time())
     chat = None
     try: chat = bot.get_chat(int(uid))
@@ -632,21 +760,23 @@ def refresh_profile(uid, force=False, ttl=1800):
             prof[k] = getattr(chat, attr, "") or ""
         photo = getattr(chat, "photo", None)
         if photo:
-            try:
-                uniq = getattr(photo, 'big_file_unique_id', '') or ''
-                if force or prof.get("photo_uid") != uniq or not os.path.exists(_avatar_path(uid)):
+            uniq = _photo_uniq(photo)
+            # 指纹没变就别碰 Telegram：本地有直接用，本地没有（重启掉了）就从 WebDAV 拉回来
+            keep = "" if force else ava_unchanged(uid, "b", uniq, prof.get("photo_uid", ""))
+            if keep: prof["photo_uid"] = keep
+            else:
+                try:
                     got = _save_avatar_from_bot(uid, photo)
-                    if got: prof["photo_uid"] = got
-            except Exception as e:
-                # 🆕 Bot 下载挂了（多半是 SSL/网络）→ 换 userbot 兜底，别让头像整轮丢掉
-                got = _save_avatar_from_tl(uid, int(uid)) if TL_CLIENT else ""
-                if got: prof["photo_uid"] = got
-                else: print(f"⚠️ 头像下载失败 {uid}: {e}")
+                    if got: prof["photo_uid"] = ava_mark(uid, "b", uniq, got)
+                except Exception as e:
+                    # 🆕 Bot 下载挂了（多半是 SSL/网络）→ 换 userbot 兜底，别让头像整轮丢掉
+                    got = _save_avatar_from_tl(uid, int(uid)) if TL_CLIENT else ""
+                    if got: prof["photo_uid"] = ava_mark(uid, "b", uniq, uniq or got)
+                    else: print(f"⚠️ 头像下载失败 {uid}: {e}")
         else:
             prof["photo_uid"] = ""
-            try: os.remove(_avatar_path(uid))
-            except Exception: pass
-    elif not os.path.exists(_avatar_path(uid)):
+            ava_drop(uid)
+    elif not os.path.exists(_avatar_path(uid)) and not dav_ava_get(uid):
         got = _save_avatar_from_tl(uid, int(uid)) if TL_CLIENT else ""
         if got: prof["photo_uid"] = got
     prof["has_avatar"] = os.path.exists(_avatar_path(uid))
@@ -659,7 +789,8 @@ def refresh_profile_bg(uid, force=False):
     """🆕 头像/名字一律后台刷：接口不能卡在 Telegram 的往返上（慢就慢在这里）"""
     uid = str(uid)
     prof = DATA.get("profiles", {}).get(uid) or {}
-    if not force and time.time() - float(prof.get("checked", 0) or 0) < 1800: return
+    missing = bool(prof.get("photo_uid")) and not os.path.exists(_avatar_path(uid))
+    if not force and not missing and time.time() - float(prof.get("checked", 0) or 0) < 21600: return
     if uid in _prof_busy: return
     _prof_busy.add(uid)
     def work():
@@ -677,12 +808,14 @@ def profile_view(uid):
         if not p.get(k) and u.get(k): p[k] = u[k]
     name = " ".join([x for x in (p.get("first_name"), p.get("last_name")) if x]).strip()
     return {"id": uid, "name": name, "username": p.get("username", ""),
+            # 有指纹就给地址：本地图万一丢了，/api/avatar 会自己去 WebDAV 拿，前端不用等下一轮
             "avatar": (f"/api/avatar/{uid}?v={p.get('photo_uid') or '0'}"
-                       if os.path.exists(_avatar_path(uid)) else ""),
+                       if (p.get("photo_uid") or os.path.exists(_avatar_path(uid))) else ""),
             "unknown": bool(p.get("err")) and not name}
 
-def resolve_chat_info(raw):
-    """🆕 认频道：给 ID / @用户名 / t.me 链接，返回真实名称、用户名、成员数和头像"""
+def resolve_chat_info(raw, known_uid=""):
+    """🆕 认频道：给 ID / @用户名 / t.me 链接，返回真实名称、用户名、成员数和头像
+    known_uid = 上次记下的头像指纹：指纹没变而且本地/WebDAV 有图，就完全不下载"""
     ident = normalize_chat(raw)
     if not ident: return {"ok": False, "msg": "请输入频道 ID、@用户名 或 t.me 链接"}
     target = peer(ident)
@@ -701,13 +834,24 @@ def resolve_chat_info(raw):
             except Exception: members = 0
         except Exception: members = 0
         photo = getattr(chat, "photo", None)
+        k0 = "c" + (cid or ident)
+        known = str(known_uid or (DATA.get("ch_meta", {}).get(str(cid)) or {}).get("photo_uid", "") or "")
         if photo:
-            try: photo_uid = _save_avatar_from_bot("c" + (cid or ident), photo) or ""
-            except Exception as e:
-                # 🆕 Bot 下载挂了 → 换 userbot 兜底
-                try: photo_uid = (_save_avatar_from_tl("c" + (cid or ident), target) if TL_CLIENT else "") or ""
-                except Exception: photo_uid = ""
-                if not photo_uid: print(f"⚠️ 频道头像下载失败: {e}")
+            uniq = _photo_uniq(photo)
+            photo_uid = ava_unchanged(k0, "b", uniq, known)   # 头像没换、图也在 ➜ 一个字节都不用下
+            if not photo_uid:
+                try: photo_uid = ava_mark(k0, "b", uniq, _save_avatar_from_bot(k0, photo))
+                except Exception as e:
+                    # 🆕 Bot 下载挂了 → 换 userbot 兜底（指纹照记 Bot 那��，下轮才对得上）
+                    got = ""
+                    try: got = (_save_avatar_from_tl(k0, target) if TL_CLIENT else "") or ""
+                    except Exception: got = ""
+                    if got: photo_uid = ava_mark(k0, "b", uniq, uniq or got)
+                    else:
+                        photo_uid = _ava_led(k0).get("v", "") if ava_have(k0) else ""   # 下不下来先用旧图顶着
+                        print(f"⚠️ 频道头像下载失败: {e}")
+        elif os.path.exists(_avatar_path(k0)) or _ava_led(k0).get("v"):
+            ava_drop(k0)          # 频道把头像删了：本地和云上那份也清掉
     else:
         # Bot 不在这个频道里，换 userbot 认
         try:
@@ -721,11 +865,23 @@ def resolve_chat_info(raw):
         raw_id = str(getattr(ent, "id", "") or "")
         cid = raw_id if raw_id.startswith("-") else f"-100{raw_id}"
         members = int(getattr(ent, "participants_count", 0) or 0)
-        photo_uid = _save_avatar_from_tl("c" + cid, ent)
+        k0 = "c" + cid
+        tphoto = getattr(ent, "photo", None)
+        uniq = str(getattr(tphoto, "photo_id", "") or "")
+        known = str(known_uid or (DATA.get("ch_meta", {}).get(str(cid)) or {}).get("photo_uid", "") or "")
+        if tphoto is None or "Empty" in type(tphoto).__name__:   # 没头像（ChatPhotoEmpty）
+            if os.path.exists(_avatar_path(k0)) or _ava_led(k0).get("v"): ava_drop(k0)
+        else:
+            photo_uid = ava_unchanged(k0, "t", uniq, known)   # photo_id 没变 ➜ 不下载
+            if not photo_uid:
+                got = _save_avatar_from_tl(k0, ent)
+                if got: photo_uid = ava_mark(k0, "t", uniq, uniq or got)   # 有 photo_id 就拿它当版本号
+                elif ava_have(k0): photo_uid = _ava_led(k0).get("v", "")
     key = "c" + (cid or ident)
     return {"ok": True, "id": cid or ident, "title": title or ident, "username": username,
-            "members": members,
-            "avatar": f"/api/avatar/{_avatar_key(key)}?v={photo_uid or '0'}" if os.path.exists(_avatar_path(key)) else ""}
+            "members": members, "photo_uid": photo_uid,
+            "avatar": (f"/api/avatar/{_avatar_key(key)}?v={photo_uid or '0'}"
+                       if (photo_uid or os.path.exists(_avatar_path(key))) else "")}
 
 def refresh_channel_meta(cid, ttl=21600, force=False):
     """🆕 地址簿频道的名称/头像缓存，默认 6 小时对一次（频道换头像会跟着变）"""
@@ -733,10 +889,11 @@ def refresh_channel_meta(cid, ttl=21600, force=False):
     meta = DATA.setdefault("ch_meta", {}).setdefault(cid, {})
     if not force and time.time() - float(meta.get("checked", 0) or 0) < ttl: return meta
     meta["checked"] = int(time.time())
-    info = resolve_chat_info(cid)
+    info = resolve_chat_info(cid, known_uid=meta.get("photo_uid", ""))
     if info.get("ok"):
         meta.update({"title": info.get("title", ""), "username": info.get("username", ""),
-                     "members": info.get("members", 0), "avatar": info.get("avatar", "")})
+                     "members": info.get("members", 0), "avatar": info.get("avatar", ""),
+                     "photo_uid": info.get("photo_uid", "")})
         meta.pop("err", None)
     else:
         meta["err"] = info.get("msg", "")[:80]
@@ -893,6 +1050,7 @@ try:
         types.BotCommand("session","🧩 Userbot 状态"),
         types.BotCommand("login","🔑 登录 Userbot（拿 Session）"),
         types.BotCommand("follow","🤝 让 Userbot 跟进频道"),
+        types.BotCommand("joinlink","🔗 借一条邀请链接把 Userbot 拉进去"),
         types.BotCommand("cleanlinks","🧹 清理邀请链接")
     ])
 except: pass
@@ -1100,6 +1258,49 @@ def cmd_follow(message):
         except Exception: bot.send_message(message.chat.id, "\n".join(lines), parse_mode="Markdown")
     Thread(target=work, daemon=True).start()
 
+# 🆕 一次性借链接入群：你把一条邀请链接给我，Userbot 就借它进去，不新建、不撤销、不删除、也不存
+@bot.message_handler(commands=['joinlink'])
+def cmd_joinlink(message):
+    uid = str(message.from_user.id)
+    if not is_admin(uid): return
+    args = (message.text or "").split()[1:]
+    usage = ("\n\n用法：`/joinlink <邀请链接>` —— 让 Userbot 借这条链接进去（一次性，不保存）\n"
+             "（把频道 → 邀请链接 里最上面那条主链接复制给我就行，我只是借用：不撤销、不删除、"
+             "面板里不会多出任何记录，只是那条链接的「已加入」会 +1。之后的自动跟进用机器人自己那条主链接）")
+    link = next((a for a in args if "t.me/" in a), "")
+    if not link:
+        return bot.reply_to(message, "🔗 把邀请链接一起发来。" + usage, parse_mode="Markdown")
+    m = bot.reply_to(message, "⏳ 正在用这条链接把 Userbot 拉进去…")
+    Thread(target=_joinlink_apply, args=(link, "", m), daemon=True).start()
+
+def _joinlink_apply(link, cid="", m=None):
+    """借用一条现成的邀请链接入群：频道 ID 从入群结果里自动认出来，所以哪个频道都不用你填"""
+    out = []
+    try:
+        gid, title = _tl_join_link(link)
+        key = cid or (f"-100{gid}" if gid else "")
+        out.append(f"✅ Userbot 已进入 **{title or key or '这个频道'}**（借用你给的链接，没新建也没撤销任何链接）")
+        if key:
+            ok, lines = userbot_follow_chat(key, title or key)   # 顺手把关联讨论组也进了
+            out += [l for l in lines if "讨论组" in l]
+    except Exception as e:
+        out.append(f"❌ 没进去：{_err_txt(e)}\n（链接失效就到频道里点「撤销链接」换一条新的主链接，再发给我）")
+    txt = "\n".join(out)
+    if m is None: return txt
+    try: bot.edit_message_text(txt, m.chat.id, m.message_id, parse_mode="Markdown")
+    except Exception: bot.send_message(m.chat.id, txt)
+
+# 🆕 白名单成员在私聊里直接甩一条 t.me/+xxx 邀请链接过来 ➜ 等同 /joinlink，不用记命令
+@bot.message_handler(func=lambda m: m.chat.type == 'private' and bool(m.text)
+                     and bool(_INVITE_RE.search(m.text)) and not (user_states.get(str(m.from_user.id)) or {}).get("step"))
+def handle_pasted_invite(message):
+    uid = str(message.from_user.id)
+    if not is_admin(uid): return
+    link = _INVITE_RE.search(message.text).group(0)
+    if not link.startswith("http"): link = "https://" + link
+    m = bot.reply_to(message, "🔗 收到一条邀请链接，正在让 Userbot 借它入群…")
+    Thread(target=_joinlink_apply, args=(link, "", m), daemon=True).start()
+
 # 🆕 清掉机器人开过的邀请链接（跟进失败时留下的那些）
 @bot.message_handler(commands=['cleanlinks'])
 def cmd_cleanlinks(message):
@@ -1110,8 +1311,12 @@ def cmd_cleanlinks(message):
     m = bot.reply_to(message, "🧹 正在清理邀请链接…")
     def work():
         out = []
-        done = revoke_tracked_links(cid or None)
-        out.append(f"记录在案的链接：撤销并删除 {done} 条")
+        done, left = revoke_tracked_links(cid or None)
+        nleft = sum(left.values())
+        out.append(f"记录在案的链接：撤销 {done} 条，其中删除成功 {done - nleft} 条")
+        if nleft:
+            out.append(f"有 {nleft} 条只撤销了、删不掉（这些频道 userbot 不是创建者）：\n"
+                       + "、".join(list(left.keys())[:10]))
         # 机器人自己没法列出邀请链接（Bot API 没这个方法），借 userbot 扫一遍
         bot_id = BOT_ID
         targets = [cid] if cid else list((DATA.get("users", {}).get(uid, {}).get("address_book") or {}).keys())
@@ -1125,7 +1330,8 @@ def cmd_cleanlinks(message):
         if swept: out.append(f"深度清扫（userbot 是创建者的频道）：又清掉 {swept} 条")
         if skipped:
             out.append(f"这 {len(skipped)} 个频道没权限列出链接（userbot 不是创建者）：\n" + "、".join(skipped[:10]))
-            out.append("这些只能手动删：频道 → 管理 → 邀请链接 → 找 userbot / userbot-1 那几条 → 撤销 → 删除")
+            out.append("这些只能你手动删：频道 → 管理 → 邀请链接 → 点「机器人」那一栏 → "
+                       "已撤销的链接（旧版本留下的叫 userbot / userbot-1）→ 长按删除")
         if not done and not swept and not skipped:
             out.append("没有需要清理的链接。")
         txt = "🧹 " + "\n".join(out)
@@ -1710,42 +1916,97 @@ def _member_backup_paths(uid, ch_id):
     remote_dir = f"members/{uid}"
     return remote_dir, f"{remote_dir}/{safe_channel}.csv", f"members_{safe_channel}.csv"
 
-# ===== 🆕 成员索引：首次全量建档，之后增量对比（与统计/扫标签的扫描逻辑一致） =====
+# ===== 🆕 成员台账：每个频道一份，实时进人就记，只增不删 =====
+# Telegram 一次最多只让看 200 个频道成员，所以「每次扫 200 就当成全部」会把老成员挤掉：
+# 200 人 + 1 个新订阅 ➜ 名单还是 200，最早那个被当成退出。
+# 现在名单是累加的台账（roster 只增不删，退出只打标记），200 只是「单次能看到多少」，不是上限。
 BJ_TZ = timezone(timedelta(hours=8))
-
-def _member_row(member, first_seen):
-    """紧凑存储：[username, first_name, last_name, is_bot, 首次出现时间]"""
-    return [member.username or '', member.first_name or '', member.last_name or '',
-            1 if member.bot else 0, int(first_seen)]
+MEMBER_VIEW_CAP = 200     # Telegram 频道成员列表的单次可见上限
+MEMBER_LOG_LIMIT = 800    # 每个频道保留的动态条数
+
+def ch_mem(cid):
+    """频道成员台账：{roster: {uid:[用户名,名,姓,是否bot,首次出现,退出时间]}, log: [...]}"""
+    m = DATA.setdefault("ch_members", {}).setdefault(str(cid), {})
+    m.setdefault("roster", {}); m.setdefault("log", [])
+    return m
+
+def _member_row(member, first_seen, left_at=0):
+    """紧凑存储：[username, first_name, last_name, is_bot, 首次出现时间, 退出时间(0=还在)]"""
+    is_bot = getattr(member, 'bot', None)
+    if is_bot is None: is_bot = getattr(member, 'is_bot', False)   # Telethon 是 .bot，Bot API 是 .is_bot
+    return [getattr(member, 'username', '') or '', getattr(member, 'first_name', '') or '',
+            getattr(member, 'last_name', '') or '', 1 if is_bot else 0,
+            int(first_seen), int(left_at)]
 
 def _member_display(row):
     nm = " ".join([x for x in (row[1], row[2]) if x]).strip()
     return nm or (f"@{row[0]}" if row[0] else "")
 
-def _diff_member_index(old_index, members, now_ts):
-    """对比新旧成员索引 ➜ (新索引, 新加入, 已退出)"""
-    old_index = old_index or {}
-    new_index = {}; joined = []; left = []
-    for member in members:
-        key = str(member.id)
-        prev = old_index.get(key)
-        first_seen = prev[4] if (prev and len(prev) > 4) else now_ts
-        row = _member_row(member, first_seen)
-        new_index[key] = row
-        if not prev: joined.append((key, row))
-    for key, row in old_index.items():
-        if key not in new_index: left.append((key, row))
-    return new_index, joined, left
+def mem_log(cid, key, row, act, src):
+    """频道自己的动态流：谁、什么时候、进还是退（持久化，运维面板直接看）"""
+    log = ch_mem(cid)["log"]
+    log.insert(0, {"t": int(time.time()), "u": str(key), "n": _member_display(row),
+                   "un": row[0], "a": act, "s": src})
+    del log[MEMBER_LOG_LIMIT:]
+
+def mem_stats(cid):
+    roster = ch_mem(cid)["roster"]
+    inside = sum(1 for r in roster.values() if not (len(r) > 5 and r[5]))
+    return {"total": len(roster), "in": inside, "left": len(roster) - inside}
+
+def mem_join(cid, member, ts=None, src="rt"):
+    """有人进来（实时事件或扫描发现）➜ 记进台账；返回 True 表示这是个新面孔"""
+    ts = int(ts or time.time()); key = str(getattr(member, 'id', member))
+    roster = ch_mem(cid)["roster"]; prev = roster.get(key)
+    if prev and not (len(prev) > 5 and prev[5]):
+        row = _member_row(member, prev[4], 0)
+        if any(row[:3]): roster[key] = row       # 只刷新资料，不算新人
+        return False
+    row = _member_row(member, prev[4] if prev else ts, 0)
+    roster[key] = row
+    mem_log(cid, key, row, "join", src)
+    return True
+
+def mem_left(cid, key, ts=None, src="rt"):
+    """有人退出 ➜ 只打退出标记，名单里仍然留着（历史可查）"""
+    ts = int(ts or time.time()); key = str(key)
+    roster = ch_mem(cid)["roster"]; row = roster.get(key)
+    if not row: return False
+    if len(row) < 6: row = list(row) + [0]
+    if row[5]: return False
+    row[5] = ts; roster[key] = row
+    mem_log(cid, key, row, "left", src)
+    return True
+
+def mem_seed(cid, members_index):
+    """把旧版监控任务里的 members_index 迁进台账（只做一次）"""
+    m = ch_mem(cid)
+    if m["roster"] or not members_index: return
+    for key, row in (members_index or {}).items():
+        r = list(row)
+        while len(r) < 5: r.append(0)
+        m["roster"][str(key)] = r[:5] + [0]
+    m["first_scan_at"] = min([r[4] for r in m["roster"].values()] or [int(time.time())])
+
+def mem_owners(cid):
+    """哪些用户在监控这个频道（备份和事件推给他们）"""
+    out = []
+    for uid, u in DATA.get("users", {}).items():
+        if any(str(x.get("channel_id")) == str(cid) for x in (u.get("member_monitors") or [])):
+            out.append(uid)
+    return out
 
 def _write_member_csv(members_index, path):
     with open(path, 'w', encoding='utf-8-sig', newline='') as f:
         writer = csv.writer(f)
-        writer.writerow(['UserID','Username','FirstName','LastName','IsBot','FirstSeen','BackupTime'])
+        writer.writerow(['UserID','Username','FirstName','LastName','IsBot','FirstSeen','Status','LeftAt','BackupTime'])
         backup_time = datetime.now(BJ_TZ).strftime("%Y-%m-%d %H:%M:%S")
+        fmt = lambda ts: datetime.fromtimestamp(int(ts), BJ_TZ).strftime("%Y-%m-%d %H:%M:%S") if ts else ''
         for uid_str, row in sorted(members_index.items(), key=lambda kv: kv[1][4]):
-            first_seen = datetime.fromtimestamp(row[4], BJ_TZ).strftime("%Y-%m-%d %H:%M:%S")
+            gone = row[5] if len(row) > 5 else 0
             writer.writerow([uid_str, f"@{row[0]}" if row[0] else '', row[1], row[2],
-                '是' if row[3] else '否', first_seen, backup_time])
+                '是' if row[3] else '否', fmt(row[4]), '已退出' if gone else '在册',
+                fmt(gone), backup_time])
 
 def _upload_member_backup(uid, ch_id, members_index):
     remote_dir, remote_path, filename = _member_backup_paths(uid, ch_id)
@@ -1779,6 +2040,79 @@ def send_member_backup(uid, ch_id):
         try: os.remove(temp_path)
         except OSError: pass
 
+# ===== 🆕 有人进来就备份：去抖上传，连着进 10 个人也只传一次 =====
+_mem_bk_lock = Lock()
+_mem_bk_timers = {}
+
+def mem_backup_now(cid):
+    """台账 ➜ CSV ➜ 每个监控者自己的 WebDAV 目录"""
+    cid = str(cid); roster = ch_mem(cid)["roster"]
+    if not roster: return
+    st = mem_stats(cid); now = int(time.time())
+    for uid in mem_owners(cid):
+        try:
+            path = _upload_member_backup(uid, cid, roster)
+            for mon in DATA["users"].get(uid, {}).get("member_monitors", []):
+                if str(mon.get("channel_id")) == cid:
+                    mon.update({"remote_path": path, "member_count": st["total"],
+                                "in_count": st["in"], "left_total": st["left"], "backup_at": now})
+        except Exception as e:
+            print(f"❌ [成员备份] {cid}: {str(e)[:80]}")
+    ch_mem(cid)["backup_at"] = now
+    save_data_soon()
+
+def mem_backup_soon(cid, delay=15):
+    cid = str(cid)
+    with _mem_bk_lock:
+        t = _mem_bk_timers.get(cid)
+        if t is not None and t.is_alive(): return
+        def run():
+            with _mem_bk_lock: _mem_bk_timers.pop(cid, None)
+            try: mem_backup_now(cid)
+            except Exception as e: print(f"❌ [成员备份] {cid}: {str(e)[:80]}")
+        t = Timer(delay, run); t.daemon = True; _mem_bk_timers[cid] = t; t.start()
+
+class _MemStub:
+    """只拿到 user_id 的场合（事件里查不到资料），先占个位，下次扫描补全"""
+    def __init__(self, i): self.id = i; self.username = ''; self.first_name = ''; self.last_name = ''; self.bot = False
+
+def mem_watch_keys():
+    """当前被监控的频道标识（原样，可能是 -100… 也可能是 @用户名）"""
+    out = set()
+    for u in DATA.get("users", {}).values():
+        for mon in (u.get("member_monitors") or []):
+            cid = str(mon.get("channel_id", "")).strip()
+            if cid: out.add(cid)
+    return out
+
+def mem_match(chat_id, username=""):
+    """这条事件属于哪些被监控频道"""
+    nid = str(chat_id or ""); hits = []
+    nid100 = nid if nid.startswith("-100") else (f"-100{nid.lstrip('-')}" if nid else "")
+    un = ("@" + str(username).lstrip("@")).lower() if username else ""
+    for key in mem_watch_keys():
+        k = normalize_chat(key) or key
+        if k in (nid, nid100) or (un and k.lower() == un): hits.append(key)
+    return hits
+
+def mem_apply(keys, users, joined, src="rt"):
+    """一批人进/退 ➜ 写台账 + 推事件 + 触发备份（Telethon 和 Bot API 两条实时通道共用）"""
+    now = int(time.time()); touched = False
+    for key in keys:
+        hit = [u for u in users if (mem_join(key, u, now, src) if joined
+               else mem_left(key, getattr(u, 'id', u), now, src))]
+        if not hit: continue
+        touched = True
+        led = ch_mem(key); led["rt_at"] = now; led["rt_src"] = src
+        st = mem_stats(key)
+        names = "、".join([_member_display(_member_row(u, 0)) or str(getattr(u, 'id', u)) for u in hit[:5]])
+        verb = f"➕ 新成员 {len(hit)}" if joined else f"➖ 退出 {len(hit)}"
+        for owner in mem_owners(key):
+            push_event(owner, "members_done", f"👥 {ch_label(owner, key)} {verb}：{names}"
+                       f"{'…' if len(hit) > 5 else ''} · 累计 {st['total']} / 在册 {st['in']}")
+        mem_backup_soon(key)      # 记录完就备份（去抖 15 秒，连着进人只传一次）
+    if touched: save_data_soon()
+    return touched
 
 def run_smart_backup_v2(latest_id, uid, src, tgt, wash=False):
     global TL_LOOP, TL_CLIENT
@@ -2183,35 +2517,50 @@ def start_telethon_worker():
     TL_CLIENT = TelegramClient(StringSession(user_session), int(api_id_str), api_hash)
 
     async def update_member_backups():
-        """成员监控：新建后立刻全量建档，之后每到检测时间做一次增量对比"""
+        """成员监控：首次全量建档，之后按间隔对一次账（实时事件是主力，这里只兜底核对）
+        关键：名单是累加台账，扫描看到 200 人（Telegram 上限）不代表只有 200 人，
+        没扫到的一律保留，只有在名单完整时才判定谁退出了。"""
         current_time = int(time.time()); data_changed = False
         for uid, u_data in DATA.get("users", {}).items():
             for monitor in u_data.get("member_monitors", []):
-                interval_sec = max(1, int(monitor.get("interval", 60))) * 60
-                members_index = monitor.get("members_index") or {}
-                is_first_run = not bool(members_index)
-                # 首次（新建后）立刻扫一次，之后按检测间隔增量扫描
-                if not is_first_run and current_time - int(monitor.get("last_run", 0)) < interval_sec: continue
                 ch_id = str(monitor.get("channel_id", "")).strip()
                 if not ch_id: continue
+                if monitor.get("members_index"):     # 旧版数据搬进频道台账，之后不再各存一份
+                    mem_seed(ch_id, monitor.pop("members_index")); data_changed = True
+                led = ch_mem(ch_id)
+                interval_sec = max(1, int(monitor.get("interval", 60))) * 60
+                is_first_run = not led["roster"]
+                if not is_first_run and current_time - int(monitor.get("last_run", 0)) < interval_sec: continue
                 try:
                     members = [member async for member in TL_CLIENT.iter_participants(peer(ch_id))]
-                    new_index, joined, left = _diff_member_index(members_index, members, current_time)
+                    joined = [m for m in members if mem_join(ch_id, m, current_time, "scan")]
+                    seen = {str(m.id) for m in members}
+                    capped = len(members) >= MEMBER_VIEW_CAP    # 只看得到 200 个 ➜ 名单不完整
+                    left = []
+                    if not capped:      # 名单完整时才敢判退出；被 200 截断时一个都不动
+                        for k, r in list(led["roster"].items()):
+                            if k not in seen and not (len(r) > 5 and r[5]) and mem_left(ch_id, k, current_time, "scan"):
+                                left.append(k)
+                    led.update({"scan_at":current_time, "capped":capped, "visible":len(members),
+                                "first_scan_at":led.get("first_scan_at") or current_time})
+                    st = mem_stats(ch_id)
                     changed = bool(joined or left) or is_first_run
                     remote_path = monitor.get("remote_path", "")
                     if changed:  # 只有名单发生变化才重新上传，避免无意义写入
-                        remote_path = await asyncio.to_thread(_upload_member_backup, uid, ch_id, new_index)
+                        remote_path = await asyncio.to_thread(_upload_member_backup, uid, ch_id, led["roster"])
                     monitor.pop("members", None)
-                    monitor.update({"last_run":current_time, "member_count":len(new_index),
-                        "members_index":new_index, "remote_path":remote_path, "last_error":"",
+                    monitor.update({"last_run":current_time, "member_count":st["total"], "in_count":st["in"],
+                        "left_total":st["left"], "remote_path":remote_path, "last_error":"", "capped":capped,
                         "joined_count":len(joined), "left_count":len(left),
                         "first_scan_at":monitor.get("first_scan_at") or current_time})
                     if is_first_run:
-                        push_event(uid, "members_done", f"✅ {ch_id} 首次建档：{len(new_index)} 人")
+                        tip = f"（Telegram 单次最多可见 {MEMBER_VIEW_CAP} 人，之后有人进来实时累加）" if capped else ""
+                        push_event(uid, "members_done", f"✅ {ch_label(uid, ch_id)} 首次建档：{st['total']} 人{tip}")
                     elif changed:
-                        names = "、".join([_member_display(r) for _, r in joined[:5]])
+                        names = "、".join([_member_display(_member_row(m, 0)) for m in joined[:5]])
                         detail = f"（{names}{'…' if len(joined) > 5 else ''}）" if names else ""
-                        push_event(uid, "members_done", f"👥 {ch_id} 新增 {len(joined)} / 退出 {len(left)}{detail}")
+                        push_event(uid, "members_done",
+                                   f"👥 {ch_label(uid, ch_id)} 对账：新增 {len(joined)} / 退出 {len(left)}{detail} · 累计 {st['total']}")
                 except Exception as e:
                     monitor.update({"last_run":current_time, "last_error":str(e)})
                     print(f"❌ [成员监控] {ch_id}: {e}")
@@ -2485,6 +2834,25 @@ def start_telethon_worker():
         return
     try: print(f"👤 Userbot: {TL_LOOP.run_until_complete(TL_CLIENT.get_me()).first_name}")
     except Exception: pass
+    # ===== 🆕 实时成员监控：有人进/退，Telegram 一推过来就记账 + 备份，不等下一轮扫描 =====
+    @TL_CLIENT.on(events.ChatAction)
+    async def _member_realtime(ev):
+        try:
+            joined = bool(getattr(ev, "user_joined", False) or getattr(ev, "user_added", False))
+            gone = bool(getattr(ev, "user_left", False) or getattr(ev, "user_kicked", False))
+            if not (joined or gone): return
+            uname = getattr(getattr(ev, "chat", None), "username", "") or ""
+            keys = mem_match(getattr(ev, "chat_id", None), uname)
+            if not keys: return
+            try: users = list(await ev.get_users() or [])
+            except Exception: users = []
+            if not users:      # 资料查不到也不能丢事件，先按 ID 记上
+                users = [_MemStub(i) for i in (getattr(ev, "user_ids", None) or [])]
+            if not users: return
+            mem_apply(keys, users, joined, "rt")
+        except Exception as e:
+            print(f"❌ [实时成员] {str(e)[:100]}")
+
     scheduler = AsyncIOScheduler(event_loop=TL_LOOP)
     scheduler.add_job(update_channel_msg, 'interval', seconds=10)
     scheduler.add_job(update_member_backups, 'interval', seconds=10)
@@ -2733,6 +3101,25 @@ def _tl_linked_chat(target):
     try: return _tl_run(_go(), timeout=60)
     except Exception: return None
 
+def _tl_join_link(url):
+    """🆕 直接用一条现成的邀请链接把 userbot 拉进去，返回 (频道内部ID, 标题)
+    一次性用法：只借这一次，不存起来（自动跟进只认机器人自己那条主链接）"""
+    from telethon.tl.functions.messages import ImportChatInviteRequest, CheckChatInviteRequest
+    if not TL_CLIENT: raise RuntimeError("Userbot 没在跑，先 /login")
+    m = _INVITE_RE.search(url or "")
+    if not m: raise ValueError("这不是 t.me/+xxxx 形式的邀请链接")
+    h = m.group(1)
+    async def _go():
+        try: res = await TL_CLIENT(ImportChatInviteRequest(h))
+        except Exception as e:
+            if type(e).__name__ != "UserAlreadyParticipantError": raise
+            res = await TL_CLIENT(CheckChatInviteRequest(h))
+        ch = None
+        for c in (getattr(res, "chats", None) or []): ch = c; break
+        if ch is None: ch = getattr(res, "chat", None)
+        return (int(getattr(ch, "id", 0) or 0), getattr(ch, "title", "") or "") if ch is not None else (0, "")
+    return _tl_run(_go(), timeout=300)
+
 def _track_link(cid, url):
     """🆕 记下我们开过的每条邀请链接：万一没当场收回，之后还能一键清掉"""
     store = DATA.setdefault("userbot", {}).setdefault("links", {}).setdefault(str(cid), [])
@@ -2746,15 +3133,18 @@ def _untrack_link(cid, url):
         save_data_soon()
 
 def revoke_tracked_links(cid=None):
-    """把记录在案的邀请链接全部撤销 + 删除（cid 为空 = 所有频道），返回处理条数"""
+    """把记录在案的邀请链接全部撤销 + 删除（cid 为空 = 所有频道）
+    返回 (处理条数, 删不掉的 {频道: 条数})"""
     store = DATA.setdefault("userbot", {}).setdefault("links", {})
-    n = 0
+    n = 0; left = {}
     for key in ([str(cid)] if cid else list(store.keys())):
         urls = list(store.get(key) or [])
         if not urls: continue
-        _purge_links(key, urls); n += len(urls)
+        n += len(urls)
+        k = _purge_links(key, urls, quiet=True)
+        if k: left[key] = k
     save_data()
-    return n
+    return n, left
 
 def tl_sweep_bot_links(cid, bot_id):
     """userbot 是频道创建者时，能把机器人建过的邀请链接列出来，逐条撤销并彻底删除
@@ -2768,6 +3158,12 @@ def tl_sweep_bot_links(cid, bot_id):
         for inv in (getattr(res, "invites", []) or []):
             link = getattr(inv, "link", "")
             if not link: continue
+            if getattr(inv, "permanent", False):
+                # ⚠️ 绝不能撤销机器人的「主链接」：撤了 Telegram 会立刻另发一条新的（等于白撤），
+                # 而 Bot API 的 getChat 还会继续吐那条已废的 hash ➜ 下次复用主链接必然
+                # InviteHashExpired，只好再建新链接，痕迹就是这么攒出来的
+                print(f"↩️ 跳过机器人主链接（不能撤）：{cid}")
+                continue
             try: await TL_CLIENT(EditExportedChatInviteRequest(peer=peer(cid), link=link, revoked=True))
             except Exception: pass
             try: await TL_CLIENT(DeleteExportedChatInviteRequest(peer=peer(cid), link=link))
@@ -2779,46 +3175,77 @@ def tl_sweep_bot_links(cid, bot_id):
     try: return _tl_run(_go(), timeout=90), ""
     except Exception as e: return 0, _err_txt(e)
 
-def _purge_links(cid, urls):
-    """🆕 撤销 + 彻底删除我们开过的邀请链接，让频道的邀请链接面板看不出痕迹
-    （Bot API 只能「撤销」，撤销后还会留在「已撤销的链接」里；真正删除得用 userbot）"""
+def _purge_links(cid, urls, quiet=False):
+    """🆕 撤销 + 尽量彻底删除我们开过的邀请链接
+    Bot API 只能「撤销」，撤销完还留在频道的「已撤销的链接」里；真正删除只能靠 userbot，
+    而 userbot 只删得掉自己建的、或它是频道创建者时才删得掉机器人建的。
+    删不掉就如实说 + 继续记账（之后 /cleanlinks 还能再试），返回没删掉的条数（quiet=True）
+    或一句给主人看的说明（默认）"""
     urls = [u for u in (urls or []) if u]
-    if not urls: return
+    if not urls: return 0 if quiet else ""
+    try:      # 保险：主链接绝不能进这个函数（撤了它 getChat 就会一直吐死 hash）
+        main = getattr(bot.get_chat(peer(cid)), "invite_link", "") or ""
+        if main and main in urls:
+            urls = [u for u in urls if u != main]; _untrack_link(cid, main)
+            print(f"↩️ 跳过主链接，不撤销：{cid}")
+        if not urls: return 0 if quiet else ""
+    except Exception: pass
     for u in urls:
         try: bot.revoke_chat_invite_link(peer(cid), u)
         except Exception as e: print(f"⚠️ 撤销链接失败 {cid}: {str(e)[:70]}")
-    if not TL_CLIENT: return
-    from telethon.tl.functions.messages import (DeleteExportedChatInviteRequest,
-        DeleteRevokedExportedChatInvitesRequest)
-    async def _go():
-        for u in urls:
-            try: await TL_CLIENT(DeleteExportedChatInviteRequest(peer=peer(cid), link=u))
-            except Exception: pass
-        if BOT_ID:      # 一次把机器人名下所有已撤销的链接清空（userbot 是创建者时才有权限）
-            try: await TL_CLIENT(DeleteRevokedExportedChatInvitesRequest(peer=peer(cid), admin_id=BOT_ID))
-            except Exception: pass
-    try: _tl_run(_go(), timeout=60)
-    except Exception as e: print(f"⚠️ 删除链接失败 {cid}: {str(e)[:70]}")
-    for u in urls: _untrack_link(cid, u)
+    gone = []
+    if TL_CLIENT:
+        from telethon.tl.functions.messages import (DeleteExportedChatInviteRequest,
+            DeleteRevokedExportedChatInvitesRequest)
+        async def _go():
+            out = []
+            for u in urls:
+                try:
+                    await TL_CLIENT(DeleteExportedChatInviteRequest(peer=peer(cid), link=u)); out.append(u)
+                except Exception as e: print(f"⚠️ 删链接失败 {cid} …{u[-8:]}: {type(e).__name__}")
+            if BOT_ID and len(out) < len(urls):
+                # 一次把机器人名下所有已撤销的链接清空（userbot 是创建者时才有这个权限）
+                try:
+                    await TL_CLIENT(DeleteRevokedExportedChatInvitesRequest(peer=peer(cid), admin_id=BOT_ID))
+                    out = list(urls)
+                except Exception as e: print(f"⚠️ 清空已撤销链接失败 {cid}: {type(e).__name__}")
+            return out
+        try: gone = _tl_run(_go(), timeout=60) or []
+        except Exception as e: print(f"⚠️ 删除链接失败 {cid}: {str(e)[:70]}")
+    left = [u for u in urls if u not in gone]
+    for u in gone: _untrack_link(cid, u)      # 删不掉的留在账上，/cleanlinks 还能再试
+    if quiet: return len(left)
+    if not left: return ""
+    return (f"🧹 临时邀请链接已撤销（还有 {len(left)} 条删不掉，留在频道『已撤销的链接』里）\n"
+            f"（userbot 不是这个频道的创建者，只有你删得掉：频道 → 管理 → 邀请链接 → "
+            f"点机器人那一栏 → 已撤销的链接 → 长按删除；或者发 /cleanlinks 让我再试一次）")
 
 def _bot_invite_links(cid, chat=None, fresh=False):
     """返回 (候选链接, 其中我们新建的, 失败原因)
-    ① 先用频道现成的主邀请链接 —— 一条新链接都不建，事后也没东西要清，等于没发生过
-    ② 现成的没有、或它被判失效后重试（fresh=True）才自己开
-       （普通链接优先，member_limit=1 的限量链接常被判 InviteHashExpired）
-       自己开的会记账，进去后立刻撤销 + 删除"""
+    ⓪ 首选：机器人自己现成的主邀请链接 —— 一条新链接都不建，事后也没东西要清
+    ① 现成的被判失效后重试（fresh=True）：先「原地重开机器人自己的主链接」
+       —— exportChatInviteLink 是替换而不是新增，面板里还是机器人那一条，
+       不会多出「userbot」这种一眼看出是机器人干的记录，事后也不用撤销
+    ② 连主链接都开不出来，才建额外链接（不起名字、先不限量：member_limit=1 常被判
+       InviteHashExpired）；只有这一类会记账，进去后立刻撤销 + 尽量删除"""
     links, created, why = [], [], ""
     if not fresh:
-        try:
+        try:      # ⓪ 机器人自己那条现成的主链接：借用，事后什么都不用清
             u = getattr(chat if chat is not None else bot.get_chat(cid), "invite_link", "") or ""
+            if u and u not in links: links.append(u)
+        except Exception as e: why = str(e)[:140]
+    else:
+        try:      # 原地换一条全新的主链接（旧的那条本来就已经被判失效了）
+            u = bot.export_chat_invite_link(cid) or ""
             if u: links.append(u)
         except Exception as e: why = str(e)[:140]
     if not links:
-        for kw in (dict(name="userbot"), dict(name="userbot-1", member_limit=1)):
+        for kw in (dict(), dict(member_limit=1)):
             try:
                 u = getattr(bot.create_chat_invite_link(cid, **kw), "invite_link", "") or ""
                 if u and u not in links:
                     links.append(u); created.append(u); _track_link(cid, u)
+                if links: break      # 一条够用了，别多留痕迹
             except Exception as e:
                 why = why or str(e)[:140]
     if links: return links, created, ""
@@ -2891,9 +3318,10 @@ def userbot_follow_chat(cid, title="", with_linked=True):
         joined = False; how = ""
         if not uname and not invites:
             lines.append(f"❌ 拿不到 **{label}** 的邀请链接：{invite_err or '未知原因'}\n"
-                         f"（私密频道只能靠邀请链接把 Userbot 拉进去。去频道 → 管理员 → 机器人，"
-                         f"打开『添加成员/邀请用户』，然后发 /follow {cid} 重试；"
-                         f"或者你自己把 {_userbot_name()} 拉进这个频道）")
+                         f"（私密频道只能靠邀请链接把 Userbot 拉进去。最省事的办法：把频道 → 邀请链接 "
+                         f"最上面那条主链接复制过来，发 `/joinlink <链接>` —— 我借用一下，不撤销也不删除。"
+                         f"或者去频道 → 管理员 → 机器人，打开『添加成员/邀请用户』后发 /follow {cid} 重试；"
+                         f"也可以你自己把 {_userbot_name()} 拉进这个频道）")
             return False, lines
         entity = ("@" + uname) if uname else target
         try:
@@ -2933,13 +3361,16 @@ def userbot_follow_chat(cid, title="", with_linked=True):
                     except Exception: pass
                     tail = ("\n" + "\n".join(diag)) if diag else ""
                     lines.append(f"❌ Userbot 加入 **{label}** 失败：{_err_txt(e)}{hint}{tail}\n"
-                                 f"（顶不住就手动把 {_userbot_name()} 拉进这个频道，效果一样）")
+                                 f"（最省事：把频道那条主链接复制过来发 `/joinlink <链接>`，我借用它进去、不撤不删；"
+                                 f"或者手动把 {_userbot_name()} 拉进这个频道，效果一样）")
             # 超时不代表没进去，再确认一次
             if not joined and _tl_joined(target):
                 lines[-1] = f"✅ Userbot 已在 **{label}** 里（前一步只是响应超时）"; joined = True
         finally:
             # 只清我们自己开的（现成的主链接绝不能动）；等审批的先留着，撤销会连带取消申请
-            if created and "申请" not in how: _purge_links(cid, created)
+            if created and "申请" not in how:
+                note = _purge_links(cid, created)
+                if note: lines.append(note)
         if not joined: return False, lines
     # 关联讨论组：榜单统计要读评论，私密讨论组不进就读不到
     if with_linked:
@@ -3029,6 +3460,27 @@ if hasattr(bot, "my_chat_member_handler"):
 else:
     print("⚠️ 当前 pyTelegramBotAPI 版本不支持 my_chat_member，userbot 自动跟进只能用 /follow 手动触发")
 
+# 🆕 第二条实时通道：机器人自己是管理员时，Bot API 也会推成员进出
+# （userbot 不是管理员就收不到 Telethon 那条，两条通道同时开，谁先到算谁，台账里天然去重）
+if hasattr(bot, "chat_member_handler"):
+    @bot.chat_member_handler(func=lambda u: True)
+    def on_chat_member(upd):
+        try:
+            chat = getattr(upd, "chat", None)
+            keys = mem_match(getattr(chat, "id", ""), getattr(chat, "username", "") or "")
+            if not keys: return
+            user = getattr(getattr(upd, "new_chat_member", None), "user", None)
+            if not user: return
+            inside = lambda cm: (getattr(cm, "status", "") in ("member", "administrator", "creator")
+                                 or (getattr(cm, "status", "") == "restricted" and getattr(cm, "is_member", False)))
+            was, now_in = inside(getattr(upd, "old_chat_member", None)), inside(getattr(upd, "new_chat_member", None))
+            if was == now_in: return          # 只是改权限/改称号，不是进出
+            mem_apply(keys, [user], now_in, "bot")
+        except Exception as e:
+            print(f"❌ [实时成员/Bot] {str(e)[:100]}")
+else:
+    print("⚠️ 当前 pyTelegramBotAPI 版本不支持 chat_member，实时成员监控只走 userbot 那条")
+
 # 🆕 给所有「私聊指令 / 内联按钮」处理器套一层白名单检查（频道消息处理器不在此列）
 def guard_bot_handlers():
     def wrap(fn, kind):
@@ -3061,10 +3513,12 @@ def guard_bot_handlers():
 @app.route('/api/avatar/<key>')
 def api_avatar(key):
     path = _avatar_path(key)
-    if not os.path.exists(path): return ("", 404)
+    if not os.path.exists(path) and not dav_ava_get(key):    # 🆕 本地没有先去 WebDAV 拿，别回 404
+        return ("", 404)
     st = os.stat(path)
     # 🆕 URL 自带头像指纹，同一个地址的内容永远不变 ➜ immutable + ETag，浏览器第二次起直接用本地缓存
-    etag = f'W/"{int(st.st_mtime)}-{st.st_size}"'
+    # ETag 只跟指纹+大小有关（不用 mtime）：容器重启后从 WebDAV 拉回来的同一张图，ETag 不变 ➜ 继续 304
+    etag = f'W/"{request.args.get("v", "0")}-{st.st_size}"'
     if request.headers.get("If-None-Match") == etag:
         resp = Response(status=304)
     else:
@@ -3084,7 +3538,8 @@ def api_resolve(uid):
         meta = DATA.setdefault("ch_meta", {}).setdefault(str(info["id"]), {})
         meta.update({"checked": int(time.time()), "title": info.get("title", ""),
                      "username": info.get("username", ""), "members": info.get("members", 0),
-                     "avatar": info.get("avatar", "")})
+                     "avatar": info.get("avatar", ""),
+                     "photo_uid": info.get("photo_uid", "")})   # 🆕 指纹要存，下次才知道头像没换
         save_data_soon()
     return jsonify(info)
 
@@ -3130,11 +3585,16 @@ def api_admins(uid):
 @need_auth
 def api_get_data(uid):
     u = dict(DATA["users"].get(uid,{}))
-    # 成员索引体积大，前端只要人数，剔除后再下发
+    # 成员名单体积大，前端只要统计数字，剔除后再下发（详情走 /api/member_log）
     monitors = []
     for mon in u.get("member_monitors", []):
         slim = {k:v for k,v in mon.items() if k != "members_index"}
-        slim["member_count"] = len(mon.get("members_index") or {}) or mon.get("member_count",0)
+        cid = str(mon.get("channel_id",""))
+        led = DATA.get("ch_members", {}).get(cid) or {}
+        st = mem_stats(cid) if led else {"total": len(mon.get("members_index") or {}) or mon.get("member_count",0), "in":0, "left":0}
+        slim.update({"member_count":st["total"], "in_count":st["in"], "left_total":st["left"],
+                     "rt_at":led.get("rt_at",0), "scan_at":led.get("scan_at",0),
+                     "capped":bool(led.get("capped")), "log_n":len(led.get("log") or [])})
         monitors.append(slim)
     if "member_monitors" in u: u["member_monitors"] = monitors
     return jsonify({"ok":True,"user":u,"msg_count":len(DATA.get("msg_map",{})),
@@ -3547,10 +4007,10 @@ def api_add_member_monitor(uid):
     if any(str(item.get("channel_id")) == ch_id for item in monitors): return jsonify({"ok":False,"msg":"该频道已在监控中"})
     try: interval = max(1, int(d.get('interval', 60)))
     except (TypeError, ValueError): return jsonify({"ok":False,"msg":"检测间隔必须是整数分钟"})
-    # members_index 为空 ➜ 调度器会立刻做一次全量建档，之后按 interval 增量扫描
+    # 台账为空 ➜ 调度器 10 秒内做一次全量建档（首次记录所有人），之后实时事件为主、按 interval 兜底对账
     monitors.append({"channel_id":ch_id,"started_at":int(time.time()),"interval":interval,
         "last_run":0,"member_count":0,"remote_path":"","last_error":"",
-        "members_index":{},"joined_count":0,"left_count":0,"first_scan_at":0})
+        "joined_count":0,"left_count":0,"first_scan_at":0})
     save_data(); return jsonify({"ok":True,"user":DATA["users"][uid]})
 
 @app.route('/api/member_monitors/<path:cid>', methods=['PUT'])
@@ -3569,9 +4029,42 @@ def api_edit_member_monitor(uid, cid):
 def api_download_member_monitor(uid, cid):
     monitor = next((m for m in DATA["users"][uid].setdefault("member_monitors", []) if str(m.get("channel_id")) == cid), None)
     if not monitor: return jsonify({"ok":False,"msg":"监控任务不存在"}), 404
-    Thread(target=send_member_backup, args=(uid, cid)).start()
+    def work():
+        try: mem_backup_now(cid)      # 先把台账最新状态写上去，再发，永远是最新名单
+        except Exception as e: print(f"⚠️ 成员备份刷新失败 {cid}: {str(e)[:60]}")
+        send_member_backup(uid, cid)
+    Thread(target=work, daemon=True).start()
     return jsonify({"ok":True,"msg":"备份文件将由机器人发送给你"})
 
+# 🆕 单个频道的成员台账：累计人数、实时动态、成员列表（分频道各记各的）
+@app.route('/api/member_log/<path:cid>')
+@need_auth
+def api_member_log(uid, cid):
+    if not any(str(m.get("channel_id")) == cid for m in DATA["users"].get(uid, {}).get("member_monitors", [])):
+        return jsonify({"ok":False,"msg":"监控任务不存在"}), 404
+    led = ch_mem(cid); roster = led["roster"]
+    q = (request.args.get("q") or "").strip().lower()
+    rows = sorted(roster.items(), key=lambda kv: (kv[1][4] or 0), reverse=True)
+    if q: rows = [kv for kv in rows if q in (_member_display(kv[1]) + " " + kv[1][0] + " " + kv[0]).lower()]
+    members = [{"id":k, "name":_member_display(r), "un":r[0], "bot":bool(r[3]),
+                "t":r[4], "left":(r[5] if len(r) > 5 else 0)} for k, r in rows[:MEMBER_VIEW_CAP]]
+    return jsonify({"ok":True, "id":cid, "title":ch_label(uid, cid), "stats":mem_stats(cid),
+                    "cap":MEMBER_VIEW_CAP, "shown":len(members), "matched":len(rows),
+                    "capped":bool(led.get("capped")), "visible":led.get("visible", 0),
+                    "scan_at":led.get("scan_at", 0), "rt_at":led.get("rt_at", 0),
+                    "rt_src":led.get("rt_src",""), "backup_at":led.get("backup_at", 0),
+                    "first_scan_at":led.get("first_scan_at", 0), "log":led["log"][:200]})
+
+# 🆕 立即对账（不等检测间隔）
+@app.route('/api/member_monitors/<path:cid>/scan', methods=['POST'])
+@need_auth
+def api_scan_member_monitor(uid, cid):
+    for mon in DATA["users"][uid].setdefault("member_monitors", []):
+        if str(mon.get("channel_id")) == cid:
+            mon["last_run"] = 0; save_data_soon()
+            return jsonify({"ok":True,"msg":"已排入队列，10 秒内对一次账"})
+    return jsonify({"ok":False,"msg":"监控任务不存在"}), 404
+
 @app.route('/api/member_monitors/<path:cid>', methods=['DELETE'])
 @need_auth
 def api_del_member_monitor(uid, cid):
@@ -3664,6 +4157,7 @@ def api_health():
 if __name__ == "__main__":
     Thread(target=lambda: app.run(host="0.0.0.0", port=7860), daemon=True).start()
     Thread(target=start_telethon_worker, daemon=True).start()
+    Thread(target=dav_ava_warm, daemon=True).start()   # 🆕 头像从 WebDAV 预热到本地，重启不再重下
     print("🔄 正在清除旧连接...")
     for attempt in range(5):
         try: bot.remove_webhook(); bot.get_updates(offset=-1, timeout=1); break
@@ -3672,7 +4166,8 @@ if __name__ == "__main__":
     while True:
         guard_bot_handlers()   # 🆕 上锁：非白名单用户的指令与按钮一律拒绝
         try: bot.infinity_polling(timeout=60, long_polling_timeout=60,
-                allowed_updates=["message","callback_query","channel_post","edited_channel_post","my_chat_member"])
+                allowed_updates=["message","callback_query","channel_post","edited_channel_post",
+                                 "my_chat_member","chat_member"])   # 🆕 chat_member = 实时成员进出
         except Exception as e:
             print(f"❌ Polling 异常: {e}"); time.sleep(10)
             try: bot.remove_webhook(); bot.get_updates(offset=-1, timeout=1)

webapp.html

@@ -584,8 +584,8 @@ const SEED={
   ],
   address_book:{'-1001682349051':'主频道','-1001733118244':'分发一号','-1001552209873':'存档仓','-1001908744236':'镜像站','-1001445096327':'周刊编辑部','-1001612987450':'索引频道','@Nine_7Eleven':'公开频道 Nine7'},
   member_monitors:[
-    {channel_id:'-1001682349051',started_at:nowS()-86400*5,interval:60,last_run:nowS()-1200,member_count:1284,remote_path:'members/backup.csv',last_error:'',joined_count:12,left_count:3,first_scan_at:nowS()-86400*5},
-    {channel_id:'@Nine_7Eleven',started_at:nowS()-86400*2,interval:120,last_run:nowS()-7200,member_count:356,remote_path:'',last_error:'ChatAdminRequired',joined_count:0,left_count:0,first_scan_at:0}
+    {channel_id:'-1001682349051',started_at:nowS()-86400*5,interval:60,last_run:nowS()-1200,member_count:1284,in_count:1271,left_total:13,rt_at:nowS()-180,scan_at:nowS()-1200,capped:true,remote_path:'members/backup.csv',last_error:'',joined_count:12,left_count:3,first_scan_at:nowS()-86400*5},
+    {channel_id:'@Nine_7Eleven',started_at:nowS()-86400*2,interval:120,last_run:nowS()-7200,member_count:356,in_count:356,left_total:0,rt_at:0,scan_at:nowS()-7200,capped:false,remote_path:'',last_error:'ChatAdminRequired',joined_count:0,left_count:0,first_scan_at:0}
   ]
 };
 function mockDB(){try{return JSON.parse(localStorage.getItem('nine7_mock'))||null}catch(e){return null}}
@@ -671,9 +671,19 @@ async function mockApi(path,{method='GET',body={},form}={}){
     if(method==='POST'&&seg.length===0){u.member_monitors.push({channel_id:d.ch_id,started_at:nowS(),interval:+d.interval||60,last_run:0,member_count:0,remote_path:'',last_error:''});mockSave(db);return out()}
     const cid=decodeURIComponent(seg[0]||'');
     if(seg[1]==='download')return{ok:true,msg:'备份文件将由机器人发送给你'};
+    if(seg[1]==='scan')return{ok:true,msg:'已排入队列，10 秒内对一次账'};
     if(method==='PUT'){const m2=u.member_monitors.find(x=>String(x.channel_id)===cid);if(m2){m2.interval=+d.interval;m2.last_run=0}mockSave(db);return out()}
     if(method==='DELETE'){u.member_monitors=u.member_monitors.filter(x=>String(x.channel_id)!==cid);mockSave(db);return out()}
   }
+  if(res==='member_log'){
+    const cid=decodeURIComponent(seg[0]||''),mm=u.member_monitors.find(x=>String(x.channel_id)===cid)||{};
+    const n=mm.member_count||0,names=['夜航星','雾都夜谈','银月','拾柒','老鹿','K','南风','阿波罗'];
+    const mk=(i,left)=>({id:String(70000+i),name:names[i%names.length]+i,un:'user'+i,bot:false,t:nowS()-i*3600,left:left?nowS()-i*600:0});
+    const mem=Array.from({length:Math.min(200,n)},(_,i)=>mk(i,i%23===0));
+    return{ok:true,id:cid,title:cid,members:mem,stats:{total:n,in:mm.in_count||n,left:mm.left_total||0},cap:200,shown:mem.length,matched:n,
+      capped:!!mm.capped,visible:200,scan_at:mm.scan_at||0,rt_at:mm.rt_at||0,rt_src:'bot',backup_at:nowS()-120,first_scan_at:mm.first_scan_at||0,
+      log:mem.slice(0,20).map((x,i)=>({t:nowS()-i*900,u:x.id,n:x.name,un:x.un,a:i%5===0?'left':'join',s:i%3===0?'scan':'rt'}))};
+  }
   if(['btn_multi','btn_old','btn_new','btn_new_media','gen_dir','replace_tag','backup','batch_create'].includes(res))return{ok:true};
   return{ok:false,msg:'演示模式不支持该操作'};
 }
@@ -1487,17 +1497,19 @@ function vOps(m){
     </div>
     <div>
     <div class="ops-c" data-rv>
-      <div class="cmp-t">${I('users')} 成员监控</div>
-      <div class="cmp-s">周期性备份频道成员名单至 WebDAV</div>
+      <div class="cmp-t">${I('users')} 成员监控 <span class="chip" style="color:var(--grn);border-color:rgba(93,255,160,.35);margin-left:6px">${I('radio',10)} 实时</span></div>
+      <div class="cmp-s">有人进就立刻记一笔并备份 · 名单只增不删，每个频道各记各的</div>
       <div id="monList">
       ${mons.length?mons.map(mm=>`<div class="mon-row">
         <div><div style="font-weight:600">${esc(S.data.address_book?.[mm.channel_id]||'未登记频道')}</div>
-        <div class="mono" style="color:var(--dim)">${esc(shortId(mm.channel_id))} · 每 ${mm.interval} 分钟 · ${mm.first_scan_at?'增量扫描':'待首次建档'}</div></div>
+        <div class="mono" style="color:var(--dim)">${esc(shortId(mm.channel_id))} · 兜底对账每 ${mm.interval} 分钟 · ${mm.first_scan_at?(mm.rt_at?('实时 '+fmtT(mm.rt_at)):'等实时事件'):'待首次建档'}</div></div>
         <div style="display:flex;align-items:center;gap:8px;flex-wrap:wrap">
-          <span class="chip">${I('users',11)} ${(mm.member_count||0).toLocaleString()}</span>
-          ${mm.joined_count?`<span class="chip" style="color:var(--grn);border-color:rgba(93,255,160,.35)">${I('user-plus',11)} +${mm.joined_count}</span>`:''}
-          ${mm.left_count?`<span class="chip" style="color:var(--red);border-color:rgba(255,93,93,.3)">${I('user-minus',11)} -${mm.left_count}</span>`:''}
-          ${mm.last_error?`<span class="chip" style="color:var(--red);border-color:rgba(255,93,93,.35)">${I('triangle-alert',11)} 异常</span>`:`<span class="chip">${I('history',11)} ${fmtT(mm.last_run)}</span>`}
+          <span class="chip" title="累计记录过的人">${I('users',11)} ${(mm.member_count||0).toLocaleString()}</span>
+          ${mm.in_count?`<span class="chip" style="color:var(--grn);border-color:rgba(93,255,160,.35)" title="当前在册">${I('user-check',11)} ${mm.in_count.toLocaleString()}</span>`:''}
+          ${mm.left_total?`<span class="chip" style="color:var(--red);border-color:rgba(255,93,93,.3)" title="已退出">${I('user-minus',11)} ${mm.left_total.toLocaleString()}</span>`:''}
+          ${mm.last_error?`<span class="chip" style="color:var(--red);border-color:rgba(255,93,93,.35)">${I('triangle-alert',11)} 异常</span>`:''}
+          <button class="ic-b" data-mv="${esc(mm.channel_id)}" title="查看名单与动态">${I('list',14)}</button>
+          <button class="ic-b" data-sc="${esc(mm.channel_id)}" title="立即对账">${I('refresh-cw',14)}</button>
           <button class="ic-b" data-dl="${esc(mm.channel_id)}" title="下载备份">${I('download',14)}</button>
           <button class="ic-b" data-ed="${esc(mm.channel_id)}" title="修改间隔">${I('pencil',14)}</button>
           <button class="ic-b danger" data-de="${esc(mm.channel_id)}" title="删除">${I('trash-2',14)}</button>
@@ -1505,7 +1517,7 @@ function vOps(m){
       </div>
       <div class="sec-t">新增监控</div>
       ${fld('频道',picker('m_ch',S.data.address_book,''))}
-      ${fld('检测间隔（分钟）',inp('m_intv',60,'60','number','min="1"'))}
+      ${fld('检测间隔（分钟）',inp('m_intv',60,'60','number','min="1"'),'实时事件为主，这个间隔只是兜底对账')}
       <button class="btn btn-acc" id="m_add" style="width:100%;justify-content:center">${I('plus',15)} 添加监控</button>
     </div>
     <!-- 🆕 白名单：在这里随时增删，不用改环境变量 -->
@@ -1569,14 +1581,57 @@ function vOps(m){
       try{applyUser(await api('/api/member_monitors/'+encodeURIComponent(cid),{method:'PUT',body:{interval:+gv('m_nintv',w)||60}}));toast('间隔已更新');w._close();go('ops')}catch(e){toast(e.message,'err')}
     };
   });
-  $$('[data-de]',m).forEach(b=>b.onclick=()=>confirmSheet('删除该成员监控任务？历史备份文件保留在 WebDAV。',async()=>{
+  $$('[data-sc]',m).forEach(b=>b.onclick=async()=>{
+    try{const j=await api('/api/member_monitors/'+encodeURIComponent(b.dataset.sc)+'/scan',{method:'POST'});toast(j.msg||'已排队对账')}catch(e){toast(e.message,'err')}
+  });
+  $$('[data-mv]',m).forEach(b=>b.onclick=()=>memSheet(b.dataset.mv));
+  $$('[data-de]',m).forEach(b=>b.onclick=()=>confirmSheet('删除该成员监控任务？频道台账与 WebDAV 备份都保留。',async()=>{
     try{applyUser(await api('/api/member_monitors/'+encodeURIComponent(b.dataset.de),{method:'DELETE'}));toast('监控已删除');go('ops')}catch(e){toast(e.message,'err')}
   }));
   loadAcl(m);
 }
+
+/* 🆕 单频道成员台账：累计人数、实时动态、成员列表（各频道分开记） */
+async function memSheet(cid){
+  const w=sheet({title:'成员台账',sub:esc(S.data.address_book?.[cid]||shortId(cid)),
+    body:'<div id="memBox"><div class="fld-h" style="padding:16px 0">读取中…</div></div>'});
+  const draw=async(q='')=>{
+    try{
+      const j=await api('/api/member_log/'+encodeURIComponent(cid)+(q?('?q='+encodeURIComponent(q)):''));
+      const st=j.stats||{},box=$('#memBox',w);
+      const tag=(t,v,c)=>`<div style="flex:1;min-width:86px;background:var(--card2,rgba(255,255,255,.03));border:1px solid var(--line);border-radius:12px;padding:9px 11px">
+        <div style="font-size:11px;color:var(--dim)">${t}</div><div style="font-size:18px;font-weight:700;${c?'color:'+c:''}">${(v||0).toLocaleString()}</div></div>`;
+      const when=ts=>ts?fmtT(ts):'—';
+      box.innerHTML=`<div style="display:flex;gap:8px;flex-wrap:wrap;margin-bottom:12px">
+          ${tag('累计记录',st.total)}${tag('当前在册',st.in,'var(--grn)')}${tag('已退出',st.left,'var(--red)')}
+        </div>
+        <div class="fld-h" style="margin-bottom:12px">实时 ${when(j.rt_at)}${j.rt_src?'（'+(j.rt_src==='bot'?'机器人':'userbot')+'）':''} · 对账 ${when(j.scan_at)} · 备份 ${when(j.backup_at)}
+        ${j.capped?`<br>Telegram 单次最多看到 ${j.cap} 人（本次看到 ${j.visible}），名单靠实时事件继续累加，不会把老成员挤掉`:''}</div>
+        <div class="sec-t">最近动态</div>
+        <div style="max-height:190px;overflow:auto">${(j.log||[]).length?(j.log||[]).slice(0,80).map(e=>`<div class="mon-row" style="padding:8px 0">
+          <div><span style="color:${e.a==='join'?'var(--grn)':'var(--red)'}">${e.a==='join'?'＋':'－'}</span> ${esc(e.n||e.u)}
+          <span class="mono" style="color:var(--dim)">${e.un?'@'+esc(e.un):esc(e.u)}</span></div>
+          <div class="mono" style="color:var(--dim)">${fmtT(e.t)} · ${e.s==='scan'?'对账':(e.s==='bot'?'实时·机器人':'实时')}</div></div>`).join(''):'<div class="fld-h" style="padding:12px 0">还没有进出记录</div>'}</div>
+        <div class="sec-t">成���名单（最新 ${j.shown}/${j.matched}${j.matched>j.cap?'，一次最多显示 '+j.cap:''}）</div>
+        ${inp('mem_q',q,'搜索名字 / @用户名 / ID')}
+        <div style="max-height:240px;overflow:auto;margin-top:10px">${(j.members||[]).length?(j.members||[]).map(u=>`<div class="mon-row" style="padding:8px 0">
+          <div>${esc(u.name||u.id)} <span class="mono" style="color:var(--dim)">${u.un?'@'+esc(u.un):esc(u.id)}</span>${u.bot?' <span class="chip">BOT</span>':''}</div>
+          <div class="mono" style="color:${u.left?'var(--red)':'var(--dim)'}">${u.left?'已退 '+fmtT(u.left):'进于 '+fmtT(u.t)}</div></div>`).join(''):'<div class="fld-h" style="padding:12px 0">没有匹配的成员</div>'}</div>`;
+      icons();
+      const qi=$('#mem_q',w);
+      if(qi){let tm;qi.oninput=()=>{clearTimeout(tm);tm=setTimeout(()=>{const v=qi.value.trim();draw(v).then(()=>{const n=$('#mem_q',w);if(n){n.focus();n.setSelectionRange(v.length,v.length)}})},350)}}
+    }catch(e){const box=$('#memBox',w);if(box)box.innerHTML=`<div class="fld-h" style="padding:16px 0">读取失败：${esc(e.message)}</div>`}
+  };
+  draw();
+}
 /* 🆕 白名单面板 */
-async function loadAcl(m){
-  try{renderAcl(m,await api('/api/admins'))}
+async function loadAcl(m,retry=0){
+  try{
+    const j=await api('/api/admins');renderAcl(m,j);
+    /* 🆕 名字/头像是后台刷的：还缺就静默再取两次，不用退出面板再进 */
+    const miss=Object.values(j.profiles||{}).some(p=>!p.avatar||!p.name);
+    if(miss&&retry<2&&document.body.contains(m))setTimeout(()=>loadAcl(m,retry+1),retry?6000:2500);
+  }
   catch(e){const b=$('#aclBox',m);if(b)b.innerHTML=`<div class="fld-h" style="padding:14px 0">读取失败：${esc(e.message)}</div>`}
 }
 function renderAcl(m,j){
@@ -1632,9 +1687,19 @@ const AVA_CSS=`.ava{width:34px;height:34px;border-radius:50%;object-fit:cover;fl
 function ava(url,name,cls=''){
   const ini=esc(String(name||'?').trim().slice(0,1).toUpperCase());
   return url?`<img class="ava ${cls}" src="${esc(url)}" alt="" loading="lazy" referrerpolicy="no-referrer"
-      onerror="this.outerHTML='<span class=&quot;ava ${cls}&quot;>${ini}</span>'">`
+      data-ini="${ini}" data-cls="${esc(cls)}" onerror="avaErr(this)">`
     :`<span class="ava ${cls}">${ini}</span>`;
 }
+/* 🆕 头像取失败先重试一次（服务端可能正在从 WebDAV 回源），真没有才退回首字母 */
+function avaErr(img){
+  if(!img.dataset.retry){
+    img.dataset.retry='1';
+    const u=img.src.split('#')[0].replace(/[?&]r=\d+/,'');
+    setTimeout(()=>{img.src=u+(u.includes('?')?'&':'?')+'r='+Date.now()},1800);
+    return;
+  }
+  img.outerHTML=`<span class="ava ${img.dataset.cls||''}">${img.dataset.ini||'?'}</span>`;
+}
 
 /* ================= 🆕 08 我的资料（头像 + 名字） ================= */
 function meInfo(){
@@ -1643,7 +1708,7 @@ function meInfo(){
   const first=p.first_name||(TGU&&TGU.first_name)||'';
   const last=p.last_name||(TGU&&TGU.last_name)||'';
   const uname=p.username||(TGU&&TGU.username)||'';
-  const photo=p.photo_url||(TGU&&TGU.photo_url)||cache.avatar||'';   /* 🆕 退回服务端缓存头像 */
+  const photo=cache.avatar||p.photo_url||(TGU&&TGU.photo_url)||'';   /* 🆕 先用服务端缓存（同源、命中浏览器缓存、秒开），TG 的 photo_url 慢且会过期 */
   const id=p.id||(TGU&&TGU.id)||'';
   const name=[first,last].filter(Boolean).join(' ')||cache.name||(uname?'@'+uname:(DEMO?'演示用户':'Telegram 用户'));
   return{name,uname,photo,id,premium:!!(p.is_premium||(TGU&&TGU.is_premium))};
@@ -1652,9 +1717,9 @@ function renderMe(){
   const box=$('#me');if(!box)return;
   const u=meInfo();
   const initials=esc((u.name||'U').trim().slice(0,1).toUpperCase());
-  /* 🆕 头像三级回退：TG 的 photo_url（会过期）→ 服务端缓存 → 首字母 */
+  /* 🆕 头像三级回退：服务端缓存（快）→ TG 的 photo_url（慢、会过期）→ 首字母 */
   const cached=(S.meCache&&S.meCache.avatar)||'';
-  const srcs=[u.photo,cached].filter(Boolean);
+  const srcs=[cached,u.photo].filter(Boolean);
   box.innerHTML=`${srcs.length?`<img class="av" src="${esc(srcs[0])}" alt="" referrerpolicy="no-referrer">`:`<span class="av">${initials}</span>`}
     <div class="mn"><b>${esc(u.name)}${u.premium?' ⭐':''}</b>
     <span>${esc(u.uname?'@'+u.uname:(u.id?'ID '+u.id:'GUEST'))}</span></div>`;