feat: implement Grouped Media feature and refactor app.py

app.py

@@ -63,19 +63,14 @@ class LogCapturer:
         self.original_stdout = original_stdout
 
     def write(self, message):
-        # Always write to the real console
         self.original_stdout.write(message)
-        
-        # Buffer it for the UI (ignore empty/newline-only writes typically from print)
         if message and message.strip() != "":
-            # Prefix with a timestamp for the UI
             timestamp = datetime.now().strftime("%H:%M:%S")
             LOG_BUFFER.append(f"[{timestamp}] {message.rstrip()}")
 
     def flush(self):
         self.original_stdout.flush()
 
-# Replace stdout with our capturer
 sys.stdout = LogCapturer(sys.stdout)
 
 # ──────────────────────────────────────────────
@@ -83,16 +78,13 @@ sys.stdout = LogCapturer(sys.stdout)
 # ──────────────────────────────────────────────
 
 def get_db():
-    """Get a database connection."""
     conn = sqlite3.connect(str(DB_PATH), timeout=10)
     conn.row_factory = sqlite3.Row
     conn.execute("PRAGMA journal_mode=WAL")
     conn.execute("PRAGMA foreign_keys=ON")
     return conn
 
-
 def init_db():
-    """Initialize database tables."""
     conn = get_db()
     conn.executescript("""
         CREATE TABLE IF NOT EXISTS jobs (
@@ -143,16 +135,14 @@ def init_db():
         );
     """)
 
-    # Migration: Add title column to jobs if it doesn't exist
+    # Migration
     try:
         cursor = conn.execute("PRAGMA table_info(jobs)")
         columns = [row[1] for row in cursor.fetchall()]
         if "title" not in columns:
-            print("[STARTUP] Migrating database: Adding 'title' column to 'jobs' table...")
             conn.execute("ALTER TABLE jobs ADD COLUMN title TEXT")
             conn.commit()
-    except Exception as e:
-        print(f"[STARTUP] [WARN] Migration failed: {e}")
+    except: pass
 
     # Default settings
     defaults = {
@@ -160,9 +150,9 @@ def init_db():
         "check_interval_minutes": "30",
         "auto_publish": "true",
         "screening_enabled": "true",
-        "screening_criteria": "Ghana news, African entertainment, sports highlights, trending stories. Skip weather reports, stock market listings, and obituaries.",
+        "screening_criteria": "Ghana news, African entertainment, sports highlights, trending stories.",
         "review_feeds_enabled": "true",
-        "wp_url": os.getenv("WP_URL", "https://afripulsetv.com").rstrip("/"),
+        "wp_url": os.getenv("WP_URL", "").rstrip("/"),
         "wp_username": os.getenv("WP_USERNAME", ""),
         "wp_app_password": os.getenv("WP_APP_PASSWORD", ""),
         "wp_category_id": os.getenv("WP_CATEGORY_ID", "1"),
@@ -170,1125 +160,309 @@ def init_db():
         "openrouter_api_key": os.getenv("OPENROUTER_API_KEY", ""),
         "ig_username": os.getenv("IG_USERNAME", ""),
         "ig_password": os.getenv("IG_PASSWORD", ""),
-        "notify_email_enabled": "false",
-        "notify_email_to": "",
-        "notify_email_smtp_host": "smtp.gmail.com",
-        "notify_email_smtp_port": "587",
-        "notify_email_smtp_user": "",
-        "notify_email_smtp_password": "",
-        "notify_telegram_enabled": "false",
-        "notify_telegram_bot_token": "",
-        "notify_telegram_chat_id": "",
-        "notify_on_publish": "true",
-        "notify_on_fail": "true",
-        "llm_base_url": os.getenv("LLM_BASE_URL", "http://localhost:1234/v1"),
-        "llm_model": os.getenv("LLM_MODEL", "google/gemma-3-4b"),
+        "llm_base_url": os.getenv("LLM_BASE_URL", "https://openrouter.ai/api/v1"),
+        "llm_model": os.getenv("LLM_MODEL", "qwen/qwen3.6-plus:free"),
     }
     for key, value in defaults.items():
-        conn.execute(
-            "INSERT OR IGNORE INTO settings (key, value) VALUES (?, ?)",
-            (key, value)
-        )
-    conn.commit()
-
-    # Sync environment variables to DB settings (allows pushing from Render dashboard)
-    # We use lowercase keys for DB and uppercase for ENV
-    env_map = {
-        "notify_email_enabled": "NOTIFY_EMAIL_ENABLED",
-        "notify_email_to": "NOTIFY_EMAIL_TO",
-        "notify_email_smtp_host": "NOTIFY_EMAIL_SMTP_HOST",
-        "notify_email_smtp_port": "NOTIFY_EMAIL_SMTP_PORT",
-        "notify_email_smtp_user": "NOTIFY_EMAIL_SMTP_USER",
-        "notify_email_smtp_password": "NOTIFY_EMAIL_SMTP_PASSWORD",
-        "notify_telegram_enabled": "NOTIFY_TELEGRAM_ENABLED",
-        "notify_telegram_bot_token": "NOTIFY_TELEGRAM_BOT_TOKEN",
-        "notify_telegram_chat_id": "NOTIFY_TELEGRAM_CHAT_ID",
-        "notify_on_publish": "NOTIFY_ON_PUBLISH",
-        "notify_on_fail": "NOTIFY_ON_FAIL",
-    }
-    for db_key, env_key in env_map.items():
-        val = os.getenv(env_key)
-        if val is not None:
-            conn.execute(
-                "INSERT INTO settings (key, value) VALUES (?, ?) "
-                "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
-                (db_key, val)
-            )
-    
+        conn.execute("INSERT OR IGNORE INTO settings (key, value) VALUES (?, ?)", (key, value))
     conn.commit()
     conn.close()
 
-
-def get_setting(key: str, default: str = "") -> str:
+def get_setting(key, default=""):
     conn = get_db()
     row = conn.execute("SELECT value FROM settings WHERE key = ?", (key,)).fetchone()
     conn.close()
     return row["value"] if row else default
 
-
-def get_all_settings() -> dict:
+def get_all_settings():
     conn = get_db()
     rows = conn.execute("SELECT key, value FROM settings").fetchall()
     conn.close()
     return {r["key"]: r["value"] for r in rows}
 
-
-def set_setting(key: str, value: str):
+def set_setting(key, value):
     conn = get_db()
-    conn.execute(
-        "INSERT INTO settings (key, value) VALUES (?, ?) "
-        "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
-        (key, value)
-    )
+    conn.execute("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", (key, value))
     conn.commit()
     conn.close()
 
-
 # ──────────────────────────────────────────────
 # Pipeline Wrappers
 # ──────────────────────────────────────────────
 
 def _apply_settings_to_env():
-    """Push dashboard settings into environment for pipelines."""
     settings = get_all_settings()
-    os.environ["WP_URL"] = settings.get("wp_url", "")
-    os.environ["WP_USERNAME"] = settings.get("wp_username", "")
-    os.environ["WP_APP_PASSWORD"] = settings.get("wp_app_password", "")
-    os.environ["WP_CATEGORY_ID"] = settings.get("wp_category_id", "1")
-    os.environ["WP_POST_STATUS"] = settings.get("wp_post_status", "publish")
-    os.environ["GOOGLE_API_KEY"] = settings.get("google_api_key", "")
-    os.environ["IG_USERNAME"] = settings.get("ig_username", "")
-    os.environ["IG_PASSWORD"] = settings.get("ig_password", "")
-    os.environ["LLM_BASE_URL"] = settings.get("llm_base_url", "")
-    os.environ["LLM_MODEL"] = settings.get("llm_model", "")
-
-
-def run_article_pipeline(url: str) -> dict:
-    """Run the article rewriter pipeline."""
-    _apply_settings_to_env()
-    # Reimport to pick up new env vars
-    import importlib
-    import article_rewriter as ar
-    importlib.reload(ar)
-    return ar.process_article(url, dry_run=False)
-
-
-def run_social_video_pipeline(url: str) -> dict:
-    """Run the Social Media Video-to-WP pipeline."""
-    _apply_settings_to_env()
-    import importlib
-    import main as m
-    importlib.reload(m)
-    return m.process_video(url)
-
+    for k in ["wp_url", "wp_username", "wp_app_password", "wp_category_id", "wp_post_status", "ig_username", "ig_password", "llm_base_url", "llm_model"]:
+        os.environ[k.upper()] = settings.get(k, "")
 
