[UPLOAD] Sync Android Times articles archive (part 8)

migrate_videos_to_articles.py

@@ -0,0 +1,155 @@
+import os
+import sys
+import re
+import shutil
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+ARTICLES_DIR = SCRIPT_DIR
+NEWSVIDEO_DIR = r"C:\Android Times\newsvideo"
+MEDIA_BUNDLE_DIR = r"C:\Android Times\media_bundle\news_videos"
+
+def extract_main_word(title):
+    title = title.replace('_', ' ').replace(',', ' ')
+    is_ja = any(ord(char) > 0x3000 for char in title)
+    cleaned = re.sub(r'\s*-\s*[^-\s]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', title, flags=re.IGNORECASE)
+    cleaned = re.sub(r'_[^_]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', cleaned, flags=re.IGNORECASE)
+    blacklisted = ["ai", "artificial intelligence", "人工知能", "生成ai", "生成系ai"]
+    def is_valid(w): return w and w.strip().lower() not in blacklisted
+
+    quotes_ja = re.findall(r'「([^」]+)」', cleaned)
+    for q in quotes_ja:
+        if is_valid(q): return q
+    quotes_en = re.findall(r'["\']([^"\']+)["\']', cleaned)
+    for q in quotes_en:
+        if len(q) < 25 and is_valid(q): return q
+
+    known_keywords = ["OpenAI", "Google", "Amazon", "Bezos", "Trump", "Anthropic", "Microsoft", "Apple", "Nvidia", "Meta", "Musk", "大谷", "オオタニ", "大谷翔平", "小田急", "ソニー", "ソフトバンク", "ChatGPT", "Claude", "IOWN", "サカナAI"]
+    for kw in known_keywords:
+        if kw.lower() in cleaned.lower() and is_valid(kw):
+            m = re.search(re.escape(kw), cleaned, re.IGNORECASE)
+            if m: return m.group(0)
+
+    if is_ja:
+        katakana = re.findall(r'[\u30a1-\u30fc]{2,}', cleaned)
+        for k in katakana:
+            if is_valid(k): return k
+        kanji = re.findall(r'[\u4e00-\u9fff]{2,}', cleaned)
+        for k in kanji:
+            if k not in ["米国", "日本", "市場", "世界", "政府", "計画", "導入"] and is_valid(k): return k
+        if kanji:
+            for k in kanji:
+                if is_valid(k): return k
+        alpha = re.findall(r'[a-zA-Z0-9]{2,}', cleaned)
+        for a in alpha:
+            if is_valid(a): return a
+    else:
+        words = re.findall(r'\b[A-Z][a-zA-Z0-9]*\b', cleaned)
+        if words:
+            for w in words:
+                if w.lower() not in ["a", "an", "the", "in", "on", "at", "for", "to", "of", "and", "or", "but", "with", "by", "is", "are", "was", "were"] and is_valid(w):
+                    return w
+            for w in words:
+                if is_valid(w): return w
+    first_token = re.search(r'\w+', cleaned)
+    if first_token and is_valid(first_token.group(0)): return first_token.group(0)
+    return ""
+
+def safe_filename(name, max_len=40):
+    main_word = extract_main_word(name).strip()
+    cleaned = name.replace('_', ' ').replace(',', ' ')
+    cleaned = re.sub(r'[\\/*?:"<>|\'\`\(\)\[\]]', ' ', cleaned)
+    cleaned = re.sub(r'\s+', ' ', cleaned).strip()
+    if main_word:
+        if cleaned.lower().startswith(main_word.lower()):
+            final_title = cleaned
+        else:
+            final_title = f"{main_word} {cleaned}"
+    else:
+        final_title = cleaned
+    final_title = re.sub(r'\s+', ' ', final_title).strip()
+    if len(final_title) > max_len:
+        final_title = final_title[:max_len].strip()
+        final_title = re.sub(r'[\s\.,\-_\+!@#\$%^&\*]+$', '', final_title)
+    return final_title
+
+def find_all_article_dirs(base_dir):
+    article_dirs = []
+    for root, dirs, files in os.walk(base_dir):
+        if any(f.endswith('.md') for f in files) or any(f.endswith('.json') for f in files):
+            if root != base_dir and os.path.basename(root) not in ['sources', 'images', '__pycache__', 'temp']:
+                article_dirs.append(root)
+    return article_dirs
+
+def migrate_videos():
+    print("=== Starting Video Migration to Article Directories ===")
+    article_dirs = find_all_article_dirs(ARTICLES_DIR)
+    print(f"Discovered {len(article_dirs)} article directories.")
+
+    safe_to_dir = {}
+    folder_to_dir = {}
+    for adir in article_dirs:
+        fname = os.path.basename(adir)
+        sname = safe_filename(fname)
+        safe_to_dir[sname.lower()] = adir
+        folder_to_dir[fname.lower()] = adir
+
+    COMFY_VIDEO_DIR = r"C:\ComfyUI\output\video"
+    source_dirs = [NEWSVIDEO_DIR, MEDIA_BUNDLE_DIR, COMFY_VIDEO_DIR]
+    migrated_count = 0
+
+    for sdir in source_dirs:
+        if not os.path.exists(sdir):
+            continue
+        print(f"\nScanning source directory: {sdir}")
+        for video_file in os.listdir(sdir):
+            if not video_file.lower().endswith('.mp4'):
+                continue
+            src_path = os.path.join(sdir, video_file)
+            base_name = os.path.splitext(video_file)[0]
+            # Strip ComfyUI counter suffix like _00001_
+            base_name = re.sub(r'_\d{5}_$', '', base_name)
+            
+            size = "middle"
+            prefix = base_name
+            for s in ["_short", "_middle", "_long"]:
+                if base_name.endswith(s):
+                    size = s[1:]
+                    prefix = base_name[:-len(s)]
+                    break
+
+            norm_prefix = prefix.strip().lower()
+            target_dir = None
+
+            if norm_prefix in folder_to_dir:
+                target_dir = folder_to_dir[norm_prefix]
+            elif norm_prefix in safe_to_dir:
+                target_dir = safe_to_dir[norm_prefix]
+            else:
+                words = [w.lower() for w in re.findall(r'[a-zA-Z0-9]+', prefix) if len(w) >= 3]
+                if words:
+                    for adir in article_dirs:
+                        aname = os.path.basename(adir).lower()
+                        if all(w in aname for w in words):
+                            target_dir = adir
+                            break
+
+            if target_dir:
+                dest_file_name = f"{safe_filename(os.path.basename(target_dir))}_{size}.mp4"
+                dest_path = os.path.join(target_dir, dest_file_name)
+                
+                if not os.path.exists(dest_path) or os.path.getsize(dest_path) != os.path.getsize(src_path):
+                    shutil.copy2(src_path, dest_path)
+                    print(f"  [MIGRATED] {video_file} -> {os.path.relpath(dest_path, ARTICLES_DIR)}")
+                    migrated_count += 1
+                else:
+                    print(f"  [EXISTS] {os.path.relpath(dest_path, ARTICLES_DIR)}")
+            else:
+                print(f"  [UNMATCHED] {video_file}")
+
+    print(f"\n=== Migration Complete: {migrated_count} video(s) copied/updated to article folders. ===")
+
+if __name__ == "__main__":
+    migrate_videos()

news_collection_and_script_generation/README.md

@@ -0,0 +1,14 @@
+# News Collection & Script Generation Toolkit
+
+This folder contains all essential Python and PowerShell scripts used for automated news collection, quality filtering, synthesis, article finalization, and multi-format script generation.
+
+## Included Scripts:
+- **collect_news_service.py**: Automated news collection service and feed ingestion.
+- **create_perplexity_article.py**: Perplexity-based article generation.
+- **synthesize_articles_litert.py / synthesize_articles_raw.py**: Article text synthesis engine using LiteRT / LLM.
+- **quality_gate_articles.py**: Article quality gate, duplicate detection, and Tier rating.
+- **finalize_articles.py**: Finalization of raw articles into structured JSON/Markdown.
+- **generate_scripts_all.py**: Batch generation of 3-length scripts (short, middle, long) and clean TTS text files.
+- **evaluate_for_tts.py / tts_articles.py / auto_tts_on_idle.py**: TTS evaluation and automated synthesis pipelines.
+- **copy_passed_articles.py / cron_processor.py**: File routing and cron scheduling utilities.
+- **run_pipeline_safely.ps1 / run_scripts_safely.ps1**: Safe execution launchers for PowerShell environment.

news_collection_and_script_generation/auto_tts_on_idle.py

