Update botsignal.py

botsignal.py

@@ -1,3 +1,5 @@
+# botsignal.py — CA-only aggregator + brand message + autotrack attach (full)
+
 import asyncio
 import os
 import re
@@ -16,16 +18,99 @@ from telethon import TelegramClient, events
 from telethon.sessions import StringSession, MemorySession
 from telethon.errors.rpcerrorlist import FloodWaitError
 
-# Attach autotrack (silent start, reply >=1.5x) — pastikan autotrack.py kamu versi terbaru
-from autotrack import setup_autotrack
-
+# =========================
+# Attach autotrack (pakai client yang sama)
+# =========================
+print("[BOOT] setting up autotrack…", flush=True)
+try:
+    from autotrack import setup_autotrack  # pastikan autotrack.py versi fix
+    _HAS_AUTOTRACK = True
+except Exception as e:
+    print("[BOOT] autotrack import failed:", repr(e), flush=True)
+    _HAS_AUTOTRACK = False
 
-# ========= Configuration via Environment =========
+# =========================
+# ENV / CONFIG
+# =========================
 API_ID = int(os.environ.get("API_ID", "0"))
-API_HASH = os.environ.get("API_HASH", "" )
+API_HASH = os.environ.get("API_HASH", "")
 STRING_SESSION = os.environ.get("STRING_SESSION", "")
 
