Update app.py

app.py

@@ -179,32 +179,40 @@ def format_settings_for_display(session: dict) -> str:
     if session.get('logo_enabled') and session.get('logo_data_bytes'):
         logo_status = f"Enabled ({session.get('logo_original_filename', 'Unknown name')})"
 
+    loop_count = session.get('loop_count', 0)
+    loop_display = "∞ Infinite" if loop_count == -1 else ("Once" if loop_count == 0 else f"{loop_count}x")
+
     display_data = {
         "Output URL": session.get('output_url'),
-        "Quality": session.get('quality_settings'),
-        "Video Codec": session.get('video_codec'),
-        "Audio Codec": session.get('audio_codec'),
-        "Resolution": session.get('resolution'),
-        "FPS": session.get('fps'),
-        "Video Bitrate": session.get('video_bitrate'),
-        "Audio Bitrate": session.get('audio_bitrate'),
-        "FFmpeg Preset": session.get('ffmpeg_preset'),
-        "Loop Count": "Infinite" if session.get('loop_count') == -1 else session.get('loop_count'),
-        "Playlist Length": len(session.get('input_url_playlist', [])),
+        "Quality": session.get('quality_settings', '-'),
+        "Video Codec": session.get('video_codec', '-'),
+        "Audio Codec": session.get('audio_codec', '-'),
+        "Resolution": session.get('resolution', '-'),
+        "FPS": session.get('fps', '-'),
+        "Video Bitrate": session.get('video_bitrate', '-'),
+        "Audio Bitrate": session.get('audio_bitrate', '-'),
+        "FFmpeg Preset": session.get('ffmpeg_preset', '-'),
+        "Loop": loop_display,
+        "Playlist Items": len(session.get('input_url_playlist', [])),
         "Logo": logo_status,
     }
     if session.get('logo_enabled') and session.get('logo_data_bytes'):
-        display_data["Logo Position"] = session.get('logo_position')
-        display_data["Logo Scale"] = session.get('logo_scale')
-        display_data["Logo Opacity"] = session.get('logo_opacity')
-    
-    return "\n".join([f"• *{k}*: `{v}`" for k, v in display_data.items() if v is not None])
+        display_data["Logo Position"] = session.get('logo_position', '-')
+        display_data["Logo Scale"] = session.get('logo_scale', '-')
+        display_data["Logo Opacity"] = session.get('logo_opacity', '-')
+
+    lines = []
+    for k, v in display_data.items():
+        if v is not None:
+            safe_v = str(v).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            lines.append(f"  \u2022 <b>{k}</b>: <code>{safe_v}</code>")
+    return "\n".join(lines)
 
 
 # --- UI Helpers (send_message, edit_message_text, answer_callback_query, get_main_keyboard, get_uptime, compose_status_message) ---
 # These functions remain largely the same as they don't interact with disk.
 # Minor change in compose_status_message for logo display from bytes.