@@ -0,0 +1,534 @@
+import os
+import re
+import sys
+import json
+import urllib.request
+import time
+import uuid
+import subprocess
+import argparse
+
+
+# Reconfigure stdout/stderr to utf-8 to avoid encoding issues on Windows
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+DEFAULT_WORKFLOW = r"C:\ComfyUI\workflows\05_Audio_&_TTS\Text to Speech.json"
+SERVER_URL = "http://127.0.0.1:7777"
+
+# Add articles dir to python path
+sys.path.append(ROOT_DIR)
+try:
+    import tts_articles
+except ImportError as e:
+    print(f"Failed to import tts_articles.py: {e}")
+    sys.exit(1)
+
+def get_gpu_stats():
+    try:
+        output = subprocess.check_output(
+            ['nvidia-smi', '--query-gpu=utilization.gpu,memory.used,memory.total', '--format=csv,noheader,nounits'],
+            stderr=subprocess.DEVNULL
+        ).decode().strip()
+        parts = output.split(',')
+        if len(parts) >= 3:
+            return {
+                "util": int(parts[0].strip()),
+                "mem_used": int(parts[1].strip()),
+                "mem_total": int(parts[2].strip())
+            }
+    except Exception:
+        pass
+    return None
+
+def is_comfyui_queue_empty():
+    try:
+        req = urllib.request.Request(f"{SERVER_URL}/queue")
+        with urllib.request.urlopen(req, timeout=3) as response:
+            queue_status = json.loads(response.read().decode('utf-8'))
+            running = queue_status.get("queue_running", [])
+            pending = queue_status.get("queue_pending", [])
+            return len(running) == 0 and len(pending) == 0
+    except Exception:
+        # If we can't connect, assume not empty to be safe
+        return False
+
+def has_ready_video_articles():
+    # Scan all articles to check if any have READY_FOR_VIDEO status
+    locales = ["en-US", "en-EU", "ja-JP", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]
+    for locale in locales:
+        locale_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(locale_path) or not os.path.isdir(locale_path):
+            continue
+        try:
+            categories = os.listdir(locale_path)
+        except OSError:
+            continue
+        for category in categories:
+            if category == "__pycache__":
+                continue
+            cat_path = os.path.join(locale_path, category)
+            if not os.path.exists(cat_path) or not os.path.isdir(cat_path):
+                continue
+            try:
+                articles = os.listdir(cat_path)
+            except OSError:
+                continue
+            for article in articles:
+                if article in ["__pycache__", "images", "sources"]:
+                    continue
+                article_path = os.path.join(cat_path, article)
+                if not os.path.isdir(article_path):
+                    continue
+                eval_path = os.path.join(article_path, "evaluation_result.json")
+                if os.path.exists(eval_path):
+                    try:
+                        with open(eval_path, 'r', encoding='utf-8') as ef:
+                            eval_data = ef.read()
+                        if '"status": "READY_FOR_VIDEO"' in eval_data:
+                            return True
+                    except Exception:
+                        pass
+    return False
+
+def is_system_idle_for_spot_tts(threshold_util=25, threshold_mem_ratio=0.96):
+    # 1. Check GPU utilization
+    stats = get_gpu_stats()
+    if stats is None:
+        return False, "GPU stats unavailable"
+    mem_ratio = stats["mem_used"] / stats["mem_total"]
+    if stats["util"] > threshold_util or mem_ratio > threshold_mem_ratio:
+        return False, f"GPU busy (Util: {stats['util']}%, Mem: {stats['mem_used']}/{stats['mem_total']}MB)"
+        
+    # 2. Check ComfyUI queue status
+    if not is_comfyui_queue_empty():
+        return False, "ComfyUI queue has active/pending jobs"
+        
+    return True, "System is idle and ready for spot TTS"
+
+def is_gpu_idle_quick(threshold_util=25, threshold_mem_ratio=0.96):
+    is_idle, _ = is_system_idle_for_spot_tts(threshold_util, threshold_mem_ratio)
+    return is_idle
+
+def is_gpu_actually_busy(threshold_util=25, threshold_mem_ratio=0.96, checks=1, interval=1):
+    for _ in range(checks):
+        if is_gpu_idle_quick(threshold_util, threshold_mem_ratio):
+            return False
+        if checks > 1:
+            time.sleep(interval)
+    return True
+
+def wait_until_gpu_idle(threshold_util=25, threshold_mem_ratio=0.96, duration=300, interval=5):
+    print(f"Waiting for system to be idle (GPU util <= {threshold_util}%, empty queue, no ready videos) for {duration} seconds...")
+    consecutive_idle = 0
+    required_consecutive = max(1, duration // interval)
+    while consecutive_idle < required_consecutive:
+        is_idle, reason = is_system_idle_for_spot_tts(threshold_util, threshold_mem_ratio)
+        if is_idle:
+            consecutive_idle += 1
+            print(f"\rSystem is idle ({consecutive_idle * interval}/{duration}s) - {reason}", end="", flush=True)
+        else:
+            if consecutive_idle > 0:
+                print(f"\nSystem became busy: {reason}. Resetting timer.")
+            consecutive_idle = 0
+            print(f"\rSystem busy - {reason}", end="", flush=True)
+        time.sleep(interval)
+    print("\nSystem is idle and ready.")
+
+
+def get_script_file(article_dir, length):
+    # Try clean txt first
+    clean_txt = os.path.join(article_dir, f"script_{length}_clean.txt")
+    if os.path.exists(clean_txt):
+        return clean_txt
+    # Fallback to md
+    md_file = os.path.join(article_dir, f"script_{length}.md")
+    if os.path.exists(md_file):
+        return md_file
+    return None
+
+def run_tts_task(task, api_prompt_template, comfy_output_dir):
+    import numpy as np
+    import librosa
+    import soundfile as sf
+
+    article_dir = task["article_dir"]
+    script_name = task["script_name"]
+    output_filename = task["output_filename"]
+    
+    script_path = os.path.join(article_dir, script_name)
+    print(f"\nProcessing TTS for {os.path.basename(article_dir)} ({script_name}) -> {output_filename}...")
+    
+    try:
+        script_text = tts_articles.clean_script_text(script_path)
+    except Exception as e:
+        print(f"Error reading/cleaning script {script_path}: {e}")
+        return False
+        
+    segments = tts_articles.split_into_segments(script_text)
+    if not segments:
+        print(f"Error: Script {script_name} is empty.")
+        return False
+        
+    client_id = str(uuid.uuid4())
+    text_input_node_id = None
+    save_audio_node_id = None
+    index_tts_node_id = None
+    emotion_text_node_id = None
+
+    for node_id, node in api_prompt_template.items():
+        if node["class_type"] == "TextInput_":
+            text_input_node_id = node_id
+        elif node["class_type"] == "SaveAudio":
+            save_audio_node_id = node_id
+        elif node["class_type"] in ["IndexTTSRun", "easy indexTTSGenerate", "IndexTTS2EmotionText"]:
+            index_tts_node_id = node_id
+        elif node["class_type"] == "easy indexTTSEmotionText":
+            emotion_text_node_id = node_id
+
+    if not text_input_node_id or not save_audio_node_id:
+        print("Error: Required nodes not found in workflow template.")
+        return False
+
+    segment_failed = False
+    
+    # 1. Setup caching variables
+    temp_prefix = output_filename.replace(".flac", "") + "_part_"
+    
+    # 2. Check if cache is valid.
+    # If the script file has been modified since the oldest part file was created, we invalidate the cache.
+    existing_parts = {}
+    for s_idx in range(len(segments)):
+        part_path = os.path.join(article_dir, f"{temp_prefix}{s_idx}.flac")
+        if os.path.exists(part_path):
+            existing_parts[s_idx] = part_path
+
+    if existing_parts:
+        script_mtime = os.path.getmtime(script_path)
+        oldest_part_mtime = min(os.path.getmtime(p) for p in existing_parts.values())
+        if script_mtime > oldest_part_mtime:
+            print("  Script file has been modified since the last run. Invalidating cache...")
+            for p in existing_parts.values():
+                try:
+                    os.remove(p)
+                except:
+                    pass
+            existing_parts = {}
+            
+    for s_idx, segment in enumerate(segments):
+        is_last = (s_idx == len(segments) - 1)
+        part_path = os.path.join(article_dir, f"{temp_prefix}{s_idx}.flac")
+        
+        # Check if this segment is already cached
+        if os.path.exists(part_path):
+            print(f"  Segment {s_idx+1}/{len(segments)} already cached. Skipping generation...")
+            continue
+            
+        speed_factor = 1.0  # Force 1.0 to bypass time_stretch and avoid echo
+        emphasized_segment = segment
+        emotion_desc = tts_articles.get_emotion_description(segment)
+        
+        # Check GPU/system status before queuing this segment. If busy, wait until idle.
+        if is_gpu_actually_busy(threshold_util=25):
+            print(f"\nSystem is busy before segment {s_idx+1}/{len(segments)}. Pausing execution...")
+            wait_until_gpu_idle(threshold_util=25, duration=60, interval=10)
+            
+        print(f"  Segment {s_idx+1}/{len(segments)}: '{segment[:60]}...'")
+        
+        prompt = json.loads(json.dumps(api_prompt_template))
+        prompt[text_input_node_id]["inputs"]["text"] = emphasized_segment
+        
+        is_japanese = "ja-jp" in article_dir.lower()
+        if is_japanese:
+            if index_tts_node_id and index_tts_node_id in prompt:
+                prompt[index_tts_node_id]["inputs"]["version"] = "v2.0-jp"
+            elif "105" in prompt:
+                prompt["105"]["inputs"]["version"] = "v2.0-jp"
+
+        if emotion_text_node_id:
+            prompt[emotion_text_node_id]["inputs"]["description"] = emotion_desc
+        elif index_tts_node_id and prompt[index_tts_node_id]["class_type"] == "IndexTTS2EmotionText":
+            prompt[index_tts_node_id]["inputs"]["emo_text"] = emotion_desc
+            prompt[index_tts_node_id]["inputs"]["use_emo_text"] = True
+            
+        prompt_id = str(uuid.uuid4())
+        filename_prefix = f"audio/article_tts_{prompt_id}"
+        prompt[save_audio_node_id]["inputs"]["filename_prefix"] = filename_prefix
+
+        if index_tts_node_id and index_tts_node_id in prompt:
+            if prompt[index_tts_node_id]["class_type"] != "IndexTTS2EmotionText":
+                prompt[index_tts_node_id]["inputs"]["unload_model"] = is_last
+        elif "105" in prompt:
+            if prompt["105"]["class_type"] not in ["IndexTTS2ModelLoader", "IndexTTS2EmotionText"]:
+                prompt["105"]["inputs"]["unload_model"] = is_last
+
+        # Queue prompt
+        try:
+            resp = tts_articles.queue_prompt(SERVER_URL, prompt, prompt_id, client_id)
+        except Exception as e:
+            print(f"    Error: Failed to queue prompt: {e}")
+            segment_failed = True
+            break
+
+        # Wait for completion
+        completed = False
+        start_time = time.time()
+        while time.time() - start_time < 1800:
+            try:
+                history = tts_articles.get_history(SERVER_URL, prompt_id)
+                if prompt_id in history:
+                    completed = True
+                    break
+            except:
+                pass
+            time.sleep(0.5)
+
+        if not completed:
+            print("    Error: TTS timed out.")
+            segment_failed = True
+            break
+
+        history_entry = history[prompt_id]
+        outputs = history_entry.get("outputs", {})
+        
+        if save_audio_node_id not in outputs or "audio" not in outputs[save_audio_node_id]:
+            print("    Error: SaveAudio output not found.")
+            segment_failed = True
+            break
+
+        audio_outputs = outputs[save_audio_node_id]["audio"]
+        if not audio_outputs:
+            print("    Error: No audio files returned.")
+            segment_failed = True
+            break
+
+        audio_info = audio_outputs[0]
+        gen_filename = audio_info["filename"]
+        gen_subfolder = audio_info["subfolder"]
+        
+        src_path = os.path.join(comfy_output_dir, gen_subfolder, gen_filename)
+        if not os.path.exists(src_path):
+            src_path = os.path.join(r"C:\ComfyUI\output", gen_subfolder, gen_filename)
+
+        if not os.path.exists(src_path):
+            print(f"    Error: Generated audio file not found at: {src_path}")
+            segment_failed = True
+            break
+
+        try:
+            # Move the segment to the cache file directly
+            import shutil
+            shutil.move(src_path, part_path)
+            print(f"    Saved segment to cache: {part_path}")
+        except Exception as mv_err:
+            print(f"    Error caching generated audio segment: {mv_err}")
+            segment_failed = True
+            break
+
+    if segment_failed:
+        print("Task failed.")
+        return False
+
+    # 3. Concatenation Phase
+    dest_path = os.path.join(article_dir, output_filename)
+    try:
+        print(f"Concatenating {len(segments)} segments...")
+        audio_segments = []
+        sr = 24000
+        for s_idx, segment in enumerate(segments):
+            part_path = os.path.join(article_dir, f"{temp_prefix}{s_idx}.flac")
+            y, file_sr = librosa.load(part_path, sr=None)
+            sr = file_sr
+            audio_segments.append(y)
+            
+            pause_duration = tts_articles.get_pause_duration(segment)
+            if pause_duration > 0 and s_idx < len(segments) - 1:
+                silence = np.zeros(int(sr * pause_duration))
+                audio_segments.append(silence)
+                
+        final_audio = np.concatenate(audio_segments)
+        max_val = np.max(np.abs(final_audio))
+        if max_val > 0.001:
+            final_audio = final_audio / max_val * 0.9
+        sf.write(dest_path, final_audio, sr, format='FLAC')
+        print(f"Saved audio to: {dest_path}")
+        
+        # Clean up temp part files
+        for s_idx in range(len(segments)):
+            part_path = os.path.join(article_dir, f"{temp_prefix}{s_idx}.flac")
+            try:
+                os.remove(part_path)
+            except Exception:
+                pass
+        return True
+    except Exception as save_err:
+        print(f"Error saving final audio: {save_err}")
+        return False
+
+script_gen_process = None
+
+def scan_and_run(long_only=False):
+    # 1. Background script generation has been delegated to the coordinated sequential pipeline loop.
+    
+    # 2. Convert default workflow to API prompt template
+    try:
+        api_prompt_template = tts_articles.convert_ui_to_api(DEFAULT_WORKFLOW, SERVER_URL)
+    except Exception as e:
+        print(f"Failed to load ComfyUI workflow: {e}. Is ComfyUI server running?")
+        return False
+        
+    comfy_output_dir = os.path.abspath(os.path.join(os.path.dirname(DEFAULT_WORKFLOW), "..", "output"))
+
+    # 3. Scan for articles requiring TTS
+    locales = ["en-US"]
+    article_dirs = []
+    
+    for locale in locales:
+        locale_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(locale_path) or not os.path.isdir(locale_path):
+            continue
+            
+        categories = os.listdir(locale_path)
+        for category in categories:
+            if category in ["__pycache__"]:
+                continue
+            cat_path = os.path.join(locale_path, category)
+            if not os.path.exists(cat_path) or not os.path.isdir(cat_path):
+                continue
+                
+            articles = os.listdir(cat_path)
+            for article in articles:
+                if article in ["__pycache__", "images", "sources"]:
+                    continue
+                article_path = os.path.join(cat_path, article)
+                if os.path.isdir(article_path):
+                    # Check if it has a main markdown file
+                    md_files = [f for f in os.listdir(article_path) if f.endswith(".md")]
+                    if md_files:
+                        article_dirs.append(article_path)
+
+    # Sort article directories by modification time (newest first)
+    article_dirs.sort(key=lambda x: os.path.getmtime(x), reverse=True)
+
+    # 4. Filter missing TTS audio tasks
+    pending_tasks = []
+    for article_dir in article_dirs:
+        article_name = os.path.basename(article_dir)
+        
+        # Only process S (tier 1) and A (tier 2) articles
+        json_path = os.path.join(article_dir, f"{article_name}.json")
+        if not os.path.exists(json_path):
+            continue
+        try:
+            with open(json_path, 'r', encoding='utf-8') as jf:
+                meta = json.load(jf)
+            if meta.get("tier") not in [1, 2]:
+                continue
+        except Exception as e:
+            print(f"Error checking tier for {article_name}: {e}")
+            continue
+        
+        if long_only:
+            lengths_info = [
+                {"len": "long", "suffix": "_long_indextts1.5.flac"}
+            ]
+        else:
+            lengths_info = [
+                {"len": "short", "suffix": "_short_indextts1.5.flac"},
+                {"len": "middle", "suffix": "_indextts1.5.flac"},
+                {"len": "long", "suffix": "_long_indextts1.5.flac"}
+            ]
+        
+        for info in lengths_info:
+            target_filename = f"{article_name}{info['suffix']}"
+            target_path = os.path.join(article_dir, target_filename)
+            
+            if not os.path.exists(target_path):
+                script_file = get_script_file(article_dir, info["len"])
+                if script_file:
+                    pending_tasks.append({
+                        "article_dir": article_dir,
+                        "script_name": os.path.basename(script_file),
+                        "output_filename": target_filename
+                    })
+
+    if not pending_tasks:
+        print("No pending TTS tasks found.")
+        return True
+
+    def get_priority_score(article_dir):
+        path_lower = article_dir.lower()
+        score = 0
+        if "en-us" in path_lower:
+            score += 10000
+        if "en-us" in path_lower and "moscow_attacks" in path_lower:
+            score += 1000
+        elif "moscow_attacks" in path_lower:
+            score += 500
+        elif "war_and_military" in path_lower:
+            score += 400
+        
+        # War-related keywords in English and Japanese
+        war_keywords = [
+            "war", "military", "conflict", "attack", "bombing", "invasion", 
+            "soldier", "battle", "clash", "defense", "missile", "drone", 
+            "bomb", "strike", "shelling", "army", "troop", "nato", "putin", 
+            "ukraine", "russia", "kremlin", "pentagon", "blasts",
+            "戦争", "軍事", "衝突", "攻撃", "爆撃", "侵攻", "兵士", "戦闘", 
+            "ミサイル", "ドローン", "爆発", "ウクライナ", "ロシア", "プーチン"
+        ]
+        if any(kw in path_lower for kw in war_keywords):
+            score += 200
+        return score
+
+    # Sort pending tasks by priority score descending
+    pending_tasks.sort(key=lambda t: get_priority_score(t["article_dir"]), reverse=True)
+
+    print(f"Found {len(pending_tasks)} pending TTS tasks.")
+    
+    # 5. Wait for 60 seconds of system idle time before starting TTS generation
+    print("\nWaiting for system to be idle for at least 60 seconds before starting TTS generation...")
+    wait_until_gpu_idle(threshold_util=25, duration=60, interval=10)
+    
+    # Process pending tasks
+    for task in pending_tasks:
+        # Check GPU status before each task
+        if is_gpu_actually_busy(threshold_util=25):
+            print("\nGPU is busy before starting task. Waiting...")
+            wait_until_gpu_idle(threshold_util=25, duration=60, interval=60)
+            
+        success = run_tts_task(task, api_prompt_template, comfy_output_dir)
+        if not success:
+            print(f"Task failed for {task['output_filename']}. Will retry in next scan.")
+            
+    return True
+
+def main():
+    parser = argparse.ArgumentParser(description="Auto TTS Daemon on GPU Idle")
+    parser.add_argument("--all-lengths", action="store_true", help="Process all script lengths instead of only long")
+    args = parser.parse_args()
+
+    long_only = not args.all_lengths
+
+    print("==================================================")
+    print(" Auto TTS Daemon on GPU Idle Started")
+    if long_only:
+        print(" MODE: Long Only TTS Generation (Spot Mode)")
+    else:
+        print(" MODE: All Script Lengths Generation")
+    print(" Polling interval: 60 seconds when idle")
+    print(" GPU idle threshold: 25% utilization")
+    print(" System check includes ComfyUI queue status")
+    print("==================================================")
+    
+    while True:
+        try:
+            scan_and_run(long_only=long_only)
+        except Exception as e:
+            print(f"Error in auto TTS loop: {e}")
+        # Sleep for 60 seconds before scanning again (faster check)
+        time.sleep(60)
+
+if __name__ == "__main__":
+    main()

news_collection_and_script_generation/collect_news_service.py

@@ -0,0 +1,524 @@
+import os
+import re
+import json
+import urllib.request
+import urllib.parse
+import xml.etree.ElementTree as ET
+import time
+import sys
+from datetime import datetime
+import requests
+try:
+    from curl_cffi import requests as requests_cffi
+    HAS_CURL_CFFI = True
+except ImportError:
+    HAS_CURL_CFFI = False
+from bs4 import BeautifulSoup
+from googlenewsdecoder import new_decoderv1
+
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+HISTORY_FILE = os.path.join(ROOT_DIR, "history.json")
+PENDING_FILE = os.path.join(ROOT_DIR, "pending.json")
+
+CATEGORIES = {
+    "Business": [
+        "https://news.google.com/rss/headlines/section/topic/BUSINESS?hl=en-US&gl=US&ceid=US:en"
+    ],
+    "World_Affairs": [
+        "https://news.google.com/rss/headlines/section/topic/WORLD?hl=en-US&gl=US&ceid=US:en",
+        "https://news.google.com/rss/search?q=Moscow+attack+OR+Moscow+drone+OR+Ukraine+Moscow&hl=en-US&gl=US&ceid=US:en",
+        "https://news.google.com/rss/search?q=war+conflict+geopolitics+security+military&hl=en-US&gl=US&ceid=US:en",
+        "https://news.google.com/rss/headlines/section/topic/POLITICS?hl=en-US&gl=US&ceid=US:en",
+        "https://news.google.com/rss/search?q=site:themoscowtimes.com+OR+site:meduza.io+OR+site:kyivindependent.com+OR+site:pravda.com.ua+OR+site:novayagazeta.eu+OR+site:zona.media&hl=en-US&gl=US&ceid=US:en",
+        "https://meduza.io/rss/en/all",
+        "https://euromaidanpress.com/feed/"
+    ],
+
+    "Animals": [
+        "https://news.google.com/rss/search?q=animals+wildlife+zoo&hl=en-US&gl=US&ceid=US:en"
+    ],
+    "General": [
+        "https://news.google.com/rss?hl=en-US&gl=US&ceid=US:en"
+    ]
+}
+
+# Priority limits
+CATEGORY_LIMITS = {
+    "Business": 5,
+    "World_Affairs": 15,
+    "Animals": 5,
+    "General": 5
+}
+
+def load_history():
+    if os.path.exists(HISTORY_FILE):
+        try:
+            with open(HISTORY_FILE, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Failed to load history: {e}")
+            return {}
+    return {}
+
+def save_history(history):
+    try:
+        with open(HISTORY_FILE, 'w', encoding='utf-8') as f:
+            json.dump(history, f, indent=4, ensure_ascii=False)
+    except Exception as e:
+        print(f"Failed to save history: {e}")
+
+def load_pending():
+    if os.path.exists(PENDING_FILE):
+        try:
+            with open(PENDING_FILE, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Failed to load pending queue: {e}")
+            return []
+    return []
+
+def save_pending(pending):
+    try:
+        with open(PENDING_FILE, 'w', encoding='utf-8') as f:
+            json.dump(pending, f, indent=4, ensure_ascii=False)
+    except Exception as e:
+        print(f"Failed to save pending queue: {e}")
+
+def extract_main_word(title):
+    # Replace underscores and commas with spaces to handle words correctly
+    title = title.replace('_', ' ').replace(',', ' ')
+    
+    is_ja = any(ord(char) > 0x3000 for char in title)
+    
+    # Clean title from source marks
+    cleaned = re.sub(r'\s*-\s*[^-\s]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', title, flags=re.IGNORECASE)
+    cleaned = re.sub(r'_[^_]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', cleaned, flags=re.IGNORECASE)
+    
+    blacklisted = ["ai", "artificial intelligence", "人工知能", "生成ai", "生成系ai"]
+    
+    def is_valid(word):
+        if not word:
+            return False
+        return word.strip().lower() not in blacklisted
+
+    # 1. Look for quotes like 「...」
+    quotes_ja = re.findall(r'「([^」]+)」', cleaned)
+    for q in quotes_ja:
+        if is_valid(q):
+            return q
+            
+    quotes_en = re.findall(r'["\']([^"\']+)["\']', cleaned)
+    for q in quotes_en:
+        if len(q) < 25 and is_valid(q):
+            return q
+
+    # 2. Known key entities list
+    known_keywords = [
+        "OpenAI", "Google", "Amazon", "Bezos", "Trump", "Anthropic", "Microsoft", "Apple", "Nvidia", "Meta", "Musk",
+        "大谷", "オオタニ", "大谷翔平", "小田急", "ソニー", "ソフトバンク", "ChatGPT", "Claude", "IOWN", "サカナAI"
+    ]
+    for kw in known_keywords:
+        if kw.lower() in cleaned.lower() and is_valid(kw):
+            m = re.search(re.escape(kw), cleaned, re.IGNORECASE)
+            if m:
+                return m.group(0)
+
+    if is_ja:
+        # Katakana sequences
+        katakana = re.findall(r'[\u30a1-\u30fc]{2,}', cleaned)
+        for k in katakana:
+            if is_valid(k):
+                return k
+        # Kanji sequences
+        kanji = re.findall(r'[\u4e00-\u9fff]{2,}', cleaned)
+        for k in kanji:
+            if k not in ["米国", "日本", "市場", "世界", "政府", "計画", "導入"] and is_valid(k):
+                return k
+        if kanji:
+            for k in kanji:
+                if is_valid(k):
+                    return k
+        # Alphabetic words
+        alpha = re.findall(r'[a-zA-Z0-9]{2,}', cleaned)
+        for a in alpha:
+            if is_valid(a):
+                return a
+    else:
+        words = re.findall(r'\b[A-Z][a-zA-Z0-9]*\b', cleaned)
+        if words:
+            for w in words:
+                if w.lower() not in ["a", "an", "the", "in", "on", "at", "for", "to", "of", "and", "or", "but", "with", "by", "is", "are", "was", "were"] and is_valid(w):
+                    return w
+            for w in words:
+                if is_valid(w):
+                    return w
+        
+    first_token = re.search(r'\w+', cleaned)
+    if first_token and is_valid(first_token.group(0)):
+        return first_token.group(0)
+        
+    return ""
+
+def safe_filename(name, max_len=40):
+    main_word = extract_main_word(name).strip()
+    
+    cleaned = name.replace('_', ' ').replace(',', ' ')
+    cleaned = re.sub(r'[\\/*?:"<>|\'\`\(\)\[\]]', ' ', cleaned)
+    cleaned = re.sub(r'\s+', ' ', cleaned).strip()
+    
+    if main_word:
+        if cleaned.lower().startswith(main_word.lower()):
+            final_title = cleaned
+        else:
+            final_title = f"{main_word} {cleaned}"
+    else:
+        final_title = cleaned
+        
+    final_title = re.sub(r'\s+', ' ', final_title).strip()
+    
+    if len(final_title) > max_len:
+        final_title = final_title[:max_len].strip()
+        final_title = re.sub(r'[\s\.,\-_\+!@#\$%^&\*]+$', '', final_title)
+        
+    return final_title
+
+def normalize_title(title):
+    if not title:
+        return ""
+    # Normalize title by converting to lowercase and stripping all non-alphanumeric characters
+    title = title.lower()
+    title = re.sub(r'[^a-z0-9]', '', title)
+    return title
+
+def extract_text_from_html(html_content):
+    try:
+        soup = BeautifulSoup(html_content, 'html.parser')
+        # Remove unwanted tags
+        for tag in soup(['script', 'style', 'head', 'title', 'meta', 'link', 'header', 'footer', 'nav']):
+            tag.decompose()
+        # Extract text and clean up whitespace
+        text = soup.get_text()
+        lines = [line.strip() for line in text.splitlines() if line.strip()]
+        return '\n'.join(lines)
+    except Exception as e:
+        print(f"BeautifulSoup error: {e}, falling back to regex")
+        # Fallback regex
+        text = re.sub(r'<(script|style|head|title|meta|link|header|footer|nav).*?>.*?</\1>', '', html_content, flags=re.DOTALL | re.IGNORECASE)
+        text = re.sub(r'<[^>]*>', ' ', text)
+        lines = []
+        for line in text.splitlines():
+            line = line.strip()
+            if line:
+                lines.append(line)
+        return '\n'.join(lines)
+
+def download_as_text(url, dest_path):
+    print(f"Downloading & extracting text: {url} -> {dest_path}")
+    
+    # Decode Google News URL to get original source URL
+    decoded_url = url
+    try:
+        res = new_decoderv1(url, interval=1)
+        if res.get("status"):
+            decoded_url = res["decoded_url"]
+            print(f"Decoded Google News URL: {decoded_url}")
+    except Exception as e:
+        print(f"Failed to decode Google News URL {url}: {e}")
+        
+    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": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Language": "ja,en-US;q=0.9,en;q=0.8",
+        "Referer": "https://news.google.com/",
+        "Connection": "keep-alive"
+    }
+    try:
+        os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+        if HAS_CURL_CFFI:
+            response = requests_cffi.get(decoded_url, headers=headers, impersonate="chrome120", timeout=30)
+        else:
+            response = requests.get(decoded_url, headers=headers, timeout=30)
+        response.raise_for_status()
+        
+        html_text = response.text
+
+            
+        # Extract plain text
+        plain_text = extract_text_from_html(html_text)
+        
+        # Check if extracted text contains API refusal/failure patterns
+        refusal_patterns = [
+            r"i apologize, but i (cannot|can't)",
+            r"i am unable to (fetch|browse|access)",
+            r"i (cannot|can't) (fetch|browse|access) (live|real-time|the web|current)",
+            r"i do not have access to (live|real-time|current)",
+            r"sign up and repeat your request",
+            r"perplexity\.com/hub/legal/privacy-policy",
+        ]
+        
+        plain_text_lower = plain_text.lower()
+        is_refusal = False
+        for pattern in refusal_patterns:
+            if re.search(pattern, plain_text_lower):
+                is_refusal = True
+                print(f"Refusal detected in content with pattern: {pattern}")
+                break
+                
+        if is_refusal:
+            print(f"Extracted content contains API refusal/error message. Rejecting.")
+            return False
+            
+        # Check if extracted text is empty or too short
+        if not plain_text.strip():
+            plain_text = "[Failed to extract meaningful text from HTML. This is a fallback.]"
+            
+        with open(dest_path, 'w', encoding='utf-8') as f:
+            f.write(plain_text)
+
+                
+        # Verify it is not 0 bytes
+        if os.path.exists(dest_path) and os.path.getsize(dest_path) > 0:
+            print(f"Text extraction success: {dest_path} ({os.path.getsize(dest_path)} bytes)")
+            return True
+        else:
+            print(f"Extracted file is empty: {dest_path}")
+            if os.path.exists(dest_path):
+                os.remove(dest_path)
+            return False
+    except Exception as e:
+        print(f"Failed to download and extract text from {decoded_url}: {e}")
+        return False
+
+def fetch_rss(url, limit=10):
+    req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+    try:
+        with urllib.request.urlopen(req, timeout=15) as response:
+            xml_data = response.read()
+        root = ET.fromstring(xml_data)
+        items = []
+        for item in root.findall('.//item')[:limit * 2]:
+            title = item.find('title').text if item.find('title') is not None else ""
+            link = item.find('link').text if item.find('link') is not None else ""
+            pub_date = item.find('pubDate').text if item.find('pubDate') is not None else ""
+            desc_elem = item.find('description')
+            desc = desc_elem.text if desc_elem is not None else ""
+            desc = re.sub(r'<[^>]*>', '', desc)
+            items.append({
+                "title": title,
+                "link": link,
+                "pub_date": pub_date,
+                "description": desc
+            })
+        return items
+    except Exception as e:
+        print(f"Failed to fetch RSS {url}: {e}")
+        return []
+
+def prioritize_items(items):
+    priority_keywords = [
+        # Specific high-priority targets & events
+        "moscow", "refinery", "kapotnya", "kremlin", "drone strike", 
+        "モスクワ", "製油所", "ドローン",
+        
+        # Geopolitical Regions & Countries (English & Japanese)
+        "iran", "america", "united states", "us", "china", "russia", "ukraine",
+        "イラン", "アメリカ", "米国", "中国", "ロシア", "ウクライナ",
+        
+        # General War & Conflict (English)
+        "war", "conflict", "military", "strike", "attack", "offensive", 
+        "missile", "explosion", "shelling", "invasion", "casualty", 
+        "casualties", "ceasefire", "truce", "defense", "defence", 
+        "air strike", "bombing", "nato", "troops", "forces", "combat",
+        
+        # General War & Conflict (Japanese)
+        "戦争", "紛争", "軍事", "攻撃", "空爆", "ミサイル", "爆発", 
+        "砲撃", "侵攻", "防衛", "戦闘", "部隊", "停戦", "被弾"
+    ]
+
+    def get_priority(item):
+        text = (item.get("title", "") + " " + item.get("description", "")).lower()
+        if any(kw in text for kw in priority_keywords):
+            return 0  # High priority (sorted to the front)
+        return 1      # Normal priority
+    return sorted(items, key=get_priority)
+
+
+
+def main():
+    print(f"Starting background news collection at {datetime.now().isoformat()}")
+    history = load_history()
+    pending = load_pending()
+    
+    # Create a set of already fetched/scheduled URLs and normalized titles to avoid duplicates
+    existing_urls = set(history.keys())
+    existing_titles = set()
+    
+    for url, info in history.items():
+        if isinstance(info, dict) and 'title' in info:
+            existing_titles.add(normalize_title(info['title']))
+            
+    for item in pending:
+        existing_urls.add(item['link'])
+        if 'title' in item:
+            existing_titles.add(normalize_title(item['title']))
+        
+    new_items_added = 0
+    
+    for category, urls in CATEGORIES.items():
+        print(f"\nProcessing category: {category}")
+        limit = CATEGORY_LIMITS.get(category, 10)
+        
+        raw_items = []
+        for url in urls:
+            raw_items.extend(fetch_rss(url, limit=limit))
+            
+        if not raw_items:
+            continue
+            
+        # Remove duplicate links within raw_items
+        seen_links = set()
+        unique_items = []
+        for item in raw_items:
+            link = item['link']
+            if link not in seen_links:
+                seen_links.add(link)
+                unique_items.append(item)
+                
+        # Filter new items (not in history or pending)
+        new_items = []
+        for item in unique_items:
+            norm_title = normalize_title(item['title'])
+            if item['link'] not in existing_urls and norm_title not in existing_titles:
+                new_items.append(item)
+                
+        # Prioritize important topics (e.g. Moscow attacks)
+        new_items = prioritize_items(new_items)
+        
+        # Limit processing items
+        new_items = new_items[:limit]
+
+                
+        if not new_items:
+            print(f"No new articles to collect for category: {category}")
+            continue
+            
+        # Directory paths
+        temp_sources_dir = os.path.join(ROOT_DIR, "temp_sources")
+        os.makedirs(temp_sources_dir, exist_ok=True)
+
+        print(f"Found {len(new_items)} new items for {category}. Downloading source text...")
+        for item in new_items:
+            safe_title = safe_filename(item['title'])
+            source_filename = f"{safe_title}_source.txt"
+            source_path = os.path.join(temp_sources_dir, source_filename)
+            
+            # Download and extract text
+            if download_as_text(item['link'], source_path):
+                # Add to pending list
+                pending.append({
+                    "category": category,
+                    "title": item['title'],
+                    "link": item['link'],
+                    "pub_date": item['pub_date'],
+                    "description": item['description'],
+                    "source_file": source_path
+                })
+                existing_urls.add(item['link'])
+                existing_titles.add(normalize_title(item['title']))
+                new_items_added += 1
+            else:
+                print(f"Skipping '{item['title']}' due to download failure.")
+                
+    if new_items_added > 0:
+        save_pending(pending)
+        print(f"Collection finished. Added {new_items_added} new items to pending queue.")
+    else:
+        print("Collection finished. No new items added.")
+        
+    # Phase 2: Run news compilation with LiteRT-LM (Gemma-4)
+    try:
+        print("\n=== PHASE 2: LiteRT-LM News Compilation (Gemma-4) ===")
+        import subprocess
+        cmd = [sys.executable, os.path.join(ROOT_DIR, "synthesize_articles_litert.py")]
+        res = subprocess.run(cmd, capture_output=False, text=True)
+        if res.returncode != 0:
+            raise RuntimeError(f"LiteRT-LM compilation subprocess exited with code {res.returncode}")
+    except Exception as e:
+        print(f"Failed to run LiteRT-LM compilation phase: {e}. Falling back to Raw News Compilation.")
+        try:
+            import synthesize_articles_raw
+            synthesize_articles_raw.main()
+        except Exception as fallback_err:
+            print(f"Failed to run fallback Raw compilation phase: {fallback_err}")
+        
+    # Phase 2.5: Article Quality Gate (Proofreading)
+    try:
+        print("\n=== PHASE 2.5: Article Quality Gate (Proofreading) ===")
+        cmd = [sys.executable, os.path.join(ROOT_DIR, "quality_gate_articles.py")]
+        res = subprocess.run(cmd, capture_output=False, text=True)
+        if res.returncode != 0:
+            print(f"Quality gate subprocess exited with code {res.returncode}")
+    except Exception as e:
+        print(f"Failed to run Quality Gate phase: {e}. Skipping proofreading.")
+        
+    # Phase 3: Run article finalization (assets download, embeds, history updates)
+    finalized_dirs = []
+    try:
+        print("\n=== PHASE 3: Article Finalization ===")
+        import finalize_articles
+        finalized_dirs = finalize_articles.main()
+    except Exception as e:
+        print(f"Failed to run finalization phase: {e}")
+
+    # Phase 3.5: LiteRT-LM News Script Generation (en-US)
+    try:
+        print("\n=== PHASE 3.5: LiteRT-LM News Script Generation ===")
+        import subprocess
+        cmd = [sys.executable, os.path.join(ROOT_DIR, "generate_scripts_all.py"), "--locale", "en-US", "--limit", "5", "--gpu"]
+        res = subprocess.run(cmd, capture_output=False, text=True)
+        if res.returncode != 0:
+            print(f"Script generation subprocess exited with code {res.returncode}")
+    except Exception as e:
+        print(f"Failed to run Script Generation phase: {e}")
+
+    # Phase 3.8: Automatically generate B-roll for newly finalized articles
+    if finalized_dirs:
+        try:
+            print("\n=== PHASE 3.8: Automatic B-roll Collection ===")
+            import subprocess
+            for art_dir in finalized_dirs:
+                print(f"Running B-roll collection for: {art_dir}")
+                broll_cmd = [sys.executable, os.path.join(ROOT_DIR, "collect_broll_agent.py"), "--article-dir", art_dir]
+                subprocess.run(broll_cmd, check=True)
+        except Exception as e:
+            print(f"Failed to run automatic B-roll collection phase: {e}")
+
+    # Phase 4: Automatically generate thumbnails for newly finalized articles
+    try:
+        print("\n=== PHASE 4: Automatic Thumbnail Generation ===")
+        sys.path.append(r"C:\VideoGemma\scripts")
+        import run_all_batches_fast
+        run_all_batches_fast.main()
+    except Exception as e:
+        print(f"Failed to run automatic thumbnail generation phase: {e}")
+
+    # Phase 5: Automatically backfill missing B-rolls for older articles (15 per run)
+    try:
+        print("\n=== PHASE 5: Automatic B-roll Backfill ===")
+        backfill_script = r"C:\Roaming\scratch\batch_generate_brolls.py"
+        if os.path.exists(backfill_script):
+            broll_cmd = [sys.executable, backfill_script, "--limit", "15"]
+            subprocess.run(broll_cmd, check=True)
+        else:
+            print(f"Backfill script not found at: {backfill_script}")
+    except Exception as e:
+        print(f"Failed to run B-roll backfill phase: {e}")
+
+if __name__ == "__main__":
+    main()
+

news_collection_and_script_generation/copy_passed_articles.py

@@ -0,0 +1,196 @@
+import os
+import sys
+import re
+import shutil
+import argparse
+from PIL import Image
+from datetime import datetime
+
+# Reconfigure stdout/stderr to utf-8 to avoid encoding issues on Windows
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+DEST_DIR = r"C:\Users\eggof\Desktop\Android Times\Articles"
+
+def check_article_gate(article_dir):
+    md_files = [f for f in os.listdir(article_dir) if f.endswith(".md") and not f.startswith("script_") and f != "watermark_scan_report.md"]
+    if not md_files:
+        return False, "Main article markdown file not found."
+    
+    main_md_path = os.path.join(article_dir, md_files[0])
+    try:
+        with open(main_md_path, "r", encoding="utf-8") as f:
+            content = f.read().strip()
+    except Exception as e:
+        return False, f"Failed to read article markdown: {e}"
+        
+    if len(content) < 150:
+        return False, f"Article content is too short ({len(content)} chars)."
+        
+    error_patterns = [
+        r"403\s+forbidden",
+        r"access\s+denied",
+        r"enable\s+javascript",
+        r"please\s+enable\s+cookies",
+        r"cloudflare",
+        r"captcha",
+        r"are\s+you\s+a\s+robot"
+    ]
+    for pattern in error_patterns:
+        if re.search(pattern, content, re.IGNORECASE):
+            return False, f"Article content contains error pattern: '{pattern}'"
+            
+    return True, "Pass"
+
+def check_script_gate(article_dir):
+    lengths = ["short", "middle", "long"]
+    for length in lengths:
+        script_md = os.path.join(article_dir, f"script_{length}.md")
+        script_txt = os.path.join(article_dir, f"script_{length}_clean.txt")
+        
+        if not os.path.exists(script_md) or not os.path.exists(script_txt):
+            return False, f"Missing script files for length: {length}"
+            
+        try:
+            with open(script_md, "r", encoding="utf-8") as f:
+                md_content = f.read().strip()
+            with open(script_txt, "r", encoding="utf-8") as f:
+                txt_content = f.read().strip()
+        except Exception as e:
+            return False, f"Failed to read script files: {e}"
+            
+        if not md_content or not txt_content:
+            return False, f"Script content is empty for length: {length}"
+            
+        # Check for speaker labels or dialogue indicators in the text
+        forbidden_labels = [r'\bAnchor\b:', r'\bReporter\b:', r'\bCorrespondent\b:', r'\bPresenter\b:', r'\bNarrator\b:', r'\bHost\b:', r'\bVoiceover\b:']
+        for pattern in forbidden_labels:
+            if re.search(pattern, txt_content, re.IGNORECASE) or re.search(pattern, md_content, re.IGNORECASE):
+                return False, f"Script contains forbidden speaker label matching: '{pattern}'"
+                
+        # Check for parenthetical directions like "(laughing)", "[music]"
+        if re.search(r'\([^)]+\)', txt_content) or re.search(r'\[[^\]]+\]', txt_content):
+            return False, f"Clean script contains parenthetical directions or annotations."
+                
+    return True, "Pass"
+
+def check_thumbnail_gate(article_dir):
+    thumb_path = os.path.join(article_dir, "thumbnail.png")
+    if not os.path.exists(thumb_path):
+        return False, "thumbnail.png not found."
+    try:
+        with Image.open(thumb_path) as img:
+            img.verify()
+        return True, "Pass"
+    except Exception as e:
+        return False, f"Thumbnail is corrupted: {e}"
+
+def sync_directory(src, dest):
+    os.makedirs(dest, exist_ok=True)
+    copied_files = 0
+    for item in os.listdir(src):
+        s_item = os.path.join(src, item)
+        d_item = os.path.join(dest, item)
+        if os.path.isdir(s_item):
+            if item in ["__pycache__"]:
+                continue
+            copied_files += sync_directory(s_item, d_item)
+        else:
+            # Copy file if newer, modified size, or missing
+            if not os.path.exists(d_item) or os.path.getsize(s_item) != os.path.getsize(d_item) or os.path.getmtime(s_item) > os.path.getmtime(d_item):
+                try:
+                    shutil.copy2(s_item, d_item)
+                    copied_files += 1
+                except Exception as e:
+                    print(f"    Failed to copy file {item}: {e}")
+    return copied_files
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate quality gates and copy passed articles to destination.")
+    parser.add_argument("--locale", type=str, default=None, help="Filter by locale.")
+    parser.add_argument("--category", type=str, default=None, help="Filter by category.")
+    parser.add_argument("--dry-run", action="store_true", help="Evaluate only, do not copy.")
+    args = parser.parse_args()
+
+    print(f"=== Quality Gate Evaluation & Copy System: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} ===")
+    print(f"Source: {ROOT_DIR}")
+    print(f"Destination: {DEST_DIR}")
+    if args.dry_run:
+        print("NOTE: Running in DRY RUN mode (no files will be copied).")
+    print("-" * 60)
+
+    # Find article directories
+    locales = [args.locale] if args.locale else [
+        d for d in os.listdir(ROOT_DIR) 
+        if os.path.isdir(os.path.join(ROOT_DIR, d)) and d not in ["__pycache__", "temp", "temp_sources", "images", "sources"]
+    ]
+    
+    total_articles = 0
+    passed_articles = 0
+    copied_count = 0
+
+    for locale in locales:
+        locale_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.isdir(locale_path):
+            continue
+            
+        categories = [args.category] if args.category else [
+            c for c in os.listdir(locale_path) 
+            if os.path.isdir(os.path.join(locale_path, c)) and c not in ["__pycache__", "images", "sources"]
+        ]
+        
+        for category in categories:
+            cat_path = os.path.join(locale_path, category)
+            if not os.path.isdir(cat_path):
+                continue
+                
+            for article in os.listdir(cat_path):
+                if article in ["__pycache__", "images", "sources"]:
+                    continue
+                article_path = os.path.join(cat_path, article)
+                if not os.path.isdir(article_path):
+                    continue
+                    
+                total_articles += 1
+                
+                # Check Gates
+                art_ok, art_reason = check_article_gate(article_path)
+                script_ok, script_reason = check_script_gate(article_path)
+                thumb_ok, thumb_reason = check_thumbnail_gate(article_path)
+                
+                if art_ok and script_ok and thumb_ok:
+                    passed_articles += 1
+                    dest_path = os.path.join(DEST_DIR, locale, category, article)
+                    
+                    if args.dry_run:
+                        print(f"[PASS] {locale}/{category}/{article} (Dry Run)")
+                    else:
+                        print(f"[PASS] {locale}/{category}/{article}")
+                        files_copied = sync_directory(article_path, dest_path)
+                        if files_copied > 0:
+                            print(f"  -> Copied/Updated {files_copied} files.")
+                            copied_count += 1
+                        else:
+                            print("  -> Already up-to-date in destination.")
+                else:
+                    failures = []
+                    if not art_ok: failures.append(f"Article: {art_reason}")
+                    if not script_ok: failures.append(f"Script: {script_reason}")
+                    if not thumb_ok: failures.append(f"Thumbnail: {thumb_reason}")
+                    
+                    # Print failures in a compact way
+                    print(f"[FAIL] {locale}/{category}/{article}")
+                    for f in failures:
+                        print(f"  - {f}")
+                        
+    print("-" * 60)
+    print(f"Evaluation finished.")
+    print(f"Total articles scanned: {total_articles}")
+    print(f"Articles passed gates : {passed_articles}")
+    if not args.dry_run:
+        print(f"Article folders updated : {copied_count}")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()

news_collection_and_script_generation/create_perplexity_article.py

@@ -0,0 +1,99 @@
+import os
+import urllib.request
+from datetime import datetime, timezone
+import json
+
+def create_article():
+    title = "Amazon Secures $17.5 Billion Loan for AI Infrastructure"
+    safe_title = "Amazon_Secures_17_5_Billion_Loan_for_AI_Infrastructure"
+    root_dir = r"C:\ComfyUI\Articles"
+    article_dir = os.path.join(root_dir, safe_title)
+    images_dir = os.path.join(article_dir, "images")
+    sources_dir = os.path.join(article_dir, "sources")
+
+    os.makedirs(images_dir, exist_ok=True)
+    os.makedirs(sources_dir, exist_ok=True)
+
+    # Download Unsplash images (Business theme)
+    img_urls = [
+        "https://images.unsplash.com/photo-1611974789855-9c2a0a7236a3?q=80&w=1000",
+        "https://images.unsplash.com/photo-1507679799987-c73779587ccf?q=80&w=1000"
+    ]
+
+    img_paths = []
+    for i, url in enumerate(img_urls, 1):
+        dest = os.path.join(images_dir, f"{safe_title}_img{i}.jpg")
+        req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+        try:
+            with urllib.request.urlopen(req, timeout=30) as response:
+                with open(dest, 'wb') as f:
+                    f.write(response.read())
+            img_paths.append(dest.replace('\\', '/'))
+        except Exception as e:
+            print(f"Failed to download image {url}: {e}")
+            img_paths.append("IMAGE_DOWNLOAD_FAILED")
+
+    date_str = datetime.now(timezone.utc).strftime('%a, %d %b %Y %H:%M:%S GMT')
+
+    md_content = f"""# {title}
+{date_str}
+
+```carousel
+![Visual Theme 1]({img_paths[0]})
+<!-- slide -->
+![Visual Theme 2]({img_paths[1]})
+```
+
+As of June 12, 2026, major developments in the AI industry are centered on massive infrastructure investment, strategic partnerships in content creation, and ongoing geopolitical and regulatory debates.
+
+## Amazon's Massive AI Investment
+Amazon has finalized a $17.5 billion loan facility with a consortium of major lenders, including Citibank, JPMorgan Chase, and Bank of America. This move underscores the industry-wide trend of "Big Tech" tapping into debt markets to fund the aggressive expansion of data centers and computing capacity required for generative AI, with combined industry capital expenditure now projected to exceed $700 billion this year.
+
+## "AI+IP" Strategic Partnership in China
+Volcano Engine has launched an in-depth partnership with Bingo Group, integrating Seedance 2.0 video generation technology with classic film intellectual property (IP), such as Stephen Chow’s *The King of Comedy* and *The God of Cookery*. This initiative aims to provide compliant AI content creation tools across multiple Chinese platforms.
+
+## OpenAI Report on Foreign Influence
+OpenAI recently published a report detailing how Chinese propaganda groups have attempted to use its AI models to influence U.S. political discourse, including efforts to foment dissent regarding trade policies and data center regulations. While the company noted the efforts had little impact, it highlights the increasing role of generative AI in digital influence operations.
+
+## Ongoing Industry Trends
+Analysts note that the current phase of the AI boom has shifted away from simple "model launches" toward building robust platforms—encompassing AI chips, runtimes, and control planes—which are becoming "stickier", multi-year investments for enterprises. 
+Oracle has also rolled out its June 2026 AI updates, including expanded multimodal capabilities and the integration of Cohere Rerank 4 to improve enterprise search and agentic AI performance. 
+
+---
+**Images & Figures:**
+- ![Visual Theme 1]({img_paths[0]})
+- ![Visual Theme 2]({img_paths[1]})
+
+**Author:** AntigravityAI News Collector (Perplexity Source)
+
+**Sources & Citations:**
+- [{title}](https://vertexaisearch.cloud.google.com/grounding-api-redirect/AUZIYQHP6OOJS5VfJxEl-sM5nkfqGVyuYPQn3GKLJ-nPoElAHqPPcOs-fRVNulH1Vc_iA-E9c_sRuJsXjw2Xc0QmME5GiFa2igHOy9sRw4wD17x1dEO9J9QtNVMJLcdQWfJCsCehTrA0-BtWJXDqsdKPjF4HdTQ94ncCPdqYuIdRKZJ13h430edofAz2ca1v5tqPhKt0F4M4v-iqRUis9ui2EmeU2L1LM73cUvoJJFQOwYh1JEfTdAzOz4qWAVhuJaj34DaR)
+- [Volcano Engine AI+IP](https://asianews.network)
+- [OpenAI Report on Influence](https://taipeitimes.com)
+"""
+
+    dest_md = os.path.join(article_dir, f"{safe_title}.md")
+    with open(dest_md, "w", encoding="utf-8") as f:
+        f.write(md_content)
+        
+    print(f"SUCCESS: Article created at {dest_md}")
+
+    # Optionally update history.json
+    history_file = os.path.join(root_dir, "history.json")
+    if os.path.exists(history_file):
+        try:
+            with open(history_file, 'r', encoding='utf-8') as f:
+                history = json.load(f)
+            history["perplexity_ai_news_june2026"] = {
+                "title": title,
+                "collected_at": datetime.now().isoformat(),
+                "category": "Business"
+            }
+            with open(history_file, 'w', encoding='utf-8') as f:
+                json.dump(history, f, indent=4, ensure_ascii=False)
+            print("Updated history.json")
+        except Exception as e:
+            print(f"Error updating history: {e}")
+
+if __name__ == "__main__":
+    create_article()

news_collection_and_script_generation/cron_processor.py

@@ -0,0 +1,62 @@
+import os
+import json
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+PENDING_FILE = os.path.join(ROOT_DIR, "pending.json")
+
+def main():
+    if not os.path.exists(PENDING_FILE):
+        print("No pending articles queue found.")
+        return
+        
+    try:
+        with open(PENDING_FILE, 'r', encoding='utf-8') as f:
+            pending = json.load(f)
+    except Exception as e:
+        print(f"Failed to read pending queue: {e}")
+        return
+        
+    if not pending:
+        print("No pending articles in queue.")
+        return
+        
+    # Group by category
+    by_category = {}
+    for item in pending:
+        cat = item["category"]
+        if cat not in by_category:
+            by_category[cat] = []
+        by_category[cat].append(item)
+        
+    print(f"=== PENDING ARTICLES FOR SYNTHESIS (Total: {len(pending)}) ===")
+    for category, items in by_category.items():
+        print(f"\nCategory: {category}")
+        for idx, item in enumerate(items, 1):
+            print(f"  {idx}. Title: {item['title']}")
+            print(f"     Link: {item['link']}")
+            print(f"     Source File: {item['source_file']}")
+            
+            src_path = item["source_file"]
+            content = ""
+            if src_path and os.path.exists(src_path):
+                try:
+                    with open(src_path, 'r', encoding='utf-8') as sf:
+                        content = sf.read().strip()
+                except Exception as e:
+                    content = f"Error reading source file: {e}"
+            else:
+                content = "Source file does not exist."
+                
+            truncated = content
+            if len(content) > 1500:
+                truncated = content[:1500] + "... [truncated]"
+                
+            print("     Content:")
+            # Indent content lines for cleaner logs
+            for line in truncated.splitlines():
+                if line.strip():
+                    print(f"       {line}")
+            print("\n" + "-" * 40)
+
+if __name__ == "__main__":
+    main()

news_collection_and_script_generation/evaluate_for_tts.py

@@ -0,0 +1,273 @@
+import os
+import sys
+import json
+import argparse
+import re
+from datetime import datetime
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+LITERT_MODEL_PATH = r"D:\text_encoders\gemma-4-E2B-it-litert-lm\gemma-4-E2B-it.litertlm"
+
+try:
+    import litert_lm
+    HAS_LITERT = True
+except ImportError:
+    HAS_LITERT = False
+
+def evaluate_script_text_quality(script_path):
+    """
+    Perform fast, hard-coded checks on script length and content 
+    before sending it to the LLM.
+    """
+    # 1. Length Check
+    size = os.path.getsize(script_path)
+    if size < 100:
+        return {"status": "FAIL", "reason": f"Script is too short ({size} bytes). Likely an error or placeholder."}
+    if size > 8000:
+        return {"status": "FLAG", "reason": f"Script is unusually long ({size} bytes). May cause TTS timeout."}
+        
+    try:
+        with open(script_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+            
+        # 2. Regex Check: Scraping Errors
+        error_patterns = [
+            r"403\s+forbidden",
+            r"access\s+denied",
+            r"enable\s+javascript",
+            r"please\s+enable\s+cookies",
+            r"cloudflare",
+            r"captcha",
+            r"are\s+you\s+a\s+robot",
+            r"i\s+apologize"
+        ]
+        for pattern in error_patterns:
+            if re.search(pattern, content, re.IGNORECASE):
+                return {"status": "FAIL", "reason": f"Script contains scraping error signature: '{pattern}'"}
+                
+        # 3. Regex Check: TTS-Breaking Elements
+        if re.search(r'https?://[^\s]+', content):
+            return {"status": "FAIL", "reason": "Script contains raw URLs (http:// or https://) which breaks TTS output."}
+            
+        if re.search(r'<\/?(?:html|div|script|style|body|head|iframe|p|span)[^>]*>', content, re.IGNORECASE):
+            return {"status": "FAIL", "reason": "Script contains raw HTML tags."}
+            
+        return {"status": "PASS", "reason": "Passed hard-coded length and regex filters."}
+    except Exception as e:
+        return {"status": "FAIL", "reason": f"Could not read script to check quality: {e}"}
+
+def evaluate_files(article_dir):
+    # Check for main md and scripts
+    md_files = [f for f in os.listdir(article_dir) if f.endswith(".md")]
+    scripts = [f for f in md_files if "script" in f]
+    main_md = [f for f in md_files if "script" not in f]
+    
+    if not main_md:
+        return {"status": "FAIL", "reason": "Main article markdown file not found"}
+    if not scripts:
+        return {"status": "FAIL", "reason": "No generated TTS script markdown files found"}
+        
+    # Check text quality and sizes for each script
+    for script in scripts:
+        script_path = os.path.join(article_dir, script)
+        quality_check = evaluate_script_text_quality(script_path)
+        if quality_check["status"] != "PASS":
+            # Pass up the FAIL or FLAG status immediately
+            return quality_check
+            
+    return {"status": "PASS", "reason": f"Found {len(scripts)} valid script file(s) passing strict quality filters"}
+
+def run_llm_evaluation(engine, article_dir):
+    # Read one script (e.g., script_long.md or the first available script)
+    md_files = [f for f in os.listdir(article_dir) if f.endswith(".md")]
+    scripts = [f for f in md_files if "script" in f]
+    
+    if not scripts:
+        return {"status": "FAIL", "reason": "No script found for LLM evaluation"}
+        
+    # Prefer script_long.md, otherwise just pick the first script
+    script_file = "script_long.md" if "script_long.md" in scripts else scripts[0]
+    
+    content_to_check = ""
+    try:
+        with open(os.path.join(article_dir, script_file), 'r', encoding='utf-8') as f:
+            content_to_check = f.read()[:3000]  # Read up to 3000 chars to avoid context limits
+    except Exception as e:
+        return {"status": "FAIL", "reason": f"Could not read script file: {e}"}
+            
+    if not content_to_check.strip():
+         return {"status": "FAIL", "reason": "Failed to read content for LLM evaluation"}
+         
+    prompt = f"""You are a strict QA evaluator for a Text-To-Speech (TTS) pipeline.
+Evaluate the following script to determine if it is ready to be synthesized into audio.
+
+--- TTS SCRIPT ---
+{content_to_check}
+------------------
+
+Check for the following issues that would break or ruin the TTS output:
+1. Tone and Flow: Ensure the text flows naturally like a news anchor reading it. It should not sound robotic or abrupt.
+2. AI Artifacts: Ensure the text doesn't contain weird AI artifacts like "As an AI language model..." or "Here is the rewritten text".
+3. Spam/Non-News: Is it an empty placeholder, captcha text, or pure advertisement?
+4. Completeness: Does the script look cut-off or nonsensical?
+
+Respond strictly with a JSON object in this exact format:
+{{
+  "status": "PASS" or "FAIL" or "FLAG",
+  "reason": "Brief explanation of your decision"
+}}
+"""
+
+    try:
+        with engine.create_conversation() as conversation:
+             response = conversation.send_message(prompt)
+             response_text = response["content"][0]["text"].strip()
+             
+             # Extract JSON from response
+             json_start = response_text.find("{")
+             json_end = response_text.rfind("}") + 1
+             if json_start >= 0 and json_end > json_start:
+                 json_str = response_text[json_start:json_end]
+                 result = json.loads(json_str)
+                 return {
+                     "status": result.get("status", "FLAG"),
+                     "reason": result.get("reason", "Could not parse reason from JSON")
+                 }
+             else:
+                 return {"status": "FLAG", "reason": "LLM response did not contain valid JSON"}
+                 
+    except Exception as e:
+        return {"status": "FLAG", "reason": f"LLM evaluation failed with exception: {e}"}
+
+def evaluate_article(engine, article_dir, skip_llm=False):
+    print(f"\nEvaluating for TTS: {os.path.basename(article_dir)}")
+    results = {
+        "timestamp": datetime.now().isoformat(),
+        "status": "PENDING",
+        "checks": {},
+        "reject_reasons": []
+    }
+    
+    # Run checks
+    results["checks"]["files"] = evaluate_files(article_dir)
+    
+    if not skip_llm and engine and results["checks"]["files"]["status"] == "PASS":
+        print("  Running LLM evaluation on scripts...")
+        results["checks"]["llm"] = run_llm_evaluation(engine, article_dir)
+    else:
+        results["checks"]["llm"] = {"status": "SKIP", "reason": "LLM evaluation skipped or text files missing"}
+        
+    # Determine overall status
+    is_rejected = False
+    is_flagged = False
+    
+    for check_name, check_res in results["checks"].items():
+        status = check_res.get("status", "FAIL")
+        if status == "FAIL":
+            is_rejected = True
+            results["reject_reasons"].append(f"[{check_name.upper()}] {check_res.get('reason')}")
+            print(f"  [FAIL] {check_name}: {check_res.get('reason')}")
+        elif status == "FLAG":
+            is_flagged = True
+            results["reject_reasons"].append(f"[{check_name.upper()} FLAGGED] {check_res.get('reason')}")
+            print(f"  [FLAG] {check_name}: {check_res.get('reason')}")
+        else:
+            print(f"  [{status}] {check_name}: {check_res.get('reason')}")
+            
+    if is_rejected:
+        results["status"] = "REJECTED"
+    elif is_flagged:
+        results["status"] = "FLAGGED_FOR_REVIEW"
+    else:
+        results["status"] = "READY_FOR_TTS"
+        
+    print(f"  -> Final TTS Status: {results['status']}")
+    
+    # Save results
+    result_path = os.path.join(article_dir, "evaluation_tts_result.json")
+    try:
+        with open(result_path, 'w', encoding='utf-8') as f:
+            json.dump(results, f, indent=4, ensure_ascii=False)
+    except Exception as e:
+        print(f"  Failed to save evaluation result: {e}")
+        
+    return results["status"]
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate articles and scripts before TTS generation.")
+    parser.add_argument("--locale", type=str, default="en-US", help="Locale to evaluate (default: en-US)")
+    parser.add_argument("--category", type=str, default=None, help="Category to evaluate (e.g. World_Affairs)")
+    parser.add_argument("--skip-llm", action="store_true", help="Skip LLM text-quality evaluation")
+    parser.add_argument("--limit", type=int, default=0, help="Limit number of articles to evaluate. 0 for all.")
+    args = parser.parse_args()
+    
+    locale_dir = os.path.join(ROOT_DIR, args.locale)
+    if not os.path.exists(locale_dir):
+        print(f"Locale directory not found: {locale_dir}")
+        sys.exit(1)
+        
+    article_dirs = []
+    categories = [args.category] if args.category else os.listdir(locale_dir)
+    
+    for category in categories:
+        cat_path = os.path.join(locale_dir, category)
+        if not os.path.isdir(cat_path) or category == "__pycache__":
+            continue
+            
+        for article in os.listdir(cat_path):
+            article_dir = os.path.join(cat_path, article)
+            if os.path.isdir(article_dir) and article not in ["images", "sources"]:
+                article_dirs.append(article_dir)
+                
+    if not article_dirs:
+        print("No articles found to evaluate.")
+        return
+        
+    if args.limit > 0:
+        article_dirs = article_dirs[:args.limit]
+        
+    print(f"Found {len(article_dirs)} articles to evaluate for TTS readiness.")
+    
+    engine = None
+    if not args.skip_llm:
+        if not HAS_LITERT:
+            print("Warning: litert_lm not found. Skipping LLM evaluation.")
+            args.skip_llm = True
+        elif not os.path.exists(LITERT_MODEL_PATH):
+            print(f"Warning: LLM model not found at {LITERT_MODEL_PATH}. Skipping LLM evaluation.")
+            args.skip_llm = True
+        else:
+            print("Loading LiteRT-LM Engine...")
+            try:
+                engine = litert_lm.Engine(LITERT_MODEL_PATH, backend=litert_lm.Backend.GPU, max_num_tokens=2048)
+            except Exception as e:
+                print(f"Failed to load LLM Engine (GPU): {e}. Trying CPU...")
+                try:
+                    engine = litert_lm.Engine(LITERT_MODEL_PATH, backend=litert_lm.Backend.CPU, max_num_tokens=2048)
+                except Exception as e2:
+                    print(f"Failed to load LLM Engine (CPU): {e2}. Skipping LLM evaluation.")
+                    args.skip_llm = True
+
+    stats = {"READY_FOR_TTS": 0, "REJECTED": 0, "FLAGGED_FOR_REVIEW": 0}
+    
+    try:
+        for article_dir in article_dirs:
+            status = evaluate_article(engine, article_dir, args.skip_llm)
+            stats[status] = stats.get(status, 0) + 1
+    finally:
+        if engine:
+            engine.close()
+            
+    print("\n" + "="*40)
+    print("Pre-TTS Evaluation Complete!")
+    print(f"Total articles evaluated: {len(article_dirs)}")
+    print(f"READY_FOR_TTS: {stats['READY_FOR_TTS']}")
+    print(f"FLAGGED_FOR_REVIEW: {stats['FLAGGED_FOR_REVIEW']}")
+    print(f"REJECTED: {stats['REJECTED']}")
+    print("="*40)
+
+if __name__ == "__main__":
+    main()

news_collection_and_script_generation/finalize_articles.py

@@ -0,0 +1,561 @@
+import os
+import re
+import json
+import urllib.request
+import urllib.parse
+import sys
+from datetime import datetime
+import requests
+try:
+    from curl_cffi import requests as requests_cffi
+    HAS_CURL_CFFI = True
+except ImportError:
+    HAS_CURL_CFFI = False
+from googlenewsdecoder import new_decoderv1
+
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+# Dynamic path for importing WatermarkRemover
+sys.path.insert(0, r"C:\Roaming\scripts")
+try:
+    from news_collector.watermark_remover import WatermarkRemover
+    HAS_REMOVER = True
+except ImportError:
+    HAS_REMOVER = False
+
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+HISTORY_FILE = os.path.join(ROOT_DIR, "history.json")
+PENDING_FILE = os.path.join(ROOT_DIR, "pending.json")
+SYNTHESIS_FILE = os.path.join(ROOT_DIR, "synthesis_output.json")
+
+TEST_VIDEO_URL = "https://www.w3schools.com/html/mov_bbb.mp4"
+
+# Fallback images removed for authentic scraping
+
+def load_json(path, default):
+    if os.path.exists(path):
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Failed to load JSON {path}: {e}")
+    return default
+
+def save_json(path, data):
+    try:
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+    except Exception as e:
+        print(f"Failed to save JSON {path}: {e}")
+
+def extract_main_word(title):
+    # Replace underscores and commas with spaces to handle words correctly
+    title = title.replace('_', ' ').replace(',', ' ')
+    
+    is_ja = any(ord(char) > 0x3000 for char in title)
+    
+    # Clean title from source marks
+    cleaned = re.sub(r'\s*-\s*[^-\s]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', title, flags=re.IGNORECASE)
+    cleaned = re.sub(r'_[^_]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', cleaned, flags=re.IGNORECASE)
+    
+    blacklisted = ["ai", "artificial intelligence", "人工知能", "生成ai", "生成系ai"]
+    
+    def is_valid(word):
+        if not word:
+            return False
+        return word.strip().lower() not in blacklisted
+
+    # 1. Look for quotes like 「...」
+    quotes_ja = re.findall(r'「([^」]+)」', cleaned)
+    for q in quotes_ja:
+        if is_valid(q):
+            return q
+            
+    quotes_en = re.findall(r'["\']([^"\']+)["\']', cleaned)
+    for q in quotes_en:
+        if len(q) < 25 and is_valid(q):
+            return q
+
+    # 2. Known key entities list
+    known_keywords = [
+        "OpenAI", "Google", "Amazon", "Bezos", "Trump", "Anthropic", "Microsoft", "Apple", "Nvidia", "Meta", "Musk",
+        "大谷", "オオタニ", "大谷翔平", "小田急", "ソニー", "ソフトバンク", "ChatGPT", "Claude", "IOWN", "サカナAI"
+    ]
+    for kw in known_keywords:
+        if kw.lower() in cleaned.lower() and is_valid(kw):
+            m = re.search(re.escape(kw), cleaned, re.IGNORECASE)
+            if m:
+                return m.group(0)
+
+    if is_ja:
+        # Katakana sequences
+        katakana = re.findall(r'[\u30a1-\u30fc]{2,}', cleaned)
+        for k in katakana:
+            if is_valid(k):
+                return k
+        # Kanji sequences
+        kanji = re.findall(r'[\u4e00-\u9fff]{2,}', cleaned)
+        for k in kanji:
+            if k not in ["米国", "日本", "市場", "世界", "政府", "計画", "導入"] and is_valid(k):
+                return k
+        if kanji:
+            for k in kanji:
+                if is_valid(k):
+                    return k
+        # Alphabetic words
+        alpha = re.findall(r'[a-zA-Z0-9]{2,}', cleaned)
+        for a in alpha:
+            if is_valid(a):
+                return a
+    else:
+        words = re.findall(r'\b[A-Z][a-zA-Z0-9]*\b', cleaned)
+        if words:
+            for w in words:
+                if w.lower() not in ["a", "an", "the", "in", "on", "at", "for", "to", "of", "and", "or", "but", "with", "by", "is", "are", "was", "were"] and is_valid(w):
+                    return w
+            for w in words:
+                if is_valid(w):
+                    return w
+        
+    first_token = re.search(r'\w+', cleaned)
+    if first_token and is_valid(first_token.group(0)):
+        return first_token.group(0)
+        
+    return ""
+
+def safe_filename(name, max_len=40):
+    main_word = extract_main_word(name).strip()
+    
+    cleaned = name.replace('_', ' ').replace(',', ' ')
+    cleaned = re.sub(r'[\\/*?:"<>|\'\`\(\)\[\]]', ' ', cleaned)
+    cleaned = re.sub(r'\s+', ' ', cleaned).strip()
+    
+    if main_word:
+        if cleaned.lower().startswith(main_word.lower()):
+            final_title = cleaned
+        else:
+            final_title = f"{main_word} {cleaned}"
+    else:
+        final_title = cleaned
+        
+    final_title = re.sub(r'\s+', ' ', final_title).strip()
+    
+    if len(final_title) > max_len:
+        final_title = final_title[:max_len].strip()
+        final_title = re.sub(r'[\s\.,\-_\+!@#\$%^&\*]+$', '', final_title)
+        
+    return final_title
+
+def to_file_uri(path):
+    path_part = path.replace(os.sep, '/')
+    return f"file:///{path_part.replace(' ', '%20')}"
+
+def to_markdown_absolute_path(path):
+    return path.replace(os.sep, '/')
+
+def download_file(url, dest_path):
+    print(f"Downloading: {url} -> {dest_path}")
+    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": "image/webp,image/apng,image/*,*/*;q=0.8",
+        "Accept-Language": "ja,en-US;q=0.9,en;q=0.8",
+        "Referer": "https://news.google.com/"
+    }
+    try:
+        os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+        if HAS_CURL_CFFI:
+            response = requests_cffi.get(url, headers=headers, impersonate="chrome120", timeout=30)
+        else:
+            response = requests.get(url, headers=headers, timeout=30)
+        response.raise_for_status()
+        with open(dest_path, 'wb') as f:
+            f.write(response.content)
+            
+        if os.path.exists(dest_path) and os.path.getsize(dest_path) > 0:
+            print(f"Download success: {dest_path} ({os.path.getsize(dest_path)} bytes)")
+            return True
+        else:
+            print(f"Downloaded file is empty: {dest_path}")
+            if os.path.exists(dest_path):
+                os.remove(dest_path)
+            return False
+    except Exception as e:
+        print(f"Failed to download {url}: {e}")
+        if os.path.exists(dest_path):
+            try:
+                os.remove(dest_path)
+            except:
+                pass
+        return False
+
+def is_valid_image(img_url, img_path):
+    # 1. URL Substring Check
+    url_lower = img_url.lower()
+    
+    # Generic keywords indicating logos, default fallback pictures, ads, etc.
+    blacklist_keywords = [
+        "logo", "avatar", "favicon", "icon", "placeholder", "default", "fallback", 
+        "dummy", "spacer", "pixel", "header", "footer", "ad-", "ads-", 
+        "advertisement", "newsletter", "subscribe", "sign-up", "social-share", 
+        "facebook-share", "twitter-share", "share-icon", "share-logo",
+        "app-store", "play-store", "transparent", "blank", "branding"
+    ]
+    
+    # Also block specific generic image names commonly used by news outlets
+    # e.g., Yahoo, Reuters, AP, Bloomberg, BBC, etc. logos or generic graphics
+    generic_patterns = [
+        "reuters-logo", "reuters_logo", "nytimes-logo", "nytimes_logo",
+        "ap-logo", "ap_logo", "bbc-logo", "bbc_logo", "cnn-logo", "cnn_logo",
+        "bloomberg-logo", "bloomberg_logo", "yahoo-logo", "yahoo_logo",
+        "wsj_logo", "wsj-logo", "guardian-logo", "guardian_logo"
+    ]
+    
+    for kw in blacklist_keywords:
+        if kw in url_lower:
+            print(f"      Rejecting image URL (matches blacklist keyword '{kw}'): {img_url}")
+            return False
+            
+    for pat in generic_patterns:
+        if pat in url_lower:
+            print(f"      Rejecting image URL (matches generic logo pattern '{pat}'): {img_url}")
+            return False
+
+    # 2. Image Content Check (using Pillow)
+    if not os.path.exists(img_path):
+        return False
+        
+    try:
+        from PIL import Image, ImageStat
+        with Image.open(img_path) as img:
+            width, height = img.size
+            
+            # Aspect Ratio
+            aspect_ratio = width / height
+            
+            # Minimum dimension requirements
+            min_width = 300
+            min_height = 200
+            
+            if width < min_width or height < min_height:
+                print(f"      Rejecting image (too small: {width}x{height}, required min {min_width}x{min_height})")
+                return False
+                
+            # Aspect Ratio Check (block extremely wide/tall banner or ad layout blocks)
+            if aspect_ratio < 0.5 or aspect_ratio > 3.0:
+                print(f"      Rejecting image (extreme aspect ratio: {aspect_ratio:.2f})")
+                return False
+                
+            # Perfect square check (width == height) for small images (usually logos/avatars)
+            if width == height and width < 450:
+                print(f"      Rejecting image (square logo/avatar heuristic: {width}x{height})")
+                return False
+                
+            # Standard Deviation check (blank or solid color placeholder images)
+            # A natural photograph typically has standard deviation > 10.
+            # Spacer GIFs or blank images will have standard deviation near 0.
+            stat = ImageStat.Stat(img)
+            # Check standard deviation of all bands (RGB / RGBA / L)
+            std_devs = stat.stddev
+            if std_devs and all(sd < 3.0 for sd in std_devs):
+                print(f"      Rejecting image (low variance / solid color placeholder: stddev={std_devs})")
+                return False
+                
+    except ImportError:
+        print("      Warning: Pillow (PIL) is not installed. Skipping image dimension and content validation.")
+    except Exception as e:
+        print(f"      Warning: Failed to validate image content properties: {e}")
+        
+    return True
+
+def extract_og_image(url):
+    print(f"Extracting og:image from: {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": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "ja,en-US;q=0.9,en;q=0.8",
+        "Referer": "https://news.google.com/"
+    }
+    try:
+        if HAS_CURL_CFFI:
+            response = requests_cffi.get(url, headers=headers, impersonate="chrome120", timeout=15)
+        else:
+            response = requests.get(url, headers=headers, timeout=15)
+        response.raise_for_status()
+        html = response.text
+        m = re.search(r'<meta[^>]*property=[\'"]og:image[\'"][^>]*content=[\'"]([^\'"]+)[\'"]', html, re.I)
+        if m:
+            return m.group(1)
+        m2 = re.search(r'<meta[^>]*content=[\'"]([^\'"]+)[\'"][^>]*property=[\'"]og:image[\'"]', html, re.I)
+        if m2:
+            return m2.group(1)
+    except Exception as e:
+        print(f"Failed to fetch og:image from {url}: {e}")
+    return None
+
+
+def finalize_article(category, title, link, article_content, source_file):
+    print(f"\nFinalizing article: {title} under category: {category}")
+    
+    safe_title = safe_filename(title)
+    
+    # Determine language (ja-JP if title contains Japanese characters, else en-US)
+    is_ja = any(ord(char) > 0x3000 for char in title)
+    lang = "ja-JP" if is_ja else "en-US"
+    
+    # Map raw RSS category to directory category name
+    CAT_MAP = {
+        "Business": "Business_and_Economy",
+        "World_Affairs": "World_Affairs",
+        "General": "General_News",
+        "Animals": "Science_and_Animals"
+    }
+    cat_folder = CAT_MAP.get(category, "Uncategorized")
+    
+    # Create article-specific directory structure under appropriate language/category
+    article_dir = os.path.join(ROOT_DIR, lang, cat_folder, safe_title)
+    images_dir = os.path.join(article_dir, "images")
+    sources_dir = os.path.join(article_dir, "sources")
+    
+    os.makedirs(images_dir, exist_ok=True)
+    os.makedirs(sources_dir, exist_ok=True)
+    
+    # 1. Rename raw source file and collect details
+    downloaded_sources = []
+    if source_file and os.path.exists(source_file):
+        final_filename = f"{safe_title}_source_1.txt"
+        final_dest = os.path.join(sources_dir, final_filename)
+        try:
+            if os.path.exists(final_dest):
+                os.remove(final_dest)
+            os.rename(source_file, final_dest)
+            downloaded_sources.append((title, to_file_uri(final_dest)))
+            print(f"Moved source file: {source_file} -> {final_dest}")
+        except Exception as e:
+            print(f"Failed to move source file {source_file} to {final_dest}: {e}")
+            downloaded_sources.append((title, to_file_uri(source_file)))
+    else:
+        print(f"Source file not found or not specified for: {title}")
+        
+    # 2. Download authentic images from source link
+    image_urls = []
+    
+    decoded_link = link
+    if "news.google.com" in link:
+        try:
+            res = new_decoderv1(link, interval=1)
+            if res.get("status"):
+                decoded_link = res["decoded_url"]
+                print(f"Decoded Google News URL for image extraction: {decoded_link}")
+        except Exception as e:
+            print(f"Failed to decode Google News URL {link} for image extraction: {e}")
+            
+    og_img = extract_og_image(decoded_link)
+    if og_img:
+        image_urls.append(og_img)
+        
+    downloaded_images = []
+    
+    # Initialize WatermarkRemover if available
+    from pathlib import Path
+    remover = WatermarkRemover(Path(ROOT_DIR)) if HAS_REMOVER else None
+    
+    for idx, url in enumerate(image_urls[:2], 1):
+        img_filename = f"{safe_title}_img{idx}.jpg"
+        img_dest = os.path.join(images_dir, img_filename)
+        success = download_file(url, img_dest)
+            
+        if success:
+            if not is_valid_image(url, img_dest):
+                print(f"Rejected downloaded image as unrelated: {url}")
+                if os.path.exists(img_dest):
+                    try:
+                        os.remove(img_dest)
+                    except:
+                        pass
+                continue
+                
+            downloaded_images.append(img_dest)
+            if remover:
+                try:
+                    remover.remove_watermark(Path(img_dest), decoded_link)
+                except Exception as rem_err:
+                    print(f"Failed to remove watermark for {img_dest}: {rem_err}")
+
+    # 3. No related video briefing available by default. Omit placeholder.
+    video_embed_md = ""
+
+    # 4. Inject Carousel at the top (right after title or date)
+    if downloaded_images:
+        lines = article_content.splitlines()
+        title_idx = -1
+        for i, line in enumerate(lines):
+            if line.strip().startswith("# "):
+                title_idx = i
+                break
+        
+        date_idx = -1
+        if title_idx != -1:
+            for i in range(title_idx + 1, len(lines)):
+                if lines[i].strip():
+                    date_idx = i
+                    break
+        
+        insert_idx = -1
+        if date_idx != -1:
+            insert_idx = date_idx + 1
+        elif title_idx != -1:
+            insert_idx = title_idx + 1
+        
+        if insert_idx != -1:
+            carousel_lines = ["", "```carousel"]
+            for j, img_path in enumerate(downloaded_images, 1):
+                if j > 1:
+                    carousel_lines.append("<!-- slide -->")
+                carousel_lines.append(f"![Visual Theme {j}]({to_markdown_absolute_path(img_path)})")
+            carousel_lines.append("```")
+            carousel_lines.append("")
+            lines = lines[:insert_idx] + carousel_lines + lines[insert_idx:]
+            article_content = "\n".join(lines)
+
+    # 5. Inject Video embed before the footer
+    if video_embed_md:
+        footer_idx = article_content.rfind("---")
+        if footer_idx != -1:
+            article_content = article_content[:footer_idx] + video_embed_md + article_content[footer_idx:]
+        else:
+            article_content += video_embed_md
+
+    # 6. Inject Source document preview iframe before the footer
+    if downloaded_sources:
+        sources_preview_md = "\n\n### Original Source Document Previews\n"
+        for title_src, uri in downloaded_sources[:3]:
+            sources_preview_md += f"#### {title_src}\n<iframe src=\"{uri}\" width=\"100%\" height=\"450px\" style=\"border: 1px solid #ccc; margin-bottom: 20px;\"></iframe>\n"
+        
+        footer_idx = article_content.rfind("---")
+        if footer_idx != -1:
+            article_content = article_content[:footer_idx] + sources_preview_md + article_content[footer_idx:]
+        else:
+            article_content += sources_preview_md
+
+    # 7. Save the final Markdown file inside the article directory
+    dest_file_path = os.path.join(article_dir, f"{safe_title}.md")
+    try:
+        with open(dest_file_path, 'w', encoding='utf-8') as f:
+            f.write(article_content)
+        print(f"Saved Article successfully: {dest_file_path}")
+        
+        # 7.5. Check if it's Russian, Ukrainian, or independent media to assign S-Tier (tier 1)
+        is_s_tier = False
+        s_tier_domains = [
+            "meduza.io", "themoscowtimes.com", "kyivindependent.com", "pravda.com.ua", 
+            "novayagazeta.eu", "novayagazeta.ru", "zona.media", "mediazona.ca", 
+            "tvrain.tv", "tvrain.ru", "istories.media", "theins.ru", "theins.press", 
+            "verstka.media", "currenttime.tv", "rferl.org", "unian.net", "unian.info", 
+            "euromaidanpress.com", "ukrinform.net", "ukrinform.ua", "hromadske.ua"
+        ]
+        link_lower = link.lower()
+        decoded_link_lower = decoded_link.lower()
+        if any(domain in link_lower or domain in decoded_link_lower for domain in s_tier_domains):
+            is_s_tier = True
+            
+        if is_s_tier:
+            meta_dest = os.path.join(article_dir, f"{safe_title}.json")
+            try:
+                with open(meta_dest, 'w', encoding='utf-8') as mf:
+                    json.dump({
+                        "importance": 9,
+                        "urgency": 9,
+                        "tier": 1
+                    }, mf, indent=4)
+                print(f"Automatically assigned S-Tier (tier 1) for independent RU/UA source: {meta_dest}")
+            except Exception as e:
+                print(f"Failed to write S-Tier metadata for {safe_title}: {e}")
+                
+        return True
+    except Exception as e:
+        print(f"Failed to save article {safe_title}: {e}")
+        return False
+
+def main():
+    print(f"Starting finalization at {datetime.now().isoformat()}")
+    synthesis_data = load_json(SYNTHESIS_FILE, [])
+    if not synthesis_data:
+        print("No synthesis data found. Exiting.")
+        return []
+
+    history = load_json(HISTORY_FILE, {})
+    pending_list = load_json(PENDING_FILE, [])
+    
+    processed_count = 0
+    newly_processed_urls = set()
+    finalized_dirs = []
+    
+    for article_dict in synthesis_data:
+        category = article_dict.get("category")
+        title = article_dict.get("title")
+        link = article_dict.get("link")
+        markdown = article_dict.get("markdown")
+        source_file = article_dict.get("source_file")
+        
+        if not markdown or not link:
+            continue
+            
+        success = finalize_article(category, title, link, markdown, source_file)
+        if success:
+            processed_count += 1
+            newly_processed_urls.add(link)
+            history[link] = {
+                "title": title,
+                "collected_at": datetime.now().isoformat(),
+                "category": category
+            }
+            # Reconstruct the exact path where the article was finalized
+            safe_title = safe_filename(title)
+            is_ja = any(ord(char) > 0x3000 for char in title)
+            lang = "ja-JP" if is_ja else "en-US"
+            CAT_MAP = {
+                "Business": "Business_and_Economy",
+                "World_Affairs": "World_Affairs",
+                "General": "General_News",
+                "Animals": "Science_and_Animals"
+            }
+            cat_folder = CAT_MAP.get(category, "Uncategorized")
+            article_dir = os.path.join(ROOT_DIR, lang, cat_folder, safe_title)
+            finalized_dirs.append(article_dir)
+                
+    if processed_count > 0:
+        if len(history) > 2000:
+            sorted_keys = sorted(history.keys(), key=lambda k: history[k].get("collected_at", ""))
+            for k in sorted_keys[:len(history) - 2000]:
+                del history[k]
+        save_json(HISTORY_FILE, history)
+        
+        updated_pending = [item for item in pending_list if item["link"] not in newly_processed_urls]
+        save_json(PENDING_FILE, updated_pending)
+        
+        print(f"Successfully finalized {processed_count} articles.")
+    
+    # Clean up temp_sources directory if empty
+    temp_sources_dir = os.path.join(ROOT_DIR, "temp_sources")
+    if os.path.exists(temp_sources_dir):
+        try:
+            if not os.listdir(temp_sources_dir):
+                os.rmdir(temp_sources_dir)
+                print("Removed empty temp_sources directory.")
+        except Exception as e:
+            print(f"Failed to check/remove temp_sources directory: {e}")
+
+    if os.path.exists(SYNTHESIS_FILE):
+        try:
+            os.remove(SYNTHESIS_FILE)
+            print("Cleared synthesis_output.json")
+        except Exception as e:
+            print(f"Failed to delete synthesis_output.json: {e}")
+            
+    return finalized_dirs
+
+if __name__ == "__main__":
+    main()

news_collection_and_script_generation/generate_scripts_all.py

@@ -0,0 +1,349 @@
+import os
+import re
+import sys
+import json
+import argparse
+from datetime import datetime
+
+# Reconfigure encoding to avoid Windows console encoding issues
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+LITERT_MODEL_PATH = r"D:\text_encoders\gemma-4-E2B-it-litert-lm\gemma-4-E2B-it.litertlm"
+
+try:
+    import litert_lm
+    HAS_LITERT = True
+except ImportError:
+    HAS_LITERT = False
+
+def clean_for_tts(text):
+    lines = text.splitlines()
+    cleaned_lines = []
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        # Skip headers
+        if line.startswith('#'):
+            continue
+        
+        # Remove speaker labels like "**Anchor:**" or "**Correspondent (Riga):**" or "Military Analyst:"
+        line = re.sub(r'^\**[A-Za-z0-9\s\(\)\.\-\_]+:\**\s*', '', line)
+        
+        # Remove parenthetical performance notes or sound effects like (Opening music...) or [Music]
+        line = re.sub(r'\([^)]*\)', '', line)
+        line = re.sub(r'\[[^\]]*\]', '', line)
+        
+        # Remove markdown bold/italic markers
+        line = line.replace('**', '').replace('*', '')
+        
+        # Remove leading/trailing quotes
+        line = line.strip()
+        if line.startswith('"') and line.endswith('"'):
+            line = line[1:-1]
+        elif line.startswith('“') and line.endswith('”'):
+            line = line[1:-1]
+            
+        line = line.strip()
+        if line:
+            cleaned_lines.append(line)
+            
+    return '\n\n'.join(cleaned_lines)
+
+def detect_japanese(text):
+    # Check for Hiragana (0x3040-0x309F), Katakana (0x30A0-0x30FF), or Kanji (0x4E00-0x9FFF)
+    for char in text:
+        cp = ord(char)
+        if (0x3040 <= cp <= 0x309F) or (0x30A0 <= cp <= 0x30FF) or (0x4E00 <= cp <= 0x9FFF):
+            return True
+    return False
+
+def generate_script_prompt(article_title, article_content, length_type, is_ja):
+    lang_name = "Japanese" if is_ja else "English"
+    is_very_short = len(article_content.strip()) < 300
+    
+    if length_type == "short":
+        word_limit = "100 words" if is_very_short else "200 words"
+    elif length_type == "middle":
+        word_limit = "200 words" if is_very_short else "400 words"
+    else: # long
+        word_limit = "400 words" if is_very_short else "800-1000 words"
+
+    # Common rules for anchor script
+    if is_ja:
+        rules = """1. スクリプトは日本語で書いてください。
+2. ニュースキャスターが声に出して読み上げるのに適した、自然で分かりやすい話し言葉（です・ます調）にしてください。
+3. 主観的な解説や、「この記事は～」「この記事が強調するように～」といったメタ的な表現（記事そのものに言及する表現）は絶対に含めないでください。あなた自身がニュースを直接伝えているキャスターであるかのように描写してください。
+4. 「これは〜を示唆しています」「この状況は〜という複雑な現実を浮き彫りにしています」のような学術的・分析的な表現は避け、事実と状況をストレートに伝えてください。
+5. 自然な導入フレーズ（例：「こんばんは。本日お伝えするニュースは、」など）で始め、最後は「アンドロイド・タイムズがお伝えしました。」という結びの言葉で終わらせてください。
+6. 単一のキャスターが連続して読み上げる形式にしてください。対話形式やヘッダー（「導入」「背景」など）、話者ラベル（「キャスター：」「ナレーター：」など）は含めないでください。"""
+    else:
+        rules = """1. Write the script in clear, spoken English, suitable for reading aloud.
+2. Use a professional yet conversational tone, typical of international news broadcasts.
+3. Act as if YOU are reporting the news firsthand as a live anchor. Crucially, do NOT say "The article says", "The article highlights", "According to the article", "This report", or refer to the text/article itself in any metatextual way.
+4. Avoid analytical or academic phrasing like "This suggests...", "The narrative...", "This highlights...". Focus only on the facts and developments of the event.
+5. Begin the script with a natural introductory phrase (e.g., "Good evening. Today, we turn to..." or "Tonight, we have an important update regarding...").
+6. Sign-off by explicitly saying a closing phrase such as "Reporting for The Android Times."
+7. Crucially, do NOT include any speaker labels (e.g., do NOT write '**Anchor:**', '**Reporter:**', etc.) or section headers. Just output the clean script text. Do not wrap paragraphs in quotation marks.
+8. Ensure correct grammar and natural phrasing. Do not omit necessary articles (e.g., say "An airstrike..." instead of "Airstrike...")."""
+
+    prompt = f"""You are a professional news anchor.
+Write a {length_type}-length news script (about {word_limit}) in {lang_name} based on the following article.
+{"Since the article content is extremely brief, expand on the potential implications and general context of this news." if is_very_short and length_type == "long" else ""}
+The script should be optimized for a news broadcast voiceover.
+
+Article Title: {article_title}
+Article Content:
+{article_content}
+
+Requirements:
+{rules}
+Keep it to approximately {word_limit} (or equivalent length in Japanese).
+Return only the script content. Do not include any introductory or concluding chat remarks or code block formatting (like ```).
+"""
+    return prompt
+
+
+def strip_forbidden_labels(text):
+    forbidden_patterns = [
+        r'^([\s\*\-]*)\**Anchor\b:\**\s*',
+        r'^([\s\*\-]*)\**Reporter\b:\**\s*',
+        r'^([\s\*\-]*)\**Correspondent\b:\**\s*',
+        r'^([\s\*\-]*)\**Presenter\b:\**\s*',
+        r'^([\s\*\-]*)\**Narrator\b:\**\s*',
+        r'^([\s\*\-]*)\**Host\b:\**\s*',
+        r'^([\s\*\-]*)\**Voiceover\b:\**\s*'
+    ]
+    lines = text.splitlines()
+    cleaned_lines = []
+    for line in lines:
+        cleaned_line = line
+        for pattern in forbidden_patterns:
+            cleaned_line = re.sub(pattern, r'\1', cleaned_line, flags=re.IGNORECASE)
+        cleaned_lines.append(cleaned_line)
+    return '\n'.join(cleaned_lines)
+
+
+def process_article(engine, article_dir, force):
+    dir_name = os.path.basename(article_dir)
+    print(f"\nProcessing article directory: {dir_name}")
+    
+    # Find the main article file (same name as directory, or ends with .md but not a script)
+    md_files = [f for f in os.listdir(article_dir) if f.endswith(".md")]
+    main_article_file = None
+    for f in md_files:
+        if not f.endswith(("script_short.md", "script_middle.md", "script_long.md", "script_normal.md", "script.md")):
+            main_article_file = f
+            break
+            
+    if not main_article_file:
+        # Fallback: search for any .md file
+        for f in md_files:
+            main_article_file = f
+            break
+            
+    if not main_article_file:
+        print(f"Error: No main markdown file found in {dir_name}. Skipping.")
+        return False
+        
+    main_article_path = os.path.join(article_dir, main_article_file)
+    try:
+        with open(main_article_path, 'r', encoding='utf-8') as f:
+            article_content = f.read().strip()
+    except Exception as e:
+        print(f"Error reading {main_article_path}: {e}. Skipping.")
+        return False
+        
+    # Get article title
+    title_m = re.match(r'^#\s+(.+)$', article_content.splitlines()[0])
+    article_title = title_m.group(1) if title_m else dir_name
+    
+    is_ja = detect_japanese(article_content)
+    print(f"Detected language: {'Japanese' if is_ja else 'English'}")
+    
+    lengths = ["short", "middle", "long"]
+    generated_any = False
+    
+    for length in lengths:
+        script_file_name = f"script_{length}.md"
+        script_path = os.path.join(article_dir, script_file_name)
+        txt_file_name = f"script_{length}_clean.txt"
+        txt_path = os.path.join(article_dir, txt_file_name)
+        
+        # Check if files already exist
+        if os.path.exists(script_path) and os.path.exists(txt_path) and not force:
+            print(f"  {length} script and TTS text already exist. Skipping.")
+            continue
+            
+        print(f"  Generating {length} script...")
+        prompt = generate_script_prompt(article_title, article_content, length, is_ja)
+        
+        try:
+            with engine.create_conversation() as conversation:
+                response = conversation.send_message(prompt)
+                script_text = response["content"][0]["text"].strip()
+                
+            # Strip forbidden speaker labels from the script markdown itself
+            script_text = strip_forbidden_labels(script_text)
+            
+            # Write markdown script
+            with open(script_path, 'w', encoding='utf-8') as f:
+                f.write(script_text)
+            print(f"    Saved script: {script_path}")
+            
+            # Clean for TTS and write text file
+            clean_text = clean_for_tts(script_text)
+            with open(txt_path, 'w', encoding='utf-8') as f:
+                f.write(clean_text)
+            print(f"    Saved TTS text: {txt_path}")
+            
+            generated_any = True
+        except Exception as e:
+            print(f"    Error generating {length} script: {e}")
+            
+    return generated_any
+
+def main():
+    parser = argparse.ArgumentParser(description="Batch generate news scripts and clean TTS text files for all articles.")
+    parser.add_argument("--limit", type=int, default=5, help="Maximum number of articles to process in this run. Default is 5.")
+    parser.add_argument("--category", type=str, default=None, help="Process only a specific category (e.g. World_Affairs).")
+    parser.add_argument("--locale", type=str, default=None, help="Process only a specific locale (e.g. en-US, ja-JP).")
+    parser.add_argument("--force", action="store_true", help="Force regeneration of scripts even if they exist.")
+    parser.add_argument("--all", action="store_true", help="Process all articles without limit.")
+    parser.add_argument("--gpu", action="store_true", help="Use GPU backend for inference.")
+    args = parser.parse_args()
+
+    if not HAS_LITERT:
+        print("Error: litert_lm package is not installed. Please check environment.")
+        sys.exit(1)
+        
+    if not os.path.exists(LITERT_MODEL_PATH):
+        print(f"Error: Model not found at {LITERT_MODEL_PATH}")
+        sys.exit(1)
+
+    # Scan article directories
+    locales = [args.locale] if args.locale else ["en-US", "en-EU", "ja-JP", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]
+    article_dirs = []
+    
+    for locale in locales:
+        locale_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(locale_path) or not os.path.isdir(locale_path):
+            continue
+            
+        categories = [args.category] if args.category else os.listdir(locale_path)
+        for category in categories:
+            if category in ["__pycache__"]:
+                continue
+            cat_path = os.path.join(locale_path, category)
+            if not os.path.exists(cat_path) or not os.path.isdir(cat_path):
+                continue
+                
+            articles = os.listdir(cat_path)
+            for article in articles:
+                if article in ["__pycache__", "images", "sources"]:
+                    continue
+                article_path = os.path.join(cat_path, article)
+                if os.path.isdir(article_path):
+                    # Check if it has a main markdown file
+                    md_files = [f for f in os.listdir(article_path) if f.endswith(".md")]
+                    if md_files:
+                        article_dirs.append(article_path)
+
+    def get_priority_score(article_dir):
+        path_lower = article_dir.lower()
+        score = 0
+        if "en-us" in path_lower:
+            score += 10000
+        if "en-us" in path_lower and "moscow_attacks" in path_lower:
+            score += 1000
+        elif "moscow_attacks" in path_lower:
+            score += 500
+        elif "war_and_military" in path_lower:
+            score += 400
+        
+        # War-related keywords in English and Japanese
+        war_keywords = [
+            "war", "military", "conflict", "attack", "bombing", "invasion", 
+            "soldier", "battle", "clash", "defense", "missile", "drone", 
+            "bomb", "strike", "shelling", "army", "troop", "nato", "putin", 
+            "ukraine", "russia", "kremlin", "pentagon", "blasts",
+            "戦争", "軍事", "衝突", "攻撃", "爆撃", "侵攻", "兵士", "戦闘", 
+            "ミサイル", "ドローン", "爆発", "ウクライナ", "ロシア", "プーチン"
+        ]
+        if any(kw in path_lower for kw in war_keywords):
+            score += 200
+        return score
+
+    # Sort by priority score descending first, then by modification time descending
+    article_dirs.sort(key=lambda x: (get_priority_score(x), os.path.getmtime(x)), reverse=True)
+
+    print(f"Found total of {len(article_dirs)} articles.")
+    
+    # Filter directories depending on whether they need processing (unless --force is set)
+    dirs_to_process = []
+    for d in article_dirs:
+        # Check if script_short.md and script_short_clean.txt etc. exist
+        all_exist = True
+        for length in ["short", "middle", "long"]:
+            script_path = os.path.join(d, f"script_{length}.md")
+            txt_path = os.path.join(d, f"script_{length}_clean.txt")
+            if not os.path.exists(script_path) or not os.path.exists(txt_path):
+                all_exist = False
+                break
+        if not all_exist or args.force:
+            dirs_to_process.append(d)
+            
+    print(f"Articles requiring script generation: {len(dirs_to_process)}")
+    
+    if not dirs_to_process:
+        print("All articles already have scripts. Use --force to regenerate.")
+        return
+
+    # Apply limit
+    limit = len(dirs_to_process) if args.all else args.limit
+    dirs_to_process = dirs_to_process[:limit]
+    print(f"Will process {len(dirs_to_process)} articles in this run.")
+
+    # Helper to check GPU utilization
+    def is_gpu_busy(threshold_util=25):
+        import subprocess
+        try:
+            output = subprocess.check_output(
+                ['nvidia-smi', '--query-gpu=utilization.gpu', '--format=csv,noheader,nounits'],
+                stderr=subprocess.DEVNULL
+            ).decode().strip()
+            util = int(output.strip())
+            return util > threshold_util
+        except Exception:
+            return False
+
+    processed_count = 0
+    
+    for idx, article_dir in enumerate(dirs_to_process, 1):
+        print(f"\n--- Article {idx}/{len(dirs_to_process)} ---")
+        
+        # Select backend dynamically based on GPU load
+        current_backend = litert_lm.Backend.CPU
+        backend_name = "CPU"
+        if args.gpu:
+            if is_gpu_busy():
+                print("GPU is currently busy (utilization > 25%). Falling back to CPU backend for this article to avoid contention and timeouts.")
+            else:
+                current_backend = litert_lm.Backend.GPU
+                backend_name = "GPU"
+
+        print(f"Loading LiteRT-LM Engine with Gemma-4 model on {backend_name}...")
+        try:
+            with litert_lm.Engine(LITERT_MODEL_PATH, backend=current_backend, max_num_tokens=8192) as engine:
+                success = process_article(engine, article_dir, args.force)
+                if success:
+                    processed_count += 1
+        except Exception as engine_err:
+            print(f"LiteRT-LM engine error for article {idx}: {engine_err}")
+        
+    print(f"\nFinished. Successfully generated scripts for {processed_count} articles.")
+
+if __name__ == "__main__":
+    main()

news_collection_and_script_generation/generator_task_config.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Date>2026-07-09T17:45:00</Date>
+    <Author>AntigravityAI</Author>
+    <Description>Automatically generate English (US) news scripts using LiteRT-LM (Gemma-4) every 15 minutes.</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <Repetition>
+        <Interval>PT15M</Interval>
+        <StopAtDurationEnd>false</StopAtDurationEnd>
+      </Repetition>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>false</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT2H</ExecutionTimeLimit>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>wscript.exe</Command>
+      <Arguments>C:\ComfyUI\Articles\run_generator_silent.vbs</Arguments>
+    </Exec>
+  </Actions>
+</Task>

news_collection_and_script_generation/quality_gate_articles.py

@@ -0,0 +1,410 @@
+import os
+import json
+import sys
+import re
+import difflib
+from datetime import datetime
+
+try:
+    import litert_lm
+except ImportError:
+    litert_lm = None
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+SYNTHESIS_FILE = os.path.join(ROOT_DIR, "synthesis_output.json")
+LITERT_MODEL_PATH = r"D:\text_encoders\gemma-4-E2B-it-litert-lm\gemma-4-E2B-it.litertlm"
+
+def get_existing_article_titles():
+    """
+    Scan category directories under locales (en-US, en-EU, ja-JP) to collect 
+    existing sanitized titles/folder names for duplicate detection.
+    """
+    titles = set()
+    locales = ["en-US", "en-EU", "ja-JP", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]
+    for locale in locales:
+        loc_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(loc_path):
+            continue
+        for cat in os.listdir(loc_path):
+            cat_path = os.path.join(loc_path, cat)
+            if not os.path.isdir(cat_path) or cat == "__pycache__":
+                continue
+            for art in os.listdir(cat_path):
+                art_path = os.path.join(cat_path, art)
+                if os.path.isdir(art_path) and art not in ["__pycache__", "images", "sources"]:
+                    titles.add(art.lower())
+                    titles.add(art.replace('_', ' ').lower())
+    return titles
+
+def is_duplicate(new_title, existing_titles, current_batch_titles, threshold=0.8):
+    """
+    Check if a new article title is a duplicate of past articles or current batch.
+    Uses SequenceMatcher ratio with a length-difference speed filter.
+    """
+    new_title_clean = new_title.strip().lower()
+    
+    # 1. Exact matches
+    if new_title_clean in existing_titles or new_title_clean in current_batch_titles:
+        return True, "Exact title match"
+        
+    # 2. Similarity checks against existing articles
+    for ext_title in existing_titles:
+        # Fast optimization: skip if length difference is too large
+        if abs(len(new_title_clean) - len(ext_title)) > max(10, len(new_title_clean) * 0.4):
+            continue
+        ratio = difflib.SequenceMatcher(None, new_title_clean, ext_title).ratio()
+        if ratio >= threshold:
+            return True, f"High similarity ({int(ratio*100)}%) with existing article: '{ext_title}'"
+            
+    # 3. Similarity checks against current batch
+    for cur_title in current_batch_titles:
+        if abs(len(new_title_clean) - len(cur_title)) > max(10, len(new_title_clean) * 0.4):
+            continue
+        ratio = difflib.SequenceMatcher(None, new_title_clean, cur_title).ratio()
+        if ratio >= threshold:
+            return True, f"High similarity ({int(ratio*100)}%) with another article in this batch: '{cur_title}'"
+            
+    return False, ""
+
+
+def clean_article_text(markdown_content):
+    """
+    Remove markdown headers, metadata lines, image embeds, links, and common footers
+    to extract the pure body text of the article for similarity comparison.
+    """
+    if not markdown_content:
+        return ""
+    
+    lines = markdown_content.splitlines()
+    cleaned_lines = []
+    
+    for line in lines:
+        line_strip = line.strip()
+        if not line_strip:
+            continue
+        if line_strip.startswith("#"):
+            continue
+        if line_strip.startswith("**Category:**") or line_strip.startswith("**Locale:**") or line_strip.startswith("**Source:**") or line_strip.startswith("**Date Collected:**"):
+            continue
+        if line_strip.startswith("!["):
+            continue
+        if line_strip == "---":
+            continue
+        if "*This article was automatically collected" in line_strip or "scraped" in line_strip.lower():
+            continue
+            
+        cleaned_lines.append(line_strip)
+        
+    text = " ".join(cleaned_lines)
+    text = re.sub(r'<[^>]+>', '', text)
+    text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def get_recent_article_bodies(max_per_category=30):
+    """
+    Scan category directories under locales (en-US, en-EU, ja-JP) to collect 
+    recent articles' markdown file paths, read their content, and return a dict of {title: cleaned_body}.
+    """
+    recent_bodies = {}
+    locales = ["en-US", "en-EU", "ja-JP", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]
+    for locale in locales:
+        loc_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(loc_path):
+            continue
+        for cat in os.listdir(loc_path):
+            cat_path = os.path.join(loc_path, cat)
+            if not os.path.isdir(cat_path) or cat == "__pycache__":
+                continue
+            
+            articles = []
+            for art in os.listdir(cat_path):
+                art_path = os.path.join(cat_path, art)
+                if os.path.isdir(art_path) and art not in ["__pycache__", "images", "sources"]:
+                    try:
+                        mtime = os.path.getmtime(art_path)
+                        articles.append((art, art_path, mtime))
+                    except Exception:
+                        continue
+            
+            articles.sort(key=lambda x: x[2], reverse=True)
+            for art, art_path, _ in articles[:max_per_category]:
+                md_file_name = f"{art}.md"
+                md_file_path = os.path.join(art_path, md_file_name)
+                if os.path.exists(md_file_path):
+                    try:
+                        with open(md_file_path, "r", encoding="utf-8") as f:
+                            content = f.read()
+                        cleaned = clean_article_text(content)
+                        if cleaned:
+                            recent_bodies[art.lower()] = cleaned
+                    except Exception as e:
+                        print(f"Error reading past article {md_file_path}: {e}")
+    return recent_bodies
+
+def get_words(text):
+    """
+    Extract alphanumeric words from text and normalize to lowercase.
+    For Japanese, extract character bi-grams (2-character pairs) to improve similarity precision.
+    """
+    text_lower = text.lower()
+    is_ja = any(ord(char) > 0x3000 for char in text_lower)
+    if is_ja:
+        cleaned_chars = [char for char in text_lower if char.isalnum() and not char.isspace()]
+        bigrams = set()
+        for i in range(len(cleaned_chars) - 1):
+            bigrams.add(cleaned_chars[i] + cleaned_chars[i+1])
+        return bigrams
+    else:
+        return set(re.findall(r'\b[a-z0-9]+\b', text_lower))
+
+def is_content_duplicate(new_text, existing_bodies, current_batch_bodies, jaccard_threshold=0.65, seq_threshold=0.70):
+    """
+    Check if the cleaned new_text is a duplicate of existing articles or current batch.
+    Uses Jaccard word/bigram similarity as a fast pre-filter, followed by SequenceMatcher on prefix.
+    """
+    new_cleaned = clean_article_text(new_text)
+    if not new_cleaned:
+        return False, ""
+        
+    new_words = get_words(new_cleaned)
+    if not new_words:
+        return False, ""
+        
+    # Check against existing articles
+    for ext_title, ext_body in existing_bodies.items():
+        ext_words = get_words(ext_body)
+        if not ext_words:
+            continue
+            
+        intersection = new_words.intersection(ext_words)
+        union = new_words.union(ext_words)
+        jaccard = len(intersection) / len(union) if union else 0.0
+        
+        # Fast early-exit: Jaccard similarity must be at least 0.35 to be a candidate
+        if jaccard < 0.35:
+            continue
+            
+        new_prefix = new_cleaned[:1000]
+        ext_prefix = ext_body[:1000]
+        ratio = difflib.SequenceMatcher(None, new_prefix, ext_prefix).ratio()
+        
+        # Strict AND condition to minimize false positives
+        if jaccard >= jaccard_threshold and ratio >= seq_threshold:
+            reason = f"High content similarity (Jaccard: {int(jaccard*100)}%, SequenceMatcher: {int(ratio*100)}%) with existing article: '{ext_title}'"
+            return True, reason
+            
+    # Check against current batch
+    for cur_title, cur_body in current_batch_bodies.items():
+        cur_words = get_words(cur_body)
+        if not cur_words:
+            continue
+            
+        intersection = new_words.intersection(cur_words)
+        union = new_words.union(cur_words)
+        jaccard = len(intersection) / len(union) if union else 0.0
+        
+        # Fast early-exit
+        if jaccard < 0.35:
+            continue
+            
+        new_prefix = new_cleaned[:1000]
+        cur_prefix = cur_body[:1000]
+        ratio = difflib.SequenceMatcher(None, new_prefix, cur_prefix).ratio()
+        
+        # Strict AND condition
+        if jaccard >= jaccard_threshold and ratio >= seq_threshold:
+            reason = f"High content similarity (Jaccard: {int(jaccard*100)}%, SequenceMatcher: {int(ratio*100)}%) with another article in this batch: '{cur_title}'"
+            return True, reason
+            
+    return False, ""
+
+
+
+def load_json(path, default):
+    if os.path.exists(path):
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Failed to load JSON {path}: {e}")
+    return default
+
+def save_json(path, data):
+    try:
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+    except Exception as e:
+        print(f"Failed to save JSON {path}: {e}")
+
+def evaluate_raw_markdown(markdown_content):
+    """
+    Perform fast, hard-coded checks before sending to LLM.
+    Returns (is_valid: bool, reason: str)
+    """
+    # 1. Length check
+    if len(markdown_content) < 150:
+        return False, "Article is too short (< 150 chars). Likely a scraping error or stub."
+        
+    # 2. Regex Check: Scraping Errors
+    error_patterns = [
+        r"403\s+forbidden",
+        r"access\s+denied",
+        r"enable\s+javascript",
+        r"please\s+enable\s+cookies",
+        r"cloudflare",
+        r"captcha",
+        r"are\s+you\s+a\s+robot"
+    ]
+    for pattern in error_patterns:
+        if re.search(pattern, markdown_content, re.IGNORECASE):
+            return False, f"Matches scraping error signature: '{pattern}'"
+            
+    return True, "Pass"
+
+def build_proofread_prompt(article_markdown):
+    prompt = f"""You are a strict News Quality Gatekeeper and Proofreader.
+Your task is to evaluate the following scraped text.
+
+Instructions:
+1. If the text is an error page, a privacy policy, a captcha request, or pure spam, reply strictly and ONLY with the text: "REJECT: [Reason]".
+2. If it is a valid news article, review it for grammatical correctness, natural flow, and factual consistency.
+3. PRESERVE the exact formatting of the article, including Markdown headings (#, ##), bullets, and the footer section ("---" and below containing Author and Sources).
+4. Output ONLY the corrected markdown text or the REJECT signal. Do not include any introductory or concluding remarks.
+
+Article to evaluate:
+{article_markdown}
+"""
+    return prompt
+
+def main():
+    print(f"Starting Quality Gate (READY_FOR_NEWS Evaluation) at {datetime.now().isoformat()}")
+    
+    synthesis_data = load_json(SYNTHESIS_FILE, [])
+    if not synthesis_data:
+        print("No synthesis data found. Exiting Quality Gate.")
+        return
+
+    print(f"Total articles pending evaluation: {len(synthesis_data)}")
+
+    if not litert_lm:
+        print("litert_lm module not found. Falling back to hard-filters only.")
+        engine = None
+    else:
+        print(f"Loading LiteRT-LM engine for deep evaluation: {LITERT_MODEL_PATH}")
+        try:
+            engine = litert_lm.Engine(LITERT_MODEL_PATH, backend=litert_lm.Backend.CPU, max_num_tokens=8192)
+        except Exception as e:
+            print(f"LiteRT-LM Engine failure: {e}. Falling back to hard-filters only.")
+            engine = None
+
+    filtered_synthesis_data = []
+    rejected_count = 0
+    passed_count = 0
+
+    # Collect existing titles and bodies once at start
+    existing_titles = get_existing_article_titles()
+    print("Loading recent article bodies for content duplication check...")
+    existing_bodies = get_recent_article_bodies(max_per_category=30)
+    print(f"Loaded {len(existing_bodies)} recent article bodies.")
+    current_batch_processed_titles = set()
+    current_batch_processed_bodies = {}  # {title: cleaned_body}
+
+    try:
+        for item in synthesis_data:
+            title = item.get("title", "Unknown Title")
+            markdown_content = item.get("markdown", "")
+            
+            if not markdown_content:
+                print(f"REJECTED '{title}': Empty markdown content.")
+                rejected_count += 1
+                continue
+                
+            print(f"Evaluating article: '{title}'...")
+            
+            # Step 0: Duplicate Checks
+            is_dup, dup_reason = is_duplicate(title, existing_titles, current_batch_processed_titles)
+            if is_dup:
+                print(f"  [REJECTED - Duplicate Title] {dup_reason}")
+                rejected_count += 1
+                continue
+                
+            is_content_dup, content_dup_reason = is_content_duplicate(
+                markdown_content, existing_bodies, current_batch_processed_bodies
+            )
+            if is_content_dup:
+                print(f"  [REJECTED - Duplicate Content] {content_dup_reason}")
+                rejected_count += 1
+                continue
+            
+            # Step 1: Hard Filters
+            is_valid, reason = evaluate_raw_markdown(markdown_content)
+            if not is_valid:
+                print(f"  [REJECTED by Hard Filter] {reason}")
+                rejected_count += 1
+                continue
+            
+            # Truncate if ridiculously long, but 8192 tokens should be enough
+            if len(markdown_content) > 15000:
+                print(f"  [FLAG] Article is extremely long. Skipping LLM proofread but passing through.")
+                item["status"] = "READY_FOR_NEWS"
+                filtered_synthesis_data.append(item)
+                passed_count += 1
+                continue
+            
+            # Step 2: LLM Evaluation
+            if engine:
+                prompt = build_proofread_prompt(markdown_content)
+                try:
+                    with engine.create_conversation() as conversation:
+                        response = conversation.send_message(prompt)
+                        output = response["content"][0]["text"].strip()
+                        
+                        if output.startswith("REJECT:"):
+                            print(f"  [REJECTED by LLM] {output[7:].strip()}")
+                            rejected_count += 1
+                            continue
+                        
+                        # Basic safety check: if model outputs something extremely short, keep original
+                        if len(output) > len(markdown_content) * 0.5:
+                            item["markdown"] = output
+                            print(f"  [PASS] Successfully evaluated and proofread.")
+                        else:
+                            print(f"  [PASS with Warning] Corrected output seems too short. Using original.")
+                            
+                except Exception as model_err:
+                    print(f"  [PASS with Warning] Error during LLM evaluation: {model_err}. Using original text.")
+            else:
+                print("  [PASS] Evaluated via hard-filter only (LLM offline).")
+                
+            item["status"] = "READY_FOR_NEWS"
+            filtered_synthesis_data.append(item)
+            current_batch_processed_titles.add(title.strip().lower())
+            
+            # Store cleaned body for future comparisons in the same batch
+            cleaned_body = clean_article_text(markdown_content)
+            current_batch_processed_bodies[title.strip().lower()] = cleaned_body
+            
+            passed_count += 1
+                    
+    finally:
+        if engine:
+            engine.close()
+
+    # Save the filtered results, dropping the rejected articles
+    if passed_count > 0 or rejected_count > 0:
+        save_json(SYNTHESIS_FILE, filtered_synthesis_data)
+        print("\n" + "="*40)
+        print("Quality Gate (READY_FOR_NEWS) Finished.")
+        print(f"Articles Passed: {passed_count}")
+        print(f"Articles Rejected & Dropped: {rejected_count}")
+        print(f"Filtered data saved to {SYNTHESIS_FILE}")
+        print("="*40)
+    else:
+        print("\nQuality Gate finished. No articles found to process.")
+
+if __name__ == "__main__":
+    main()

news_collection_and_script_generation/run_pipeline_safely.ps1

@@ -0,0 +1,79 @@
+# run_pipeline_safely.ps1
+# Runs script generation, media collection, and quality gate copying for all locales sequentially,
+# and sleeps between batches to allow TTS/Video generation on GPU to proceed.
+
+$limit = 20
+$sleepSeconds = 90  # Give plenty of time for TTS/video generation to run when GPU is idle
+
+Write-Host "=== Safe Coordinated Sequential Pipeline Loop Started ==="
+
+while ($true) {
+    $locales = @("en-US", "en-EU", "ja-JP")
+    $any_remaining = $false
+    
+    foreach ($locale in $locales) {
+        Write-Host ""
+        Write-Host "========================================"
+        Write-Host "Processing Locale: $locale at $(Get-Date -Format 'HH:mm:ss')"
+        Write-Host "========================================"
+        
+        # 1. Check remaining count first
+        $check = python -c "
+import os
+ROOT_DIR = r'C:\ComfyUI\Articles'
+locale = '$locale'
+loc_path = os.path.join(ROOT_DIR, locale)
+article_dirs = []
+if os.path.exists(loc_path):
+    for cat in os.listdir(loc_path):
+        if cat == '__pycache__': continue
+        cat_path = os.path.join(loc_path, cat)
+        if os.path.isdir(cat_path):
+            for art in os.listdir(cat_path):
+                if art in ['__pycache__', 'images', 'sources']: continue
+                art_path = os.path.join(cat_path, art)
+                if os.path.isdir(art_path):
+                    md_files = [f for f in os.listdir(art_path) if f.endswith('.md')]
+                    if md_files:
+                        article_dirs.append(art_path)
+dirs_to_process = []
+for d in article_dirs:
+    all_exist = True
+    for length in ['short', 'middle', 'long']:
+        script_path = os.path.join(d, f'script_{length}.md')
+        txt_path = os.path.join(d, f'script_{length}_clean.txt')
+        if not os.path.exists(script_path) or not os.path.exists(txt_path):
+            all_exist = False
+            break
+    if not all_exist:
+        dirs_to_process.append(d)
+print(len(dirs_to_process))
+"
+        $remaining = [int]($check.Trim())
+        Write-Host "Remaining articles needing scripts in $($locale): $remaining"
+        
+        if ($remaining -gt 0) {
+            $any_remaining = $true
+            
+            Write-Host "1. Running script generation (limit $limit, GPU)..."
+            $process = Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\generate_scripts_all.py --locale $locale --limit $limit --gpu" -NoNewWindow -PassThru -Wait
+            
+            Write-Host "2. Running media collection..."
+            Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\collect_media_parallel.py --locale $locale" -NoNewWindow -PassThru -Wait
+            
+            Write-Host "3. Running quality gate evaluation and copy..."
+            Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\copy_passed_articles.py --locale $locale" -NoNewWindow -PassThru -Wait
+        }
+    }
+    
+    if (-not $any_remaining) {
+        Write-Host "All locales have 100% of their scripts drafted!"
+        # We can still sleep and check again later, or sleep a long time.
+        Write-Host "Sleeping for 5 minutes before next check..."
+        Start-Sleep -Seconds 300
+    } else {
+        # Sleep to let the GPU run TTS and video generation
+        Write-Host "Cycle complete at $(Get-Date -Format 'HH:mm:ss'). Sleeping for $sleepSeconds seconds to let ComfyUI process TTS and videos..."
+        Start-Sleep -Seconds $sleepSeconds
+    }
+}

news_collection_and_script_generation/run_scripts_safely.ps1

@@ -0,0 +1,93 @@
+param (
+    [string]$locale = "en-EU",
+    [string]$category = "",
+    [int]$limit = 10,
+    [switch]$gpu
+)
+
+Write-Host "Starting safe script generation loop for locale: $locale, category: $category, limit: $limit, GPU: $gpu"
+
+$cmdArgs = "--locale $locale --limit $limit"
+if ($gpu) {
+    $cmdArgs = $cmdArgs + " --gpu"
+}
+if ($category -ne "") {
+    $cmdArgs = $cmdArgs + " --category " + $category
+}
+
+# Infinite loop running generate_scripts_all.py
+while ($true) {
+    Write-Host "Running next batch (limit $limit)..."
+    
+    # Run the script and capture both stdout and stderr
+    $process = Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\generate_scripts_all.py $cmdArgs" -NoNewWindow -PassThru -Wait
+    
+    $exitCode = $process.ExitCode
+    Write-Host "Process finished with exit code: $exitCode"
+    
+    Write-Host "Running media collection..."
+    $mediaArgs = "--locale $locale"
+    Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\collect_media_parallel.py $mediaArgs" -NoNewWindow -PassThru -Wait
+    
+    Write-Host "Running quality gate evaluation and copy..."
+    $copyArgs = "--locale $locale"
+    if ($category -ne "") {
+        $copyArgs = $copyArgs + " --category " + $category
+    }
+    Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\copy_passed_articles.py $copyArgs" -NoNewWindow -PassThru -Wait
+
+    # Wait a bit to prevent tight loop if something is fundamentally broken
+    Start-Sleep -Seconds 3
+    
+    # Verify if there are any remaining articles by doing a quick run that will check status
+    # We can run with --limit 0 (if supported) or just check the output of a test check.
+    # To keep it simple, we run a check logic:
+    # If the process completed successfully but processed 0 count, it means we are done.
+    # We can inspect history or files, but running the script and checking if it skips immediately is easiest.
+    # Let's run a dry run check via python inline
+    $check = python -c "
+import os
+ROOT_DIR = r'C:\ComfyUI\Articles'
+locale = '$locale'
+category = '$category' if '$category' else None
+locales = [locale]
+article_dirs = []
+for loc in locales:
+    loc_path = os.path.join(ROOT_DIR, loc)
+    if not os.path.exists(loc_path): continue
+    cats = [category] if category else os.listdir(loc_path)
+    for cat in cats:
+        if cat == '__pycache__': continue
+        cat_path = os.path.join(loc_path, cat)
+        if not os.path.exists(cat_path) or not os.path.isdir(cat_path): continue
+        for art in os.listdir(cat_path):
+            if art in ['__pycache__', 'images', 'sources']: continue
+            art_path = os.path.join(cat_path, art)
+            if os.path.isdir(art_path):
+                md_files = [f for f in os.listdir(art_path) if f.endswith('.md')]
+                if md_files:
+                    article_dirs.append(art_path)
+
+dirs_to_process = []
+for d in article_dirs:
+    all_exist = True
+    for length in ['short', 'middle', 'long']:
+        script_path = os.path.join(d, f'script_{length}.md')
+        txt_path = os.path.join(d, f'script_{length}_clean.txt')
+        if not os.path.exists(script_path) or not os.path.exists(txt_path):
+            all_exist = False
+            break
+    if not all_exist:
+        dirs_to_process.append(d)
+
+print(len(dirs_to_process))
+"
+    
+    $remaining = [int]($check.Trim())
+    Write-Host "Remaining articles requiring scripts: $remaining"
+    
+    if ($remaining -eq 0) {
+        Write-Host "Success! All articles in $locale (category: $category) have scripts generated."
+        break
+    }
+}

news_collection_and_script_generation/synthesize_articles_litert.py

@@ -0,0 +1,194 @@
+import os
+import json
+import sys
+from datetime import datetime
+import litert_lm
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+PENDING_FILE = os.path.join(ROOT_DIR, "pending.json")
+SYNTHESIS_FILE = os.path.join(ROOT_DIR, "synthesis_output.json")
+LITERT_MODEL_PATH = r"D:\text_encoders\gemma-4-E2B-it-litert-lm\gemma-4-E2B-it.litertlm"
+
+CATEGORY_LIMITS = {
+    "Business": 3,
+    "World_Affairs": 5,
+    "Animals": 3,
+    "General": 3
+}
+
+# Removed UNSPLASH_IMAGES constants to use authentic images
+
+def load_json(path, default):
+    if os.path.exists(path):
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Failed to load JSON {path}: {e}")
+    return default
+
+def save_json(path, data):
+    try:
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+    except Exception as e:
+        print(f"Failed to save JSON {path}: {e}")
+
+def parse_date(date_str):
+    formats = [
+        "%a, %d %b %Y %H:%M:%S %Z",
+        "%a, %d %b %Y %H:%M:%S %z",
+        "%Y-%m-%dT%H:%M:%S%z",
+        "%Y-%m-%d %H:%M:%S"
+    ]
+    for fmt in formats:
+        try:
+            return datetime.strptime(date_str, fmt)
+        except:
+            pass
+    return datetime.min
+
+def build_single_article_prompt(title, category, content):
+    prompt = f"""You are a professional news editor.
+Your task is to write a clean, engaging, and comprehensive news report in English based on the following raw crawled source text.
+
+Category: {category}
+Title of the news: {title}
+
+Raw source text:
+{content}
+
+Requirements:
+1. Write the entire article in English and format it in Markdown (.md).
+2. The first line of your output MUST be the article title prefixed by a single '#', like: '# [Article Title]'.
+3. The second line should be the current date (e.g. {datetime.now().strftime('%B %d, %Y')}).
+4. Write a detailed, cohesive summary of the main news events. Organize the content into paragraphs and sections with '## [Section Name]' where appropriate. Do not include external links or image URLs in your summary.
+
+Generate only the markdown article content. Do not include any introductory or concluding chat remarks.
+"""
+    return prompt
+
+def main():
+    print(f"Starting individual LiteRT-LM news synthesis at {datetime.now().isoformat()}")
+    
+    pending_list = load_json(PENDING_FILE, [])
+    if not pending_list:
+        print("No pending articles to process.")
+        return
+
+    # Group by category to apply limits
+    by_category = {}
+    for item in pending_list:
+        cat = item["category"]
+        if cat not in by_category:
+            by_category[cat] = []
+        by_category[cat].append(item)
+        
+    cleaned_pending = []
+    process_jobs = []
+    discarded_count = 0
+    
+    for category, items in by_category.items():
+        limit = CATEGORY_LIMITS.get(category, 5)
+        # Sort by pub_date descending (latest first)
+        sorted_items = sorted(items, key=lambda x: parse_date(x.get("pub_date", "")), reverse=True)
+        
+        kept_items = sorted_items[:limit]
+        discarded_items = sorted_items[limit:]
+        
+        cleaned_pending.extend(kept_items)
+        process_jobs.extend(kept_items)
+        
+        for item in discarded_items:
+            discarded_count += 1
+            src_file = item.get("source_file", "")
+            if src_file and os.path.exists(src_file):
+                try:
+                    os.remove(src_file)
+                    print(f"Removed excess source file: {src_file}")
+                except Exception as e:
+                    print(f"Failed to remove excess source file: {e}")
+                    
+    save_json(PENDING_FILE, cleaned_pending)
+    if discarded_count > 0:
+        print(f"Cleaned queue: kept {len(cleaned_pending)} items, discarded {discarded_count} items.")
+
+    synthesis_output = []
+    
+    if not process_jobs:
+        print("No articles to process after filtering.")
+        return
+
+    print(f"Loading LiteRT-LM engine with model: {LITERT_MODEL_PATH}")
+    try:
+        # Load with max_num_tokens=8192 for longer contexts
+        with litert_lm.Engine(LITERT_MODEL_PATH, backend=litert_lm.Backend.CPU, max_num_tokens=8192) as engine:
+            for item in process_jobs:
+                category = item["category"]
+                title = item["title"]
+                link = item["link"]
+                src_path = item.get("source_file", "")
+                
+                print(f"Summarizing article '{title}' under category '{category}' with Gemma-4...")
+                
+                # Read full text content
+                content = ""
+                if src_path and os.path.exists(src_path):
+                    try:
+                        with open(src_path, 'r', encoding='utf-8') as sf:
+                            content = sf.read().strip()
+                    except Exception as e:
+                        print(f"Failed to read source file {src_path}: {e}")
+                
+                if not content:
+                    content = item.get('description', '')
+                
+                # Truncate content per article to keep prompt length reasonable (under model limits)
+                if len(content) > 4000:
+                    content = content[:4000] + "... [truncated]"
+                
+                prompt = build_single_article_prompt(title, category, content)
+                
+                try:
+                    with engine.create_conversation() as conversation:
+                        response = conversation.send_message(prompt)
+                        gemma_markdown = response["content"][0]["text"].strip()
+                except Exception as model_err:
+                    print(f"Gemma-4 synthesis error for '{title}': {model_err}. Falling back to raw text.")
+                    gemma_markdown = f"# {title}\n\n{content}"
+                
+                # Append Unsplash images and citation block to the model's markdown output
+                lines = [gemma_markdown]
+                lines.append("")
+                lines.append("---")
+                lines.append("")
+                lines.append("**Author:** AntigravityAI News Collector")
+                lines.append("")
+                lines.append("**Sources & Citations:**")
+                lines.append(f"- [{title}]({link})")
+                
+                final_markdown = "\n".join(lines)
+                
+                synthesis_output.append({
+                    "category": category,
+                    "title": title,
+                    "link": link,
+                    "markdown": final_markdown,
+                    "source_file": src_path
+                })
+                print(f"Gemma-4 synthesis finished for '{title}' successfully.")
+    except Exception as e:
+        print(f"LiteRT-LM Engine failure during synthesis: {e}")
+        return
+
+    if synthesis_output:
+        save_json(SYNTHESIS_FILE, synthesis_output)
+        print(f"Individual compilation finished. Saved {len(synthesis_output)} articles to {SYNTHESIS_FILE}")
+    else:
+        print("No outputs generated.")
+
+if __name__ == "__main__":
+    main()

news_collection_and_script_generation/synthesize_articles_raw.py

@@ -0,0 +1,151 @@
+import os
+import json
+import sys
+from datetime import datetime
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+PENDING_FILE = os.path.join(ROOT_DIR, "pending.json")
+SYNTHESIS_FILE = os.path.join(ROOT_DIR, "synthesis_output.json")
+
+CATEGORY_LIMITS = {
+    "Business": 5,
+    "World_Affairs": 15,
+    "Animals": 5,
+    "General": 5
+}
+
+# Removed UNSPLASH_IMAGES constants to use authentic images
+
+def load_json(path, default):
+    if os.path.exists(path):
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Failed to load JSON {path}: {e}")
+    return default
+
+def save_json(path, data):
+    try:
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+    except Exception as e:
+        print(f"Failed to save JSON {path}: {e}")
+
+def parse_date(date_str):
+    formats = [
+        "%a, %d %b %Y %H:%M:%S %Z",
+        "%a, %d %b %Y %H:%M:%S %z",
+        "%Y-%m-%dT%H:%M:%S%z",
+        "%Y-%m-%d %H:%M:%S"
+    ]
+    for fmt in formats:
+        try:
+            return datetime.strptime(date_str, fmt)
+        except:
+            pass
+    return datetime.min
+
+def main():
+    print(f"Starting raw individual news compilation at {datetime.now().isoformat()}")
+    
+    pending_list = load_json(PENDING_FILE, [])
+    if not pending_list:
+        print("No pending articles to process.")
+        return
+
+    # Group by category to apply limits
+    by_category = {}
+    for item in pending_list:
+        cat = item["category"]
+        if cat not in by_category:
+            by_category[cat] = []
+        by_category[cat].append(item)
+        
+    cleaned_pending = []
+    process_jobs = []
+    discarded_count = 0
+    
+    for category, items in by_category.items():
+        limit = CATEGORY_LIMITS.get(category, 10)
+        # Sort by pub_date descending
+        sorted_items = sorted(items, key=lambda x: parse_date(x.get("pub_date", "")), reverse=True)
+        
+        kept_items = sorted_items[:limit]
+        discarded_items = sorted_items[limit:]
+        
+        cleaned_pending.extend(kept_items)
+        process_jobs.extend(kept_items)
+        
+        for item in discarded_items:
+            discarded_count += 1
+            src_file = item.get("source_file", "")
+            if src_file and os.path.exists(src_file):
+                try:
+                    os.remove(src_file)
+                    print(f"Removed excess source file: {src_file}")
+                except Exception as e:
+                    print(f"Failed to remove excess source file: {e}")
+                    
+    save_json(PENDING_FILE, cleaned_pending)
+    if discarded_count > 0:
+        print(f"Cleaned queue: kept {len(cleaned_pending)} items, discarded {discarded_count} items.")
+
+    synthesis_output = []
+    
+    for item in process_jobs:
+        category = item["category"]
+        title = item["title"]
+        link = item["link"]
+        pub_date = item.get("pub_date", "Unknown")
+        src_path = item.get("source_file", "")
+        
+        print(f"Compiling article '{title}' under category '{category}'...")
+        
+        # Read full text content
+        content = ""
+        if src_path and os.path.exists(src_path):
+            try:
+                with open(src_path, 'r', encoding='utf-8') as sf:
+                    content = sf.read().strip()
+            except Exception as e:
+                print(f"Failed to read source file {src_path}: {e}")
+        
+        if not content:
+            content = item.get('description', '')
+            
+        # Build individual article document
+        lines = []
+        lines.append(f"# {title}")
+        lines.append(pub_date)
+        lines.append("")
+        lines.append(content)
+        lines.append("")
+        lines.append("---")
+        lines.append("")
+        lines.append("**Author:** AntigravityAI News Collector")
+        lines.append("")
+        lines.append("**Sources & Citations:**")
+        lines.append(f"- [{title}]({link})")
+        
+        markdown_content = "\n".join(lines)
+        
+        synthesis_output.append({
+            "category": category,
+            "title": title,
+            "link": link,
+            "markdown": markdown_content,
+            "source_file": src_path
+        })
+
+    if synthesis_output:
+        save_json(SYNTHESIS_FILE, synthesis_output)
+        print(f"Compilation finished. Saved {len(synthesis_output)} articles to {SYNTHESIS_FILE}")
+    else:
+        print("No outputs generated.")
+
+if __name__ == "__main__":
+    main()

news_collection_and_script_generation/task_config.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Date>2026-06-11T12:00:00</Date>
+    <Author>AntigravityAI</Author>
+    <Description>Automatically collect English news reports every 4 hours and on logon.</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <Repetition>
+        <Interval>PT4H</Interval>
+        <StopAtDurationEnd>false</StopAtDurationEnd>
+      </Repetition>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>false</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT2H</ExecutionTimeLimit>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>wscript.exe</Command>
+      <Arguments>C:\ComfyUI\Articles\run_silent.vbs</Arguments>
+    </Exec>
+  </Actions>
+</Task>

news_collection_and_script_generation/tts_articles.py

@@ -0,0 +1,541 @@
+import os
+import re
+import sys
+import json
+import uuid
+import time
+import argparse
+import shutil
+import urllib.request
+import urllib.parse
+
+
+# Reconfigure encoding to avoid Windows console encoding issues
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+DEFAULT_WORKFLOW = r"C:\ComfyUI\workflows\05_Audio_&_TTS\Text to Speech.json"
+DEFAULT_PORT = 7777
+
+def get_default_value(node_info, key):
+    inputs = node_info.get("input", {})
+    for cat in ["required", "optional"]:
+        if key in inputs.get(cat, {}):
+            param = inputs[cat][key]
+            if len(param) > 1 and isinstance(param[1], dict) and "default" in param[1]:
+                return param[1]["default"]
+    return None
+
+def convert_ui_to_api(wf_path, server_url):
+    print(f"Fetching node object info from ComfyUI server at {server_url}...")
+    try:
+        with urllib.request.urlopen(f"{server_url}/object_info") as r:
+            object_info = json.loads(r.read().decode('utf-8'))
+    except Exception as e:
+        print(f"Error connecting to ComfyUI at {server_url}: {e}")
+        print("Please make sure ComfyUI is running on this port.")
+        sys.exit(1)
+
+    print(f"Loading UI workflow from {wf_path}...")
+    with open(wf_path, 'r', encoding='utf-8') as f:
+        wf = json.load(f)
+
+    # Map link_id -> (from_node_id, from_slot)
+    link_map = {}
+    for link in wf.get("links", []):
+        if link:
+            link_id, from_node, from_slot, to_node, to_slot, type_name = link
+            link_map[link_id] = [str(from_node), from_slot]
+
+    api_prompt = {}
+    for node in wf.get("nodes", []):
+        node_id = str(node["id"])
+        class_type = node["type"]
+
+        if class_type not in object_info:
+            print(f"Warning: node type '{class_type}' not found in ComfyUI object info. Skipping node {node_id}.")
+            continue
+
+        node_info = object_info[class_type]
+        req_inputs = node_info.get("input", {}).get("required", {})
+        opt_inputs = node_info.get("input", {}).get("optional", {})
+        all_input_keys = list(req_inputs.keys()) + list(opt_inputs.keys())
+
+        inputs = {}
+        linked_keys = {}
+        for ui_input in node.get("inputs", []):
+            name = ui_input["name"]
+            link_id = ui_input.get("link")
+            if link_id and link_id in link_map:
+                linked_keys[name] = link_map[link_id]
+
+        widgets_values = node.get("widgets_values", [])
+        widget_idx = 0
+
+        for key in all_input_keys:
+            if key in linked_keys:
+                inputs[key] = linked_keys[key]
+            else:
+                if widget_idx < len(widgets_values):
+                    val = widgets_values[widget_idx]
+                    if val is not None:
+                        inputs[key] = val
+                    else:
+                        inputs[key] = get_default_value(node_info, key)
+                    widget_idx += 1
+                else:
+                    inputs[key] = get_default_value(node_info, key)
+
+            # Clean up None values to let ComfyUI use its default behavior
+            if inputs[key] is None:
+                del inputs[key]
+
+        api_prompt[node_id] = {
+            "class_type": class_type,
+            "inputs": inputs
+        }
+
+    return api_prompt
+
+def queue_prompt(server_url, prompt, prompt_id, client_id):
+    p = {"prompt": prompt, "client_id": client_id, "prompt_id": prompt_id}
+    data = json.dumps(p).encode('utf-8')
+    req = urllib.request.Request(f"{server_url}/prompt", data=data)
+    with urllib.request.urlopen(req) as response:
+        return json.loads(response.read().decode('utf-8'))
+
+def get_history(server_url, prompt_id):
+    with urllib.request.urlopen(f"{server_url}/history/{prompt_id}") as response:
+        return json.loads(response.read().decode('utf-8'))
+
+def find_script_file(article_dir):
+    files = os.listdir(article_dir)
+    # Prefer normal script
+    for f in files:
+        if f.endswith("_script_normal.md"):
+            return os.path.join(article_dir, f)
+    # Fallback to general script
+    for f in files:
+        if f.endswith("_script.md"):
+            return os.path.join(article_dir, f)
+    # Fallback to other script types
+    for f in files:
+        if f.endswith(("_script_short.md", "_script_long.md")):
+            return os.path.join(article_dir, f)
+    # Absolute fallback to any md file except the main article one if possible
+    for f in files:
+        if f.endswith(".md") and not f.endswith(os.path.basename(article_dir) + ".md"):
+            return os.path.join(article_dir, f)
+    # Final fallback
+    for f in files:
+        if f.endswith(".md"):
+            return os.path.join(article_dir, f)
+    return None
+
+def clean_script_text(file_path):
+    with open(file_path, "r", encoding="utf-8") as f:
+        text = f.read().strip()
+        
+    # If it's a raw article file containing a summary, extract just the summary
+    if "## Summary" in text:
+        parts = text.split("## Summary", 1)
+        if len(parts) > 1:
+            summary_part = parts[1]
+            if "---" in summary_part:
+                summary_part = summary_part.split("---", 1)[0]
+            text = summary_part.strip()
+            
+    lines = text.splitlines()
+    cleaned_lines = []
+    in_carousel = False
+    
+    for line in lines:
+        stripped = line.strip()
+        
+        # Handle carousel blocks
+        if stripped.startswith("```carousel"):
+            in_carousel = True
+            continue
+        if in_carousel:
+            if stripped.startswith("```"):
+                in_carousel = False
+            continue
+            
+        # Skip headers
+        if stripped.startswith("#"):
+            continue
+            
+        # Skip metadata lines
+        if any(stripped.startswith(prefix) for prefix in [
+            "Category:", "Locale:", "Source:", "Date Collected:", 
+            "Author:", "Sources & Citations:", "**Category:**", 
+            "**Locale:**", "**Source:**", "**Date Collected:**"
+        ]):
+            continue
+            
+        # Clean inline markdown bold/italic
+        cleaned_line = line.replace("**", "").replace("*", "")
+        
+        # Replace &nbsp; with spaces
+        cleaned_line = cleaned_line.replace("&nbsp;", " ")
+        
+        # Clean up markdown links [Text](URL) -> Text
+        cleaned_line = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', cleaned_line)
+        
+        if cleaned_line.strip():
+            cleaned_lines.append(cleaned_line)
+            
+    return "\n".join(cleaned_lines).strip()
+
+
+
+def split_into_segments(text):
+    # Split by sentence endings keeping the punctuation
+    sentences = re.split(r'(?<=[.!?])\s+', text.strip())
+    return [s.strip() for s in sentences if s.strip()]
+
+
+def get_speed_factor(sentence):
+    words = sentence.split()
+    word_count = len(words)
+    
+    # 1. Very short sentence / punctuation emphasis -> speak slower
+    if word_count <= 3:
+        return 0.80 # 20% slower
+    
+    # 2. Key quotes, emotional words, exclamation -> speak slower
+    if '"' in sentence or "'" in sentence:
+        return 0.85
+    if sentence.endswith('!') or any(w.lower() in ["must", "never", "critical", "painful", "truce", "ceasefire", "alert", "warn"] for w in words):
+        return 0.85 # 15% slower
+        
+    # 3. Long sentence / transition explanations -> speak faster
+    if word_count >= 18:
+        return 1.15 # 15% faster
+    
+    if words and words[0].lower() in ["and", "but", "so", "however", "because", "also", "then"]:
+        return 1.15 # 15% faster
+        
+    # 4. Default normal speed
+    return 1.00
+
+
+def get_pause_duration(sentence):
+    if sentence.endswith('?') or sentence.endswith('!'):
+        return 0.50
+    elif sentence.endswith(','):
+        return 0.15
+    else:
+        return 0.35
+
+def get_emotion_description(text):
+    text_lower = text.lower()
+    urgent_keywords = ['breaking', 'just now', 'immediately', 'urgent', 'sudden', 'latest']
+    tense_keywords = ['warning', 'threat', 'alert', 'imminent', 'escalate', 'danger', 'fear', 'tense', 'unstable']
+    serious_keywords = ['war', 'attack', 'death', 'casualty', 'killed', 'destroy', 'bomb', 'fire', 'severe', 'tragedy', 'crisis', 'terror', 'ukraine', 'moscow', 'russia', 'military', 'soldier', 'strike', 'conflict']
+    
+    if any(kw in text_lower for kw in urgent_keywords):
+        return "Urgent, fast-paced, breathless news reporter delivering breaking news"
+        
+    if any(kw in text_lower for kw in tense_keywords):
+        return "Tense, worried, anxious news reporter talking about danger"
+        
+    if any(kw in text_lower for kw in serious_keywords):
+        return "Serious, sad, grim, news reporter talking about tragedy"
+    
+    if "!" in text or "amazing" in text_lower or "incredible" in text_lower:
+        return "Excited, energetic, happy news reporter"
+        
+    return "Neutral, calm, informative, professional news anchor"
+
+def add_emphasis_pauses(text):
+    # Add native easy-indextts2 pauses around important keywords
+    important_keywords = ['must', 'never', 'critical', 'warning', 'breaking', 'however']
+    words = text.split()
+    for i, w in enumerate(words):
+        clean_w = w.lower().strip(',.?!')
+        if clean_w in important_keywords:
+            words[i] = "-0.2s- " + w + " -0.2s-"
+    return " ".join(words)
+
+
+def main():
+    import numpy as np
+    import librosa
+    import soundfile as sf
+
+    parser = argparse.ArgumentParser(description="Batch process ComfyUI TTS on articles.")
+    parser.add_argument("--limit", type=int, default=None, help="Limit number of articles to process.")
+    parser.add_argument("--overwrite", action="store_true", help="Force process even if audio file already exists.")
+    parser.add_argument("--workflow", type=str, default=DEFAULT_WORKFLOW, help="Path to UI Text to Speech workflow JSON.")
+    parser.add_argument("--port", type=int, default=DEFAULT_PORT, help="Port of running ComfyUI server.")
+    parser.add_argument("--lang", type=str, default=None, help="Only process articles in this language (e.g. en-US, en-EU, ja-JP).")
+    parser.add_argument("--category", type=str, default=None, help="Only process articles in this category (e.g. Moscow_Attacks).")
+    args = parser.parse_args()
+
+    server_url = f"http://127.0.0.1:{args.port}"
+    client_id = str(uuid.uuid4())
+
+    # Build api prompt template
+    api_prompt_template = convert_ui_to_api(args.workflow, server_url)
+
+    # Find nodes to manipulate
+    text_input_node_id = None
+    save_audio_node_id = None
+    index_tts_node_id = None
+    emotion_text_node_id = None
+
+    for node_id, node in api_prompt_template.items():
+        if node["class_type"] == "TextInput_":
+            text_input_node_id = node_id
+        elif node["class_type"] == "SaveAudio":
+            save_audio_node_id = node_id
+        elif node["class_type"] in ["IndexTTSRun", "easy indexTTSGenerate", "IndexTTS2EmotionText"]:
+            index_tts_node_id = node_id
+        elif node["class_type"] == "easy indexTTSEmotionText":
+            emotion_text_node_id = node_id
+
+    if not text_input_node_id:
+        print("Error: Could not find TextInput_ node in workflow.")
+        sys.exit(1)
+    if not save_audio_node_id:
+        print("Error: Could not find SaveAudio node in workflow.")
+        sys.exit(1)
+
+    # Scan directories (both root level and language/category subdirectories)
+    article_dirs = []
+    
+    # 1. Check root level direct article directories (for backward compatibility)
+    if not args.lang and not args.category:
+        for d in os.listdir(ROOT_DIR):
+            full_path = os.path.join(ROOT_DIR, d)
+            if os.path.isdir(full_path) and d not in ["__pycache__", "temp_sources", "en-US", "en-EU", "ja-JP", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]:
+                article_dirs.append(full_path)
+            
+    # 2. Check under language and category directories
+    langs_to_scan = [args.lang] if args.lang else ["en-US", "en-EU", "ja-JP", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]
+    for lang in langs_to_scan:
+        lang_path = os.path.join(ROOT_DIR, lang)
+        if os.path.exists(lang_path) and os.path.isdir(lang_path):
+            for cat in os.listdir(lang_path):
+                if args.category and cat != args.category:
+                    continue
+                cat_path = os.path.join(lang_path, cat)
+                if os.path.isdir(cat_path) and cat not in ["__pycache__"]:
+                    for article in os.listdir(cat_path):
+                        article_path = os.path.join(cat_path, article)
+                        if os.path.isdir(article_path) and article not in ["__pycache__", "images", "sources"]:
+                            article_dirs.append(article_path)
+    
+    # Sort alphabetically by the article directory name for predictability
+    article_dirs.sort(key=lambda x: os.path.basename(x))
+
+    print(f"Found {len(article_dirs)} article directories.")
+    
+    processed_count = 0
+    skipped_count = 0
+    failed_count = 0
+
+    comfy_output_dir = os.path.abspath(os.path.join(os.path.dirname(args.workflow), "..", "output"))
+    # In case workflow is in C:\ComfyUI\workflow, output is C:\ComfyUI\output
+
+    for idx, article_dir in enumerate(article_dirs, 1):
+        d = os.path.basename(article_dir)
+        if args.limit is not None and processed_count >= args.limit:
+            print(f"Limit of {args.limit} reached. Stopping.")
+            break
+        
+        # Check if audio file already exists in directory
+        audio_files = [f for f in os.listdir(article_dir) if f.endswith((".wav", ".flac", ".mp3"))]
+        if audio_files and not args.overwrite:
+            skipped_count += 1
+            continue
+
+        script_file = find_script_file(article_dir)
+        if not script_file:
+            print(f"[{idx}/{len(article_dirs)}] Warning: No script file found in {d}. Skipping.")
+            failed_count += 1
+            continue
+
+        try:
+            script_text = clean_script_text(script_file)
+        except Exception as e:
+            print(f"[{idx}/{len(article_dirs)}] Error: Failed to read script in {d}: {e}")
+            failed_count += 1
+            continue
+
+        segments = split_into_segments(script_text)
+        if not segments:
+            print(f"[{idx}/{len(article_dirs)}] Warning: Script file in {d} is empty. Skipping.")
+            failed_count += 1
+            continue
+
+        print(f"\n[{idx}/{len(article_dirs)}] Processing: {d} ({len(segments)} segments) ...")
+        
+        audio_segments = []
+        segment_failed = False
+        sr = 24000 # default fallback
+
+        for s_idx, segment in enumerate(segments):
+            is_last = (s_idx == len(segments) - 1)
+            speed_factor = get_speed_factor(segment)
+            pause_duration = get_pause_duration(segment)
+            
+            # Apply emphasis pauses natively
+            emphasized_segment = add_emphasis_pauses(segment)
+            emotion_desc = get_emotion_description(segment)
+            print(f"    -> Emotion: {emotion_desc}")
+            
+            # Prepare custom prompt
+            prompt = json.loads(json.dumps(api_prompt_template))
+            prompt[text_input_node_id]["inputs"]["text"] = emphasized_segment
+            
+            is_japanese = "ja-jp" in article_dir.lower()
+            if is_japanese:
+                if index_tts_node_id and index_tts_node_id in prompt:
+                    prompt[index_tts_node_id]["inputs"]["version"] = "v2.0-jp"
+                elif "105" in prompt:
+                    prompt["105"]["inputs"]["version"] = "v2.0-jp"
+
+            if emotion_text_node_id:
+                prompt[emotion_text_node_id]["inputs"]["description"] = emotion_desc
+            elif index_tts_node_id and prompt[index_tts_node_id]["class_type"] == "IndexTTS2EmotionText":
+                prompt[index_tts_node_id]["inputs"]["emo_text"] = emotion_desc
+                prompt[index_tts_node_id]["inputs"]["use_emo_text"] = True
+            
+            prompt_id = str(uuid.uuid4())
+            filename_prefix = f"audio/article_tts_{prompt_id}"
+            prompt[save_audio_node_id]["inputs"]["filename_prefix"] = filename_prefix
+
+            # VRAM optimization: Keep model loaded except for the very last segment
+            if index_tts_node_id and index_tts_node_id in prompt:
+                if prompt[index_tts_node_id]["class_type"] != "IndexTTS2EmotionText":
+                    prompt[index_tts_node_id]["inputs"]["unload_model"] = is_last
+            elif "105" in prompt:
+                if prompt["105"]["class_type"] not in ["IndexTTS2ModelLoader", "IndexTTS2EmotionText"]:
+                    prompt["105"]["inputs"]["unload_model"] = is_last
+
+            # Queue prompt
+            try:
+                resp = queue_prompt(server_url, prompt, prompt_id, client_id)
+            except Exception as e:
+                print(f"  Segment {s_idx+1}/{len(segments)} Error: Failed to queue prompt: {e}")
+                segment_failed = True
+                break
+
+            # Wait for completion
+            completed = False
+            start_time = time.time()
+            
+            while time.time() - start_time < 1800:
+                try:
+                    history = get_history(server_url, prompt_id)
+                    if prompt_id in history:
+                        completed = True
+                        break
+                except Exception as e:
+                    pass
+                time.sleep(0.5)
+
+            if not completed:
+                print(f"  Segment {s_idx+1}/{len(segments)} Error: TTS timed out.")
+                segment_failed = True
+                break
+
+            # Process output
+            history_entry = history[prompt_id]
+            outputs = history_entry.get("outputs", {})
+            
+            if save_audio_node_id not in outputs or "audio" not in outputs[save_audio_node_id]:
+                print(f"  Segment {s_idx+1}/{len(segments)} Error: SaveAudio output not found.")
+                segment_failed = True
+                break
+
+            audio_outputs = outputs[save_audio_node_id]["audio"]
+            if not audio_outputs:
+                print(f"  Segment {s_idx+1}/{len(segments)} Error: No audio files returned.")
+                segment_failed = True
+                break
+
+            # Load generated file
+            audio_info = audio_outputs[0]
+            gen_filename = audio_info["filename"]
+            gen_subfolder = audio_info["subfolder"]
+            
+            # Path to generated file
+            src_path = os.path.join(comfy_output_dir, gen_subfolder, gen_filename)
+            
+            if not os.path.exists(src_path):
+                # Fallback check directly in C:\ComfyUI\output\audio
+                src_path = os.path.join(r"C:\ComfyUI\output", gen_subfolder, gen_filename)
+
+            if not os.path.exists(src_path):
+                print(f"  Segment {s_idx+1}/{len(segments)} Error: Generated audio file not found at: {src_path}")
+                segment_failed = True
+                break
+
+            try:
+                # Load and time-stretch
+                y, sr = librosa.load(src_path, sr=None)
+                if abs(speed_factor - 1.0) > 0.01:
+                    y_stretched = librosa.effects.time_stretch(y=y, rate=speed_factor)
+                else:
+                    y_stretched = y
+                audio_segments.append(y_stretched)
+                
+                # Add pause
+                if pause_duration > 0 and not is_last:
+                    silence = np.zeros(int(sr * pause_duration))
+                    audio_segments.append(silence)
+                
+                # Clean up temp file
+                os.remove(src_path)
+            except Exception as audio_err:
+                print(f"  Segment {s_idx+1}/{len(segments)} Error: Audio post-processing failed: {audio_err}")
+                segment_failed = True
+                break
+
+        if segment_failed:
+            failed_count += 1
+            # Clean up the loaded model just in case it got stuck loaded
+            try:
+                prompt = json.loads(json.dumps(api_prompt_template))
+                prompt[text_input_node_id]["inputs"]["text"] = "."
+                prompt_id = str(uuid.uuid4())
+                prompt[save_audio_node_id]["inputs"]["filename_prefix"] = f"audio/cleanup_{prompt_id}"
+                if index_tts_node_id and index_tts_node_id in prompt:
+                    prompt[index_tts_node_id]["inputs"]["unload_model"] = True
+                elif "105" in prompt:
+                    prompt["105"]["inputs"]["unload_model"] = True
+                queue_prompt(server_url, prompt, prompt_id, client_id)
+            except:
+                pass
+            continue
+
+        # Destination filename is the directory name with .flac extension
+        dest_filename = f"{d}.flac"
+        dest_path = os.path.join(article_dir, dest_filename)
+
+        try:
+            final_audio = np.concatenate(audio_segments)
+            # Peak normalize the audio to 0.9 (approx -1dB) to ensure consistent volume
+            max_val = np.max(np.abs(final_audio))
+            if max_val > 0.001:
+                final_audio = final_audio / max_val * 0.9
+            sf.write(dest_path, final_audio, sr, format='FLAC')
+            print(f"Saved TTS audio to: {dest_path}")
+            processed_count += 1
+        except Exception as save_err:
+            print(f"Error: Failed to save final audio for {d}: {save_err}")
+            failed_count += 1
+
+    print("\n" + "="*40)
+    print("Batch TTS Job Summary:")
+    print(f"Successfully processed: {processed_count}")
+    print(f"Skipped (already exist): {skipped_count}")
+    print(f"Failed or skipped (no script): {failed_count}")
+    print("="*40)
+
+if __name__ == "__main__":
+    main()

process_broll_watermarks.py

@@ -0,0 +1,84 @@
+import os
+import sys
+import shutil
+from pathlib import Path
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("process_broll_watermarks")
+
+# Add ComfyUI Articles directory to sys.path
+sys.path.append(r"C:\ComfyUI\Articles")
+
+from quality_gate_broll import detect_watermarks, remove_watermark_with_lama
+from collect_broll_agent import generate_ken_burns_clip
+
+ROOT_DIR = Path(r"C:\ComfyUI\Articles")
+
+def main():
+    logger.info("Scanning for existing B-roll images in Articles directory...")
+    
+    # Walk through ROOT_DIR to find Broll folders
+    broll_images = []
+    for root, dirs, files in os.walk(ROOT_DIR):
+        if Path(root).name == "Broll":
+            for f in files:
+                f_path = Path(root) / f
+                # Target only jpg/png images, skipping temporary files, masks, and originals
+                if f_path.suffix.lower() in [".jpg", ".jpeg", ".png"]:
+                    if f.startswith("tmp_") or f.startswith("std_") or "_original" in f or "_mask" in f:
+                        continue
+                    broll_images.append(f_path)
+                    
+    logger.info(f"Found {len(broll_images)} candidate B-roll images.")
+    
+    flagged_count = 0
+    removed_count = 0
+    regenerated_count = 0
+    
+    for i, img_path in enumerate(broll_images, 1):
+        logger.info(f"[{i}/{len(broll_images)}] Scanning {img_path.relative_to(ROOT_DIR)}")
+        
+        detected_corners = detect_watermarks(img_path)
+        if detected_corners:
+            flagged_count += 1
+            logger.info(f"  -> Watermark detected in corners: {detected_corners}")
+            
+            # Backup original image if not already done
+            backup_path = img_path.parent / f"{img_path.name.replace(img_path.suffix, '')}_original{img_path.suffix}"
+            if not backup_path.exists():
+                shutil.copy2(img_path, backup_path)
+                logger.info(f"  -> Created backup: {backup_path.name}")
+                
+            # Perform watermark removal using LaMa
+            # We pass backup_path as input and img_path as output, so we always inpaint from the clean original
+            success, reason = remove_watermark_with_lama(backup_path, img_path)
+            
+            if success:
+                removed_count += 1
+                logger.info(f"  -> Successfully removed watermark from {img_path.name}")
+                
+                # Check for corresponding mp4 clip to regenerate
+                mp4_path = img_path.parent / f"{img_path.stem}.mp4"
+                if mp4_path.exists():
+                    logger.info(f"  -> Corresponding video clip found: {mp4_path.name}. Regenerating...")
+                    # Re-render clip from the watermarked-free image
+                    if generate_ken_burns_clip(img_path, mp4_path):
+                        regenerated_count += 1
+                        logger.info(f"  -> Successfully regenerated video clip: {mp4_path.name}")
+                    else:
+                        logger.error(f"  -> Failed to regenerate video clip: {mp4_path.name}")
+            else:
+                logger.warning(f"  -> Watermark removal failed: {reason}")
+                
+    logger.info("========================================")
+    logger.info("Watermark Processing Finished.")
+    logger.info(f"Total images scanned: {len(broll_images)}")
+    logger.info(f"Images flagged with watermarks: {flagged_count}")
+    logger.info(f"Images successfully inpainted: {removed_count}")
+    logger.info(f"Video clips successfully regenerated: {regenerated_count}")
+    logger.info("========================================")
+
+if __name__ == "__main__":
+    main()

process_ready_videos_step.py

@@ -0,0 +1,797 @@
+import os
+import sys
+import json
+import re
+import shutil
+import urllib.request
+import subprocess
+from datetime import datetime
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+ROOT_DIR = SCRIPT_DIR if os.path.exists(os.path.join(SCRIPT_DIR, "en-US")) else r"C:\ComfyUI\Articles"
+WORKSPACE_DIR = os.path.dirname(SCRIPT_DIR)
+COMFY_INPUT_DIR = r"C:\ComfyUI\input"
+COMFY_OUTPUT_DIR = r"C:\ComfyUI\output"
+
+def extract_main_word(title):
+    # Replace underscores and commas with spaces to handle words correctly
+    title = title.replace('_', ' ').replace(',', ' ')
+    
+    is_ja = any(ord(char) > 0x3000 for char in title)
+    
+    # Clean title from source marks
+    cleaned = re.sub(r'\s*-\s*[^-\s]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', title, flags=re.IGNORECASE)
+    cleaned = re.sub(r'_[^_]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', cleaned, flags=re.IGNORECASE)
+    
+    blacklisted = ["ai", "artificial intelligence", "人工知能", "生成ai", "生成系ai"]
+    
+    def is_valid(word):
+        if not word:
+            return False
+        return word.strip().lower() not in blacklisted
+
+    # 1. Look for quotes like 「...」
+    quotes_ja = re.findall(r'「([^」]+)」', cleaned)
+    for q in quotes_ja:
+        if is_valid(q):
+            return q
+            
+    quotes_en = re.findall(r'["\']([^"\']+)["\']', cleaned)
+    for q in quotes_en:
+        if len(q) < 25 and is_valid(q):
+            return q
+
+    # 2. Known key entities list
+    known_keywords = [
+        "OpenAI", "Google", "Amazon", "Bezos", "Trump", "Anthropic", "Microsoft", "Apple", "Nvidia", "Meta", "Musk",
+        "大谷", "オオタニ", "大谷翔平", "小田急", "ソニー", "ソフトバンク", "ChatGPT", "Claude", "IOWN", "サカナAI"
+    ]
+    for kw in known_keywords:
+        if kw.lower() in cleaned.lower() and is_valid(kw):
+            m = re.search(re.escape(kw), cleaned, re.IGNORECASE)
+            if m:
+                return m.group(0)
+
+    if is_ja:
+        # Katakana sequences
+        katakana = re.findall(r'[\u30a1-\u30fc]{2,}', cleaned)
+        for k in katakana:
+            if is_valid(k):
+                return k
+        # Kanji sequences
+        kanji = re.findall(r'[\u4e00-\u9fff]{2,}', cleaned)
+        for k in kanji:
+            if k not in ["米国", "日本", "市場", "世界", "政府", "計画", "導入"] and is_valid(k):
+                return k
+        if kanji:
+            for k in kanji:
+                if is_valid(k):
+                    return k
+        # Alphabetic words
+        alpha = re.findall(r'[a-zA-Z0-9]{2,}', cleaned)
+        for a in alpha:
+            if is_valid(a):
+                return a
+    else:
+        words = re.findall(r'\b[A-Z][a-zA-Z0-9]*\b', cleaned)
+        if words:
+            for w in words:
+                if w.lower() not in ["a", "an", "the", "in", "on", "at", "for", "to", "of", "and", "or", "but", "with", "by", "is", "are", "was", "were"] and is_valid(w):
+                    return w
+            for w in words:
+                if is_valid(w):
+                    return w
+        
+    first_token = re.search(r'\w+', cleaned)
+    if first_token and is_valid(first_token.group(0)):
+        return first_token.group(0)
+        
+    return ""
+
+def safe_filename(name, max_len=40):
+    main_word = extract_main_word(name).strip()
+    
+    cleaned = name.replace('_', ' ').replace(',', ' ')
+    cleaned = re.sub(r'[\\/*?:"<>|\'\`\(\)\[\]]', ' ', cleaned)
+    cleaned = re.sub(r'\s+', ' ', cleaned).strip()
+    
+    if main_word:
+        if cleaned.lower().startswith(main_word.lower()):
+            final_title = cleaned
+        else:
+            final_title = f"{main_word} {cleaned}"
+    else:
+        final_title = cleaned
+        
+    final_title = re.sub(r'\s+', ' ', final_title).strip()
+    
+    if len(final_title) > max_len:
+        final_title = final_title[:max_len].strip()
+        final_title = re.sub(r'[\s\.,\-_\+!@#\$%^&\*]+$', '', final_title)
+        
+    return final_title
+
+def get_gpu_stats():
+    try:
+        output = subprocess.check_output(
+            ['nvidia-smi', '--query-gpu=utilization.gpu,memory.used,memory.total', '--format=csv,noheader,nounits'],
+            stderr=subprocess.DEVNULL
+        ).decode().strip()
+        parts = output.split(',')
+        if len(parts) >= 3:
+            return {
+                "util": int(parts[0].strip()),
+                "mem_used": int(parts[1].strip()),
+                "mem_total": int(parts[2].strip())
+            }
+    except Exception:
+        pass
+    return None
+
+def is_gpu_actually_busy(threshold_util=25, threshold_mem_ratio=0.96):
+    stats = get_gpu_stats()
+    if stats is None:
+        return False
+    mem_ratio = stats["mem_used"] / stats["mem_total"]
+    if stats["util"] > threshold_util or mem_ratio > threshold_mem_ratio:
+        return True
+    return False
+
+def is_port_open(host, port):
+    import socket
+    try:
+        with socket.create_connection((host, port), timeout=1):
+            return True
+    except OSError:
+        return False
+
+def get_comfyui_url():
+    if is_port_open("127.0.0.1", 8188):
+        return "http://127.0.0.1:8188"
+    if is_port_open("127.0.0.1", 7777):
+        return "http://127.0.0.1:7777"
+    return "http://127.0.0.1:8188"
+
+def get_queue():
+    try:
+        url = get_comfyui_url()
+        req = urllib.request.Request(f"{url}/queue")
+        with urllib.request.urlopen(req, timeout=3) as response:
+            return json.loads(response.read().decode('utf-8'))
+    except Exception as e:
+        print(f"Error connecting to ComfyUI ({get_comfyui_url()}): {e}")
+        return None
+
+def queue_prompt(prompt, client_id="video_generator_agent"):
+    p = {"prompt": prompt, "client_id": client_id}
+    data = json.dumps(p).encode('utf-8')
+    url = get_comfyui_url()
+    req = urllib.request.Request(f"{url}/prompt", data=data, headers={'Content-Type': 'application/json'})
+    with urllib.request.urlopen(req) as response:
+        return json.loads(response.read().decode('utf-8'))
+
+def check_severe_assets():
+    avatar_exists = os.path.exists(os.path.join(COMFY_INPUT_DIR, "android_severe_upscale.png"))
+    voice_exists = os.path.exists(os.path.join(COMFY_INPUT_DIR, "android_severe.wav"))
+    return avatar_exists and voice_exists
+
+def generate_youtube_metadata(article_path, dest_dir, safe_name, size):
+    # Try to find the original article title from the main markdown file
+    main_title = safe_name
+    main_md_files = [f for f in os.listdir(article_path) if f.endswith(".md") and not f.startswith("script_") and f != "watermark_scan_report.md"]
+    article_summary = ""
+    source_info = ""
+    
+    if main_md_files:
+        main_md_path = os.path.join(article_path, main_md_files[0])
+        try:
+            with open(main_md_path, "r", encoding="utf-8", errors="replace") as f:
+                first_line = f.readline().strip()
+                if first_line.startswith("#"):
+                    main_title = first_line.lstrip("#").strip()
+                else:
+                    main_title = os.path.splitext(main_md_files[0])[0]
+                    
+            with open(main_md_path, "r", encoding="utf-8", errors="replace") as f:
+                content = f.read().strip()
+                paragraphs = [p.strip() for p in content.split('\n') if p.strip()]
+                non_headers = [p for p in paragraphs if not p.startswith('#')]
+                if non_headers:
+                    article_summary = non_headers[0]
+                
+                for p in paragraphs:
+                    if p.startswith("**Source:**"):
+                        source_text = p.replace("**Source:**", "").strip()
+                        match = re.search(r'\[([^\]]+)\]\(([^)]+)\)', source_text)
+                        if match:
+                            source_info = f"{match.group(1)} ({match.group(2)})"
+                        else:
+                            source_info = source_text
+        except Exception as e:
+            print(f"  Warning: Could not parse markdown for metadata: {e}")
+
+    suffix = f" ({size.capitalize()} Version)"
+    max_title_len = 100 - len(suffix)
+    if len(main_title) > max_title_len:
+        main_title = main_title[:max_title_len-3].strip() + "..."
+        
+    main_title = f"{main_title}{suffix}"
+        
+    script_text = ""
+    script_path = os.path.join(article_path, f"script_{size}_clean.txt")
+    if not os.path.exists(script_path):
+        script_path = os.path.join(article_path, f"script_{size}.md")
+        
+    if os.path.exists(script_path):
+        try:
+            with open(script_path, "r", encoding="utf-8") as f:
+                script_text = f.read().strip()
+        except Exception:
+            pass
+
+    if script_path.endswith('.md') and script_text:
+        lines = script_text.splitlines()
+        cleaned_lines = []
+        for line in lines:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            line = re.sub(r'^\**[A-Za-z0-9\s\(\)\.\-\_]+:\**\s*', '', line)
+            line = re.sub(r'\([^)]*\)', '', line)
+            line = re.sub(r'\[[^\]]*\]', '', line)
+            line = line.replace('**', '').replace('*', '').strip()
+            if line:
+                cleaned_lines.append(line)
+        script_text = "\n\n".join(cleaned_lines)
+
+    metadata_lines = []
+    metadata_lines.append("=== YOUTUBE UPLOAD METADATA ===")
+    metadata_lines.append(f"SUGGESTED TITLE: {main_title}")
+    metadata_lines.append("===============================")
+    metadata_lines.append("")
+    metadata_lines.append("=== DESCRIPTION ===")
+    
+    if script_text:
+        metadata_lines.append(script_text[:500] + ("..." if len(script_text) > 500 else ""))
+    elif article_summary:
+        metadata_lines.append(article_summary)
+    else:
+        metadata_lines.append(f"In this video: Latest news and updates about {main_title}.")
+        
+    if source_info:
+        metadata_lines.append(f"\nSource: {source_info}")
+    else:
+        metadata_lines.append("\nSource: The Android Times / Provided News Sources")
+        
+    metadata_lines.append("")
+    metadata_lines.append("--- Video Transcript ---")
+    if script_text:
+        metadata_lines.append(script_text)
+    else:
+        metadata_lines.append("(Transcript not available)")
+        
+    metadata_lines.append("")
+    metadata_lines.append("--- About The Android Times ---")
+    metadata_lines.append("Your daily source for Android, AI, and technology news updates.")
+    metadata_lines.append("Subscribe to stay updated with the latest in tech!")
+    metadata_lines.append("")
+    metadata_lines.append(f"#Android #Tech #News #{size.capitalize()}")
+    metadata_lines.append("")
+    
+    metadata_path = os.path.join(dest_dir, "youtube_metadata.txt")
+    try:
+        with open(metadata_path, "w", encoding="utf-8") as f:
+            f.write("\n".join(metadata_lines))
+        print(f"  Generated YouTube metadata: {metadata_path}")
+    except Exception as e:
+        print(f"  Error generating YouTube metadata file: {e}")
+
+def package_youtube_assets(article_path, src_video_path, safe_name, size):
+    try:
+        youtube_dest_dir = os.path.join(WORKSPACE_DIR, "Youtube", f"{safe_name}_{size}")
+        os.makedirs(youtube_dest_dir, exist_ok=True)
+        
+        # 1. Copy article folder contents to Youtube\<safe_name>_<size>
+        for item in os.listdir(article_path):
+            s_item = os.path.join(article_path, item)
+            d_item = os.path.join(youtube_dest_dir, item)
+            if os.path.isdir(s_item):
+                if item not in ["__pycache__", "images", "sources"]:
+                    shutil.copytree(s_item, d_item, dirs_exist_ok=True)
+            else:
+                shutil.copy2(s_item, d_item)
+                
+        # Copy the video .mp4 there too
+        youtube_video_dest = os.path.join(youtube_dest_dir, f"{safe_name}_{size}.mp4")
+        shutil.copy2(src_video_path, youtube_video_dest)
+        print(f"  Successfully copied video to Youtube folder: {youtube_video_dest}")
+        
+        # 2. Generate YouTube Metadata
+        generate_youtube_metadata(article_path, youtube_dest_dir, safe_name, size)
+        
+    except Exception as e:
+        print(f"  Error packaging YouTube assets: {e}")
+
+def get_all_article_directories():
+    article_paths = []
+    locales = ["en-US"]
+    for locale in locales:
+        locale_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(locale_path) or not os.path.isdir(locale_path):
+            continue
+        try:
+            categories = os.listdir(locale_path)
+        except OSError:
+            continue
+        for category in categories:
+            if category == "__pycache__":
+                continue
+            cat_path = os.path.join(locale_path, category)
+            if not os.path.exists(cat_path) or not os.path.isdir(cat_path):
+                continue
+            try:
+                articles = os.listdir(cat_path)
+            except OSError:
+                continue
+            for article in articles:
+                if article in ["__pycache__", "images", "sources"]:
+                    continue
+                article_path = os.path.join(cat_path, article)
+                if os.path.isdir(article_path):
+                    article_paths.append(article_path)
+    return article_paths
+
+def copy_talkvideos_to_articles():
+    talkvideo_dir = r"C:\Android Times\newsvideo"
+    if not os.path.exists(talkvideo_dir):
+        print(f"talkvideo directory not found: {talkvideo_dir}")
+        return
+        
+    try:
+        video_files = [f for f in os.listdir(talkvideo_dir) if f.lower().endswith(".mp4")]
+    except OSError as e:
+        print(f"Error listing talkvideo directory: {e}")
+        return
+        
+    if not video_files:
+        print("No video files found in talkvideo directory.")
+        return
+        
+    article_dirs = get_all_article_directories()
+    
+    copied_count = 0
+    for video_file in video_files:
+        src_path = os.path.join(talkvideo_dir, video_file)
+        
+        # Parse prefix and suffix
+        base_name = os.path.splitext(video_file)[0]
+        size = None
+        for s in ["_short", "_middle", "_long"]:
+            if base_name.endswith(s):
+                size = s[1:]
+                prefix = base_name[:-len(s)]
+                break
+        else:
+            size = "middle"
+            prefix = base_name
+            
+        normalized_prefix = prefix.strip().lower()
+        matched_article_path = None
+        
+        # 1. Try exact matching
+        for art_path in article_dirs:
+            folder_name = os.path.basename(art_path)
+            if safe_filename(folder_name).strip().lower() == normalized_prefix:
+                matched_article_path = art_path
+                break
+            if folder_name.strip().lower() == normalized_prefix:
+                matched_article_path = art_path
+                break
+            if folder_name.replace('_', ' ').strip().lower() == normalized_prefix:
+                matched_article_path = art_path
+                break
+                
+        # 2. Try word-based fallback matching if no exact match found
+        if not matched_article_path:
+            words = re.findall(r'[a-zA-Z0-9]+', prefix)
+            ignore_words = {"and", "the", "for", "with", "from", "that", "this", "our", "you", "your", "com"}
+            filtered_words = [w.lower() for w in words if len(w) >= 2 and w.lower() not in ignore_words]
+            
+            if filtered_words:
+                candidates = []
+                for art_path in article_dirs:
+                    folder_name = os.path.basename(art_path).replace('_', ' ').lower()
+                    if all(w in folder_name for w in filtered_words):
+                        candidates.append(art_path)
+                
+                if len(candidates) == 1:
+                    matched_article_path = candidates[0]
+                elif len(candidates) > 1:
+                    # Filter candidates that have .flac files
+                    candidates_with_flac = []
+                    for c in candidates:
+                        flac_files = [f for f in os.listdir(c) if f.lower().endswith(".flac")]
+                        if flac_files:
+                            candidates_with_flac.append(c)
+                    
+                    if len(candidates_with_flac) == 1:
+                        matched_article_path = candidates_with_flac[0]
+                    elif len(candidates_with_flac) > 1:
+                        candidates_with_flac.sort(key=lambda p: len(os.path.basename(p)))
+                        matched_article_path = candidates_with_flac[0]
+                    else:
+                        candidates.sort(key=lambda p: len(os.path.basename(p)))
+                        matched_article_path = candidates[0]
+                        
+        if matched_article_path:
+            folder_name = os.path.basename(matched_article_path)
+            safe_name = safe_filename(folder_name)
+            dest_filename = f"{safe_name}_{size}.mp4"
+            
+            # Copy to ComfyUI articles folder
+            dest_path = os.path.join(matched_article_path, dest_filename)
+            
+            # Copy to Workspace articles folder
+            rel_path = os.path.relpath(matched_article_path, ROOT_DIR)
+            workspace_dest_dir = os.path.join(WORKSPACE_DIR, "Articles", rel_path)
+            workspace_dest_path = os.path.join(workspace_dest_dir, dest_filename)
+            
+            try:
+                src_size = os.path.getsize(src_path)
+                
+                # Check ComfyUI target
+                comfy_updated = False
+                if (not os.path.exists(dest_path)) or (os.path.getsize(dest_path) != src_size):
+                    print(f"Saving speaker video to ComfyUI article folder:")
+                    print(f"  {src_path} -> {dest_path}")
+                    shutil.copy2(src_path, dest_path)
+                    comfy_updated = True
+                    copied_count += 1
+                    
+                # Check Workspace target
+                if (not os.path.exists(workspace_dest_path)) or (os.path.getsize(workspace_dest_path) != src_size):
+                    print(f"Saving speaker video to Workspace article folder:")
+                    print(f"  {src_path} -> {workspace_dest_path}")
+                    os.makedirs(workspace_dest_dir, exist_ok=True)
+                    shutil.copy2(src_path, workspace_dest_path)
+                    if not comfy_updated: # avoid double counting
+                        copied_count += 1
+                        
+            except Exception as e:
+                print(f"  Error copying {video_file}: {e}")
+                
+    print(f"Speaker video sync finished. Copied/updated {copied_count} file(s).")
+
+def main():
+    print(f"=== News Video Generator Step Utility: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} ===")
+    
+    # Copy speaker videos from talkvideo to corresponding article directories
+    copy_talkvideos_to_articles()
+
+    
+    if not (is_port_open("127.0.0.1", 8188) or is_port_open("127.0.0.1", 7777)):
+        print("Error: ComfyUI server is offline (ports 8188 / 7777).")
+        sys.exit(1)
+        
+    queue_status = get_queue()
+    if queue_status is None:
+        sys.exit(1)
+        
+    running_jobs = queue_status.get("queue_running", [])
+    pending_jobs = queue_status.get("queue_pending", [])
+    
+    running_count = len(running_jobs)
+    pending_count = len(pending_jobs)
+    
+    print(f"ComfyUI Status - Running: {running_count}, Pending: {pending_count}")
+    
+    # 1. Scan for READY_FOR_VIDEO articles
+    locales = ["en-US"]
+    ready_articles = []
+    
+    target_article = None
+    if len(sys.argv) > 1:
+        for i in range(1, len(sys.argv)):
+            if sys.argv[i] == "--article" and i + 1 < len(sys.argv):
+                target_article = sys.argv[i+1]
+    
+    for locale in locales:
+        locale_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(locale_path) or not os.path.isdir(locale_path):
+            continue
+            
+        try:
+            categories = os.listdir(locale_path)
+        except OSError:
+            continue
+            
+        for category in categories:
+            if category == "__pycache__":
+                continue
+            cat_path = os.path.join(locale_path, category)
+            if not os.path.exists(cat_path) or not os.path.isdir(cat_path):
+                continue
+                
+            try:
+                articles = os.listdir(cat_path)
+            except OSError:
+                continue
+                
+            for article in articles:
+                if article in ["__pycache__", "images", "sources"]:
+                    continue
+                if target_article and target_article not in article:
+                    continue
+                article_path = os.path.join(cat_path, article)
+                if not os.path.isdir(article_path):
+                    continue
+                    
+                # Check evaluation status
+                eval_path = os.path.join(article_path, "evaluation_result.json")
+                if os.path.exists(eval_path):
+                    try:
+                        with open(eval_path, 'r', encoding='utf-8') as ef:
+                            eval_data = ef.read()
+                        if '"status": "READY_FOR_VIDEO"' in eval_data:
+                            # Check tier (Only S/A tier: 1 or 2)
+                            json_path = os.path.join(article_path, f"{article}.json")
+                            if not os.path.exists(json_path):
+                                continue
+                            try:
+                                with open(json_path, 'r', encoding='utf-8') as jf:
+                                    meta = json.load(jf)
+                                if meta.get("tier") not in [1, 2]:
+                                    continue
+                            except Exception as te:
+                                print(f"Warning: Failed to read tier for {article}: {te}")
+                                continue
+
+                            safe_name = safe_filename(article)
+                            
+                            # Migrate legacy [safe_name].mp4 to [safe_name]_middle.mp4 if it exists
+                            legacy_video = os.path.join(article_path, f"{safe_name}.mp4")
+                            migrated_video = os.path.join(article_path, f"{safe_name}_middle.mp4")
+                            if os.path.exists(legacy_video) and not os.path.exists(migrated_video):
+                                try:
+                                    shutil.move(legacy_video, migrated_video)
+                                    print(f"Migrated legacy video for {article} to _middle.mp4")
+                                except Exception as me:
+                                    print(f"Warning: Failed to migrate legacy video: {me}")
+
+                            # Find which of the sizes are missing
+                            missing_sizes = []
+                            for sz in ["middle", "short", "long"]:
+                                if not os.path.exists(os.path.join(article_path, f"{safe_name}_{sz}.mp4")):
+                                    missing_sizes.append(sz)
+                                    
+                            if missing_sizes:
+                                ready_articles.append({
+                                    "path": article_path,
+                                    "category": category,
+                                    "locale": locale,
+                                    "name": article,
+                                    "missing_sizes": missing_sizes
+                                })
+                    except Exception as e:
+                        print(f"Warning: Failed to read {eval_path}: {e}")
+
+    # Prioritize Moscow Attacks and War/Military categories
+    def get_priority(art):
+        path_lower = art["path"].lower()
+        score = 0
+        if "en-us" in path_lower:
+            score += 10000
+        if "en-us" in path_lower and "moscow_attacks" in path_lower:
+            score += 1000
+        elif "moscow_attacks" in path_lower:
+            score += 500
+        elif "war_and_military" in path_lower:
+            score += 400
+        return score
+
+    ready_articles.sort(key=get_priority, reverse=True)
+
+    # 2. Check for completed videos in ComfyUI output directory and copy them
+    video_dir = os.path.join(COMFY_OUTPUT_DIR, "video")
+    if not os.path.exists(video_dir):
+        video_dir = os.path.join(r"C:\ComfyUI\output", "video")
+        
+    copied_count = 0
+    if os.path.exists(video_dir):
+        for art in ready_articles:
+            safe_name = safe_filename(art["name"])
+            for sz in list(art["missing_sizes"]): # Use list copy to safely modify missing_sizes
+                try:
+                    # ComfyUI output filenames will be prefixed with safe_name_sz
+                    matching_files = [f for f in os.listdir(video_dir) if f.startswith(f"{safe_name}_{sz}") and f.endswith(".mp4")]
+                except OSError:
+                    matching_files = []
+                if matching_files:
+                    # Sort by modification time to get the latest
+                    matching_files.sort(key=lambda f: os.path.getmtime(os.path.join(video_dir, f)), reverse=True)
+                    latest_video = matching_files[0]
+                    src_path = os.path.join(video_dir, latest_video)
+                    dest_path = os.path.join(art["path"], f"{safe_name}_{sz}.mp4")
+                    
+                    print(f"Found completed {sz} video for: {art['name']}")
+                    print(f"  Copying: {src_path} -> {dest_path}")
+                    try:
+                        shutil.copy2(src_path, dest_path)
+                        print("  Successfully copied!")
+                        package_youtube_assets(art["path"], src_path, safe_name, sz)
+                        copied_count += 1
+                        art["missing_sizes"].remove(sz)
+                    except Exception as e:
+                        print(f"  Error copying file: {e}")
+
+    # Update ready list (exclude ones that have no missing sizes anymore)
+    if copied_count > 0:
+        ready_articles = [art for art in ready_articles if art["missing_sizes"]]
+        
+        # Run sync script
+        copy_script = os.path.join(ROOT_DIR, "copy_passed_articles.py")
+        if os.path.exists(copy_script):
+            print("\nRunning copy_passed_articles.py to sync to workspace...")
+            try:
+                import subprocess
+                subprocess.run(["python", copy_script], check=True)
+                print("Sync completed successfully.")
+            except Exception as e:
+                print(f"Warning: Failed to sync: {e}")
+
+    # 3. Submit next job if ComfyUI is idle
+    if running_count == 0 and pending_count == 0:
+        if ready_articles:
+            # Check GPU utilization
+            if is_gpu_actually_busy(threshold_util=25):
+                print("ComfyUI queue is empty, but GPU is busy (possibly running TTS or other tasks). Suspending video generation job submission.")
+                sys.exit(0)
+                
+            next_art = ready_articles[0]
+            # Select the highest priority missing size
+            script_type = next_art["missing_sizes"][0]
+            print(f"\nSubmitting next video generation job for: {next_art['name']} (Size: {script_type})")
+            
+            # Find script and determine the matched script type
+            script_path = os.path.join(next_art["path"], f"script_{script_type}_clean.txt")
+            if not os.path.exists(script_path):
+                script_path = os.path.join(next_art["path"], f"script_{script_type}.md")
+
+            if not os.path.exists(script_path):
+                print(f"  Error: No script file found for {script_type} in {next_art['path']}. Skipping.")
+                sys.exit(1)
+
+            try:
+                with open(script_path, 'r', encoding='utf-8') as f:
+                    script_text = f.read().strip()
+            except Exception as e:
+                print(f"  Error: Failed to read script file {script_path}: {e}")
+                sys.exit(1)
+
+            # Clean script text if md
+            if script_path.endswith('.md'):
+                lines = script_text.splitlines()
+                cleaned_lines = []
+                for line in lines:
+                    line = line.strip()
+                    if not line or line.startswith('#'):
+                        continue
+                    line = re.sub(r'^\**[A-Za-z0-9\s\(\)\.\-\_]+:\**\s*', '', line)
+                    line = re.sub(r'\([^)]*\)', '', line)
+                    line = re.sub(r'\[[^\]]*\]', '', line)
+                    line = line.replace('**', '').replace('*', '').strip()
+                    if line:
+                        cleaned_lines.append(line)
+                script_text = "\n\n".join(cleaned_lines)
+
+            if not script_text:
+                print("  Error: Cleaned script text is empty. Skipping.")
+                sys.exit(1)
+
+            # Determine severity
+            cat_lower = str(next_art["category"]).lower()
+            is_severe = "military" in cat_lower or "conflict" in cat_lower or "severe" in cat_lower or "attack" in cat_lower
+            
+            use_severe_workflow = False
+            if is_severe:
+                if check_severe_assets():
+                    use_severe_workflow = True
+                    print("  Using severe category settings.")
+                else:
+                    print("  Severe assets missing in ComfyUI/input. Falling back to normal settings.")
+
+            workflow_filename = "flat_prompt_severe.json" if use_severe_workflow else "flat_prompt.json"
+            workflow_path = os.path.join(WORKSPACE_DIR, workflow_filename)
+            if not os.path.exists(workflow_path):
+                workflow_path = os.path.join(ROOT_DIR, workflow_filename)
+
+            if not os.path.exists(workflow_path):
+                print(f"  Error: Workflow JSON not found at {workflow_path}.")
+                sys.exit(1)
+
+            try:
+                with open(workflow_path, 'r', encoding='utf-8') as f:
+                    workflow = json.load(f)
+            except Exception as e:
+                print(f"  Error: Failed to load workflow JSON {workflow_path}: {e}")
+                sys.exit(1)
+
+            workflow["42"]["inputs"]["text"] = script_text
+            
+            # Find pre-generated voiceover audio in the article directory matching the script type
+            audio_files = [f for f in os.listdir(next_art["path"]) if f.lower().endswith(('.flac', '.wav', '.mp3'))]
+            if audio_files:
+                # Try to find a file matching the specific script type (short, long, or middle/standard)
+                audio_file = None
+                if script_type == "short":
+                    matched = [f for f in audio_files if "_short_" in f.lower()]
+                    if matched: audio_file = matched[0]
+                elif script_type == "long":
+                    matched = [f for f in audio_files if "_long_" in f.lower()]
+                    if matched: audio_file = matched[0]
+                else: # middle
+                    matched = [f for f in audio_files if "_indextts" in f.lower() and "_short_" not in f.lower() and "_long_" not in f.lower()]
+                    if matched: audio_file = matched[0]
+                
+                # Fallback to any flac or audio file if specific match not found
+                if not audio_file:
+                    main_audio = [f for f in audio_files if f.lower().endswith('.flac')]
+                    if not main_audio:
+                        main_audio = audio_files
+                    audio_file = main_audio[0]
+                
+                src_audio_path = os.path.join(next_art["path"], audio_file)
+                dest_audio_name = f"temp_ready_audio{os.path.splitext(audio_file)[1]}"
+                dest_audio_path = os.path.join(COMFY_INPUT_DIR, dest_audio_name)
+                
+                print(f"  Found pre-generated voiceover audio: {audio_file} (matched to {script_type} script)")
+                print(f"  Copying: {src_audio_path} -> {dest_audio_path}")
+                try:
+                    shutil.copy2(src_audio_path, dest_audio_path)
+                    if "66_73" in workflow:
+                        workflow["66_73"]["inputs"]["audio"] = dest_audio_name
+                        print(f"  Updated LoadAudio node to load: {dest_audio_name}")
+                    elif "66:73" in workflow:
+                        workflow["66:73"]["inputs"]["audio"] = dest_audio_name
+                        print(f"  Updated LoadAudio node to load: {dest_audio_name}")
+                    else:
+                        print("  Warning: LoadAudio node 66_73 (or 66:73) not found in workflow.")
+                except Exception as copy_err:
+                    print(f"  Warning: Failed to copy voiceover audio: {copy_err}")
+            else:
+                print("  Warning: No pre-generated voiceover audio found in article directory.")
+
+            safe_name = safe_filename(next_art["name"])
+            
+            # Support both SaveVideo node ID 78 and 97
+            save_video_id = None
+            if "78" in workflow:
+                save_video_id = "78"
+            elif "97" in workflow:
+                save_video_id = "97"
+                
+            if save_video_id:
+                workflow[save_video_id]["inputs"]["filename_prefix"] = f"video/{safe_name}_{script_type}"
+                print(f"  Updated SaveVideo node {save_video_id} filename_prefix.")
+            else:
+                print("  Warning: SaveVideo node 78 or 97 not found in workflow.")
+
+            try:
+                res = queue_prompt(workflow)
+                prompt_id = res.get("prompt_id")
+                print(f"  Success! Job queued in ComfyUI. Prompt ID: {prompt_id}")
+            except Exception as e:
+                print(f"  Error submitting prompt to ComfyUI: {e}")
+                sys.exit(1)
+        else:
+            print("No articles are ready for video generation.")
+    else:
+        # Check if the running job has our client ID
+        running_prompts = [x[1] for x in running_jobs]
+        print(f"Active Job in ComfyUI: {running_prompts}")
+
+if __name__ == "__main__":
+    main()

quality_gate_articles.py

@@ -0,0 +1,410 @@
+import os
+import json
+import sys
+import re
+import difflib
+from datetime import datetime
+
+try:
+    import litert_lm
+except ImportError:
+    litert_lm = None
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+SYNTHESIS_FILE = os.path.join(ROOT_DIR, "synthesis_output.json")
+LITERT_MODEL_PATH = r"D:\text_encoders\gemma-4-E2B-it-litert-lm\gemma-4-E2B-it.litertlm"
+
+def get_existing_article_titles():
+    """
+    Scan category directories under locales (en-US, en-EU, ja-JP) to collect 
+    existing sanitized titles/folder names for duplicate detection.
+    """
+    titles = set()
+    locales = ["en-US", "en-EU", "ja-JP", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]
+    for locale in locales:
+        loc_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(loc_path):
+            continue
+        for cat in os.listdir(loc_path):
+            cat_path = os.path.join(loc_path, cat)
+            if not os.path.isdir(cat_path) or cat == "__pycache__":
+                continue
+            for art in os.listdir(cat_path):
+                art_path = os.path.join(cat_path, art)
+                if os.path.isdir(art_path) and art not in ["__pycache__", "images", "sources"]:
+                    titles.add(art.lower())
+                    titles.add(art.replace('_', ' ').lower())
+    return titles
+
+def is_duplicate(new_title, existing_titles, current_batch_titles, threshold=0.8):
+    """
+    Check if a new article title is a duplicate of past articles or current batch.
+    Uses SequenceMatcher ratio with a length-difference speed filter.
+    """
+    new_title_clean = new_title.strip().lower()
+    
+    # 1. Exact matches
+    if new_title_clean in existing_titles or new_title_clean in current_batch_titles:
+        return True, "Exact title match"
+        
+    # 2. Similarity checks against existing articles
+    for ext_title in existing_titles:
+        # Fast optimization: skip if length difference is too large
+        if abs(len(new_title_clean) - len(ext_title)) > max(10, len(new_title_clean) * 0.4):
+            continue
+        ratio = difflib.SequenceMatcher(None, new_title_clean, ext_title).ratio()
+        if ratio >= threshold:
+            return True, f"High similarity ({int(ratio*100)}%) with existing article: '{ext_title}'"
+            
+    # 3. Similarity checks against current batch
+    for cur_title in current_batch_titles:
+        if abs(len(new_title_clean) - len(cur_title)) > max(10, len(new_title_clean) * 0.4):
+            continue
+        ratio = difflib.SequenceMatcher(None, new_title_clean, cur_title).ratio()
+        if ratio >= threshold:
+            return True, f"High similarity ({int(ratio*100)}%) with another article in this batch: '{cur_title}'"
+            
+    return False, ""
+
+
+def clean_article_text(markdown_content):
+    """
+    Remove markdown headers, metadata lines, image embeds, links, and common footers
+    to extract the pure body text of the article for similarity comparison.
+    """
+    if not markdown_content:
+        return ""
+    
+    lines = markdown_content.splitlines()
+    cleaned_lines = []
+    
+    for line in lines:
+        line_strip = line.strip()
+        if not line_strip:
+            continue
+        if line_strip.startswith("#"):
+            continue
+        if line_strip.startswith("**Category:**") or line_strip.startswith("**Locale:**") or line_strip.startswith("**Source:**") or line_strip.startswith("**Date Collected:**"):
+            continue
+        if line_strip.startswith("!["):
+            continue
+        if line_strip == "---":
+            continue
+        if "*This article was automatically collected" in line_strip or "scraped" in line_strip.lower():
+            continue
+            
+        cleaned_lines.append(line_strip)
+        
+    text = " ".join(cleaned_lines)
+    text = re.sub(r'<[^>]+>', '', text)
+    text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def get_recent_article_bodies(max_per_category=30):
+    """
+    Scan category directories under locales (en-US, en-EU, ja-JP) to collect 
+    recent articles' markdown file paths, read their content, and return a dict of {title: cleaned_body}.
+    """
+    recent_bodies = {}
+    locales = ["en-US", "en-EU", "ja-JP", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]
+    for locale in locales:
+        loc_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(loc_path):
+            continue
+        for cat in os.listdir(loc_path):
+            cat_path = os.path.join(loc_path, cat)
+            if not os.path.isdir(cat_path) or cat == "__pycache__":
+                continue
+            
+            articles = []
+            for art in os.listdir(cat_path):
+                art_path = os.path.join(cat_path, art)
+                if os.path.isdir(art_path) and art not in ["__pycache__", "images", "sources"]:
+                    try:
+                        mtime = os.path.getmtime(art_path)
+                        articles.append((art, art_path, mtime))
+                    except Exception:
+                        continue
+            
+            articles.sort(key=lambda x: x[2], reverse=True)
+            for art, art_path, _ in articles[:max_per_category]:
+                md_file_name = f"{art}.md"
+                md_file_path = os.path.join(art_path, md_file_name)
+                if os.path.exists(md_file_path):
+                    try:
+                        with open(md_file_path, "r", encoding="utf-8") as f:
+                            content = f.read()
+                        cleaned = clean_article_text(content)
+                        if cleaned:
+                            recent_bodies[art.lower()] = cleaned
+                    except Exception as e:
+                        print(f"Error reading past article {md_file_path}: {e}")
+    return recent_bodies
+
+def get_words(text):
+    """
+    Extract alphanumeric words from text and normalize to lowercase.
+    For Japanese, extract character bi-grams (2-character pairs) to improve similarity precision.
+    """
+    text_lower = text.lower()
+    is_ja = any(ord(char) > 0x3000 for char in text_lower)
+    if is_ja:
+        cleaned_chars = [char for char in text_lower if char.isalnum() and not char.isspace()]
+        bigrams = set()
+        for i in range(len(cleaned_chars) - 1):
+            bigrams.add(cleaned_chars[i] + cleaned_chars[i+1])
+        return bigrams
+    else:
+        return set(re.findall(r'\b[a-z0-9]+\b', text_lower))
+
+def is_content_duplicate(new_text, existing_bodies, current_batch_bodies, jaccard_threshold=0.65, seq_threshold=0.70):
+    """
+    Check if the cleaned new_text is a duplicate of existing articles or current batch.
+    Uses Jaccard word/bigram similarity as a fast pre-filter, followed by SequenceMatcher on prefix.
+    """
+    new_cleaned = clean_article_text(new_text)
+    if not new_cleaned:
+        return False, ""
+        
+    new_words = get_words(new_cleaned)
+    if not new_words:
+        return False, ""
+        
+    # Check against existing articles
+    for ext_title, ext_body in existing_bodies.items():
+        ext_words = get_words(ext_body)
+        if not ext_words:
+            continue
+            
+        intersection = new_words.intersection(ext_words)
+        union = new_words.union(ext_words)
+        jaccard = len(intersection) / len(union) if union else 0.0
+        
+        # Fast early-exit: Jaccard similarity must be at least 0.35 to be a candidate
+        if jaccard < 0.35:
+            continue
+            
+        new_prefix = new_cleaned[:1000]
+        ext_prefix = ext_body[:1000]
+        ratio = difflib.SequenceMatcher(None, new_prefix, ext_prefix).ratio()
+        
+        # Strict AND condition to minimize false positives
+        if jaccard >= jaccard_threshold and ratio >= seq_threshold:
+            reason = f"High content similarity (Jaccard: {int(jaccard*100)}%, SequenceMatcher: {int(ratio*100)}%) with existing article: '{ext_title}'"
+            return True, reason
+            
+    # Check against current batch
+    for cur_title, cur_body in current_batch_bodies.items():
+        cur_words = get_words(cur_body)
+        if not cur_words:
+            continue
+            
+        intersection = new_words.intersection(cur_words)
+        union = new_words.union(cur_words)
+        jaccard = len(intersection) / len(union) if union else 0.0
+        
+        # Fast early-exit
+        if jaccard < 0.35:
+            continue
+            
+        new_prefix = new_cleaned[:1000]
+        cur_prefix = cur_body[:1000]
+        ratio = difflib.SequenceMatcher(None, new_prefix, cur_prefix).ratio()
+        
+        # Strict AND condition
+        if jaccard >= jaccard_threshold and ratio >= seq_threshold:
+            reason = f"High content similarity (Jaccard: {int(jaccard*100)}%, SequenceMatcher: {int(ratio*100)}%) with another article in this batch: '{cur_title}'"
+            return True, reason
+            
+    return False, ""
+
+
+
+def load_json(path, default):
+    if os.path.exists(path):
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Failed to load JSON {path}: {e}")
+    return default
+
+def save_json(path, data):
+    try:
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+    except Exception as e:
+        print(f"Failed to save JSON {path}: {e}")
+
+def evaluate_raw_markdown(markdown_content):
+    """
+    Perform fast, hard-coded checks before sending to LLM.
+    Returns (is_valid: bool, reason: str)
+    """
+    # 1. Length check
+    if len(markdown_content) < 150:
+        return False, "Article is too short (< 150 chars). Likely a scraping error or stub."
+        
+    # 2. Regex Check: Scraping Errors
+    error_patterns = [
+        r"403\s+forbidden",
+        r"access\s+denied",
+        r"enable\s+javascript",
+        r"please\s+enable\s+cookies",
+        r"cloudflare",
+        r"captcha",
+        r"are\s+you\s+a\s+robot"
+    ]
+    for pattern in error_patterns:
+        if re.search(pattern, markdown_content, re.IGNORECASE):
+            return False, f"Matches scraping error signature: '{pattern}'"
+            
+    return True, "Pass"
+
+def build_proofread_prompt(article_markdown):
+    prompt = f"""You are a strict News Quality Gatekeeper and Proofreader.
+Your task is to evaluate the following scraped text.
+
+Instructions:
+1. If the text is an error page, a privacy policy, a captcha request, or pure spam, reply strictly and ONLY with the text: "REJECT: [Reason]".
+2. If it is a valid news article, review it for grammatical correctness, natural flow, and factual consistency.
+3. PRESERVE the exact formatting of the article, including Markdown headings (#, ##), bullets, and the footer section ("---" and below containing Author and Sources).
+4. Output ONLY the corrected markdown text or the REJECT signal. Do not include any introductory or concluding remarks.
+
+Article to evaluate:
+{article_markdown}
+"""
+    return prompt
+
+def main():
+    print(f"Starting Quality Gate (READY_FOR_NEWS Evaluation) at {datetime.now().isoformat()}")
+    
+    synthesis_data = load_json(SYNTHESIS_FILE, [])
+    if not synthesis_data:
+        print("No synthesis data found. Exiting Quality Gate.")
+        return
+
+    print(f"Total articles pending evaluation: {len(synthesis_data)}")
+
+    if not litert_lm:
+        print("litert_lm module not found. Falling back to hard-filters only.")
+        engine = None
+    else:
+        print(f"Loading LiteRT-LM engine for deep evaluation: {LITERT_MODEL_PATH}")
+        try:
+            engine = litert_lm.Engine(LITERT_MODEL_PATH, backend=litert_lm.Backend.CPU, max_num_tokens=8192)
+        except Exception as e:
+            print(f"LiteRT-LM Engine failure: {e}. Falling back to hard-filters only.")
+            engine = None
+
+    filtered_synthesis_data = []
+    rejected_count = 0
+    passed_count = 0
+
+    # Collect existing titles and bodies once at start
+    existing_titles = get_existing_article_titles()
+    print("Loading recent article bodies for content duplication check...")
+    existing_bodies = get_recent_article_bodies(max_per_category=30)
+    print(f"Loaded {len(existing_bodies)} recent article bodies.")
+    current_batch_processed_titles = set()
+    current_batch_processed_bodies = {}  # {title: cleaned_body}
+
+    try:
+        for item in synthesis_data:
+            title = item.get("title", "Unknown Title")
+            markdown_content = item.get("markdown", "")
+            
+            if not markdown_content:
+                print(f"REJECTED '{title}': Empty markdown content.")
+                rejected_count += 1
+                continue
+                
+            print(f"Evaluating article: '{title}'...")
+            
+            # Step 0: Duplicate Checks
+            is_dup, dup_reason = is_duplicate(title, existing_titles, current_batch_processed_titles)
+            if is_dup:
+                print(f"  [REJECTED - Duplicate Title] {dup_reason}")
+                rejected_count += 1
+                continue
+                
+            is_content_dup, content_dup_reason = is_content_duplicate(
+                markdown_content, existing_bodies, current_batch_processed_bodies
+            )
+            if is_content_dup:
+                print(f"  [REJECTED - Duplicate Content] {content_dup_reason}")
+                rejected_count += 1
+                continue
+            
+            # Step 1: Hard Filters
+            is_valid, reason = evaluate_raw_markdown(markdown_content)
+            if not is_valid:
+                print(f"  [REJECTED by Hard Filter] {reason}")
+                rejected_count += 1
+                continue
+            
+            # Truncate if ridiculously long, but 8192 tokens should be enough
+            if len(markdown_content) > 15000:
+                print(f"  [FLAG] Article is extremely long. Skipping LLM proofread but passing through.")
+                item["status"] = "READY_FOR_NEWS"
+                filtered_synthesis_data.append(item)
+                passed_count += 1
+                continue
+            
+            # Step 2: LLM Evaluation
+            if engine:
+                prompt = build_proofread_prompt(markdown_content)
+                try:
+                    with engine.create_conversation() as conversation:
+                        response = conversation.send_message(prompt)
+                        output = response["content"][0]["text"].strip()
+                        
+                        if output.startswith("REJECT:"):
+                            print(f"  [REJECTED by LLM] {output[7:].strip()}")
+                            rejected_count += 1
+                            continue
+                        
+                        # Basic safety check: if model outputs something extremely short, keep original
+                        if len(output) > len(markdown_content) * 0.5:
+                            item["markdown"] = output
+                            print(f"  [PASS] Successfully evaluated and proofread.")
+                        else:
+                            print(f"  [PASS with Warning] Corrected output seems too short. Using original.")
+                            
+                except Exception as model_err:
+                    print(f"  [PASS with Warning] Error during LLM evaluation: {model_err}. Using original text.")
+            else:
+                print("  [PASS] Evaluated via hard-filter only (LLM offline).")
+                
+            item["status"] = "READY_FOR_NEWS"
+            filtered_synthesis_data.append(item)
+            current_batch_processed_titles.add(title.strip().lower())
+            
+            # Store cleaned body for future comparisons in the same batch
+            cleaned_body = clean_article_text(markdown_content)
+            current_batch_processed_bodies[title.strip().lower()] = cleaned_body
+            
+            passed_count += 1
+                    
+    finally:
+        if engine:
+            engine.close()
+
+    # Save the filtered results, dropping the rejected articles
+    if passed_count > 0 or rejected_count > 0:
+        save_json(SYNTHESIS_FILE, filtered_synthesis_data)
+        print("\n" + "="*40)
+        print("Quality Gate (READY_FOR_NEWS) Finished.")
+        print(f"Articles Passed: {passed_count}")
+        print(f"Articles Rejected & Dropped: {rejected_count}")
+        print(f"Filtered data saved to {SYNTHESIS_FILE}")
+        print("="*40)
+    else:
+        print("\nQuality Gate finished. No articles found to process.")
+
+if __name__ == "__main__":
+    main()

quality_gate_broll.py

@@ -0,0 +1,535 @@
+import os
+import sys
+import json
+import sqlite3
+import argparse
+import subprocess
+import logging
+from pathlib import Path
+import numpy as np
+from PIL import Image, ImageFilter
+
+# Reconfigure stdout/stderr to utf-8 to avoid encoding issues on Windows
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+# Logging setup
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("quality_gate_broll")
+
+def validate_image_asset(img_path, min_width=500, min_height=300):
+    """
+    Perform deep validation of a B-roll image file.
+    Checks: file existence, PIL verification, resolution, aspect ratio, blankness, and watermarks.
+    Returns: (bool, str) -> (is_valid, reason)
+    """
+    path = Path(img_path)
+    if not path.exists():
+        return False, "File does not exist"
+        
+    # Check minimum file size (e.g. 5KB)
+    try:
+        size = path.stat().st_size
+        if size < 5120:
+            return False, f"File size is too small ({size} bytes). Likely a corrupt download or placeholder."
+    except Exception as e:
+        return False, f"Failed to get file stats: {e}"
+
+    # 1. PIL opening and integrity check
+    try:
+        with Image.open(path) as img:
+            img.verify() # verify integrity of the file container
+    except Exception as e:
+        return False, f"Image container is corrupted or invalid: {e}"
+
+    # Re-open because verify() makes the file handle unusable
+    try:
+        with Image.open(path) as img:
+            w, h = img.size
+            
+            # 2. Resolution check
+            if w < min_width or h < min_height:
+                return False, f"Resolution too low ({w}x{h}). Minimum required is {min_width}x{min_height}."
+                
+            # 3. Aspect Ratio check
+            aspect = w / h
+            # Normal landscape should be around 1.33 to 1.78. 
+            # Reject vertical portrait (aspect < 0.75) and extreme panoramas (aspect > 2.5)
+            if aspect < 0.75:
+                return False, f"Asset is vertical / portrait (aspect ratio: {aspect:.2f}). 16:9 crop will lose context."
+            if aspect > 2.5:
+                return False, f"Asset is too wide / panoramic (aspect ratio: {aspect:.2f}). 16:9 crop will look extremely stretched or cropped."
+
+            # 4. Blank screen / Solid color check
+            # Convert to grayscale to simplify calculation
+            gray_img = img.convert("L")
+            arr = np.array(gray_img, dtype=np.float32)
+            std_dev = np.std(arr)
+            # A standard deviation < 5.0 indicates almost zero contrast (solid color / blank / broken download)
+            if std_dev < 5.0:
+                return False, f"Blank or solid color image detected (standard deviation: {std_dev:.2f})."
+
+            # 5. Watermark / logo detection
+            detected = detect_watermarks(img_path)
+            if detected:
+                return False, f"Watermark or logo pattern detected in regions: {detected}."
+
+    except Exception as e:
+        return False, f"Unexpected error during visual analysis: {e}"
+
+    return True, "Pass"
+
+def detect_watermarks(img_path):
+    """
+    Scan the corners and central-right/bottom-center of the image and return a list of regions that contain watermarks.
+    """
+    path = Path(img_path)
+    if not path.exists():
+        return []
+        
+    # Check if the filename contains stock/news keywords for adaptive thresholding
+    path_lower = str(path).lower()
+    is_stock_source = any(x in path_lower for x in ["getty", "alamy", "stock", "shutter", "anadolu", "reuters", "exclusive", "refinery"])
+    
+    try:
+        with Image.open(path) as img:
+            w, h = img.size
+            gray_img = img.convert("L")
+            arr = np.array(gray_img, dtype=np.float32)
+            
+            diff_x = np.abs(arr[:, 1:] - arr[:, :-1])
+            diff_y = np.abs(arr[1:, :] - arr[:-1, :])
+            edges = np.zeros_like(arr)
+            edges[:, :-1] += diff_x
+            edges[:-1, :] += diff_y
+            
+            cw = int(w * 0.15)
+            ch = int(h * 0.15)
+            cw = max(cw, 10)
+            ch = max(ch, 10)
+            
+            regions = {
+                "top_left": (0, 0, cw, ch),
+                "top_right": (w-cw, 0, w, ch),
+                "bottom_left": (0, h-ch, cw, h),
+                "bottom_right": (w-cw, h-ch, w, h),
+                "center_right": (int(w * 0.55), int(h * 0.45), int(w * 0.98), int(h * 0.80)),
+                "bottom_center": (int(w * 0.20), int(h * 0.82), int(w * 0.80), h),
+                "center": (int(w * 0.30), int(h * 0.30), int(w * 0.70), int(h * 0.70))
+            }
+            
+            detected = []
+            for name, (x1, y1, x2, y2) in regions.items():
+                region = edges[y1:y2, x1:x2]
+                if region.size == 0:
+                    continue
+                mean_edge = np.mean(region)
+                max_edge = np.max(region)
+                
+                # Corner heuristics (normally low texture, so strict threshold)
+                if name in ["top_left", "top_right", "bottom_left", "bottom_right"]:
+                    if mean_edge > 15.0 and max_edge > 150.0:
+                        detected.append(name)
+                # Central/Bottom heuristics (higher natural texture, adaptive check to avoid false positives)
+                else:
+                    if is_stock_source:
+                        high_contrast_pixels = np.sum(region > 120.0)
+                        # Detect even if the mean edge is diluted in a large region, as long as strong local edges exist
+                        if (mean_edge > 5.0 and max_edge > 80.0 and high_contrast_pixels > 15) or (high_contrast_pixels > 40):
+                            detected.append(name)
+                    else:
+                        if mean_edge > 20.0 and max_edge > 200.0:
+                            high_contrast_pixels = np.sum(region > 200.0)
+                            if high_contrast_pixels > 30:
+                                detected.append(name)
+            return detected
+    except Exception as e:
+        logger.error(f"Error checking watermarks for {img_path}: {e}")
+        return []
+
+def generate_watermark_mask(img_path, output_mask_path, detected_corners=None):
+    """
+    Generate a binary mask where detected watermark pixels are white (255) and dilated.
+    """
+    path = Path(img_path)
+    if not path.exists():
+        return False
+        
+    if detected_corners is None:
+        detected_corners = detect_watermarks(img_path)
+        
+    if not detected_corners:
+        # Create empty mask if no corners detected
+        try:
+            with Image.open(path) as img:
+                mask = Image.new("L", img.size, color=0)
+                mask.save(output_mask_path, "JPEG")
+                return True
+        except Exception as e:
+            logger.error(f"Failed to create empty mask: {e}")
+            return False
+            
+    try:
+        with Image.open(path) as img:
+            w, h = img.size
+            gray_img = img.convert("L")
+            arr = np.array(gray_img, dtype=np.float32)
+            
+            # Recompute edges to find watermark pixels
+            diff_x = np.abs(arr[:, 1:] - arr[:, :-1])
+            diff_y = np.abs(arr[1:, :] - arr[:-1, :])
+            edges = np.zeros_like(arr)
+            edges[:, :-1] += diff_x
+            edges[:-1, :] += diff_y
+            
+            # Create a base black mask
+            mask_arr = np.zeros((h, w), dtype=np.uint8)
+            
+            cw = int(w * 0.15)
+            ch = int(h * 0.15)
+            cw = max(cw, 10)
+            ch = max(ch, 10)
+            
+            regions = {
+                "top_left": (0, 0, cw, ch),
+                "top_right": (w-cw, 0, w, ch),
+                "bottom_left": (0, h-ch, cw, h),
+                "bottom_right": (w-cw, h-ch, w, h),
+                "center_right": (int(w * 0.55), int(h * 0.45), int(w * 0.98), int(h * 0.80)),
+                "bottom_center": (int(w * 0.20), int(h * 0.82), int(w * 0.80), h),
+                "center": (int(w * 0.30), int(h * 0.30), int(w * 0.70), int(h * 0.70))
+            }
+            
+            for name in detected_corners:
+                if name not in regions:
+                    continue
+                x1, y1, x2, y2 = regions[name]
+                # In the region, pixels with edge strength > 15 are likely watermark strokes
+                region_edges = edges[y1:y2, x1:x2]
+                mask_region = np.zeros_like(region_edges, dtype=np.uint8)
+                mask_region[region_edges > 15.0] = 255
+                mask_arr[y1:y2, x1:x2] = mask_region
+                
+            mask_img = Image.fromarray(mask_arr)
+            
+            # Dilate the mask using PIL's MaxFilter to cover surrounding pixels of the watermark text/logo
+            dilated_mask = mask_img.filter(ImageFilter.MaxFilter(size=9))
+            
+            # Save mask
+            dilated_mask.save(output_mask_path, "JPEG")
+            return True
+            
+    except Exception as e:
+        logger.error(f"Error generating mask for {img_path}: {e}")
+        return False
+
+def remove_watermark_with_lama(img_path, output_path=None):
+    """
+    Detect, mask, and inpaint watermark/logo out of the image using LaMa.
+    Then re-validate the result.
+    Returns: (bool, str) -> (success, reason)
+    """
+    path = Path(img_path)
+    if not path.exists():
+        return False, "File does not exist"
+        
+    if output_path is None:
+        output_path = img_path
+        
+    detected_corners = detect_watermarks(img_path)
+    if not detected_corners:
+        return True, "No watermark detected"
+        
+    logger.info(f"Watermark detected in corners {detected_corners} of {path.name}. Initiating removal...")
+    
+    # Paths for temporary mask and temporary output
+    temp_mask_path = path.parent / f".temp_mask_{path.stem}.jpg"
+    temp_out_path = path.parent / f".temp_out_{path.stem}.jpg"
+    
+    try:
+        # 1. Generate mask
+        if not generate_watermark_mask(path, temp_mask_path, detected_corners):
+            return False, "Failed to generate watermark mask"
+            
+        # 2. Run LaMa inpainting
+        lama_script = r"C:\Roaming\.agents\skills\lama-inpainting\lama_inpaint.py"
+        if not os.path.exists(lama_script):
+            return False, f"LaMa script not found at {lama_script}"
+            
+        cmd = [
+            sys.executable,
+            lama_script,
+            "--image", str(path),
+            "--mask", str(temp_mask_path),
+            "--output", str(temp_out_path),
+            "--device", "cpu"
+        ]
+        
+        logger.info(f"Running LaMa inpainting: {' '.join(cmd)}")
+        res = subprocess.run(cmd, capture_output=True, text=True, timeout=90)
+        
+        if res.returncode != 0:
+            return False, f"LaMa inpainting script failed: {res.stderr.strip()}"
+            
+        if not temp_out_path.exists():
+            return False, "LaMa script returned 0 but output file was not created"
+            
+        # 3. Re-validate the output image
+        ok, reason = validate_image_asset(temp_out_path)
+        if not ok:
+            # If it failed because of watermark again, it means the removal failed or was incomplete
+            return False, f"Watermark removal validation failed: {reason}"
+            
+        # 4. Overwrite/Save to target destination
+        out_path = Path(output_path)
+        if out_path.exists():
+            out_path.unlink()
+        temp_out_path.rename(out_path)
+        
+        logger.info(f"Watermark successfully removed and verified for {path.name}")
+        return True, "Pass"
+        
+    except subprocess.TimeoutExpired:
+        return False, "LaMa inpainting execution timed out"
+    except Exception as e:
+        logger.error(f"Unexpected error during watermark removal: {e}")
+        return False, f"Unexpected error during removal: {e}"
+    finally:
+        # Cleanup temp files
+        if temp_mask_path.exists():
+            temp_mask_path.unlink(missing_ok=True)
+        if temp_out_path.exists():
+            temp_out_path.unlink(missing_ok=True)
+
+def validate_video_asset(video_path):
+    """
+    Perform validation of a B-roll video file (Ken-Burns clip).
+    Checks: file existence, size, and container integrity using ffprobe.
+    Returns: (bool, str) -> (is_valid, reason)
+    """
+    path = Path(video_path)
+    if not path.exists():
+        return False, "File does not exist"
+        
+    try:
+        size = path.stat().st_size
+        if size < 10240: # 10KB minimum
+            return False, f"File size is too small ({size} bytes). Likely a failed render."
+    except Exception as e:
+        return False, f"Failed to get file stats: {e}"
+
+    # Use ffprobe to verify video integrity
+    ffprobe = os.environ.get("VIDEO_AGENT_FFPROBE", "ffprobe")
+    cmd = [
+        ffprobe, "-v", "error",
+        "-show_entries", "format=duration,size:stream=codec_type",
+        "-of", "json",
+        str(path)
+    ]
+    try:
+        res = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+        if res.returncode != 0:
+            return False, f"ffprobe container validation failed: {res.stderr.strip()}"
+            
+        data = json.loads(res.stdout)
+        
+        # Check duration
+        duration_str = data.get("format", {}).get("duration")
+        if not duration_str:
+            return False, "No duration found in video container metadata"
+        duration = float(duration_str)
+        if duration <= 0:
+            return False, f"Invalid video duration: {duration}s"
+            
+        # Check for video stream
+        streams = data.get("streams", [])
+        has_video_stream = any(s.get("codec_type") == "video" for s in streams)
+        if not has_video_stream:
+            return False, "No video stream found in the container"
+            
+    except subprocess.TimeoutExpired:
+        return False, "ffprobe container validation timed out"
+    except Exception as e:
+        return False, f"Failed to validate video container via ffprobe: {e}"
+        
+    return True, "Pass"
+
+def scan_and_cleanup_broll_database(db_path, dry_run=False):
+    """
+    Scan the local SQLite DB, validate all registered B-roll video and source image assets,
+    delete failed ones, and clean up database records.
+    """
+    if not os.path.exists(db_path):
+        logger.error(f"Database {db_path} does not exist.")
+        return {"error": "DB not found"}
+
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    
+    try:
+        cursor.execute("SELECT id, title, query, image_url, local_path FROM broll_assets")
+        rows = cursor.fetchall()
+    except Exception as e:
+        logger.error(f"Failed to query database: {e}")
+        conn.close()
+        return {"error": str(e)}
+        
+    logger.info(f"Scanning {len(rows)} registered B-roll records...")
+    
+    scanned = 0
+    passed = 0
+    failed_video = 0
+    failed_image = 0
+    missing_files = 0
+    deleted_records = []
+    
+    # We will track which images are associated with which videos to locate the source images.
+    # The source images are typically in C:\ComfyUI\Broll\images with a name derived from URL hash and title.
+    # The database local_path points to the video (.mp4).
+    for row_id, title, query, url, local_path_str in rows:
+        scanned += 1
+        
+        if not local_path_str:
+            logger.warning(f"Record ID {row_id} has empty local_path. Removing record.")
+            deleted_records.append(row_id)
+            missing_files += 1
+            continue
+            
+        video_path = Path(local_path_str)
+        
+        # Locate corresponding source image in ComfyUI\Broll\images
+        # The filename of the video is [hash]_[title].mp4 and the image is [hash]_[title].jpg
+        video_name = video_path.name
+        img_name = video_name.replace(".mp4", ".jpg")
+        img_path = Path(r"C:\ComfyUI\Broll\images") / img_name
+        
+        # 1. Check file existence
+        if not video_path.exists():
+            logger.warning(f"Video file missing: {video_path}. Removing record.")
+            deleted_records.append(row_id)
+            missing_files += 1
+            # Clean up image if it exists
+            if img_path.exists() and not dry_run:
+                img_path.unlink()
+            continue
+            
+        # 2. Validate Video
+        vid_ok, vid_reason = validate_video_asset(video_path)
+        if not vid_ok:
+            logger.warning(f"Video {video_name} failed Quality Gate: {vid_reason}")
+            failed_video += 1
+            deleted_records.append(row_id)
+            if not dry_run:
+                video_path.unlink(missing_ok=True)
+                if img_path.exists():
+                    img_path.unlink(missing_ok=True)
+            continue
+            
+        # 3. Validate Source Image (if exists)
+        if img_path.exists():
+            img_ok, img_reason = validate_image_asset(img_path)
+            if not img_ok:
+                # If failed because of watermark, try to remove it
+                if "Watermark" in img_reason:
+                    logger.info(f"Source image {img_name} has watermark. Attempting automatic removal...")
+                    if not dry_run:
+                        removed, remove_reason = remove_watermark_with_lama(img_path)
+                        if removed:
+                            # Re-generate video because the old video has the watermark
+                            logger.info(f"Watermark removed from image. Regenerating video clip {video_name}...")
+                            try:
+                                from collect_broll_agent import generate_ken_burns_clip
+                                # Delete old video
+                                video_path.unlink(missing_ok=True)
+                                if generate_ken_burns_clip(img_path, video_path):
+                                    logger.info(f"Video regenerated successfully: {video_name}")
+                                    img_ok = True
+                                else:
+                                    logger.error(f"Failed to regenerate video {video_name} from restored image")
+                            except Exception as ex:
+                                logger.error(f"Error during video regeneration: {ex}")
+                        else:
+                            logger.warning(f"Watermark removal failed for {img_name}: {remove_reason}")
+                            
+                if not img_ok:
+                    logger.warning(f"Source image {img_name} failed Quality Gate: {img_reason}")
+                    failed_image += 1
+                    deleted_records.append(row_id)
+                    if not dry_run:
+                        video_path.unlink(missing_ok=True)
+                        img_path.unlink(missing_ok=True)
+                    continue
+        else:
+            # If the source image is missing but the video exists and is valid, we let it pass
+            # because the video is already compiled and good to go.
+            pass
+            
+        passed += 1
+
+    # Apply database deletions
+    if deleted_records and not dry_run:
+        logger.info(f"Removing {len(deleted_records)} failed/missing records from database...")
+        try:
+            # SQLite supports up to 999 variables, chunk if needed
+            for i in range(0, len(deleted_records), 500):
+                chunk = deleted_records[i:i+500]
+                cursor.execute(f"DELETE FROM broll_assets WHERE id IN ({','.join('?' for _ in chunk)})", chunk)
+            conn.commit()
+        except Exception as e:
+            logger.error(f"Failed to delete records from DB: {e}")
+            
+    conn.close()
+    
+    summary = {
+        "scanned": scanned,
+        "passed": passed,
+        "failed_video": failed_video,
+        "failed_image": failed_image,
+        "missing_files": missing_files,
+        "deleted_records_count": len(deleted_records)
+    }
+    
+    logger.info(f"Cleanup finished. Summary: {summary}")
+    return summary
+
+def main():
+    parser = argparse.ArgumentParser(description="B-roll Quality Gate Scanner & Cleaner")
+    parser.add_argument("--db-path", type=str, default=r"C:\ComfyUI\Articles\broll_assets.db", help="Path to SQLite DB")
+    parser.add_argument("--cleanup", action="store_true", help="Perform database scanning and cleanup.")
+    parser.add_argument("--dry-run", action="store_true", help="Scan only, do not delete files or DB records.")
+    parser.add_argument("--image", type=str, help="Validate a single image file.")
+    parser.add_argument("--remove-watermark", action="store_true", help="Remove watermark from single image (must specify --image)")
+    parser.add_argument("--video", type=str, help="Validate a single video file.")
+    args = parser.parse_args()
+
+    if args.image:
+        if args.remove_watermark:
+            ok, reason = remove_watermark_with_lama(args.image)
+            print(f"Watermark removal for {args.image}: {'PASS' if ok else 'FAIL'}")
+            if not ok:
+                print(f"Reason: {reason}")
+            sys.exit(0 if ok else 1)
+        else:
+            ok, reason = validate_image_asset(args.image)
+            print(f"Image validation for {args.image}: {'PASS' if ok else 'FAIL'}")
+            if not ok:
+                print(f"Reason: {reason}")
+            sys.exit(0 if ok else 1)
+        
+    if args.video:
+        ok, reason = validate_video_asset(args.video)
+        print(f"Video validation for {args.video}: {'PASS' if ok else 'FAIL'}")
+        if not ok:
+            print(f"Reason: {reason}")
+        sys.exit(0 if ok else 1)
+
+    if args.cleanup:
+        summary = scan_and_cleanup_broll_database(args.db_path, dry_run=args.dry_run)
+        print("\n=== Cleanup Scan Report ===")
+        print(json.dumps(summary, indent=4))
+        sys.exit(0)
+
+    parser.print_help()
+
+if __name__ == "__main__":
+    main()

quality_gate_newsvideo.py

@@ -0,0 +1,414 @@
+import os
+import sys
+import json
+import re
+import shutil
+import subprocess
+import logging
+import argparse
+from pathlib import Path
+from datetime import datetime
+from fractions import Fraction
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("quality_gate_newsvideo")
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+WORKSPACE_DIR = r"C:\Users\eggof\Desktop\Android Times"
+NEWSVIDEO_DIR = r"C:\Android Times\newsvideo"
+
+YT_MAX_FILE_SIZE_BYTES = 256 * 1024 * 1024 * 1024
+YT_MAX_DURATION_SECONDS = 12 * 60 * 60
+YT_MIN_FILE_SIZE_BYTES = 10240
+YT_ACCEPTED_VIDEO_CODECS = {"h264", "hevc", "h265", "vp9", "av1", "vp8", "mpeg4", "mpeg2video", "mpeg1video", "prores", "dnxhd"}
+YT_PREFERRED_VIDEO_CODEC = "h264"
+YT_ACCEPTED_AUDIO_CODECS = {"aac", "mp3", "vorbis", "opus", "pcm_s16le", "pcm_s24le", "flac", "ac3", "eac3"}
+YT_PREFERRED_AUDIO_CODEC = "aac"
+YT_STANDARD_FRAME_RATES = {24, 25, 30, 48, 50, 60}
+
+def extract_main_word(title):
+    title = title.replace('_', ' ').replace(',', ' ')
+    is_ja = any(ord(char) > 0x3000 for char in title)
+    cleaned = re.sub(r'\s*-\s*[^-\s]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', title, flags=re.IGNORECASE)
+    cleaned = re.sub(r'_[^_]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', cleaned, flags=re.IGNORECASE)
+    blacklisted = ["ai", "artificial intelligence", "人工知能", "生成ai", "生成系ai"]
+    def is_valid(word):
+        if not word:
+            return False
+        return word.strip().lower() not in blacklisted
+    
+    quotes_ja = re.findall(r'「([^」]+)」', cleaned)
+    for q in quotes_ja:
+        if is_valid(q):
+            return q
+    quotes_en = re.findall(r'["\']([^"\']+)["\']', cleaned)
+    for q in quotes_en:
+        if len(q) < 25 and is_valid(q):
+            return q
+        
+    known_keywords = [
+        "OpenAI", "Google", "Amazon", "Bezos", "Trump", "Anthropic", "Microsoft", "Apple", "Nvidia", "Meta", "Musk",
+        "大谷", "オオタニ", "大谷翔平", "小田急", "ソニー", "ソフトバンク", "ChatGPT", "Claude", "IOWN", "サカナAI"
+    ]
+    for kw in known_keywords:
+        if kw.lower() in cleaned.lower() and is_valid(kw):
+            m = re.search(re.escape(kw), cleaned, re.IGNORECASE)
+            if m:
+                return m.group(0)
+    if is_ja:
+        katakana = re.findall(r'[\u30a1-\u30fc]{2,}', cleaned)
+        for k in katakana:
+            if is_valid(k):
+                return k
+        kanji = re.findall(r'[\u4e00-\u9fff]{2,}', cleaned)
+        for k in kanji:
+            if k not in ["米国", "日本", "市場", "世界", "政府", "計画", "導入"] and is_valid(k):
+                return k
+        if kanji:
+            for k in kanji:
+                if is_valid(k):
+                    return k
+        alpha = re.findall(r'[a-zA-Z0-9]{2,}', cleaned)
+        for a in alpha:
+            if is_valid(a):
+                return a
+    else:
+        words = re.findall(r'\b[A-Z][a-zA-Z0-9]*\b', cleaned)
+        if words:
+            for w in words:
+                if w.lower() not in ["a", "an", "the", "in", "on", "at", "for", "to", "of", "and", "or", "but", "with", "by", "is", "are", "was", "were"] and is_valid(w):
+                    return w
+            for w in words:
+                if is_valid(w):
+                    return w
+    first_token = re.search(r'\w+', cleaned)
+    if first_token and is_valid(first_token.group(0)):
+        return first_token.group(0)
+    return ""
+
+def safe_filename(name, max_len=40):
+    main_word = extract_main_word(name).strip()
+    cleaned = name.replace('_', ' ').replace(',', ' ')
+    cleaned = re.sub(r'[\\/*?:"<>|\'`\(\)\[\]]', ' ', cleaned)
+    cleaned = re.sub(r'\s+', ' ', cleaned).strip()
+    if main_word:
+        if cleaned.lower().startswith(main_word.lower()):
+            final_title = cleaned
+        else:
+            final_title = f"{main_word} {cleaned}"
+    else:
+        final_title = cleaned
+    final_title = re.sub(r'\s+', ' ', final_title).strip()
+    if len(final_title) > max_len:
+        final_title = final_title[:max_len].strip()
+        final_title = re.sub(r'[\s\.,\-_\+!@#\$%^&\*]+$', '', final_title)
+    return final_title
+
+def _parse_frame_rate(r_frame_rate_str):
+    if not r_frame_rate_str:
+        return None
+    try:
+        if '/' in r_frame_rate_str:
+            num, den = r_frame_rate_str.split('/')
+            den = int(den)
+            if den == 0:
+                return None
+            return float(int(num)) / den
+        return float(r_frame_rate_str)
+    except (ValueError, ZeroDivisionError):
+        return None
+
+def validate_video(video_path):
+    path = Path(video_path)
+    details = {}
+    warnings = []
+    
+    if not path.exists():
+        return False, "File does not exist", details, warnings
+    
+    try:
+        file_size = path.stat().st_size
+        details["file_size_bytes"] = file_size
+        details["file_size_mb"] = round(file_size / (1024 * 1024), 2)
+    except Exception as e:
+        return False, f"Failed to get file stats: {e}", details, warnings
+    
+    if file_size < YT_MIN_FILE_SIZE_BYTES:
+        return False, f"File size too small ({file_size} bytes). Likely a failed render.", details, warnings
+    
+    if file_size > YT_MAX_FILE_SIZE_BYTES:
+        return False, f"File size ({details['file_size_mb']} MB) exceeds maximum of 256 GB", details, warnings
+    
+    ffprobe = os.environ.get("VIDEO_AGENT_FFPROBE", "ffprobe")
+    cmd = [
+        ffprobe, "-v", "error",
+        "-show_entries",
+        "format=duration,size,bit_rate"
+        ":stream=codec_type,codec_name,width,height,r_frame_rate,field_order,sample_rate,channels,bit_rate",
+        "-of", "json",
+        str(path)
+    ]
+    try:
+        res = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+        if res.returncode != 0:
+            return False, f"ffprobe validation failed: {res.stderr.strip()}", details, warnings
+        data = json.loads(res.stdout)
+    except subprocess.TimeoutExpired:
+        return False, "ffprobe validation timed out (30s)", details, warnings
+    except json.JSONDecodeError as e:
+        return False, f"ffprobe returned invalid JSON: {e}", details, warnings
+    except Exception as e:
+        return False, f"Failed to run ffprobe: {e}", details, warnings
+    
+    fmt = data.get("format", {})
+    streams = data.get("streams", [])
+    
+    duration_str = fmt.get("duration")
+    if not duration_str:
+        return False, "No duration found in container metadata", details, warnings
+    try:
+        duration = float(duration_str)
+    except ValueError:
+        return False, f"Invalid duration value: {duration_str}", details, warnings
+    
+    details["duration_s"] = round(duration, 2)
+    
+    if duration <= 0:
+        return False, f"Invalid video duration: {duration}s", details, warnings
+    if duration > YT_MAX_DURATION_SECONDS:
+        return False, f"Duration ({duration/3600:.1f}h) exceeds maximum of 12 hours", details, warnings
+    
+    video_streams = [s for s in streams if s.get("codec_type") == "video"]
+    if not video_streams:
+        return False, "No video stream found", details, warnings
+    
+    vs = video_streams[0]
+    
+    video_codec = vs.get("codec_name", "unknown")
+    details["video_codec"] = video_codec
+    if video_codec not in YT_ACCEPTED_VIDEO_CODECS:
+        warnings.append(f"Video codec '{video_codec}' may not be accepted")
+    
+    width = vs.get("width")
+    height = vs.get("height")
+    if width and height:
+        details["resolution"] = f"{width}x{height}"
+    
+    r_frame_rate = vs.get("r_frame_rate")
+    fps = _parse_frame_rate(r_frame_rate)
+    if fps:
+        details["fps"] = round(fps, 2)
+    
+    field_order = vs.get("field_order", "")
+    details["scan_type"] = field_order if field_order else "progressive"
+    
+    audio_streams = [s for s in streams if s.get("codec_type") == "audio"]
+    if not audio_streams:
+        return False, "No audio stream found", details, warnings
+    
+    aus = audio_streams[0]
+    
+    audio_codec = aus.get("codec_name", "unknown")
+    details["audio_codec"] = audio_codec
+    
+    sample_rate = aus.get("sample_rate")
+    if sample_rate:
+        details["audio_sample_rate"] = int(sample_rate)
+    
+    channels = aus.get("channels")
+    if channels:
+        details["audio_channels"] = channels
+    
+    bitrate_str = fmt.get("bit_rate")
+    if bitrate_str:
+        try:
+            bitrate_kbps = int(bitrate_str) // 1000
+            details["bitrate_kbps"] = bitrate_kbps
+        except (ValueError, TypeError):
+            pass
+    
+    return True, "Pass", details, warnings
+
+def evaluate_newsvideo_ready(article_dir, force=False, dry_run=False):
+    if not os.path.exists(article_dir):
+        logger.warning(f"Directory {article_dir} does not exist.")
+        return "REJECTED"
+
+    result_path = os.path.join(article_dir, "evaluation_result.json")
+    if not os.path.exists(result_path):
+        return None
+
+    try:
+        with open(result_path, 'r', encoding='utf-8') as f:
+            results = json.load(f)
+    except Exception as e:
+        logger.error(f"Failed to read evaluation result from {result_path}: {e}")
+        return None
+
+    current_status = results.get("status", "")
+    if not force and current_status in ["READY_FOR_NEWSVIDEO", "YOUTUBE_READY"]:
+        return current_status
+        
+    if current_status not in ["READY_FOR_VIDEO", "READY_FOR_NEWSVIDEO", "NEWSVIDEO_GATE_FAILED", "YOUTUBE_GATE_FAILED", "YOUTUBE_READY"]:
+        return None
+
+    safe_name = safe_filename(os.path.basename(article_dir))
+    sizes = ["short", "middle", "long"]
+    
+    # Check if videos actually exist before processing this gate
+    # If videos don't exist yet, it's likely they are still being generated, so skip for now.
+    videos_exist = True
+    for size in sizes:
+        video_file = f"{safe_name}_{size}.mp4"
+        video_path = os.path.join(article_dir, video_file)
+        if not os.path.exists(video_path):
+            video_path = os.path.join(NEWSVIDEO_DIR, video_file)
+        if not os.path.exists(video_path):
+            videos_exist = False
+            break
+
+    if not videos_exist:
+        # Videos are not all present, assume generation is pending. Do not fail the gate yet.
+        return None
+
+    logger.info(f"Evaluating NewsVideo Gate for: {os.path.basename(article_dir)}")
+    
+    if "checks" not in results:
+        results["checks"] = {}
+        
+    results["checks"]["newsvideo_gate"] = {
+        "timestamp": datetime.now().isoformat(),
+        "status": "PENDING",
+        "video": {"status": "PENDING", "reason": "", "details": {}},
+        "warnings": []
+    }
+    
+    if "reject_reasons" not in results:
+        results["reject_reasons"] = []
+        
+    results["reject_reasons"] = [r for r in results["reject_reasons"] if not r.startswith("[NEWSVIDEO_GATE]")]
+
+    all_warnings = []
+    video_failures = []
+    video_details_all = {}
+    
+    for size in sizes:
+        video_file = f"{safe_name}_{size}.mp4"
+        video_path = os.path.join(article_dir, video_file)
+        if not os.path.exists(video_path):
+            video_path = os.path.join(NEWSVIDEO_DIR, video_file)
+        ok, reason, details, warns = validate_video(video_path)
+        video_details_all[size] = details
+        if not ok:
+            video_failures.append(f"{size}: {reason}")
+        for w in warns:
+            all_warnings.append(f"{size} video: {w}")
+            
+    if video_failures:
+        results["checks"]["newsvideo_gate"]["video"] = {
+            "status": "FAIL",
+            "reason": "; ".join(video_failures),
+            "details": video_details_all
+        }
+    else:
+        results["checks"]["newsvideo_gate"]["video"] = {
+            "status": "PASS",
+            "reason": "All sizes (short, middle, long) videos pass requirements",
+            "details": video_details_all
+        }
+
+    results["checks"]["newsvideo_gate"]["warnings"] = all_warnings
+
+    gate_ok = True
+    gate_reasons = []
+    
+    sub_status = results["checks"]["newsvideo_gate"]["video"]["status"]
+    sub_reason = results["checks"]["newsvideo_gate"]["video"]["reason"]
+    if sub_status == "FAIL":
+        gate_ok = False
+        gate_reasons.append(f"[NEWSVIDEO_GATE] VIDEO FAIL: {sub_reason}")
+
+    if gate_ok:
+        results["checks"]["newsvideo_gate"]["status"] = "PASS"
+        results["status"] = "READY_FOR_NEWSVIDEO"
+        warn_summary = f" ({len(all_warnings)} warnings)" if all_warnings else ""
+        logger.info(f"  -> Final Status: READY_FOR_NEWSVIDEO{warn_summary}")
+    else:
+        results["checks"]["newsvideo_gate"]["status"] = "FAIL"
+        results["status"] = "NEWSVIDEO_GATE_FAILED"
+        results["reject_reasons"].extend(gate_reasons)
+        logger.warning(f"  -> Final Status: NEWSVIDEO_GATE_FAILED (Reasons: {gate_reasons})")
+
+    if not dry_run:
+        try:
+            with open(result_path, 'w', encoding='utf-8') as f:
+                json.dump(results, f, indent=4, ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"Failed to save evaluation result to {result_path}: {e}")
+    else:
+        logger.info(f"[DRY-RUN] Would save evaluation result to {result_path}")
+
+    return results["status"]
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="NewsVideo Ready Quality Gate — validates output news videos."
+    )
+    parser.add_argument("--locale", type=str, default=None, help="Locale to evaluate (default: all)")
+    parser.add_argument("--category", type=str, default=None, help="Category to evaluate")
+    parser.add_argument("--dry-run", action="store_true", help="Evaluate only, do not save status")
+    parser.add_argument("--force", action="store_true", help="Force evaluation even if already READY_FOR_NEWSVIDEO")
+    args = parser.parse_args()
+
+    locales = [args.locale] if args.locale else ["en-US", "en-EU", "ja-JP", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]
+    
+    article_dirs = []
+    for locale in locales:
+        locale_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(locale_path) or not os.path.isdir(locale_path):
+            continue
+        try:
+            categories = [args.category] if args.category else os.listdir(locale_path)
+        except OSError as e:
+            logger.error(f"Error listing categories in {locale_path}: {e}")
+            continue
+            
+        for category in categories:
+            cat_path = os.path.join(locale_path, category)
+            if not os.path.isdir(cat_path) or category == "__pycache__":
+                continue
+            try:
+                articles = os.listdir(cat_path)
+            except OSError:
+                continue
+            for article in articles:
+                article_dir = os.path.join(cat_path, article)
+                if os.path.isdir(article_dir) and article not in ["images", "sources", "__pycache__"]:
+                    article_dirs.append(article_dir)
+
+    if not article_dirs:
+        logger.info("No articles found to evaluate.")
+        return
+
+    processed_count = 0
+    passed_count = 0
+    failed_count = 0
+    
+    for idx, article_dir in enumerate(article_dirs):
+        status = evaluate_newsvideo_ready(article_dir, force=args.force, dry_run=args.dry_run)
+        if status:
+            processed_count += 1
+            if status == "READY_FOR_NEWSVIDEO":
+                passed_count += 1
+            elif status == "NEWSVIDEO_GATE_FAILED":
+                failed_count += 1
+
+    logger.info(f"Evaluation complete. Processed {processed_count} relevant articles.")
+    logger.info(f"Passed: {passed_count}, Failed: {failed_count}")
+
+if __name__ == "__main__":
+    main()

quality_gate_youtube.py

@@ -0,0 +1,830 @@
+import os
+import sys
+import json
+import re
+import shutil
+import subprocess
+import logging
+import argparse
+from pathlib import Path
+from datetime import datetime
+from PIL import Image
+from fractions import Fraction
+
+# Reconfigure stdout/stderr to utf-8 to avoid encoding issues on Windows
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+# Logging setup
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("quality_gate_youtube")
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+WORKSPACE_DIR = r"C:\Users\eggof\Desktop\Android Times"
+YOUTUBE_DIR = os.path.join(WORKSPACE_DIR, "Youtube")
+
+# ============================================================================
+# YouTube Official Specifications (from YouTube Data API v3 documentation
+# and https://support.google.com/youtube/answer/1722171)
+# ============================================================================
+
+# Maximum file size: 256 GB
+YT_MAX_FILE_SIZE_BYTES = 256 * 1024 * 1024 * 1024  # 256 GB
+
+# Maximum duration: 12 hours (43200 seconds)
+YT_MAX_DURATION_SECONDS = 12 * 60 * 60  # 43200s
+
+# Minimum file size threshold for valid renders
+YT_MIN_FILE_SIZE_BYTES = 10240  # 10 KB
+
+# Accepted video codecs (YouTube re-encodes all uploads; H.264 preferred input)
+YT_ACCEPTED_VIDEO_CODECS = {"h264", "hevc", "h265", "vp9", "av1", "vp8", "mpeg4", "mpeg2video", "mpeg1video", "prores", "dnxhd"}
+YT_PREFERRED_VIDEO_CODEC = "h264"
+
+# Accepted audio codecs (AAC-LC preferred at 48kHz, 192kbps+)
+YT_ACCEPTED_AUDIO_CODECS = {"aac", "mp3", "vorbis", "opus", "pcm_s16le", "pcm_s24le", "flac", "ac3", "eac3"}
+YT_PREFERRED_AUDIO_CODEC = "aac"
+
+# Standard frame rates accepted by YouTube
+YT_STANDARD_FRAME_RATES = {24, 25, 30, 48, 50, 60}
+
+# YouTube recommended bitrates for SDR H.264 (kbps), keyed by vertical resolution
+# Values are for standard frame rate (24/25/30); high frame rate values are ~1.5x
+YT_RECOMMENDED_BITRATES_KBPS = {
+    2160: 35000,  # 4K: 35-45 Mbps
+    1440: 16000,  # 2K: 16 Mbps
+    1080: 8000,   # 1080p: 8 Mbps
+    720:  5000,   # 720p: 5 Mbps
+    480:  2500,   # 480p: 2.5 Mbps
+    360:  1000,   # 360p: 1 Mbps
+}
+
+# Thumbnail specifications
+YT_THUMB_MAX_SIZE_BYTES = 2 * 1024 * 1024  # 2 MB
+YT_THUMB_RECOMMENDED_WIDTH = 1280
+YT_THUMB_RECOMMENDED_HEIGHT = 720
+YT_THUMB_MIN_WIDTH = 640
+YT_THUMB_ACCEPTED_FORMATS = {"JPEG", "PNG", "GIF", "BMP"}
+
+# Metadata character limits
+YT_TITLE_MAX_CHARS = 100
+YT_DESCRIPTION_MAX_CHARS = 5000
+YT_TAGS_MAX_CHARS = 500
+YT_BANNED_CHARS = {'<', '>'}
+
+
+# ============================================================================
+# Utility functions
+# ============================================================================
+
+def extract_main_word(title):
+    title = title.replace('_', ' ').replace(',', ' ')
+    is_ja = any(ord(char) > 0x3000 for char in title)
+    cleaned = re.sub(r'\s*-\s*[^-\s]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', title, flags=re.IGNORECASE)
+    cleaned = re.sub(r'_[^_]+(?:ニュース|新聞|オンライン|net|jp|com|JAPAN|Jpn|DIG|WSJ| Forbes|産経|共同|時事|読売|朝日|毎日|毎日新聞|株探|かぶたん|note|AFPBB|Gizmodo|MONOist|Impress|Real Sound|デイリー|西日本|沖縄|神戸|下野|福島|東奥|愛媛|福井|佐賀)\s*$', '', cleaned, flags=re.IGNORECASE)
+    blacklisted = ["ai", "artificial intelligence", "人工知能", "生成ai", "生成系ai"]
+    def is_valid(word):
+        if not word:
+            return False
+        return word.strip().lower() not in blacklisted
+    
+    quotes_ja = re.findall(r'「([^」]+)」', cleaned)
+    for q in quotes_ja:
+        if is_valid(q):
+            return q
+    quotes_en = re.findall(r'["\']([^"\']+)["\']', cleaned)
+    for q in quotes_en:
+        if len(q) < 25 and is_valid(q):
+            return q
+        
+    known_keywords = [
+        "OpenAI", "Google", "Amazon", "Bezos", "Trump", "Anthropic", "Microsoft", "Apple", "Nvidia", "Meta", "Musk",
+        "大谷", "オオタニ", "大谷翔平", "小田急", "ソニー", "ソフトバンク", "ChatGPT", "Claude", "IOWN", "サカナAI"
+    ]
+    for kw in known_keywords:
+        if kw.lower() in cleaned.lower() and is_valid(kw):
+            m = re.search(re.escape(kw), cleaned, re.IGNORECASE)
+            if m:
+                return m.group(0)
+    if is_ja:
+        katakana = re.findall(r'[\u30a1-\u30fc]{2,}', cleaned)
+        for k in katakana:
+            if is_valid(k):
+                return k
+        kanji = re.findall(r'[\u4e00-\u9fff]{2,}', cleaned)
+        for k in kanji:
+            if k not in ["米国", "日本", "市場", "世界", "政府", "計画", "導入"] and is_valid(k):
+                return k
+        if kanji:
+            for k in kanji:
+                if is_valid(k):
+                    return k
+        alpha = re.findall(r'[a-zA-Z0-9]{2,}', cleaned)
+        for a in alpha:
+            if is_valid(a):
+                return a
+    else:
+        words = re.findall(r'\b[A-Z][a-zA-Z0-9]*\b', cleaned)
+        if words:
+            for w in words:
+                if w.lower() not in ["a", "an", "the", "in", "on", "at", "for", "to", "of", "and", "or", "but", "with", "by", "is", "are", "was", "were"] and is_valid(w):
+                    return w
+            for w in words:
+                if is_valid(w):
+                    return w
+    first_token = re.search(r'\w+', cleaned)
+    if first_token and is_valid(first_token.group(0)):
+        return first_token.group(0)
+    return ""
+
+def safe_filename(name, max_len=40):
+    main_word = extract_main_word(name).strip()
+    cleaned = name.replace('_', ' ').replace(',', ' ')
+    cleaned = re.sub(r'[\\/*?:"<>|\'`\(\)\[\]]', ' ', cleaned)
+    cleaned = re.sub(r'\s+', ' ', cleaned).strip()
+    if main_word:
+        if cleaned.lower().startswith(main_word.lower()):
+            final_title = cleaned
+        else:
+            final_title = f"{main_word} {cleaned}"
+    else:
+        final_title = cleaned
+    final_title = re.sub(r'\s+', ' ', final_title).strip()
+    if len(final_title) > max_len:
+        final_title = final_title[:max_len].strip()
+        final_title = re.sub(r'[\s\.,\-_\+!@#\$%^&\*]+$', '', final_title)
+    return final_title
+
+
+def _parse_frame_rate(r_frame_rate_str):
+    """Parse ffprobe r_frame_rate string (e.g. '30/1', '30000/1001') into a float."""
+    if not r_frame_rate_str:
+        return None
+    try:
+        if '/' in r_frame_rate_str:
+            num, den = r_frame_rate_str.split('/')
+            den = int(den)
+            if den == 0:
+                return None
+            return float(int(num)) / den
+        return float(r_frame_rate_str)
+    except (ValueError, ZeroDivisionError):
+        return None
+
+
+def _get_recommended_bitrate(height, fps):
+    """Get YouTube recommended minimum bitrate (kbps) for given resolution and frame rate."""
+    # Find the closest matching resolution tier
+    tiers = sorted(YT_RECOMMENDED_BITRATES_KBPS.keys())
+    matched_tier = tiers[0]
+    for tier in tiers:
+        if height >= tier:
+            matched_tier = tier
+    base_bitrate = YT_RECOMMENDED_BITRATES_KBPS[matched_tier]
+    # High frame rate (>30fps) recommended bitrates are ~1.5x
+    if fps and fps > 30:
+        return int(base_bitrate * 1.5)
+    return base_bitrate
+
+
+# ============================================================================
+# Validation functions — based on YouTube Data API v3 official specs
+# ============================================================================
+
+def validate_video(video_path):
+    """
+    Validate a video file against YouTube's official upload requirements.
+    
+    Returns: (passed: bool, reason: str, details: dict, warnings: list[str])
+    
+    Checks based on YouTube Data API v3 and encoding recommendations:
+    - File existence and minimum size
+    - File size <= 256 GB (YouTube maximum)
+    - Container readability (ffprobe)
+    - Video stream present (required)
+    - Audio stream present (required — YouTube rejects video-only uploads)
+    - Duration > 0 and <= 12 hours
+    - Video codec in accepted list (H.264 preferred)
+    - Audio codec in accepted list (AAC-LC preferred)
+    - Frame rate is standard (24/25/30/48/50/60 fps)
+    - Progressive scan (not interlaced)
+    - Bitrate vs YouTube recommended minimums
+    """
+    path = Path(video_path)
+    details = {}
+    warnings = []
+    
+    # --- File existence ---
+    if not path.exists():
+        return False, "File does not exist", details, warnings
+    
+    # --- File size checks ---
+    try:
+        file_size = path.stat().st_size
+        details["file_size_bytes"] = file_size
+        details["file_size_mb"] = round(file_size / (1024 * 1024), 2)
+    except Exception as e:
+        return False, f"Failed to get file stats: {e}", details, warnings
+    
+    if file_size < YT_MIN_FILE_SIZE_BYTES:
+        return False, f"File size too small ({file_size} bytes). Likely a failed render.", details, warnings
+    
+    if file_size > YT_MAX_FILE_SIZE_BYTES:
+        return False, f"File size ({details['file_size_mb']} MB) exceeds YouTube maximum of 256 GB", details, warnings
+    
+    # --- ffprobe deep inspection ---
+    ffprobe = os.environ.get("VIDEO_AGENT_FFPROBE", "ffprobe")
+    cmd = [
+        ffprobe, "-v", "error",
+        "-show_entries",
+        "format=duration,size,bit_rate"
+        ":stream=codec_type,codec_name,width,height,r_frame_rate,field_order,sample_rate,channels,bit_rate",
+        "-of", "json",
+        str(path)
+    ]
+    try:
+        res = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+        if res.returncode != 0:
+            return False, f"ffprobe validation failed: {res.stderr.strip()}", details, warnings
+        data = json.loads(res.stdout)
+    except subprocess.TimeoutExpired:
+        return False, "ffprobe validation timed out (30s)", details, warnings
+    except json.JSONDecodeError as e:
+        return False, f"ffprobe returned invalid JSON: {e}", details, warnings
+    except Exception as e:
+        return False, f"Failed to run ffprobe: {e}", details, warnings
+    
+    fmt = data.get("format", {})
+    streams = data.get("streams", [])
+    
+    # --- Duration check (YouTube max: 12 hours) ---
+    duration_str = fmt.get("duration")
+    if not duration_str:
+        return False, "No duration found in container metadata", details, warnings
+    try:
+        duration = float(duration_str)
+    except ValueError:
+        return False, f"Invalid duration value: {duration_str}", details, warnings
+    
+    details["duration_s"] = round(duration, 2)
+    
+    if duration <= 0:
+        return False, f"Invalid video duration: {duration}s", details, warnings
+    if duration > YT_MAX_DURATION_SECONDS:
+        return False, f"Duration ({duration/3600:.1f}h) exceeds YouTube maximum of 12 hours", details, warnings
+    
+    # --- Video stream check (required) ---
+    video_streams = [s for s in streams if s.get("codec_type") == "video"]
+    if not video_streams:
+        return False, "No video stream found — YouTube requires a video stream", details, warnings
+    
+    vs = video_streams[0]  # Primary video stream
+    
+    # Video codec
+    video_codec = vs.get("codec_name", "unknown")
+    details["video_codec"] = video_codec
+    if video_codec not in YT_ACCEPTED_VIDEO_CODECS:
+        warnings.append(f"Video codec '{video_codec}' may not be accepted by YouTube (preferred: {YT_PREFERRED_VIDEO_CODEC})")
+    elif video_codec != YT_PREFERRED_VIDEO_CODEC:
+        warnings.append(f"Video codec '{video_codec}' is accepted but '{YT_PREFERRED_VIDEO_CODEC}' is preferred by YouTube")
+    
+    # Resolution
+    width = vs.get("width")
+    height = vs.get("height")
+    if width and height:
+        details["resolution"] = f"{width}x{height}"
+        if height < 240:
+            warnings.append(f"Resolution {width}x{height} is very low — minimum practical is 240p")
+    
+    # Frame rate
+    r_frame_rate = vs.get("r_frame_rate")
+    fps = _parse_frame_rate(r_frame_rate)
+    if fps:
+        details["fps"] = round(fps, 2)
+        # Check if close to a standard frame rate
+        closest_std = min(YT_STANDARD_FRAME_RATES, key=lambda x: abs(x - fps))
+        if abs(fps - closest_std) > 1.0:
+            warnings.append(f"Frame rate {fps:.2f} fps is non-standard (YouTube standard: {sorted(YT_STANDARD_FRAME_RATES)})")
+    
+    # Progressive scan check (interlaced is not recommended)
+    field_order = vs.get("field_order", "")
+    if field_order and field_order not in ("progressive", "unknown", ""):
+        warnings.append(f"Video appears interlaced (field_order='{field_order}'). YouTube recommends progressive scan.")
+    details["scan_type"] = field_order if field_order else "progressive"
+    
+    # --- Audio stream check (REQUIRED — YouTube rejects video-only uploads) ---
+    audio_streams = [s for s in streams if s.get("codec_type") == "audio"]
+    if not audio_streams:
+        return False, "No audio stream found — YouTube requires both video AND audio streams", details, warnings
+    
+    aus = audio_streams[0]  # Primary audio stream
+    
+    # Audio codec
+    audio_codec = aus.get("codec_name", "unknown")
+    details["audio_codec"] = audio_codec
+    if audio_codec not in YT_ACCEPTED_AUDIO_CODECS:
+        warnings.append(f"Audio codec '{audio_codec}' may not be accepted by YouTube (preferred: {YT_PREFERRED_AUDIO_CODEC})")
+    elif audio_codec != YT_PREFERRED_AUDIO_CODEC:
+        warnings.append(f"Audio codec '{audio_codec}' is accepted but '{YT_PREFERRED_AUDIO_CODEC}' is preferred")
+    
+    # Audio sample rate (YouTube recommends 48kHz)
+    sample_rate = aus.get("sample_rate")
+    if sample_rate:
+        details["audio_sample_rate"] = int(sample_rate)
+        if int(sample_rate) < 44100:
+            warnings.append(f"Audio sample rate {sample_rate}Hz is low (YouTube recommends 48000Hz)")
+    
+    # Audio channels
+    channels = aus.get("channels")
+    if channels:
+        details["audio_channels"] = channels
+    
+    # --- Overall bitrate check ---
+    bitrate_str = fmt.get("bit_rate")
+    if bitrate_str:
+        try:
+            bitrate_kbps = int(bitrate_str) // 1000
+            details["bitrate_kbps"] = bitrate_kbps
+            if height:
+                recommended = _get_recommended_bitrate(height, fps)
+                details["yt_recommended_bitrate_kbps"] = recommended
+                if bitrate_kbps < recommended * 0.5:
+                    warnings.append(
+                        f"Bitrate {bitrate_kbps} kbps is well below YouTube's recommended "
+                        f"{recommended} kbps for {height}p — may result in poor quality"
+                    )
+        except (ValueError, TypeError):
+            pass
+    
+    # --- Aspect ratio info ---
+    if width and height:
+        gcd_val = Fraction(width, height)
+        details["aspect_ratio"] = f"{gcd_val.numerator}:{gcd_val.denominator}"
+        # Not a FAIL, just informational warning if not 16:9
+        if not (abs(width / height - 16/9) < 0.05):
+            warnings.append(f"Aspect ratio {gcd_val.numerator}:{gcd_val.denominator} is not 16:9 — YouTube may add letterboxing/pillarboxing")
+    
+    return True, "Pass", details, warnings
+
+
+def validate_thumbnail(thumb_path):
+    """
+    Validate a thumbnail image against YouTube's official thumbnail requirements.
+    
+    Returns: (passed: bool, reason: str, details: dict, warnings: list[str])
+    
+    YouTube thumbnail specs (from API docs and support.google.com/youtube/answer/72431):
+    - Dimensions: 1280x720 (recommended), minimum width 640px
+    - File size: <= 2 MB
+    - Formats: JPG, PNG, GIF (non-animated), BMP
+    - Aspect ratio: 16:9
+    """
+    path = Path(thumb_path)
+    details = {}
+    warnings = []
+    
+    if not path.exists():
+        return False, "Thumbnail file not found", details, warnings
+    
+    # --- File size check (YouTube max: 2 MB) ---
+    try:
+        file_size = path.stat().st_size
+        details["file_size_bytes"] = file_size
+        details["file_size_kb"] = round(file_size / 1024, 1)
+    except Exception as e:
+        return False, f"Failed to get thumbnail file stats: {e}", details, warnings
+    
+    if file_size > YT_THUMB_MAX_SIZE_BYTES:
+        return False, f"Thumbnail file size ({details['file_size_kb']} KB) exceeds YouTube maximum of 2 MB", details, warnings
+    
+    # --- Image validation ---
+    try:
+        with Image.open(path) as img:
+            width, height = img.size
+            img_format = img.format  # e.g. "JPEG", "PNG", "GIF", "BMP"
+            details["width"] = width
+            details["height"] = height
+            details["format"] = img_format
+            
+            # Format check
+            if img_format not in YT_THUMB_ACCEPTED_FORMATS:
+                return False, f"Thumbnail format '{img_format}' is not accepted by YouTube (accepted: {', '.join(YT_THUMB_ACCEPTED_FORMATS)})", details, warnings
+            
+            # Minimum width check (YouTube requires >= 640px)
+            if width < YT_THUMB_MIN_WIDTH:
+                return False, f"Thumbnail width {width}px is below YouTube minimum of {YT_THUMB_MIN_WIDTH}px", details, warnings
+            
+            # Recommended dimensions check
+            if width != YT_THUMB_RECOMMENDED_WIDTH or height != YT_THUMB_RECOMMENDED_HEIGHT:
+                warnings.append(f"Thumbnail is {width}x{height} — YouTube recommends {YT_THUMB_RECOMMENDED_WIDTH}x{YT_THUMB_RECOMMENDED_HEIGHT}")
+            
+            # Aspect ratio check (16:9)
+            if width > 0 and height > 0:
+                ratio = width / height
+                if abs(ratio - 16/9) > 0.05:
+                    aspect = Fraction(width, height)
+                    warnings.append(f"Thumbnail aspect ratio {aspect.numerator}:{aspect.denominator} is not 16:9 — YouTube may add black bars")
+            
+            # Verify image integrity
+            img.verify()
+            
+    except Exception as e:
+        return False, f"Thumbnail is corrupted or unreadable: {e}", details, warnings
+    
+    reason_parts = [f"{width}x{height}"]
+    reason_parts.append(f"{details['file_size_kb']}KB")
+    reason_parts.append(img_format)
+    return True, f"Pass ({', '.join(reason_parts)})", details, warnings
+
+
+def validate_metadata(metadata_path):
+    """
+    Validate YouTube metadata file against YouTube Data API v3 requirements.
+    
+    Returns: (passed: bool, reason: str, details: dict, warnings: list[str])
+    
+    YouTube API metadata constraints (from developers.google.com/youtube/v3):
+    - Title: 1-100 characters, no < or > characters
+    - Description: <= 5000 characters, no < or > characters  
+    - Tags: total <= 500 characters
+    - Source attribution must be present
+    """
+    path = Path(metadata_path)
+    details = {}
+    warnings = []
+    
+    if not path.exists():
+        return False, "youtube_metadata.txt file not found", details, warnings
+    
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            content = f.read()
+    except Exception as e:
+        return False, f"Failed to read metadata file: {e}", details, warnings
+    
+    failures = []
+    
+    # --- TITLE validation ---
+    if "SUGGESTED TITLE:" not in content:
+        failures.append("Missing SUGGESTED TITLE section")
+    else:
+        title_match = re.search(r"SUGGESTED TITLE:\s*(.+)", content)
+        if not title_match or not title_match.group(1).strip():
+            failures.append("Suggested title is empty")
+        else:
+            title = title_match.group(1).strip()
+            details["title"] = title
+            details["title_length"] = len(title)
+            
+            # YouTube API: Title max 100 characters
+            if len(title) > YT_TITLE_MAX_CHARS:
+                failures.append(f"Title is {len(title)} characters — YouTube maximum is {YT_TITLE_MAX_CHARS}")
+            
+            # YouTube API: < and > are banned in titles
+            banned_in_title = [c for c in title if c in YT_BANNED_CHARS]
+            if banned_in_title:
+                failures.append(f"Title contains banned characters: {banned_in_title} — YouTube rejects < and > in titles")
+    
+    # --- DESCRIPTION validation ---
+    if "=== DESCRIPTION ===" not in content:
+        failures.append("Missing DESCRIPTION section")
+    else:
+        desc_parts = content.split("=== DESCRIPTION ===")
+        if len(desc_parts) < 2 or not desc_parts[1].strip():
+            failures.append("Description section is empty")
+        else:
+            # Extract description text (up to the next section marker or end of file)
+            desc_text = desc_parts[1]
+            # The description that gets uploaded is everything between === DESCRIPTION === and --- Video Transcript ---
+            transcript_marker = "--- Video Transcript ---"
+            if transcript_marker in desc_text:
+                desc_text = desc_text.split(transcript_marker)[0]
+            desc_text = desc_text.strip()
+            
+            details["description_length"] = len(desc_text)
+            
+            # YouTube API: Description max 5000 characters
+            if len(desc_text) > YT_DESCRIPTION_MAX_CHARS:
+                failures.append(f"Description is {len(desc_text)} characters — YouTube maximum is {YT_DESCRIPTION_MAX_CHARS}")
+            
+            # YouTube API: < and > are banned in descriptions
+            banned_in_desc = [c for c in desc_text if c in YT_BANNED_CHARS]
+            if banned_in_desc:
+                failures.append(f"Description contains {len(banned_in_desc)} banned character(s) (< or >) — YouTube rejects these")
+    
+    # --- SOURCE attribution check ---
+    if "Source:" not in content:
+        failures.append("Missing Source (attribution) information in description")
+    else:
+        details["has_source"] = True
+    
+    # --- TAGS validation (if tags section exists) ---
+    hashtag_matches = re.findall(r'#\w+', content)
+    if hashtag_matches:
+        total_tag_chars = sum(len(tag) - 1 for tag in hashtag_matches)  # Subtract # prefix
+        details["tags_count"] = len(hashtag_matches)
+        details["tags_total_chars"] = total_tag_chars
+        if total_tag_chars > YT_TAGS_MAX_CHARS:
+            warnings.append(f"Tags total {total_tag_chars} characters — YouTube maximum is {YT_TAGS_MAX_CHARS}")
+    
+    if failures:
+        return False, "; ".join(failures), details, warnings
+    
+    reason_parts = []
+    if "title_length" in details:
+        reason_parts.append(f"Title: {details['title_length']} chars")
+    if "description_length" in details:
+        reason_parts.append(f"Desc: {details['description_length']} chars")
+    reason_parts.append("Source: present")
+    
+    return True, f"Pass ({', '.join(reason_parts)})", details, warnings
+
+
+# ============================================================================
+# Main evaluation function
+# ============================================================================
+
+def evaluate_youtube_ready(article_dir, force=False, dry_run=False):
+    """
+    Evaluate whether an article's video assets are ready for YouTube upload.
+    
+    Checks video, thumbnail, metadata, and package integrity against
+    YouTube Data API v3 official requirements.
+    """
+    if not os.path.exists(article_dir):
+        logger.warning(f"Directory {article_dir} does not exist.")
+        return "REJECTED"
+
+    result_path = os.path.join(article_dir, "evaluation_result.json")
+    if not os.path.exists(result_path):
+        logger.info(f"Skipping {os.path.basename(article_dir)}: No evaluation_result.json found.")
+        return None
+
+    try:
+        with open(result_path, 'r', encoding='utf-8') as f:
+            results = json.load(f)
+    except Exception as e:
+        logger.error(f"Failed to read evaluation result from {result_path}: {e}")
+        return None
+
+    current_status = results.get("status", "")
+    if not force and current_status == "YOUTUBE_READY":
+        logger.info(f"Skipping {os.path.basename(article_dir)}: Already YOUTUBE_READY.")
+        return "YOUTUBE_READY"
+        
+    if current_status not in ["READY_FOR_NEWSVIDEO", "READY_FOR_VIDEO", "YOUTUBE_READY", "YOUTUBE_GATE_FAILED"]:
+        logger.info(f"Skipping {os.path.basename(article_dir)}: Status is '{current_status}', not ready for YouTube gate.")
+        return None
+
+    logger.info(f"Evaluating YouTube Gate for: {os.path.basename(article_dir)}")
+    
+    # Initialize/reset YouTube gate checks with enhanced structure
+    results["checks"]["youtube_gate"] = {
+        "timestamp": datetime.now().isoformat(),
+        "status": "PENDING",
+        "video": {"status": "PENDING", "reason": "", "details": {}},
+        "thumbnail": {"status": "PENDING", "reason": "", "details": {}},
+        "metadata": {"status": "PENDING", "reason": "", "details": {}},
+        "package": {"status": "PENDING", "reason": ""},
+        "warnings": []
+    }
+    
+    if "reject_reasons" not in results:
+        results["reject_reasons"] = []
+        
+    # Clean old YouTube gate reject reasons
+    results["reject_reasons"] = [r for r in results["reject_reasons"] if not r.startswith("[YOUTUBE_GATE]")]
+
+    safe_name = safe_filename(os.path.basename(article_dir))
+    all_warnings = []
+    
+    # ===== 1. VIDEO CHECK =====
+    sizes = ["short", "middle", "long"]
+    video_failures = []
+    video_details_all = {}
+    
+    for size in sizes:
+        video_file = f"{safe_name}_{size}.mp4"
+        video_path = os.path.join(article_dir, video_file)
+        ok, reason, details, warns = validate_video(video_path)
+        video_details_all[size] = details
+        if not ok:
+            video_failures.append(f"{size}: {reason}")
+        for w in warns:
+            all_warnings.append(f"{size} video: {w}")
+            
+    if video_failures:
+        results["checks"]["youtube_gate"]["video"] = {
+            "status": "FAIL",
+            "reason": "; ".join(video_failures),
+            "details": video_details_all
+        }
+    else:
+        results["checks"]["youtube_gate"]["video"] = {
+            "status": "PASS",
+            "reason": "All sizes (short, middle, long) videos pass YouTube requirements",
+            "details": video_details_all
+        }
+
+    # ===== 2. PACKAGE CHECK (video + thumbnail in package) =====
+    package_failures = []
+    
+    for size in sizes:
+        pkg_dir = os.path.join(YOUTUBE_DIR, f"{safe_name}_{size}")
+        if not os.path.exists(pkg_dir):
+            package_failures.append(f"Package directory for {size} missing")
+            continue
+            
+        # Check video in package
+        pkg_video = os.path.join(pkg_dir, f"{safe_name}_{size}.mp4")
+        ok, reason, _, _ = validate_video(pkg_video)
+        if not ok:
+            package_failures.append(f"{size} package video: {reason}")
+            
+        # Check thumbnail in package (with YouTube specs)
+        pkg_thumb = os.path.join(pkg_dir, "thumbnail.png")
+        ok, reason, thumb_details, thumb_warns = validate_thumbnail(pkg_thumb)
+        if not ok:
+            package_failures.append(f"{size} package thumbnail: {reason}")
+        for w in thumb_warns:
+            all_warnings.append(f"{size} package thumbnail: {w}")
+        
+        # Store thumbnail details from one package for reporting
+        if thumb_details and "details" not in results["checks"]["youtube_gate"]["thumbnail"]:
+            results["checks"]["youtube_gate"]["thumbnail"]["details"] = thumb_details
+
+    if package_failures:
+        results["checks"]["youtube_gate"]["package"] = {
+            "status": "FAIL",
+            "reason": "; ".join(package_failures)
+        }
+    else:
+        results["checks"]["youtube_gate"]["package"] = {
+            "status": "PASS",
+            "reason": "All packages have valid video and thumbnail meeting YouTube specs"
+        }
+
+    # ===== 3. THUMBNAIL CHECK (dedicated — from package) =====
+    # Use the first available package's thumbnail for the primary check
+    thumb_checked = False
+    for size in sizes:
+        pkg_dir = os.path.join(YOUTUBE_DIR, f"{safe_name}_{size}")
+        pkg_thumb = os.path.join(pkg_dir, "thumbnail.png")
+        if os.path.exists(pkg_thumb):
+            ok, reason, thumb_details, thumb_warns = validate_thumbnail(pkg_thumb)
+            results["checks"]["youtube_gate"]["thumbnail"] = {
+                "status": "PASS" if ok else "FAIL",
+                "reason": reason,
+                "details": thumb_details
+            }
+            for w in thumb_warns:
+                all_warnings.append(f"thumbnail: {w}")
+            thumb_checked = True
+            break
+    
+    if not thumb_checked:
+        results["checks"]["youtube_gate"]["thumbnail"] = {
+            "status": "FAIL",
+            "reason": "No thumbnail found in any package directory",
+            "details": {}
+        }
+
+    # ===== 4. METADATA CHECK =====
+    metadata_failures = []
+    metadata_details_all = {}
+    
+    for size in sizes:
+        pkg_dir = os.path.join(YOUTUBE_DIR, f"{safe_name}_{size}")
+        pkg_meta = os.path.join(pkg_dir, "youtube_metadata.txt")
+        ok, reason, meta_details, meta_warns = validate_metadata(pkg_meta)
+        metadata_details_all[size] = meta_details
+        if not ok:
+            metadata_failures.append(f"{size}: {reason}")
+        for w in meta_warns:
+            all_warnings.append(f"{size} metadata: {w}")
+
+    if metadata_failures:
+        results["checks"]["youtube_gate"]["metadata"] = {
+            "status": "FAIL",
+            "reason": "; ".join(metadata_failures),
+            "details": metadata_details_all
+        }
+    else:
+        results["checks"]["youtube_gate"]["metadata"] = {
+            "status": "PASS",
+            "reason": "All metadata passes YouTube API requirements",
+            "details": metadata_details_all
+        }
+
+    # ===== Store all warnings =====
+    results["checks"]["youtube_gate"]["warnings"] = all_warnings
+
+    # ===== Determine overall gate status =====
+    gate_ok = True
+    gate_reasons = []
+    
+    for subcheck in ["video", "thumbnail", "metadata", "package"]:
+        sub_status = results["checks"]["youtube_gate"][subcheck]["status"]
+        sub_reason = results["checks"]["youtube_gate"][subcheck]["reason"]
+        if sub_status == "FAIL":
+            gate_ok = False
+            gate_reasons.append(f"[YOUTUBE_GATE] {subcheck.upper()} FAIL: {sub_reason}")
+
+    if gate_ok:
+        results["checks"]["youtube_gate"]["status"] = "PASS"
+        results["status"] = "YOUTUBE_READY"
+        warn_summary = f" ({len(all_warnings)} warnings)" if all_warnings else ""
+        logger.info(f"  -> Final Status: YOUTUBE_READY{warn_summary}")
+    else:
+        results["checks"]["youtube_gate"]["status"] = "FAIL"
+        results["status"] = "YOUTUBE_GATE_FAILED"
+        results["reject_reasons"].extend(gate_reasons)
+        logger.warning(f"  -> Final Status: YOUTUBE_GATE_FAILED (Reasons: {gate_reasons})")
+
+    # Save results
+    if not dry_run:
+        try:
+            with open(result_path, 'w', encoding='utf-8') as f:
+                json.dump(results, f, indent=4, ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"Failed to save evaluation result to {result_path}: {e}")
+    else:
+        logger.info(f"[DRY-RUN] Would save evaluation result to {result_path}")
+
+    return results["status"]
+
+
+# ============================================================================
+# CLI entry point
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="YouTube Ready Quality Gate — validates video assets against YouTube Data API v3 requirements."
+    )
+    parser.add_argument("--locale", type=str, default=None, help="Locale to evaluate (default: all)")
+    parser.add_argument("--category", type=str, default=None, help="Category to evaluate")
+    parser.add_argument("--dry-run", action="store_true", help="Evaluate only, do not save status")
+    parser.add_argument("--force", action="store_true", help="Force evaluation even if already YOUTUBE_READY")
+    parser.add_argument("--verbose", action="store_true", help="Show detailed validation info per article")
+    args = parser.parse_args()
+
+    locales = [args.locale] if args.locale else ["en-US", "en-EU", "ja-JP", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]
+    
+    article_dirs = []
+    for locale in locales:
+        locale_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(locale_path) or not os.path.isdir(locale_path):
+            continue
+        try:
+            categories = [args.category] if args.category else os.listdir(locale_path)
+        except OSError as e:
+            logger.error(f"Error listing categories in {locale_path}: {e}")
+            continue
+            
+        for category in categories:
+            cat_path = os.path.join(locale_path, category)
+            if not os.path.isdir(cat_path) or category == "__pycache__":
+                continue
+            try:
+                articles = os.listdir(cat_path)
+            except OSError:
+                continue
+            for article in articles:
+                article_dir = os.path.join(cat_path, article)
+                if os.path.isdir(article_dir) and article not in ["images", "sources", "__pycache__"]:
+                    article_dirs.append(article_dir)
+
+    if not article_dirs:
+        logger.info("No articles found to evaluate.")
+        return
+
+    logger.info(f"Found {len(article_dirs)} articles to scan for YouTube Quality Gate.")
+    logger.info("Validating against YouTube Data API v3 specifications:")
+    logger.info(f"  Video: codec, audio stream, duration ≤{YT_MAX_DURATION_SECONDS}s, file size ≤256GB")
+    logger.info(f"  Thumbnail: ≥{YT_THUMB_MIN_WIDTH}px width, ≤{YT_THUMB_MAX_SIZE_BYTES // (1024*1024)}MB, 16:9")
+    logger.info(f"  Metadata: title ≤{YT_TITLE_MAX_CHARS} chars, description ≤{YT_DESCRIPTION_MAX_CHARS} chars, no <> chars")
+
+    stats = {"YOUTUBE_READY": 0, "YOUTUBE_GATE_FAILED": 0, "SKIPPED": 0, "WARNINGS": 0}
+
+    for art_dir in article_dirs:
+        res = evaluate_youtube_ready(art_dir, force=args.force, dry_run=args.dry_run)
+        if res == "YOUTUBE_READY":
+            stats["YOUTUBE_READY"] += 1
+        elif res == "YOUTUBE_GATE_FAILED":
+            stats["YOUTUBE_GATE_FAILED"] += 1
+        else:
+            stats["SKIPPED"] += 1
+
+    print("\n" + "="*60)
+    print("YouTube Quality Gate Scan Complete!")
+    print(f"  Specs: YouTube Data API v3 + Encoding Recommendations")
+    print("-"*60)
+    print(f"  Total articles scanned:  {len(article_dirs)}")
+    print(f"  YOUTUBE_READY:           {stats['YOUTUBE_READY']}")
+    print(f"  YOUTUBE_GATE_FAILED:     {stats['YOUTUBE_GATE_FAILED']}")
+    print(f"  SKIPPED:                 {stats['SKIPPED']}")
+    print("="*60)
+
+if __name__ == "__main__":
+    main()

