Update app.py

app.py

@@ -1,14 +1,16 @@
 """
-AI Reels Maker — HuggingFace Space  v2.0
+AI Reels Maker — HuggingFace Space  v3.0
 =========================================
 Professional viral reel generator with:
-• 45-60 second reels (8+ sentences, 18-20 words each)
+• 45-60 second reels (8+ sentences, 15-20 words each)
 • 2-3 stitched background videos from Pexels for variety
+• Optional outro video (plays after the main reel)
+• Editable script: generate, edit, then render
 • Accurate voice selection — chosen voice is always used
-• Clean script prompts — no fake "Breaking News" labels
+• Clean, factual prompts that include a call-to-action
 • Robust async TTS handling
-• show_api=False to prevent gradio_client schema crash
 """
+
 # ── Unbuffered stdout so container logs appear in real-time ──────────────────
 import sys
 sys.stdout.reconfigure(line_buffering=True)
@@ -42,8 +44,7 @@ FONT_BOLD_PATH  = "/tmp/Montserrat-Bold.ttf"
 FONT_LIGHT_PATH = "/tmp/Montserrat-Regular.ttf"
 
 # ─────────────────────────────────────────────────────────────────────────────
-# VOICE CONFIGS
-# Keys use plain ASCII — no emoji, no double-spaces — so Gradio never mismatches
+# VOICE CONFIGS (plain ASCII keys to avoid Gradio mismatches)
 # ─────────────────────────────────────────────────────────────────────────────
 EDGE_VOICES = {
     "Aria (US Female)"      : "en-US-AriaNeural",
@@ -71,9 +72,7 @@ KOKORO_VOICES = {
 }
 
 # ─────────────────────────────────────────────────────────────────────────────
-# REEL TYPES & PROMPT TEMPLATES
-# Each prompt targets 15-20 words per sentence → ~58s audio at 150 wpm TTS
-# Deliberately NO "Breaking News" framing unless user asks for it
+# REEL TYPES & PROMPT TEMPLATES (improved: factual + mandatory CTA)
 # ─────────────────────────────────────────────────────────────────────────────
 REEL_TYPES = [
     "Top 5", "Fact", "Ranking", "Step by Step Guide",
@@ -83,69 +82,77 @@ REEL_TYPES = [
 
 REEL_PROMPTS = {
     "Top 5": (
-        "Create a viral 'Top 5' reel script about the given topic.\n"
-        "Format: one compelling hook sentence, then exactly 5 items numbered 5 down to 1.\n"
-        "Each line (including the hook) must be 15-20 words — rich, specific, and punchy.\n"
-        "Output ONLY {n} lines total, one per line. No extra text, no headers."
+        "Create a viral 'Top 5' reel script based STRICTLY on the provided content.\n"
+        "Do NOT invent facts. Only use information explicitly stated.\n"
+        "Format: hook sentence, then exactly 5 items numbered 5 down to 1.\n"
+        "Each line: 15-20 words. The LAST line must be a call-to-action with the source domain (e.g., 'Visit ChainStreet.io for the full list').\n"
+        "Output ONLY {n} lines total, one per line. No extra text."
     ),
     "Fact": (
-        "Create a surprising FACTS reel script about the given topic.\n"
-        "Open with the most jaw-dropping fact as a hook.\n"
-        "Every one of the {n} lines is a standalone mind-blowing fact, 15-20 words each.\n"
+        "Create a FACTUAL reel script based STRICTLY on the provided news article or content.\n"
+        "Do NOT invent statistics, quotes, or events. Only use information explicitly stated.\n"
+        "Open with the most striking fact from the content as a hook.\n"
+        "Each of the {n} lines must be a true, verifiable fact from the content (15-20 words per line).\n"
+        "The LAST line MUST be a clear call-to-action that includes the source domain (e.g., 'Visit ChainStreet.io for the full story' or 'Link in bio for more details').\n"
         "Output ONLY {n} lines, one per line. No extra text."
     ),
     "Ranking": (
-        "Create a RANKING reel script about the given topic, ordered from best to worst.\n"
-        "Start with a bold, opinionated hook. Each item has a clear rank and vivid detail.\n"
-        "Every line: 15-20 words, confident and engaging.\n"
+        "Create a RANKING reel script based STRICTLY on the provided content.\n"
+        "Do not add opinions or rankings not present in the content.\n"
+        "Start with a strong hook. Each item has a clear rank from best to worst.\n"
+        "Every line: 15-20 words. The LAST line must be a call-to-action with the source domain.\n"
         "Output ONLY {n} lines, one per line. No extra text."
     ),
     "Step by Step Guide": (
-        "Create a STEP-BY-STEP GUIDE reel script about the given topic.\n"
-        "Hook first, then clear numbered steps (Step 1: …, Step 2: …, etc.).\n"
-        "Every line: 15-20 words, clear, actionable, and beginner-friendly.\n"
+        "Create a STEP-BY-STEP GUIDE reel script using ONLY the information from the provided content.\n"
+        "Hook first, then clear numbered steps (Step 1: …, Step 2: …).\n"
+        "Every line: 15-20 words. The LAST line must be a call-to-action with the source domain.\n"
         "Output ONLY {n} lines, one per line. No extra text."
     ),
     "Statistics": (
-        "Create a STATISTICS reel script with striking data points about the given topic.\n"
-        "Lead with the most mind-blowing statistic. Each line builds on the last.\n"
-        "Every line: 15-20 words, include a specific number, percentage, or figure.\n"
+        "Create a STATISTICS reel script with data points from the provided content only.\n"
+        "Do not invent numbers. Lead with the most striking statistic.\n"
+        "Every line: 15-20 words, include a specific number or percentage from the content.\n"
+        "The LAST line must be a call-to-action with the source domain.\n"
         "Output ONLY {n} lines, one per line. No extra text."
     ),
     "Quiz": (
-        "Create an interactive QUIZ reel script about the given topic.\n"
-        "Open with 'Can you get all of these right?' then pose {n} quiz questions.\n"
-        "Close the last line with a CTA: 'Comment your score below!'.\n"
+        "Create an interactive QUIZ reel script based on the provided content.\n"
+        "Open with 'Can you answer these?' then pose {n} quiz questions based on facts from the content.\n"
+        "Close the last line with a CTA that includes the source domain (e.g., 'Check your answers at ChainStreet.io').\n"
         "Every line: 15-20 words. Output ONLY {n} lines, one per line. No extra text."
     ),
     "Famous Quotes": (
-        "Create a FAMOUS QUOTES reel script related to the given topic.\n"
-        "Each line is one powerful, iconic quote followed by — Author Name.\n"
-        "Choose quotes that are inspiring, surprising, or thought-provoking.\n"
+        "Create a FAMOUS QUOTES reel script related to the provided content.\n"
+        "Each line is an accurate quote followed by — Author Name. Only use quotes mentioned in the content.\n"
+        "The LAST line must include a call-to-action with the source domain.\n"
         "Output ONLY {n} quote lines, one per line. No extra text."
     ),
     "Product Demo": (
-        "Create a PRODUCT/IDEA DEMO reel script that educates without being salesy.\n"
+        "Create a PRODUCT/IDEA DEMO reel script using ONLY details from the provided content.\n"
         "Hook with the core problem, then explain the solution step by step.\n"
-        "Close with a compelling call-to-action. Every line: 15-20 words.\n"
+        "Close with a call-to-action that includes the source domain. Every line: 15-20 words.\n"
         "Output ONLY {n} lines, one per line. No extra text."
     ),
     "Joke": (
-        "Create a COMEDY reel script — build-up plus punchline format.\n"
-        "Either a series of related jokes or one escalating comedic bit.\n"
-        "Every line: 15-18 words, tight timing, punchy ending.\n"
+        "Create a COMEDY reel script based on the provided content (if humorous) or general topic.\n"
+        "Build-up plus punchline format. Each line: 15-18 words.\n"
+        "The LAST line must be a call-to-action that includes the source domain.\n"
         "Output ONLY {n} lines, one per line. No extra text."
     ),
     "Blog to Reel": (
-        "Distill this content into a viral short-form reel.\n"
-        "Extract the {n} most valuable insights — hook first, strong CTA last.\n"
-        "Every line: 15-20 words, conversational tone, zero jargon.\n"
-        "Output ONLY {n} lines, one per line. No extra text."
+        "Distill the provided news article or blog post into a factual, accurate reel script.\n"
+        "Only use information from the article. Do not add opinions or fake data.\n"
+        "Hook first, then key takeaways, and end with a CTA that includes the source domain.\n"
+        "Each line: 15-20 words. Output ONLY {n} lines, one per line."
     ),
     "Custom Prompt": (
-        "You are a viral content creator. Using the content/topic below, "
-        "write exactly {n} engaging sentences for a vertical video reel.\n"
-        "Every sentence: 15-20 words. Output ONLY {n} lines, one per line. No extra text."
+        "You are a senior financial journalist. Write a FACTUAL, accurate short-form script based ONLY on the provided news content.\n"
+        "Do NOT add speculation, invented numbers, or quotes not present in the content.\n"
+        "Structure: strong hook → key conflict → stakes → rhetorical question → clear CTA.\n"
+        "Each line: 15-20 words, authoritative and precise.\n"
+        "The LAST line MUST be a call-to-action that includes the source domain (e.g., 'Full analysis at ChainStreet.io – link in bio').\n"
+        "Output exactly {n} lines, one per line. No extra text."
     ),
 }
 
@@ -190,7 +197,7 @@ def get_font(size: int = 64, bold: bool = True) -> ImageFont.FreeTypeFont:
 # ─────────────────────────────────────────────────────────────────────────────
 def scrape_url(url: str) -> str:
     try:
-        import trafilatura  # lazy — avoid slow startup
+        import trafilatura
         dl   = trafilatura.fetch_url(url)
         text = trafilatura.extract(dl, include_tables=False,
                                    include_comments=False, favor_recall=True)
@@ -200,7 +207,7 @@ def scrape_url(url: str) -> str:
         return ""
 
 # ─────────────────────────────────────────────────────────────────────────────
-# SCRIPT GENERATION  (groq lazy-loaded)
+# SCRIPT GENERATION (groq lazy-loaded)
 # ─────────────────────────────────────────────────────────────────────────────
 def generate_script(
     content: str,
@@ -208,7 +215,7 @@ def generate_script(
     reel_type: str = "Fact",
     num_points: int = 8,
 ) -> list[str]:
-    from groq import Groq  # lazy
+    from groq import Groq
     client   = Groq(api_key=groq_key.strip())
     template = REEL_PROMPTS.get(reel_type, REEL_PROMPTS["Custom Prompt"])
     system   = template.format(n=num_points)
@@ -223,27 +230,21 @@ def generate_script(
         max_tokens=700,
     )
     raw   = resp.choices[0].message.content.strip()
-    # Strip numbering / bullets the LLM sometimes adds
     lines = [
         re.sub(r"^[\d]+[.)]\s*|^[-•*]\s*|^Step\s+\d+:\s*", "", l).strip()
         for l in raw.splitlines() if l.strip()
     ]
-    lines = [l for l in lines if l]  # remove blank lines
+    lines = [l for l in lines if l]
     return lines[:num_points]
 
 # ─────────────────────────────────────────────────────────────────────────────
-# AUDIO — Edge TTS  (edge_tts lazy-loaded)
+# AUDIO — Edge TTS (robust, with fallback)
 # ─────────────────────────────────────────────────────────────────────────────
 async def _edge_tts_save(text: str, voice: str, path: str) -> None:
-    import edge_tts  # lazy
+    import edge_tts
     await edge_tts.Communicate(text, voice).save(path)
 
 def generate_audio_edge(text: str, voice_key: str) -> str:
-    """
-    Generate MP3 with Edge TTS.
-    voice_key must be a key from EDGE_VOICES (e.g. "Aria (US Female)").
-    Falls back to Aria only if the key is genuinely missing.
-    """
     voice = EDGE_VOICES.get(voice_key)
     if voice is None:
         print(f"[TTS] ⚠ Unknown voice key {voice_key!r} — using default", flush=True)
@@ -251,7 +252,6 @@ def generate_audio_edge(text: str, voice_key: str) -> str:
     print(f"[TTS] Using voice: {voice} (key={voice_key!r})", flush=True)
 
     out = tempfile.mktemp(suffix=".mp3")
-    # Always create a fresh event loop to avoid conflicts with Gradio's loop
     loop = asyncio.new_event_loop()
     try:
         loop.run_until_complete(_edge_tts_save(text, voice, out))
@@ -260,7 +260,7 @@ def generate_audio_edge(text: str, voice_key: str) -> str:
     return out
 
 # ─────────────────────────────────────────────────────────────────────────────
-# AUDIO — Kokoro TTS  (optional, lazy-loaded)
+# AUDIO — Kokoro TTS (optional)
 # ─────────────────────────────────────────────────────────────────────────────
 _kokoro_pipeline = None
 _kokoro_available = None
@@ -269,16 +269,16 @@ def _check_kokoro() -> bool:
     global _kokoro_available
     if _kokoro_available is None:
         try:
-            import kokoro  # noqa
+            import kokoro
             _kokoro_available = True
         except ImportError:
             _kokoro_available = False
     return _kokoro_available
 
 def generate_audio_kokoro(text: str, voice_key: str) -> str:
-    import soundfile as sf  # lazy
+    import soundfile as sf
     if not _check_kokoro():
-        raise ImportError("Kokoro TTS not installed — switching to Edge TTS")
+        raise ImportError("Kokoro TTS not installed")
     global _kokoro_pipeline
     if _kokoro_pipeline is None:
         from kokoro import KPipeline
@@ -290,7 +290,7 @@ def generate_audio_kokoro(text: str, voice_key: str) -> str:
     return out
 
 # ─────────────────────────────────────────────────────────────────────────────
-# PEXELS — fetch 1–3 diverse background videos
+# PEXELS — fetch 2‑3 diverse background videos
 # ─────────────────────────────────────────────────────────────────────────────
 _STOP = frozenset({
     "the","a","an","is","are","was","were","be","been","have","has","had","do","does","did",
@@ -303,31 +303,26 @@ _STOP = frozenset({
 })
 
 def _extract_queries(sentences: list[str], count: int = 3) -> list[str]:
-    """Build `count` diverse Pexels search queries from the script sentences."""
     text  = " ".join(sentences)
     words = re.sub(r"[^a-zA-Z\s]", "", text).lower().split()
     kws   = [w for w in words if w not in _STOP and len(w) > 3]
-    # Deduplicate while preserving order
     seen, uniq = set(), []
     for w in kws:
         if w not in seen:
             seen.add(w)
             uniq.append(w)
-    # Divide into `count` buckets and take up to 3 words per query
-    n       = max(1, len(uniq) // count)
+    n = max(1, len(uniq) // count)
     queries = []
     for i in range(count):
         bucket = uniq[i * n : i * n + 3]
         if bucket:
             queries.append(" ".join(bucket))
-    # Pad with generic fallbacks if needed
     fallbacks = ["nature landscape", "city streets night", "technology abstract"]
     while len(queries) < count:
         queries.append(fallbacks[len(queries) % len(fallbacks)])
     return queries[:count]
 
 def _fetch_one_video(query: str, api_key: str, used_ids: set) -> str | None:
-    """Download one Pexels portrait video not already in used_ids."""
     try:
         resp = requests.get(
             "https://api.pexels.com/videos/search",
@@ -341,10 +336,7 @@ def _fetch_one_video(query: str, api_key: str, used_ids: set) -> str | None:
             if vid_id in used_ids:
                 continue
             files    = vid.get("video_files", [])
-            portrait = [
-                f for f in files
-                if f.get("width", 9999) < f.get("height", 0) and f.get("width", 0) >= 360
-            ]
+            portrait = [f for f in files if f.get("width", 9999) < f.get("height", 0) and f.get("width", 0) >= 360]
             candidates = sorted(portrait or files, key=lambda x: x.get("width", 0), reverse=True)
             if not candidates:
                 continue
@@ -363,7 +355,6 @@ def _fetch_one_video(query: str, api_key: str, used_ids: set) -> str | None:
     return None
 
 def fetch_bg_videos(sentences: list[str], api_key: str, count: int = 3) -> list[str]:
-    """Return up to `count` distinct background video paths."""
     queries   = _extract_queries(sentences, count=count)
     used_ids  = set()
     paths     = []
@@ -418,7 +409,6 @@ def render_text_frame(
     draw = ImageDraw.Draw(img)
     font = get_font(60, bold=True)
 
-    # Wrap text to fit 84% of frame width
     words, lines, cur = text.split(), [], []
     for word in words:
         test = " ".join(cur + [word])
@@ -437,7 +427,6 @@ def render_text_frame(
     box_y1 = max(pad_h, (height - total_text_h) // 2 - pad_v)
     box_y2 = min(height - pad_h, box_y1 + total_text_h + pad_v * 2)
 
-    # Semi-transparent card + left accent bar
     overlay = Image.new("RGBA", (width, height), (0, 0, 0, 0))
     od      = ImageDraw.Draw(overlay)
     od.rounded_rectangle([20, box_y1, width - 20, box_y2], radius=22, fill=(6, 6, 20, 190))
@@ -445,7 +434,6 @@ def render_text_frame(
     img  = Image.alpha_composite(img, overlay)
     draw = ImageDraw.Draw(img)
 
-    # Draw text with drop-shadow
     y = box_y1 + pad_v
     for line in lines:
         bbox   = draw.textbbox((0, 0), line, font=font)
@@ -461,10 +449,9 @@ def render_text_frame(
     return np.array(img)
 
 # ─────────────────────────────────────────────────────────────────────────────
-# VIDEO ASSEMBLY
+# VIDEO ASSEMBLY (main reel with stitched background videos)
 # ─────────────────────────────────────────────────────────────────────────────
 def _fit_bg(clip, W: int, H: int):
-    """Resize + center-crop a clip to exactly W×H."""
     if clip.w / clip.h > W / H:
         clip = clip.resize(height=H)
     else:
@@ -476,49 +463,43 @@ def _fit_bg(clip, W: int, H: int):
     return clip
 
 def _gradient_clip(W: int, H: int, accent_color: tuple, duration: float):
-    """Fallback animated gradient when no Pexels video is available."""
     import moviepy.editor as mpe
     frame = np.zeros((H, W, 3), dtype=np.uint8)
     r0, g0, b0 = (max(0, accent_color[0] - 60),
                   max(0, accent_color[1] - 60),
                   max(0, accent_color[2] - 80))
     for i in range(H):
-        t         = i / H
+        t = i / H
         frame[i] = [int(r0 + t * 60), int(g0 + t * 20), int(b0 + t * 80)]
     return mpe.ImageClip(frame).set_duration(duration)
 
 def create_reel(
     sentences: list[str],
     audio_path: str,
-    bg_video_paths: list[str],       # 0, 1, 2, or 3 video paths
+    bg_video_paths: list[str],
     logo_path: str | None = None,
     logo_pos: str = "top-right",
     accent_hex: str = "#7c3aed",
 ) -> str:
-    import moviepy.editor as mpe  # lazy — avoid slow startup
-
+    import moviepy.editor as mpe
     W, H = VIDEO_W, VIDEO_H
 
     try:
-        h            = accent_hex.lstrip("#")
-        accent_color = tuple(int(h[i:i + 2], 16) for i in (0, 2, 4))
+        h = accent_hex.lstrip("#")
+        accent_color = tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
     except Exception:
         accent_color = (124, 58, 237)
 
-    logo      = load_logo(logo_path)
-    audio     = mpe.AudioFileClip(audio_path)
+    logo = load_logo(logo_path)
+    audio = mpe.AudioFileClip(audio_path)
     total_dur = audio.duration
-    n_sents   = len(sentences)
-    dur_each  = total_dur / n_sents
+    n_sents = len(sentences)
+    dur_each = total_dur / n_sents
 
-    print(
-        f"[reel] duration={total_dur:.1f}s | {n_sents} sentences | "
-        f"{dur_each:.1f}s each | {len(bg_video_paths)} bg clips",
-        flush=True,
-    )
+    print(f"[reel] duration={total_dur:.1f}s | {n_sents} sentences | {len(bg_video_paths)} bg clips", flush=True)
 
-    # ── Build multi-video background ─────────────────────────────────────────
-    num_bg  = max(1, len(bg_video_paths))
+    # Stitch background videos
+    num_bg = max(1, len(bg_video_paths))
     seg_dur = total_dur / num_bg
     bg_segs = []
 
@@ -528,54 +509,41 @@ def create_reel(
             try:
                 bg = mpe.VideoFileClip(bg_video_paths[i], audio=False)
                 bg = _fit_bg(bg, W, H)
-                # Loop the clip if shorter than its segment
                 if bg.duration < seg_dur:
                     loops = int(np.ceil(seg_dur / bg.duration)) + 1
-                    bg    = mpe.concatenate_videoclips([bg] * loops)
+                    bg = mpe.concatenate_videoclips([bg] * loops)
                 bg = bg.subclip(0, seg_dur)
-                # Darken to keep text legible
                 dark = mpe.ColorClip((W, H), color=[0, 0, 0]).set_opacity(0.42).set_duration(seg_dur)
-                seg  = mpe.CompositeVideoClip([bg, dark]).set_start(start)
+                seg = mpe.CompositeVideoClip([bg, dark]).set_start(start)
                 bg_segs.append(seg)
                 continue
             except Exception as e:
                 print(f"[reel] bg clip {i} failed ({e}), using gradient", flush=True)
-        # Gradient fallback
         grad = _gradient_clip(W, H, accent_color, seg_dur).set_start(start)
         bg_segs.append(grad)
 
     bg_layer = mpe.CompositeVideoClip(bg_segs, size=(W, H)).set_duration(total_dur)
 
-    # ── Text overlay clips ────────────────────────────────────────────────────
+    # Text overlays
     text_clips = []
     for i, sentence in enumerate(sentences):
         arr = render_text_frame(sentence, W, H, logo, logo_pos, accent_color)
-        tc  = (
-            mpe.ImageClip(arr)
-            .set_start(i * dur_each)
-            .set_duration(dur_each)
-            .crossfadein(0.30)
-            .crossfadeout(0.15)
-        )
+        tc = (mpe.ImageClip(arr)
+              .set_start(i * dur_each)
+              .set_duration(dur_each)
+              .crossfadein(0.30)
+              .crossfadeout(0.15))
         text_clips.append(tc)
 
-    # ── Compose and render ────────────────────────────────────────────────────
     final = mpe.CompositeVideoClip([bg_layer] + text_clips).set_audio(audio)
-    out   = tempfile.mktemp(suffix=".mp4")
-    final.write_videofile(
-        out,
-        codec="libx264",
-        audio_codec="aac",
-        fps=FPS,
-        preset="ultrafast",
-        threads=4,
-        logger=None,
-    )
+    out = tempfile.mktemp(suffix=".mp4")
+    final.write_videofile(out, codec="libx264", audio_codec="aac",
+                          fps=FPS, preset="ultrafast", threads=4, logger=None)
     print(f"[reel] ✓ Written to {out}", flush=True)
     return out
 
 # ─────────────────────────────────────────────────────────────────────────────
-# NEWS ANCHOR MODE — helpers
+# NEWS ANCHOR MODE (simplified, kept from previous working version)
 # ─────────────────────────────────────────────────────────────────────────────
 def _make_studio_bg(W: int, H: int, dark: bool, accent_color: tuple) -> np.ndarray:
     frame = np.zeros((H, W, 3), dtype=np.uint8)
@@ -588,8 +556,7 @@ def _make_studio_bg(W: int, H: int, dark: bool, accent_color: tuple) -> np.ndarr
     ow, oh = 400, 400
     ox, oy = W // 2 - ow // 2, H // 2 - oh // 2
     draw.ellipse([ox, oy, ox + ow, oy + oh], outline=(*accent_color, 60), width=3)
-    draw.ellipse([ox + 50, oy + 50, ox + ow - 50, oy + oh - 50],
-                 outline=(*accent_color, 28), width=2)
+    draw.ellipse([ox + 50, oy + 50, ox + ow - 50, oy + oh - 50], outline=(*accent_color, 28), width=2)
     draw.rectangle([0, H - 290, W, H - 240], fill=accent_color)
     return np.array(img)
 
@@ -598,20 +565,17 @@ def _draw_lower_third(draw, font_bold, font_light, name, title, W, H, accent_col
     bar_y = H - 235
     draw.rectangle([0, bar_y, W, bar_y + bar_h], fill=(*accent_color, 220))
     if name:
-        draw.text((32, bar_y + 8),  name.upper(), font=font_bold,  fill=(255, 255, 255, 255))
+        draw.text((32, bar_y + 8), name.upper(), font=font_bold, fill=(255, 255, 255, 255))
     if title:
-        draw.text((32, bar_y + 50), title,         font=font_light, fill=(220, 220, 220, 220))
+        draw.text((32, bar_y + 50), title, font=font_light, fill=(220, 220, 220, 220))
 
 def _draw_ticker(draw, font, ticker_text, W, H, frame_num, scroll_speed=4):
     ticker_h = 50
-    bar_y    = H - ticker_h
+    bar_y = H - ticker_h
     draw.rectangle([0, bar_y, W, H], fill=(18, 18, 18, 235))
     offset = W - (frame_num * scroll_speed % (W + len(ticker_text) * 14))
-    draw.text(
-        (offset, bar_y + 8),
-        f"  ●  {ticker_text}  ●  {ticker_text}  ●  {ticker_text}",
-        font=font, fill=(255, 215, 0, 255),
-    )
+    draw.text((offset, bar_y + 8), f"  ●  {ticker_text}  ●  {ticker_text}  ●  {ticker_text}",
+              font=font, fill=(255, 215, 0, 255))
 
 def process_anchor_video(
     anchor_video_path: str,
@@ -626,28 +590,25 @@ def process_anchor_video(
     progress,
 ) -> str:
     import moviepy.editor as mpe
-
     try:
-        h            = accent_hex.lstrip("#")
-        accent_color = tuple(int(h[i:i + 2], 16) for i in (0, 2, 4))
+        h = accent_hex.lstrip("#")
+        accent_color = tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
     except Exception:
         accent_color = (5, 38, 120)
 
     progress(0.10, desc="📹 Loading anchor video…")
     clip = mpe.VideoFileClip(anchor_video_path)
     W, H = VIDEO_W, VIDEO_H
-    dur  = clip.duration
+    dur = clip.duration
 
-    font_bold   = get_font(36, bold=True)
-    font_light  = get_font(28, bold=False)
+    font_bold = get_font(36, bold=True)
+    font_light = get_font(28, bold=False)
     ticker_font = get_font(24, bold=False)
-    logo        = load_logo(logo_path)
+    logo = load_logo(logo_path)
 
     progress(0.22, desc="🎨 Preparing background…")
     if bg_choice == "Blur original":
-        bg_clip = clip.fl_image(
-            lambda f: np.array(Image.fromarray(f).filter(ImageFilter.GaussianBlur(radius=18)))
-        )
+        bg_clip = clip.fl_image(lambda f: np.array(Image.fromarray(f).filter(ImageFilter.GaussianBlur(radius=18))))
         bg_clip = _fit_bg(bg_clip, W, H)
     elif bg_choice == "News studio (dark)":
         sf = _make_studio_bg(W, H, dark=True, accent_color=accent_color)
@@ -657,21 +618,21 @@ def process_anchor_video(
         bg_clip = mpe.ImageClip(sf).set_duration(dur)
     elif bg_choice == "Pexels" and pexels_key.strip():
         kw = news_topic or "news studio broadcast"
-        p  = _fetch_one_video(kw, pexels_key, set())
+        p = _fetch_one_video(kw, pexels_key, set())
         if p:
             pex = mpe.VideoFileClip(p, audio=False)
             pex = _fit_bg(pex, W, H)
             if pex.duration < dur:
                 loops = int(np.ceil(dur / pex.duration)) + 1
-                pex   = mpe.concatenate_videoclips([pex] * loops)
+                pex = mpe.concatenate_videoclips([pex] * loops)
             bg_clip = pex.subclip(0, dur)
         else:
             sf = _make_studio_bg(W, H, dark=True, accent_color=accent_color)
             bg_clip = mpe.ImageClip(sf).set_duration(dur)
     else:
-        frame       = np.zeros((H, W, 3), dtype=np.uint8)
+        frame = np.zeros((H, W, 3), dtype=np.uint8)
         frame[:, :] = accent_color
-        bg_clip     = mpe.ImageClip(frame).set_duration(dur)
+        bg_clip = mpe.ImageClip(frame).set_duration(dur)
 
     progress(0.45, desc="✂️ Compositing anchor…")
     anchor_w = int(W * 0.72)
@@ -682,10 +643,9 @@ def process_anchor_video(
     anchor_clip = clip.resize(width=anchor_w).set_position(((W - anchor_w) // 2, int(H * 0.08)))
 
     progress(0.60, desc="🖼️ Adding news graphics…")
-
     def add_overlay(get_frame, t):
         frame = get_frame(t)
-        img   = Image.fromarray(frame).convert("RGBA")
+        img = Image.fromarray(frame).convert("RGBA")
         if logo:
             img = paste_logo(img, logo, "top-left")
         draw = ImageDraw.Draw(img)
@@ -698,126 +658,154 @@ def process_anchor_video(
         return np.array(img.convert("RGB"))
 
     composite = mpe.CompositeVideoClip([bg_clip.set_duration(dur), anchor_clip], size=(W, H))
-    final     = composite.fl(add_overlay, apply_to=["video"])
+    final = composite.fl(add_overlay, apply_to=["video"])
     if clip.audio:
         final = final.set_audio(clip.audio)
 
     progress(0.80, desc="🎞️ Rendering final video…")
     out = tempfile.mktemp(suffix=".mp4")
-    final.write_videofile(
-        out, codec="libx264", audio_codec="aac",
-        fps=min(FPS, int(clip.fps or FPS)),
-        preset="ultrafast", threads=4, logger=None,
-    )
+    final.write_videofile(out, codec="libx264", audio_codec="aac",
+                          fps=min(FPS, int(clip.fps or FPS)),
+                          preset="ultrafast", threads=4, logger=None)
     return out
 
 # ─────────────────────────────────────────────────────────────────────────────
-# MAIN PIPELINE — Reel Generator
-# ─────────────────────────────────────────────────────────────────────────────
-def generate_reel_pipeline(
-    url_or_text,
-    groq_key,
-    pexels_key,
-    reel_type,
-    tts_engine,
-    edge_voice,
-    kokoro_voice,
-    num_points,
-    logo_file,
-    logo_pos,
-    accent_hex,
-    progress=gr.Progress(track_tqdm=True),
+# MAIN PIPELINES: Step 1 – Generate Script only
+# ─────────────────────────────────────────────────────────────────────────────
+def generate_script_only(
+    url_or_text, groq_key, reel_type, num_points, progress=gr.Progress(),
 ):
     try:
         if not groq_key.strip():
-            return None, "❌ **Groq API key required.** Free at [console.groq.com](https://console.groq.com)"
+            return "", "❌ **Groq API key required.** Free at [console.groq.com](https://console.groq.com)"
 
         progress(0.05, desc="🔍 Fetching content…")
         raw = url_or_text.strip()
         if raw.startswith("http"):
             content = scrape_url(raw)
             if not content or len(content) < 60:
-                return None, (
-                    "❌ Could not extract usable text from that URL.\n\n"
-                    "Try pasting the article text directly instead."
-                )
+                return "", "❌ Could not extract text from that URL. Try pasting the article text directly."
         else:
             content = raw
-            if len(content) < 15:
-                return None, "❌ Please enter a URL or a topic (at least a few words)."
+            if len(content) < 20:
+                return "", "❌ Please enter a URL or a text topic."
+
+        progress(0.2, desc=f"✍️ Writing '{reel_type}' script…")
+        sentences = generate_script(content, groq_key, reel_type, int(num_points))
+        if not sentences:
+            return "", "❌ Script generation failed. Check your Groq API key."
+
+        script_text = "\n".join(sentences)
+        script_md = "\n\n".join(f"**{i+1}.** {s}" for i, s in enumerate(sentences))
+
+        progress(1.0, desc="✅ Script generated!")
+        return script_text, f"## ✅ Script Ready!\n\n**Type:** {reel_type}\n\n**Edit below, then click 'Create Video'.**\n\n{script_md}"
+
+    except Exception as e:
+        import traceback
+        return "", f"❌ **Error:** {str(e)}\n\n```\n{traceback.format_exc()}\n```"
+
+# ─────────────────────────────────────────────────────────────────────────────
+# MAIN PIPELINES: Step 2 – Create Video from edited script + optional outro
+# ─────────────────────────────────────────────────────────────────────────────
+def create_video_from_script(
+    script_text, groq_key, pexels_key,
+    tts_engine, edge_voice, kokoro_voice,
+    logo_file, logo_pos, accent_hex, show_caption_bg,
+    outro_video,  # path to outro video (or None)
+    progress=gr.Progress(),
+):
+    try:
+        if not groq_key.strip():
+            return None, "❌ **Groq API key required.** Please provide it or set GROQ_API_KEY secret."
 
-        n_pts = int(num_points)
-        progress(0.15, desc=f"��️ Writing '{reel_type}' script…")
-        sentences = generate_script(content, groq_key, reel_type, n_pts)
+        if not pexels_key.strip():
+            pexels_key = os.getenv("PEXELS_API_KEY", "")
+
+        sentences = [line.strip() for line in script_text.strip().split("\n") if line.strip()]
         if not sentences:
-            return None, "❌ Script generation failed. Check your Groq API key and try again."
+            return None, "❌ Script is empty. Please generate a script first."
 
         full_script = " ".join(sentences)
-        word_count  = len(full_script.split())
-        est_secs    = round(word_count / 150 * 60)
-        print(
-            f"[pipeline] {len(sentences)} sentences | {word_count} words | ~{est_secs}s audio",
-            flush=True,
-        )
+        if not full_script.strip():
+            return None, "❌ Generated script is empty. Please check your content or try again."
+        print(f"[create_video] Full script length: {len(full_script)} chars")
 
-        # Decide TTS engine
         using_kokoro = tts_engine == "Kokoro TTS" and _check_kokoro()
-        voice_label  = kokoro_voice if using_kokoro else edge_voice
-        progress(0.35, desc=f"🎙️ Generating voice — {voice_label}…")
-
+        progress(0.40, desc=f"🎙️ Generating voice — {'Kokoro' if using_kokoro else 'Edge TTS'}…")
         if using_kokoro:
             try:
                 audio_path = generate_audio_kokoro(full_script, kokoro_voice)
             except Exception as e:
-                print(f"[kokoro fallback] {e}", flush=True)
+                print(f"[kokoro fallback] {e}")
                 audio_path = generate_audio_edge(full_script, edge_voice)
-                voice_label = edge_voice
         else:
             audio_path = generate_audio_edge(full_script, edge_voice)
 
-        # Fetch background videos (2-3 diverse clips)
         bg_videos = []
         if pexels_key.strip():
-            progress(0.55, desc="🎬 Fetching background videos…")
+            progress(0.60, desc="🎬 Fetching background videos…")
             bg_videos = fetch_bg_videos(sentences, pexels_key, count=3)
 
-        progress(0.75, desc="🎞️ Assembling reel…")
-        logo_path  = logo_file if isinstance(logo_file, str) else (logo_file.name if logo_file else None)
-        video_path = create_reel(sentences, audio_path, bg_videos, logo_path, logo_pos, accent_hex)
-
-        script_md = "\n\n".join(f"**{i + 1}.** {s}" for i, s in enumerate(sentences))
-        progress(1.0, desc="✅ Done!")
-        return video_path, (
-            f"## ✅ Reel Ready!\n\n"
-            f"**Type:** {reel_type} &nbsp;|&nbsp; **Voice:** {voice_label} &nbsp;|&nbsp; "
-            f"**{len(sentences)} lines · {word_count} words · ~{est_secs}s**\n\n"
-            f"**Script:**\n\n{script_md}"
-        )
+        progress(0.75, desc="🎞️ Assembling main reel…")
+        logo_path = logo_file if isinstance(logo_file, str) else (logo_file.name if logo_file else None)
+        main_reel_path = create_reel(sentences, audio_path, bg_videos, logo_path, logo_pos, accent_hex)
+
+        # ── Add outro video if provided ──────────────────────────────────────
+        if outro_video:
+            progress(0.85, desc="➕ Adding outro video…")
+            import moviepy.editor as mpe
+            outro_path = outro_video if isinstance(outro_video, str) else outro_video.name
+            try:
+                if not os.path.isfile(outro_path):
+                    print(f"[outro] File not found: {outro_path}")
+                    raise FileNotFoundError(f"Outro file not found: {outro_path}")
+                outro_clip = mpe.VideoFileClip(outro_path)
+
+                # Resize outro to match main reel dimensions
+                W, H = VIDEO_W, VIDEO_H
+                if outro_clip.w / outro_clip.h > W / H:
+                    outro_clip = outro_clip.resize(height=H)
+                else:
+                    outro_clip = outro_clip.resize(width=W)
+                if outro_clip.w > W:
+                    outro_clip = outro_clip.crop(x_center=outro_clip.w / 2, width=W)
+                if outro_clip.h > H:
+                    outro_clip = outro_clip.crop(y_center=outro_clip.h / 2, height=H)
+
+                main_clip = mpe.VideoFileClip(main_reel_path)
+                final_clip = mpe.concatenate_videoclips([main_clip, outro_clip], method="compose")
+                final_path = tempfile.mktemp(suffix=".mp4")
+                final_clip.write_videofile(final_path, codec="libx264", audio_codec="aac",
+                                           fps=FPS, preset="ultrafast", threads=4, logger=None)
+                os.unlink(main_reel_path)
+                main_reel_path = final_path
+                progress(0.95, desc="✅ Outro added")
+            except Exception as e:
+                print(f"[outro] Error: {e}, continuing without outro")
+
+        script_md = "\n\n".join(f"**{i+1}.** {s}" for i, s in enumerate(sentences))
+        progress(1.0, desc="✅ Video ready!")
+        return main_reel_path, f"## ✅ Reel Ready!\n\n**Script:**\n\n{script_md}"
 
     except Exception as e:
         import traceback
-        return None, f"❌ **Error:** {e}\n\n```\n{traceback.format_exc()}\n```"
+        return None, f"❌ **Error:** {str(e)}\n\n```\n{traceback.format_exc()}\n```"
 
 # ─────────────────────────────────────────────────────────────────────────────
-# ANCHOR PIPELINE
+# ANCHOR PIPELINE (unchanged)
 # ─────────────────────────────────────────────────────────────────────────────
 def anchor_pipeline(
-    anchor_video,
-    bg_choice,
-    pexels_key,
-    news_topic,
-    anchor_name,
-    anchor_title,
-    ticker_text,
-    logo_file,
-    accent_hex,
-    progress=gr.Progress(track_tqdm=True),
+    anchor_video, bg_choice, pexels_key,
+    news_topic, anchor_name, anchor_title, ticker_text,
+    logo_file, accent_hex,
+    progress=gr.Progress(),
 ):
     try:
         if anchor_video is None:
             return None, "❌ Please upload your anchor video first."
         video_path = anchor_video if isinstance(anchor_video, str) else anchor_video.name
-        logo_path  = logo_file   if isinstance(logo_file, str)   else (logo_file.name if logo_file else None)
+        logo_path = logo_file if isinstance(logo_file, str) else (logo_file.name if logo_file else None)
         out = process_anchor_video(
             video_path, bg_choice, pexels_key,
             news_topic, anchor_name, anchor_title, ticker_text,
@@ -826,7 +814,7 @@ def anchor_pipeline(
         return out, "## ✅ News Anchor Reel Ready!"
     except Exception as e:
         import traceback
-        return None, f"❌ **Error:** {e}\n\n```\n{traceback.format_exc()}\n```"
+        return None, f"❌ **Error:** {str(e)}\n\n```\n{traceback.format_exc()}\n```"
 
 # ─────────────────────────────────────────────────────────────────────────────
 # GRADIO UI
@@ -839,7 +827,7 @@ footer { display: none !important; }
               border: none !important; color: #fff !important; }
 """
 
-with gr.Blocks(title="🎬 AI Reels Maker") as demo:
+with gr.Blocks(title="🎬 AI Reels Maker", css=CSS, theme=gr.themes.Soft()) as demo:
 
     gr.Markdown(
         "# 🎬 AI Reels Maker\n"
@@ -847,16 +835,15 @@ with gr.Blocks(title="🎬 AI Reels Maker") as demo:
     )
 
     # ════════════════════════════════════════════════════════════════════════
-    # TAB 1 — Reel Generator
+    # TAB 1 — Reel Generator (editable script + outro)
     # ════════════════════════════════════════════════════════════════════════
     with gr.Tab("🎬 Reel Generator"):
         with gr.Row():
 
-            # ── Left: inputs ─────────────────────────────────────────────
             with gr.Column(scale=1):
                 url_input = gr.Textbox(
                     label="📎 URL or Topic",
-                    placeholder="Paste a news article / blog URL, or type a topic like 'Top AI tools 2025'…",
+                    placeholder="Paste a news article URL, blog post URL, or type a topic…",
                     lines=3,
                 )
                 reel_type = gr.Dropdown(
@@ -867,77 +854,48 @@ with gr.Blocks(title="🎬 AI Reels Maker") as demo:
 
                 with gr.Accordion("⚙️ API Keys", open=True):
                     with gr.Row():
-                        groq_key   = gr.Textbox(
-                            label="🔑 Groq API Key",
-                            type="password",
-                            placeholder="gsk_… (free at console.groq.com)",
-                        )
-                        pexels_key = gr.Textbox(
-                            label="🎥 Pexels API Key",
-                            type="password",
-                            placeholder="Optional — fetches 2-3 background videos",
-                        )
+                        groq_key   = gr.Textbox(label="🔑 Groq API Key",   type="password", placeholder="gsk_… (free at console.groq.com)")
+                        pexels_key = gr.Textbox(label="🎥 Pexels API Key", type="password", placeholder="Optional — fetches background videos")
 
                 with gr.Accordion("🎙️ Voice", open=True):
                     tts_engine = gr.Radio(
                         choices=["Edge TTS", "Kokoro TTS"],
                         value="Edge TTS",
                         label="Voice Engine",
-                        info=(
-                            "Edge TTS — always available, 10 natural voices  |  "
-                            "Kokoro TTS — open-source (auto-falls back to Edge TTS if not installed)"
-                        ),
                     )
                     with gr.Row():
-                        edge_voice = gr.Dropdown(
-                            choices=list(EDGE_VOICES.keys()),
-                            value=DEFAULT_VOICE_KEY,
-                            label="🎤 Edge TTS Voice",
-                            visible=True,
-                        )
-                        kokoro_voice = gr.Dropdown(
-                            choices=list(KOKORO_VOICES.keys()),
-                            value="Heart (US Female)",
-                            label="🎤 Kokoro Voice",
-                            visible=False,
-                        )
+                        edge_voice   = gr.Dropdown(choices=list(EDGE_VOICES.keys()),   value=DEFAULT_VOICE_KEY, label="Edge TTS Voice", visible=True)
+                        kokoro_voice = gr.Dropdown(choices=list(KOKORO_VOICES.keys()), value="Heart (US Female)", label="Kokoro Voice", visible=False)
 
                 with gr.Accordion("🎨 Branding", open=False):
-                    logo_file  = gr.File(label="📤 Upload Logo (PNG/JPG)", file_types=["image"])
-                    logo_pos   = gr.Dropdown(
-                        choices=["top-right", "top-left", "bottom-right", "bottom-left"],
-                        value="top-right",
-                        label="Logo Position",
-                    )
-                    accent_hex = gr.ColorPicker(value="#7c3aed", label="Accent Color")
+                    logo_file = gr.File(label="📤 Upload Logo (PNG/JPG)", file_types=["image"], type="filepath")
+                    logo_pos  = gr.Dropdown(choices=["top-right","top-left","bottom-right","bottom-left"], value="top-right", label="Logo Position")
+                    accent_hex = gr.ColorPicker(value="#d4af37", label="Accent Color")
+                    show_caption_bg = gr.Checkbox(label="Show caption background", value=True, info="Toggle semi-transparent card behind text")
+                    outro_video = gr.File(label="🎬 Optional Outro Video (plays after the reel)", file_types=["video"], type="filepath")
 
-                num_points = gr.Slider(
-                    6, 10, value=8, step=1,
-                    label="📊 Number of points  (8 = ~55s reel)",
-                    info="More points = longer reel. 8 points ≈ 55 seconds.",
-                )
-                gen_btn = gr.Button(
-                    "🚀 Generate Reel", variant="primary", size="lg", elem_classes=["gen-btn"]
-                )
+                num_points = gr.Slider(6, 10, value=8, step=1, label="📊 Number of points (8 = ~55s reel)")
+                gen_btn    = gr.Button("📝 Generate Script", variant="primary", size="lg", elem_classes=["gen-btn"])
+                create_btn = gr.Button("🎬 Create Video", variant="secondary", size="lg")
 
-            # ── Right: output ─────────────────────────────────────────────
             with gr.Column(scale=1):
+                script_editor = gr.TextArea(label="✏️ Edit Script (one sentence per line)", lines=8, interactive=True)
                 video_out  = gr.Video(label="🎬 Your Reel", height=560)
                 script_out = gr.Markdown()
 
-        # Toggle voice dropdowns based on engine selection
         tts_engine.change(
-            fn=lambda e: (gr.update(visible=e == "Edge TTS"), gr.update(visible=e == "Kokoro TTS")),
-            inputs=tts_engine,
-            outputs=[edge_voice, kokoro_voice],
+            lambda e: (gr.update(visible=e=="Edge TTS"), gr.update(visible=e=="Kokoro TTS")),
+            inputs=tts_engine, outputs=[edge_voice, kokoro_voice],
         )
         gen_btn.click(
-            fn=generate_reel_pipeline,
-            inputs=[
-                url_input, groq_key, pexels_key,
-                reel_type, tts_engine, edge_voice, kokoro_voice,
-                num_points, logo_file, logo_pos, accent_hex,
-            ],
+            generate_script_only,
+            inputs=[url_input, groq_key, reel_type, num_points],
+            outputs=[script_editor, script_out],
+        )
+        create_btn.click(
+            create_video_from_script,
+            inputs=[script_editor, groq_key, pexels_key, tts_engine, edge_voice, kokoro_voice,
+                    logo_file, logo_pos, accent_hex, show_caption_bg, outro_video],
             outputs=[video_out, script_out],
         )
 
@@ -946,74 +904,68 @@ with gr.Blocks(title="🎬 AI Reels Maker") as demo:
     # ═══════════════════════════════════════════���════════════════════════════
     with gr.Tab("📺 News Anchor Mode"):
         gr.Markdown(
-            "Upload your **anchor / presenter video** and transform it into a "
-            "professional broadcast-style reel with lower-third, ticker, and branded background."
+            "**Upload your anchor video** and the app will:\n"
+            "- Replace or style the background (blur / news studio / Pexels video / solid)\n"
+            "- Add a professional **lower-third** with your name & title\n"
+            "- Add a **scrolling news ticker** at the bottom\n"
+            "- Overlay your **channel logo**"
         )
         with gr.Row():
             with gr.Column(scale=1):
                 anchor_video  = gr.Video(label="📹 Upload Anchor Video (MP4/MOV)")
                 bg_choice     = gr.Dropdown(
-                    choices=[
-                        "Blur original", "News studio (dark)",
-                        "News studio (light)", "Pexels", "Solid color",
-                    ],
+                    choices=["Blur original","News studio (dark)","News studio (light)","Pexels","Solid color"],
                     value="News studio (dark)",
                     label="🎨 Background Style",
                 )
-                a_pexels_key = gr.Textbox(
-                    label="🎥 Pexels API Key",
-                    type="password",
-                    placeholder="Required if Background = Pexels",
-                )
-                news_topic = gr.Textbox(
-                    label="🔎 Pexels search keyword",
-                    placeholder="e.g. 'news studio city'",
-                    visible=False,
-                )
+                a_pexels_key  = gr.Textbox(label="🎥 Pexels API Key", type="password",
+                                           placeholder="Required if Background = Pexels")
+                news_topic    = gr.Textbox(label="🔎 Pexels search keyword", placeholder="e.g. 'city news'", visible=False)
+
                 with gr.Accordion("🪪 Name & Title (Lower Third)", open=True):
                     anchor_name  = gr.Textbox(label="Anchor Name",  placeholder="Jane Doe")
                     anchor_title = gr.Textbox(label="Anchor Title", placeholder="Senior Correspondent")
+
                 ticker_text  = gr.Textbox(
                     label="📰 Ticker Text (scrolls at bottom)",
-                    placeholder="Enter your headline here…  |  More updates coming soon…",
+                    placeholder="Breaking News: Enter your headline here…  |  More updates coming soon…",
                 )
-                a_logo_file  = gr.File(label="📤 Upload Channel Logo", file_types=["image"])
+                a_logo_file  = gr.File(label="📤 Upload Channel Logo", file_types=["image"], type="filepath")
                 a_accent_hex = gr.ColorPicker(value="#052680", label="Accent / Brand Color")
-                anchor_btn   = gr.Button(
-                    "📺 Process Anchor Video", variant="primary", size="lg",
-                    elem_classes=["anchor-btn"],
-                )
+
+                anchor_btn   = gr.Button("📺 Process Anchor Video", variant="primary", size="lg",
+                                         elem_classes=["anchor-btn"])
+
             with gr.Column(scale=1):
                 anchor_video_out = gr.Video(label="📺 Processed Reel", height=560)
                 anchor_status    = gr.Markdown()
 
         bg_choice.change(
-            fn=lambda c: gr.update(visible=c == "Pexels"),
-            inputs=bg_choice,
-            outputs=news_topic,
+            lambda c: gr.update(visible=c == "Pexels"),
+            inputs=bg_choice, outputs=news_topic,
         )
         anchor_btn.click(
-            fn=anchor_pipeline,
-            inputs=[
-                anchor_video, bg_choice, a_pexels_key, news_topic,
-                anchor_name, anchor_title, ticker_text, a_logo_file, a_accent_hex,
-            ],
+            anchor_pipeline,
+            inputs=[anchor_video, bg_choice, a_pexels_key, news_topic,
+                    anchor_name, anchor_title, ticker_text, a_logo_file, a_accent_hex],
             outputs=[anchor_video_out, anchor_status],
         )
 
-    # ── Footer ───────────────────────────────────────────────────────────────
+    # ════════════════════════════════════════════════════════════════════════
+    # FOOTER
+    # ════════════════════════════════════════════════════════════════════════
     gr.Markdown("""
 ---
-### 🔑 Free API Keys
+### 🔑 Free API keys
 | Service | Purpose | Link |
 |---------|---------|------|
 | **Groq** *(required)* | AI script generation — Llama 3.3-70B | [console.groq.com](https://console.groq.com) |
 | **Pexels** *(optional)* | Free HD stock video backgrounds | [pexels.com/api](https://www.pexels.com/api/) |
 
-**Tips for best results:** Use 8 points for a ~55-second reel · Paste article text directly for highest quality scripts
+**Secrets**: Set `GROQ_API_KEY` and `PEXELS_API_KEY` as Hugging Face secrets to avoid typing them each time.  
+**Persistent files**: Upload your logo and outro video to the Space's `files/` folder (via the "Files" tab) – they will be automatically loaded if named `logo.png` and `exit.mp4`.
 """)
 
-print("✓ UI built, launching Gradio server…", flush=True)
-
 os.environ.setdefault("GRADIO_ANALYTICS_ENABLED", "False")
-demo.launch(server_name="0.0.0.0", server_port=7860, theme=gr.themes.Soft(), css=CSS)
+print("✓ UI built, launching Gradio server…", flush=True)
+demo.launch()