Integrated pattern deviation, fixed Cebuano modeling, and added ISO Survey

backend/train.py

@@ -1000,24 +1000,31 @@ def load_fake_news_dataset(
 
     if cebuano_only:
         # ── Cebuano-only mode ──────────────────────────────────────────────
-        # Real: CebuaNER  |  Fake: MT-translated from jcblaise Tagalog fakes
+        # Real: CebuaNER (capped)  |  Fake: MT-translated from jcblaise Tagalog fakes
         print("  Mode: CEBUANO-ONLY")
 
+        df_ceb_fake = _augment_fake_news_with_translation(target_lang="ceb")
+        ceb_fake_count = len(df_ceb_fake) if df_ceb_fake is not None else 0
+
         df3 = _load_cebuaner_as_dataframe()
         if df3 is not None:
+            if ceb_fake_count > 0 and len(df3) > ceb_fake_count:
+                print(
+                    f"  [3] Undersampling CebuaNER real news: "
+                    f"{len(df3)} → {ceb_fake_count} (to match {ceb_fake_count} fake articles)"
+                )
+                df3 = df3.sample(n=ceb_fake_count, random_state=42).reset_index(drop=True)
             frames.append(df3)
 
-        df_ceb_fake = _augment_fake_news_with_translation(target_lang="ceb")
         if df_ceb_fake is not None:
             frames.append(df_ceb_fake)
 
     elif tagalog_only:
         # ── Tagalog-only mode ──────────────────────────────────────────────
-        # Strategy: trust known Filipino datasets as-is; only run langdetect
-        # on the Philippine Corpus (which is 99.6% English) to extract its
-        # small Tagalog-credible subset.  This preserves all 1,603 jcblaise
-        # fake articles instead of the ~71 that survived the old global filter.
-        print("  Mode: TAGALOG-ONLY (per-dataset filtering)")
+        # Fake priority: satire_facebook.csv first (real Filipino social media
+        # fake news), then augmented_tl_fakes.csv to fill the quota.
+        # Real news: BalitaNLP capped to total fake count (undersampling).
+        print("  Mode: TAGALOG-ONLY (per-dataset filtering, undersampled)")
 
         # [1] jcblaise — labeled Filipino fake-news corpus, load ALL rows
         csv1 = os.path.join(
@@ -1077,15 +1084,43 @@ def load_fake_news_dataset(
         # [3] CebuaNER — skip (Cebuano, not Tagalog)
         print("  [3] josephimperial/CebuaNER: skipped (Tagalog-only mode)")
 
-        # [4] BalitaNLP — trusted Filipino dataset, load all (no langdetect needed)
-        df4 = _load_balitanlp_as_dataframe()
-        if df4 is not None:
-            frames.append(df4)
+        # [sat] PRIORITY: satire_facebook.csv — real Filipino social-media fake news.
+        #       Loaded FIRST so it is always included in the fake quota.
+        tl_satire_count = 0
+        csv_satire = os.path.join(PROJECT_ROOT, "data", "raw", "satire_facebook.csv")
+        if os.path.exists(csv_satire):
+            df_sat = pd.read_csv(csv_satire)
+            if "article" in df_sat.columns:
+                df_sat = df_sat[["article"]].dropna().copy()
+                df_sat = df_sat[df_sat["article"].str.split().str.len() >= 5]
+                df_sat["label"] = 1  # Fake/Satire
+                tl_satire_count = len(df_sat)
+                print(
+                    f"  [sat] satire_facebook.csv (PRIORITY): "
+                    f"{tl_satire_count} Tagalog satire posts (all Fake)"
+                )
+                frames.append(df_sat)
+        else:
+            print("  [sat] satire_facebook.csv not found — skipping priority satire.")
 
-        # [aug] MT-translate English "Not Credible" → Tagalog fakes (~500 articles)
+        # [aug] MT-translated Tagalog fakes — fill remaining quota after satire.
         df_tl_fake = _augment_fake_news_with_translation(target_lang="tl")
         if df_tl_fake is not None:
             frames.append(df_tl_fake)
+        tl_aug_count = len(df_tl_fake) if df_tl_fake is not None else 0
+        total_tl_fake = tl_satire_count + tl_aug_count
+        print(f"  Total Tagalog fakes available: {total_tl_fake} ({tl_satire_count} satire + {tl_aug_count} augmented)")  # noqa: E501
+
+        # [4] BalitaNLP — Tagalog real news, capped to total fake count (undersampling)
+        df4 = _load_balitanlp_as_dataframe()
+        if df4 is not None:
+            if total_tl_fake > 0 and len(df4) > total_tl_fake:
+                print(
+                    f"  [4] Undersampling BalitaNLP: "
+                    f"{len(df4):,} → {total_tl_fake:,} (matching {total_tl_fake} fake articles)"
+                )
+                df4 = df4.sample(n=total_tl_fake, random_state=42).reset_index(drop=True)
+            frames.append(df4)
 
     else:
         # ── Mixed mode: all datasets, no language filter ──
@@ -1140,12 +1175,32 @@ def load_fake_news_dataset(
         # [4] BalitaNLP — skipped in mixed mode (use --tagalog-only to include)
         print("  [4] LanceBunag/BalitaNLP: skipped (use --tagalog-only to include)")
 
+    # [5] Facebook satire posts — included in mixed mode only.
+    #     In tagalog_only mode, satire is loaded above as [sat] PRIORITY.
+    #     In cebuano_only mode, satire is Tagalog/Filipino and not relevant.
+    if not tagalog_only and not cebuano_only:
+        csv_satire = os.path.join(PROJECT_ROOT, "data", "raw", "satire_facebook.csv")
+        if os.path.exists(csv_satire):
+            df_satire = pd.read_csv(csv_satire)
+            if "article" in df_satire.columns:
+                df_satire = df_satire[["article"]].dropna().copy()
+                df_satire = df_satire[df_satire["article"].str.split().str.len() >= 5]
+                df_satire["label"] = 1  # satire = Fake
+                print(
+                    f"  [5] Facebook satire (BreakingPHMemes): {len(df_satire)} posts "
+                    f"(all Fake/Satire)"
+                )
+                frames.append(df_satire)
+        else:
+            print("  [5] satire_facebook.csv not found — run scraper/scrape_satire_facebook.py to generate it")
+
     if not frames:
         raise FileNotFoundError(
             "No datasets found! Place at least one dataset in data/raw/."
         )
 
     # ── Merge and deduplicate ──
+
     df = pd.concat(frames, ignore_index=True)
     df = df.dropna(subset=["article"]).copy()
     df = df[df["article"].str.len() > 0].copy()
@@ -1180,11 +1235,12 @@ def preprocess(df, undersample=False, oversample=True):
 
     Balancing strategy (applied in order of preference):
       1. oversample=True  — RandomOverSampler duplicates minority-class (Fake) rows
-                            until classes are equal. Preferred for small Tagalog/Cebuano
-                            datasets where downsampling would waste Real data.
+                            until classes are equal. Used for mixed-language mode
+                            where the real:fake ratio can be large.
       2. undersample=True — downsample the majority class (legacy fallback).
       Both: oversample is applied first, then undersample (rarely needed).
-      Neither: return data as-is (class_weight='balanced' in RF handles the rest).
+      Neither (language-specific modes): real news is already capped to match fake
+                            count at load time, so no resampling is needed here.
 
     class_weight='balanced' is ALSO set on the RandomForest, so even without
     resampling the model still penalises fake-news misclassification more.
@@ -1325,9 +1381,18 @@ def build_features(texts, tfidf=None, scaler=None, fit=False):
 # ───────────────────────────────────────────────────────────
 
 
-def train_model(X_texts, y_labels):
-    """Train a Random Forest with hybrid features and cross-validation."""
+def train_model(X_texts, y_labels, max_depth=20, min_samples_leaf=3):
+    """Train a Random Forest with hybrid features and cross-validation.
+
+    Args:
+        max_depth (int): Maximum tree depth. Use lower values (8-10) for small or
+            homogeneous datasets (e.g. Cebuano) to prevent memorizing source-format
+            artifacts instead of genuine fake-news signals.
+        min_samples_leaf (int): Minimum samples at a leaf. Higher values (5+) add
+            regularization and reduce overfitting on small datasets.
+    """
     label_names = ["Real", "Fake"]
+    print(f"  Hyperparameters: max_depth={max_depth}, min_samples_leaf={min_samples_leaf}")
 
     # ── Split data (80/10/10) ──
     print("\nSplitting data (80/10/10)...")
@@ -1362,9 +1427,9 @@ def train_model(X_texts, y_labels):
     print("\nRunning 5-Fold Cross-Validation on training set...")
     rf_cv = RandomForestClassifier(
         n_estimators=500,
-        max_depth=20,
+        max_depth=max_depth,
         min_samples_split=5,
-        min_samples_leaf=3,
+        min_samples_leaf=min_samples_leaf,
         class_weight="balanced",
         n_jobs=-1,
         random_state=42,
@@ -1379,9 +1444,9 @@ def train_model(X_texts, y_labels):
     start_time = time.time()
     rf = RandomForestClassifier(
         n_estimators=500,
-        max_depth=20,
+        max_depth=max_depth,
         min_samples_split=5,
-        min_samples_leaf=3,
+        min_samples_leaf=min_samples_leaf,
         class_weight="balanced",
         n_jobs=-1,
         random_state=42,
@@ -1542,12 +1607,24 @@ def main():
     )
 
     # 2. Preprocess
-    # undersample=False: keep ALL real articles — RandomForest's class_weight='balanced'
-    # already compensates for imbalance without discarding training data.
-    X_texts, y_labels = preprocess(df, undersample=False)
+    # For language-specific modes (tagalog/cebuano), real news is already
+    # undersampled to match fake count at load time — no oversampling needed.
+    # For mixed mode, classes are imbalanced so oversample=True is kept.
+    lang_specific = args.tagalog_only or args.cebuano_only
+    X_texts, y_labels = preprocess(df, undersample=False, oversample=not lang_specific)
 
     # 3. Train & evaluate
-    model, vectorizer, scaler, metrics = train_model(X_texts, y_labels)
+    # Cebuano-only: reduce model complexity to prevent memorizing source-format
+    # artifacts (machine-translated fakes vs. native CebuaNER text). Lower
+    # max_depth forces the model to use weaker, more-generalizable signals.
+    if args.cebuano_only:
+        model, vectorizer, scaler, metrics = train_model(
+            X_texts, y_labels,
+            max_depth=8,
+            min_samples_leaf=5,
+        )
+    else:
+        model, vectorizer, scaler, metrics = train_model(X_texts, y_labels)
 
     # 4. Save
     print("\n" + "=" * 60)

check_app/pubspec.lock

@@ -148,10 +148,10 @@ packages:
     dependency: transitive
     description:
       name: matcher
-      sha256: "12956d0ad8390bbcc63ca2e1469c0619946ccb52809807067a7020d57e647aa6"
+      sha256: dc0b7dc7651697ea4ff3e69ef44b0407ea32c487a39fff6a4004fa585e901861
       url: "https://pub.dev"
     source: hosted
-    version: "0.12.18"
+    version: "0.12.19"
   material_color_utilities:
     dependency: transitive
     description:
@@ -321,10 +321,10 @@ packages:
     dependency: transitive
     description:
       name: test_api
-      sha256: "93167629bfc610f71560ab9312acdda4959de4df6fac7492c89ff0d3886f6636"
+      sha256: "8161c84903fd860b26bfdefb7963b3f0b68fee7adea0f59ef805ecca346f0c7a"
       url: "https://pub.dev"
     source: hosted
-    version: "0.7.9"
+    version: "0.7.10"
   typed_data:
     dependency: transitive
     description:

check_article.py

@@ -170,6 +170,86 @@ def explain_sources(db_results, web_results, top_score):
     return lines
 
 
+def display_pattern_deviation(pd):
+    """Display the Pattern Deviation Check section."""
+    print("=" * 60)
+    print("  PATTERN DEVIATION CHECK")
+    print("  Does this article follow the reputable news pattern?")
+    print("=" * 60)
+
+    verdict = pd.get("verdict", "")
+    deviation_score = pd.get("deviation_score", 0.0)
+    extra_claims = pd.get("extra_claims", [])
+    corroborated = pd.get("corroborated_claims", [])
+    all_titles = pd.get("all_source_titles", [])
+    reliable_count = pd.get("reliable_source_count", 0)
+
+    if verdict == "NO EXTERNAL SOURCES":
+        print("  No external sources available for pattern comparison.")
+        print()
+        return
+
+    # External pattern preview
+    print(f"  Based on {len(all_titles)} external source(s)")
+    if reliable_count > 0:
+        print(f"  ({reliable_count} from known reliable sources):")
+    else:
+        print("  (no known reliable sources):")
+    for title, source in all_titles[:4]:
+        src_label = f" [{source}]" if source else ""
+        print(f"    • \"{title[:90]}\"{src_label}")
+    if len(all_titles) > 4:
+        print(f"    • …and {len(all_titles) - 4} more")
+    print()
+
+    # Corroborated claims
+    if corroborated:
+        print(f"  ✔ Corroborated ({len(corroborated)} sentence(s) align with external sources):")
+        for s in corroborated[:2]:
+            print(f"    → \"{s[:100]}{'...' if len(s) > 100 else ''}\"")
+        print()
+
+    # Extra claims (deviations)
+    if extra_claims:
+        print(f"  ⚠️  Extra claims not found in reputable sources ({len(extra_claims)} sentence(s)):")
+        for s in extra_claims[:4]:
+            print(f"    → \"{s[:100]}{'...' if len(s) > 100 else ''}\"")
+        if len(extra_claims) > 4:
+            print(f"    …and {len(extra_claims) - 4} more")
+        print()
+    else:
+        print("  ✔ No extra claims detected — article stays within the reported facts.")
+        print()
+
+    # Deviation score bar
+    bar_filled = int(deviation_score * 20)
+    bar = "█" * bar_filled + "░" * (20 - bar_filled)
+    print(f"  Deviation score: {deviation_score:.0%}  [{bar}]")
+
+    # Verdict with icon
+    VERDICT_ICONS = {
+        "FOLLOWS PATTERN": "✅",
+        "MINOR DEVIATION": "🟡",
+        "SIGNIFICANT DEVIATION": "🟠",
+    }
+    icon = VERDICT_ICONS.get(verdict, "⚠️")
+    print(f"  Verdict: {icon} {verdict}")
+
+    if verdict == "FOLLOWS PATTERN":
+        print("  ➤ The article's claims are consistent with what reputable sources report.")
+    elif verdict == "MINOR DEVIATION":
+        print(
+            "  ➤ The article mostly follows reputable reporting but includes "
+            "some claims that could not be corroborated externally. Verify those claims."
+        )
+    elif verdict == "SIGNIFICANT DEVIATION":
+        print(
+            "  ➤ BIAS SIGNAL: The article adds substantial claims not found in "
+            "any reputable external source. These additions are the likely source of bias."
+        )
+    print()
+
+
 def get_user_input():
     """Read multi-line input from user (2 blank lines or 'done' to stop)."""
     print("=" * 60)
@@ -433,6 +513,11 @@ def display_results(result):
             print(line)
         print()
 
+    # Pattern Deviation Check
+    pattern_deviation = result.get("pattern_deviation")
+    if pattern_deviation and pattern_deviation.get("verdict") != "NO EXTERNAL SOURCES":
+        display_pattern_deviation(pattern_deviation)
+
     # 5. Date Flags (if any)
     if date_flags:
         print("=" * 60)

checker/external/pattern_deviation.py

@@ -0,0 +1,216 @@
+"""
+Pattern Deviation Analyzer
+===========================
+Implements the student journalist mental model for bias detection:
+
+  1. Build a "reputable pattern" from external news titles/snippets
+     (Google News + local DB results from reliable sources).
+  2. Compare every article sentence against that pattern.
+  3. Sentences whose concepts are NOT present in ANY reputable source
+     are surfaced as "extra claims" — possible bias signals.
+
+No new dependencies — uses the MiniLM model already loaded by the project
+(sentence_transformers) for semantic similarity.
+"""
+
+import re
+from typing import List, Dict, Any, Tuple
+
+# Reliable source identifiers (same list as check_article.py)
+RELIABLE_SOURCES = {
+    "inquirer", "philstar", "manila bulletin", "abs-cbn",
+    "cnn philippines", "gma", "rappler", "sunstar",
+    "businessmirror", "pna", "philippine news agency",
+    "bbc", "reuters", "ap", "associated press",
+    "new york times", "the guardian",
+}
+
+# Thresholds
+SENTENCE_SIMILARITY_THRESHOLD = 0.65  # Below this → sentence not in external pattern (raised from 0.40 as MiniLM baseline is high)
+DEVIATION_MINOR_THRESHOLD = 0.30      # deviation_score >= this → MINOR DEVIATION
+DEVIATION_SIGNIFICANT_THRESHOLD = 0.55  # deviation_score >= this → SIGNIFICANT DEVIATION
+
+# Cap how many sentences we analyze (performance guard for long articles)
+MAX_SENTENCES = 20
+
+
+def _is_reliable(source: str) -> bool:
+    src = source.lower()
+    return any(r in src for r in RELIABLE_SOURCES)
+
+
+def _split_sentences(text: str) -> List[str]:
+    """Naively split text into sentences on . ! ? boundaries."""
+    raw = re.split(r"(?<=[.!?])\s+", text.strip())
+    # Filter very short fragments (less than 5 words)
+    return [s.strip() for s in raw if len(s.split()) >= 5]
+
+
+def build_external_pattern(web_results: List[Dict], db_results: List[Dict]) -> str:
+    """
+    Concatenate titles from reliable web and DB sources into a single
+    'pattern string' representing what reputable journalism says on this topic.
+
+    Returns:
+        str: Combined pattern text, or empty string if no reliable sources found.
+    """
+    fragments = []
+
+    for r in web_results:
+        source = r.get("source", "")
+        title = r.get("title", "").strip()
+        if title and _is_reliable(source):
+            fragments.append(title)
+
+    for r in db_results:
+        source = r.get("source", "")
+        title = r.get("title", "").strip()
+        if title and _is_reliable(source):
+            fragments.append(title)
+
+    # Fall back to ALL sources (reliable or not) if none found
+    if not fragments:
+        for r in web_results + db_results:
+            title = r.get("title", "").strip()
+            if title:
+                fragments.append(title)
+
+    return " | ".join(fragments)
+
+
+def _get_minilm():
+    """Lazy import of MiniLM to avoid circular imports."""
+    from checker.internal.core import get_minilm_model
+    return get_minilm_model()
+
+
+def _cosine(a, b) -> float:
+    """Compute cosine similarity between two numpy vectors."""
+    import numpy as np
+    norm_a = float(np.linalg.norm(a))
+    norm_b = float(np.linalg.norm(b))
+    if norm_a == 0 or norm_b == 0:
+        return 0.0
+    return float(np.dot(a, b) / (norm_a * norm_b))
+
+
+def compare_to_external_pattern(
+    article_text: str,
+    web_results: List[Dict],
+    db_results: List[Dict] = None,
+) -> Dict[str, Any]:
+    """
+    Compare the article's sentences against the external reputable pattern.
+
+    For each article sentence, measure the maximum cosine similarity to the
+    external pattern string (encoded as a single MiniLM embedding).  Sentences
+    below SENTENCE_SIMILARITY_THRESHOLD are flagged as 'extra claims' — content
+    that does not appear in any reputable external source.
+
+    Args:
+        article_text (str): The full article or claim to analyze.
+        web_results (list): Google News results (dicts with 'title', 'source').
+        db_results (list): Local DB results (dicts with 'title', 'source').
+
+    Returns:
+        dict with keys:
+            - external_pattern (str): Summary of what reputable sources say.
+            - extra_claims (list[str]): Sentences not found in external pattern.
+            - corroborated_claims (list[str]): Sentences aligned with pattern.
+            - deviation_score (float): 0–1 fraction of sentences that deviate.
+            - verdict (str): "FOLLOWS PATTERN" | "MINOR DEVIATION" | "SIGNIFICANT DEVIATION"
+            - reliable_source_count (int): Number of reliable sources used.
+            - all_source_titles (list[str]): All titles from external sources.
+    """
+    if db_results is None:
+        db_results = []
+
+    # ── Build external pattern ──────────────────────────────────────────────
+    external_pattern = build_external_pattern(web_results, db_results)
+
+    # Collect all titles for display
+    all_titles = []
+    for r in web_results + db_results:
+        t = r.get("title", "").strip()
+        if t:
+            all_titles.append((t, r.get("source", "")))
+
+    reliable_count = sum(1 for r in web_results + db_results if _is_reliable(r.get("source", "")))
+
+    # If no external sources at all, can't compare
+    if not external_pattern.strip():
+        return {
+            "external_pattern": "",
+            "extra_claims": [],
+            "corroborated_claims": [],
+            "deviation_score": 0.0,
+            "verdict": "NO EXTERNAL SOURCES",
+            "reliable_source_count": 0,
+            "all_source_titles": [],
+        }
+
+    # ── Split article into sentences ────────────────────────────────────────
+    sentences = _split_sentences(article_text)[:MAX_SENTENCES]
+
+    if not sentences:
+        return {
+            "external_pattern": external_pattern,
+            "extra_claims": [],
+            "corroborated_claims": [],
+            "deviation_score": 0.0,
+            "verdict": "FOLLOWS PATTERN",
+            "reliable_source_count": reliable_count,
+            "all_source_titles": all_titles,
+        }
+
+    # ── Embed all sentences + pattern in one batched call ──────────────────
+    try:
+        minilm = _get_minilm()
+        all_texts = sentences + [external_pattern]
+        embeddings = minilm.encode(all_texts, batch_size=64, show_progress_bar=False)
+        sentence_embeddings = embeddings[:len(sentences)]
+        pattern_embedding = embeddings[-1]
+    except Exception:
+        # Graceful degradation — can't run MiniLM, return neutral result
+        return {
+            "external_pattern": external_pattern,
+            "extra_claims": [],
+            "corroborated_claims": list(sentences),
+            "deviation_score": 0.0,
+            "verdict": "FOLLOWS PATTERN",
+            "reliable_source_count": reliable_count,
+            "all_source_titles": all_titles,
+        }
+
+    # ── Classify each sentence ──────────────────────────────────────────────
+    extra_claims: List[str] = []
+    corroborated_claims: List[str] = []
+
+    for sent, emb in zip(sentences, sentence_embeddings):
+        sim = _cosine(emb, pattern_embedding)
+        if sim < SENTENCE_SIMILARITY_THRESHOLD:
+            extra_claims.append(sent)
+        else:
+            corroborated_claims.append(sent)
+
+    # ── Compute deviation score ─────────────────────────────────────────────
+    total = len(sentences)
+    deviation_score = round(len(extra_claims) / total, 3) if total > 0 else 0.0
+
+    # ── Determine verdict ───────────────────────────────────────────────────
+    if deviation_score >= DEVIATION_SIGNIFICANT_THRESHOLD:
+        verdict = "SIGNIFICANT DEVIATION"
+    elif deviation_score >= DEVIATION_MINOR_THRESHOLD:
+        verdict = "MINOR DEVIATION"
+    else:
+        verdict = "FOLLOWS PATTERN"
+
+    return {
+        "external_pattern": external_pattern,
+        "extra_claims": extra_claims,
+        "corroborated_claims": corroborated_claims,
+        "deviation_score": deviation_score,
+        "verdict": verdict,
+        "reliable_source_count": reliable_count,
+        "all_source_titles": all_titles,
+    }

checker/fact_checker.py

@@ -25,6 +25,7 @@ from checker.internal.core import (
 )
 from checker.external.core import ExternalChecker
 from checker.external.claim_verifier import check_claims
+from checker.external.pattern_deviation import compare_to_external_pattern
 from scipy.sparse import hstack, csr_matrix
 
 
@@ -74,45 +75,56 @@ class FactChecker:
         # Use cleaned text for pipeline, but keep original for reference
         analysis_text = cleaned_for_analysis if cleaned_for_analysis else text
 
-        # 2. Internal check (ML model + bias)
-        internal_result = self.internal.check(analysis_text)
-
-        # 3. External check (DB + web)
+        # 2. External check (DB + web) — must run before pattern deviation
         # Use headline for external search if provided — headlines make much
         # better search queries than full article bodies.
         search_query = headline if headline else analysis_text
         external_result = self.external.check_claim(search_query)
 
-        # 4. Extract time-orientation scores from stylometric features
+        # 3. Pattern deviation — runs FIRST before internal bias analysis so its
+        #    result can be fed directly into analyze_bias() as a primary signal.
+        pattern_deviation = compare_to_external_pattern(
+            analysis_text,
+            web_results=external_result.get("web_results", []),
+            db_results=external_result.get("db_results", []),
+        )
+
+        # 4. Internal check (ML model + bias), pattern_deviation passed in so
+        #    bias_analyzer can weight deviating articles as more sensational/biased.
+        internal_result = self.internal.check(analysis_text, pattern_deviation=pattern_deviation)
+
+        # 5. Extract time-orientation scores from stylometric features
         stylo = extract_stylometric_features(clean_text(analysis_text))
         present_focus = stylo[23] if len(stylo) > 23 else 0.0
 
-        # 5. Date validation
+        # 6. Date validation
         article_date, date_flags = self._validate_dates(external_result, present_focus)
 
-        # 6. Combine verdicts (with date and obfuscation awareness)
+        # 7. Combine verdicts (pattern_deviation weighted more heavily)
         obfuscated = internal_result.get("bias", {}).get("obfuscated_text", False)
         final_verdict, final_details = self._combine_verdicts(
-            internal_result, external_result, date_flags, obfuscated=obfuscated
+            internal_result, external_result, date_flags,
+            obfuscated=obfuscated, pattern_deviation=pattern_deviation
         )
 
-        # 7. Classify misinformation type using existing signals
+        # 8. Classify misinformation type using existing signals
         obfuscated = internal_result.get("bias", {}).get("obfuscated_text", False)
         misinfo_type = self._classify_misinfo_type(
-            internal_result, external_result, date_flags, obfuscated=obfuscated
+            internal_result, external_result, date_flags,
+            obfuscated=obfuscated, pattern_deviation=pattern_deviation
         )
 
-        # 8. LIME explanation (why the ML model decided Real or Fake)
+        # 9. LIME explanation (why the ML model decided Real or Fake)
         # Use cleaned text so URL fragments don't appear as contributing words
         lime_samples = int(os.environ.get("LIME_SAMPLES", 100))
         lime_explanation = self.explain(analysis_text, num_samples=lime_samples)
 
-        # 9. Headline-body consistency check (if headline provided)
+        # 10. Headline-body consistency check (if headline provided)
         headline_analysis = None
         if headline and len(analysis_text) > len(headline) + 20:
             headline_analysis = self._check_headline_consistency(headline, analysis_text)
 
-        # 10. Lightweight claim verification (regex + existing Google News search)
+        # 11. Lightweight claim verification (regex + existing Google News search)
         web_results = external_result.get("web_results", [])
         topic_context = web_results[0]["title"] if web_results else ""
         claim_verification = check_claims(text, topic_context=topic_context)
@@ -132,6 +144,7 @@ class FactChecker:
             "lime_explanation": lime_explanation,
             "misinformation_type": misinfo_type,
             "claim_verification": claim_verification,
+            "pattern_deviation": pattern_deviation,
         }
         if headline_analysis:
             result["headline_analysis"] = headline_analysis
@@ -312,7 +325,7 @@ class FactChecker:
         )
         return article_date_str, date_flags
 
-    def _classify_misinfo_type(self, internal, external, date_flags, obfuscated=False):
+    def _classify_misinfo_type(self, internal, external, date_flags, obfuscated=False, pattern_deviation=None):
         """
         Classify the type of misinformation using existing pipeline signals.
 
@@ -356,37 +369,56 @@ class FactChecker:
                 "(∆, leet-speak, ALL-CAPS) typical of sensationalized or manipulated social media posts."
             )
 
-        # Priority 1: Old news being shared as current
+        # Priority 1: Pattern deviation — promoted above old-news check because
+        # an article that adds claims not in ANY reputable source is a stronger
+        # and more specific signal than recirculated date information.
+        if pattern_deviation and pattern_deviation.get("verdict") == "SIGNIFICANT DEVIATION":
+            if has_external:
+                return (
+                    "🟠 Added Claims / Spin — A real event is covered by reputable sources, "
+                    "but this version adds claims not corroborated by any of them"
+                )
+            else:
+                return (
+                    "🔴 Unverifiable Added Claims — This article makes specific claims "
+                    "that do not appear in any reputable source found online"
+                )
+
+        if pattern_deviation and pattern_deviation.get("verdict") == "MINOR DEVIATION":
+            if not has_external:
+                return "🟡 Possible Spin — Article makes claims not confirmed by any reputable coverage found"
+
+        # Priority 2: Old news being shared as current
         if is_old_news:
             return "🚩 Old News Recirculated — Real event, but being shared as if it's current news"
 
-        # Priority 2: Out of context (real story, old source, not ML-flagged as fake)
+        # Priority 3: Out of context (real story, old source, not ML-flagged as fake)
         if has_date_flag and has_external and ml_verdict != "Fake":
             return "🟡 Out of Context — The referenced event is real but may be misrepresenting its timeframe or circumstances"
 
-        # Priority 3: Misleading headline (external story exists, but ML flags content as fake)
+        # Priority 4: Misleading headline (external story exists, but ML flags content as fake)
         if has_external and ml_verdict == "Fake":
             return "🟠 Misleading Headline — A real event exists, but this version appears to distort or misrepresent the facts"
 
-        # Priority 4: Fabricated (high-confidence fake, no external coverage at all)
+        # Priority 5: Fabricated (high-confidence fake, no external coverage at all)
         if ml_verdict == "Fake" and ml_confidence >= 0.70 and not has_external:
             return "🔴 Fabricated — No credible coverage found and ML model flags content as likely fabricated"
 
-        # Priority 5: Soft fake signal but no external coverage
+        # Priority 6: Soft fake signal but no external coverage
         if ml_verdict == "Fake" and not has_external:
             return "🔴 Likely Fabricated — No external coverage found; ML model suggests this may be fabricated (moderate confidence)"
 
-        # Priority 6: Verified/strong external match with no fake signal = clean
+        # Priority 7: Verified/strong external match with no fake signal = clean
         if ext_verdict == "VERIFIED":
             return "✅ No misinformation detected — Article verified by matching news sources"
 
-        # Priority 7: Unverified claim (no external coverage, ML not confident either way)
+        # Priority 8: Unverified claim (no external coverage, ML not confident either way)
         if ext_verdict == "UNVERIFIED":
             return "⚠️ Unverifiable — No matching coverage found to confirm or deny this claim"
 
         return "✅ No misinformation type detected"
 
-    def _combine_verdicts(self, internal, external, date_flags=None, obfuscated=False):
+    def _combine_verdicts(self, internal, external, date_flags=None, obfuscated=False, pattern_deviation=None):
         """
         Combine internal ML verdict with external source verification.
 
@@ -435,26 +467,54 @@ class FactChecker:
             ml_confidence = max(0.0, ml_confidence - SOURCE_PENALTY)
 
         # ── Build verdict and details ──
+        # Check pattern deviation before issuing final VERIFIED — high deviation
+        # means the article adds extra claims beyond what sources report.
+        pd_verdict = (pattern_deviation or {}).get("verdict", "")
+        pd_score = (pattern_deviation or {}).get("deviation_score", 0.0)
+        significant_deviation = pd_verdict == "SIGNIFICANT DEVIATION"
+
         if ext_verdict == "VERIFIED":
-            verdict = "VERIFIED"
-            details = (
-                f"This article matches verified news sources "
-                f"(similarity: {top_score:.0%})."
-            )
+            if significant_deviation:
+                # Downgrade: story exists but article adds unreported claims
+                verdict = "COVERAGE FOUND — PATTERN DEVIATION"
+                details = (
+                    f"This topic is covered by reputable sources (similarity: {top_score:.0%}), "
+                    f"but the article adds claims not found in those sources "
+                    f"(deviation score: {pd_score:.0%})."
+                )
+            else:
+                verdict = "VERIFIED"
+                details = (
+                    f"This article matches verified news sources "
+                    f"(similarity: {top_score:.0%})."
+                )
             if source_count > 1:
                 details += f" {source_count} corroborating sources found."
         elif ext_verdict == "COVERAGE_FOUND_ONLINE":
-            verdict = "COVERAGE FOUND ONLINE"
-            source_word = "source" if len(web_results) == 1 else "sources"
-            details = (
-                f"Covered by {len(web_results)} online news {source_word}. "
-                "Review the related sources below to verify."
-            )
+            if significant_deviation:
+                # Also downgrade online coverage when deviation is significant
+                verdict = "BIASED COVERAGE — PATTERN DEVIATION"
+                source_word = "source" if len(web_results) == 1 else "sources"
+                details = (
+                    f"Found {len(web_results)} online news {source_word}, but the article "
+                    f"adds claims not present in those sources (deviation score: {pd_score:.0%}). "
+                    "This article may be spinning or exaggerating a real event."
+                )
+            else:
+                verdict = "COVERAGE FOUND ONLINE"
+                source_word = "source" if len(web_results) == 1 else "sources"
+                details = (
+                    f"Covered by {len(web_results)} online news {source_word}. "
+                    "Review the related sources below to verify."
+                )
         elif ext_verdict == "WEAK_MATCH":
             verdict = "WEAK MATCH"
             details = "Some loosely related articles were found, but no strong match. Review carefully."
         else:
             # No external sources — rely on internal ML model
+            # Apply additional confidence penalty when deviation is high but ML says Real
+            if significant_deviation and ml_verdict == "Real":
+                ml_confidence = max(0.0, ml_confidence - 0.10)
             if ml_verdict == "Fake":
                 verdict = "LIKELY FAKE"
                 details = (

checker/internal/bias_analyzer.py

@@ -1245,21 +1245,30 @@ def _score_political_figures(text_lower):
 # ── Main function ─────────────────────────────────────────────────────────────
 
 
-def analyze_bias(text):
+def analyze_bias(text, pattern_deviation=None):
     """Analyze a news article for political bias and subjectivity.
 
+    Args:
+        text (str): Article text.
+        pattern_deviation (dict|None): Result from compare_to_external_pattern().
+            When provided, deviation from reputable sources directly boosts
+            sensationalism score and leaning confidence — making pattern deviation
+            a primary signal rather than a post-hoc annotation.
+
     Returns:
         dict with keys:
-            leaning:            "Conservative", "Admin/Right", "Left-leaning", or "Centrist"
-            is_biased:          bool — True if clearly leaning or sensational
-            unsourced_claim:    bool — True if article appears to be a blind item / chismis
-            unsourced_score:    int  — raw unsourced claim score
-            subjectivity:       float (0-1)
-            subjectivity_flag:  bool
-            vader_compound:     float
-            vader_biased:       bool
-            confidence:         float (0-1)
-            details:            dict with full breakdown
+            leaning:                    "Conservative", "Admin/Right", "Left-leaning", or "Centrist"
+            is_biased:                  bool — True if clearly leaning or sensational
+            unsourced_claim:            bool — True if article appears to be a blind item / chismis
+            unsourced_score:            int  — raw unsourced claim score
+            subjectivity:               float (0-1)
+            subjectivity_flag:          bool
+            vader_compound:             float
+            vader_biased:               bool
+            confidence:                 float (0-1)
+            pattern_deviation_verdict:  str — "FOLLOWS PATTERN", "MINOR DEVIATION", "SIGNIFICANT DEVIATION", or ""
+            deviation_score:            float — 0.0–1.0 fraction of sentences not in reputable sources
+            details:                    dict with full breakdown
     """
     if not text or not isinstance(text, str) or len(text.strip()) < 20:
         return {
@@ -1327,6 +1336,20 @@ def analyze_bias(text):
     if vader_biased:
         sensationalism_score += 3
 
+    # ── Pattern deviation boost (primary signal when available) ────────────────
+    # Deviation from reputable external sources is treated as a strong bias
+    # indicator: articles that add claims not found in any credible source are
+    # more likely to be biased or sensationalized, regardless of keyword matches.
+    pd_verdict = (pattern_deviation or {}).get("verdict", "")
+    pd_score = (pattern_deviation or {}).get("deviation_score", 0.0)
+    pd_confidence_boost = 0.0
+
+    if pd_verdict == "SIGNIFICANT DEVIATION":
+        sensationalism_score += 3   # strong signal: adds claims no credible source reports
+        pd_confidence_boost = 0.08  # more certain about the detected leaning
+    elif pd_verdict == "MINOR DEVIATION":
+        sensationalism_score += 1   # mild signal
+
     # ── Determine leaning ──
     total_political = right_score + left_score
     bias_threshold = 3  # raised slightly since we now have more signal sources
@@ -1344,11 +1367,11 @@ def analyze_bias(text):
         else:
             leaning = "Admin/Right"
         diff = right_score - left_score
-        confidence = min(0.95, 0.5 + diff * 0.08 + sensationalism_score * 0.02)
+        confidence = min(0.95, 0.5 + diff * 0.08 + sensationalism_score * 0.02 + pd_confidence_boost)
     elif left_score > right_score:
         leaning = "Left-leaning"
         diff = left_score - right_score
-        confidence = min(0.95, 0.5 + diff * 0.08 + sensationalism_score * 0.02)
+        confidence = min(0.95, 0.5 + diff * 0.08 + sensationalism_score * 0.02 + pd_confidence_boost)
     else:
         leaning = "Centrist"
         confidence = 0.45 if sensationalism_score >= 4 else 0.7
@@ -1374,6 +1397,8 @@ def analyze_bias(text):
         "vader_compound": round(vader_compound, 4),
         "vader_biased": vader_biased,
         "confidence": round(min(confidence, 1.0), 4),
+        "pattern_deviation_verdict": pd_verdict,
+        "deviation_score": round(pd_score, 4),
         "details": {
             "left_keywords": left_hits,
             "right_keywords": right_hits,
@@ -1390,5 +1415,7 @@ def analyze_bias(text):
             "liberal_score": liberal_score,
             "evidence_score": evidence_score,
             "sensationalism_score": sensationalism_score,
+            "pattern_deviation_verdict": pd_verdict,
+            "deviation_score": round(pd_score, 4),
         },
     }

checker/internal/core.py

@@ -460,11 +460,19 @@ class InternalChecker:
 
     # ── Public interface ──────────────────────────────────────────────
 
-    def check(self, text):
-        """Run validation, bias analysis, and journalism structure check."""
+    def check(self, text, pattern_deviation=None):
+        """Run validation, bias analysis, and journalism structure check.
+
+        Args:
+            text (str): Article text to analyze.
+            pattern_deviation (dict|None): Pre-computed pattern deviation result
+                from compare_to_external_pattern(). When provided, it is passed
+                directly into analyze_bias() so deviation from reputable sources
+                acts as a primary bias signal rather than a post-hoc annotation.
+        """
         return {
             "validation": self._validate(text),
-            "bias": analyze_bias(text),
+            "bias": analyze_bias(text, pattern_deviation=pattern_deviation),
             "structure": analyze_structure(text),
         }
 

scraper/collect_satire_manual.py

@@ -0,0 +1,108 @@
+"""
+Manual Satire Post Collector
+==============================
+Since automated Facebook scraping is unreliable, this script lets you
+manually paste posts one-by-one (or in batches) and saves them to the
+same satire_facebook.csv that train.py expects.
+
+Usage:
+    python scraper/collect_satire_manual.py
+
+Just open the Facebook page, copy the post text, paste it here, press Enter twice.
+Type 'done' when finished. Type 'quit' to exit without saving.
+"""
+
+import os
+import csv
+
+OUTPUT_PATH = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+    "data", "raw", "satire_facebook.csv"
+)
+MIN_WORD_COUNT = 10
+
+
+def get_multiline_input(prompt=""):
+    """Read a multi-line paste. Two blank lines or 'done' finishes input."""
+    if prompt:
+        print(prompt)
+    lines = []
+    blank_streak = 0
+    while True:
+        try:
+            line = input()
+        except EOFError:
+            break
+        stripped = line.strip().lower()
+        if stripped == "quit":
+            return None
+        if stripped == "done" and not lines:
+            return "DONE"
+        if line == "":
+            blank_streak += 1
+            if blank_streak >= 2:
+                break
+        else:
+            blank_streak = 0
+            lines.append(line)
+    return " ".join(lines).strip()
+
+
+def save(posts, path):
+    exists = os.path.exists(path)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "a", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=["article", "label"])
+        if not exists:
+            writer.writeheader()
+        writer.writerows(posts)
+
+
+def main():
+    print("=" * 58)
+    print("  MANUAL SATIRE POST COLLECTOR — BreakingPHMemes")
+    print("=" * 58)
+    print()
+    print("Open https://www.facebook.com/BreakingPHMemes in your browser.")
+    print("Copy a post's text, paste it below, then press Enter twice.")
+    print("Type 'done' on an empty line when finished.")
+    print("Type 'quit' to exit without saving.")
+    print()
+
+    collected = 0
+    post_num = 1
+
+    while True:
+        text = get_multiline_input(f"--- Post #{post_num} (paste text, Enter x2 to confirm) ---")
+
+        if text is None:  # quit
+            print("\nExiting without saving.")
+            return
+
+        if text == "DONE" or text == "":
+            break
+
+        word_count = len(text.split())
+        if word_count < MIN_WORD_COUNT:
+            print(f"  [skip] Too short ({word_count} words, need {MIN_WORD_COUNT}+). Try again.\n")
+            continue
+
+        # Auto-save immediately — no data lost if you Ctrl+C
+        save([{"article": text, "label": 1}], OUTPUT_PATH)
+        collected += 1
+        print(f"  ✓ Auto-saved ({word_count} words). Total in file: {collected}\n")
+        post_num += 1
+
+    if collected == 0:
+        print("No posts collected.")
+        return
+
+    print(f"\n{'=' * 58}")
+    print(f"  Session complete — {collected} new post(s) saved.")
+    print(f"  File: {OUTPUT_PATH}")
+    print(f"  Now retrain with: python backend/train.py")
+    print(f"{'=' * 58}")
+
+
+if __name__ == "__main__":
+    main()

survey_form.txt

@@ -0,0 +1,281 @@
+================================================================================
+   DOCUMENT NO.: FC-SURVEY-001          VERSION: 1.0          DATE: 2026-03-25
+================================================================================
+
+              USER SATISFACTION AND SYSTEM EVALUATION SURVEY
+           FactCheck: A Multilingual Filipino Fake News Detection System
+
+                         Controlled Document — ISO 9001:2015
+          Quality Objective: Measure user satisfaction and system effectiveness
+                         to support continual improvement (Clause 9.1.2)
+
+================================================================================
+INSTRUCTIONS TO RESPONDENTS
+================================================================================
+
+This survey is part of a quality evaluation study for the FactCheck system, a
+multilingual (Filipino/Tagalog, Cebuano, English) AI-based fake news detection
+tool. Your honest responses will directly inform the improvement of the system.
+
+Target Respondents : Students enrolled in a Bachelor of Arts in Journalism
+                     or related Communication programs.
+Estimated Time     : 10–15 minutes
+Confidentiality    : Responses are anonymous and will be used solely for
+                     academic research and system improvement purposes.
+Version Control    : This form is subject to review and revision under the
+                     project's Document Control procedure (ISO 9001 Clause 7.5).
+
+RATING SCALE:
+  ┌─────────────────┬───────┬─────────┬──────────┬───────────────────┐
+  │ Strongly Agree  │ Agree │ Neutral │ Disagree │ Strongly Disagree │
+  │       (5)       │  (4)  │   (3)   │   (2)    │        (1)        │
+  └─────────────────┴───────┴─────────┴──────────┴───────────────────┘
+
+Please write the number (1–5) in the space provided, or tick the appropriate
+box if a printed form is used. Leave no item blank; write N/A only if the
+feature was not available during your session.
+
+================================================================================
+PART I — RESPONDENT PROFILE
+================================================================================
+
+Name (optional)  : ___________________________________________________________
+Year Level       : □ 1st Year   □ 2nd Year   □ 3rd Year   □ 4th Year
+Major / Track    : ___________________________________________________________
+School           : ___________________________________________________________
+Date Accomplished: ___________________________________________________________
+
+Have you previously used any fact-checking tool or platform?
+  □ Yes (please specify): _______________________     □ No
+
+================================================================================
+PART II — SYSTEM QUALITY
+   (ISO 9001 Clause 8.5 — Refers to the technical reliability and correctness
+    of outputs produced by the system.)
+================================================================================
+
+                                                           5   4   3   2   1
+                                                          SA   A   N   D  SD
+                                                         ---  --  --  --  --
+ 1. The system correctly identifies fake news articles
+    most of the time.                                    [ ] [ ] [ ] [ ] [ ]
+
+ 2. The system correctly identifies real/legitimate
+    news articles most of the time.                      [ ] [ ] [ ] [ ] [ ]
+
+ 3. The system's verdict (Verified / Likely Fake /
+    Unverified) is accurate based on my journalism
+    knowledge.                                           [ ] [ ] [ ] [ ] [ ]
+
+ 4. The ML confidence score displayed reflects how
+    credible the article actually is.                    [ ] [ ] [ ] [ ] [ ]
+
+ 5. The pattern deviation feature (comparing the article
+    against reputable sources) provides useful and
+    accurate results.                                    [ ] [ ] [ ] [ ] [ ]
+
+ 6. The bias leaning classification (Left / Conservative
+    / Centrist / Admin-Right) is appropriate for the
+    Philippine media context.                            [ ] [ ] [ ] [ ] [ ]
+
+ 7. The system performs consistently across different
+    types of news articles (political, crime, health,
+    etc.).                                               [ ] [ ] [ ] [ ] [ ]
+
+================================================================================
+PART III — INFORMATION QUALITY
+   (ISO 9001 Clause 7.5 / 8.6 — Refers to the relevance, completeness, and
+    clarity of information presented to the user.)
+================================================================================
+
+                                                           5   4   3   2   1
+                                                          SA   A   N   D  SD
+                                                         ---  --  --  --  --
+ 8. The final verdict and details section clearly
+    explains why an article was flagged.                 [ ] [ ] [ ] [ ] [ ]
+
+ 9. The LIME explanation (word-level reasoning) helps
+    me understand which words contributed to the
+    fake/real decision.                                  [ ] [ ] [ ] [ ] [ ]
+
+10. The external source results (Google News / database
+    matches) are relevant to the article being checked. [ ] [ ] [ ] [ ] [ ]
+
+11. The misinformation type label (e.g., Fabricated,
+    Added Claims/Spin, Old News Recirculated) is
+    descriptive and informative.                         [ ] [ ] [ ] [ ] [ ]
+
+12. The pattern deviation output (extra claims vs.
+    corroborated claims) is easy to understand.         [ ] [ ] [ ] [ ] [ ]
+
+13. The unsourced claim / "blind item" detection is
+    relevant to how fake news spreads on Philippine
+    social media.                                        [ ] [ ] [ ] [ ] [ ]
+
+14. The system's output is complete enough for me to
+    make a journalism decision about an article.         [ ] [ ] [ ] [ ] [ ]
+
+================================================================================
+PART IV — USABILITY AND USER EXPERIENCE
+   (ISO 9001 Clause 9.1.2 — Customer satisfaction; refers to ease of use
+    and accessibility of the system interface.)
+================================================================================
+
+                                                           5   4   3   2   1
+                                                          SA   A   N   D  SD
+                                                         ---  --  --  --  --
+15. The system is easy to navigate and use without
+    prior technical training.                            [ ] [ ] [ ] [ ] [ ]
+
+16. The system responds within an acceptable amount
+    of time (speed is satisfactory).                     [ ] [ ] [ ] [ ] [ ]
+
+17. The output is presented in a clear, readable, and
+    well-organized format.                               [ ] [ ] [ ] [ ] [ ]
+
+18. I did not encounter any technical errors or crashes
+    during my use of the system.                         [ ] [ ] [ ] [ ] [ ]
+
+19. The terminology used in the outputs is
+    understandable to a journalism student.              [ ] [ ] [ ] [ ] [ ]
+
+================================================================================
+PART V — RELEVANCE TO JOURNALISM PRACTICE
+   (ISO 9001 Clause 6.1 / 8.2 — Addresses whether the system meets the
+    specific needs of its intended users — journalism students and practitioners.)
+================================================================================
+
+                                                           5   4   3   2   1
+                                                          SA   A   N   D  SD
+                                                         ---  --  --  --  --
+20. The system supports my ability to verify news
+    before publishing or sharing it.                     [ ] [ ] [ ] [ ] [ ]
+
+21. The multilingual support (Filipino/Tagalog, Cebuano,
+    English) is important for Philippine journalism.     [ ] [ ] [ ] [ ] [ ]
+
+22. I would recommend this tool to fellow journalism
+    students or practicing journalists.                  [ ] [ ] [ ] [ ] [ ]
+
+23. The bias analysis module would help newsrooms detect
+    editorial bias in their own content.                 [ ] [ ] [ ] [ ] [ ]
+
+24. The system would be a useful tool for fact-checking
+    social media posts in the Philippine context.        [ ] [ ] [ ] [ ] [ ]
+
+25. The satire detection capability is relevant to the
+    current fake news problem on Philippine social media.[ ] [ ] [ ] [ ] [ ]
+
+================================================================================
+PART VI — OVERALL SATISFACTION
+   (ISO 9001 Clause 9.1.2 — Overall customer satisfaction measurement.)
+================================================================================
+
+                                                           5   4   3   2   1
+                                                          SA   A   N   D  SD
+                                                         ---  --  --  --  --
+26. Overall, I am satisfied with the performance of
+    the FactCheck system.                                [ ] [ ] [ ] [ ] [ ]
+
+27. Overall, the system meets my expectations as a
+    journalism student.                                  [ ] [ ] [ ] [ ] [ ]
+
+28. I believe this system has potential for real-world
+    use in Philippine media organizations.               [ ] [ ] [ ] [ ] [ ]
+
+================================================================================
+PART VII — OPEN-ENDED QUESTIONS
+   (Qualitative data for continual improvement — ISO 9001 Clause 10.3)
+================================================================================
+
+29. What feature of the system did you find most useful? Why?
+
+    ________________________________________________________________________
+
+    ________________________________________________________________________
+
+    ________________________________________________________________________
+
+30. What aspect of the system needs the most improvement?
+
+    ________________________________________________________________________
+
+    ________________________________________________________________________
+
+    ________________________________________________________________________
+
+31. Were there any outputs or results that you found confusing or misleading?
+    Please provide a specific example if possible.
+
+    ________________________________________________________________________
+
+    ________________________________________________________________________
+
+    ________________________________________________________________________
+
+32. As a journalism student, what additional features would make this system
+    more useful in your daily work?
+
+    ________________________________________________________________________
+
+    ________________________________________________________________________
+
+    ________________________________________________________________________
+
+33. Any other comments or suggestions:
+
+    ________________________________________________________________________
+
+    ________________________________________________________________________
+
+    ________________________________________________________________________
+
+================================================================================
+SCORING AND INTERPRETATION GUIDE  (For Researcher Use Only)
+================================================================================
+
+   Score Range        Descriptive Interpretation
+   ──────────────     ──────────────────────────────────────────────────────
+   4.50 – 5.00        Excellent — Exceeds user expectations
+   3.50 – 4.49        Good — Meets user expectations with minor gaps
+   2.50 – 3.49        Fair — Partially meets expectations; improvement needed
+   1.50 – 2.49        Poor — Does not meet expectations; major revision needed
+   1.00 – 1.49        Very Poor — Fails to meet minimum acceptable standards
+
+   Weighted Mean Formula:
+     WM = Σ(f × w) / N
+     where f = frequency of responses, w = weight (1–5), N = total respondents
+
+   Reliability Target (ISO 9001 Clause 9.1.3):
+     Cronbach's Alpha ≥ 0.70 is required for instrument reliability.
+     Compute using statistical software (SPSS, R, or Python/pingouin) prior
+     to reporting results.
+
+================================================================================
+DOCUMENT CONTROL INFORMATION      (ISO 9001 Clause 7.5.2 / 7.5.3)
+================================================================================
+
+   Document Title    : User Satisfaction and System Evaluation Survey
+   Document No.      : FC-SURVEY-001
+   Version           : 1.0
+   Prepared by       : [Researcher Name / Institution]
+   Reviewed by       : [Thesis Adviser / Quality Representative]
+   Approved by       : [Department Chair / IRB / Ethics Committee]
+   Date Issued       : 2026-03-25
+   Review Schedule   : Prior to each data collection round, or upon major
+                       system update that affects surveyed features.
+   Status            : □ Draft   □ For Review   ■ Released   □ Superseded
+
+   REVISION HISTORY
+   ┌─────────┬────────────┬─────────────────────────────────┬──────────────┐
+   │ Version │    Date    │           Description           │  Revised By  │
+   ├─────────┼────────────┼─────────────────────────────────┼──────────────┤
+   │   1.0   │ 2026-03-25 │ Initial release                 │ [Author]     │
+   ├─────────┼────────────┼─────────────────────────────────┼──────────────┤
+   │         │            │                                 │              │
+   └─────────┴────────────┴─────────────────────────────────┴──────────────┘
+
+================================================================================
+                              END OF DOCUMENT
+           FC-SURVEY-001 v1.0 | FactCheck Multilingual Fake News Detector
+================================================================================