recover_missing_images.py

@@ -0,0 +1,360 @@
+import os
+import re
+import sys
+from pathlib import Path
+import requests
+from googlenewsdecoder import new_decoderv1
+
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(encoding='utf-8')
+
+ROOT_DIR = r"C:\ComfyUI\Articles"
+
+# Dynamic path for importing WatermarkRemover
+sys.path.insert(0, r"C:\Roaming\scripts")
+try:
+    from news_collector.watermark_remover import WatermarkRemover
+    HAS_REMOVER = True
+except ImportError:
+    HAS_REMOVER = False
+
+try:
+    from curl_cffi import requests as requests_cffi
+    HAS_CURL_CFFI = True
+except ImportError:
+    HAS_CURL_CFFI = False
+
+def download_file(url, dest_path):
+    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": "image/webp,image/apng,image/*,*/*;q=0.8",
+        "Accept-Language": "ja,en-US;q=0.9,en;q=0.8",
+        "Referer": "https://news.google.com/"
+    }
+    try:
+        os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+        if HAS_CURL_CFFI:
+            response = requests_cffi.get(url, headers=headers, impersonate="chrome120", timeout=30)
+        else:
+            response = requests.get(url, headers=headers, timeout=30)
+        response.raise_for_status()
+        with open(dest_path, 'wb') as f:
+            f.write(response.content)
+        return True
+    except Exception as e:
+        print(f"      Failed to download image {url}: {e}")
+        if os.path.exists(dest_path):
+            try:
+                os.remove(dest_path)
+            except:
+                pass
+        return False
+
+def is_valid_image(img_url, img_path):
+    # 1. URL Substring Check
+    url_lower = img_url.lower()
+    
+    # Generic keywords indicating logos, default fallback pictures, ads, etc.
+    blacklist_keywords = [
+        "logo", "avatar", "favicon", "icon", "placeholder", "default", "fallback", 
+        "dummy", "spacer", "pixel", "header", "footer", "ad-", "ads-", 
+        "advertisement", "newsletter", "subscribe", "sign-up", "social-share", 
+        "facebook-share", "twitter-share", "share-icon", "share-logo",
+        "app-store", "play-store", "transparent", "blank", "branding"
+    ]
+    
+    # Also block specific generic image names commonly used by news outlets
+    # e.g., Yahoo, Reuters, AP, Bloomberg, BBC, etc. logos or generic graphics
+    generic_patterns = [
+        "reuters-logo", "reuters_logo", "nytimes-logo", "nytimes_logo",
+        "ap-logo", "ap_logo", "bbc-logo", "bbc_logo", "cnn-logo", "cnn_logo",
+        "bloomberg-logo", "bloomberg_logo", "yahoo-logo", "yahoo_logo",
+        "wsj_logo", "wsj-logo", "guardian-logo", "guardian_logo"
+    ]
+    
+    for kw in blacklist_keywords:
+        if kw in url_lower:
+            print(f"      Rejecting image URL (matches blacklist keyword '{kw}'): {img_url}")
+            return False
+            
+    for pat in generic_patterns:
+        if pat in url_lower:
+            print(f"      Rejecting image URL (matches generic logo pattern '{pat}'): {img_url}")
+            return False
+
+    # 2. Image Content Check (using Pillow)
+    if not os.path.exists(img_path):
+        return False
+        
+    try:
+        from PIL import Image, ImageStat
+        with Image.open(img_path) as img:
+            width, height = img.size
+            
+            # Aspect Ratio
+            aspect_ratio = width / height
+            
+            # Minimum dimension requirements
+            min_width = 300
+            min_height = 200
+            
+            if width < min_width or height < min_height:
+                print(f"      Rejecting image (too small: {width}x{height}, required min {min_width}x{min_height})")
+                return False
+                
+            # Aspect Ratio Check (block extremely wide/tall banner or ad layout blocks)
+            if aspect_ratio < 0.5 or aspect_ratio > 3.0:
+                print(f"      Rejecting image (extreme aspect ratio: {aspect_ratio:.2f})")
+                return False
+                
+            # Perfect square check (width == height) for small images (usually logos/avatars)
+            if width == height and width < 450:
+                print(f"      Rejecting image (square logo/avatar heuristic: {width}x{height})")
+                return False
+                
+            # Standard Deviation check (blank or solid color placeholder images)
+            # A natural photograph typically has standard deviation > 10.
+            # Spacer GIFs or blank images will have standard deviation near 0.
+            stat = ImageStat.Stat(img)
+            # Check standard deviation of all bands (RGB / RGBA / L)
+            std_devs = stat.stddev
+            if std_devs and all(sd < 3.0 for sd in std_devs):
+                print(f"      Rejecting image (low variance / solid color placeholder: stddev={std_devs})")
+                return False
+                
+    except ImportError:
+        print("      Warning: Pillow (PIL) is not installed. Skipping image dimension and content validation.")
+    except Exception as e:
+        print(f"      Warning: Failed to validate image content properties: {e}")
+        
+    return True
+
+def extract_og_image(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": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "ja,en-US;q=0.9,en;q=0.8",
+        "Referer": "https://news.google.com/"
+    }
+    try:
+        if HAS_CURL_CFFI:
+            response = requests_cffi.get(url, headers=headers, impersonate="chrome120", timeout=15)
+        else:
+            response = requests.get(url, headers=headers, timeout=15)
+        response.raise_for_status()
+        html = response.text
+        m = re.search(r'<meta[^>]*property=[\'"]og:image[\'"][^>]*content=[\'"]([^\'"]+)[\'"]', html, re.I)
+        if m:
+            return m.group(1)
+        m2 = re.search(r'<meta[^>]*content=[\'"]([^\'"]+)[\'"][^>]*property=[\'"]og:image[\']', html, re.I)
+        if m2:
+            return m2.group(1)
+    except Exception as e:
+        print(f"      Failed to fetch og:image from {url}: {e}")
+    return None
+
+def extract_source_url(md_content):
+    # Try finding the link in "Sources & Citations:" section at bottom
+    # e.g., - [Article Title](https://...)
+    urls = re.findall(r'-\s+\[[^\]]+\]\((https?://[^\)]+)\)', md_content)
+    if urls:
+        return urls[0]
+        
+    # Fallback to metadata block
+    m = re.search(r'\*\*Source:\*\*\s*\[[^\]]+\]\((https?://[^\)]+)\)', md_content)
+    if m:
+        return m.group(1)
+        
+    # Simple regex for any URL in parentheses
+    urls_any = re.findall(r'\((https?://[^\)]+)\)', md_content)
+    if urls_any:
+        return urls_any[0]
+        
+    return None
+
+def inject_carousel_to_md(md_path, img_paths):
+    try:
+        with open(md_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+            
+        # If carousel already exists, do not duplicate
+        if "```carousel" in content:
+            return
+            
+        lines = content.splitlines()
+        title_idx = -1
+        for i, line in enumerate(lines):
+            if line.strip().startswith("# "):
+                title_idx = i
+                break
+        
+        date_idx = -1
+        if title_idx != -1:
+            for i in range(title_idx + 1, len(lines)):
+                if lines[i].strip():
+                    date_idx = i
+                    break
+        
+        insert_idx = -1
+        if date_idx != -1:
+            insert_idx = date_idx + 1
+        elif title_idx != -1:
+            insert_idx = title_idx + 1
+            
+        if insert_idx != -1:
+            carousel_lines = ["", "```carousel"]
+            for j, img_path in enumerate(img_paths, 1):
+                # Clean path relative to ROOT_DIR
+                rel_path = os.path.relpath(img_path, ROOT_DIR).replace(os.sep, '/')
+                if j > 1:
+                    carousel_lines.append("<!-- slide -->")
+                carousel_lines.append(f"![Visual Theme {j}]({rel_path})")
+            carousel_lines.append("```")
+            carousel_lines.append("")
+            
+            lines = lines[:insert_idx] + carousel_lines + lines[insert_idx:]
+            new_content = "\n".join(lines)
+            
+            with open(md_path, 'w', encoding='utf-8') as f:
+                f.write(new_content)
+            print(f"      Injected image carousel into markdown.")
+    except Exception as e:
+        print(f"      Failed to update markdown file: {e}")
+
+def main():
+    print("Starting recovery of missing article images...")
+    locales = ["en-US", "ja-JP", "en-EU", "en-UA", "en-RU", "en-CN", "en-ME", "en-IN", "en-PK", "en-ZA", "en-AU"]
+    remover = WatermarkRemover(Path(ROOT_DIR)) if HAS_REMOVER else None
+    
+    recovered_count = 0
+    failed_count = 0
+    limit = 300  # Expand processing limit to 300 for mass recovery
+    
+    article_dirs = []
+    
+    # Scan all directories
+    for locale in locales:
+        locale_path = os.path.join(ROOT_DIR, locale)
+        if not os.path.exists(locale_path) or not os.path.isdir(locale_path):
+            continue
+        for cat in os.listdir(locale_path):
+            cat_path = os.path.join(locale_path, cat)
+            if not os.path.isdir(cat_path) or cat == "__pycache__":
+                continue
+            for art in os.listdir(cat_path):
+                art_path = os.path.join(cat_path, art)
+                if not os.path.isdir(art_path) or art in ["__pycache__", "images", "sources"]:
+                    continue
+                article_dirs.append((art_path, art))
+                
+    print(f"Total articles found: {len(article_dirs)}")
+    
+    # Filter for articles missing images
+    missing_images_dirs = []
+    for art_path, art in article_dirs:
+        has_img = False
+        img_dir = os.path.join(art_path, "images")
+        if os.path.exists(img_dir):
+            imgs = [f for f in os.listdir(img_dir) if f.lower().endswith(('.jpg', '.jpeg', '.png'))]
+            if imgs:
+                has_img = True
+        else:
+            imgs = [f for f in os.listdir(art_path) if f.lower().endswith(('.jpg', '.jpeg', '.png'))]
+            if imgs:
+                has_img = True
+                
+        if not has_img:
+            missing_images_dirs.append((art_path, art))
+            
+    print(f"Articles missing images: {len(missing_images_dirs)}")
+    
+    if not missing_images_dirs:
+        print("No articles are missing images. All clear!")
+        return
+        
+    to_process = missing_images_dirs[:limit]
+    print(f"Processing first {len(to_process)} articles missing images...")
+    
+    for art_path, art in to_process:
+        print(f"\nProcessing: {art}")
+        
+        # Find main markdown file
+        md_files = [f for f in os.listdir(art_path) if f.endswith(".md") and not f.endswith(("script_short.md", "script_middle.md", "script_long.md", "script_normal.md", "script.md"))]
+        if not md_files:
+            print("  Warning: No main article markdown file found.")
+            continue
+            
+        md_path = os.path.join(art_path, md_files[0])
+        try:
+            with open(md_path, 'r', encoding='utf-8') as f:
+                md_content = f.read()
+        except Exception as e:
+            print(f"  Error reading markdown file: {e}")
+            continue
+            
+        source_url = extract_source_url(md_content)
+        if not source_url:
+            print("  Warning: Could not extract source URL from markdown.")
+            continue
+            
+        print(f"  Source URL: {source_url}")
+        
+        # Decode Google News link
+        decoded_url = source_url
+        if "news.google.com" in source_url:
+            try:
+                res = new_decoderv1(source_url, interval=1)
+                if res.get("status"):
+                    decoded_url = res["decoded_url"]
+                    print(f"  Decoded URL: {decoded_url}")
+            except Exception as e:
+                print(f"  Warning: Failed to decode Google News URL: {e}")
+                
+        # Extract og:image
+        img_url = extract_og_image(decoded_url)
+        if not img_url:
+            print("  Warning: No og:image found on site.")
+            failed_count += 1
+            continue
+            
+        print(f"  Found Image URL: {img_url}")
+        
+        # Create images folder
+        images_dir = os.path.join(art_path, "images")
+        os.makedirs(images_dir, exist_ok=True)
+        
+        img_dest = os.path.join(images_dir, f"{art}_img1.jpg")
+        success = download_file(img_url, img_dest)
+        
+        if success:
+            if not is_valid_image(img_url, img_dest):
+                print("  Rejected downloaded image as unrelated.")
+                if os.path.exists(img_dest):
+                    try:
+                        os.remove(img_dest)
+                    except:
+                        pass
+                failed_count += 1
+                continue
+                
+            print("  Image downloaded and validated successfully.")
+            # Remove watermark
+            if remover:
+                try:
+                    remover.remove_watermark(Path(img_dest), decoded_url)
+                except Exception as rem_err:
+                    print(f"  Failed to remove watermark: {rem_err}")
+            
+            # Inject into markdown
+            inject_carousel_to_md(md_path, [img_dest])
+            recovered_count += 1
+        else:
+            failed_count += 1
+            
+    print(f"\nImage recovery run finished.")
+    print(f"Successfully recovered images for: {recovered_count} articles")
+    print(f"Failed to recover for: {failed_count} articles")
+    print(f"Remaining articles missing images: {len(missing_images_dirs) - recovered_count}")
+
+if __name__ == "__main__":
+    main()

run_generator_silent.vbs

@@ -0,0 +1,3 @@
+Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run "cmd.exe /c cd /d C:\ComfyUI\Articles && C:\Users\eggof\AppData\Local\Programs\Python\Python313\python.exe generate_scripts_all.py --locale en-US --limit 5 --gpu >> generator_service.log 2>&1", 0, True
+

run_pipeline_safely.ps1

@@ -0,0 +1,79 @@
+# run_pipeline_safely.ps1
+# Runs script generation, media collection, and quality gate copying for all locales sequentially,
+# and sleeps between batches to allow TTS/Video generation on GPU to proceed.
+
+$limit = 20
+$sleepSeconds = 90  # Give plenty of time for TTS/video generation to run when GPU is idle
+
+Write-Host "=== Safe Coordinated Sequential Pipeline Loop Started ==="
+
+while ($true) {
+    $locales = @("en-US", "en-EU", "ja-JP")
+    $any_remaining = $false
+    
+    foreach ($locale in $locales) {
+        Write-Host ""
+        Write-Host "========================================"
+        Write-Host "Processing Locale: $locale at $(Get-Date -Format 'HH:mm:ss')"
+        Write-Host "========================================"
+        
+        # 1. Check remaining count first
+        $check = python -c "
+import os
+ROOT_DIR = r'C:\ComfyUI\Articles'
+locale = '$locale'
+loc_path = os.path.join(ROOT_DIR, locale)
+article_dirs = []
+if os.path.exists(loc_path):
+    for cat in os.listdir(loc_path):
+        if cat == '__pycache__': continue
+        cat_path = os.path.join(loc_path, cat)
+        if os.path.isdir(cat_path):
+            for art in os.listdir(cat_path):
+                if art in ['__pycache__', 'images', 'sources']: continue
+                art_path = os.path.join(cat_path, art)
+                if os.path.isdir(art_path):
+                    md_files = [f for f in os.listdir(art_path) if f.endswith('.md')]
+                    if md_files:
+                        article_dirs.append(art_path)
+dirs_to_process = []
+for d in article_dirs:
+    all_exist = True
+    for length in ['short', 'middle', 'long']:
+        script_path = os.path.join(d, f'script_{length}.md')
+        txt_path = os.path.join(d, f'script_{length}_clean.txt')
+        if not os.path.exists(script_path) or not os.path.exists(txt_path):
+            all_exist = False
+            break
+    if not all_exist:
+        dirs_to_process.append(d)
+print(len(dirs_to_process))
+"
+        $remaining = [int]($check.Trim())
+        Write-Host "Remaining articles needing scripts in $($locale): $remaining"
+        
+        if ($remaining -gt 0) {
+            $any_remaining = $true
+            
+            Write-Host "1. Running script generation (limit $limit, GPU)..."
+            $process = Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\generate_scripts_all.py --locale $locale --limit $limit --gpu" -NoNewWindow -PassThru -Wait
+            
+            Write-Host "2. Running media collection..."
+            Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\collect_media_parallel.py --locale $locale" -NoNewWindow -PassThru -Wait
+            
+            Write-Host "3. Running quality gate evaluation and copy..."
+            Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\copy_passed_articles.py --locale $locale" -NoNewWindow -PassThru -Wait
+        }
+    }
+    
+    if (-not $any_remaining) {
+        Write-Host "All locales have 100% of their scripts drafted!"
+        # We can still sleep and check again later, or sleep a long time.
+        Write-Host "Sleeping for 5 minutes before next check..."
+        Start-Sleep -Seconds 300
+    } else {
+        # Sleep to let the GPU run TTS and video generation
+        Write-Host "Cycle complete at $(Get-Date -Format 'HH:mm:ss'). Sleeping for $sleepSeconds seconds to let ComfyUI process TTS and videos..."
+        Start-Sleep -Seconds $sleepSeconds
+    }
+}

run_scripts_safely.ps1

@@ -0,0 +1,93 @@
+param (
+    [string]$locale = "en-EU",
+    [string]$category = "",
+    [int]$limit = 10,
+    [switch]$gpu
+)
+
+Write-Host "Starting safe script generation loop for locale: $locale, category: $category, limit: $limit, GPU: $gpu"
+
+$cmdArgs = "--locale $locale --limit $limit"
+if ($gpu) {
+    $cmdArgs = $cmdArgs + " --gpu"
+}
+if ($category -ne "") {
+    $cmdArgs = $cmdArgs + " --category " + $category
+}
+
+# Infinite loop running generate_scripts_all.py
+while ($true) {
+    Write-Host "Running next batch (limit $limit)..."
+    
+    # Run the script and capture both stdout and stderr
+    $process = Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\generate_scripts_all.py $cmdArgs" -NoNewWindow -PassThru -Wait
+    
+    $exitCode = $process.ExitCode
+    Write-Host "Process finished with exit code: $exitCode"
+    
+    Write-Host "Running media collection..."
+    $mediaArgs = "--locale $locale"
+    Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\collect_media_parallel.py $mediaArgs" -NoNewWindow -PassThru -Wait
+    
+    Write-Host "Running quality gate evaluation and copy..."
+    $copyArgs = "--locale $locale"
+    if ($category -ne "") {
+        $copyArgs = $copyArgs + " --category " + $category
+    }
+    Start-Process -FilePath "python" -ArgumentList "C:\ComfyUI\Articles\copy_passed_articles.py $copyArgs" -NoNewWindow -PassThru -Wait
+
+    # Wait a bit to prevent tight loop if something is fundamentally broken
+    Start-Sleep -Seconds 3
+    
+    # Verify if there are any remaining articles by doing a quick run that will check status
+    # We can run with --limit 0 (if supported) or just check the output of a test check.
+    # To keep it simple, we run a check logic:
+    # If the process completed successfully but processed 0 count, it means we are done.
+    # We can inspect history or files, but running the script and checking if it skips immediately is easiest.
+    # Let's run a dry run check via python inline
+    $check = python -c "
+import os
+ROOT_DIR = r'C:\ComfyUI\Articles'
+locale = '$locale'
+category = '$category' if '$category' else None
+locales = [locale]
+article_dirs = []
+for loc in locales:
+    loc_path = os.path.join(ROOT_DIR, loc)
+    if not os.path.exists(loc_path): continue
+    cats = [category] if category else os.listdir(loc_path)
+    for cat in cats:
+        if cat == '__pycache__': continue
+        cat_path = os.path.join(loc_path, cat)
+        if not os.path.exists(cat_path) or not os.path.isdir(cat_path): continue
+        for art in os.listdir(cat_path):
+            if art in ['__pycache__', 'images', 'sources']: continue
+            art_path = os.path.join(cat_path, art)
+            if os.path.isdir(art_path):
+                md_files = [f for f in os.listdir(art_path) if f.endswith('.md')]
+                if md_files:
+                    article_dirs.append(art_path)
+
+dirs_to_process = []
+for d in article_dirs:
+    all_exist = True
+    for length in ['short', 'middle', 'long']:
+        script_path = os.path.join(d, f'script_{length}.md')
+        txt_path = os.path.join(d, f'script_{length}_clean.txt')
+        if not os.path.exists(script_path) or not os.path.exists(txt_path):
+            all_exist = False
+            break
+    if not all_exist:
+        dirs_to_process.append(d)
+
+print(len(dirs_to_process))
+"
+    
+    $remaining = [int]($check.Trim())
+    Write-Host "Remaining articles requiring scripts: $remaining"
+    
+    if ($remaining -eq 0) {
+        Write-Host "Success! All articles in $locale (category: $category) have scripts generated."
+        break
+    }
+}

run_silent.vbs

@@ -0,0 +1,3 @@
+Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run "cmd.exe /c cd /d C:\ComfyUI\Articles && C:\Users\eggof\AppData\Local\Programs\Python\Python313\python.exe collect_news_service.py >> service.log 2>&1", 0, True
+

run_tts_silent.vbs

@@ -0,0 +1,3 @@
+Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run "cmd.exe /c C:\Users\eggof\AppData\Local\Programs\Python\Python313\python.exe -u C:\ComfyUI\Articles\auto_tts_on_idle.py --all-lengths >> C:\ComfyUI\Articles\auto_tts_stdout.log 2>> C:\ComfyUI\Articles\auto_tts_stderr.log", 0, False
+

run_video_watcher.ps1

@@ -0,0 +1,24 @@
+# C:\ComfyUI\Articles\run_video_watcher.ps1
+# Runs process_ready_videos_step.py in a loop to copy completed videos and queue next jobs when ComfyUI is idle.
+
+Write-Host "=== Continuous Video Pipeline Watcher Loop Started ==="
+
+while ($true) {
+    Write-Host ""
+    Write-Host "========================================"
+    Write-Host "Running video step check at $(Get-Date -Format 'HH:mm:ss')"
+    Write-Host "========================================"
+    
+    # Clean up duplicate PowerShell and Python processes to prevent resource contention/OOM
+    C:\Python313\python.exe C:\ComfyUI\Articles\cleanup_duplicates.py
+    
+    C:\Python313\python.exe C:\ComfyUI\Articles\evaluate_for_video.py --locale en-US --skip-llm
+    # C:\Python313\python.exe C:\ComfyUI\Articles\evaluate_for_video.py --locale en-EU --skip-llm
+    # C:\Python313\python.exe C:\ComfyUI\Articles\evaluate_for_video.py --locale ja-JP --skip-llm
+
+    C:\Python313\python.exe C:\ComfyUI\Articles\process_ready_videos_step.py
+    
+    # Sleep for 60 seconds before next check
+    Start-Sleep -Seconds 60
+}
+

script_long.json

@@ -0,0 +1,5 @@
+{
+    "importance": 8,
+    "urgency": 8,
+    "tier": 1
+}

script_long.md

@@ -0,0 +1,7 @@
+Good evening. Tonight, we delve into a fascinating development in the world of media analysis and content verification. A recent report highlights an intriguing phenomenon: high-contrast corner patterns in images flagged as potentially containing logos or text embedded within them. 
+
+The report reveals that over 900 images were scanned, with a significant portion flagged for further investigation.  This raises questions about the potential use of watermarks and their impact on image authenticity. The report highlights specific examples where these high-contrast corners, often associated with watermarks, have been identified as a cause for concern.
+
+The report details several images from BBC News, specifically focusing on articles related to the South African migrant crisis. These images showcase prominent watermarks in the bottom left corner.  The report reveals that the presence of such watermarks is flagged as a potential indicator of manipulation or alteration. 
+
+These findings raise important questions about the integrity of online content and the need for robust verification practices. As we move forward, it's crucial to understand how these techniques are used and what measures can be taken to ensure the accuracy and authenticity of information shared online.

script_long.rag_ingested

@@ -0,0 +1 @@
+{"doc_id": "7c0992c4ac379025", "ingested_at": "2026-06-30T08:25:13.843281", "content_hash": "7c0992c4ac379025"}