-def run_upload_pipeline(video_path: str) -> dict:
-    """Run the uploaded video pipeline (skips download)."""
+def run_upload_pipeline(video_path):
     _apply_settings_to_env()
-    import importlib
     import main as m
-    importlib.reload(m)
     return m.process_uploaded_video(video_path)
 
-
-def run_image_upload_pipeline(image_path: str) -> dict:
-    """Run the uploaded image pipeline."""
+def run_image_upload_pipeline(image_path):
     _apply_settings_to_env()
-    import importlib
     import main as m
-    importlib.reload(m)
     return m.process_uploaded_image(image_path)
 
-
 # ──────────────────────────────────────────────
-# Job Processor (Background Thread)
+# Job Processor
 # ──────────────────────────────────────────────
 
 def process_pending_jobs():
-    """Process pending jobs concurrently using a thread pool."""
-    if STOP_PROCESSING.is_set():
-        return False  # Stop flag is active
-
+    if STOP_PROCESSING.is_set(): return False
     conn = get_db()
-    jobs = conn.execute(
-        "SELECT * FROM jobs WHERE status = 'pending' ORDER BY created_at ASC LIMIT 5"
-    ).fetchall()
+    jobs = conn.execute("SELECT * FROM jobs WHERE status = 'pending' ORDER BY created_at ASC LIMIT 5").fetchall()
     conn.close()
-
-    if not jobs:
-        return False
+    if not jobs: return False
 
     def process_one_job(job):
         job_id = job["id"]
         url = job["url"]
         mode = job["mode"]
-
-        # Mark as running
         conn = get_db()
-        conn.execute(
-            "UPDATE jobs SET status = 'running', started_at = datetime('now') WHERE id = ?",
-            (job_id,)
-        )
+        conn.execute("UPDATE jobs SET status = 'running', started_at = datetime('now') WHERE id = ?", (job_id,))
         conn.commit()
         conn.close()
 
         try:
-            # URL might be a JSON list (from multi-upload) or a single string
-            import json
             try:
                 url_data = json.loads(url)
-                # If it's a list, it's our multi-upload
-                # If it's something else, treat as raw string
-                if not isinstance(url_data, (list, dict)):
-                    url_data = url
-            except:
-                url_data = url
+                if not isinstance(url_data, (list, dict)): url_data = url
+            except: url_data = url
 
             print(f"[AGENT] Processing job #{job_id}: {mode}")
-
-            if job["mode"] == "article":
+            if mode == "article":
                 from article_rewriter import process_article
                 result = process_article(url_data)
-            elif job["mode"] in ["instagram", "social"]:
-                result = run_social_video_pipeline(url_data)
-            elif job["mode"] == "upload":  # Legacy fallback
-                result = run_upload_pipeline(url_data)
-            elif job["mode"] == "upload_video":
+            elif mode in ["instagram", "social"]:
+                from main import process_video
+                _apply_settings_to_env()
+                result = process_video(url_data)
+            elif mode in ["upload", "upload_video"]:
                 result = run_upload_pipeline(url_data)
-            elif job["mode"] == "upload_image":
+            elif mode == "upload_image":
                 result = run_image_upload_pipeline(url_data)
             else:
-                raise ValueError(f"Unknown mode: {job['mode']}")
+                raise ValueError(f"Unknown mode: {mode}")
 
-            # Mark as done
             conn = get_db()
-            conn.execute(
-                "UPDATE jobs SET status = 'done', finished_at = datetime('now'), "
-                "result_json = ? WHERE id = ?",
-                (json.dumps(result), job_id)
-            )
-
-            # Save to posts table
-            conn.execute(
-                "INSERT INTO posts (title, wp_url, wp_post_id, source_url, mode, "
-                "featured_image_url, youtube_count, image_count) VALUES (?,?,?,?,?,?,?,?)",
-                (
-                    result.get("title", "Untitled"),
-                    result.get("wp_url", result.get("post_url", "")),
-                    result.get("post_id", 0),
-                    url,
-                    mode,
-                    result.get("flyer_url", result.get("featured_image_url", "")),
-                    result.get("youtube_videos", 0),
-                    result.get("embedded_images", result.get("image_count", 0)),
-                )
-            )
+            conn.execute("UPDATE jobs SET status = 'done', finished_at = datetime('now'), result_json = ? WHERE id = ?", (json.dumps(result), job_id))
+            conn.execute("INSERT INTO posts (title, wp_url, wp_post_id, source_url, mode, featured_image_url, youtube_count, image_count) VALUES (?,?,?,?,?,?,?,?)",
+                (result.get("title", "Untitled"), result.get("wp_url", ""), result.get("post_id", 0), url, mode, result.get("featured_image_url", ""), result.get("youtube_videos", 0), result.get("image_count", 0)))
             conn.commit()
             conn.close()
-
             print(f"[AGENT] ✅ Job #{job_id} completed: {result.get('title', 'N/A')}")
-
-            # Send publish notification
-            send_notification(
-                event="published",
-                title=result.get("title", "Untitled"),
-                post_url=result.get("post_url", ""),
-                mode=mode
-            )
+            send_notification("published", result.get("title", "Untitled"), result.get("wp_url", ""), mode)
 
         except Exception as e:
             error_msg = f"{e}\n{traceback.format_exc()}"
             conn = get_db()
-            conn.execute(
-                "UPDATE jobs SET status = 'failed', finished_at = datetime('now'), "
-                "error = ? WHERE id = ?",
-                (error_msg[:2000], job_id)
-            )
+            conn.execute("UPDATE jobs SET status = 'failed', finished_at = datetime('now'), error = ? WHERE id = ?", (error_msg[:2000], job_id))
             conn.commit()
             conn.close()
             print(f"[AGENT] ❌ Job #{job_id} failed: {e}")
-
-            # Send failure notification
-            send_notification(
-                event="failed",
-                title=url,
-                post_url=str(e)[:200],
-                mode=mode
-            )
+            send_notification("failed", url, str(e)[:200], mode)
 
     with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
         futures = [executor.submit(process_one_job, job) for job in jobs]
-        for future in concurrent.futures.as_completed(futures):
-            future.result()  # Raise any exception if needed
-
+        for f in concurrent.futures.as_completed(futures): f.result()
     return True
 
-    except Exception as e:
-        error_msg = f"{e}\n{traceback.format_exc()}"
-        conn = get_db()
-        conn.execute(
-            "UPDATE jobs SET status = 'failed', finished_at = datetime('now'), "
-            "error = ? WHERE id = ?",
-            (error_msg[:2000], job_id)
-        )
-        conn.commit()
-        conn.close()
-        print(f"[AGENT] ❌ Job #{job_id} failed: {e}")
-
-        # Send failure notification
-        send_notification(
-            event="failed",
-            title=url,
-            post_url=str(e)[:200],
-            mode=mode
-        )
-
-        return True
-
+def _process_all_pending():
+    while process_pending_jobs(): time.sleep(1)
 
 # ──────────────────────────────────────────────
-# Notifications (Email + WhatsApp)
+# Notifications
 # ──────────────────────────────────────────────
 
-def send_notification(event: str, title: str, post_url: str, mode: str):
-    """Send notification via configured channels when a post is published or fails."""
+def send_notification(event, title, post_url, mode):
     try:
-        if event == "published" and get_setting("notify_on_publish", "true") != "true":
-            return
-        if event == "failed" and get_setting("notify_on_fail", "true") != "true":
-            return
-
-        if event == "published":
-            emoji = "✅"
-            subject = f"Article Published: {title}"
-            body = f"📰 New {mode} post published!\n\nTitle: {title}\nURL: {post_url}\nTime: {datetime.now().strftime('%Y-%m-%d %H:%M')}"
-        else:
-            emoji = "❌"
-            subject = f"Job Failed: {title[:50]}"
-            body = f"⚠️ A {mode} job failed.\n\nSource: {title}\nError: {post_url}\nTime: {datetime.now().strftime('%Y-%m-%d %H:%M')}"
-
-        # Email notification
-        if get_setting("notify_email_enabled", "false") == "true":
-            send_email_alert(subject, body)
-
-        # Telegram notification
-        if get_setting("notify_telegram_enabled", "false") == "true":
-            send_telegram_alert(f"{emoji} {subject}\n\n{body}")
-
-    except Exception as e:
-        print(f"[AGENT] [WARN] Notification error: {e}")
-
-
-def send_email_alert(subject: str, body: str):
-    """Send email via SMTP."""
+        if get_setting(f"notify_on_{event}", "true") != "true": return
+        emoji = "✅" if event == "published" else "❌"
+        subject = f"{'Published' if event == 'published' else 'Failed'}: {title[:50]}"
+        body = f"{emoji} {mode} job {event}!\nTitle: {title}\nURL: {post_url}"
+        if get_setting("notify_email_enabled") == "true": send_email_alert(subject, body)
+        if get_setting("notify_telegram_enabled") == "true": send_telegram_alert(f"{emoji} {subject}\n\n{body}")
+    except Exception as e: print(f"[AGENT] Notification error: {e}")
+
+def send_email_alert(subject, body):
     try:
-        to_addr = get_setting("notify_email_to", "")
-        smtp_host = get_setting("notify_email_smtp_host", "smtp.gmail.com")
-        smtp_port = int(get_setting("notify_email_smtp_port", "587"))
-        smtp_user = get_setting("notify_email_smtp_user", "")
-        smtp_pass = get_setting("notify_email_smtp_password", "")
-
-        if not all([to_addr, smtp_user, smtp_pass]):
-            print("[AGENT] [WARN] Email not configured — skipping")
-            return
-
-        msg = MIMEMultipart()
-        msg["From"] = smtp_user
-        msg["To"] = to_addr
-        msg["Subject"] = f"🤖 Content Agent — {subject}"
+        to_addr = get_setting("notify_email_to")
+        user = get_setting("notify_email_smtp_user")
+        pwd = get_setting("notify_email_smtp_password")
+        if not all([to_addr, user, pwd]): return
+        msg = MIMEMultipart(); msg["From"] = user; msg["To"] = to_addr; msg["Subject"] = f"🤖 {subject}"
         msg.attach(MIMEText(body, "plain"))
+        with smtplib.SMTP(get_setting("notify_email_smtp_host", "smtp.gmail.com"), int(get_setting("notify_email_smtp_port", "587"))) as s:
+            s.starttls(); s.login(user, pwd); s.send_message(msg)
+    except Exception as e: print(f"[AGENT] Email failed: {e}")
 
-        with smtplib.SMTP(smtp_host, smtp_port) as server:
-            server.starttls()
-            server.login(smtp_user, smtp_pass)
-            server.send_message(msg)
-
-        print(f"[AGENT] 📧 Email sent to {to_addr}")
-
-    except Exception as e:
-        print(f"[AGENT] [WARN] Email failed: {e}")
-
-
-def send_telegram_alert(message: str):
-    """Send Telegram message via Bot API.
-
-    Setup:
-    1. Message @BotFather on Telegram, send /newbot
-    2. Copy the bot token
-    3. Message your bot, then visit:
-       https://api.telegram.org/bot<TOKEN>/getUpdates
-       to find your chat_id
-    """
+def send_telegram_alert(message):
     try:
-        import requests as req
-
-        token = get_setting("notify_telegram_bot_token", "")
-        chat_id = get_setting("notify_telegram_chat_id", "")
-
-        if not token or not chat_id:
-            print("[AGENT] [WARN] Telegram not configured — skipping")
-            return
-
-        url = f"https://api.telegram.org/bot{token}/sendMessage"
-        resp = req.post(url, json={
-            "chat_id": chat_id,
-            "text": message,
-            "parse_mode": "HTML"
-        }, timeout=10)
-
-        if resp.status_code == 200:
-            print(f"[AGENT] 📱 Telegram sent to chat {chat_id}")
-        else:
-            error = resp.json().get("description", resp.text[:200])
-            print(f"[AGENT] [WARN] Telegram API error: {error}")
-
-    except Exception as e:
-        print(f"[AGENT] [WARN] Telegram failed: {e}")
+        token = get_setting("notify_telegram_bot_token")
+        chat_id = get_setting("notify_telegram_chat_id")
+        if token and chat_id:
+            requests.post(f"https://api.telegram.org/bot{token}/sendMessage", json={"chat_id": chat_id, "text": message, "parse_mode": "HTML"}, timeout=10)
+    except Exception as e: print(f"[AGENT] Telegram failed: {e}")
 
+# ──────────────────────────────────────────────
+# RSS Feeds
+# ──────────────────────────────────────────────
 
-def screen_article(title: str, summary: str, criteria: str) -> bool:
-    """
-    Use Dual-Engine AI (OpenRouter -> Groq) to decide if an article is worth publishing.
-    Returns True if the article passes screening, False otherwise.
-    """
+def screen_article(title, summary, criteria):
     try:
-        openrouter_key = os.getenv("OPENROUTER_API_KEY")
-        groq_key = os.getenv("GROQ_API_KEY")
-        
-        if not openrouter_key:
-            return True  # If no keys, skip screening
-
-        prompt = textwrap.dedent(f"""
-            You are a content editor deciding which articles to publish on a news/blog website.
-
-            ARTICLE TITLE: {title}
-            ARTICLE SUMMARY: {summary[:500]}
-
-            EDITORIAL CRITERIA:
-            {criteria}
-
-            Based on the criteria above, should this article be published?
-            Consider: topic relevance, reader interest, quality, and uniqueness.
-
-            Think step-by-step about the content and criteria before deciding.
-
-            Respond with ONLY a JSON object (no markdown, no code blocks):
-            {{"publish": true/false, "reason": "Brief one-line reason"}}
-        """).strip()
-
-        raw_text = None
-
-        # --- Step 1: OpenRouter (Primary) ---
-        if openrouter_key:
-            try:
-                print(f"[AGENT]   [SCREENING] Trying OpenRouter (qwen/qwen3.6-plus:free)...")
-                client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=openrouter_key)
-                completion = client.chat.completions.create(
-                    model="qwen/qwen3.6-plus:free",
-                    messages=[{"role": "user", "content": prompt}],
-                    temperature=0.2,
-                    response_format={"type": "json_object"},
-                    extra_body={"reasoning": {"max_tokens": 1024}}
-                )
-                raw_text = completion.choices[0].message.content.strip()
-            except Exception as e:
-                print(f"[AGENT]   [WARN] OpenRouter screening failed: {e}")
-
-        # --- Step 2: Groq (Backup) ---
-        if not raw_text and groq_key:
-            try:
-                print(f"[AGENT]   [SCREENING] Trying Groq Backup (qwen/qwen3-32b)...")
-                client = OpenAI(base_url="https://api.groq.com/openai/v1", api_key=groq_key)
-                completion = client.chat.completions.create(
-                    model="qwen/qwen3-32b",
-                    messages=[{"role": "user", "content": prompt}],
-                    temperature=0.2
-                )
-                raw_text = completion.choices[0].message.content.strip()
-            except Exception as e:
-                print(f"[AGENT]   [WARN] Groq screening failed: {e}")
-
-        if not raw_text:
-            return True # Fail-open
-
-        # Clean JSON
-        raw_text = raw_text.replace("```json", "").replace("```", "").strip()
-        import re
-        json_match = re.search(r'\{.*\}', raw_text, re.DOTALL)
-        if json_match:
-            result = json.loads(json_match.group())
-            should_publish = result.get("publish", True)
-            reason = result.get("reason", "")
-            status = "✅ APPROVED" if should_publish else "❌ REJECTED"
-            print(f"[AGENT] {status}: {title[:50]}... — {reason}")
-            return should_publish
-
-        return True  # Default to publishing if parsing fails
-
-    except Exception as e:
-        print(f"[AGENT] [WARN] Screening failed: {e} — defaulting to publish")
-        return True  # Fail-open
-
+        key = os.getenv("OPENROUTER_API_KEY")
+        if not key: return True
+        prompt = f"Decide if this article matches criteria: {criteria}\nTitle: {title}\nSummary: {summary}\nRespond ONLY with JSON: {{\"publish\": true/false, \"reason\": \"...\"}}"
+        client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=key)
+        resp = client.chat.completions.create(model="qwen/qwen3.6-plus:free", messages=[{"role":"user","content":prompt}], response_format={"type":"json_object"})
+        result = json.loads(resp.choices[0].message.content)
+        print(f"[AGENT] Screening: {result.get('publish')} - {result.get('reason')}")
+        return result.get("publish", True)
+    except: return True
 
 def check_rss_feeds():
