Update app.py

app.py

@@ -1,1631 +1,322 @@
-"""
-╔══════════════════════════════════════════════════════════════════════════╗
-║  AGENTFORGE v2 — Full Agentic Telegram Bot (Hugging Face Ready)        ║
-║                                                                        ║
-║  • Curl Bridge bypasses HF network restrictions                        ║
-║  • 10 coordinated AI agents working as a team                          ║
-║  • 30+ tools with full system access                                   ║
-║  • Always-alive Doctor health monitor                                   ║
-║  • Admin-only power • Group-safe • Self-evolving                       ║
-║  • Image AI+PIL • Voice • Documents • Multi-model                      ║
-║  • Supabase + SQLite + ChromaDB triple memory                          ║
-║  • Bot spawner • Workflows • Broadcasts                                ║
-╚══════════════════════════════════════════════════════════════════════════╝
-"""
-
-import logging, asyncio, os, sys, json, subprocess, threading, time
-import base64, io, re, hashlib, traceback
-from datetime import datetime, timedelta
+import asyncio
+import json
+import logging
+import os
+import re
+import subprocess
+import threading
+import time
 from urllib.parse import urlparse
-from pathlib import Path
 
-# ── Flask Bridge ──
 from flask import Flask, request, Response
 
-# ── Aiogram ──
-from aiogram import Bot, Dispatcher, types, F
+from aiogram import Bot, Dispatcher, F, types
 from aiogram.filters import CommandStart, Command
-from aiogram.types import (
-    InlineKeyboardMarkup, InlineKeyboardButton,
-    BufferedInputFile, FSInputFile, CallbackQuery, Message,
-    InlineQuery, InlineQueryResultArticle, InputTextMessageContent,
-    BotCommand,
-)
-from aiogram.enums import ParseMode, ChatAction, ChatType
+from aiogram.enums import ParseMode, ChatType, ChatAction
 from aiogram.client.session.aiohttp import AiohttpSession
 from aiogram.client.telegram import TelegramAPIServer
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
-# ── Our Brain ──
-from agent import (
-    Config, Permission, DB, SupabaseDB, llm, memory, tools,
-    orchestrator, agent_team, doctor, rate_limiter,
-    ImageProcessor, AGENTS, ALL_TOOLS_SCHEMA,
-)
+from agent import Config, DB, Permission, tools, engine, scheduler, live_log, TOOLS_SCHEMA
 
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-    handlers=[
-        logging.StreamHandler(),
-        logging.FileHandler(os.path.join(Config.LOGS_DIR, "bot.log"), encoding="utf-8"),
-    ]
-)
-log = logging.getLogger("AgentForge")
+logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
+log = logging.getLogger("app")
 
+# =========================================================
+# HF CURL BRIDGE (Telegram API proxy)
+# =========================================================
 
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║          🌉 CURL BRIDGE — BYPASSES HF NETWORK BLOCK              ║
-# ║                                                                   ║
-# ║  HF blocks direct Python HTTP to api.telegram.org                 ║
-# ║  But curl subprocess + --resolve + CF Worker = ✅                 ║
-# ║                                                                   ║
-# ║  Flow: Bot → localhost:7860 → curl → CF Worker → Telegram API    ║
-# ╚═══════════════════════════════════════════════════════════════════╝
+BRIDGE_PORT = int(os.getenv("BRIDGE_PORT", "7860"))
+PROXY_TARGET = os.getenv("PROXY_TARGET", "https://api.telegram.org")  # ideally your Cloudflare Worker
+CLOUDFLARE_IP = os.getenv("CLOUDFLARE_IP", "")  # optional
 
 flask_app = Flask(__name__)
+BOOT = time.time()
 
-@flask_app.route('/')
+@flask_app.route("/")
 def health():
-    uptime = time.time() - BOOT_TIME
-    h, m = divmod(int(uptime), 3600)
-    mins, s = divmod(m, 60)
     return json.dumps({
-        "status": "✅ AgentForge Running",
-        "uptime": f"{h}h {mins}m {s}s",
-        "agents": len(AGENTS),
-        "tools": len(ALL_TOOLS_SCHEMA),
-        "models": len(llm.available_models()),
-        "spawned_bots": len(tools.spawned_bots),
+        "status": "ok",
+        "uptime_sec": int(time.time() - BOOT),
+        "bot_username": Config.BOT_USERNAME,
+        "admin_ids": Config.ADMIN_IDS,
     }), 200, {"Content-Type": "application/json"}
 
-
-@flask_app.route('/health')
-def health_detail():
-    """Detailed health endpoint for monitoring."""
-    try:
-        import psutil
-        return json.dumps({
-            "status": "ok",
-            "cpu": psutil.cpu_percent(),
-            "ram": psutil.virtual_memory().percent,
-            "disk": psutil.disk_usage('/').percent,
-        }), 200, {"Content-Type": "application/json"}
-    except:
-        return json.dumps({"status": "ok"}), 200
-
-
-def run_curl(method, url, data=None):
-    """Execute curl with optional CF IP resolution to bypass blocks."""
+def run_curl(method: str, url: str, data=None):
     parsed = urlparse(url)
     domain = parsed.hostname
 
     cmd = ["curl", "-X", method, url]
 
-    # Cloudflare IP resolve trick
-    if Config.CLOUDFLARE_IP and domain:
-        cmd += ["--resolve", f"{domain}:443:{Config.CLOUDFLARE_IP}"]
+    if CLOUDFLARE_IP and domain:
+        cmd += ["--resolve", f"{domain}:443:{CLOUDFLARE_IP}"]
 
     cmd += [
-        "-H", "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+        "-H", "User-Agent: Mozilla/5.0",
         "-H", "Content-Type: application/json",
-        "-k", "-s", "--max-time", "30",
+        "-k", "-s", "--max-time", "30"
     ]
 
-    input_str = None
-    if data:
-        cmd += ["--data-binary", "@-"]  # Read body from stdin
-        input_str = json.dumps(data)
+    stdin_payload = None
+    if data is not None:
+        cmd += ["--data-binary", "@-"]
+        stdin_payload = json.dumps(data)
 
     try:
-        result = subprocess.run(
-            cmd, input=input_str,
-            capture_output=True, text=True, timeout=35
-        )
-        if not result.stdout:
-            log.warning(f"Curl empty response. stderr: {result.stderr[:200]}")
-            return json.dumps({"ok": False, "description": f"Empty curl response: {result.stderr[:200]}"})
-        return result.stdout
-    except subprocess.TimeoutExpired:
-        return json.dumps({"ok": False, "description": "Curl timeout (35s)"})
+        r = subprocess.run(cmd, input=stdin_payload, capture_output=True, text=True, timeout=35)
+        if not r.stdout:
+            return json.dumps({"ok": False, "description": f"Empty curl response: {r.stderr[:200]}"})
+        return r.stdout
     except Exception as e:
         return json.dumps({"ok": False, "description": str(e)[:300]})
 
-
-@flask_app.route('/bot<token>/<method>', methods=['POST', 'GET'])
+@flask_app.route("/bot<token>/<method>", methods=["POST", "GET"])
 def proxy(token, method):
-    """Proxy Telegram API calls through curl."""
-    real_url = f"{Config.PROXY_TARGET}/bot{token}/{method}"
-
-    # Force-parse JSON body
+    real_url = f"{PROXY_TARGET}/bot{token}/{method}"
     data = request.get_json(force=True, silent=True)
     if not data:
         data = request.form.to_dict() or request.args.to_dict() or None
-
-    resp = run_curl(request.method, real_url, data)
-    return Response(resp, mimetype='application/json')
-
+    out = run_curl(request.method, real_url, data)
+    return Response(out, mimetype="application/json")
 
 def start_bridge():
-    """Start Flask bridge in a daemon thread."""
-    log.info(f"🌉 Starting curl bridge on 0.0.0.0:{Config.BRIDGE_PORT}")
-    # Suppress Flask request logs in production
-    wlog = logging.getLogger('werkzeug')
-    wlog.setLevel(logging.WARNING)
-    flask_app.run(host="0.0.0.0", port=Config.BRIDGE_PORT, threaded=True)
-
+    werk = logging.getLogger("werkzeug")
+    werk.setLevel(logging.WARNING)
+    log.info(f"Bridge running on 0.0.0.0:{BRIDGE_PORT} → {PROXY_TARGET} (resolve_ip={bool(CLOUDFLARE_IP)})")
+    flask_app.run(host="0.0.0.0", port=BRIDGE_PORT, threaded=True)
 
-BOOT_TIME = time.time()
 threading.Thread(target=start_bridge, daemon=True).start()
-time.sleep(3)
-log.info("🌉 Bridge ready")
-
+time.sleep(2)
 
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║                   🤖 BOT INITIALIZATION                          ║
-# ╚═══════════════════════════════════════════════════════════════════╝
+# =========================================================
+# Telegram Bot (Aiogram)
+# =========================================================
 
-session = AiohttpSession(
-    api=TelegramAPIServer.from_base(f"http://127.0.0.1:{Config.BRIDGE_PORT}")
-)
+session = AiohttpSession(api=TelegramAPIServer.from_base(f"http://127.0.0.1:{BRIDGE_PORT}"))
 bot = Bot(token=Config.BOT_TOKEN, session=session)
 dp = Dispatcher()
-scheduler = AsyncIOScheduler()
-
-# Per-user state (non-persistent, resets on restart)
-user_state: dict[int, dict] = {}
-
-
-def get_state(uid: int) -> dict:
-    if uid not in user_state:
-        user_state[uid] = {
-            "agent": None,
-            "model": None,
-            "awaiting": None,
-            "last_message": "",
-            "last_response": None,
-        }
-    return user_state[uid]
-
-
-def is_admin(uid: int) -> bool:
-    return Config.is_admin(uid)
-
-
-def is_group(message: Message) -> bool:
-    return message.chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
 
