Datasets:

aoiandroid
/

android-times-articles

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()

	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(jaccard100)}%, SequenceMatcher: {int(ratio100)}%) 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(jaccard100)}%, SequenceMatcher: {int(ratio100)}%) 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()