-    """Check all active RSS feeds for new articles. Uses AI screening if enabled."""
     conn = get_db()
     feeds = conn.execute("SELECT * FROM feeds WHERE active = 1").fetchall()
     conn.close()
-
-    screening_enabled = get_setting("screening_enabled", "true") == "true"
-    criteria = get_setting("screening_criteria", "")
-
+    screening = get_setting("screening_enabled", "true") == "true"
+    criteria = get_setting("screening_criteria")
     new_articles = 0
-    screened_out = 0
-
     for feed in feeds:
         try:
-            # Use requests with browser headers first to avoid bot blocks, 
-            # then pass content to feedparser
-            print(f"[AGENT] Checking RSS feed: {feed['url']}")
-            headers = {
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-                "Accept": "application/rss+xml, application/xml, text/xml, */*"
-            }
-            resp = requests.get(feed["url"], headers=headers, timeout=20)
-            
-            # Check for LiteSpeed / Bot verification
-            if "Bot Verification" in resp.text or "grecaptcha" in resp.text:
-                print(f"[AGENT] [WARN] Feed blocked by Bot Verification firewall: {feed['url']}")
-                continue
-                
+            resp = requests.get(feed["url"], headers={"User-Agent": "Mozilla/5.0"}, timeout=20)
             parsed = feedparser.parse(resp.content)
-            
-            if not parsed.entries:
-                print(f"[AGENT] [INFO] No entries found (or parse failed) for {feed['url']}")
-                continue
-
-            for entry in parsed.entries[:10]:  # Check last 10 entries
-                article_url = entry.get("link", "")
-                if not article_url:
-                    continue
-
-                # Check if we already have this URL in memory, jobs or posts
+            for entry in parsed.entries[:10]:
+                url = entry.get("link")
+                if not url: continue
                 conn = get_db()
-                
-                # 1. Check dedicated memory first
-                memo = conn.execute("SELECT status FROM processed_urls WHERE url = ?", (article_url,)).fetchone()
-                if memo:
-                    conn.close()
-                    continue
-                
-                # 2. Check jobs/posts (for migration/safety)
-                existing = conn.execute(
-                    "SELECT id FROM jobs WHERE url = ? UNION SELECT id FROM posts WHERE source_url = ?",
-                    (article_url, article_url)
-                ).fetchone()
-
-                if existing:
-                    # Mark as legacy in memory to avoid full re-checks later
-                    conn.execute("INSERT OR IGNORE INTO processed_urls (url, status) VALUES (?, ?)", (article_url, 'legacy'))
-                    conn.commit()
-                    conn.close()
-                    continue
-
-                # AI Screening
-                if screening_enabled and criteria:
-                    entry_title = entry.get("title", "")
-                    entry_summary = entry.get("summary", entry.get("description", ""))
-                    if not screen_article(entry_title, entry_summary, criteria):
-                        screened_out += 1
-                        # Remember rejection
-                        conn.execute("INSERT OR IGNORE INTO processed_urls (url, status) VALUES (?, ?)", (article_url, 'rejected'))
-                        conn.commit()
-                        conn.close()
-                        continue
-
-                    # Check if manual review is enabled
-                    review_enabled = get_setting("review_feeds_enabled", "true") == "true"
-                    initial_status = "review" if review_enabled else "pending"
-
-                    # Approved / Queued
-                    conn.execute(
-                        "INSERT INTO jobs (url, title, mode, status) VALUES (?, ?, 'article', ?)",
-                        (article_url, entry_title, initial_status)
-                    )
-                    conn.execute("INSERT OR IGNORE INTO processed_urls (url, status) VALUES (?, ?)", (article_url, 'queued'))
-                    conn.commit()
+                if conn.execute("SELECT status FROM processed_urls WHERE url = ?", (url,)).fetchone():
+                    conn.close(); continue
+                if screening and not screen_article(entry.get("title", ""), entry.get("summary", ""), criteria):
+                    conn.execute("INSERT INTO processed_urls (url, status) VALUES (?, ?)", (url, 'rejected'))
+                else:
+                    review = get_setting("review_feeds_enabled", "true") == "true"
+                    status = "review" if review else "pending"
+                    conn.execute("INSERT INTO jobs (url, title, mode, status) VALUES (?, ?, 'article', ?)", (url, entry.get("title", "Untitled"), status))
+                    conn.execute("INSERT INTO processed_urls (url, status) VALUES (?, ?)", (url, 'queued'))
                     new_articles += 1
-                    if review_enabled:
-                        print(f"[AGENT] 👀 Queued article for review: {article_url}")
-                    else:
-                        print(f"[AGENT] 📰 Queued article: {article_url}")
-
-                conn.close()
-
-            # Update last_checked
-            conn = get_db()
-            conn.execute(
-                "UPDATE feeds SET last_checked = datetime('now'), "
-                "articles_found = articles_found + ? WHERE id = ?",
-                (new_articles, feed["id"])
-            )
-            conn.commit()
-            conn.close()
-
-        except Exception as e:
-            print(f"[AGENT] [WARN] RSS check failed for {feed['name']}: {e}")
-
-    if screened_out:
-        print(f"[AGENT] 🔍 Screened out {screened_out} article(s) that didn't match criteria")
-
+                conn.commit(); conn.close()
+            conn = get_db(); conn.execute("UPDATE feeds SET last_checked = datetime('now'), articles_found = articles_found + ? WHERE id = ?", (new_articles, feed["id"])); conn.commit(); conn.close()
+        except Exception as e: print(f"[AGENT] RSS failed for {feed['url']}: {e}")
     return new_articles
 
-
 def agent_loop():
-    """Main agent background loop."""
     print("[AGENT] 🤖 Agent thread started")
-    from main import _ensure_dirs
-    _ensure_dirs()
-    last_rss_check = 0
-
+    last_rss = 0
     while True:
         try:
-            agent_enabled = get_setting("agent_enabled", "false") == "true"
-            interval = int(get_setting("check_interval_minutes", "30"))
-
-            if agent_enabled:
-                # Check RSS feeds periodically
-                now = time.time()
-                if now - last_rss_check > interval * 60:
-                    print("[AGENT] 📡 Checking RSS feeds...")
-                    new = check_rss_feeds()
-                    if new:
-                        print(f"[AGENT] Found {new} new article(s)")
-                    last_rss_check = now
-
-                # Process pending jobs
-                with LOCK:
-                    process_pending_jobs()
-
-            time.sleep(10)  # Check every 10 seconds
-
-        except Exception as e:
-            print(f"[AGENT] Loop error: {e}")
-            time.sleep(30)
-
+            if get_setting("agent_enabled") == "true":
+                if time.time() - last_rss > int(get_setting("check_interval_minutes", "30")) * 60:
+                    check_rss_feeds(); last_rss = time.time()
+                with LOCK: process_pending_jobs()
+            time.sleep(10)
+        except Exception as e: print(f"[AGENT] Loop error: {e}"); time.sleep(30)
 
 # ──────────────────────────────────────────────