+def is_group(m: types.Message) -> bool:
+    return m.chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
 
-def should_respond_in_group(message: Message) -> bool:
-    """In groups: only respond to replies to bot or @mentions."""
-    if not is_group(message):
+def should_respond_in_group(m: types.Message) -> bool:
+    # Reply to bot message
+    if m.reply_to_message and m.reply_to_message.from_user and m.reply_to_message.from_user.id == bot.id:
         return True
 
-    # Reply to bot's message
-    if message.reply_to_message and message.reply_to_message.from_user:
-        if message.reply_to_message.from_user.id == bot.id:
-            return True
-
-    # @mention
-    bot_username = Config.BOT_USERNAME.lower()
-    if bot_username and message.text:
-        if f"@{bot_username}" in message.text.lower():
-            return True
+    # @mention by username
+    uname = (Config.BOT_USERNAME or "").lower()
+    if uname and m.text and f"@{uname}" in m.text.lower():
+        return True
 
-    # Check entities for mention
-    if message.entities:
-        for e in message.entities:
+    # entity mention
+    if uname and m.entities and m.text:
+        for e in m.entities:
             if e.type == "mention":
-                mention = message.text[e.offset:e.offset + e.length].lower()
-                if mention == f"@{bot_username}":
+                mention = m.text[e.offset:e.offset + e.length].lower()
+                if mention == f"@{uname}":
                     return True
 
     return False
 
-
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║                     📋 KEYBOARDS                                  ║
-# ╚═══════════════════════════════════════════════════════════════════╝
-
-def kb_main():
-    rows = [
-        [InlineKeyboardButton(text="💬 Chat", callback_data="agent:chat"),
-         InlineKeyboardButton(text="💻 Code", callback_data="agent:code"),
-         InlineKeyboardButton(text="🔬 Research", callback_data="agent:research")],
-        [InlineKeyboardButton(text="📋 Task", callback_data="agent:task"),
-         InlineKeyboardButton(text="🎨 Creative", callback_data="agent:creative"),
-         InlineKeyboardButton(text="⚙️ System", callback_data="agent:system")],
-        [InlineKeyboardButton(text="🔄 Model", callback_data="nav:models"),
-         InlineKeyboardButton(text="⚙️ Settings", callback_data="nav:settings"),
-         InlineKeyboardButton(text="📊 Stats", callback_data="nav:stats")],
-    ]
-    return InlineKeyboardMarkup(inline_keyboard=rows)
-
-
-def kb_agents():
-    rows = []
-    for key, info in AGENTS.items():
-        if key == "director": continue  # Director is always active
-        rows.append([InlineKeyboardButton(
-            text=f"{info['icon']} {info['name']}", callback_data=f"agent:{key}")])
-    rows.append([InlineKeyboardButton(text="🤖 Auto (Director decides)", callback_data="agent:auto")])
-    rows.append([InlineKeyboardButton(text="◀️ Back", callback_data="nav:main")])
-    return InlineKeyboardMarkup(inline_keyboard=rows)
-
-
-def kb_models():
-    models = llm.available_models()
-    rows = []
-    row = []
-    for m in models:
-        short = m.split("/")[-1]
-        if len(short) > 20: short = short[:18] + ".."
-        row.append(InlineKeyboardButton(text=short, callback_data=f"model:{m}"))
-        if len(row) == 2:
-            rows.append(row); row = []
-    if row: rows.append(row)
-    rows.append([InlineKeyboardButton(text="◀️ Back", callback_data="nav:main")])
-    return InlineKeyboardMarkup(inline_keyboard=rows)
-
-
-def kb_settings(uid):
-    user = DB.get_user(uid)
-    temp = user["temperature"] if user else 0.7
-    return InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text=f"🌡️ Temperature: {temp}", callback_data="set:temp")],
-        [InlineKeyboardButton(text="📝 Custom System Prompt", callback_data="set:sysprompt")],
-        [InlineKeyboardButton(text="🎭 Personas", callback_data="set:personas")],
-        [InlineKeyboardButton(text="🔄 Reset Everything", callback_data="set:reset")],
-        [InlineKeyboardButton(text="◀️ Back", callback_data="nav:main")],
-    ])
-
-
-def kb_temp():
-    temps = [(0.0,"🧊 0.0"),(0.3,"😊 0.3"),(0.5,"🙂 0.5"),(0.7,"😄 0.7"),(0.9,"🔥 0.9"),(1.0,"🌋 1.0")]
-    rows = [[InlineKeyboardButton(text=l, callback_data=f"temp:{t}") for t, l in temps[i:i+3]]
-            for i in range(0, len(temps), 3)]
-    return InlineKeyboardMarkup(inline_keyboard=rows)
-
-
-def kb_feedback():
-    return InlineKeyboardMarkup(inline_keyboard=[[
-        InlineKeyboardButton(text="👍", callback_data="fb:up"),
-        InlineKeyboardButton(text="👎", callback_data="fb:down"),
-        InlineKeyboardButton(text="🔄 Retry", callback_data="fb:retry"),
-        InlineKeyboardButton(text="🔊 Read", callback_data="fb:speak"),
-    ]])
-
-
-def kb_memory():
-    return InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="📝 View", callback_data="mem:view"),
-         InlineKeyboardButton(text="🔍 Search", callback_data="mem:search")],
-        [InlineKeyboardButton(text="🗑️ Clear All", callback_data="mem:clear"),
-         InlineKeyboardButton(text="◀️ Back", callback_data="nav:main")],
-    ])
-
-
-def kb_health():
-    return InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="🔄 Refresh", callback_data="health:refresh"),
-         InlineKeyboardButton(text="📋 Logs", callback_data="health:logs")],
-    ])
-
-
-def kb_admin():
-    return InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="📊 Full Stats", callback_data="adm:stats"),
-         InlineKeyboardButton(text="🏥 Health", callback_data="adm:health")],
-        [InlineKeyboardButton(text="📜 Tool Logs", callback_data="adm:toologs"),
-         InlineKeyboardButton(text="🤖 Bots", callback_data="adm:bots")],
-        [InlineKeyboardButton(text="🔄 Restart", callback_data="adm:restart"),
-         InlineKeyboardButton(text="💾 Backup DB", callback_data="adm:backup")],
-    ])
-
-
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║              💬 CORE RESPONSE SENDER (handles everything)        ║
-# ╚═══════════════════════════════════════════════════════════════════╝
-
-async def send_response(message: Message, response: dict):
-    """
-    Send the orchestrator's response. Handles:
-    - Long text splitting
-    - Image sending
-    - Audio/TTS sending
-    - Screenshot sending
-    - Tool usage footer
-    - Feedback buttons
-    - Broadcast / Restart triggers
-    """
-
-    # ── Handle special actions ──
-    if response.get("_restart"):
-        await message.answer("🔄 Restarting in 3 seconds...")
-        await asyncio.sleep(3)
-        os.execv(sys.executable, [sys.executable] + sys.argv)
-        return
-
-    if response.get("_broadcast"):
-        msg_text = response["_broadcast"]
-        users = DB.execute("SELECT telegram_id FROM users WHERE is_banned=0", fetch=True)
-        sent, fail = 0, 0
-        for u in users:
-            try:
-                await bot.send_message(u["telegram_id"],
-                    f"📢 <b>Announcement</b>\n\n{msg_text}", parse_mode=ParseMode.HTML)
-                sent += 1
-            except: fail += 1
-        await message.answer(f"📢 Broadcast complete: {sent} sent, {fail} failed")
-        # Also send the AI's text response
-        if response.get("text") and response["text"] != "Broadcast sent.":
-            pass  # Fall through to send text below
-        else:
-            return
-
-    text = response.get("text", "")
-    images = response.get("images", [])
-    audio_files = response.get("audio_files", [])
-    screenshots = response.get("screenshots", [])
-    tools_used = response.get("tools_used", [])
-    tokens = response.get("tokens", 0)
-    model = response.get("model", "")
-
-    # ── Build footer ──
-    footer = ""
-    if tools_used:
-        unique = list(dict.fromkeys(tools_used))[:10]
-        footer += f"\n\n🛠️ <i>{', '.join(unique)}</i>"
-    footer += f"\n👑 <i>Director | {model.split('/')[-1]} | {tokens:,} tokens</i>"
-
-    full_text = text + footer
-
-    # ── Send text (with splitting) ──
-    MAX_LEN = 4000
-    if len(full_text) <= MAX_LEN:
-        await _safe_send(message, full_text, reply_markup=kb_feedback())
-    else:
-        # Split at newlines
-        chunks = _split_text(text, MAX_LEN - 200)
-        for i, chunk in enumerate(chunks):
-            is_last = (i == len(chunks) - 1)
-            prefix = f"📄 <b>Part {i+1}/{len(chunks)}</b>\n\n" if len(chunks) > 1 else ""
-            suffix = footer if is_last else ""
-            await _safe_send(message, prefix + chunk + suffix,
-                             reply_markup=kb_feedback() if is_last else None)
-            if not is_last:
-                await asyncio.sleep(0.5)  # Rate limit protection
-
-    # ── Send images ──
-    for img_url in images:
-        try:
-            import aiohttp
-            async with aiohttp.ClientSession() as s:
-                async with s.get(img_url, timeout=aiohttp.ClientTimeout(total=30)) as r:
-                    img_bytes = await r.read()
-            await message.answer_photo(
-                photo=BufferedInputFile(img_bytes, filename="generated.png"),
-                caption="🎨 Generated Image")
-        except Exception as e:
-            await message.answer(f"🎨 Image URL: {img_url}")
-
-    # ── Send audio ──
-    for audio_path in audio_files:
-        try:
-            if os.path.exists(audio_path):
-                await message.answer_voice(
-                    voice=FSInputFile(audio_path),
-                    caption="🔊 Text-to-Speech")
-                # Cleanup
-                try: os.unlink(audio_path)
-                except: pass
-        except Exception as e:
-            log.warning(f"Audio send failed: {e}")
-
-    # ── Send screenshots ──
-    for ss_path in screenshots:
+def strip_mention(text: str) -> str:
+    if not text:
+        return text
+    uname = Config.BOT_USERNAME
+    if not uname:
+        return text
+    return re.sub(rf"@{re.escape(uname)}", "", text, flags=re.IGNORECASE).strip()
+
+async def safe_send(chat_id: int, text: str):
+    if not text:
+        text = "OK"
+    # Telegram message limit ~4096
+    chunks = [text[i:i+3500] for i in range(0, len(text), 3500)]
+    for c in chunks:
         try:
-            if os.path.exists(ss_path):
-                await message.answer_photo(
-                    photo=FSInputFile(ss_path),
-                    caption="📸 Screenshot")
-                try: os.unlink(ss_path)
-                except: pass
-        except Exception as e:
-            log.warning(f"Screenshot send failed: {e}")
-
-
-async def _safe_send(message: Message, text: str, **kwargs):
-    """Send with HTML, fallback to plain text."""
-    if not text.strip():
-        text = "✅ Done."
-    try:
-        await message.answer(text, parse_mode=ParseMode.HTML, **kwargs)
-    except Exception:
-        try:
-            # Strip HTML tags for fallback
-            import re
-            clean = re.sub(r'<[^>]+>', '', text)
-            await message.answer(clean, **kwargs)
-        except Exception as e:
-            await message.answer(f"Response error: {str(e)[:200]}")
-
-
-def _split_text(text: str, max_len: int) -> list[str]:
-    """Split text at natural break points."""
-    if len(text) <= max_len:
-        return [text]
-    chunks = []
-    remaining = text
-    while remaining:
-        if len(remaining) <= max_len:
-            chunks.append(remaining)
-            break
-        # Try to split at double newline, then single newline, then space
-        split_at = -1
-        for sep in ['\n\n', '\n', '. ', ' ']:
-            idx = remaining.rfind(sep, 0, max_len)
-            if idx > max_len // 3:  # Don't split too early
-                split_at = idx + len(sep)
-                break
-        if split_at == -1:
-            split_at = max_len
-        chunks.append(remaining[:split_at])
-        remaining = remaining[split_at:]
-    return chunks
-
-
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║           🔄 PROCESS PIPELINE (middleware → agent → send)        ║
-# ╚═══════════════════════════════════════════════════════════════════╝
-
-async def process_and_reply(message: Message, text: str,
-                            attachments: list = None, force_admin: bool = False):
-    """Full pipeline: auth → rate limit → orchestrator → send."""
-    uid = message.from_user.id
-    cid = message.chat.id
-    group = is_group(message)
-
-    # ── Middleware: Auth ──
-    user = DB.upsert_user(
-        uid,
-        message.from_user.username or "",
-        message.from_user.first_name or "",
-        message.from_user.last_name or "")
-
-    if user and user["is_banned"] and not is_admin(uid):
-        return await message.answer("🚫 You are banned from using this bot.")
-
-    # ── Middleware: Rate Limit ──
-    if rate_limiter.check(uid, is_admin(uid)):
-        return await message.answer(
-            "⏳ Rate limit reached. Please wait a moment.\n"
-            f"({'Unlimited' if is_admin(uid) else f'{Config.RATE_LIMIT_USER}/{Config.RATE_WINDOW}s'})")
-
-    # ── Non-admin in DM: limited response ──
-    if not is_admin(uid) and not group:
-        pass  # Allow but tools are filtered by Permission system
-
-    # ── Status message ──
-    status = await message.answer("💭 Thinking...")
-    try:
-        await bot.send_chat_action(cid, ChatAction.TYPING)
-    except: pass
-
-    # ── User settings ──
-    state = get_state(uid)
-    state["last_message"] = text
-
-    settings = {
-        "preferred_model": state.get("model") or (user["preferred_model"] if user else Config.DEFAULT_MODEL),
-        "temperature": user["temperature"] if user else 0.7,
-        "system_prompt": user["system_prompt"] if user else "",
-        "max_tokens": user["max_tokens"] if user else 4096,
-    }
-
-    try:
-        # ── Run orchestrator ──
-        response = await orchestrator.process(
-            user_id=uid, chat_id=cid, message=text,
-            model=settings["preferred_model"],
-            attachments=attachments,
-            user_settings=settings,
-            is_group=group)
-
-        # ── Update stats ──
-        DB.inc_usage(uid, response.get("tokens", 0))
-        state["last_response"] = response
-
-        # ── Delete status ──
-        try: await status.delete()
-        except: pass
-
-        # ── Send response ──
-        await send_response(message, response)
-
-    except Exception as e:
-        log.error(f"Processing error: {traceback.format_exc()}")
-        try:
-            await status.edit_text(f"❌ Error: {str(e)[:300]}")
+            await bot.send_message(chat_id, c, parse_mode=ParseMode.HTML, disable_web_page_preview=True)
         except:
-            await message.answer(f"❌ Error: {str(e)[:300]}")
-
-
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║                   📝 COMMAND HANDLERS                             ║
-# ╚═══════════════════════════════════════════════════════════════════╝
-
-@dp.message(CommandStart())
-async def cmd_start(message: Message):
-    uid = message.from_user.id
-    DB.upsert_user(uid, message.from_user.username or "",
-                   message.from_user.first_name or "", "")
-    name = message.from_user.first_name or "there"
-    is_adm = "👑 Admin" if is_admin(uid) else "👤 User"
-
-    # Dynamic buttons from Supabase
-    extra_buttons = await SupabaseDB.get_buttons()
-    extra_rows = []
-    row = []
-    for b in extra_buttons:
-        row.append(InlineKeyboardButton(text=b["label"], url=b["url"]))
-        if len(row) == 2:
-            extra_rows.append(row); row = []
-    if row: extra_rows.append(row)
-
-    kb = kb_main()
-    if extra_rows:
-        kb = InlineKeyboardMarkup(inline_keyboard=kb.inline_keyboard + extra_rows)
-
-    await message.answer(
-        f"""🚀 <b>Welcome to AgentForge, {name}!</b> ({is_adm})
-
-I'm a <b>fully autonomous multi-agent AI system</b>.
-
-👑 <b>Director</b> leads a team of <b>10 specialist agents</b>:
-  💻 Coder • 🔬 Researcher • ⚙️ SysAdmin
-  🎨 Creative • 📊 Analyst • 🏥 Doctor
-  📁 FileManager • 🛡️ Security
-
-🛠️ <b>30+ Tools</b> — Search, Code, Shell, Files,
-  Self-Modify, Bot Spawn, Images, TTS, Memory...
-
-🧠 <b>Triple Memory</b> — Remembers you forever
-🔄 <b>Multi-Model</b> — GPT / Claude / Gemini / Llama / Custom
-🏥 <b>Always-Alive</b> — Doctor monitors 24/7
-
-Just send a message or use /help!""",
-        parse_mode=ParseMode.HTML, reply_markup=kb)
-
-
-@dp.message(Command("help"))
-async def cmd_help(message: Message):
-    admin_section = """
-<b>👑 Admin:</b>
-/admin - Admin panel
-/broadcast &lt;msg&gt; - Send to all users
-/ban &lt;id&gt; / /unban &lt;id&gt;
-/premium &lt;id&gt; - Toggle premium
-/shell &lt;cmd&gt; - Run shell command
-/sysinfo - System details
-/health - Health check
-/logs - Recent tool logs
-/restart - Restart bot
-/addbutton &lt;label&gt;|&lt;url&gt; - Add /start button
-""" if is_admin(message.from_user.id) else ""
-
-    await message.answer(f"""📚 <b>AgentForge Help</b>
-
-<b>💬 Chat:</b>
-/start - Welcome screen
-/help - This menu
-/clear - Clear conversation
-/agent - Switch agent mode
-/model - Switch AI model
-/settings - Preferences
-
-<b>🛠️ Actions:</b>
-/search &lt;query&gt; - Web search
-/code &lt;code or task&gt; - Code execution
-/image &lt;desc&gt; - Generate image (DALL-E)
-/summarize &lt;text/url&gt; - Summarize
-/translate &lt;lang&gt; &lt;text&gt; - Translate
-/tts &lt;text&gt; - Text to speech
-
-<b>📁 Files:</b>
-/read &lt;path&gt; - Read file
-/write &lt;path&gt; &lt;content&gt; - Write file
-/ls &lt;path&gt; - List files
-
-<b>🧠 Memory:</b>
-/memory - Memory panel
-/remember &lt;fact&gt; - Store memory
-/recall &lt;query&gt; - Search memory
-
-<b>🤖 Advanced:</b>
-/newbot &lt;token&gt; - Spawn new bot
-/bots - List spawned bots
-/self &lt;instruction&gt; - Self-modify
-/workflow - Workflows
-/persona &lt;name&gt; &lt;prompt&gt; - Save persona
-/personas - List personas
-/tools - All available tools
-
-<b>📊 Info:</b>
-/stats - Your statistics
-/export - Export conversation
-/feedback &lt;msg&gt; - Feedback
-{admin_section}
-<b>💡 Also handles:</b> 📷 Photos, 🎙️ Voice, 📄 Documents, 😀 Stickers
-<b>💡 Groups:</b> Reply to my message or @mention me""",
-        parse_mode=ParseMode.HTML)
-
-
-@dp.message(Command("agent"))
-async def cmd_agent(message: Message):
-    state = get_state(message.from_user.id)
-    current = state.get("agent") or "auto (Director decides)"
-    await message.answer(
-        f"🤖 <b>Agent Mode</b>\nCurrent: <b>{current}</b>\n\nDirector always coordinates — choose a specialist focus:",
-        parse_mode=ParseMode.HTML, reply_markup=kb_agents())
-
-
-@dp.message(Command("model"))
-async def cmd_model(message: Message):
-    state = get_state(message.from_user.id)
-    current = state.get("model") or Config.DEFAULT_MODEL
-    await message.answer(f"🔄 <b>AI Model</b>\nCurrent: <code>{current}</code>",
-                         parse_mode=ParseMode.HTML, reply_markup=kb_models())
-
-
-@dp.message(Command("clear"))
-async def cmd_clear(message: Message):
-    uid = message.from_user.id
-    memory.clear(uid, message.chat.id)
-    get_state(uid).update({"agent": None, "last_message": "", "last_response": None})
-    await message.answer("🗑️ Conversation cleared! Starting fresh.")
-
-
-@dp.message(Command("settings"))
-async def cmd_settings(message: Message):
-    uid = message.from_user.id
-    user = DB.get_user(uid)
-    state = get_state(uid)
-    m = state.get("model") or (user["preferred_model"] if user else Config.DEFAULT_MODEL)
-    await message.answer(
-        f"⚙️ <b>Settings</b>\n\n"
-        f"🔄 Model: <code>{m}</code>\n"
-        f"🌡️ Temp: <code>{user['temperature'] if user else 0.7}</code>\n"
-        f"📝 Prompt: <code>{(user['system_prompt'][:40]+'...') if user and user['system_prompt'] else 'Default'}</code>",
-        parse_mode=ParseMode.HTML, reply_markup=kb_settings(uid))
-
-
-@dp.message(Command("search"))
-async def cmd_search(message: Message):
-    q = message.text.split(maxsplit=1)
-    if len(q) < 2: return await message.answer("Usage: /search &lt;query&gt;", parse_mode=ParseMode.HTML)
-    await process_and_reply(message, f"Research this thoroughly with multiple searches: {q[1]}")
-
-
-@dp.message(Command("code"))
-async def cmd_code(message: Message):
-    c = message.text.split(maxsplit=1)
-    if len(c) < 2: return await message.answer("Usage: /code &lt;code or description&gt;", parse_mode=ParseMode.HTML)
-    if not is_admin(message.from_user.id):
-        return await message.answer("🚫 Code execution is admin-only.")
-    await process_and_reply(message, c[1])
-
-
-@dp.message(Command("image"))
-async def cmd_image(message: Message):
-    p = message.text.split(maxsplit=1)
-    if len(p) < 2: return await message.answer("Usage: /image &lt;description&gt;", parse_mode=ParseMode.HTML)
-    await process_and_reply(message, f"Generate an image of: {p[1]}")
-
-
-@dp.message(Command("summarize"))
-async def cmd_summarize(message: Message):
-    text = message.text.split(maxsplit=1)
-    if len(text) < 2:
-        if message.reply_to_message and message.reply_to_message.text:
-            text = ["", message.reply_to_message.text]
-        else:
-            return await message.answer("Usage: /summarize &lt;text or URL&gt;", parse_mode=ParseMode.HTML)
-    await process_and_reply(message, f"Summarize this concisely:\n\n{text[1]}")
-
-
-@dp.message(Command("translate"))
-async def cmd_translate(message: Message):
-    parts = message.text.split(maxsplit=2)
-    if len(parts) < 3:
-        return await message.answer("Usage: /translate &lt;language&gt; &lt;text&gt;", parse_mode=ParseMode.HTML)
-    await process_and_reply(message, f"Translate to {parts[1]}:\n\n{parts[2]}")
-
-
-@dp.message(Command("tts"))
-async def cmd_tts(message: Message):
-    t = message.text.split(maxsplit=1)
-    if len(t) < 2: return await message.answer("Usage: /tts &lt;text&gt;", parse_mode=ParseMode.HTML)
-    status = await message.answer("🔊 Generating speech...")
-    try:
-        audio = await llm.tts(t[1])
-        if audio:
-            path = os.path.join(Config.DATA_DIR, f"tts_{int(time.time())}.mp3")
-            with open(path, "wb") as f: f.write(audio)
-            await message.answer_voice(voice=FSInputFile(path))
-            try: os.unlink(path)
-            except: pass
-        else:
-            await message.answer("❌ TTS unavailable (needs OpenAI key)")
-    except Exception as e:
-        await message.answer(f"❌ TTS error: {str(e)[:200]}")
-    try: await status.delete()
-    except: pass
-
-
-@dp.message(Command("read"))
-async def cmd_read(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    p = message.text.split(maxsplit=1)
-    if len(p) < 2: return await message.answer("Usage: /read &lt;path&gt;", parse_mode=ParseMode.HTML)
-    r = await tools.execute("file_read", {"path": p[1]}, message.from_user.id)
-    await _safe_send(message, r[:4000])
-
-
-@dp.message(Command("write"))
-async def cmd_write(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    parts = message.text.split(maxsplit=2)
-    if len(parts) < 3: return await message.answer("Usage: /write &lt;path&gt; &lt;content&gt;", parse_mode=ParseMode.HTML)
-    r = await tools.execute("file_write", {"path": parts[1], "content": parts[2]}, message.from_user.id)
-    await message.answer(r)
-
-
-@dp.message(Command("ls"))
-async def cmd_ls(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    p = message.text.split(maxsplit=1)
-    path = p[1] if len(p) > 1 else "."
-    r = await tools.execute("file_list", {"path": path}, message.from_user.id)
-    await _safe_send(message, r[:4000])
+            await bot.send_message(chat_id, c, disable_web_page_preview=True)
 
+# =========================================================
+# Scheduler hookup (24/7 autonomous tasks)
+# =========================================================
 
-@dp.message(Command("memory"))
-async def cmd_memory(message: Message):
-    await message.answer("🧠 <b>Memory Management</b>", parse_mode=ParseMode.HTML, reply_markup=kb_memory())
+async def scheduler_sender(chat_id: int, text: str):
+    await safe_send(chat_id, text)
 
+# =========================================================
+# Commands
+# =========================================================
 
-@dp.message(Command("remember"))
-async def cmd_remember(message: Message):
-    f = message.text.split(maxsplit=1)
-    if len(f) < 2: return await message.answer("Usage: /remember &lt;fact&gt;", parse_mode=ParseMode.HTML)
-    await memory.store_long_term(message.from_user.id, f[1])
-    await message.answer(f"🧠 Stored: <i>{f[1][:100]}</i>", parse_mode=ParseMode.HTML)
-
-
-@dp.message(Command("recall"))
-async def cmd_recall(message: Message):
-    q = message.text.split(maxsplit=1)
-    if len(q) < 2: return await message.answer("Usage: /recall &lt;query&gt;", parse_mode=ParseMode.HTML)
-    r = await memory.recall(message.from_user.id, q[1], 7)
-    if not r: return await message.answer("🧠 Nothing found.")
-    await _safe_send(message, "🧠 <b>Recalled:</b>\n\n" + "\n".join(f"• {x}" for x in r))
-
-
-@dp.message(Command("stats"))
-async def cmd_stats(message: Message):
-    uid = message.from_user.id
-    user = DB.get_user(uid)
-    if not user: return await message.answer("No stats yet. Send a message first!")
+@dp.message(CommandStart())
+async def start_cmd(message: types.Message):
+    DB.upsert_user(message.from_user.id, message.from_user.username or "", message.from_user.first_name or "")
     await message.answer(
-        f"📊 <b>Your Statistics</b>\n\n"
-        f"💬 Messages: <b>{user['total_messages']}</b>\n"
-        f"🔤 Tokens: <b>{user['total_tokens']:,}</b>\n"
-        f"📅 Joined: <b>{user['created_at']}</b>\n"
-        f"⏰ Active: <b>{user['last_active']}</b>\n"
-        f"🔄 Model: <b>{user['preferred_model']}</b>\n"
-        f"⭐ Premium: <b>{'Yes' if user['is_premium'] else 'No'}</b>\n"
-        f"👑 Admin: <b>{'Yes' if is_admin(uid) else 'No'}</b>",
-        parse_mode=ParseMode.HTML)
-
-
-@dp.message(Command("export"))
-async def cmd_export(message: Message):
-    uid = message.from_user.id
-    hist = memory.get_full(uid, message.chat.id)
-    if not hist: return await message.answer("📤 Nothing to export.")
-    text = "# AgentForge Conversation Export\n\n"
-    for m in hist:
-        ts = datetime.fromtimestamp(m.get("ts",0)).strftime("%H:%M:%S") if m.get("ts") else ""
-        agent = m.get("agent", "")
-        text += f"## {m['role'].title()} [{ts}] {f'({agent})' if agent else ''}\n{m['content']}\n\n---\n\n"
-    await message.answer_document(
-        BufferedInputFile(text.encode(), filename=f"export_{uid}_{int(time.time())}.md"),
-        caption="📤 Conversation Export")
-
-
-@dp.message(Command("feedback"))
-async def cmd_feedback(message: Message):
-    t = message.text.split(maxsplit=1)
-    if len(t) < 2: return await message.answer("Usage: /feedback &lt;message&gt;", parse_mode=ParseMode.HTML)
-    DB.execute("INSERT INTO feedback (user_id,comment) VALUES (?,?)", (message.from_user.id, t[1]))
-    await message.answer("💡 Thanks for your feedback!")
-
-
-@dp.message(Command("newbot"))
-async def cmd_newbot(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    parts = message.text.split(maxsplit=1)
-    if len(parts) < 2:
-        return await message.answer(
-            "Usage: /newbot &lt;TOKEN&gt;\n"
-            "Or: /newbot TOKEN|System prompt for the bot", parse_mode=ParseMode.HTML)
-    data = parts[1]
-    token, sp = (data.split("|",1) + ["You are a helpful assistant."])[:2]
-    status = await message.answer("🤖 Spawning bot...")
-    r = await tools.execute("spawn_bot",
-        {"token": token.strip(), "system_prompt": sp.strip(),
-         "name": f"Sub_{len(tools.spawned_bots)+1}"},
-        uid=message.from_user.id)
-    await _safe_send(message, r)
-    try: await status.delete()
-    except: pass
-
-
-@dp.message(Command("bots"))
-async def cmd_bots(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    r = await tools.execute("manage_bots", {"action": "list"}, message.from_user.id)
-    await _safe_send(message, r)
-
-
-@dp.message(Command("self"))
-async def cmd_self(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    instr = message.text.split(maxsplit=1)
-    if len(instr) < 2:
-        return await message.answer(
-            "Usage: /self &lt;instruction&gt;\n\nExamples:\n"
-            "• /self add a /joke command\n"
-            "• /self show your app.py source code\n"
-            "• /self improve error handling", parse_mode=ParseMode.HTML)
-    await process_and_reply(message,
-        f"SELF-MODIFICATION REQUEST: {instr[1]}\n\n"
-        "Read the relevant source files first (app.py, agent.py), "
-        "plan the changes, then apply them using self_modify tool. "
-        "Be careful and precise.")
-
+        "<b>AgentForge (test build) online.</b>\n\n"
+        "Group mode: reply to me or @mention me.\n\n"
+        "Try:\n"
+        "• /tools\n"
+        "• /logs\n"
+        "• /remind 20 check oven\n"
+        "• Ask: 'search for x' or 'system info'\n",
+        parse_mode=ParseMode.HTML
+    )
 
 @dp.message(Command("tools"))
-async def cmd_tools(message: Message):
-    cats = {
-        "🔍 Search": ["web_search","read_webpage"],
-        "💻 Code": ["execute_python","run_shell","install_package"],
-        "📁 Files": ["file_read","file_write","file_delete","file_list"],
-        "🧬 Modify": ["self_modify"],
-        "🎨 Media": ["generate_image","analyze_image","text_to_speech","screenshot"],
-        "🧮 Math": ["calculator"],
-        "🌤️ Info": ["get_weather","system_info"],
-        "🧠 Memory": ["memory_store","memory_recall"],
-        "🌐 Net": ["http_request","translate_text","summarize_text"],
-        "🤖 Bots": ["spawn_bot","manage_bots"],
-        "📋 Auto": ["create_workflow","run_workflow"],
-        "👑 Admin": ["broadcast_message","ban_user","restart_system","send_email"],
-        "🤝 Team": ["delegate_task","agent_dispatch"],
-    }
-    text = f"🛠️ <b>{len(ALL_TOOLS_SCHEMA)} Tools Available</b>\n"
-    for cat, tnames in cats.items():
-        text += f"\n{cat}\n"
-        for tn in tnames: text += f"  • <code>{tn}</code>\n"
-    await message.answer(text, parse_mode=ParseMode.HTML)
-
+async def tools_cmd(message: types.Message):
+    names = [t["function"]["name"] for t in TOOLS_SCHEMA]
+    await message.answer("<b>Tools:</b>\n" + "\n".join(f"• <code>{n}</code>" for n in names),
+                         parse_mode=ParseMode.HTML)
 
-@dp.message(Command("workflow"))
-async def cmd_workflow(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    parts = message.text.split(maxsplit=1)
+@dp.message(Command("logs"))
+async def logs_cmd(message: types.Message):
+    if not Config.is_admin(message.from_user.id):
+        return await message.answer("Admin only.")
+    await message.answer("<b>Live Logs</b>\n\n<pre>" + live_log.format(60) + "</pre>",
+                         parse_mode=ParseMode.HTML)
+
+@dp.message(Command("tasks"))
+async def tasks_cmd(message: types.Message):
+    if not Config.is_admin(message.from_user.id):
+        return await message.answer("Admin only.")
+    out = await tools.run(message.from_user.id, "list_tasks", {}, is_group=is_group(message))
+    await message.answer(f"<pre>{out}</pre>", parse_mode=ParseMode.HTML)
+
+@dp.message(Command("canceltask"))
+async def canceltask_cmd(message: types.Message):
+    if not Config.is_admin(message.from_user.id):
+        return await message.answer("Admin only.")
+    parts = message.text.split()
     if len(parts) < 2:
-        rows = DB.execute("SELECT * FROM workflows WHERE user_id=?", (message.from_user.id,), fetch=True)
-        if not rows: return await message.answer("No workflows. Ask AI to create one!")
-        text = "📋 <b>Workflows:</b>\n"
-        for r in rows:
-            text += f"\n• <b>{r['name']}</b> (ID:{r['id']}, runs:{r['run_count']})"
-        text += "\n\nRun: /workflow &lt;id&gt;"
-        return await message.answer(text, parse_mode=ParseMode.HTML)
-    wid = int(parts[1])
-    status = await message.answer("▶️ Running workflow...")
-    r = await orchestrator.run_workflow(message.from_user.id, wid) if hasattr(orchestrator, 'run_workflow') else "Not supported"
-    await _safe_send(message, f"📋 <b>Result:</b>\n\n{r[:3500]}")
-    try: await status.delete()
-    except: pass
-
+        return await message.answer("Usage: /canceltask <id>")
+    try:
+        tid = int(parts[1])
+    except:
+        return await message.answer("Invalid id.")
+    out = await tools.run(message.from_user.id, "cancel_task", {"task_id": tid}, is_group=is_group(message))
+    await message.answer(out)
 
-@dp.message(Command("persona"))
-async def cmd_persona(message: Message):
+@dp.message(Command("remind"))
+async def remind_cmd(message: types.Message):
+    """
+    /remind 20 do something
+    Schedules a task that will fire and message you.
+    """
+    if not Config.is_admin(message.from_user.id):
+        return await message.answer("Admin only (for now).")
     parts = message.text.split(maxsplit=2)
     if len(parts) < 3:
-        return await message.answer("Usage: /persona &lt;name&gt; &lt;system prompt&gt;", parse_mode=ParseMode.HTML)
-    DB.execute("INSERT INTO personas (user_id,name,prompt) VALUES (?,?,?)",
-               (message.from_user.id, parts[1], parts[2]))
-    await message.answer(f"🎭 Persona '<b>{parts[1]}</b>' saved!", parse_mode=ParseMode.HTML)
-
-
-@dp.message(Command("personas"))
-async def cmd_personas(message: Message):
-    rows = DB.execute("SELECT * FROM personas WHERE user_id=?", (message.from_user.id,), fetch=True)
-    if not rows: return await message.answer("No personas. Use /persona &lt;name&gt; &lt;prompt&gt;", parse_mode=ParseMode.HTML)
-    text = "🎭 <b>Personas:</b>\n\n"
-    kb_rows = []
-    for r in rows:
-        text += f"• <b>{r['name']}</b>: {r['prompt'][:50]}...\n"
-        kb_rows.append([InlineKeyboardButton(text=f"🎭 {r['name']}", callback_data=f"persona:{r['id']}")])
-    kb_rows.append([InlineKeyboardButton(text="🗑️ Clear All", callback_data="persona:clear")])
-    await message.answer(text, parse_mode=ParseMode.HTML,
-                         reply_markup=InlineKeyboardMarkup(inline_keyboard=kb_rows))
-
-
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║                     👑 ADMIN COMMANDS                             ║
-# ╚═══════════════════════════════════════════════════════════════════╝
-
-@dp.message(Command("admin"))
-async def cmd_admin(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    stats = DB.user_stats()
-    tc = DB.execute("SELECT COUNT(*) as c FROM tool_usage", fetchone=True)["c"]
-    await message.answer(
-        f"👑 <b>Admin Panel</b>\n\n"
-        f"👥 Users: {stats['total']} ({stats['active_today']} today)\n"
-        f"💬 Messages: {stats['total_messages']:,}\n"
-        f"🔤 Tokens: {stats['total_tokens']:,}\n"
-        f"🛠️ Tool calls: {tc}\n"
-        f"🤖 Bots: {len(tools.spawned_bots)}\n"
-        f"🏥 Doctor: {'🟢 Active' if doctor.running else '🔴 Stopped'}\n"
-        f"⏱️ Uptime: {timedelta(seconds=int(time.time()-BOOT_TIME))}",
-        parse_mode=ParseMode.HTML, reply_markup=kb_admin())
-
-
-@dp.message(Command("broadcast"))
-async def cmd_broadcast(message: Message):
-    if not is_admin(message.from_user.id): return
-    t = message.text.split(maxsplit=1)
-    if len(t) < 2: return await message.answer("Usage: /broadcast &lt;message&gt;", parse_mode=ParseMode.HTML)
-    users = DB.execute("SELECT telegram_id FROM users WHERE is_banned=0", fetch=True)
-    sent, fail = 0, 0
-    for u in users:
-        try:
-            await bot.send_message(u["telegram_id"], f"📢 <b>Announcement</b>\n\n{t[1]}", parse_mode=ParseMode.HTML)
-            sent += 1
-        except: fail += 1
-        await asyncio.sleep(0.1)  # Rate limit
-    await message.answer(f"📢 Done: {sent} sent, {fail} failed")
-
-
-@dp.message(Command("ban"))
-async def cmd_ban(message: Message):
-    if not is_admin(message.from_user.id): return
+        return await message.answer("Usage: /remind <seconds> <message>")
     try:
-        uid = int(message.text.split()[1])
-        DB.update_user(uid, is_banned=1)
-        await message.answer(f"🚫 User {uid} banned.")
-    except: await message.answer("Usage: /ban &lt;user_id&gt;", parse_mode=ParseMode.HTML)
-
-
-@dp.message(Command("unban"))
-async def cmd_unban(message: Message):
-    if not is_admin(message.from_user.id): return
-    try:
-        uid = int(message.text.split()[1])
-        DB.update_user(uid, is_banned=0)
-        await message.answer(f"✅ User {uid} unbanned.")
-    except: await message.answer("Usage: /unban &lt;user_id&gt;", parse_mode=ParseMode.HTML)
-
-
-@dp.message(Command("premium"))
-async def cmd_premium(message: Message):
-    if not is_admin(message.from_user.id): return
-    try:
-        uid = int(message.text.split()[1])
-        user = DB.get_user(uid)
-        new = 0 if user and user["is_premium"] else 1
-        DB.update_user(uid, is_premium=new)
-        await message.answer(f"⭐ User {uid} premium: {'ON' if new else 'OFF'}")
-    except: await message.answer("Usage: /premium &lt;user_id&gt;", parse_mode=ParseMode.HTML)
-
-
-@dp.message(Command("shell"))
-async def cmd_shell(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    c = message.text.split(maxsplit=1)
-    if len(c) < 2: return await message.answer("Usage: /shell &lt;command&gt;", parse_mode=ParseMode.HTML)
-    r = await tools.execute("run_shell", {"command": c[1]}, message.from_user.id)
-    await _safe_send(message, r[:4000])
-
-
-@dp.message(Command("sysinfo"))
-async def cmd_sysinfo(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    r = await tools.execute("system_info", {}, message.from_user.id)
-    await _safe_send(message, r)
-
-
-@dp.message(Command("health"))
-async def cmd_health(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    status = await message.answer("🏥 Running health check...")
-    h = await doctor.check_health()
-    report = doctor.format_report(h)
-    try: await status.delete()
-    except: pass
-    await message.answer(report, reply_markup=kb_health())
-
-
-@dp.message(Command("logs"))
-async def cmd_logs(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    rows = DB.execute("SELECT * FROM tool_usage ORDER BY created_at DESC LIMIT 25", fetch=True)
-    text = "📜 <b>Recent Tool Usage:</b>\n\n"
-    for r in rows:
-        s = "✅" if r["success"] else "❌"
-        text += f"{s} <code>{r['tool_name']}</code> by {r['agent_name']} | u:{r['user_id']} | {r['execution_time']:.1f}s\n"
-    await _safe_send(message, text[:4000])
-
-
-@dp.message(Command("restart"))
-async def cmd_restart(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    await message.answer("🔄 Restarting in 3 seconds...")
-    await asyncio.sleep(3)
-    os.execv(sys.executable, [sys.executable] + sys.argv)
-
-
-@dp.message(Command("addbutton"))
-async def cmd_addbutton(message: Message):
-    if not is_admin(message.from_user.id): return await message.answer("🚫 Admin only.")
-    t = message.text.split(maxsplit=1)
-    if len(t) < 2 or "|" not in t[1]:
-        return await message.answer("Usage: /addbutton Label|https://url", parse_mode=ParseMode.HTML)
-    label, url = t[1].split("|", 1)
-    ok = await SupabaseDB.add_button(label.strip(), url.strip())
-    DB.execute("INSERT INTO bot_buttons (label,url) VALUES (?,?)", (label.strip(), url.strip()))
-    await message.answer(f"{'✅' if ok else '⚠️'} Button '{label.strip()}' added!")
+        sec = int(parts[1])
+    except:
+        return await message.answer("Seconds must be an integer.")
+    reminder_text = parts[2].strip()
+    prompt = f"Send a reminder to the user now. Reminder text: {reminder_text}"
+    out = await tools.run(message.from_user.id, "schedule_task",
+                          {"delay_seconds": sec, "prompt": prompt, "repeat_seconds": 0},
+                          is_group=is_group(message))
+    await message.answer(out)
 
+@dp.message(Command("model"))
+async def model_cmd(message: types.Message):
+    if not Config.is_admin(message.from_user.id):
+        return await message.answer("Admin only (for now).")
+    parts = message.text.split(maxsplit=1)
+    if len(parts) < 2:
+        return await message.answer(f"Usage: /model <model_name>\nCurrent default: {Config.DEFAULT_MODEL}")
+    new_model = parts[1].strip()
+    DB.q("UPDATE users SET preferred_model=? WHERE telegram_id=?", (new_model, message.from_user.id))
+    await message.answer(f"Model set to: <code>{new_model}</code>", parse_mode=ParseMode.HTML)
 
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║                  📨 MESSAGE HANDLERS                              ║
-# ╚═══════════════════════════════════════════════════════════════════╝
+# =========================================================
+# Main message handler
+# =========================================================
 
 @dp.message(F.text & ~F.text.startswith("/"))
-async def handle_text(message: Message):
-    """Handle all plain text messages."""
-    # Group check
+async def on_text(message: types.Message):
     if is_group(message) and not should_respond_in_group(message):
         return
 
-    text = message.text
-
-    # Clean @mention from text in groups
-    if Config.BOT_USERNAME:
-        text = text.replace(f"@{Config.BOT_USERNAME}", "").strip()
-        text = text.replace(f"@{Config.BOT_USERNAME.lower()}", "").strip()
-
-    # Reply context
-    if message.reply_to_message and message.reply_to_message.text:
-        reply_text = message.reply_to_message.text[:500]
-        text = f"[Replying to: {reply_text}]\n\n{text}"
-
-    # Check awaiting state
-    state = get_state(message.from_user.id)
-    if state.get("awaiting") == "sysprompt":
-        DB.update_user(message.from_user.id, system_prompt=text)
-        state["awaiting"] = None
-        return await message.answer(f"📝 System prompt set!\n<i>{text[:200]}</i>", parse_mode=ParseMode.HTML)
-
-    if state.get("awaiting") == "mem_search":
-        state["awaiting"] = None
-        r = await memory.recall(message.from_user.id, text, 7)
-        if not r: return await message.answer("🧠 Nothing found.")
-        return await _safe_send(message, "🧠 <b>Results:</b>\n\n" + "\n".join(f"• {x}" for x in r))
-
-    await process_and_reply(message, text)
+    uid = message.from_user.id
+    DB.upsert_user(uid, message.from_user.username or "", message.from_user.first_name or "")
 
+    text = strip_mention(message.text or "")
 
-@dp.message(F.voice | F.audio)
-async def handle_voice(message: Message):
-    """Voice → transcribe → process."""
-    if is_group(message) and not should_respond_in_group(message):
-        return
-
-    status = await message.answer("🎙️ Transcribing...")
+    # show typing
     try:
-        voice = message.voice or message.audio
-        file = await bot.get_file(voice.file_id)
-        fdata = await bot.download_file(file.file_path)
-        audio_bytes = fdata.read() if hasattr(fdata, 'read') else bytes(fdata)
-
-        transcript = await llm.stt(audio_bytes)
-        if not transcript:
-            return await status.edit_text("❌ Could not transcribe. Need OpenAI key.")
-
-        await status.edit_text(f"🎙️ <i>{transcript[:200]}</i>\n\n💭 Processing...",
-                               parse_mode=ParseMode.HTML)
-        try: await status.delete()
-        except: pass
-
-        await process_and_reply(message, transcript)
-
-    except Exception as e:
-        log.error(f"Voice error: {e}")
-        try: await status.edit_text(f"❌ Voice error: {str(e)[:200]}")
-        except: pass
-
-
-@dp.message(F.photo)
-async def handle_photo(message: Message):
-    """Photo → AI vision + PIL fallback → respond."""
-    if is_group(message) and not should_respond_in_group(message):
-        return
+        await bot.send_chat_action(message.chat.id, ChatAction.TYPING)
+    except:
+        pass
 
-    status = await message.answer("👁️ Analyzing image...")
+    status = await message.answer("💭 Thinking...")
     try:
-        photo = message.photo[-1]  # Largest size
-        file = await bot.get_file(photo.file_id)
-        fdata = await bot.download_file(file.file_path)
-        photo_bytes = fdata.read() if hasattr(fdata, 'read') else bytes(fdata)
-        b64 = base64.b64encode(photo_bytes).decode()
-
-        caption = message.caption or "Analyze this image in detail."
-
-        try: await status.delete()
-        except: pass
-
-        await process_and_reply(message, caption, attachments=[{"type": "image", "b64": b64}])
-
+        result = await engine.run(uid, message.chat.id, text, is_group=is_group(message))
+        reply = result.get("text", "OK")
+        footer = ""
+        if result.get("tools_used"):
+            footer += "\n\n<i>Tools:</i> " + ", ".join(list(dict.fromkeys(result["tools_used"]))[:10])
+        footer += f"\n<i>Model:</i> {result.get('model','')}"
+        footer += f" | <i>Tokens:</i> {result.get('tokens',0)}"
+        await status.delete()
+        await safe_send(message.chat.id, reply + footer)
     except Exception as e:
-        log.error(f"Photo error: {e}")
-        try: await status.edit_text(f"❌ Photo error: {str(e)[:200]}")
-        except: pass
-
-
-@dp.message(F.document)
-async def handle_document(message: Message):
-    """Documents → read → analyze."""
-    if is_group(message) and not should_respond_in_group(message):
-        return
-
-    doc = message.document
-    if doc.file_size and doc.file_size > 15 * 1024 * 1024:
-        return await message.answer("📁 File too large (max 15MB).")
-
-    status = await message.answer("📁 Reading file...")
-    try:
-        file = await bot.get_file(doc.file_id)
-        fdata = await bot.download_file(file.file_path)
-        content_bytes = fdata.read() if hasattr(fdata, 'read') else bytes(fdata)
-
-        fname = doc.file_name or "unknown"
-        ext = fname.split(".")[-1].lower() if "." in fname else "txt"
-
-        # Image documents
-        if ext in ("png", "jpg", "jpeg", "gif", "webp", "bmp"):
-            b64 = base64.b64encode(content_bytes).decode()
-            caption = message.caption or "Analyze this image."
-            try: await status.delete()
-            except: pass
-            return await process_and_reply(message, caption, attachments=[{"type": "image", "b64": b64}])
-
-        # Text-based files
+        log.exception("engine error")
         try:
-            content = content_bytes.decode("utf-8", errors="replace")
+            await status.edit_text(f"❌ Error: {str(e)[:200]}")
         except:
-            content = f"[Binary file: {fname}, {len(content_bytes)} bytes]"
-
-        caption = message.caption or f"Analyze this {ext} file."
-        msg = f"{caption}\n\nFile: {fname} ({len(content_bytes):,} bytes)\n\n```{ext}\n{content[:8000]}\n```"
-
-        # Save file locally for admin
-        if is_admin(message.from_user.id):
-            save_path = os.path.join(Config.FILES_DIR, fname)
-            with open(save_path, "wb") as f: f.write(content_bytes)
-            msg += f"\n\n💾 Saved to: {save_path}"
-
-        try: await status.delete()
-        except: pass
-
-        await process_and_reply(message, msg)
-
-    except Exception as e:
-        log.error(f"Document error: {e}")
-        try: await status.edit_text(f"❌ File error: {str(e)[:200]}")
-        except: pass
-
-
-@dp.message(F.sticker)
-async def handle_sticker(message: Message):
-    if is_group(message) and not should_respond_in_group(message):
-        return
-    emoji = message.sticker.emoji or "😀"
-    await process_and_reply(message, f"User sent a sticker: {emoji}. Respond playfully!")
-
-
-@dp.message(F.location)
-async def handle_location(message: Message):
-    if is_group(message) and not should_respond_in_group(message):
-        return
-    lat, lon = message.location.latitude, message.location.longitude
-    await process_and_reply(message,
-        f"User shared their location: lat={lat}, lon={lon}. "
-        "Look up what's nearby and provide useful information about this location.")
-
+            pass
 
-@dp.message(F.contact)
-async def handle_contact(message: Message):
+@dp.message(F.photo)
+async def on_photo(message: types.Message):
     if is_group(message) and not should_respond_in_group(message):
         return
-    c = message.contact
-    await process_and_reply(message,
-        f"User shared a contact: {c.first_name} {c.last_name or ''}, phone: {c.phone_number}")
-
-
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║                  🔘 CALLBACK HANDLERS                             ║
-# ╚═══════════════════════════════════════════════════════════════════╝
-
-@dp.callback_query(F.data.startswith("agent:"))
-async def cb_agent(cb: CallbackQuery):
-    agent = cb.data.split(":")[1]
-    state = get_state(cb.from_user.id)
-    if agent == "auto":
-        state["agent"] = None
-        await cb.message.edit_text("🤖 Mode: <b>Auto</b> — Director decides which agents to use",
-                                    parse_mode=ParseMode.HTML)
-    else:
-        state["agent"] = agent
-        info = AGENTS.get(agent, {})
-        await cb.message.edit_text(
-            f"{info.get('icon','')} Agent: <b>{info.get('name', agent)}</b>\n\n"
-            f"<i>{info.get('prompt','')[:200]}...</i>",
-            parse_mode=ParseMode.HTML)
-    await cb.answer("Switched!")
-
-
-@dp.callback_query(F.data.startswith("model:"))
-async def cb_model(cb: CallbackQuery):
-    model = cb.data.split(":", 1)[1]
-    get_state(cb.from_user.id)["model"] = model
-    DB.update_user(cb.from_user.id, preferred_model=model)
-    await cb.message.edit_text(f"🔄 Model: <code>{model}</code>", parse_mode=ParseMode.HTML)
-    await cb.answer("Model switched!")
-
-
-@dp.callback_query(F.data.startswith("nav:"))
-async def cb_nav(cb: CallbackQuery):
-    page = cb.data.split(":")[1]
-    if page == "main":
-        await cb.message.edit_text("🏠 <b>Main Menu</b>", parse_mode=ParseMode.HTML, reply_markup=kb_main())
-    elif page == "models":
-        await cb.message.edit_text("🔄 <b>Select Model</b>", parse_mode=ParseMode.HTML, reply_markup=kb_models())
-    elif page == "settings":
-        await cb.message.edit_text("⚙️ <b>Settings</b>", parse_mode=ParseMode.HTML,
-                                    reply_markup=kb_settings(cb.from_user.id))
-    elif page == "stats":
-        user = DB.get_user(cb.from_user.id)
-        if user:
-            await cb.message.edit_text(
-                f"📊 <b>Stats</b>\n💬 {user['total_messages']} msgs | 🔤 {user['total_tokens']:,} tokens",
-                parse_mode=ParseMode.HTML)
-    await cb.answer()
-
-
-@dp.callback_query(F.data.startswith("set:"))
-async def cb_set(cb: CallbackQuery):
-    action = cb.data.split(":")[1]
-    if action == "temp":
-        await cb.message.edit_text("🌡️ <b>Temperature</b>\nLow = precise, High = creative",
-                                    parse_mode=ParseMode.HTML, reply_markup=kb_temp())
-    elif action == "sysprompt":
-        get_state(cb.from_user.id)["awaiting"] = "sysprompt"
-        await cb.message.edit_text("📝 Send your custom system prompt now.\nSend 'clear' to reset.")
-    elif action == "personas":
-        rows = DB.execute("SELECT * FROM personas WHERE user_id=?", (cb.from_user.id,), fetch=True)
-        if not rows:
-            await cb.message.edit_text("No personas yet. Use /persona &lt;name&gt; &lt;prompt&gt;",
-                                        parse_mode=ParseMode.HTML)
-        else:
-            kb_rows = [[InlineKeyboardButton(text=f"🎭 {r['name']}", callback_data=f"persona:{r['id']}")]
-                       for r in rows]
-            await cb.message.edit_text("🎭 <b>Your Personas:</b>", parse_mode=ParseMode.HTML,
-                                        reply_markup=InlineKeyboardMarkup(inline_keyboard=kb_rows))
-    elif action == "reset":
-        DB.update_user(cb.from_user.id, preferred_model=Config.DEFAULT_MODEL,
-                       temperature=0.7, system_prompt="", max_tokens=4096)
-        get_state(cb.from_user.id).update({"model": None, "agent": None})
-        await cb.message.edit_text("✅ All settings reset to defaults.")
-    await cb.answer()
-
-
-@dp.callback_query(F.data.startswith("temp:"))
-async def cb_temp(cb: CallbackQuery):
-    t = float(cb.data.split(":")[1])
-    DB.update_user(cb.from_user.id, temperature=t)
-    await cb.message.edit_text(f"🌡️ Temperature set to <b>{t}</b>", parse_mode=ParseMode.HTML)
-    await cb.answer()
-
-
-@dp.callback_query(F.data.startswith("fb:"))
-async def cb_feedback(cb: CallbackQuery):
-    action = cb.data.split(":")[1]
-    if action == "up":
-        DB.execute("INSERT INTO feedback (user_id,rating) VALUES (?,5)", (cb.from_user.id,))
-        await cb.answer("👍 Thanks!")
-    elif action == "down":
-        DB.execute("INSERT INTO feedback (user_id,rating) VALUES (?,1)", (cb.from_user.id,))
-        await cb.answer("👎 We'll improve!")
-    elif action == "retry":
-        state = get_state(cb.from_user.id)
-        if state.get("last_message"):
-            await cb.answer("🔄 Retrying...")
-            # Re-process
-            await process_and_reply(cb.message, state["last_message"])
-        else:
-            await cb.answer("No message to retry")
-    elif action == "speak":
-        state = get_state(cb.from_user.id)
-        resp = state.get("last_response")
-        if resp and resp.get("text"):
-            await cb.answer("🔊 Generating audio...")
-            try:
-                audio = await llm.tts(resp["text"][:4000])
-                if audio:
-                    path = os.path.join(Config.DATA_DIR, f"tts_{int(time.time())}.mp3")
-                    with open(path, "wb") as f: f.write(audio)
-                    await cb.message.answer_voice(voice=FSInputFile(path))
-                    try: os.unlink(path)
-                    except: pass
-                else:
-                    await cb.message.answer("❌ TTS unavailable")
-            except Exception as e:
-                await cb.message.answer(f"❌ TTS error: {str(e)[:100]}")
-        else:
-            await cb.answer("Nothing to read")
-
-
-@dp.callback_query(F.data.startswith("mem:"))
-async def cb_memory(cb: CallbackQuery):
-    action = cb.data.split(":")[1]
-    uid = cb.from_user.id
-    if action == "view":
-        r = await memory.recall(uid, "everything about me", 10)
-        text = "🧠 <b>Your Memories:</b>\n\n" + ("\n".join(f"• {x}" for x in r) if r else "Empty")
-        await cb.message.edit_text(text[:4000], parse_mode=ParseMode.HTML)
-    elif action == "search":
-        get_state(uid)["awaiting"] = "mem_search"
-        await cb.message.edit_text("🔍 Send your search query:")
-    elif action == "clear":
-        await cb.message.edit_text("⚠️ Clear ALL memories?",
-            reply_markup=InlineKeyboardMarkup(inline_keyboard=[
-                [InlineKeyboardButton(text="✅ Yes", callback_data="mem:do_clear"),
-                 InlineKeyboardButton(text="❌ No", callback_data="nav:main")]]))
-    elif action == "do_clear":
-        try:
-            if memory.collection:
-                r = memory.collection.get(where={"user_id": str(uid)})
-                if r and r["ids"]: memory.collection.delete(ids=r["ids"])
-        except: pass
-        DB.execute("DELETE FROM memories WHERE user_id=?", (uid,))
-        await cb.message.edit_text("🗑️ All memories cleared.")
-    await cb.answer()
-
-
-@dp.callback_query(F.data.startswith("persona:"))
-async def cb_persona(cb: CallbackQuery):
-    val = cb.data.split(":")[1]
-    if val == "clear":
-        DB.execute("DELETE FROM personas WHERE user_id=?", (cb.from_user.id,))
-        await cb.message.edit_text("🗑️ All personas deleted.")
-    else:
-        pid = int(val)
-        row = DB.execute("SELECT * FROM personas WHERE id=? AND user_id=?",
-                         (pid, cb.from_user.id), fetchone=True)
-        if row:
-            DB.update_user(cb.from_user.id, system_prompt=row["prompt"])
-            await cb.message.edit_text(f"🎭 Activated: <b>{row['name']}</b>", parse_mode=ParseMode.HTML)
-    await cb.answer()
-
-
-@dp.callback_query(F.data.startswith("health:"))
-async def cb_health(cb: CallbackQuery):
-    action = cb.data.split(":")[1]
-    if action == "refresh":
-        h = await doctor.check_health()
-        await cb.message.edit_text(doctor.format_report(h), reply_markup=kb_health())
-    elif action == "logs":
-        rows = DB.execute("SELECT * FROM health_logs ORDER BY created_at DESC LIMIT 5", fetch=True)
-        text = "📋 <b>Health Logs:</b>\n\n"
-        for r in rows:
-            text += f"• {r['status']} | {r['created_at']}\n"
-        await cb.message.edit_text(text[:4000], parse_mode=ParseMode.HTML)
-    await cb.answer()
-
-
-@dp.callback_query(F.data.startswith("adm:"))
-async def cb_admin(cb: CallbackQuery):
-    if not is_admin(cb.from_user.id):
-        return await cb.answer("🚫 Admin only")
-    action = cb.data.split(":")[1]
-    if action == "stats":
-        stats = DB.user_stats()
-        await cb.message.edit_text(
-            f"📊 <b>Full Stats</b>\n\n"
-            f"👥 Users: {stats['total']}\n📈 Active today: {stats['active_today']}\n"
-            f"💬 Total msgs: {stats['total_messages']:,}\n🔤 Tokens: {stats['total_tokens']:,}",
-            parse_mode=ParseMode.HTML, reply_markup=kb_admin())
-    elif action == "health":
-        h = await doctor.check_health()
-        await cb.message.edit_text(doctor.format_report(h), reply_markup=kb_health())
-    elif action == "toologs":
-        rows = DB.execute("SELECT * FROM tool_usage ORDER BY created_at DESC LIMIT 15", fetch=True)
-        text = "📜 <b>Tool Logs:</b>\n"
-        for r in rows:
-            s = "✅" if r["success"] else "❌"
-            text += f"\n{s} <code>{r['tool_name']}</code> ({r['agent_name']}) {r['execution_time']:.1f}s"
-        await cb.message.edit_text(text[:4000], parse_mode=ParseMode.HTML, reply_markup=kb_admin())
-    elif action == "bots":
-        r = await tools.execute("manage_bots", {"action": "list"}, cb.from_user.id)
-        await cb.message.edit_text(r[:4000], reply_markup=kb_admin())
-    elif action == "restart":
-        await cb.message.edit_text("🔄 Restarting...")
-        await asyncio.sleep(2)
-        os.execv(sys.executable, [sys.executable] + sys.argv)
-    elif action == "backup":
-        if os.path.exists(DB_PATH := os.path.join(Config.DATA_DIR, "agentforge.db")):
-            await cb.message.answer_document(
-                FSInputFile(DB_PATH), caption="💾 Database Backup")
-        await cb.answer("Backup sent!")
-    await cb.answer()
 
+    uid = message.from_user.id
+    DB.upsert_user(uid, message.from_user.username or "", message.from_user.first_name or "")
 
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║                   🔎 INLINE QUERY                                 ║
-# ╚═══════════════════════════════════════════════════════════════════╝
+    # Download largest photo
+    photo = message.photo[-1]
+    file = await bot.get_file(photo.file_id)
+    data = await bot.download_file(file.file_path)
+    img_bytes = data.read() if hasattr(data, "read") else bytes(data)
+    b64 = base64.b64encode(img_bytes).decode()
 
-@dp.inline_query()
-async def inline_handler(inline_query: InlineQuery):
-    query = inline_query.query
-    if not query or len(query) < 3: return
+    caption = strip_mention(message.caption or "Analyze this image.")
+    status = await message.answer("👁️ Processing photo...")
 
     try:
-        r = await llm.chat([
-            {"role": "system", "content": "Answer in 2-3 sentences. Be helpful and concise."},
-            {"role": "user", "content": query}
-        ], model="gpt-4o-mini", max_tokens=200)
-
-        text = r["content"]
-        results = [InlineQueryResultArticle(
-            id=hashlib.md5(query.encode()).hexdigest()[:16],
-            title=f"🤖 {query[:50]}",
-            description=text[:100],
-            input_message_content=InputTextMessageContent(
-                message_text=f"❓ <b>{query}</b>\n\n🤖 {text}",
-                parse_mode=ParseMode.HTML))]
-        await inline_query.answer(results, cache_time=30)
-    except: pass
-
-
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║              🏥 DOCTOR BACKGROUND ALERT SYSTEM                    ║
-# ╚═══════════════════════════════════════════════════════════════════╝
-
-async def doctor_alert_callback():
-    """Called periodically to check if doctor found critical issues."""
-    if doctor.issues and Config.ADMIN_IDS:
-        critical = [i for i in doctor.issues if any(w in i.lower() for w in ["disk", "ram", "database"])]
-        if critical:
-            alert = "🚨 <b>DOCTOR ALERT</b>\n\n" + "\n".join(f"⚠️ {i}" for i in critical)
-            for admin_id in Config.ADMIN_IDS:
-                try:
-                    await bot.send_message(admin_id, alert, parse_mode=ParseMode.HTML)
-                except: pass
-
-
-# ╔═══════════════════════════════════════════════════════════════════╗
-# ║                   🚀 STARTUP & MAIN                               ║
-# ╚═══════════════════════════════════════════════════════════════════╝
+        result = await engine.run(uid, message.chat.id, caption, is_group=is_group(message),
+                                  attachments=[{"type":"image","b64":b64}])
+        await status.delete()
+        await safe_send(message.chat.id, result.get("text","OK"))
+    except Exception as e:
+        await status.edit_text(f"❌ Error: {str(e)[:200]}")
 
-async def on_startup():
-    log.info("🤖 AgentForge v2 starting...")
+# =========================================================
+# Startup / main
+# =========================================================
 
-    # Set bot commands
+async def main():
+    # set username for group mentions
     try:
-        commands = [
-            BotCommand(command="start",     description="🚀 Start bot"),
-            BotCommand(command="help",      description="📚 Help menu"),
-            BotCommand(command="agent",     description="🤖 Switch agent"),
-            BotCommand(command="model",     description="🔄 Switch model"),
-            BotCommand(command="search",    description="🔍 Web search"),
-            BotCommand(command="code",      description="💻 Run code"),
-            BotCommand(command="image",     description="🎨 Generate image"),
-            BotCommand(command="tts",       description="🔊 Text to speech"),
-            BotCommand(command="memory",    description="🧠 Memory"),
-            BotCommand(command="clear",     description="🗑️ Clear chat"),
-            BotCommand(command="settings",  description="⚙️ Settings"),
-            BotCommand(command="tools",     description="🛠️ List tools"),
-            BotCommand(command="stats",     description="📊 Statistics"),
-            BotCommand(command="self",      description="🧬 Self-modify"),
-            BotCommand(command="health",    description="🏥 Health check"),
-            BotCommand(command="help",      description="📚 All commands"),
-        ]
-        await bot.set_my_commands(commands)
-
-        # Get bot username for group mentions
         me = await bot.get_me()
         Config.BOT_USERNAME = me.username or ""
-        log.info(f"✅ Bot: @{Config.BOT_USERNAME}")
+        log.info(f"Bot username: @{Config.BOT_USERNAME}")
     except Exception as e:
-        log.warning(f"Commands/username warning: {e}")
-
-    # Models
-    models = llm.available_models()
-    log.info(f"✅ Models available: {len(models)}")
-    for m in models: log.info(f"   • {m}")
-
-    # Start Doctor (always-alive health monitor)
-    await doctor.start()
-    log.info("✅ Doctor started (monitoring every {Config.HEALTH_INTERVAL}s)")
-
-    # Schedule periodic doctor alerts
-    scheduler.add_job(doctor_alert_callback, 'interval', minutes=10)
-    scheduler.start()
-    log.info("✅ Scheduler started")
+        log.warning(f"Could not get bot username: {e}")
 
-    # Notify admins
-    for admin_id in Config.ADMIN_IDS:
-        try:
-            await bot.send_message(admin_id,
-                f"🚀 <b>AgentForge Online!</b>\n\n"
-                f"🤖 @{Config.BOT_USERNAME}\n"
-                f"🔄 Models: {len(models)}\n"
-                f"🛠️ Tools: {len(ALL_TOOLS_SCHEMA)}\n"
-                f"🤝 Agents: {len(AGENTS)}\n"
-                f"🏥 Doctor: Active\n"
-                f"⏱️ Boot: {datetime.now().strftime('%H:%M:%S')}",
-                parse_mode=ParseMode.HTML)
-        except: pass
-
-    log.info("🎉 AgentForge v2 fully operational!")
-
-
-async def on_shutdown():
-    log.info("Shutting down...")
-    await doctor.stop()
-    scheduler.shutdown(wait=False)
-    for h, info in list(tools.spawned_bots.items()):
-        try:
-            info["task"].cancel()
-            await info["bot"].session.close()
-        except: pass
-
-
-async def main():
-    await on_startup()
+    # start scheduler
+    scheduler.set_sender(scheduler_sender)
+    await scheduler.start()
 
     try:
         await bot.delete_webhook(drop_pending_updates=True)
-    except Exception as e:
-        log.warning(f"Webhook warning: {e}")
-
-    log.info("📡 Starting polling...")
-    try:
-        await dp.start_polling(bot)
-    finally:
-        await on_shutdown()
+    except:
+        pass
 
+    log.info("Polling start")
+    await dp.start_polling(bot)
 
 if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        log.info("Bot stopped by user")
-    except Exception as e:
-        log.critical(f"Fatal: {e}", exc_info=True)
-        sys.exit(1)
+    asyncio.run(main())