-def send_message(chat_id: int, text: str, parse_mode="Markdown", reply_markup=None):
+def send_message(chat_id: int, text: str, parse_mode="HTML", reply_markup=None):
     logger.info(f"[Chat {chat_id}] Sending message: {text[:100]}...")
     response = {
         "method": "sendMessage",
@@ -216,7 +224,7 @@ def send_message(chat_id: int, text: str, parse_mode="Markdown", reply_markup=No
         response["reply_markup"] = reply_markup
     return response
 
-def edit_message_text(chat_id: int, message_id: int, text: str, parse_mode="Markdown", reply_markup=None):
+def edit_message_text(chat_id: int, message_id: int, text: str, parse_mode="HTML", reply_markup=None):
     logger.info(f"[Chat {chat_id}] Editing message {message_id}: {text[:100]}...")
     response = {
         "method": "editMessageText",
@@ -282,40 +290,52 @@ def get_uptime(start_time_obj):
 def compose_status_message(chat_id: int, include_config: bool = False) -> str:
     session = get_user_session(chat_id)
     state = session['streaming_state']
-    
-    status_lines = [
-        f"🤖 *Stream Bot Status for Chat ID {chat_id} (In-Memory Mode)*",
-        f"_Settings, logos, and schedules are NOT persistent across bot restarts._",
-        f"State: `{state}`",
+
+    STATE_EMOJI = {
+        "idle": "💤", "starting": "🔄", "streaming": "🔴",
+        "paused": "⏸", "stopping": "🛑", "stopped": "⏹",
+        "completed": "✅", "error": "❌",
+    }
+    state_icon = STATE_EMOJI.get(state, "❓")
+
+    lines = [
+        f"🤖 <b>Stream Bot</b> — Chat <code>{chat_id}</code>",
+        f"<i>⚠️ Settings are in-memory only — lost on restart.</i>",
+        f"",
+        f"{state_icon} <b>State:</b> <code>{state}</code>",
     ]
+
     if session.get('error_notification_user'):
-        status_lines.append(f"⚠️ Error: `{session['error_notification_user']}`")
+        safe_err = str(session['error_notification_user']).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        lines.append(f"⚠️ <b>Last Error:</b> <code>{safe_err}</code>")
 
     if state in ["streaming", "paused", "starting", "stopping"]:
-        current_input_url_display = "N/A"
         playlist = session.get('input_url_playlist', [])
         playlist_idx = session.get('current_playlist_index', 0)
-        if playlist and 0 <= playlist_idx < len(playlist):
-            current_input_url_display = playlist[playlist_idx]
-
-        status_lines.extend([
-            f"Uptime: `{get_uptime(session['stream_start_time'])}`",
-            f"Frames Encoded: `{session['frames_encoded']}`",
-            f"Bytes Sent: `{session['bytes_sent'] / (1024*1024):.2f} MB`",
-            f"Current Input: `{current_input_url_display}` (Item {playlist_idx+1}/{len(playlist)})",
-            f"Loop Iteration: {session.get('current_loop_iteration',0)+1}/{'Infinite' if session.get('loop_count',0) == -1 else session.get('loop_count',0) or 1}"
-        ])
-    
+        current_input_url_display = playlist[playlist_idx] if playlist and 0 <= playlist_idx < len(playlist) else "N/A"
+        safe_url = current_input_url_display.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        loop_count = session.get('loop_count', 0)
+        loop_total = "&#8734;" if loop_count == -1 else str(max(loop_count, 1))
+
+        lines += [
+            f"",
+            f"⏱ <b>Uptime:</b> <code>{get_uptime(session['stream_start_time'])}</code>",
+            f"🎞 <b>Frames:</b> <code>{session['frames_encoded']:,}</code>",
+            f"📤 <b>Sent:</b> <code>{session['bytes_sent'] / (1024*1024):.2f} MB</code>",
+            f"🎬 <b>Input:</b> <code>{safe_url}</code> ({playlist_idx+1}/{len(playlist)})",
+            f"🔁 <b>Loop:</b> <code>{session.get('current_loop_iteration', 0)+1}/{loop_total}</code>",
+        ]
+
     if include_config or state not in ["streaming", "paused"]:
-        status_lines.append("\n📝 *Current Configuration:*")
-        status_lines.append(format_settings_for_display(session))
+        lines += ["", "📝 <b>Current Configuration:</b>", format_settings_for_display(session)]
 
     if state in ["streaming", "paused", "starting"]:
-        status_lines.append("\n📋 *User Live Logs (last 10):*")
-        user_logs_preview = "\n".join(session['live_log_lines_user'][-10:])
-        status_lines.append(f"<pre>{user_logs_preview if user_logs_preview else 'No user logs yet.'}</pre>")
-        
-    return "\n".join(status_lines)
+        user_logs = session.get('live_log_lines_user', [])
+        last_logs = "\n".join(user_logs[-8:]) if user_logs else "No logs yet."
+        safe_logs = last_logs.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        lines += ["", "📋 <b>Recent Logs:</b>", f"<pre>{safe_logs}</pre>"]
+
+    return "\n".join(lines)
 
 
 # --- Core Streaming Logic ---
@@ -691,6 +711,14 @@ def stream_engine_thread_target(chat_id: int):
 # get_help_text needs to be updated about non-persistence.
 
 async def handle_telegram_update(update: dict):
+    try:
+        return await _handle_telegram_update_inner(update)
+    except Exception as e:
+        logger.error(f"Unhandled exception in handle_telegram_update: {e}", exc_info=True)
+        return {"status": "ok", "message": "Internal error — please try again."}
+
+
+async def _handle_telegram_update_inner(update: dict):
     if "message" in update:
         message = update["message"]
         chat_id = message["chat"]["id"]
@@ -703,38 +731,46 @@ async def handle_telegram_update(update: dict):
         
         if message.get("photo") or message.get("document"):
             if session.get("current_step") == "awaiting_logo_upload":
-                # Need to pass the actual UploadFile if using FastAPI's file handling for webhook
-                # For direct JSON, we'd get file_id and need a bot instance to download.
-                # Assuming direct JSON from Telegram with file_id:
                 return await handle_logo_data_from_telegram(chat_id, message)
             else:
-                return send_message(chat_id, "Received a file, but I wasn't expecting one. Use /set_logo first if you want to upload a logo.")
+                return send_message(chat_id, "📎 Got a file, but I wasn't expecting one.\nUse /set_logo first if you want to upload a logo.", reply_markup=get_main_keyboard(session))
 
         if command:
             logger.info(f"[Chat {chat_id} ({user_name})] Received command: {text}")
-            if command == "/start" or command == "/menu":
-                with lock: session['current_step'] = None 
-                return send_message(chat_id, compose_status_message(chat_id, include_config=True), reply_markup=get_main_keyboard(session), parse_mode="HTML")
+            if command in ("/start", "/menu"):
+                with lock: session['current_step'] = None
+                return send_message(chat_id, compose_status_message(chat_id, include_config=True), reply_markup=get_main_keyboard(session))
             elif command == "/help":
-                return send_message(chat_id, get_help_text(), parse_mode="Markdown")
+                return send_message(chat_id, get_help_text(), reply_markup=get_main_keyboard(session))
             elif command == "/settings":
-                return start_settings_conversation(chat_id, advanced=True)
+                resp = start_settings_conversation(chat_id, advanced=True)
+                return send_message(chat_id, resp['text'], reply_markup=resp.get('reply_markup') or get_main_keyboard(session))
             elif command == "/stream":
-                 return await start_stream_command_handler(chat_id)
+                return await start_stream_command_handler(chat_id)
             elif command == "/playlist":
                 return await handle_playlist_command(chat_id, text)
             elif command == "/set_logo":
-                 with lock: session["current_step"] = "awaiting_logo_upload"
-                 return send_message(chat_id, "Please upload your logo image (PNG or JPG). Max 1MB recommended due to in-memory storage.")
+                with lock: session["current_step"] = "awaiting_logo_upload"
+                return send_message(chat_id, "🖼 Please upload your logo image (PNG or JPG).\n<i>Max 1 MB recommended due to in-memory storage.</i>", reply_markup=get_main_keyboard(session))
             elif command == "/schedule":
                 return await handle_schedule_command(chat_id, text)
             elif command == "/status":
-                 return send_message(chat_id, compose_status_message(chat_id, include_config=True), reply_markup=get_main_keyboard(session), parse_mode="HTML")
+                return send_message(chat_id, compose_status_message(chat_id, include_config=True), reply_markup=get_main_keyboard(session))
             elif command == "/abort":
-                return await stream_abort_handler(chat_id) 
-            else: 
-                return await handle_conversation_step(chat_id, text)
-        else: 
+                return await stream_abort_handler(chat_id)
+            elif command == "/cancel":
+                # /cancel works both inside and outside a conversation
+                return await handle_conversation_step(chat_id, "/cancel")
+            else:
+                # Unknown slash command — if in a conversation pass it through, else show hint
+                if session.get('current_step'):
+                    return await handle_conversation_step(chat_id, text)
+                return send_message(
+                    chat_id,
+                    f"❓ Unknown command <code>{text.split()[0]}</code>.\nTap <b>❔ Help</b> below or use /help for a list of commands.",
+                    reply_markup=get_main_keyboard(session)
+                )
+        else:
             return await handle_conversation_step(chat_id, text)
 
     elif "callback_query" in update:
@@ -752,25 +788,25 @@ async def handle_telegram_update(update: dict):
         
         if data == "cfg_start":
             if not session.get('input_url_playlist') or not session.get('output_url'):
-                # This is tricky as start_settings_conversation returns a message dict, not just text.
                 settings_response = start_settings_conversation(chat_id, advanced=session.get('advanced_mode', False))
-                response_text = "Playlist or Output URL is not set. Let's configure.\n" + settings_response['text']
-                # If settings_response has its own reply_markup, it might conflict.
-                # For simplicity, let's assume start_settings_conversation is primarily text.
+                response_text = "⚙️ <b>Playlist or Output URL not set.</b> Let's configure:\n\n" + settings_response['text']
                 return [ack, send_message(chat_id, response_text, reply_markup=settings_response.get('reply_markup') or get_main_keyboard(session))]
-
             else:
                 return [ack, await start_stream_command_handler(chat_id, message_id_to_edit=message_id)]
+
         elif data == "cfg_advanced":
             settings_response = start_settings_conversation(chat_id, advanced=True)
-            return [ack, edit_message_text(chat_id, message_id, settings_response['text'] + "\n\n" + compose_status_message(chat_id, include_config=True), reply_markup=settings_response.get('reply_markup') or get_main_keyboard(session), parse_mode="HTML")]
+            return [ack, edit_message_text(chat_id, message_id,
+                settings_response['text'] + "\n\n" + compose_status_message(chat_id, include_config=True),
+                reply_markup=settings_response.get('reply_markup') or get_main_keyboard(session))]
+
         elif data == "cfg_playlist":
             return [ack, await handle_playlist_config_interaction(chat_id, message_id)]
         elif data == "cfg_logo":
             return [ack, await handle_logo_config_interaction(chat_id, message_id)]
         elif data == "cfg_schedule":
             return [ack, await handle_schedule_config_interaction(chat_id, message_id)]
-        
+
         elif data == "stream_pause":
             return [ack, await stream_pause_handler(chat_id, message_id)]
         elif data == "stream_resume":
@@ -778,30 +814,46 @@ async def handle_telegram_update(update: dict):
         elif data == "stream_abort":
             return [ack, await stream_abort_handler(chat_id, message_id_to_edit=message_id)]
         elif data == "stream_status":
-            return [ack, edit_message_text(chat_id, message_id, compose_status_message(chat_id, include_config=False), reply_markup=get_main_keyboard(session), parse_mode="HTML")]
+            return [ack, edit_message_text(chat_id, message_id,
+                compose_status_message(chat_id, include_config=False),
+                reply_markup=get_main_keyboard(session))]
         elif data == "stream_stop_loop_graceful":
             with lock: session['stop_gracefully_flag'] = True
             append_user_live_log(chat_id, "Graceful loop stop requested.")
-            return [ack, edit_message_text(chat_id, message_id, "Graceful loop stop initiated. Current iteration will complete.\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session), parse_mode="HTML")]
+            return [ack, edit_message_text(chat_id, message_id,
+                "⏳ <b>Graceful stop initiated.</b> Current iteration will finish before stopping.\n\n" + compose_status_message(chat_id),
+                reply_markup=get_main_keyboard(session))]
 
         elif data == "show_global_logs":
-            global_logs_text = "📜 *Global Bot Logs (last 20):*\n<pre>" + "\n".join(live_log_lines_global[-20:]) + "</pre>"
-            return [ack, edit_message_text(chat_id, message_id, global_logs_text + "\n\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session), parse_mode="HTML")]
+            safe_logs = "\n".join(live_log_lines_global[-20:]).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            global_logs_text = "📜 <b>Global Bot Logs (last 20):</b>\n<pre>" + (safe_logs or "No logs yet.") + "</pre>"
+            return [ack, edit_message_text(chat_id, message_id,
+                global_logs_text + "\n\n" + compose_status_message(chat_id),
+                reply_markup=get_main_keyboard(session))]
+
         elif data == "show_help":
-            return [ack, edit_message_text(chat_id, message_id, get_help_text() + "\n\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session))]
-        
+            return [ack, edit_message_text(chat_id, message_id,
+                get_help_text() + "\n\n" + compose_status_message(chat_id),
+                reply_markup=get_main_keyboard(session))]
+
         elif data.startswith("set_quality_"):
-            quality = data.split("_")[-1]
-            with lock:
-                session["quality_settings"] = quality
-                if quality in QUALITY_SETTINGS_MAP and quality != "custom":
-                    for key, val in QUALITY_SETTINGS_MAP[quality].items():
-                        session[key] = val
-                session["current_step"] = None 
-            # save_user_settings_to_file(chat_id) # REMOVED
-            return [ack, edit_message_text(chat_id, message_id, f"Quality set to `{quality}`.\n" + compose_status_message(chat_id, True), reply_markup=get_main_keyboard(session), parse_mode="HTML")]
-        
-        return [ack, send_message(chat_id, "Unknown action.")]
+            quality = data.split("_", 2)[-1]
+            if quality in QUALITY_SETTINGS_MAP or quality == "custom":
+                with lock:
+                    session["quality_settings"] = quality
+                    if quality in QUALITY_SETTINGS_MAP and quality != "custom":
+                        for key, val in QUALITY_SETTINGS_MAP[quality].items():
+                            session[key] = val
+                    session["current_step"] = None
+                return [ack, edit_message_text(chat_id, message_id,
+                    f"✅ <b>Quality set to</b> <code>{quality}</code>.\n\n" + compose_status_message(chat_id, True),
+                    reply_markup=get_main_keyboard(session))]
+            else:
+                return [ack, answer_callback_query(cb_query["id"], text=f"Unknown quality: {quality}", show_alert=True)]
+
+        return [ack, send_message(chat_id,
+            "❓ <b>Unknown action.</b> Please use the menu buttons below.",
+            reply_markup=get_main_keyboard(session))]
 
     return {"status": "ok", "message": "Update type not handled"}
 
@@ -832,15 +884,12 @@ def start_settings_conversation(chat_id: int, advanced: bool):
         session['conversation_fields_list'] = CONVERSATION_STEPS_ADVANCED if advanced else CONVERSATION_STEPS_SIMPLE
         session['current_step_index'] = 0
         session['current_step'] = session['conversation_fields_list'][0][0]
-    
+
     first_field_key, first_prompt, _ = session['conversation_fields_list'][0]
-    
-    # Prepare initial message (send_message or part of edit_message_text)
-    initial_message_content = {}
-    
+
     if first_field_key == "quality_settings_prompt":
-        initial_message_content = {
-            "text": first_prompt,
+        return {
+            "text": f"<b>{first_prompt}</b>",
             "reply_markup": {
                 "inline_keyboard": [
                     [{"text": q.title(), "callback_data": f"set_quality_{q}"} for q in ["low", "medium", "high", "custom"]]
@@ -848,11 +897,11 @@ def start_settings_conversation(chat_id: int, advanced: bool):
             }
         }
     else:
-        current_value_msg = f"(Current: `{session.get(first_field_key, 'Not set')}`)" if session.get(first_field_key) else ""
-        initial_message_content = {"text": f"{first_prompt}\n{current_value_msg}\n\nType /cancel to abort setup."}
-
-    # This function is now called from callbacks too, so it needs to return a dict that can be used by send_message or edit_message_text
-    return initial_message_content
+        current_val = session.get(first_field_key)
+        current_value_msg = f"\nCurrent: <code>{str(current_val).replace('&','&amp;').replace('<','&lt;').replace('>','&gt;')}</code>" if current_val else ""
+        return {
+            "text": f"<b>{first_prompt}</b>{current_value_msg}\n\nType <code>/cancel</code> to abort setup."
+        }
 
 
 async def handle_conversation_step(chat_id: int, user_text: str):
@@ -862,100 +911,114 @@ async def handle_conversation_step(chat_id: int, user_text: str):
     current_step_key_local = None
     validator_local = None
     current_step_index_local = -1
+    no_setup = False
+    cancelled = False
+    invalid_index = False
 
     with lock:
         if not session.get('current_step') or not session.get('conversation_fields_list'):
-            return send_message(chat_id, "No setup in progress. Use /start or a menu button.", reply_markup=get_main_keyboard(session))
-
-        if user_text.lower() == "/cancel":
+            no_setup = True
+        elif user_text.strip().lower() == "/cancel":
             session['current_step'] = None
-            session['current_step_index'] = 0 # Reset index
+            session['current_step_index'] = 0
             cancelled = True
-        else:
-            cancelled = False
-
-        # Ensure current_step_index is valid
-        if not cancelled and not (0 <= session.get('current_step_index', -1) < len(session['conversation_fields_list'])):
-            session['current_step'] = None # Invalid state, reset
+        elif not (0 <= session.get('current_step_index', -1) < len(session['conversation_fields_list'])):
+            session['current_step'] = None
             session['current_step_index'] = 0
             logger.warning(f"[Chat {chat_id}] Invalid current_step_index, resetting conversation.")
             invalid_index = True
         else:
-            invalid_index = False
-
-        if not cancelled and not invalid_index:
             current_step_index_local = session['current_step_index']
             current_step_key_local, _, validator_local = session['conversation_fields_list'][current_step_index_local]
-        
-    # Handle early exits outside the lock
+
+    # All responses happen outside the lock to prevent deadlocks
+    if no_setup:
+        return send_message(
+            chat_id,
+            "💬 No setup in progress. Use /start or tap a menu button to begin.",
+            reply_markup=get_main_keyboard(session)
+        )
     if cancelled:
-        return send_message(chat_id, "Setup cancelled.", reply_markup=get_main_keyboard(session))
+        return send_message(chat_id, "✅ <b>Setup cancelled.</b> Your previous settings are unchanged.", reply_markup=get_main_keyboard(session))
     if invalid_index:
-        return send_message(chat_id, "Conversation state error, setup reset. Please start again.", reply_markup=get_main_keyboard(session))
+        return send_message(chat_id, "⚠️ <b>Conversation state error — setup reset.</b>\nPlease start again.", reply_markup=get_main_keyboard(session))
+
     user_input = user_text.strip()
 
     if validator_local and not validator_local(user_input):
-        # Re-fetch prompt as it might have been clobbered if lock wasn't held long enough (should be fine here)
-        _, prompt, _ = session['conversation_fields_list'][current_step_index_local] # Use local index; tuple is (key, prompt, validator)
-        return send_message(chat_id, f"Invalid input for {current_step_key_local.replace('_',' ').title()}. Please try again.\n{prompt}")
+        _, prompt, _ = session['conversation_fields_list'][current_step_index_local]
+        field_label = current_step_key_local.replace('_', ' ').title()
+        return send_message(
+            chat_id,
+            f"❌ <b>Invalid input for {field_label}.</b>\nPlease try again.\n\n<i>{prompt}</i>\n\nType <code>/cancel</code> to abort setup."
+        )
+
+    next_step_key = None
+    next_prompt = None
+    next_step_is_quality = False
+    current_value_msg = ""
+    step_mismatch = False
+    log_line = None
 
     with lock:
-        # Re-verify current_step_key just in case, though primary logic relies on index
         if current_step_key_local != session['conversation_fields_list'][session['current_step_index']][0]:
             logger.error(f"[Chat {chat_id}] Conversation step mismatch! Aborting step.")
-            # Build response outside lock below
             step_mismatch = True
         else:
-            step_mismatch = False
-
-        if not step_mismatch:
             if current_step_key_local == "input_url_playlist":
                 session["input_url_playlist"] = [user_input] if user_input else []
             elif current_step_key_local == "quality_settings_prompt":
                 quality_input = user_input.lower()
-                if quality_input in QUALITY_SETTINGS_MAP.keys() or quality_input == "custom":
+                if quality_input in QUALITY_SETTINGS_MAP or quality_input == "custom":
                     session["quality_settings"] = quality_input
                     if quality_input in QUALITY_SETTINGS_MAP and quality_input != "custom":
-                        for key, val in QUALITY_SETTINGS_MAP[quality_input].items(): session[key] = val
-                    append_user_live_log(chat_id, f"Quality set to {quality_input} via text.")
+                        for key, val in QUALITY_SETTINGS_MAP[quality_input].items():
+                            session[key] = val
+                    log_line = f"Quality set to {quality_input}"
                 else:
-                    logger.warning(f"[Chat {chat_id}] Invalid quality input '{quality_input}' in conversation step. Not applied.")
-            elif current_step_key_local == "loop_count" or current_step_key_local == "fps":
+                    logger.warning(f"[Chat {chat_id}] Invalid quality input '{quality_input}'. Not applied.")
+            elif current_step_key_local in ("loop_count", "fps"):
                 session[current_step_key_local] = int(user_input)
+                log_line = f"Set {current_step_key_local} = {user_input}"
             else:
                 session[current_step_key_local] = user_input
-            
-            append_user_live_log(chat_id, f"Set {current_step_key_local} = {user_input}")
+                log_line = f"Set {current_step_key_local} = {user_input}"
 
             session['current_step_index'] += 1
             if session['current_step_index'] < len(session['conversation_fields_list']):
                 next_step_key, next_prompt, _ = session['conversation_fields_list'][session['current_step_index']]
                 session['current_step'] = next_step_key
                 next_step_is_quality = (next_step_key == "quality_settings_prompt")
-                current_value_msg = f"(Current: `{session.get(next_step_key, 'Not set')}`)" if session.get(next_step_key) else ""
+                current_value_msg = f"(Current: <code>{session.get(next_step_key, 'Not set')}</code>)" if session.get(next_step_key) else ""
             else:
-                next_step_key = None
-                next_prompt = None
-                next_step_is_quality = False
-                current_value_msg = ""
                 session['current_step'] = None
                 session['current_step_index'] = 0
                 logger.info(f"[Chat {chat_id}] In-memory settings configured.")
 
-    # All returns happen outside the lock to avoid holding it during send_message calls
+    # Log outside the lock to avoid deadlock (append_user_live_log acquires same lock)
+    if log_line:
+        append_user_live_log(chat_id, log_line)
+
     if step_mismatch:
-        return send_message(chat_id, "A state error occurred. Please try /cancel and restart setup.", reply_markup=get_main_keyboard(session))
+        return send_message(chat_id, "⚠️ <b>State error during setup.</b>\nType <code>/cancel</code> and restart.", reply_markup=get_main_keyboard(session))
 
     if next_step_key is not None:
         if next_step_is_quality:
-            return send_message(chat_id, next_prompt, reply_markup={
+            return send_message(chat_id, f"<b>{next_prompt}</b>", reply_markup={
                 "inline_keyboard": [
                     [{"text": q.title(), "callback_data": f"set_quality_{q}"} for q in ["low", "medium", "high", "custom"]]
-                ]})
-        return send_message(chat_id, f"{next_prompt}\n{current_value_msg}\n\nType /cancel to abort setup.")
+                ]
+            })
+        return send_message(
+            chat_id,
+            f"<b>{next_prompt}</b>\n{current_value_msg}\n\nType <code>/cancel</code> to abort setup."
+        )
     else:
-        # save_user_settings_to_file(chat_id) # REMOVED
-        return send_message(chat_id, "All settings configured (in memory for this session)!\n" + compose_status_message(chat_id, True), reply_markup=get_main_keyboard(session), parse_mode="HTML")
+        return send_message(
+            chat_id,
+            "✅ <b>All settings saved</b> (in-memory for this session)!\n\n" + compose_status_message(chat_id, True),
+            reply_markup=get_main_keyboard(session)
+        )
 
 
 async def handle_playlist_command(chat_id: int, text: str):
@@ -964,48 +1027,78 @@ async def handle_playlist_command(chat_id: int, text: str):
     parts = text.split(maxsplit=2)
     action = parts[1].lower() if len(parts) > 1 else "show"
     msg = ""
-    
+
     with lock:
         playlist = session.get('input_url_playlist', [])
-        if action == "add" and len(parts) > 2:
-            url_to_add = parts[2]
-            if validate_url(url_to_add):
-                playlist.append(url_to_add)
-                # session['input_url_playlist'] = playlist # Modified in place
-                msg = f"Added to playlist. Total items: {len(playlist)}."
+        if action == "add":
+            if len(parts) > 2:
+                url_to_add = parts[2]
+                if validate_url(url_to_add):
+                    playlist.append(url_to_add)
+                    msg = f"✅ <b>Added to playlist.</b>\nTotal items: <code>{len(playlist)}</code>"
+                else:
+                    msg = f"❌ <b>Invalid URL format.</b>\nMust start with http/https/rtmp/rtsp/udp/srt/file.\n<code>{url_to_add}</code>"
+            else:
+                msg = "⚠️ Usage: <code>/playlist add &lt;url&gt;</code>"
+        elif action == "remove":
+            if len(parts) > 2:
+                idx_str = parts[2]
+                removed_item = None
+                if idx_str.lower() == "last" and playlist:
+                    removed_item = playlist.pop()
+                elif idx_str.isdigit():
+                    idx_to_remove = int(idx_str) - 1
+                    if 0 <= idx_to_remove < len(playlist):
+                        removed_item = playlist.pop(idx_to_remove)
+                safe_removed = removed_item[:60].replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;") if removed_item else None
+                if removed_item:
+                    msg = f"🗑 <b>Removed:</b> <code>{safe_removed}</code>\nTotal items remaining: <code>{len(playlist)}</code>"
+                else:
+                    msg = f"❌ <b>Invalid index or playlist is empty.</b>"
             else:
-                msg = "Invalid URL format."
-        elif action == "remove" and len(parts) > 2:
-            idx_str = parts[2]
-            removed_item = None
-            if idx_str.lower() == "last" and playlist: removed_item = playlist.pop()
-            elif idx_str.isdigit():
-                idx_to_remove = int(idx_str) -1 
-                if 0 <= idx_to_remove < len(playlist): removed_item = playlist.pop(idx_to_remove)
-            if removed_item: msg = f"Removed '{removed_item[:50]}...' from playlist. Total items: {len(playlist)}."
-            else: msg = "Invalid index or playlist empty."
+                msg = "⚠️ Usage: <code>/playlist remove &lt;index|last&gt;</code>"
         elif action == "clear":
+            count = len(playlist)
             session['input_url_playlist'] = []
-            msg = "Playlist cleared."
+            msg = f"🗑 <b>Playlist cleared.</b> Removed {count} item(s)."
         elif action == "show":
             if playlist:
-                plist_str = "\n".join([f"{i+1}. `{url}`" for i, url in enumerate(playlist)])
-                msg = f"*Current Playlist ({len(playlist)} items):*\n{plist_str}"
-            else: msg = "Playlist is empty."
-        else: msg = "Usage: /playlist [add <url>|remove <index|last>|clear|show]"
-    
-    # save_user_settings_to_file(chat_id) # REMOVED (for playlist changes)
+                safe_urls = "\n".join([
+                    f"  <code>{i+1}.</code> {url.replace('&','&amp;').replace('<','&lt;').replace('>','&gt;')}"
+                    for i, url in enumerate(playlist)
+                ])
+                msg = f"📜 <b>Playlist ({len(playlist)} items):</b>\n{safe_urls}"
+            else:
+                msg = "📜 <b>Playlist is empty.</b>\nAdd items with <code>/playlist add &lt;url&gt;</code>"
+        else:
+            msg = (
+                "⚠️ <b>Unknown playlist action.</b>\n"
+                "Usage:\n"
+                "  <code>/playlist add &lt;url&gt;</code>\n"
+                "  <code>/playlist remove &lt;index|last&gt;</code>\n"
+                "  <code>/playlist clear</code>\n"
+                "  <code>/playlist show</code>"
+            )
+
     return send_message(chat_id, msg, reply_markup=get_main_keyboard(session))
 
 async def handle_playlist_config_interaction(chat_id: int, message_id: int):
     session = get_user_session(chat_id)
     playlist = session.get('input_url_playlist', [])
-    msg = ""
     if playlist:
-        plist_str = "\n".join([f"{i+1}. `{url}`" for i, url in enumerate(playlist)])
-        msg = f"*Current Playlist ({len(playlist)} items):*\n{plist_str}\n\nUse `/playlist add <url>`, `/playlist remove <index>`, `/playlist clear`."
+        safe_urls = "\n".join([
+            f"  <code>{i+1}.</code> {url.replace('&','&amp;').replace('<','&lt;').replace('>','&gt;')}"
+            for i, url in enumerate(playlist)
+        ])
+        msg = (
+            f"📜 <b>Playlist ({len(playlist)} items):</b>\n{safe_urls}\n\n"
+            "Manage with:\n"
+            "  <code>/playlist add &lt;url&gt;</code>\n"
+            "  <code>/playlist remove &lt;index&gt;</code>\n"
+            "  <code>/playlist clear</code>"
+        )
     else:
-        msg = "Playlist is empty. Use `/playlist add <url>` to add your first stream input."
+        msg = "📜 <b>Playlist is empty.</b>\nAdd your first stream URL:\n<code>/playlist add &lt;url&gt;</code>"
     return edit_message_text(chat_id, message_id, msg + "\n\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session))
 
 
@@ -1051,27 +1144,47 @@ async def handle_logo_data_from_telegram(chat_id: int, message: dict):
         session['logo_enabled'] = True
         session['current_step'] = None
     
-    # save_user_settings_to_file(chat_id) # REMOVED
     append_user_live_log(chat_id, f"CONCEPTUAL: Logo data for '{dummy_filename}' stored in memory.")
-    return send_message(chat_id, f"Conceptual: Logo '{dummy_filename}' data stored in memory and enabled! (Actual file download/processing requires full bot capabilities beyond this webhook example.)\nLogo settings (position, etc.) are in Advanced Settings.", reply_markup=get_main_keyboard(session))
+    return send_message(
+        chat_id,
+        f"✅ <b>Logo received</b> (conceptual).\n"
+        f"File <code>{dummy_filename}</code> stored in memory and enabled.\n"
+        f"<i>Note: Actual file download requires full bot API capabilities beyond this webhook example.</i>\n\n"
+        f"Logo settings (position, scale, opacity) are in ⚙️ <b>Advanced Settings</b>.",
+        reply_markup=get_main_keyboard(session)
+    )
 
 async def handle_logo_config_interaction(chat_id: int, message_id: int):
     session = get_user_session(chat_id)
-    msg_parts = ["*Logo Configuration (In-Memory):*"]
+    lines = ["🖼 <b>Logo Configuration</b>"]
     if session.get('logo_data_bytes') and session.get('logo_enabled'):
-        msg_parts.append(f"Status: Enabled (`{session.get('logo_original_filename', 'N/A')}`)")
-        msg_parts.append(f"Position: `{session.get('logo_position')}` (Change in Advanced Settings)")
-        msg_parts.append(f"Scale: `{session.get('logo_scale')}` (Change in Advanced Settings)")
-        msg_parts.append(f"Opacity: `{session.get('logo_opacity')}` (Change in Advanced Settings)")
-        msg_parts.append("\nTo change logo, send /set_logo then upload a new image.")
-        msg_parts.append("To disable: `/configure_logo enabled false` (conceptual command).")
+        fname = session.get('logo_original_filename', 'N/A').replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        lines += [
+            f"  Status: ✅ <b>Enabled</b> — <code>{fname}</code>",
+            f"  Position: <code>{session.get('logo_position', '-')}</code>",
+            f"  Scale: <code>{session.get('logo_scale', '-')}</code>",
+            f"  Opacity: <code>{session.get('logo_opacity', '-')}</code>",
+            "",
+            "To replace: /set_logo then upload a new image.",
+            "To change position/scale/opacity: use ⚙️ Settings.",
+        ]
     elif session.get('logo_data_bytes') and not session.get('logo_enabled'):
-        msg_parts.append(f"Status: Disabled (`{session.get('logo_original_filename', 'N/A')}`)")
-        msg_parts.append("To enable: `/configure_logo enabled true` (conceptual command).")
+        fname = session.get('logo_original_filename', 'N/A').replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        lines += [
+            f"  Status: ⏸ <b>Disabled</b> — <code>{fname}</code>",
+            "To enable: update via ⚙️ Settings.",
+        ]
     else:
-        msg_parts.append("No logo uploaded/stored. Send /set_logo then upload an image.")
-    
-    return edit_message_text(chat_id, message_id, "\n".join(msg_parts) + "\n\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session))
+        lines += [
+            "  No logo uploaded.",
+            "Use /set_logo then upload a PNG or JPG image.",
+        ]
+
+    return edit_message_text(
+        chat_id, message_id,
+        "\n".join(lines) + "\n\n" + compose_status_message(chat_id),
+        reply_markup=get_main_keyboard(session)
+    )
 
 
 def schedule_stream_job(chat_id: int, trigger_time: datetime.datetime, job_name: str = None):
@@ -1115,7 +1228,13 @@ def start_stream_for_scheduler(chat_id: int):
 async def handle_schedule_command(chat_id: int, text: str):
     parts = text.split(maxsplit=3)
     if len(parts) < 3:
-        return send_message(chat_id, "Usage: `/schedule YYYY-MM-DD HH:MM:SS [Optional Job Name]`\nExample: `/schedule 2024-12-31 23:55:00 NYE`\nTimezone is UTC. Schedules are in-memory and lost on restart.")
+        return send_message(
+            chat_id,
+            "🕒 <b>Schedule a Stream</b>\n\n"
+            "Usage: <code>/schedule YYYY-MM-DD HH:MM:SS [Name]</code>\n"
+            "Example: <code>/schedule 2025-12-31 23:55:00 NYE Stream</code>\n\n"
+            "<i>Timezone: UTC. Schedules are in-memory and lost on restart.</i>"
+        )
 
     try:
         date_str, time_str = parts[1], parts[2]
@@ -1124,73 +1243,92 @@ async def handle_schedule_command(chat_id: int, text: str):
         trigger_time_utc = trigger_time_naive.replace(tzinfo=datetime.timezone.utc)
 
         if trigger_time_utc <= datetime.datetime.now(datetime.timezone.utc):
-            return send_message(chat_id, "Scheduled time must be in the future.")
+            return send_message(chat_id, "❌ <b>Scheduled time must be in the future.</b> Please use a future UTC date/time.")
 
         schedule_stream_job(chat_id, trigger_time_utc, job_name)
         session = get_user_session(chat_id)
-        return send_message(chat_id, f"Stream scheduled (in-memory) as '{job_name}' for {trigger_time_utc.strftime('%Y-%m-%d %H:%M:%S %Z')}. Current settings will be used.", reply_markup=get_main_keyboard(session))
+        safe_name = job_name.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        return send_message(
+            chat_id,
+            f"✅ <b>Stream scheduled!</b>\n"
+            f"  Name: <b>{safe_name}</b>\n"
+            f"  Time: <code>{trigger_time_utc.strftime('%Y-%m-%d %H:%M:%S UTC')}</code>\n\n"
+            f"<i>Current settings will be used when it fires. Schedule is in-memory only.</i>",
+            reply_markup=get_main_keyboard(session)
+        )
     except ValueError as e:
-        return send_message(chat_id, f"Invalid date/time format: {e}. Use YYYY-MM-DD HH:MM:SS.")
+        return send_message(
+            chat_id,
+            f"❌ <b>Invalid date/time format.</b>\n"
+            f"Error: <code>{str(e).replace('&','&amp;').replace('<','&lt;').replace('>','&gt;')}</code>\n\n"
+            f"Expected: <code>YYYY-MM-DD HH:MM:SS</code>"
+        )
 
 async def handle_schedule_config_interaction(chat_id: int, message_id: int):
     session = get_user_session(chat_id)
     jobs = scheduler.get_jobs()
     user_jobs = [job for job in jobs if job.id.startswith(f"stream_{chat_id}_")]
-    
-    msg_parts = ["*Scheduled Streams (In-Memory - Lost on Restart):*"]
+
+    lines = ["🕒 <b>Scheduled Streams</b>  <i>(in-memory — lost on restart)</i>"]
     if user_jobs:
         for job in user_jobs:
-            run_time_str = job.next_run_time.strftime('%Y-%m-%d %H:%M:%S %Z') if job.next_run_time else "N/A"
-            msg_parts.append(f"• `{job.name}` at `{run_time_str}` (ID: `{job.id}`)")
-            msg_parts.append(f"  To cancel: `/cancel_schedule {job.id}` (conceptual command).")
+            run_time_str = job.next_run_time.strftime('%Y-%m-%d %H:%M:%S UTC') if job.next_run_time else "N/A"
+            safe_name = str(job.name).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            safe_id = str(job.id).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            lines.append(f"  \u2022 <b>{safe_name}</b> at <code>{run_time_str}</code>")
+            lines.append(f"    ID: <code>{safe_id}</code>")
     else:
-        msg_parts.append("No streams currently scheduled.")
-    msg_parts.append("\nUse `/schedule YYYY-MM-DD HH:MM:SS [Name]` to schedule a new stream.")
-    
-    return edit_message_text(chat_id, message_id, "\n".join(msg_parts) + "\n\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session))
+        lines.append("  No streams currently scheduled.")
+
+    lines += [
+        "",
+        "To schedule: <code>/schedule YYYY-MM-DD HH:MM:SS [Name]</code>",
+    ]
+
+    return edit_message_text(
+        chat_id, message_id,
+        "\n".join(lines) + "\n\n" + compose_status_message(chat_id),
+        reply_markup=get_main_keyboard(session)
+    )
 
 
 async def start_stream_command_handler(chat_id: int, message_id_to_edit: int = None, is_scheduled: bool = False):
     session = get_user_session(chat_id)
     lock = session_locks[chat_id]
-    response = None
+
+    early_exit_msg = None
 
     with lock:
         if session['streaming_state'] in ["streaming", "paused", "starting"]:
-            msg = f"A stream is already active ({session['streaming_state']})."
-            if message_id_to_edit: response = edit_message_text(chat_id, message_id_to_edit, msg + "\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session), parse_mode="HTML")
-            else: response = send_message(chat_id, msg, reply_markup=get_main_keyboard(session))
-            return response
-
-        if not session.get('input_url_playlist') or not session.get('output_url'):
-            msg = "Input playlist or Output URL is not set. Please configure first using /settings or menu."
-            if message_id_to_edit: response = edit_message_text(chat_id, message_id_to_edit, msg + "\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session), parse_mode="HTML")
-            else: response = send_message(chat_id, msg, reply_markup=get_main_keyboard(session))
-            return response
-
-        session['streaming_state'] = "starting"
-        session['error_notification_user'] = ""
-        
-        # save_user_settings_to_file(chat_id) # REMOVED
+            early_exit_msg = f"⚠️ <b>Stream already active</b> (state: <code>{session['streaming_state']}</code>)."
+        elif not session.get('input_url_playlist') or not session.get('output_url'):
+            early_exit_msg = "⚙️ <b>Input playlist or Output URL not configured.</b>\nUse /settings or the menu to set them up first."
+        else:
+            session['streaming_state'] = "starting"
+            session['error_notification_user'] = ""
 
-        thread = threading.Thread(target=stream_engine_thread_target, args=(chat_id,), name=f"StreamThread-{chat_id}", daemon=True)
+    if early_exit_msg:
+        status_snippet = compose_status_message(chat_id)
+        if message_id_to_edit:
+            return edit_message_text(chat_id, message_id_to_edit, early_exit_msg + "\n\n" + status_snippet, reply_markup=get_main_keyboard(session))
+        return send_message(chat_id, early_exit_msg + "\n\n" + status_snippet, reply_markup=get_main_keyboard(session))
+
+    thread = threading.Thread(target=stream_engine_thread_target, args=(chat_id,), name=f"StreamThread-{chat_id}", daemon=True)
+    with lock:
         session['stream_thread_ref'] = thread
-        thread.start()
-        append_user_live_log(chat_id, "Stream thread initiated.")
-    
+    thread.start()
+    append_user_live_log(chat_id, "Stream thread initiated.")
+
     await asyncio.sleep(0.2)
 
     status_msg = compose_status_message(chat_id)
     if is_scheduled and not message_id_to_edit:
         logger.info(f"[Chat {chat_id}] Scheduled stream started. Status: {status_msg[:100]}")
-        # Conceptual proactive message:
-        # await send_proactive_message(chat_id, "Your scheduled stream is now starting!\n" + status_msg)
         return {"status": "scheduled_stream_started_silently_inmemory"}
     elif message_id_to_edit:
-        response = edit_message_text(chat_id, message_id_to_edit, "Stream starting...\n" + status_msg, reply_markup=get_main_keyboard(session), parse_mode="HTML")
+        return edit_message_text(chat_id, message_id_to_edit, "🔴 <b>Stream starting…</b>\n\n" + status_msg, reply_markup=get_main_keyboard(session))
     else:
-        response = send_message(chat_id, "Stream starting...\n" + status_msg, reply_markup=get_main_keyboard(session), parse_mode="HTML")
-    return response
+        return send_message(chat_id, "🔴 <b>Stream starting…</b>\n\n" + status_msg, reply_markup=get_main_keyboard(session))
 
 
 async def stream_pause_handler(chat_id: int, message_id: int):
@@ -1199,11 +1337,17 @@ async def stream_pause_handler(chat_id: int, message_id: int):
     with lock:
         if session['streaming_state'] == "streaming":
             session['streaming_state'] = "paused"
-            append_user_live_log(chat_id, "Stream paused by user.")
-            msg = "Stream paused."
+            paused_ok = True
         else:
-            msg = f"Stream is not streaming (state: {session['streaming_state']}). Cannot pause."
-    return edit_message_text(chat_id, message_id, msg + "\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session), parse_mode="HTML")
+            paused_ok = False
+            state_now = session['streaming_state']
+    if paused_ok:
+        append_user_live_log(chat_id, "Stream paused by user.")
+        msg = "⏸ <b>Stream paused.</b>"
+    else:
+        msg = f"ℹ️ Cannot pause — current state is <code>{state_now}</code>."
+    return edit_message_text(chat_id, message_id, msg + "\n\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session))
+
 
 async def stream_resume_handler(chat_id: int, message_id: int):
     session = get_user_session(chat_id)
@@ -1211,28 +1355,39 @@ async def stream_resume_handler(chat_id: int, message_id: int):
     with lock:
         if session['streaming_state'] == "paused":
             session['streaming_state'] = "streaming"
-            append_user_live_log(chat_id, "Stream resumed by user.")
-            msg = "Stream resumed."
+            resumed_ok = True
         else:
-            msg = f"Stream is not paused (state: {session['streaming_state']}). Cannot resume."
-    return edit_message_text(chat_id, message_id, msg + "\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session), parse_mode="HTML")
+            resumed_ok = False
+            state_now = session['streaming_state']
+    if resumed_ok:
+        append_user_live_log(chat_id, "Stream resumed by user.")
+        msg = "▶️ <b>Stream resumed.</b>"
+    else:
+        msg = f"ℹ️ Cannot resume — current state is <code>{state_now}</code>."
+    return edit_message_text(chat_id, message_id, msg + "\n\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session))
 
 async def stream_abort_handler(chat_id: int, message_id_to_edit: int = None):
     session = get_user_session(chat_id)
     lock = session_locks[chat_id]
     thread_to_join = None
-    msg = ""
-    
+    no_active_stream = False
+
     with lock:
         if session['streaming_state'] in ["streaming", "paused", "starting"]:
-            session['streaming_state'] = "stopping" 
+            session['streaming_state'] = "stopping"
             thread_to_join = session.get('stream_thread_ref')
-            append_user_live_log(chat_id, "Stream abort sequence initiated by user.")
-            msg = "Stream aborting..."
         else:
-            msg = f"No active stream to abort (state: {session['streaming_state']})."
-            if message_id_to_edit: return edit_message_text(chat_id, message_id_to_edit, msg + "\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session), parse_mode="HTML")
-            return send_message(chat_id, msg, reply_markup=get_main_keyboard(session))
+            no_active_stream = True
+
+    # Handle "nothing to abort" outside the lock
+    if no_active_stream:
+        state = session['streaming_state']
+        msg = f"ℹ️ <b>No active stream to abort.</b>\nCurrent state: <code>{state}</code>"
+        if message_id_to_edit:
+            return edit_message_text(chat_id, message_id_to_edit, msg + "\n\n" + compose_status_message(chat_id), reply_markup=get_main_keyboard(session))
+        return send_message(chat_id, msg, reply_markup=get_main_keyboard(session))
+
+    append_user_live_log(chat_id, "Stream abort sequence initiated by user.")
 
     if thread_to_join and thread_to_join.is_alive():
         logger.info(f"[Chat {chat_id}] Waiting for stream thread {thread_to_join.name} to join...")
@@ -1242,46 +1397,53 @@ async def stream_abort_handler(chat_id: int, message_id_to_edit: int = None):
             logger.warning(f"[Chat {chat_id}] Stream thread {thread_to_join.name} still alive after join timeout.")
         else:
             append_user_live_log(chat_id, "Stream thread terminated.")
-    
+
     with lock:
         if session['streaming_state'] == "stopping":
             session['streaming_state'] = "stopped"
         session['stream_thread_ref'] = None
 
-    final_status_msg = "Stream aborted.\n" + compose_status_message(chat_id)
+    final_msg = "⏹ <b>Stream aborted.</b>\n\n" + compose_status_message(chat_id)
     if message_id_to_edit:
-        return edit_message_text(chat_id, message_id_to_edit, final_status_msg, reply_markup=get_main_keyboard(session), parse_mode="HTML")
-    else:
-        return send_message(chat_id, final_status_msg, reply_markup=get_main_keyboard(session), parse_mode="HTML")
+        return edit_message_text(chat_id, message_id_to_edit, final_msg, reply_markup=get_main_keyboard(session))
+    return send_message(chat_id, final_msg, reply_markup=get_main_keyboard(session))
 
 
 def get_help_text():
     return (
-        f"*Advanced Stream Bot v{APP_VERSION} (In-Memory Edition) Help*\n\n"
-        "⚠️ *IMPORTANT: All settings, uploaded logos, and schedules are stored in memory "
-        "and will be LOST if the bot restarts due to environment restrictions.*\n\n"
-        "Use the interactive menu buttons or the following commands:\n"
-        "*/start* or */menu* - Show main menu and status.\n"
-        "*/settings* - Start advanced configuration.\n"
-        "*/stream* - Start stream with current settings.\n"
-        "*/playlist add <url>* - Add URL to playlist.\n"
-        "*/playlist remove <index|last>* - Remove URL from playlist.\n"
-        "*/playlist clear* - Clear entire playlist.\n"
-        "*/playlist show* - Display current playlist.\n"
-        "*/set_logo* - Prompts to upload a logo image (stored in memory).\n"
-        "   (Logo settings like position, scale are in Advanced Settings via menu)\n"
-        "*/schedule YYYY-MM-DD HH:MM:SS [Name]* - Schedule a stream (UTC time, in-memory).\n"
-        "   Example: `/schedule 2024-07-04 18:30:00 My Stream`\n"
-        "*/status* - Show detailed stream status and config.\n"
-        "*/abort* - Force stop the current stream.\n"
-        "\n*While Streaming (via menu buttons):*\n"
-        "• Pause/Resume Stream.\n"
-        "• Abort Stream.\n"
-        "• Status Update (refreshes message).\n"
-        "• Stop Loop Gracefully (for infinite loops, current iteration completes).\n"
-        "\n*Configuration Conversation:*\n"
-        "When in a setup process (e.g., after /settings), reply to prompts.\n"
-        "Type `/cancel` to exit setup anytime.\n"
+        f"<b>🤖 Advanced Stream Bot v{APP_VERSION}</b>\n"
+        f"<i>In-Memory Edition — all data lost on restart.</i>\n"
+        "\n"
+        "<b>⚠️ Important:</b> Settings, logos and schedules are stored only in RAM.\n"
+        "\n"
+        "<b>📋 Commands:</b>\n"
+        "  /start  or  /menu — Main menu &amp; status\n"
+        "  /settings — Open advanced configuration\n"
+        "  /stream — Start stream with current settings\n"
+        "  /status — Detailed stream status\n"
+        "  /abort — Force stop the current stream\n"
+        "\n"
+        "<b>🎬 Playlist:</b>\n"
+        "  /playlist add &lt;url&gt;\n"
+        "  /playlist remove &lt;index|last&gt;\n"
+        "  /playlist clear\n"
+        "  /playlist show\n"
+        "\n"
+        "<b>🖼 Logo:</b>\n"
+        "  /set_logo — Upload a logo image (PNG/JPG)\n"
+        "  Position, scale &amp; opacity via ⚙️ Settings menu\n"
+        "\n"
+        "<b>🕒 Schedule:</b>\n"
+        "  /schedule YYYY-MM-DD HH:MM:SS [Name]  (UTC)\n"
+        "  Example: <code>/schedule 2025-12-31 23:55:00 NYE</code>\n"
+        "\n"
+        "<b>▶️ While Streaming (menu buttons):</b>\n"
+        "  ⏸ Pause / ▶️ Resume / ⏹ Abort / 📊 Status\n"
+        "  ⏳ Stop Loop Gracefully (infinite loops only)\n"
+        "\n"
+        "<b>⚙️ Setup Conversations:</b>\n"
+        "  Reply to prompts during /settings flow.\n"
+        "  Type <code>/cancel</code> anytime to exit setup.\n"
     )
 
 # --- FastAPI Webhook Endpoint ---