-# Authentication
+# Routes
 # ──────────────────────────────────────────────
 
 @app.before_request
 def require_login():
-    # Only protect root and API routes, allow static and login
-    if request.endpoint in ['login', 'static']:
-        return
-    if not session.get('logged_in'):
+    if request.endpoint not in ['login', 'static'] and not session.get('logged_in'):
         return redirect(url_for('login'))
 
 @app.route("/login", methods=["GET", "POST"])
 def login():
     if request.method == "POST":
-        username = request.form.get("username")
-        password = request.form.get("password")
-        if username == "webmazta" and password == "2010":
-            session["logged_in"] = True
-            return redirect(url_for("dashboard"))
-        else:
-            flash("Invalid credentials", "error")
+        if request.form.get("username") == "webmazta" and request.form.get("password") == "2010":
+            session["logged_in"] = True; return redirect(url_for("dashboard"))
+        flash("Invalid credentials", "error")
     return render_template("login.html")
 
 @app.route("/logout")
-def logout():
-    session.pop("logged_in", None)
-    return redirect(url_for("login"))
-
-# ──────────────────────────────────────────────
-# API Routes
-# ──────────────────────────────────────────────
+def logout(): session.pop("logged_in", None); return redirect(url_for("login"))
 
 @app.route("/")
-def dashboard():
-    return render_template("dashboard.html")
-
+def dashboard(): return render_template("dashboard.html")
 
 @app.route("/api/stats")
 def api_stats():
     conn = get_db()
-    total_posts = conn.execute("SELECT COUNT(*) as c FROM posts").fetchone()["c"]
-    today_posts = conn.execute(
-        "SELECT COUNT(*) as c FROM posts WHERE date(created_at) = date('now')"
-    ).fetchone()["c"]
-    queue_size = conn.execute(
-        "SELECT COUNT(*) as c FROM jobs WHERE status IN ('pending', 'running')"
-    ).fetchone()["c"]
-    total_jobs = conn.execute("SELECT COUNT(*) as c FROM jobs").fetchone()["c"]
-    failed_jobs = conn.execute(
-        "SELECT COUNT(*) as c FROM jobs WHERE status = 'failed'"
-    ).fetchone()["c"]
-    success_rate = (
-        round((total_jobs - failed_jobs) / total_jobs * 100) if total_jobs > 0 else 100
-    )
-    active_feeds = conn.execute(
-        "SELECT COUNT(*) as c FROM feeds WHERE active = 1"
-    ).fetchone()["c"]
-    agent_enabled = get_setting("agent_enabled", "false") == "true"
-    conn.close()
-
-    return jsonify({
-        "total_posts": total_posts,
-        "today_posts": today_posts,
-        "queue_size": queue_size,
-        "total_jobs": total_jobs,
-        "failed_jobs": failed_jobs,
-        "success_rate": success_rate,
-        "active_feeds": active_feeds,
-        "agent_enabled": agent_enabled,
-    })
-
+    stats = {
+        "total_posts": conn.execute("SELECT COUNT(*) FROM posts").fetchone()[0],
+        "today_posts": conn.execute("SELECT COUNT(*) FROM posts WHERE date(created_at) = date('now')").fetchone()[0],
+        "queue_size": conn.execute("SELECT COUNT(*) FROM jobs WHERE status IN ('pending', 'running')").fetchone()[0],
+        "total_jobs": conn.execute("SELECT COUNT(*) FROM jobs").fetchone()[0],
+        "failed_jobs": conn.execute("SELECT COUNT(*) FROM jobs WHERE status = 'failed'").fetchone()[0],
+        "active_feeds": conn.execute("SELECT COUNT(*) FROM feeds WHERE active = 1").fetchone()[0],
+        "agent_enabled": get_setting("agent_enabled") == "true"
+    }
+    stats["success_rate"] = round((stats["total_jobs"] - stats["failed_jobs"]) / stats["total_jobs"] * 100) if stats["total_jobs"] > 0 else 100
+    conn.close(); return jsonify(stats)
 
 @app.route("/api/jobs", methods=["GET"])
 def api_jobs_list():
-    status_filter = request.args.get("status", "")
-    limit = int(request.args.get("limit", "50"))
-
+    status = request.args.get("status", "")
     conn = get_db()
-    if status_filter:
-        rows = conn.execute(
-            "SELECT * FROM jobs WHERE status = ? ORDER BY created_at DESC LIMIT ?",
-            (status_filter, limit)
-        ).fetchall()
-    else:
-        rows = conn.execute(
-            "SELECT * FROM jobs ORDER BY created_at DESC LIMIT ?", (limit,)
-        ).fetchall()
-    conn.close()
-
-    return jsonify([dict(r) for r in rows])
-
+    if status: rows = conn.execute("SELECT * FROM jobs WHERE status = ? ORDER BY created_at DESC LIMIT 50", (status,)).fetchall()
+    else: rows = conn.execute("SELECT * FROM jobs ORDER BY created_at DESC LIMIT 50").fetchall()
+    conn.close(); return jsonify([dict(r) for r in rows])
 
 @app.route("/api/jobs", methods=["POST"])
 def api_jobs_create():
     data = request.get_json()
     urls = data.get("urls", [])
     mode = data.get("mode", "article")
-
-    if isinstance(urls, str):
-        urls = [u.strip() for u in urls.split("\n") if u.strip() and not u.strip().startswith("#")]
-
-    if not urls:
-        return jsonify({"error": "No URLs provided"}), 400
-
+    group_media = data.get("group_media", False)
+    if isinstance(urls, str): urls = [u.strip() for u in urls.split("\n") if u.strip() and not u.strip().startswith("#")]
+    if not urls: return jsonify({"error": "No URLs provided"}), 400
     conn = get_db()
-    created = []
-    for url in urls:
-        conn.execute(
-            "INSERT INTO jobs (url, mode) VALUES (?, ?)",
-            (url.strip(), mode)
-        )
-        created.append(url.strip())
-    conn.commit()
-    conn.close()
-
-    # Trigger processing in background
-    threading.Thread(target=_process_all_pending, daemon=True).start()
-
-    return jsonify({"created": len(created), "urls": created}), 201
-
-
-# Upload directory for manually uploaded videos/images
-UPLOAD_DIR = Path("uploads")
-UPLOAD_DIR.mkdir(exist_ok=True)
-ALLOWED_VIDEO_EXTENSIONS = {".mp4", ".mov", ".avi", ".webm"}
-ALLOWED_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp", ".bmp"}
-
-
-@app.route("/api/upload", methods=["POST"])
-def api_upload_media():
-    """Accept multiple media files (video/image) upload, save them, and create a job."""
-    if "video" not in request.files:
-        return jsonify({"error": "No media file provided"}), 400
-
-    files = request.files.getlist("video")
-    if not files or all(f.filename == "" for f in files):
-        return jsonify({"error": "No files selected"}), 400
-
-    saved_paths = []
-    has_video = False
-    has_image = False
-
-    for file in files:
-        if file.filename == "":
-            continue
-            
-        # Validate extension
-        ext = Path(file.filename).suffix.lower()
-        is_video = ext in ALLOWED_VIDEO_EXTENSIONS
-        is_image = ext in ALLOWED_IMAGE_EXTENSIONS
-
-        if not is_video and not is_image:
-            allowed = list(ALLOWED_VIDEO_EXTENSIONS) + list(ALLOWED_IMAGE_EXTENSIONS)
-            return jsonify({"error": f"Unsupported file type: {ext} in {file.filename}. Allowed: {', '.join(allowed)}"}), 400
-
-        if is_video: has_video = True
-        if is_image: has_image = True
-
-        # Save with unique name to avoid collisions
-        import uuid
-        unique_name = f"{uuid.uuid4().hex[:12]}_{file.filename}"
-        save_path = UPLOAD_DIR / unique_name
-        file.save(str(save_path))
-        saved_paths.append(str(save_path.resolve()))
-
-    if not saved_paths:
-        return jsonify({"error": "No valid files uploaded"}), 400
-
-    # Determine mode based on content
-    if has_video:
-        mode = "upload_video" # Video takes priority or it's mixed
+    if group_media and len(urls) > 1:
+        conn.execute("INSERT INTO jobs (url, mode) VALUES (?, ?)", (json.dumps(urls), mode))
     else:
-        mode = "upload_image"
-
-    print(f"[UPLOAD] Saved {len(saved_paths)} file(s). Mode: {mode}")
-
-    # Create job with JSON list of paths
-    conn = get_db()
-    conn.execute(
-        "INSERT INTO jobs (url, mode) VALUES (?, ?)",
-        (json.dumps(saved_paths), mode)
-    )
-    conn.commit()
-    conn.close()
-
-    # Trigger processing
-    threading.Thread(target=_process_all_pending, daemon=True).start()
-
-    return jsonify({
-        "ok": True, 
-        "count": len(saved_paths),
-        "message": f"{len(saved_paths)} file(s) uploaded and queued"
-    }), 201
-
-
-def _process_all_pending():
-    """Process all pending jobs (triggered by manual submission)."""
-    STOP_PROCESSING.clear()  # Reset stop flag when starting
-    while not STOP_PROCESSING.is_set():
-        with LOCK:
-            had_work = process_pending_jobs()
-        if not had_work:
-            break
-        time.sleep(1)
-    if STOP_PROCESSING.is_set():
-        print("[AGENT] ⛔ Queue processing stopped by user")
-
-
-@app.route("/api/jobs/stop", methods=["POST"])
-def api_jobs_stop():
-    """Stop processing the queue. Running job will finish, but no new jobs start."""
-    STOP_PROCESSING.set()
-
-    # Also mark any running jobs as failed/cancelled
-    conn = get_db()
-    running = conn.execute("SELECT id FROM jobs WHERE status = 'running'").fetchall()
-    for job in running:
-        conn.execute(
-            "UPDATE jobs SET status = 'failed', error = 'Cancelled by user', "
-            "finished_at = datetime('now') WHERE id = ?",
-            (job["id"],)
-        )
-    conn.commit()
-    conn.close()
-
-    count = len(running)
-    print(f"[AGENT] ⛔ Queue stopped. {count} running job(s) cancelled.")
-    return jsonify({"stopped": True, "cancelled_running": count})
-
-
-@app.route("/api/jobs/cancel-all", methods=["POST"])
-def api_jobs_cancel_all():
-    """Cancel all pending jobs."""
-    STOP_PROCESSING.set()
-    conn = get_db()
-    result = conn.execute("DELETE FROM jobs WHERE status = 'pending'")
-    cancelled = result.rowcount
-    conn.commit()
-    conn.close()
-    print(f"[AGENT] 🗑️ Cancelled {cancelled} pending job(s)")
-    return jsonify({"cancelled": cancelled})
-
-
-@app.route("/api/jobs/<int:job_id>", methods=["DELETE"])
-def api_jobs_delete(job_id):
-    conn = get_db()
-    conn.execute(
-        "DELETE FROM jobs WHERE id = ? AND status IN ('pending', 'failed', 'review')", (job_id,)
-    )
-    conn.commit()
-    conn.close()
-    return jsonify({"deleted": True})
-
-
-@app.route("/api/jobs/<int:job_id>/approve", methods=["POST"])
-def api_jobs_approve(job_id):
-    conn = get_db()
-    conn.execute(
-        "UPDATE jobs SET status = 'pending' WHERE id = ? AND status = 'review'",
-        (job_id,)
-    )
-    conn.commit()
-    conn.close()
-
-    # Trigger processing in background
-    threading.Thread(target=_process_all_pending, daemon=True).start()
-    return jsonify({"approved": True})
-
-
-@app.route("/api/jobs/<int:job_id>/retry", methods=["POST"])
-def api_jobs_retry(job_id):
-    conn = get_db()
-    conn.execute(
-        "UPDATE jobs SET status = 'pending', error = NULL, "
-        "started_at = NULL, finished_at = NULL WHERE id = ?",
-        (job_id,)
-    )
-    conn.commit()
-    conn.close()
-
+        for u in urls: conn.execute("INSERT INTO jobs (url, mode) VALUES (?, ?)", (u, mode))
+    conn.commit(); conn.close()
     threading.Thread(target=_process_all_pending, daemon=True).start()
-    return jsonify({"retried": True})
-
-
-@app.route("/api/posts")
-def api_posts_list():
-    limit = int(request.args.get("limit", "50"))
-    conn = get_db()
-    rows = conn.execute(
-        "SELECT * FROM posts ORDER BY created_at DESC LIMIT ?", (limit,)
-    ).fetchall()
-    conn.close()
-    return jsonify([dict(r) for r in rows])
-
-
-@app.route("/api/feeds", methods=["GET"])
-def api_feeds_list():
-    conn = get_db()
-    rows = conn.execute("SELECT * FROM feeds ORDER BY created_at DESC").fetchall()
-    conn.close()
-    return jsonify([dict(r) for r in rows])
-
-
-@app.route("/api/feeds", methods=["POST"])
-def api_feeds_create():
-    data = request.get_json()
-    name = data.get("name", "").strip()
-    url = data.get("url", "").strip()
-
-    if not name or not url:
-        return jsonify({"error": "Name and URL required"}), 400
-
-    conn = get_db()
-    try:
-        conn.execute(
-            "INSERT INTO feeds (name, url) VALUES (?, ?)", (name, url)
-        )
-        conn.commit()
-    except sqlite3.IntegrityError:
-        return jsonify({"error": "Feed URL already exists"}), 409
-    finally:
-        conn.close()
-
-    return jsonify({"created": True}), 201
-
-
-@app.route("/api/feeds/<int:feed_id>", methods=["DELETE"])
-def api_feeds_delete(feed_id):
-    conn = get_db()
-    conn.execute("DELETE FROM feeds WHERE id = ?", (feed_id,))
-    conn.commit()
-    conn.close()
-    return jsonify({"deleted": True})
-
-
-@app.route("/api/feeds/<int:feed_id>/toggle", methods=["POST"])
-def api_feeds_toggle(feed_id):
-    conn = get_db()
-    conn.execute(
-        "UPDATE feeds SET active = CASE WHEN active = 1 THEN 0 ELSE 1 END WHERE id = ?",
-        (feed_id,)
-    )
-    conn.commit()
-    conn.close()
-    return jsonify({"toggled": True})
-
+    return jsonify({"success": True}), 201
 
 @app.route("/api/settings", methods=["GET"])
 def api_settings_get():
-    settings = get_all_settings()
-    # Mask password fields for security
-    masked = dict(settings)
-    if masked.get("wp_app_password"):
-        masked["wp_app_password"] = "••••••" + masked["wp_app_password"][-4:]
-    if masked.get("ig_password"):
-        masked["ig_password"] = "••••••" + masked["ig_password"][-4:]
-    if masked.get("google_api_key"):
-        masked["google_api_key"] = masked["google_api_key"][:8] + "••••••"
-    if masked.get("notify_email_smtp_password"):
-        masked["notify_email_smtp_password"] = "••••••" + masked["notify_email_smtp_password"][-4:]
-    return jsonify(masked)
-
+    s = get_all_settings()
+    for k in ["wp_app_password", "ig_password", "openrouter_api_key"]:
+        if s.get(k): s[k] = "••••••" + s[k][-4:]
+    return jsonify(s)
 
 @app.route("/api/settings", methods=["POST"])
 def api_settings_update():
     data = request.get_json()
-    for key, value in data.items():
-        # Don't save masked values
-        if "••••••" in str(value):
-            continue
-        set_setting(key, str(value))
+    for k, v in data.items():
+        if "••••••" not in str(v): set_setting(k, str(v))
     return jsonify({"updated": True})
 
