Update app.py

app.py

@@ -23,6 +23,7 @@ import asyncio
 from urllib.parse import urlparse
 from pathlib import Path
 import io
+import requests  # for Telegram file download
 
 from fastapi import FastAPI, Request, HTTPException
 import av
@@ -120,7 +121,7 @@ DEFAULT_USER_SETTINGS = {
     "stop_on_error_in_playlist": True,
     "reconnect_on_stream_error": True,
     "reconnect_delay_seconds": 5,
-    "max_reconnect_attempts": 3,
+    "max_reconnect_attempts": 10,
 
     # Connection / network
     "open_timeout_seconds": 15,
@@ -141,9 +142,6 @@ DEFAULT_USER_SETTINGS = {
     "current_step_index": 0,
     "conversation_fields_list": [],
     "settings_editing_field": None,
-
-    # UX mode: "send" = always new message (default), "edit" = edit-in-place
-    "ux_mode": "send",
 }
 
 DEFAULT_SESSION_RUNTIME_STATE = {
@@ -167,9 +165,6 @@ DEFAULT_SESSION_RUNTIME_STATE = {
     "reconnect_attempt": 0,
     "last_frame_time": None,        # for watchdog
     "last_notified_state": None,    # for state-change notifications
-    "status_message_id": None,      # message to auto-update in real-time
-    "status_chat_id": None,
-    "active_output_url": None,       # the URL actually being streamed to right now
 }
 
 # ──────────────────────────────────────────────
@@ -220,17 +215,50 @@ def append_user_live_log(chat_id: int, line: str):
 
 # ──────────────────────────────────────────────
 # TELEGRAM API HELPERS
-# (Webhook-only mode: no outbound Telegram API calls)
 # ──────────────────────────────────────────────
+def _tg_api_call(method: str, payload: dict) -> dict:
+    """Make a direct outgoing Telegram API call (for push notifications from threads)."""
+    if not TELEGRAM_BOT_TOKEN:
+        logger.warning("No TELEGRAM_BOT_TOKEN set — cannot make outgoing API calls.")
+        return {}
+    try:
+        url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/{method}"
+        resp = requests.post(url, json=payload, timeout=10)
+        return resp.json()
+    except Exception as e:
+        logger.error(f"Outgoing API call failed ({method}): {e}")
+        return {}
+
+
 def push_message(chat_id: int, text: str, reply_markup=None, parse_mode="HTML"):
-    """
-    In webhook-only mode outbound calls are not possible.
-    Log the notification so it appears in /logs instead.
-    """
-    import html
-    plain = html.unescape(re.sub(r'<[^>]+>', '', text))
-    logger.info(f"[Chat {chat_id}] [push_message suppressed] {plain[:200]}")
-    append_user_live_log(chat_id, f"[notification] {plain[:200]}")
+    """Send a message proactively from a background thread."""
+    payload = {"chat_id": chat_id, "text": text, "parse_mode": parse_mode}
+    if reply_markup:
+        payload["reply_markup"] = json.dumps(reply_markup)
+    return _tg_api_call("sendMessage", payload)
+
+
+def download_telegram_file(file_id: str) -> bytes:
+    """Download a file from Telegram by file_id. Returns bytes or None."""
+    if not TELEGRAM_BOT_TOKEN:
+        return None
+    try:
+        resp = requests.get(
+            f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/getFile",
+            params={"file_id": file_id}, timeout=10
+        )
+        data = resp.json()
+        if not data.get("ok"):
+            return None
+        file_path = data["result"]["file_path"]
+        file_resp = requests.get(
+            f"https://api.telegram.org/file/bot{TELEGRAM_BOT_TOKEN}/{file_path}",
+            timeout=30
+        )
+        return file_resp.content
+    except Exception as e:
+        logger.error(f"Failed to download Telegram file {file_id}: {e}")
+        return None
 
 
 # ──────────────────────────────────────────────
@@ -261,91 +289,6 @@ def answer_callback_query(cq_id: str, text: str = None, show_alert: bool = False
     return resp
 
 
-# ──────────────────────────────────────────────
-# REAL-TIME STATUS UPDATER
-# ──────────────────────────────────────────────
-# How it works (webhook-only, no outbound calls):
-#   1. When the user taps 📊 Status, we register their chat_id + message_id.
-#   2. A background thread every 5s builds fresh status text and stores it as
-#      a "pending edit" dict keyed by chat_id.
-#   3. The /webhook handler, before returning its own response, checks if there
-#      is a pending edit for this chat_id that differs from the last-sent text,
-#      and if so returns the editMessageText as the response (Telegram applies it).
-#   4. A GET /status/{chat_id} endpoint lets any HTTP client poll for the latest
-#      status text (useful for dashboards / external monitoring).
-_pending_status_updates: dict = {}   # chat_id -> {message_id, last_sent, pending_text}
-_status_updater_lock = threading.Lock()
-
-
-def register_status_message(chat_id: int, message_id: int):
-    """Start tracking this message for real-time updates."""
-    session = get_user_session(chat_id)
-    with lock_for(chat_id):
-        session['status_message_id'] = message_id
-    with _status_updater_lock:
-        _pending_status_updates[chat_id] = {
-            "message_id": message_id,
-            "last_sent": "",
-            "pending_text": None,
-        }
-    logger.info(f"[Chat {chat_id}] Real-time status registered for msg {message_id}.")
-
-
-def lock_for(chat_id: int):
-    return session_locks.get(chat_id, threading.Lock())
-
-
-def unregister_status_message(chat_id: int):
-    with _status_updater_lock:
-        _pending_status_updates.pop(chat_id, None)
-
-
-def pop_pending_status_edit(chat_id: int):
-    """Return an editMessageText dict if there's a fresher status, else None."""
-    with _status_updater_lock:
-        info = _pending_status_updates.get(chat_id)
-        if not info or not info.get("pending_text"):
-            return None
-        if info["pending_text"] == info["last_sent"]:
-            return None
-        session = get_user_session(chat_id)
-        kb = get_main_keyboard(session)
-        resp = edit_message_text(chat_id, info["message_id"], info["pending_text"],
-                                 reply_markup=kb)
-        info["last_sent"] = info["pending_text"]
-        return resp
-
-
-def _status_updater_loop():
-    """Background thread: refresh pending_text every 5 seconds."""
-    while True:
-        time.sleep(5)
-        try:
-            with _status_updater_lock:
-                items = list(_pending_status_updates.items())
-            for chat_id, info in items:
-                try:
-                    session = get_user_session(chat_id)
-                    state = session.get('streaming_state', 'idle')
-                    new_text = compose_status_message(chat_id, include_config=False)
-                    with _status_updater_lock:
-                        if chat_id in _pending_status_updates:
-                            _pending_status_updates[chat_id]["pending_text"] = new_text
-                    # Auto-unregister once stream fully ended
-                    if state in ('idle', 'stopped', 'completed', 'error'):
-                        # leave one final update queued, then stop
-                        unregister_status_message(chat_id)
-                except Exception as e_inner:
-                    logger.warning(f"Status updater inner error for {chat_id}: {e_inner}")
-        except Exception as e:
-            logger.error(f"Status updater error: {e}")
-
-
-_status_updater_thread = threading.Thread(target=_status_updater_loop,
-                                          name="StatusUpdater", daemon=True)
-_status_updater_thread.start()
-
-
 # ──────────────────────────────────────────────
 # CONTEXT-AWARE KEYBOARDS
 # ──────────────────────────────────────────────
@@ -404,10 +347,8 @@ def get_main_keyboard(session: dict):
     return {"inline_keyboard": btns}
 
 
-def get_settings_keyboard(session: dict = None):
+def get_settings_keyboard():
     """Inline keyboard for settings navigation."""
-    ux = (session or {}).get("ux_mode", "send")
-    ux_label = "💬 UX: New Message ✅" if ux == "send" else "✏️ UX: Edit In-Place ✅"
     return {"inline_keyboard": [
         [{"text": "📡 Output URL",       "callback_data": "set_output_url"},
          {"text": "🎬 Input Playlist",   "callback_data": "view_playlist"}],
@@ -426,7 +367,6 @@ def get_settings_keyboard(session: dict = None):
         [{"text": "🛑 Stop on Error",    "callback_data": "toggle_stop_on_error"},
          {"text": "⏰ Open Timeout",     "callback_data": "set_open_timeout"}],
         [{"text": "🎨 Quality Preset",   "callback_data": "pick_quality_preset"}],
-        [{"text": ux_label,              "callback_data": "toggle_ux_mode"}],
         [{"text": "✅ Done",             "callback_data": "settings_done"}],
     ]}
 
@@ -742,15 +682,9 @@ def stream_engine_thread_target(chat_id: int):
         notify_state_change(chat_id, "starting")
 
         # --- Open output container ---
-        # Always read fresh from session so any /set output_url change takes effect.
-        with lock:
-            output_url = session['output_url']
-            output_format = session.get('output_format', 'flv')
-            open_timeout = session.get('open_timeout_seconds', 15)
-        # Also store the active_output_url in session for status display
-        with lock:
-            session['active_output_url'] = output_url
-        append_user_live_log(chat_id, f"Opening output: {output_url} [{output_format}]")
+        output_url = session['output_url']
+        output_format = session.get('output_format', 'flv')
+        open_timeout = session.get('open_timeout_seconds', 15)
         try:
             active_output_container = av.open(
                 output_url, mode='w', format=output_format,
@@ -797,9 +731,6 @@ def stream_engine_thread_target(chat_id: int):
                 if session.get('stop_gracefully_flag') or session['streaming_state'] == "stopping":
                     break
                 current_loop_iter = session['current_loop_iteration']
-                # Re-read total_loops and playlist each iteration so live changes are picked up
-                total_loops = session.get('loop_count', 0)
-                playlist = list(session.get('input_url_playlist', []))
 
             if total_loops != -1 and current_loop_iter >= max(total_loops, 1):
                 append_user_live_log(chat_id, f"Completed all {max(total_loops, 1)} loop(s).")
@@ -825,7 +756,7 @@ def stream_engine_thread_target(chat_id: int):
                 _input_container = None
                 reconnect_on_error = session.get('reconnect_on_stream_error', True)
                 reconnect_delay = session.get('reconnect_delay_seconds', 5)
-                max_reconnects = session.get('max_reconnect_attempts', 3)
+                max_reconnects = session.get('max_reconnect_attempts', 10)
                 read_timeout = session.get('read_timeout_seconds', 30)
 
                 try:
@@ -980,7 +911,7 @@ def stream_engine_thread_target(chat_id: int):
                         should_stop_now = session['streaming_state'] == "stopping"
                         reconnect_on = session.get('reconnect_on_stream_error', True)
                         cur_attempt = session.get('reconnect_attempt', 0)
-                        max_att = session.get('max_reconnect_attempts', 3)
+                        max_att = session.get('max_reconnect_attempts', 10)
                         stop_on_err = session.get('stop_on_error_in_playlist', True)
 
                     if should_stop_now:
@@ -1092,32 +1023,27 @@ def stream_engine_thread_target(chat_id: int):
 # ──────────────────────────────────────────────
 # STREAM CONTROL HANDLERS
 # ──────────────────────────────────────────────
-async def start_stream_handler(chat_id: int, message_id_to_edit: int = None):
+async def start_stream_handler(chat_id: int):
     session = get_user_session(chat_id)
     lock = session_locks[chat_id]
 
-    def _reply(text, kb):
-        if message_id_to_edit:
-            return edit_message_text(chat_id, message_id_to_edit, text, reply_markup=kb)
-        return send_message(chat_id, text, reply_markup=kb)
-
     with lock:
         state = session['streaming_state']
         if state in ("streaming", "paused", "starting", "reconnecting"):
-            return _reply(
+            return send_message(chat_id,
                 f"⚠️ Stream already active (state: <code>{state}</code>).\n"
                 f"Use /abort to stop it first.",
-                get_main_keyboard(session))
+                reply_markup=get_main_keyboard(session))
         if not session.get('input_url_playlist'):
-            return _reply(
+            return send_message(chat_id,
                 "📜 <b>Playlist is empty.</b>\nAdd at least one URL:\n"
                 "<code>/playlist add &lt;url&gt;</code>",
-                get_main_keyboard(session))
+                reply_markup=get_main_keyboard(session))
         if not session.get('output_url') or session['output_url'] == DEFAULT_USER_SETTINGS['output_url']:
-            return _reply(
+            return send_message(chat_id,
                 "📡 <b>Output URL not configured.</b>\n"
                 "Set it with: <code>/set output_url rtmp://your-url/key</code>",
-                get_main_keyboard(session))
+                reply_markup=get_main_keyboard(session))
         session['streaming_state'] = "starting"
         session['error_notification_user'] = ""
 
@@ -1133,7 +1059,7 @@ async def start_stream_handler(chat_id: int, message_id_to_edit: int = None):
     await asyncio.sleep(0.3)
     t_watch.start()
 
-    return _reply(
+    return send_message(chat_id,
         "🔄 <b>Stream starting…</b>\n\n"
         "I'll notify you when it's live.\n\n"
         "<b>Commands while streaming:</b>\n"
@@ -1141,10 +1067,10 @@ async def start_stream_handler(chat_id: int, message_id_to_edit: int = None):
         "  /resume — resume\n"
         "  /abort — stop the stream\n"
         "  /status — current status",
-        get_main_keyboard(session))
+        reply_markup=get_main_keyboard(session))
 
 
-async def pause_stream_handler(chat_id: int, message_id: int = None):
+async def pause_stream_handler(chat_id: int):
     session = get_user_session(chat_id)
     lock = session_locks[chat_id]
     with lock:
@@ -1155,21 +1081,17 @@ async def pause_stream_handler(chat_id: int, message_id: int = None):
             ok = False
             st = session['streaming_state']
 
-    def _reply(text, kb):
-        if message_id:
-            return edit_message_text(chat_id, message_id, text, reply_markup=kb)
-        return send_message(chat_id, text, reply_markup=kb)
-
     if ok:
         append_user_live_log(chat_id, "Paused by user.")
         threading.Thread(target=notify_state_change, args=(chat_id, "paused"), daemon=True).start()
-        return _reply("⏸ <b>Stream paused.</b>\nUse /resume to continue or /abort to stop.",
-                      get_main_keyboard(session))
+        return send_message(chat_id, "⏸ <b>Stream paused.</b>\nUse /resume to continue or /abort to stop.",
+                            reply_markup=get_main_keyboard(session))
     else:
-        return _reply(f"ℹ️ Cannot pause — state is <code>{st}</code>.", get_main_keyboard(session))
+        return send_message(chat_id, f"ℹ️ Cannot pause — state is <code>{st}</code>.",
+                            reply_markup=get_main_keyboard(session))
 
 
-async def resume_stream_handler(chat_id: int, message_id: int = None):
+async def resume_stream_handler(chat_id: int):
     session = get_user_session(chat_id)
     lock = session_locks[chat_id]
     with lock:
@@ -1180,20 +1102,16 @@ async def resume_stream_handler(chat_id: int, message_id: int = None):
             ok = False
             st = session['streaming_state']
 
-    def _reply(text, kb):
-        if message_id:
-            return edit_message_text(chat_id, message_id, text, reply_markup=kb)
-        return send_message(chat_id, text, reply_markup=kb)
-
     if ok:
         append_user_live_log(chat_id, "Resumed by user.")
         threading.Thread(target=notify_state_change, args=(chat_id, "streaming"), daemon=True).start()
-        return _reply("▶️ <b>Stream resumed.</b>", get_main_keyboard(session))
+        return send_message(chat_id, "▶️ <b>Stream resumed.</b>", reply_markup=get_main_keyboard(session))
     else:
-        return _reply(f"ℹ️ Cannot resume — state is <code>{st}</code>.", get_main_keyboard(session))
+        return send_message(chat_id, f"ℹ️ Cannot resume — state is <code>{st}</code>.",
+                            reply_markup=get_main_keyboard(session))
 
 
-async def abort_stream_handler(chat_id: int, message_id: int = None):
+async def abort_stream_handler(chat_id: int):
     session = get_user_session(chat_id)
     lock = session_locks[chat_id]
     thread_ref = None
@@ -1207,13 +1125,9 @@ async def abort_stream_handler(chat_id: int, message_id: int = None):
             aborted = False
             st = session['streaming_state']
 
-    def _reply(text, kb):
-        if message_id:
-            return edit_message_text(chat_id, message_id, text, reply_markup=kb)
-        return send_message(chat_id, text, reply_markup=kb)
-
     if not aborted:
-        return _reply(f"ℹ️ No active stream (state: <code>{st}</code>).", get_main_keyboard(session))
+        return send_message(chat_id, f"ℹ️ No active stream (state: <code>{st}</code>).",
+                            reply_markup=get_main_keyboard(session))
 
     append_user_live_log(chat_id, "Abort requested by user.")
     if thread_ref and thread_ref.is_alive():
@@ -1226,8 +1140,9 @@ async def abort_stream_handler(chat_id: int, message_id: int = None):
             session['streaming_state'] = "stopped"
         session['stream_thread_ref'] = None
 
-    return _reply("⏹ <b>Stream aborted.</b>\n\n" + compose_status_message(chat_id),
-                  get_main_keyboard(session))
+    return send_message(chat_id,
+        "⏹ <b>Stream aborted.</b>\n\n" + compose_status_message(chat_id),
+        reply_markup=get_main_keyboard(session))
 
 
 # ──────────────────────────────────────────────
@@ -1426,270 +1341,122 @@ async def handle_logo_upload(chat_id: int, message: dict):
     if not file_id:
         return send_message(chat_id, "❌ Could not get file from message.", reply_markup=get_main_keyboard(session))
 
-    # Webhook-only mode: Telegram sends only file_id, not the actual bytes.
-    # Downloading requires an outbound getFile API call which is blocked on HuggingFace Spaces.
-    with lock:
-        session['current_step'] = None
-    return send_message(chat_id,
-        "⚠️ <b>Logo upload is unavailable in webhook-only mode.</b>\n\n"
-        "This deployment blocks outbound requests, so the bot cannot download "
-        "files from Telegram's servers.\n\n"
-        "To use a logo, host the image publicly and set it via a URL workaround, "
-        "or run the bot in an environment that allows outbound connections.",
-        reply_markup=get_main_keyboard(session))
-
-
-# ──────────────────────────────────────────────
-# SCHEDULE HANDLER
-# ──────────────────────────────────────────────
-# Scheduling flow (conversation steps):
-#   sched_when      → user picks "timer" or "datetime"
-#   sched_timer     → user types "in X minutes/hours"
-#   sched_datetime  → user types YYYY-MM-DD HH:MM:SS
-#   sched_name      → user types a friendly job name
-#   sched_rtmp      → user types the RTMP output URL for this job
-#   sched_input     → user types the input URL for this job
-# Then job is registered with its own output+input URLs (independent of session).
-
-def _list_schedules(chat_id: int) -> str:
-    """Build schedule list text."""
-    jobs = scheduler.get_jobs()
-    user_jobs = [j for j in jobs if j.id.startswith(f"stream_{chat_id}_")]
-    lines = ["🕒 <b>Scheduled Streams</b> <i>(in-memory, lost on restart)</i>\n"]
-    if user_jobs:
-        for j in user_jobs:
-            rt = j.next_run_time.strftime("%Y-%m-%d %H:%M:%S UTC") if j.next_run_time else "N/A"
-            meta = getattr(j, "_job_meta", {})
-            rtmp = meta.get("output_url", "?")
-            inp  = meta.get("input_url",  "?")
-            lines.append(
-                f"  • <b>{esc(j.name)}</b>\n"
-                f"    ⏰ <code>{rt}</code>\n"
-                f"    📡 <code>{esc(rtmp[:60])}</code>\n"
-                f"    🎬 <code>{esc(inp[:60])}</code>\n"
-                f"    Cancel: <code>/schedule cancel {esc(j.id)}</code>"
-            )
-    else:
-        lines.append("  No scheduled streams.")
-    lines += [
-        "",
-        "➕ <b>Add a schedule:</b>  use <b>🕒 Schedule</b> button or <code>/schedule new</code>",
-        "❌ <b>Cancel:</b>  <code>/schedule cancel &lt;job_id&gt;</code>",
-    ]
-    return "\n".join(lines)
-
-
-def get_schedule_when_keyboard():
-    return {"inline_keyboard": [
-        [{"text": "⏱ Timer (in X minutes)", "callback_data": "sched_pick_timer"},
-         {"text": "📅 Date & Time (UTC)",   "callback_data": "sched_pick_datetime"}],
-        [{"text": "❌ Cancel",               "callback_data": "sched_cancel_setup"}],
-    ]}
-
-
-def get_schedule_menu_keyboard(session: dict = None):
-    """Keyboard shown on the schedule list view."""
-    return {"inline_keyboard": [
-        [{"text": "➕ New Schedule", "callback_data": "sched_new"}],
-        [{"text": "🔙 Back",         "callback_data": "settings_done"}],
-    ]}
-
+    if not TELEGRAM_BOT_TOKEN:
+        return send_message(chat_id,
+            "⚠️ <b>TELEGRAM_BOT_TOKEN not set.</b>\nCannot download files. Set the env variable and restart.",
+            reply_markup=get_main_keyboard(session))
 
-async def handle_schedule_command(chat_id: int, text: str):
-    session = get_user_session(chat_id)
-    lock = session_locks[chat_id]
-    parts = text.split(maxsplit=2)
-    sub = parts[1].lower() if len(parts) > 1 else ""
+    logo_bytes = download_telegram_file(file_id)
+    if not logo_bytes:
+        return send_message(chat_id, "❌ Failed to download the file from Telegram. Try again.",
+                            reply_markup=get_main_keyboard(session))
 
-    # List / entry point
-    if not sub or sub == "list":
-        return send_message(chat_id, _list_schedules(chat_id),
+    # Validate it's an image
+    try:
+        img = Image.open(io.BytesIO(logo_bytes))
+        img.verify()
+    except Exception as e:
+        return send_message(chat_id, f"❌ Invalid image file: {esc(str(e))}",
                             reply_markup=get_main_keyboard(session))
 
-    # Start new schedule conversation
-    if sub == "new":
-        with lock:
-            session["current_step"] = "sched_when"
-            session["_sched_draft"] = {}
+    MAX_SIZE = 5 * 1024 * 1024  # 5 MB
+    if len(logo_bytes) > MAX_SIZE:
         return send_message(chat_id,
-            "🕒 <b>New Scheduled Stream</b>\n\nWhen should it start?",
-            reply_markup=get_schedule_when_keyboard())
+            f"❌ File too large ({len(logo_bytes)/1024/1024:.1f} MB). Max 5 MB.",
+            reply_markup=get_main_keyboard(session))
 
-    # Cancel a job
-    if sub == "cancel":
-        job_id = parts[2].strip() if len(parts) > 2 else None
-        if not job_id:
-            return send_message(chat_id,
-                "Usage: <code>/schedule cancel &lt;job_id&gt;</code>",
-                reply_markup=get_main_keyboard(session))
-        try:
-            scheduler.remove_job(job_id)
-            return send_message(chat_id,
-                f"✅ Cancelled: <code>{esc(job_id)}</code>",
-                reply_markup=get_main_keyboard(session))
-        except Exception:
-            return send_message(chat_id,
-                f"❌ Job not found: <code>{esc(job_id)}</code>",
-                reply_markup=get_main_keyboard(session))
+    with lock:
+        session['logo_data_bytes'] = logo_bytes
+        session['logo_mime_type'] = mime_type
+        session['logo_original_filename'] = filename
+        session['logo_enabled'] = True
+        session['current_step'] = None
 
+    append_user_live_log(chat_id, f"Logo uploaded: {filename} ({len(logo_bytes)/1024:.1f} KB)")
     return send_message(chat_id,
-        "⚠️ Unknown sub-command.\nTry /schedule, /schedule new, or /schedule cancel &lt;id&gt;",
+        f"✅ <b>Logo uploaded and enabled!</b>\n"
+        f"File: <code>{esc(filename)}</code> ({len(logo_bytes)/1024:.1f} KB)\n\n"
+        f"Adjust logo settings:\n"
+        f"  <code>/set logo_position top_right</code>\n"
+        f"  <code>/set logo_scale 0.1</code>\n"
+        f"  <code>/set logo_opacity 0.8</code>\n"
+        f"  <code>/set logo_enabled off</code> — to disable",
         reply_markup=get_main_keyboard(session))
 
 
-async def handle_schedule_conversation(chat_id: int, text: str):
-    """Handle text input during schedule setup conversation steps."""
+# ──────────────────────────────────────────────
+# SCHEDULE HANDLER
+# ──────────────────────────────────────────────
+async def handle_schedule_command(chat_id: int, text: str):
     session = get_user_session(chat_id)
-    lock = session_locks[chat_id]
-    step = session.get("current_step", "")
-    draft = session.setdefault("_sched_draft", {})
-
-    if step == "sched_timer":
-        # Parse "30", "30m", "2h", "1h30m", "90 minutes" etc.
-        raw = text.strip().lower().replace(" ", "")
-        minutes = 0
-        import re as _re
-        hm = _re.match(r"^(?:(\d+)h)?(?:(\d+)m?)?$", raw)
-        plain = _re.match(r"^(\d+)$", raw)
-        if hm and (hm.group(1) or hm.group(2)):
-            minutes = int(hm.group(1) or 0) * 60 + int(hm.group(2) or 0)
-        elif plain:
-            minutes = int(plain.group(1))
-        if minutes <= 0:
-            return send_message(chat_id,
-                "❌ Could not parse duration. Try <code>30</code>, <code>2h</code>, <code>1h30m</code>\nOr /cancel.")
-        trigger_time = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(minutes=minutes)
-        draft["trigger_time"] = trigger_time
-        with lock:
-            session["current_step"] = "sched_name"
-        return send_message(chat_id,
-            f"✅ Timer set: <b>{minutes} minute(s)</b> from now\n"
-            f"  → <code>{trigger_time.strftime('%Y-%m-%d %H:%M:%S UTC')}</code>\n\n"
-            f"Give this schedule a <b>name</b> (or type <code>skip</code>):")
-
-    elif step == "sched_datetime":
-        raw = text.strip()
-        try:
-            # Accept both "YYYY-MM-DD HH:MM:SS" and "YYYY-MM-DD HH:MM"
-            fmt = "%Y-%m-%d %H:%M:%S" if len(raw) > 16 else "%Y-%m-%d %H:%M"
-            trigger_time = datetime.datetime.strptime(raw, fmt).replace(tzinfo=datetime.timezone.utc)
-        except ValueError:
-            return send_message(chat_id,
-                "❌ Invalid format. Use <code>YYYY-MM-DD HH:MM:SS</code> (UTC)\nOr /cancel.")
-        if trigger_time <= datetime.datetime.now(datetime.timezone.utc):
-            return send_message(chat_id,
-                "❌ That time is in the past. Enter a future time (UTC):\nOr /cancel.")
-        draft["trigger_time"] = trigger_time
-        with lock:
-            session["current_step"] = "sched_name"
-        return send_message(chat_id,
-            f"✅ Time set: <code>{trigger_time.strftime('%Y-%m-%d %H:%M:%S UTC')}</code>\n\n"
-            f"Give this schedule a <b>name</b> (or type <code>skip</code>):")
-
-    elif step == "sched_name":
-        name = text.strip()
-        draft["name"] = f"Scheduled Stream {chat_id}" if name.lower() == "skip" or not name else name
-        with lock:
-            session["current_step"] = "sched_rtmp"
-        return send_message(chat_id,
-            f"📡 <b>Step: RTMP Output URL</b>\n\n"
-            f"Enter the RTMP URL to stream to:\n"
-            f"<code>rtmp://a.rtmp.youtube.com/live2/YOUR_KEY</code>\n\n"
-            f"Or type <code>use</code> to use your current output URL (<code>{esc(session.get('output_url', 'not set'))}</code>)\n"
-            f"Or /cancel.")
-
-    elif step == "sched_rtmp":
-        raw = text.strip()
-        if raw.lower() == "use":
-            url = session.get("output_url", "")
-        else:
-            url = raw
-        if not validate_url(url):
-            return send_message(chat_id,
-                "❌ Invalid URL. Must start with rtmp/http/https/rtsp/...\nTry again or /cancel.")
-        draft["output_url"] = url
-        with lock:
-            session["current_step"] = "sched_input"
-        return send_message(chat_id,
-            f"🎬 <b>Step: Input URL</b>\n\n"
-            f"Enter the stream/video input URL:\n"
-            f"<code>https://example.com/video.mp4</code>\n\n"
-            f"Or type <code>use</code> to use your current playlist first item (<code>{esc((session.get('input_url_playlist') or ['not set'])[0])}</code>)\n"
-            f"Or /cancel.")
+    parts = text.split(maxsplit=3)
 
-    elif step == "sched_input":
-        raw = text.strip()
-        if raw.lower() == "use":
-            pl = session.get("input_url_playlist", [])
-            url = pl[0] if pl else ""
+    if len(parts) < 3:
+        jobs = scheduler.get_jobs()
+        user_jobs = [j for j in jobs if j.id.startswith(f"stream_{chat_id}_")]
+        lines = ["🕒 <b>Scheduled Streams</b> <i>(in-memory, lost on restart)</i>\n"]
+        if user_jobs:
+            for j in user_jobs:
+                rt = j.next_run_time.strftime('%Y-%m-%d %H:%M:%S UTC') if j.next_run_time else "N/A"
+                lines.append(f"  • <b>{esc(j.name)}</b> at <code>{rt}</code>")
+                lines.append(f"    Cancel: <code>/schedule cancel {esc(j.id)}</code>")
         else:
-            url = raw
-        if not validate_url(url):
-            return send_message(chat_id,
-                "❌ Invalid URL. Must start with http/https/rtmp/rtsp/...\nTry again or /cancel.")
-        draft["input_url"] = url
+            lines.append("  No scheduled streams.")
+        lines += [
+            "",
+            "<b>Schedule a stream:</b>",
+            "  <code>/schedule YYYY-MM-DD HH:MM:SS [Name]</code>",
+            "  Example: <code>/schedule 2025-12-31 23:55:00 NYE</code>",
+            "",
+            "<b>Cancel a schedule:</b>",
+            "  <code>/schedule cancel &lt;job_id&gt;</code>",
+        ]
+        return send_message(chat_id, "\n".join(lines), reply_markup=get_main_keyboard(session))
 
-        # All info collected — register the job
-        trigger_time = draft["trigger_time"]
-        job_name     = draft["name"]
-        output_url   = draft["output_url"]
-        input_url    = draft["input_url"]
+    if parts[1].lower() == "cancel":
+        job_id = parts[2] if len(parts) > 2 else None
+        if job_id:
+            try:
+                scheduler.remove_job(job_id)
+                return send_message(chat_id, f"✅ Schedule <code>{esc(job_id)}</code> cancelled.",
+                                    reply_markup=get_main_keyboard(session))
+            except Exception:
+                return send_message(chat_id, f"❌ Job not found: <code>{esc(job_id)}</code>",
+                                    reply_markup=get_main_keyboard(session))
 
-        job_id = f"stream_{chat_id}_{int(trigger_time.timestamp())}"
-        try:
-            job = scheduler.add_job(
-                _scheduled_stream_runner,
-                "date",
-                run_date=trigger_time,
-                args=[chat_id, output_url, input_url],
-                id=job_id,
-                name=job_name,
-                replace_existing=True,
-            )
-            # Stash meta on job object for display (APScheduler allows arbitrary attrs)
-            job._job_meta = {"output_url": output_url, "input_url": input_url}
-        except Exception as e:
-            return send_message(chat_id, f"❌ Failed to register job: {esc(str(e))}",
-                                reply_markup=get_main_keyboard(session))
+    try:
+        date_str, time_str = parts[1], parts[2]
+        job_name = parts[3] if len(parts) > 3 else f"Stream for {chat_id}"
+        trigger_time = datetime.datetime.strptime(f"{date_str} {time_str}", "%Y-%m-%d %H:%M:%S")
+        trigger_time = trigger_time.replace(tzinfo=datetime.timezone.utc)
 
-        mins_away = int((trigger_time - datetime.datetime.now(datetime.timezone.utc)).total_seconds() / 60)
-        with lock:
-            session["current_step"] = None
-            session["_sched_draft"] = {}
+        if trigger_time <= datetime.datetime.now(datetime.timezone.utc):
+            return send_message(chat_id, "❌ Scheduled time must be in the future (UTC).")
 
+        job_id = f"stream_{chat_id}_{int(trigger_time.timestamp())}"
+        scheduler.add_job(
+            _scheduled_stream_runner,
+            'date',
+            run_date=trigger_time,
+            args=[chat_id],
+            id=job_id,
+            name=job_name,
+            replace_existing=True
+        )
         return send_message(chat_id,
-            f"✅ <b>Stream Scheduled!</b>\n\n"
-            f"  📛 <b>Name:</b> {esc(job_name)}\n"
-            f"  ⏰ <b>Time:</b> <code>{trigger_time.strftime('%Y-%m-%d %H:%M:%S UTC')}</code> (~{mins_away}m from now)\n"
-            f"  📡 <b>Output:</b> <code>{esc(output_url[:60])}</code>\n"
-            f"  🎬 <b>Input:</b>  <code>{esc(input_url[:60])}</code>\n"
-            f"  🔑 <b>ID:</b> <code>{job_id}</code>\n\n"
-            f"View all: /schedule\nCancel: <code>/schedule cancel {job_id}</code>",
+            f"✅ <b>Stream scheduled!</b>\n"
+            f"  Name: <b>{esc(job_name)}</b>\n"
+            f"  Time: <code>{trigger_time.strftime('%Y-%m-%d %H:%M:%S UTC')}</code>\n"
+            f"  ID: <code>{job_id}</code>\n\n"
+            f"View/cancel: /schedule",
             reply_markup=get_main_keyboard(session))
-
-    # Fallback — unknown step
-    with lock:
-        session["current_step"] = None
-    return send_message(chat_id,
-        "⚠️ Schedule setup cancelled (unknown step).",
-        reply_markup=get_main_keyboard(session))
+    except ValueError as e:
+        return send_message(chat_id,
+            f"❌ Invalid date/time format.\nExpected: <code>YYYY-MM-DD HH:MM:SS</code>\nError: {esc(str(e))}")
 
 
-def _scheduled_stream_runner(chat_id: int, output_url: str = None, input_url: str = None):
-    """Run by APScheduler at the scheduled time. Overrides session URLs if provided."""
+def _scheduled_stream_runner(chat_id: int):
     logger.info(f"[Scheduler] Firing scheduled stream for chat {chat_id}")
-    session = get_user_session(chat_id)
-    lock = session_locks[chat_id]
-
-    # Override session URLs with the per-job ones
-    if output_url:
-        with lock:
-            session["output_url"] = output_url
-            session["active_output_url"] = output_url
-    if input_url:
-        with lock:
-            session["input_url_playlist"] = [input_url]
-
     loop = _main_event_loop
     if loop and loop.is_running():
         asyncio.run_coroutine_threadsafe(start_stream_handler(chat_id), loop)
@@ -1728,13 +1495,9 @@ def get_help_text() -> str:
         "  /set logo_scale 0.1\n"
         "  /set logo_opacity 0.8\n\n"
         "<b>━━ Schedule ━━</b>\n"
-        "  /schedule — List &amp; manage schedules\n"
-        "  /schedule new — Create a new schedule (conversation)\n"
-        "  /schedule cancel &lt;id&gt; — Cancel a scheduled stream\n\n"
-        "<b>📅 Scheduling supports:</b>\n"
-        "  ⏱ Timer: <i>in X minutes/hours</i>\n"
-        "  📅 Date &amp; time: <code>YYYY-MM-DD HH:MM:SS</code> (UTC)\n"
-        "  Each schedule has its own RTMP output + input URL\n\n"
+        "  /schedule — List schedules\n"
+        "  /schedule YYYY-MM-DD HH:MM:SS [Name]\n"
+        "  /schedule cancel &lt;id&gt;\n\n"
         "<b>━━ Diagnostics ━━</b>\n"
         "  /logs — Recent user logs\n"
         "  /globallogs — System logs\n\n"
@@ -1892,73 +1655,40 @@ async def _handle_update_inner(update: dict):
         logger.info(f"[Chat {chat_id}] Callback: {data}")
         ack = answer_callback_query(cq["id"])
 
-        # ── UX mode helpers ──────────────────────────────────────────────────
-        # ux_mode "send"  → always sendMessage (new bubble, default)
-        # ux_mode "edit"  → editMessageText in-place (replaces the button msg)
-        ux = session.get("ux_mode", "send")
-
-        def reply(text, kb=None):
-            """Send or edit depending on ux_mode."""
-            kb = kb or get_main_keyboard(session)
-            if ux == "edit":
-                return edit_message_text(chat_id, message_id, text, reply_markup=kb)
-            return send_message(chat_id, text, reply_markup=kb)
-
-        def edit(text, kb=None):
-            """Always edit in-place (used for sub-menus that must stay in same msg)."""
-            return edit_message_text(chat_id, message_id, text,
-                                     reply_markup=kb or get_main_keyboard(session))
-
-        # ─────────────────────────────────────────────────────────────────────
         # Stream controls
         if data == "stream_start":
-            mid = message_id if ux == "edit" else None
-            return [ack, await start_stream_handler(chat_id, message_id_to_edit=mid)]
+            return [ack, await start_stream_handler(chat_id)]
         elif data == "stream_pause":
-            mid = message_id if ux == "edit" else None
-            return [ack, await pause_stream_handler(chat_id, message_id=mid)]
+            return [ack, await pause_stream_handler(chat_id)]
         elif data == "stream_resume":
-            mid = message_id if ux == "edit" else None
-            return [ack, await resume_stream_handler(chat_id, message_id=mid)]
+            return [ack, await resume_stream_handler(chat_id)]
         elif data == "stream_abort":
-            mid = message_id if ux == "edit" else None
-            return [ack, await abort_stream_handler(chat_id, message_id=mid)]
+            return [ack, await abort_stream_handler(chat_id)]
         elif data == "stream_status":
-            status_text = compose_status_message(chat_id, include_config=True)
-            # Register this message for real-time auto-updates
-            register_status_message(chat_id, message_id)
-            return [ack, edit(status_text)]  # always edit for live status
+            return [ack, send_message(chat_id, compose_status_message(chat_id, include_config=True),
+                                      reply_markup=get_main_keyboard(session))]
         elif data == "stream_stop_graceful":
             with lock:
                 session['stop_gracefully_flag'] = True
             append_user_live_log(chat_id, "Graceful stop requested.")
-            return [ack, edit("⏳ <b>Will stop after current loop finishes.</b>\n\n"
-                              + compose_status_message(chat_id))]
+            return [ack, send_message(chat_id,
+                "⏳ <b>Will stop after current loop finishes.</b>",
+                reply_markup=get_main_keyboard(session))]
 
         # Settings navigation
         elif data == "open_settings":
-            return [ack, edit(
+            return [ack, send_message(chat_id,
                 "⚙️ <b>Settings</b>\n\n" + format_settings_display(session) + "\n\n"
                 "Tap a parameter to change it, or use <code>/set &lt;field&gt; &lt;value&gt;</code>",
-                get_settings_keyboard(session))]
-
-        elif data == "toggle_ux_mode":
-            with lock:
-                current_ux = session.get("ux_mode", "send")
-                session["ux_mode"] = "edit" if current_ux == "send" else "send"
-                new_ux = session["ux_mode"]
-            label = "New Message (sendMessage)" if new_ux == "send" else "Edit In-Place (editMessageText)"
-            return [ack, edit(
-                f"✅ <b>UX Mode switched to:</b> <code>{label}</code>\n\n"
-                f"{'💬 Each button press sends a new message.' if new_ux == 'send' else '✏️ Button presses edit the existing message in-place.'}\n\n"
-                + format_settings_display(session),
-                get_settings_keyboard(session))]
+                reply_markup=get_settings_keyboard())]
 
         elif data == "settings_done":
-            return [ack, reply(compose_status_message(chat_id, True))]
+            return [ack, send_message(chat_id, compose_status_message(chat_id, True),
+                                      reply_markup=get_main_keyboard(session))]
 
         elif data == "pick_quality_preset":
-            return [ack, edit("🎨 <b>Choose Quality Preset:</b>", get_quality_keyboard())]
+            return [ack, send_message(chat_id, "🎨 <b>Choose Quality Preset:</b>",
+                                      reply_markup=get_quality_keyboard())]
 
         elif data.startswith("apply_quality_"):
             q = data.replace("apply_quality_", "")
@@ -1967,33 +1697,39 @@ async def _handle_update_inner(update: dict):
                     session['quality_preset'] = q
                     for k, v in QUALITY_PRESETS[q].items():
                         session[k] = v
-                return [ack, edit(
+                return [ack, send_message(chat_id,
                     f"✅ Quality preset <code>{q}</code> applied.\n\n" + format_settings_display(session),
-                    get_settings_keyboard(session))]
+                    reply_markup=get_settings_keyboard())]
 
         elif data == "set_video_codec":
-            return [ack, edit("🎥 <b>Choose Video Codec:</b>", get_codec_keyboard("video"))]
+            return [ack, send_message(chat_id, "🎥 <b>Choose Video Codec:</b>",
+                                      reply_markup=get_codec_keyboard("video"))]
 
         elif data.startswith("set_vcodec_"):
             codec = data.replace("set_vcodec_", "")
             with lock: session['video_codec'] = codec
-            return [ack, edit(f"✅ Video codec: <code>{codec}</code>", get_settings_keyboard(session))]
+            return [ack, send_message(chat_id, f"✅ Video codec: <code>{codec}</code>",
+                                      reply_markup=get_settings_keyboard())]
 
         elif data == "set_audio_codec":
-            return [ack, edit("🔊 <b>Choose Audio Codec:</b>", get_codec_keyboard("audio"))]
+            return [ack, send_message(chat_id, "🔊 <b>Choose Audio Codec:</b>",
+                                      reply_markup=get_codec_keyboard("audio"))]
 
         elif data.startswith("set_acodec_"):
             codec = data.replace("set_acodec_", "")
             with lock: session['audio_codec'] = codec
-            return [ack, edit(f"✅ Audio codec: <code>{codec}</code>", get_settings_keyboard(session))]
+            return [ack, send_message(chat_id, f"✅ Audio codec: <code>{codec}</code>",
+                                      reply_markup=get_settings_keyboard())]
 
         elif data == "set_ffmpeg_preset":
-            return [ack, edit("⚡ <b>Choose FFmpeg Preset:</b>", get_preset_keyboard())]
+            return [ack, send_message(chat_id, "⚡ <b>Choose FFmpeg Preset:</b>",
+                                      reply_markup=get_preset_keyboard())]
 
         elif data.startswith("set_preset_"):
             preset = data.replace("set_preset_", "")
             with lock: session['ffmpeg_preset'] = preset
-            return [ack, edit(f"✅ Preset: <code>{preset}</code>", get_settings_keyboard(session))]
+            return [ack, send_message(chat_id, f"✅ Preset: <code>{preset}</code>",
+                                      reply_markup=get_settings_keyboard())]
 
         # Inline-triggered field edits (ask user to type)
         elif data in ("set_output_url", "set_resolution", "set_fps", "set_video_bitrate",
@@ -2017,11 +1753,12 @@ async def _handle_update_inner(update: dict):
             with lock:
                 session['current_step'] = "editing_field"
                 session['settings_editing_field'] = field
-            return [ack, reply(
+            return [ack, send_message(chat_id,
                 f"📝 <b>Set {field}</b>\n"
                 f"Current: <code>{esc(str(cur))}</code>\n"
                 f"Expected: {esc(desc)}\n\n"
-                f"Type the new value now, or /cancel to abort.")]
+                f"Type the new value now, or /cancel to abort.",
+                reply_markup=get_main_keyboard(session))]
 
         elif data in ("toggle_reconnect", "toggle_stop_on_error"):
             field_map = {
@@ -2032,9 +1769,9 @@ async def _handle_update_inner(update: dict):
             with lock:
                 session[field] = not session.get(field, True)
                 new_val = session[field]
-            return [ack, edit(
+            return [ack, send_message(chat_id,
                 f"✅ <b>{field}</b> → <code>{'on' if new_val else 'off'}</code>",
-                get_settings_keyboard(session))]
+                reply_markup=get_settings_keyboard())]
 
         # Playlist view
         elif data == "view_playlist":
@@ -2049,7 +1786,7 @@ async def _handle_update_inner(update: dict):
             else:
                 msg = ("📜 <b>Playlist is empty.</b>\n"
                        "<code>/playlist add &lt;url&gt;</code>")
-            return [ack, reply(msg)]
+            return [ack, send_message(chat_id, msg, reply_markup=get_main_keyboard(session))]
 
         # Logo
         elif data == "cfg_logo":
@@ -2076,95 +1813,69 @@ async def _handle_update_inner(update: dict):
                 lines.append("Change scale/opacity: <code>/set logo_scale 0.15</code>")
             else:
                 lines.append("No logo uploaded.")
-            return [ack, edit("\n".join(lines), {"inline_keyboard": logo_btns})]
+            return [ack, send_message(chat_id, "\n".join(lines),
+                                      reply_markup={"inline_keyboard": logo_btns})]
 
         elif data == "toggle_logo":
             with lock:
                 session['logo_enabled'] = not session.get('logo_enabled', False)
                 v = session['logo_enabled']
-            return [ack, edit(f"🖼 Logo {'enabled ✅' if v else 'disabled ❌'}.")]
+            return [ack, send_message(chat_id, f"🖼 Logo {'enabled ✅' if v else 'disabled ❌'}.",
+                                      reply_markup=get_main_keyboard(session))]
 
         elif data == "change_logo_pos":
-            return [ack, edit("📍 <b>Choose logo position:</b>", get_logo_pos_keyboard())]
+            return [ack, send_message(chat_id, "📍 <b>Choose logo position:</b>",
+                                      reply_markup=get_logo_pos_keyboard())]
 
         elif data.startswith("set_logo_pos_"):
             pos = data.replace("set_logo_pos_", "")
             with lock: session['logo_position'] = pos
-            return [ack, edit(f"✅ Logo position: <code>{pos}</code>")]
+            return [ack, send_message(chat_id, f"✅ Logo position: <code>{pos}</code>",
+                                      reply_markup=get_main_keyboard(session))]
 
         elif data == "upload_new_logo":
             with lock: session['current_step'] = "awaiting_logo"
-            return [ack, reply("🖼 Send a PNG or JPG image now. /cancel to abort.")]
+            return [ack, send_message(chat_id,
+                "🖼 Send a PNG or JPG image now. /cancel to abort.",
+                reply_markup=get_main_keyboard(session))]
 
         # Schedule
         elif data == "cfg_schedule":
-            return [ack, reply(_list_schedules(chat_id),
-                               get_schedule_menu_keyboard(session))]
-
-        elif data == "sched_new":
-            with lock:
-                session["current_step"] = "sched_when"
-                session["_sched_draft"] = {}
-            return [ack, reply(
-                "🕒 <b>New Scheduled Stream</b>\n\nWhen should it start?",
-                get_schedule_when_keyboard())]
-
-        elif data == "sched_pick_timer":
-            with lock:
-                session["current_step"] = "sched_timer"
-            return [ack, reply(
-                "\u23f1 <b>Timer Setup</b>\n\n"
-                "How long from now? Type a duration:\n"
-                "  <code>30</code> \u2192 30 minutes\n"
-                "  <code>2h</code> \u2192 2 hours\n"
-                "  <code>1h30m</code> \u2192 1h 30min\n\n"
-                "Or /cancel.")]
-
-        elif data == "sched_pick_datetime":
-            with lock:
-                session["current_step"] = "sched_datetime"
-            return [ack, reply(
-                "\U0001f4c5 <b>Date &amp; Time (UTC)</b>\n\n"
-                "Enter the start time:\n"
-                "<code>YYYY-MM-DD HH:MM:SS</code>\n"
-                "Example: <code>2025-12-31 23:55:00</code>\n\n"
-                "Or /cancel.")]
-
-        elif data == "sched_cancel_setup":
-            with lock:
-                session["current_step"] = None
-                session["_sched_draft"] = {}
-            return [ack, reply("❌ Schedule setup cancelled.",
-                               get_main_keyboard(session))]
+            return [ack, await handle_schedule_command(chat_id, "/schedule")]
 
         # Quick setup
         elif data == "quick_setup":
             with lock:
                 session['current_step'] = "quick_output_url"
-            return [ack, reply(
+            return [ack, send_message(chat_id,
                 "⚙️ <b>Quick Setup</b>\n\n"
                 "Step 1/2: Enter your <b>RTMP Output URL</b>:\n"
                 "<code>rtmp://a.rtmp.youtube.com/live2/YOUR_STREAM_KEY</code>\n\n"
-                "Or /cancel to abort.")]
+                "Or /cancel to abort.",
+                reply_markup=get_main_keyboard(session))]
 
         # Reset
         elif data == "confirm_reset":
-            return [ack, edit("⚠️ <b>Reset all settings to defaults?</b>",
-                              get_reset_confirm_keyboard())]
+            return [ack, send_message(chat_id,
+                "⚠️ <b>Reset all settings to defaults?</b>",
+                reply_markup=get_reset_confirm_keyboard())]
 
         elif data == "do_reset":
             reset_session_settings(chat_id)
-            return [ack, reply("🔄 <b>Settings restored to defaults.</b>\n\n"
-                              + compose_status_message(chat_id, True))]
+            return [ack, send_message(chat_id,
+                "🔄 <b>Settings restored to defaults.</b>\n\n" + compose_status_message(chat_id, True),
+                reply_markup=get_main_keyboard(session))]
 
         # Logs
         elif data == "show_user_logs":
             logs = session.get('live_log_lines_user', [])
             last = "\n".join(logs[-20:]) if logs else "No logs yet."
-            return [ack, reply("📋 <b>Stream Logs (last 20):</b>\n<pre>" + esc(last) + "</pre>")]
+            return [ack, send_message(chat_id,
+                "📋 <b>Stream Logs (last 20):</b>\n<pre>" + esc(last) + "</pre>",
+                reply_markup=get_main_keyboard(session))]
 
         elif data == "show_help":
-            return [ack, reply(get_help_text())]
+            return [ack, send_message(chat_id, get_help_text(), reply_markup=get_main_keyboard(session))]
 
         return [ack, answer_callback_query(cq["id"], "Unknown action", show_alert=True)]
 
@@ -2237,10 +1948,6 @@ async def handle_conversation_input(chat_id: int, text: str):
         return send_message(chat_id,
             "🖼 Please <b>send an image file</b> (PNG/JPG), not text. /cancel to abort.")
 
-    elif step in ("sched_when", "sched_timer", "sched_datetime",
-                  "sched_name", "sched_rtmp", "sched_input"):
-        return await handle_schedule_conversation(chat_id, text)
-
     else:
         with lock:
             session['current_step'] = None
@@ -2274,45 +1981,17 @@ async def shutdown_event():
 async def telegram_webhook_endpoint(request: Request):
     try:
         update = await request.json()
-
-        # Identify chat_id early to drain any pending real-time status edit
-        chat_id = None
-        try:
-            if "message" in update:
-                chat_id = update["message"]["chat"]["id"]
-            elif "callback_query" in update:
-                chat_id = update["callback_query"]["message"]["chat"]["id"]
-        except Exception:
-            pass
-
         response_data = await handle_telegram_update(update)
 
-        # Collect the primary response
-        primary = None
         if isinstance(response_data, list):
-            items = [i for i in response_data if i and isinstance(i, dict) and i.get("method")]
-            for priority in ("sendMessage", "editMessageText"):
-                for item in items:
-                    if item.get("method") == priority:
-                        primary = item
-                        break
-                if primary:
-                    break
-            if not primary:
-                for item in items:
-                    if item.get("method") == "answerCallbackQuery":
-                        primary = item
-                        break
-        elif isinstance(response_data, dict):
-            primary = response_data
+            for item in response_data:
+                if item and isinstance(item, dict) and item.get("method") in (
+                    "sendMessage", "editMessageText", "answerCallbackQuery"
+                ):
+                    return item
+            return response_data[0] if response_data else {"status": "ok"}
 
-        # Piggyback a pending real-time status edit if we have no real response
-        if chat_id:
-            pending_edit = pop_pending_status_edit(chat_id)
-            if pending_edit and (primary is None or primary.get("method") == "answerCallbackQuery"):
-                primary = pending_edit
-
-        return primary or {"status": "ok"}
+        return response_data
 
     except json.JSONDecodeError:
         raise HTTPException(status_code=400, detail="Invalid JSON")
@@ -2341,30 +2020,6 @@ async def health():
     }
 
 
-@app.get("/status/{chat_id}")
-async def get_status_endpoint(chat_id: int):
-    """HTTP polling — returns current stream state as JSON for external dashboards."""
-    if chat_id not in user_sessions:
-        raise HTTPException(status_code=404, detail="No session for this chat_id")
-    session = get_user_session(chat_id)
-    uptime = 0
-    if session.get("stream_start_time"):
-        try:
-            uptime = int((datetime.datetime.now(datetime.timezone.utc) - session["stream_start_time"]).total_seconds())
-        except Exception:
-            pass
-    return {
-        "chat_id": chat_id,
-        "state": session.get("streaming_state", "idle"),
-        "frames_encoded": session.get("frames_encoded", 0),
-        "bytes_sent": session.get("bytes_sent", 0),
-        "uptime_seconds": uptime,
-        "reconnect_attempt": session.get("reconnect_attempt", 0),
-        "error": session.get("error_notification_user", ""),
-        "status_text": compose_status_message(chat_id, include_config=False),
-    }
-
-
 # ──────────────────────────────────────────────
 # MAIN
 # ──────────────────────────────────────────────