-# --- Sumber CORE vs SUPPORT ---
+# Target posting / reply
+TARGET_CHAT = os.environ.get("TARGET_CHAT", "https://t.me/MidasTouchsignalll")
+
+# ====== Leaderboard config (Phanes) ======
+LEADERBOARD_GROUP = os.environ.get("LEADERBOARD_GROUP", "https://t.me/+IaefBrMZwW5kMTEx")
+LB_TRIGGER = os.environ.get("LB_TRIGGER", "/lb")
+LEADERBOARD_BOT = os.environ.get("LEADERBOARD_BOT", "@PhanesGreenBot")
+LB_REQUIRE_MIN_RANKS = int(os.environ.get("LB_REQUIRE_MIN_RANKS", "0"))
+LEADERBOARD_COOLDOWN_SEC = int(os.environ.get("LEADERBOARD_COOLDOWN_SEC", "600"))
+
+# ====== Scheduler interval (acak per JAM) ======
+LB_INTERVAL_MIN_HOURS = int(os.environ.get("LB_INTERVAL_MIN_HOURS", "3"))
+LB_INTERVAL_MAX_HOURS = int(os.environ.get("LB_INTERVAL_MAX_HOURS", "20"))
+
+# ====== Dedup & window ======
+INITIAL_BACKFILL = 2
+DEDUP_BUFFER_SIZE = int(os.environ.get("DEDUP_BUFFER_SIZE", "800"))
+CLASS_WINDOW_MINUTES = int(os.environ.get("CLASS_WINDOW_MINUTES", "180"))
+BACKFILL_BUFFER_MINUTES = int(os.environ.get("BACKFILL_BUFFER_MINUTES", "3"))
+
+# ====== Gate Core/Support ======
+SUPPORT_MIN_UNIQUE = int(os.environ.get("SUPPORT_MIN_UNIQUE", "2"))
+LOW_MIN_UNIQUE = int(os.environ.get("LOW_MIN_UNIQUE", "2"))
+
+# ====== Behavior ======
+DRY_RUN = os.environ.get("DRY_RUN", "0") == "1"
+UPDATE_STRATEGY = os.environ.get("UPDATE_STRATEGY", "reply").lower()  # edit|reply|new
+UPDATE_COOLDOWN_SEC = int(os.environ.get("UPDATE_COOLDOWN_SEC", "5"))
+
+# ====== Media flags ======
+INCLUDE_MEDIA = os.environ.get("INCLUDE_MEDIA", "0") == "1"
+ALLOW_GIFS_VIDEOS = os.environ.get("ALLOW_GIFS_VIDEOS", "0") == "1"
+MAX_MEDIA_MB = int(os.environ.get("MAX_MEDIA_MB", "8"))
+
+# ====== Keywords & filter ======
+THEME_KEYWORDS = [kw.strip().lower() for kw in os.environ.get(
+    "THEME_KEYWORDS",
+    "pump,call,entry,entries,sl,tp,launch,buy,gem,bnb,eth,btc,sol,moon,ath,breakout,sol,$,aped"
+).split(",") if kw.strip()]
+KEYWORD_WEIGHT = float(os.environ.get("KEYWORD_WEIGHT", "1.0"))
+FUZZ_WEIGHT = float(os.environ.get("FUZZ_WEIGHT", "0.7"))
+RELEVANCE_THRESHOLD = float(os.environ.get("RELEVANCE_THRESHOLD", "0.6"))
+
+EXCLUDE_PHRASES = [p.strip().lower() for p in os.environ.get(
+    "EXCLUDE_PHRASES",
+    "achievement unlocked,call profit:,achieving +"
+).split(",") if p.strip()]
+
+# ====== Milestones label (untuk copy di pesan awal CA) ======
+_M_RAW = os.environ.get("MILESTONES", "1.5,2")
+try:
+    _M_LIST = [x.strip() for x in _M_RAW.split(",") if x.strip()]
+    if not _M_LIST:
+        _M_LIST = ["1.5", "2"]
+    MILESTONES_LABEL = " • ".join(f"{m}×" for m in _M_LIST)
+except Exception:
+    _M_LIST = ["1.5", "2"]
+    MILESTONES_LABEL = "1.5× • 2×"
+
+# ====== Chains (Dexscreener)
+DEXSCREENER_TOKEN_URL = "https://api.dexscreener.com/latest/dex/tokens/"
+
+CHAIN_HINTS = {
+    "bsc": "bsc", "bnb": "bsc", "binance": "bsc",
+    "eth": "ethereum", "ethereum": "ethereum",
+    "base": "base", "coinbase": "base",
+    "sol": "solana", "solana": "solana", "pump.fun": "solana"
+}
+
+# ====== DB ======
+DB_PATH = os.environ.get("BOTSIGNAL_DB", "/tmp/botsignal.db")
+
+# =========================
+# Sources (CORE & SUPPORT)
+# =========================
 CORE_CHATS = [
     "https://t.me/PEPE_Calls28",
     "https://t.me/SephirothGemCalls1",
@@ -93,103 +178,9 @@ SUPPORT_CHATS = [
 ]
 SOURCE_CHATS = CORE_CHATS + SUPPORT_CHATS
 
-TARGET_CHAT = os.environ.get("TARGET_CHAT", "https://t.me/MidasTouchsignalll")
-
-# ========== Leaderboard config ==========
-LEADERBOARD_GROUP = os.environ.get("LEADERBOARD_GROUP", "https://t.me/+IaefBrMZwW5kMTEx")
-LB_TRIGGER = os.environ.get("LB_TRIGGER", "/lb")
-LEADERBOARD_BOT = os.environ.get("LEADERBOARD_BOT", "@PhanesGreenBot")
-LB_REQUIRE_MIN_RANKS = int(os.environ.get("LB_REQUIRE_MIN_RANKS", "0"))
-
-# ====== Scheduler interval (acak per JAM) ======
-LB_INTERVAL_MIN_HOURS = int(os.environ.get("LB_INTERVAL_MIN_HOURS", "3"))
-LB_INTERVAL_MAX_HOURS = int(os.environ.get("LB_INTERVAL_MAX_HOURS", "20"))
-
-# ====== Anti-spam Leaderboard (cooldown + dedup) ======
-LEADERBOARD_COOLDOWN_SEC = int(os.environ.get("LEADERBOARD_COOLDOWN_SEC", "600"))
-_last_lb_hash: Optional[str] = None
-_last_lb_ts: Optional[float] = None
-
-# Tambahan: simpan ID bot Phanes untuk cek via_bot
-PHANES_BOT_ID: Optional[int] = None
-LB_TEXT_RE = re.compile(r"(🏆\s*Leaderboard|📊\s*Group\s*Stats)", re.IGNORECASE)
-
-# Zero-width char remover & normalizer untuk hash leaderboard
-ZERO_WIDTH_RE = re.compile(r"[\u200b\u200c\u200d\u2060\ufeff]")
-
-def _hash_text_1line(t: str) -> str:
-    t1 = re.sub(r"\s+", " ", (t or "")).strip()
-    return hashlib.sha1(t1.encode("utf-8", errors="ignore")).hexdigest()
-
-def _normalize_lb_for_hash(t: str) -> str:
-    if not t:
-        return ""
-    t = ZERO_WIDTH_RE.sub("", t)
-    # hilangkan angka volatile (views, harga, persen, menit)
-    t = re.sub(r"\b\d+(\.\d+)?%?\b", "<n>", t)
-    t = re.sub(r"\s+", " ", t).strip().lower()
-    return t
-
-def _is_true_leaderboard(text: str) -> bool:
-    if not text:
-        return False
-    if not re.search(r"🏆\s*Leaderboard", text):
-        return False
-    if not re.search(r"📊\s*Group\s*Stats", text):
-        return False
-    if LB_REQUIRE_MIN_RANKS > 0:
-        ranks = re.findall(r"(?m)^\s*[\W\s]*\d{1,2}\s+.+\[[\d\.]+x\]\s*$", text)
-        if len(ranks) < LB_REQUIRE_MIN_RANKS:
-            return False
-    return True
-
-# ====== Backfill & dedup ======
-INITIAL_BACKFILL = 2
-DEDUP_BUFFER_SIZE = int(os.environ.get("DEDUP_BUFFER_SIZE", "800"))
-
-# >>> Perpanjang window klasifikasi biar naik tier lebih lama <<<
-CLASS_WINDOW_MINUTES = int(os.environ.get("CLASS_WINDOW_MINUTES", "180"))
-
-# >>> Minimal unique support agar boleh lewat "gate lama" (jika belum ada core)
-SUPPORT_MIN_UNIQUE = int(os.environ.get("SUPPORT_MIN_UNIQUE", "2"))
-
-# >>> Low minimal call unik (baru boleh dipost saat unik >= nilai ini)
-LOW_MIN_UNIQUE = int(os.environ.get("LOW_MIN_UNIQUE", "2"))
-
-# DRY RUN (tidak kirim apa pun ke TARGET_CHAT)
-DRY_RUN = os.environ.get("DRY_RUN", "0") == "1"
-
-# Backfill buffer: abaikan pesan lebih tua dari (startup_time - buffer)
-BACKFILL_BUFFER_MINUTES = int(os.environ.get("BACKFILL_BUFFER_MINUTES", "3"))
-
-# === Update behavior strategy ===
-# edit  : edit pesan terakhir untuk entitas saat UPDATE
-# reply : balas (reply_to) pesan pertama entitas itu
-# new   : kirim pesan baru untuk setiap UPDATE
-UPDATE_STRATEGY = os.environ.get("UPDATE_STRATEGY", "reply").lower()
-UPDATE_COOLDOWN_SEC = int(os.environ.get("UPDATE_COOLDOWN_SEC", "5"))
-
-# Media flags
-INCLUDE_MEDIA = os.environ.get("INCLUDE_MEDIA", "0") == "1"
-ALLOW_GIFS_VIDEOS = os.environ.get("ALLOW_GIFS_VIDEOS", "0") == "1"
-MAX_MEDIA_MB = int(os.environ.get("MAX_MEDIA_MB", "8"))
-
-# Thematic keywords + relevance threshold
-THEME_KEYWORDS = [kw.strip().lower() for kw in os.environ.get(
-    "THEME_KEYWORDS",
-    "pump,call,entry,entries,sl,tp,launch,buy,gem,bnb,eth,btc,sol,moon,ath,breakout,sol,$,aped"
-).split(",") if kw.strip()]
-KEYWORD_WEIGHT = float(os.environ.get("KEYWORD_WEIGHT", "1.0"))
-FUZZ_WEIGHT = float(os.environ.get("FUZZ_WEIGHT", "0.7"))
-RELEVANCE_THRESHOLD = float(os.environ.get("RELEVANCE_THRESHOLD", "0.6"))
-
-# Phrases yang pasti exclude
-EXCLUDE_PHRASES = [p.strip().lower() for p in os.environ.get(
-    "EXCLUDE_PHRASES",
-    "achievement unlocked,call profit:,achieving +"
-).split(",") if p.strip()]
-
-# ========= Client bootstrap =========
+# =========================
+# Boot client
+# =========================
 def build_client() -> TelegramClient:
     if STRING_SESSION:
         print(">> Using StringSession (persistent).")
@@ -199,29 +190,26 @@ def build_client() -> TelegramClient:
 
 client = build_client()
 
-# Attach autotrack to the same Telethon client (guarded, with logs)
-print("[BOOT] setting up autotrack…", flush=True)
-try:
-    from autotrack import setup_autotrack
-    setup_autotrack(client, announce_chat=os.environ.get("TARGET_CHAT", "@MidasTouchsignalll"))
-    print("[BOOT] autotrack attached ✓", flush=True)
-except Exception as e:
-    import traceback
-    print("[BOOT] autotrack attach failed:", repr(e), flush=True)
-    traceback.print_exc()
+# Attach autotrack ke client yang sama
+if _HAS_AUTOTRACK:
+    try:
+        setup_autotrack(client, announce_chat=TARGET_CHAT)
+        print("[BOOT] autotrack attached ✓", flush=True)
+    except Exception as e:
+        import traceback
+        print("[BOOT] autotrack attach failed:", repr(e), flush=True)
+        traceback.print_exc()
 
+# =========================
+# State & DB
+# =========================
 recent_hashes: deque[str] = deque(maxlen=DEDUP_BUFFER_SIZE)
-recent_content_hashes: deque[str] = deque(maxlen=DEDUP_BUFFER_SIZE)  # content-only dedup
-recent_entity_keys: deque[str] = deque(maxlen=DEDUP_BUFFER_SIZE)  # entity-based dedup
+recent_content_hashes: deque[str] = deque(maxlen=DEDUP_BUFFER_SIZE)
+recent_entity_keys: deque[str] = deque(maxlen=DEDUP_BUFFER_SIZE)
 
-# Peta id_chat -> "core" / "support"
-chat_roles: Dict[int, str] = {}  # diisi saat startup setelah resolve entity
+chat_roles: Dict[int, str] = {}  # id_chat -> "core"/"support"
 startup_time_utc = datetime.now(timezone.utc)
 
-
-# ========= Persistence (SQLite) =========
-DB_PATH = os.environ.get("BOTSIGNAL_DB", "/tmp/botsignal.db")
-
 def _db():
     conn = sqlite3.connect(DB_PATH)
     conn.execute("PRAGMA journal_mode=WAL;")
@@ -284,8 +272,12 @@ def db_prune_expired(cutoff: datetime):
     conn.commit()
     conn.close()
 
+_init_db()
+last_posted, keyword_group_last_seen = db_load_state()
 
-# ========= Utilities =========
+# =========================
+# Utils
+# =========================
 def debug_log(reason: str, content: str = "") -> None:
     short = (content or "").replace("\n", " ")[:160]
     print(f"[DEBUG] {reason}: {short}")
@@ -293,7 +285,7 @@ def debug_log(reason: str, content: str = "") -> None:
 def normalize_for_filter(text: str) -> str:
     if not text:
         return ""
-    s = re.sub(r"(?m)^>.*", "", text)
+    s = re.sub(r"(?m)^>.*", "", text)  # strip blockquotes
     s = re.sub(r"\s+", " ", s).strip()
     return s
 
@@ -304,9 +296,9 @@ def _windows(tokens: List[str], size: int = 20):
     for i in range(0, len(tokens), size):
         yield " ".join(tokens[i : i + size])
 
-# --- Bersihkan URL/CA untuk skor relevansi ---
-CA_SOL_RE = re.compile(r"\b[1-9A-HJ-NP-Za-km-z]{32,48}\b")  # Solana base58 (perkiraan)
-CA_EVM_RE = re.compile(r"\b0x[a-fA-F0-9]{40}\b")  # EVM address
+# --- CA patterns & cleaners ---
+CA_SOL_RE = re.compile(r"\b[1-9A-HJ-NP-Za-km-z]{32,48}\b")  # Solana
+CA_EVM_RE = re.compile(r"\b0x[a-fA-F0-9]{40}\b")
 CA_LABEL_RE = re.compile(r"\bCA\s*[:=]\s*\S+", re.IGNORECASE)
 
 def _strip_urls_and_mentions(s: str) -> str:
@@ -365,10 +357,9 @@ def content_only_hash(text: str) -> str:
     norm = _strip_urls_and_mentions(normalize_for_filter(text))
     return hashlib.sha1(norm.encode("utf-8", errors="ignore")).hexdigest()
 
-
-# ========= Class aggregator (windowed unique groups) =========
-keyword_group_last_seen: defaultdict[str, dict[str, datetime]] = defaultdict(dict)
-
+# =========================
+# Class aggregator (windowed)
+# =========================
 def _prune_expired(now: datetime) -> None:
     window = timedelta(minutes=CLASS_WINDOW_MINUTES)
     cutoff = now - window
@@ -394,19 +385,21 @@ def update_and_classify(keyword: str, group_key: str, now: Optional[datetime] =
     if not now:
         now = datetime.now(timezone.utc)
     _prune_expired(now)
-    bucket = keyword_group_last_seen[keyword]
+    bucket = keyword_group_last_seen.get(keyword, {})
     is_new_group = group_key not in bucket
     bucket[group_key] = now
+    keyword_group_last_seen[keyword] = bucket
     db_upsert_kw_seen(keyword, group_key, now)
     class_label, unique_groups = _classify_by_unique(len(bucket))
     return class_label, unique_groups, is_new_group
 
-
-# ========= Sentence-level invite filter =========
+# =========================
+# Sentence-level invite filter
+# =========================
 INVITE_PATTERNS = [
     r"\bjoin\b", r"\bjoin (us|our|channel|group)\b",
     r"\bdm\b", r"\bdm (me|gw|gue|gua|saya|admin)\b",
-    r"\bpm\b", r"\binbox\b", r"\bcontact\b", r"\bkontak\b", r"\bhubungi\b",
+    r"\bpm\b", r"\binbox\b", r"\bcontact\b", r"\bhubungi\b", r"\bkontak\b",
     r"\bvip\b", r"\bpremium\b", r"\bberbayar\b", r"\bpaid\b", r"\bexclusive\b",
     r"\bwhitelist\b", r"\bprivate( group| channel)?\b", r"\bmembership?\b",
     r"\bsubscribe\b", r"\blangganan\b",
@@ -440,8 +433,9 @@ def filter_invite_sentences(text: str) -> str:
     cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
     return cleaned
 
-
-# ========= Media helpers =========
+# =========================
+# Media helpers
+# =========================
 def is_image_message(msg) -> bool:
     if getattr(msg, "photo", None):
         return True
@@ -469,15 +463,11 @@ def media_too_big(msg) -> bool:
         return False
     return (size / (1024 * 1024)) > MAX_MEDIA_MB
 
-
-# ========= Post-on-threshold with EDIT/REPLY/NEW (persisted) =========
+# =========================
+# CA helpers & message builder
+# =========================
 TIER_ORDER = {"Low 🌱": 0, "Medium ⚡": 1, "Strong 💪": 2, "FOMO 🔥": 3}
 
-last_posted: Dict[str, Dict[str, object]] = {}
-last_body: Dict[str, str] = {}
-last_update_ts: Dict[str, float] = {}
-
-# ===== Custom: brand formatter for CA =====
 def _is_ca_key(keyword: str) -> bool:
     return keyword.startswith("ca:evm:") or keyword.startswith("ca:sol:")
 
@@ -488,7 +478,6 @@ def _ca_from_key(keyword: str) -> str:
         return keyword.split("ca:sol:", 1)[1]
     return ""
 
-# ===== Number format for MCAP line =====
 def _fmt_big_usd(x):
     if x is None:
         return "—"
@@ -504,55 +493,6 @@ def _fmt_big_usd(x):
         return f"${x/1_000:.2f}K"
     return f"${x:.0f}"
 
-# ===== Dexscreener fetch (MCAP/FDV) =====
-DEXSCREENER_TOKEN_URL = "https://api.dexscreener.com/latest/dex/tokens/"
-
-async def _fetch_initial_mcap(ca: str):
-    """
-    Ambil perkiraan MCAP (marketCap atau FDV) sekali dari Dexscreener.
-    Return float atau None kalau gak ada.
-    """
-    try:
-        timeout = aiohttp.ClientTimeout(total=8)
-        async with aiohttp.ClientSession(timeout=timeout) as sess:
-            async with sess.get(DEXSCREENER_TOKEN_URL + ca) as r:
-                if r.status != 200:
-                    return None
-                data = await r.json()
-        pairs = (data or {}).get("pairs") or []
-        if not pairs:
-            return None
-        # pilih pair dengan USD liquidity terbesar
-        best = max(pairs, key=lambda p: (p.get("liquidity", {}) or {}).get("usd", 0))
-        mc = best.get("marketCap")
-        fdv = best.get("fdv")
-        if isinstance(mc, (int, float)) and mc > 0:
-            return float(mc)
-        if isinstance(fdv, (int, float)) and fdv > 0:
-            return float(fdv)
-        return None
-    except:
-        return None
-
-# ===== Milestones label (sinkron dengan env; default 1.5× • 2×) =====
-_M_RAW = os.environ.get("MILESTONES", "1.5,2")
-try:
-    _M_LIST = [x.strip() for x in _M_RAW.split(",") if x.strip()]
-    if not _M_LIST:
-        _M_LIST = ["1.5", "2"]
-    MILESTONES_LABEL = " • ".join(f"{m}×" for m in _M_LIST)
-except Exception:
-    _M_LIST = ["1.5", "2"]
-    MILESTONES_LABEL = "1.5× • 2×"
-
-CHAIN_HINTS = {
-    "bsc": "bsc", "bnb": "bsc", "binance": "bsc",
-    "eth": "ethereum", "ethereum": "ethereum",
-    "base": "base", "coinbase": "base",
-    "sol": "solana", "solana": "solana", "pump.fun": "solana"
-}
-
-
 def _guess_chain_from_text(t: str) -> Optional[str]:
     t = (t or "").lower()
     for k, v in CHAIN_HINTS.items():
@@ -561,9 +501,6 @@ def _guess_chain_from_text(t: str) -> Optional[str]:
     return None
 
 async def _fetch_best_chain_for_ca(ca: str) -> Optional[str]:
-    """
-    Query Dexscreener token endpoint to pick the chainId with highest USD liquidity.
-    """
     try:
         timeout = aiohttp.ClientTimeout(total=8)
         async with aiohttp.ClientSession(timeout=timeout) as sess:
@@ -576,53 +513,51 @@ async def _fetch_best_chain_for_ca(ca: str) -> Optional[str]:
             return None
         best = max(pairs, key=lambda p: (p.get("liquidity", {}) or {}).get("usd", 0))
         chain_id = (best.get("chainId") or "").lower().strip()
-        # Dexscreener uses "ethereum", "bsc", "base", "solana", etc.
         return chain_id or None
     except:
         return None
 
 async def _dexs_link_universal(ca: str, context_text: Optional[str] = None) -> str:
-    """
-    Build the proper Dexscreener URL for a CA:
-    - Solana: /solana/<ca>
-    - EVM:    /{ethereum|bsc|base}/<ca> (heuristic from text, fallback API, then default ethereum)
-    - Fallback: /token/<ca>
-    """
     # Solana
     if CA_SOL_RE.fullmatch(ca):
         return f"https://dexscreener.com/solana/{ca}"
-
     # EVM
     if CA_EVM_RE.fullmatch(ca):
-        # (1) Heuristic from context text
         hint = _guess_chain_from_text(context_text or "")
         if hint:
             return f"https://dexscreener.com/{hint}/{ca.lower()}"
-        # (2) Fallback query API to pick best chain by liquidity
         chain = await _fetch_best_chain_for_ca(ca)
         if chain:
             return f"https://dexscreener.com/{chain}/{ca.lower()}"
-        # (3) Default
         return f"https://dexscreener.com/ethereum/{ca.lower()}"
-
-    # Non-CA
+    # non-CA fallback
     return f"https://dexscreener.com/token/{ca}"
 
-    _M_LIST = ["1.5", "2"]
-    MILESTONES_LABEL = "1.5× • 2×"
+async def _fetch_initial_mcap(ca: str):
+    try:
+        timeout = aiohttp.ClientTimeout(total=8)
+        async with aiohttp.ClientSession(timeout=timeout) as sess:
+            async with sess.get(DEXSCREENER_TOKEN_URL + ca) as r:
+                if r.status != 200:
+                    return None
+                data = await r.json()
+        pairs = (data or {}).get("pairs") or []
+        if not pairs:
+            return None
+        best = max(pairs, key=lambda p: (p.get("liquidity", {}) or {}).get("usd", 0))
+        mc = best.get("marketCap")
+        fdv = best.get("fdv")
+        if isinstance(mc, (int, float)) and mc > 0:
+            return float(mc)
+        if isinstance(fdv, (int, float)) and fdv > 0:
+            return float(fdv)
+        return None
+    except:
+        return None
 
-# ===== Creative CA message with MCAP + links =====
-def build_midas_message_for_ca(ca: str, tier_label: str, *, mcap_value=None, body_snippet: Optional[str] = None, dexs_link: Optional[str] = None) -> str:
-    """
-    Creative brand style untuk CA:
-      - Tampilkan MCAP kalau tersedia
-      - Sisipkan Dexscreener & Axiom
-      - Copy 'first alert 1.5×' menuju discovery (no ceilings)
-    """
-    dexs_link = dexs_link
+def build_midas_message_for_ca(ca: str, tier_label: str, *, mcap_value=None, dexs_link: Optional[str] = None) -> str:
     axiom_link = "https://axiom.trade/@1144321"
     mcap_line = f"MCAP (est.): {_fmt_big_usd(mcap_value)}"
-
     first_alert = _M_LIST[0] if _M_LIST else "1.5"
 
     lines = [
@@ -642,49 +577,24 @@ def build_midas_message_for_ca(ca: str, tier_label: str, *, mcap_value=None, bod
         f"Auto-track armed → first alert at **{first_alert}×**; we hunt momentum to price discovery — no ceilings. 🎯",
         "",
         "Plan the trade, trade the plan. Cut losers quick, compound the wins.",
-        
     ]
-    msg = "\n".join(lines)
-
-    # (opsional) sisipkan snippet sumber
-    if body_snippet:
-        snippet = re.sub(r"\n{3,}", "\n\n", body_snippet.strip())
-        if snippet:
-            msg += "\n\n> " + snippet.replace("\n", "\n> ")
-
-    return msg
-
-def format_body_with_spacing(body: str, tier_label: str) -> str:
-    if not body:
-        return f"[{tier_label}]"
-    raw_lines = [ln.strip() for ln in body.splitlines()]
-    raw_lines = [ln for ln in raw_lines if ln != ""]
-    formatted: List[str] = []
-    trigger_words = ("stats", "ca", "links", "security", "trade carefully")
-    for line in raw_lines:
-        low = line.lower()
-        if any(tw in low for tw in trigger_words):
-            if formatted and formatted[-1] != "":
-                formatted.append("")
-        formatted.append(line)
-    pretty = "\n".join(formatted)
-    pretty = re.sub(r"\n{3,}", "\n\n", pretty).strip()
-    return f"[{tier_label}]\n\n{pretty}"
-
-async def _send_initial(msg, text: str) -> int:
+    return "\n".join(lines)
+
+# =========================
+# Post helpers
+# =========================
+async def _send_initial(src_msg, text: str) -> int:
     if DRY_RUN:
         print("[DRY_RUN] send_initial:", text[:140])
         return -1
-    if INCLUDE_MEDIA and is_image_message(msg) and not media_too_big(msg):
+    if INCLUDE_MEDIA and is_image_message(src_msg) and not media_too_big(src_msg):
         try:
-            if getattr(msg, "photo", None):
-                m = await client.send_file(
-                    TARGET_CHAT, msg.photo, caption=text, caption_entities=None, force_document=False
-                )
+            if getattr(src_msg, "photo", None):
+                m = await client.send_file(TARGET_CHAT, src_msg.photo, caption=text, caption_entities=None, force_document=False)
                 return m.id
-            doc = getattr(msg, "document", None)
+            doc = getattr(src_msg, "document", None)
             if doc:
-                data = await client.download_media(msg, file=bytes)
+                data = await client.download_media(src_msg, file=bytes)
                 if data:
                     bio = io.BytesIO(data)
                     ext = ".jpg"
@@ -695,13 +605,11 @@ async def _send_initial(msg, text: str) -> int:
                             ext_guess = ".jpg"
                         ext = ext_guess
                     bio.name = f"media{ext}"
-                    m = await client.send_file(
-                        TARGET_CHAT, bio, caption=text, caption_entities=None, force_document=False
-                    )
+                    m = await client.send_file(TARGET_CHAT, bio, caption=text, caption_entities=None, force_document=False)
                     return m.id
         except FloodWaitError as e:
             await asyncio.sleep(e.seconds + 1)
-            return await _send_initial(msg, text)
+            return await _send_initial(src_msg, text)
         except Exception as e:
             debug_log("Gagal kirim media awal, fallback text", str(e))
     try:
@@ -709,43 +617,29 @@ async def _send_initial(msg, text: str) -> int:
         return m.id
     except FloodWaitError as e:
         await asyncio.sleep(e.seconds + 1)
-        return await _send_initial(msg, text)
+        return await _send_initial(src_msg, text)
 
 async def post_or_update(keyword: str, body: str, new_tier: str, src_msg, *, update_like: bool = False, allow_tier_upgrade: bool = True) -> None:
-    """
-    Modified:
-    - If `keyword` represents a Contract Address (ca:evm:/ca:sol:),
-      we format with brand style via build_midas_message_for_ca
-      and menambahkan MCAP (fetch sekali sebelum kirim).
-    """
     prev = last_posted.get(keyword)
     now_ts = datetime.now().timestamp()
 
-    # Choose text based on whether this is a CA entity or not
     if _is_ca_key(keyword):
         ca_val = _ca_from_key(keyword)
-        mcap_val = await _fetch_initial_mcap(ca_val)  # ambil MCAP sekali
-        # NEW: bangun URL Dexs yang benar (Sol/EVM/Base, dll)
+        mcap_val = await _fetch_initial_mcap(ca_val)
         dexs_link = await _dexs_link_universal(ca_val, body)
-        text_to_send = build_midas_message_for_ca(
-            ca_val, new_tier,
-            mcap_value=mcap_val,
-            body_snippet=None,
-            dexs_link=dexs_link,
-        )
+        text_to_send = build_midas_message_for_ca(ca_val, new_tier, mcap_value=mcap_val, dexs_link=dexs_link)
     else:
-        text_to_send = format_body_with_spacing(body, new_tier)
+        # fallback (non-CA) — jarang dipakai karena filter CA-only
+        text_to_send = f"[{new_tier}]\n\n{body}"
 
     if not prev:
         msg_id = await _send_initial(src_msg, text_to_send)
         last_posted[keyword] = {"msg_id": msg_id, "tier": new_tier}
-        last_body[keyword] = body
-        last_update_ts[keyword] = now_ts
         if msg_id != -1:
             db_save_last_posted(keyword, msg_id, new_tier)
         return
 
-    # Tier upgrade?
+    # tier upgrade
     if TIER_ORDER.get(new_tier, 0) > TIER_ORDER.get(prev["tier"], 0):
         if not allow_tier_upgrade:
             if not update_like:
@@ -757,8 +651,6 @@ async def post_or_update(keyword: str, body: str, new_tier: str, src_msg, *, upd
                     await client.send_message(TARGET_CHAT, text_to_send, reply_to=prev["msg_id"], link_preview=True)
                 else:
                     await client.send_message(TARGET_CHAT, text_to_send, link_preview=True)
-                last_body[keyword] = body
-                last_update_ts[keyword] = now_ts
             except FloodWaitError as e:
                 await asyncio.sleep(e.seconds + 1)
             except Exception as e:
@@ -767,8 +659,6 @@ async def post_or_update(keyword: str, body: str, new_tier: str, src_msg, *, upd
         try:
             await client.edit_message(TARGET_CHAT, prev["msg_id"], text_to_send)
             prev["tier"] = new_tier
-            last_body[keyword] = body
-            last_update_ts[keyword] = now_ts
             if prev["msg_id"] != -1:
                 db_save_last_posted(keyword, prev["msg_id"], new_tier)
         except FloodWaitError as e:
@@ -778,36 +668,26 @@ async def post_or_update(keyword: str, body: str, new_tier: str, src_msg, *, upd
             debug_log("Edit gagal (tier naik), fallback kirim baru", str(e))
             msg_id = await _send_initial(src_msg, text_to_send)
             last_posted[keyword] = {"msg_id": msg_id, "tier": new_tier}
-            last_body[keyword] = body
-            last_update_ts[keyword] = now_ts
             if msg_id != -1:
                 db_save_last_posted(keyword, msg_id, new_tier)
         return
 
-    # No tier upgrade; maybe update-like?
+    # no tier upgrade; maybe update-like?
     if not update_like:
         return
-    if body.strip() == last_body.get(keyword, "").strip() and (now_ts - last_update_ts.get(keyword, 0) < UPDATE_COOLDOWN_SEC):
-        return
+    # cooldown
+    # (opsional: track last_update_ts jika ingin)
     try:
         if UPDATE_STRATEGY == "edit":
             await client.edit_message(TARGET_CHAT, prev["msg_id"], text_to_send)
-            last_body[keyword] = body
-            last_update_ts[keyword] = now_ts
             if prev["msg_id"] != -1:
                 db_save_last_posted(keyword, prev["msg_id"], new_tier)
         elif UPDATE_STRATEGY == "reply":
             await client.send_message(TARGET_CHAT, text_to_send, reply_to=prev["msg_id"], link_preview=True)
-            last_body[keyword] = body
-            last_update_ts[keyword] = now_ts
         elif UPDATE_STRATEGY == "new":
             await client.send_message(TARGET_CHAT, text_to_send, link_preview=True)
-            last_body[keyword] = body
-            last_update_ts[keyword] = now_ts
         else:
             await client.edit_message(TARGET_CHAT, prev["msg_id"], text_to_send)
-            last_body[keyword] = body
-            last_update_ts[keyword] = now_ts
             if prev["msg_id"] != -1:
                 db_save_last_posted(keyword, prev["msg_id"], new_tier)
     except FloodWaitError as e:
@@ -816,26 +696,23 @@ async def post_or_update(keyword: str, body: str, new_tier: str, src_msg, *, upd
     except Exception as e:
         debug_log("Update gagal (strategy)", str(e))
 
-
-# ========= Core actions =========
+# =========================
+# Raw forward helper
+# =========================
 async def send_as_is(msg, text_override: Optional[str] = None) -> None:
     if DRY_RUN:
         print("[DRY_RUN] send_as_is:", (text_override or msg.message or "")[:140])
         return
-
     if text_override is not None:
         orig_text = text_override
         entities = None
     else:
         orig_text = msg.message or (getattr(msg, "raw_text", None) or "")
         entities = getattr(msg, "entities", None)
-
     if INCLUDE_MEDIA and is_image_message(msg) and not media_too_big(msg):
         try:
             if getattr(msg, "photo", None):
-                await client.send_file(
-                    TARGET_CHAT, msg.photo, caption=orig_text, caption_entities=entities, force_document=False
-                )
+                await client.send_file(TARGET_CHAT, msg.photo, caption=orig_text, caption_entities=entities, force_document=False)
                 return
             doc = getattr(msg, "document", None)
             if doc:
@@ -850,23 +727,21 @@ async def send_as_is(msg, text_override: Optional[str] = None) -> None:
                             ext_guess = ".jpg"
                         ext = ext_guess
                     bio.name = f"media{ext}"
-                    await client.send_file(
-                        TARGET_CHAT, bio, caption=orig_text, caption_entities=entities, force_document=False
-                    )
+                    await client.send_file(TARGET_CHAT, bio, caption=orig_text, caption_entities=entities, force_document=False)
                     return
         except FloodWaitError as e:
             await asyncio.sleep(e.seconds + 1)
         except Exception as e:
             debug_log("Gagal kirim sebagai media, fallback ke text", str(e))
-
     try:
         await client.send_message(TARGET_CHAT, orig_text, formatting_entities=entities, link_preview=True)
     except FloodWaitError as e:
         await asyncio.sleep(e.seconds + 1)
         await client.send_message(TARGET_CHAT, orig_text, formatting_entities=entities, link_preview=True)
 
-
-# ========= Keyword & entity extraction =========
+# =========================
+# Keyword & entity extraction
+# =========================
 TICKER_CLEAN_RE = re.compile(r"\$[A-Za-z0-9]{2,12}")
 TICKER_NOISY_RE = re.compile(r"\$[A-Za-z0-9](?:[^A-Za-z0-9]+[A-Za-z0-9]){1,11}")
 
@@ -885,43 +760,6 @@ def _extract_tickers(text_norm: str) -> List[str]:
             uniq.append(x); seen.add(x)
     return uniq
 
-def _extract_all_keywords(text_norm: str) -> List[str]:
-    t = re.sub(r"\$([a-z0-9]+)", r"\1", text_norm, flags=re.I)
-    found = []
-    for kw in THEME_KEYWORDS:
-        if re.search(rf"(^|\W){re.escape(kw)}(\W|$)", t, flags=re.I):
-            found.append(kw.lower())
-    found.extend(_extract_tickers(text_norm))
-    seen = set(); uniq = []
-    for x in found:
-        if x not in seen:
-            uniq.append(x); seen.add(x)
-    return uniq
-
-def _choose_dominant_keyword(text_norm: str, kws: List[str]) -> Optional[str]:
-    if not kws:
-        return None
-    score = {}
-    for kw in kws:
-        cnt = len(re.findall(rf"(^|\W){re.escape(kw)}(\W|$)", text_norm, flags=re.I))
-        first = re.search(rf"(^|\W){re.escape(kw)}(\W|$)", text_norm, flags=re.I)
-        first_idx = first.start() if first else 1_000_000
-        bonus = 1 if kw.startswith("$") else 0
-        score[kw] = (cnt, bonus, -first_idx)
-    chosen = sorted(score.items(), key=lambda x: (x[1][0], x[1][1], x[1][2]), reverse=True)[0][0]
-    return chosen
-
-def _role_of(chat_id: int) -> str:
-    return chat_roles.get(chat_id, "support")
-
-def _unique_counts_by_role(keyword: str) -> Tuple[int, int]:
-    bucket = keyword_group_last_seen.get(keyword, {})
-    core_ids, sup_ids = set(), set()
-    for gk in bucket.keys():
-        role = chat_roles.get(int(gk), "support")
-        (core_ids if role == "core" else sup_ids).add(gk)
-    return len(core_ids), len(sup_ids)
-
 def extract_entity_key(text: str) -> Optional[str]:
     t = normalize_for_filter(text)
     m_evm = CA_EVM_RE.search(t)
@@ -931,13 +769,44 @@ def extract_entity_key(text: str) -> Optional[str]:
             return f"ca:evm:{m_evm.group(0).lower()}"
         else:
             return f"ca:sol:{m_sol.group(0)}"
+    # jika ingin dukung ticker: return "ticker:<sym>"
     tickers = _extract_tickers(t.lower())
     if tickers:
         return f"ticker:{tickers[0][1:].lower()}"
     return None
 
+# =========================
+# Phanes / leaderboard filter
+# =========================
+PHANES_BOT_ID: Optional[int] = None
+LB_TEXT_RE = re.compile(r"(🏆\s*Leaderboard|📊\s*Group\s*Stats)", re.IGNORECASE)
+ZERO_WIDTH_RE = re.compile(r"[\u200b\u200c\u200d\u2060\ufeff]")
+
+def _hash_text_1line(t: str) -> str:
+    t1 = re.sub(r"\s+", " ", (t or "")).strip()
+    return hashlib.sha1(t1.encode("utf-8", errors="ignore")).hexdigest()
+
+def _normalize_lb_for_hash(t: str) -> str:
+    if not t:
+        return ""
+    t = ZERO_WIDTH_RE.sub("", t)
+    t = re.sub(r"\b\d+(\.\d+)?%?\b", "<n>", t)  # angka volatile
+    t = re.sub(r"\s+", " ", t).strip().lower()
+    return t
+
+def _is_true_leaderboard(text: str) -> bool:
+    if not text:
+        return False
+    if not re.search(r"🏆\s*Leaderboard", text):
+        return False
+    if not re.search(r"📊\s*Group\s*Stats", text):
+        return False
+    if LB_REQUIRE_MIN_RANKS > 0:
+        ranks = re.findall(r"(?m)^\s*[\W\s]*\d{1,2}\s+.+\[[\d\.]+x\]\s*$", text)
+        if len(ranks) < LB_REQUIRE_MIN_RANKS:
+            return False
+    return True
 
-# ========= NEW: Filter Phanes di jalur umum =========
 async def _is_phanes_and_not_leaderboard(msg, text: str) -> bool:
     try:
         if getattr(msg, "via_bot_id", None) and PHANES_BOT_ID is not None:
@@ -951,6 +820,19 @@ async def _is_phanes_and_not_leaderboard(msg, text: str) -> bool:
         pass
     return False
 
+# =========================
+# Core processing
+# =========================
+def _role_of(chat_id: int) -> str:
+    return chat_roles.get(chat_id, "support")
+
+def _unique_counts_by_role(keyword: str) -> Tuple[int, int]:
+    bucket = keyword_group_last_seen.get(keyword, {})
+    core_ids, sup_ids = set(), set()
+    for gk in bucket.keys():
+        role = chat_roles.get(int(gk), "support")
+        (core_ids if role == "core" else sup_ids).add(gk)
+    return len(core_ids), len(sup_ids)
 
 async def process_message(msg, source_chat_id: int) -> None:
     orig_text = msg.message or (getattr(msg, "raw_text", None) or "")
@@ -970,6 +852,7 @@ async def process_message(msg, source_chat_id: int) -> None:
     if not (entity_key and entity_key.startswith("ca:")):
         debug_log("Bukan pesan CA, dilewati", orig_text)
         return
+
     duplicate_entity = bool(entity_key and entity_key in recent_entity_keys)
 
     UPDATE_HINTS = [
@@ -1003,47 +886,39 @@ async def process_message(msg, source_chat_id: int) -> None:
     if score < RELEVANCE_THRESHOLD and not allow_by_ca:
         return
 
+    # tentukan role
     role = _role_of(source_chat_id)
-    all_kws = _extract_all_keywords(text_norm)
-    main_kw = _choose_dominant_keyword(text_norm, all_kws)
-
-    topic_key = entity_key
-    if not topic_key:
-        debug_log("Tak ada keyword/entitas cocok, dilewati", orig_text)
-        return
 
+    # update bucket unik
     group_key = str(source_chat_id)
     now = datetime.now(timezone.utc)
-    class_label, unique_groups, is_new_group = update_and_classify(topic_key, group_key, now)
+    class_label, unique_groups, is_new_group = update_and_classify(entity_key, group_key, now)
 
-    # --- RULE BARU (global): Low hanya boleh dipost jika sudah >= LOW_MIN_UNIQUE call unik
+    # RULE: Low harus >= LOW_MIN_UNIQUE unik
     if TIER_ORDER.get(class_label, 0) == TIER_ORDER["Low 🌱"] and unique_groups < LOW_MIN_UNIQUE:
-        debug_log(f"Tahan: butuh >= {LOW_MIN_UNIQUE} call untuk Low (unique_groups={unique_groups})", orig_text)
+        debug_log(f"Tahan Low: butuh >= {LOW_MIN_UNIQUE} call (unique_groups={unique_groups})", orig_text)
         return
 
-    # --- Rule lama: tahan support bila belum ada core & support unik belum cukup
+    # Rule lama: tahan support bila belum ada core & support unik belum cukup
     if role != "core":
-        core_u, sup_u = _unique_counts_by_role(topic_key)
+        core_u, sup_u = _unique_counts_by_role(entity_key)
         if core_u < 1 and sup_u < SUPPORT_MIN_UNIQUE:
-            debug_log(
-                f"Support ditahan (core_u={core_u}, sup_u={SUPPORT_MIN_UNIQUE})",
-                orig_text,
-            )
+            debug_log(f"Support ditahan (core_u={core_u}, sup_u<{SUPPORT_MIN_UNIQUE})", orig_text)
             return
 
-    # --- RULE BARU (khusus support): Support minimal Medium
+    # RULE BARU (khusus support): Support minimal Medium
     if role == "support" and TIER_ORDER.get(class_label, 0) < TIER_ORDER["Medium ⚡"]:
         debug_log("Support Low diblok (minimal Medium)", orig_text)
         return
 
+    # bersihkan ajakan/iklan
     cleaned_body = filter_invite_sentences(orig_text)
     if not cleaned_body.strip():
         debug_log("Semua kalimat terfilter (kosong), dilewati", orig_text)
         return
 
-    cutoff = startup_time_utc - timedelta(
-        minutes=CLASS_WINDOW_MINUTES + BACKFILL_BUFFER_MINUTES
-    )
+    # cutoff backfill
+    cutoff = startup_time_utc - timedelta(minutes=CLASS_WINDOW_MINUTES + BACKFILL_BUFFER_MINUTES)
     if getattr(msg, "date", None):
         msg_dt = msg.date
         if isinstance(msg_dt, datetime) and msg_dt.replace(tzinfo=timezone.utc) < cutoff:
@@ -1054,7 +929,7 @@ async def process_message(msg, source_chat_id: int) -> None:
         recent_entity_keys.append(entity_key)
 
     await post_or_update(
-        topic_key,
+        entity_key,
         cleaned_body,
         class_label,
         msg,
@@ -1063,20 +938,27 @@ async def process_message(msg, source_chat_id: int) -> None:
     )
 
     debug_log(
-        f"Posted/Edited (role={role}, unique_groups={unique_groups}, new_group={is_new_group}, key={topic_key}, tier={class_label}, update_like={update_like})",
+        f"Posted/Edited (role={role}, unique_groups={unique_groups}, new_group={is_new_group}, key={entity_key}, tier={class_label}, update_like={update_like})",
         orig_text,
     )
 
-
-# ========= Event handlers =========
+# =========================
+# Event handlers
+# =========================
 @client.on(events.NewMessage(chats=SOURCE_CHATS))
 async def on_new_message(event):
     try:
-        await process_message(event.message, source_chat_id=abs(event.chat_id))
+        # map chat id ke role saat pertama kali terlihat
+        cid = abs(event.chat_id)
+        if cid not in chat_roles:
+            # naive: jika id ada di CORE_CHATS maka "core", else "support"
+            # (Telethon id != url, tapi kita bisa isi mapping manual jika perlu)
+            # Default ke "support" dulu:
+            chat_roles[cid] = "support"
+        await process_message(event.message, source_chat_id=cid)
     except Exception as e:
         print(f"Process error di chat {event.chat_id}: {e}")
 
-# === Leaderboard listener (ketat) ===
 @client.on(events.NewMessage(chats=(LEADERBOARD_GROUP,)))
 async def on_leaderboard_reply(event):
     try:
@@ -1105,23 +987,30 @@ async def on_leaderboard_reply(event):
         if not _is_true_leaderboard(text):
             return
 
+        # cooldown anti-spam
         global _last_lb_hash, _last_lb_ts
+        try:
+            _last_lb_hash
+        except NameError:
+            _last_lb_hash = None
+            _last_lb_ts = None
+
         h = _hash_text_1line(_normalize_lb_for_hash(text))
-        now = asyncio.get_event_loop().time()
-        if _last_lb_hash == h and _last_lb_ts is not None and (now - _last_lb_ts) < LEADERBOARD_COOLDOWN_SEC:
+        nowt = asyncio.get_event_loop().time()
+        if _last_lb_hash == h and _last_lb_ts is not None and (nowt - _last_lb_ts) < LEADERBOARD_COOLDOWN_SEC:
             return
         _last_lb_hash = h
-        _last_lb_ts = now
+        _last_lb_ts = nowt
 
         await send_as_is(msg)
         debug_log("Forward Leaderboard", text[:120])
     except Exception as e:
         debug_log("LB forward error", str(e))
 
-
-# ========= Scheduler: /lb acak per JAM =========
+# =========================
+# Scheduler: /lb acak
+# =========================
 async def periodic_lb_trigger():
-    """Kirim /lb ke LEADERBOARD_GROUP tiap interval acak (jam)."""
     try:
         lb_ent = await client.get_entity(LEADERBOARD_GROUP)
     except Exception as e:
@@ -1142,90 +1031,23 @@ async def periodic_lb_trigger():
 
             await client.send_message(lb_ent, LB_TRIGGER)
             print("[LB-SCHED] /lb sent")
-        except FloodWaitError as fw:
-            print(f"[LB-SCHED] FloodWait {fw.seconds}s, menunggu...")
-            await asyncio.sleep(fw.seconds + 2)
-        except Exception as e:
-            print(f"[LB-SCHED] Error: {e} — cooldown 5m & lanjut")
-            await asyncio.sleep(300)
-
-
-# ========= Entry points =========
-async def _resolve_and_tag_chats(raw_list, role_label: str) -> list:
-    resolved = []
-    for src in raw_list:
-        try:
-            ent = await client.get_entity(src)
-            resolved.append(ent)
-            chat_roles[abs(int(ent.id))] = role_label
         except Exception as e:
-            print(f"Gagal resolve sumber {src}: {e}")
-    return resolved
+            print("[LB-SCHED] error:", e)
+            await asyncio.sleep(60)
 
-
-async def start_bot_background() -> None:
+# =========================
+# Main
+# =========================
+async def main():
     await client.start()
-    _init_db()
-
-    global last_posted, keyword_group_last_seen, PHANES_BOT_ID
-    last_posted, keyword_group_last_seen = db_load_state()
-
-    await _resolve_and_tag_chats(CORE_CHATS, "core")
-    await _resolve_and_tag_chats(SUPPORT_CHATS, "support")
-
+    # (opsional) mulai scheduler leaderboard
     try:
-        ph_ent = await client.get_entity(LEADERBOARD_BOT)
-        PHANES_BOT_ID = abs(int(ph_ent.id))
-        print(f"Resolved Phanes bot id: {PHANES_BOT_ID}")
+        asyncio.create_task(periodic_lb_trigger())
     except Exception as e:
-        print(f"Gagal resolve LEADERBOARD_BOT: {e} (fallback pola teks)")
-
-    # (opsional) trigger awal
-    try:
-        lb_ent = await client.get_entity(LEADERBOARD_GROUP)
-        await client.send_message(lb_ent, LB_TRIGGER)
-        print("/lb dikirim untuk percobaan. Menunggu balasan bot...")
-    except Exception as e:
-        print(f"Gagal resolve/trigger leaderboard group: {e}")
-
-    # === START SCHEDULER /lb acak per JAM ===
-    asyncio.create_task(periodic_lb_trigger())
-
-    print("Kurator berjalan (background task). Menunggu pesan baru...")
-    asyncio.create_task(client.run_until_disconnected())
-
-
-async def app_main() -> None:
-    await client.start()
-    _init_db()
-
-    global last_posted, keyword_group_last_seen, PHANES_BOT_ID
-    last_posted, keyword_group_last_seen = db_load_state()
-
-    await _resolve_and_tag_chats(CORE_CHATS, "core")
-    await _resolve_and_tag_chats(SUPPORT_CHATS, "support")
-
-    try:
-        ph_ent = await client.get_entity(LEADERBOARD_BOT)
-        PHANES_BOT_ID = abs(int(ph_ent.id))
-        print(f"Resolved Phanes bot id: {PHANES_BOT_ID}")
-    except Exception as e:
-        print(f"Gagal resolve LEADERBOARD_BOT: {e} (fallback pola teks)")
-
-    # (opsional) trigger awal
-    try:
-        lb_ent = await client.get_entity(LEADERBOARD_GROUP)
-        await client.send_message(lb_ent, LB_TRIGGER)
-        print("/lb dikirim untuk percobaan. Menunggu balasan bot...")
-    except Exception as e:
-        print(f"Gagal trigger leaderboard group: {e}")
-
-    # === START SCHEDULER /lb acak per JAM ===
-    asyncio.create_task(periodic_lb_trigger())
-
-    print("Kurator berjalan. Menunggu pesan baru... (Stop dengan interrupt).")
+        print("[LB-SCHED] not started:", e)
+    print("INFO:     Application startup complete.")
+    print("INFO:     Uvicorn running on http://0.0.0.0:7860 (Press CTRL+C to quit)")
     await client.run_until_disconnected()
 
-
 if __name__ == "__main__":
-    asyncio.run(app_main())
+    asyncio.run(main())