-
-@app.route("/api/agent/toggle", methods=["POST"])
-def api_agent_toggle():
-    current = get_setting("agent_enabled", "false")
-    new_val = "false" if current == "true" else "true"
-    set_setting("agent_enabled", new_val)
-    return jsonify({"agent_enabled": new_val == "true"})
-
-
-@app.route("/api/test-notification", methods=["POST"])
-def api_test_notification():
-    """Send a test notification to verify email/WhatsApp config."""
-    results = {"email": None, "whatsapp": None}
-
-    # Test email
-    if get_setting("notify_email_enabled", "false") == "true":
-        try:
-            to_addr = get_setting("notify_email_to", "")
-            smtp_host = get_setting("notify_email_smtp_host", "smtp.gmail.com")
-            smtp_port = int(get_setting("notify_email_smtp_port", "587"))
-            smtp_user = get_setting("notify_email_smtp_user", "")
-            smtp_pass = get_setting("notify_email_smtp_password", "")
-
-            if not all([to_addr, smtp_user, smtp_pass]):
-                results["email"] = {"ok": False, "error": "Missing email config: fill in all SMTP fields"}
-            else:
-                msg = MIMEMultipart()
-                msg["From"] = smtp_user
-                msg["To"] = to_addr
-                msg["Subject"] = "🤖 Content Agent — Test Notification"
-                msg.attach(MIMEText(
-                    "✅ Email notifications are working!\n\n"
-                    "You will receive alerts when articles are published or jobs fail.\n\n"
-                    f"— Content Agent @ {datetime.now().strftime('%Y-%m-%d %H:%M')}",
-                    "plain"
-                ))
-
-                with smtplib.SMTP(smtp_host, smtp_port, timeout=10) as server:
-                    server.starttls()
-                    server.login(smtp_user, smtp_pass)
-                    server.send_message(msg)
-
-                results["email"] = {"ok": True, "message": f"Test email sent to {to_addr}"}
-                print(f"[AGENT] 📧 Test email sent to {to_addr}")
-
-        except smtplib.SMTPAuthenticationError as e:
-            error = f"Authentication failed. For Gmail, make sure you're using an App Password (not your regular password). Error: {e}"
-            results["email"] = {"ok": False, "error": error}
-            print(f"[AGENT] [WARN] Test email auth failed: {e}")
-        except Exception as e:
-            results["email"] = {"ok": False, "error": str(e)}
-            print(f"[AGENT] [WARN] Test email failed: {e}")
-    else:
-        results["email"] = {"ok": False, "error": "Email notifications are disabled"}
-
-    # Test Telegram
-    if get_setting("notify_telegram_enabled", "false") == "true":
-        try:
-            import requests as req
-            token = get_setting("notify_telegram_bot_token", "")
-            chat_id = get_setting("notify_telegram_chat_id", "")
-
-            if not token or not chat_id:
-                results["telegram"] = {"ok": False, "error": "Missing bot token or chat ID"}
-            else:
-                url = f"https://api.telegram.org/bot{token}/sendMessage"
-                resp = req.post(url, json={
-                    "chat_id": chat_id,
-                    "text": "✅ Content Agent test — Telegram notifications are working!",
-                }, timeout=10)
-
-                if resp.status_code == 200:
-                    results["telegram"] = {"ok": True, "message": f"Test message sent to chat {chat_id}"}
-                    print(f"[AGENT] 📱 Test Telegram sent to chat {chat_id}")
-                else:
-                    error = resp.json().get("description", resp.text[:200])
-                    results["telegram"] = {"ok": False, "error": f"Telegram API: {error}"}
-        except Exception as e:
-            results["telegram"] = {"ok": False, "error": str(e)}
-    else:
-        results["telegram"] = {"ok": False, "error": "Telegram notifications are disabled"}
-
-    return jsonify(results)
-
-
-# ──────────────────────────────────────────────
-# Health Check (no template needed)
-# ──────────────────────────────────────────────
-
-@app.route("/health")
-def health_check():
-    return jsonify({"status": "ok"}), 200
-
-
 @app.route("/api/logs", methods=["GET"])
-def api_logs_get():
-    """Return the recent terminal logs for the UI."""
-    return jsonify({"logs": list(LOG_BUFFER)})
+def api_logs_get(): return jsonify({"logs": list(LOG_BUFFER)})
 
-@app.route("/api/logs/clear", methods=["POST"])
-def api_logs_clear():
-    """Clear the terminal log buffer."""
-    LOG_BUFFER.clear()
-    return jsonify({"cleared": True})
+@app.route("/health")
+def health_check(): return jsonify({"status": "ok"}), 200
 
 # ──────────────────────────────────────────────
 # Main
 # ──────────────────────────────────────────────
 
-_agent_started = False
-
-def _start_agent_thread():
-    """Start the agent background thread (only once)."""
-    global _agent_started
-    if not _agent_started:
-        _agent_started = True
-        agent_thread = threading.Thread(target=agent_loop, daemon=True)
-        agent_thread.start()
+_started = False
+def _start_agent():
+    global _started
+    if not _started: 
+        _started = True; threading.Thread(target=agent_loop, daemon=True).start()
 
-# Initialize database with error handling
 print("[STARTUP] Initializing database...")
-try:
-    init_db()
-    print("[STARTUP] Database initialized successfully")
-except Exception as e:
-    print(f"[STARTUP] WARNING: Database init failed: {e}")
-    import traceback
-    traceback.print_exc()
-
-# For Gunicorn: start agent thread after worker is ready
-@app.before_request
-def _ensure_agent():
-    _start_agent_thread()
-
-print("[STARTUP] App module loaded successfully")
+init_db()
 
+@app.before_request
+def _ensure_agent(): _start_agent()
 
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 5000))
-    print("🤖 Content Publishing Agent")
-    print(f"📊 Dashboard: http://localhost:{port}")
-    print(f"💾 Database: {DB_PATH.absolute()}")
-    _start_agent_thread()
-    app.run(host="0.0.0.0", port=port, debug=False)
+    _start_agent(); app.run(host="0.0.0.0", port=port, debug=False)

main.py

@@ -1237,32 +1237,34 @@ def publish_post(
     flyer_url: str,
     source_url: str,
     is_video: bool = True,
-    extra_image_urls: list[str] = None
+    extra_media: list[dict] = None
 ) -> dict:
     """
     Create and publish a WordPress post via REST API.
-    Returns: {"id": int, "url": str}
+    extra_media: list of {"url": str, "id": int, "type": "image"|"video"}
     """
     print("[JOB] Publishing post to WordPress...")
 
-    button_text = "Watch VIDEO" if is_video else "See Images"
-    
-    # Image links section
-    image_links_html = ""
-    if extra_image_urls:
-        links = []
-        for i, img_url in enumerate(extra_image_urls, 1):
-            links.append(f'<!-- wp:button --><div class="wp-block-button is-style-outline"><a class="wp-block-button__link wp-element-button" href="{img_url}" target="_blank" rel="noreferrer noopener">View Image {i}</a></div><!-- /wp:button -->')
-        
-        image_links_html = f"""
-        <!-- wp:buttons {{"layout":{{"type":"flex","justifyContent":"center"}}}} -->
-        <div class="wp-block-buttons">
-            {"".join(links)}
-        </div>
-        <!-- /wp:buttons -->
-        """
+    # Media section (Gutenberg blocks)
+    media_html = ""
+    if extra_media:
+        for item in extra_media:
+            m_url = item["url"]
+            m_id = item["id"]
+            if item.get("type") == "video":
+                media_html += f"""
+                <!-- wp:video {{"id":{m_id},"sizeSlug":"full"}} -->
+                <figure class="wp-block-video"><video controls src="{m_url}"></video></figure>
+                <!-- /wp:video -->
+                """
+            else:
+                media_html += f"""
+                <!-- wp:image {{"id":{m_id},"sizeSlug":"full","linkDestination":"none"}} -->
+                <figure class="wp-block-image size-full"><img src="{m_url}" alt="" class="wp-image-{m_id}"/></figure>
+                <!-- /wp:image -->
+                """
 
-    # Construct post body with Gutenberg blocks
+    # Construct post body
     post_body = textwrap.dedent(f"""\
         <!-- wp:paragraph -->
         <p>{paragraph1}</p>
@@ -1276,12 +1278,12 @@ def publish_post(
         <figure class="wp-block-image size-full"><img src="{flyer_url}" alt="{title}" class="wp-image-{flyer_id}"/></figure>
         <!-- /wp:image -->
 
-        {image_links_html}
+        {media_html}
 
         <!-- wp:buttons {{"layout":{{"type":"flex","justifyContent":"center"}}}} -->
         <div class="wp-block-buttons">
             <!-- wp:button -->
-            <div class="wp-block-button"><a class="wp-block-button__link wp-element-button" href="{source_url}" target="_blank" rel="noreferrer noopener">{button_text}</a></div>
+            <div class="wp-block-button"><a class="wp-block-button__link wp-element-button" href="{source_url}" target="_blank" rel="noreferrer noopener">Source Link</a></div>
             <!-- /wp:button -->
         </div>
         <!-- /wp:buttons -->
@@ -1300,106 +1302,99 @@ def publish_post(
     }
 
     url = f"{WP_URL}/wp-json/wp/v2/posts"
-    response = requests.post(
-        url,
-        json=post_data,
-        auth=_wp_auth(),
-        timeout=30
-    )
-
+    response = requests.post(url, json=post_data, auth=_wp_auth(), timeout=30)
     if response.status_code not in (200, 201):
-        raise Exception(
-            f"WordPress post creation failed ({response.status_code}): "
-            f"{response.text[:300]}"
-        )
+        raise Exception(f"WP post failed: {response.text[:300]}")
 
     data = response.json()
-    result = {
-        "id": data["id"],
-        "url": data.get("link", data.get("guid", {}).get("rendered", ""))
-    }
-    print(f"   [OK] Post published: {result['url']}")
-    return result
+    return {"id": data["id"], "url": data.get("link", "")}
 
 
 # ──────────────────────────────────────────────
 # 7. Full Pipeline
 # ──────────────────────────────────────────────
 
-def process_video(url: str) -> dict:
+def process_video(url_input: any) -> dict:
     """
-    Full pipeline for a single video URL:
-    download → analyze → generate content → create media → publish to WP.
+    Pipeline for video URL(s). Handles single URL string or list of URLs.
     """
+    urls = [url_input] if isinstance(url_input, str) else url_input
+    primary_url = urls[0]
+
     print(f"\n{'='*60}")
-    print(f"[JOB] Processing: {url}")
+    print(f"[JOB] Processing {len(urls)} media URL(s)...")
     print(f"{'='*60}")
 
+    _ensure_dirs()
+    
     import hashlib
-    url_hash = hashlib.md5(url.encode()).hexdigest()[:8]
+    primary_hash = hashlib.md5(primary_url.encode()).hexdigest()[:8]
     safe_name = _sanitize_filename(
-        re.search(r'/(?:reel|p|video|shorts)/([A-Za-z0-9_-]+)', url).group(1)
-        if re.search(r'/(?:reel|p|video|shorts)/([A-Za-z0-9_-]+)', url)
-        else url_hash
+        re.search(r'/(?:reel|p|video|shorts)/([A-Za-z0-9_-]+)', primary_url).group(1)
+        if re.search(r'/(?:reel|p|video|shorts)/([A-Za-z0-9_-]+)', primary_url)
+        else primary_hash
     )
 
-    # Step 1: Download
-    video_path = download_video(url)
-
-    # Step 2: Extract frames (more frames for better selection)
-    frames = extract_frames(video_path, count=10)
+    all_frames = []
+    wp_extra_media = []
 
-    # Step 3: Analyze video with AI
-    analysis = analyze_video(video_path)
+    for i, url in enumerate(urls):
+        print(f"[{i+1}/{len(urls)}] Downloading: {url}")
+        video_path = download_video(url)
+        ext = video_path.suffix.lower()
+        is_video = ext in [".mp4", ".webm", ".avi", ".mov"]
+        
+        # Extract frames
+        frames = extract_frames(video_path, count=5)
+        all_frames.extend(frames)
+
+        # Upload original to WP
+        wp_item = upload_media_to_wp(video_path, f"grouped-{i}-{video_path.name}")
+        wp_extra_media.append({
+            "id": wp_item["id"],
+            "url": wp_item["url"],
+            "type": "video" if is_video else "image"
+        })
+
+    # Step: Analyze Primary (first one)
+    primary_video = download_video(primary_url) # Redownload or use cache
+    analysis = analyze_video(primary_video)
     categories = analysis.get("frame_categories", {}) if isinstance(analysis, dict) else {}
 
-    # Step 4: Generate blog content
-    content = generate_content(analysis, url)
+    # Step: Generate Content
+    content = generate_content(analysis, primary_url)
     title = content["title"]
-    p1 = content["paragraph1"]
-    p2 = content["paragraph2"]
 
-    # Step 5: Create featured image (16:9 - 3:1 Collage)
-    featured_path = create_featured_image(title, frames, safe_name, categories)
+    # Step: Create Collages
+    # Use first few frames for the featured image
+    processing_frames = all_frames[:10]
+    featured_path = create_featured_image(title, processing_frames, safe_name, categories)
+    flyer_path = create_flyer(title, processing_frames, safe_name, categories)
 
-    # Step 6: Create flyer (1080x1080)
-    flyer_path = create_flyer(title, frames, safe_name, categories)
-
-    # Step 7: Upload media to WordPress
-    featured_media = upload_media_to_wp(
-        featured_path, f"featured-{safe_name}.jpg"
-    )
-    flyer_media = upload_media_to_wp(
-        flyer_path, f"flyer-{safe_name}.jpg"
-    )
-
-    # Determine if it's a video based on file extension instead of frame count
-    is_video_file = video_path.suffix.lower() in [".mp4", ".webm", ".avi", ".mov"]
+    # Step: Upload Generated
+    featured_media = upload_media_to_wp(featured_path, f"featured-{safe_name}.jpg")
+    flyer_media = upload_media_to_wp(flyer_path, f"flyer-{safe_name}.jpg")
 
-    # Step 8: Publish post
+    # Step: Publish
     post = publish_post(
         title=title,
-        paragraph1=p1,
-        paragraph2=p2,
+        paragraph1=content["paragraph1"],
+        paragraph2=content["paragraph2"],
         featured_media_id=featured_media["id"],
         flyer_id=flyer_media["id"],
         flyer_url=flyer_media["url"],
-        source_url=url,
-        is_video=is_video_file
+        source_url=primary_url,
+        extra_media=wp_extra_media
     )
 
-    result = {
-        "source_url": url,
+    print(f"\n[DONE] Grouped post published: {post['url']}")
+    return {
+        "source_url": primary_url,
         "title": title,
         "post_url": post["url"],
-        "post_id": post["id"],
-        "featured_image_id": featured_media["id"],
-        "flyer_url": flyer_media["url"],
+        "post_id": post["id"]
     }
 
-    print(f"\n[DONE] SUCCESS! Post published: {post['url']}")
-    return result
-
 
 # ──────────────────────────────────────────────
 # 7b. Uploaded Video Pipeline (no download step)

static/dashboard.js

@@ -99,11 +99,13 @@ async function submitJobs() {
 
     const urls = urlsText.split("\n").filter(u => u.trim() && !u.trim().startsWith("#"));
 
+    const groupMedia = document.getElementById("groupMedia").checked;
+
     try {
         const resp = await fetch("/api/jobs", {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ urls, mode })
+            body: JSON.stringify({ urls, mode, group_media: groupMedia })
         });
         const data = await resp.json();
 
@@ -219,10 +221,12 @@ async function submitUpload() {
         return;
     }
 
+    const groupMedia = document.getElementById("groupMedia").checked;
     const formData = new FormData();
     for (let i = 0; i < fileInput.files.length; i++) {
         formData.append("video", fileInput.files[i]);
     }
+    formData.append("group_media", groupMedia);
 
     const progressBar = document.getElementById("uploadProgressBar");
     const progressWrap = document.getElementById("uploadProgress");