Phase 6 implemented

docs/progress.md

@@ -67,8 +67,18 @@ Do not read entire codebase to understand progress — read this file.
 ✅ r5_defender_preservation.py — rewritten to TF-IDF cosine sim (pyarrow DLL workaround)
 ✅ Phase 5 gate — submission_check 10/10 PASS, demo runs end-to-end
 
-## Phase 6 — [Pending]
-⏳ [feature name] — [one line description]
+## Phase 6 — Moderation Agent + Originality Agent
+✅ ModerationAgent — zero-LLM rule-based shadowban detection, 6 categories, severity mapping
+✅ OriginalityAgent — zero-LLM fuzzy template matching, difflib SequenceMatcher at 0.75 threshold
+✅ SafetyReward (R6) — hard zero on high-severity, tiered scoring for medium/low/clean
+✅ OriginalityReward (R7) — cliff at 0.4, continuous scoring above
+✅ data/shadowban_triggers.json — 20+ entries per 6 categories
+✅ data/viral_templates.json — 20+ entries per 4 categories (hooks, structures, CTAs, transitions)
+✅ observations.py — R6/R7 fields in RewardComponents, moderation/originality outputs in DebateRound
+✅ env.py — ModerationAgent + OriginalityAgent wired into reset() and step()
+✅ reward_aggregator.py — new weights (R6: 0.10, R7: 0.10), R6 hard-zero fires before catastrophic drop check
+✅ test_phase6.py — 16 tests, all passing
+✅ Phase 6 gate — PHASE 6 GATE: PASS, R6+R7 active, 7 total reward components
 
 ## Phase 7 — [Pending]
 ⏳ [feature name] — [one line description]

session/phase-log.md

@@ -24,6 +24,7 @@ ROLLED BACK — changes reverted, reason in line
 [2026-04-26] [Phase 3] COMPLETE — curriculum tiers, GRPO pipeline, rollout fn, dry-run gate PASS
 [2026-04-26] [Phase 4] COMPLETE — DifficultyTracker, CriticEscalationEngine, env wiring, 6 tests pass, gate PASS
 [2026-04-26] [Phase 5] COMPLETE — HF deploy infra, demo, README, submission_check 10/10 PASS, demo end-to-end ok
+[2026-04-26] [Phase 6] COMPLETE — ModerationAgent, OriginalityAgent, R6/R7 rewards, 16 tests PASS, gate PASS
 
 ---
 

viral_script_engine/agents/moderation_agent.py

@@ -0,0 +1,114 @@
+import json
+import re
+from pathlib import Path
+from typing import Dict, List
+
+from pydantic import BaseModel
+
+
+class ModerationFlag(BaseModel):
+    category: str
+    trigger_phrase: str
+    position: str
+    severity: str
+    suggestion: str
+
+
+class ModerationOutput(BaseModel):
+    flags: List[ModerationFlag]
+    is_safe: bool
+    overall_risk: str
+    total_flags: int
+
+
+_CATEGORY_LABEL_MAP = {
+    "hate_speech_patterns": "hate_speech",
+    "misleading_health_claims": "misleading_health",
+    "copyright_bait_phrases": "copyright_bait",
+    "engagement_bait": "engagement_bait",
+    "spam_signals": "spam",
+    "platform_policy_violations": "policy_violation",
+}
+
+_SEVERITY_MAP = {
+    "hate_speech_patterns": "high",
+    "misleading_health_claims": "high",
+    "copyright_bait_phrases": "medium",
+    "engagement_bait": "low",
+    "spam_signals": "medium",
+    "platform_policy_violations": "high",
+}
+
+_SUGGESTIONS = {
+    "hate_speech_patterns": "Remove or replace with respectful, inclusive language.",
+    "misleading_health_claims": "Replace with evidence-based language; avoid absolute health guarantees.",
+    "copyright_bait_phrases": "Remove references to free/leaked content to avoid DMCA flags.",
+    "engagement_bait": "Replace with a genuine question or value-based CTA.",
+    "spam_signals": "Remove external link bait; focus on in-app value delivery.",
+    "platform_policy_violations": "Remove policy-violating claims; keep messaging compliant.",
+}
+
+
+def _split_script(script: str) -> Dict[str, str]:
+    sentences = re.split(r'(?<=[.!?])\s+', script.strip())
+    if len(sentences) <= 5:
+        return {"hook": script, "body": "", "cta": ""}
+    hook = " ".join(sentences[:3])
+    cta = " ".join(sentences[-2:])
+    body = " ".join(sentences[3:-2])
+    return {"hook": hook, "body": body, "cta": cta}
+
+
+class ModerationAgent:
+    """
+    Checks scripts for content that would get flagged or shadowbanned on Reels.
+    Zero LLM calls — purely rule-based against shadowban_triggers.json.
+    """
+
+    def __init__(self, kb_path: str = "data/shadowban_triggers.json"):
+        resolved = Path(kb_path)
+        if not resolved.is_absolute():
+            resolved = Path(__file__).parent.parent / kb_path
+        with open(resolved) as f:
+            self._kb: Dict[str, List[str]] = json.load(f)
+
+    def check(self, script: str) -> ModerationOutput:
+        sections = _split_script(script)
+        flags: List[ModerationFlag] = []
+
+        for category, triggers in self._kb.items():
+            severity = _SEVERITY_MAP.get(category, "low")
+            label = _CATEGORY_LABEL_MAP.get(category, category)
+            suggestion = _SUGGESTIONS.get(category, "Review and revise this content.")
+            for position, text in sections.items():
+                if not text:
+                    continue
+                text_lower = text.lower()
+                for trigger in triggers:
+                    if trigger in text_lower:
+                        flags.append(ModerationFlag(
+                            category=label,
+                            trigger_phrase=trigger,
+                            position=position,
+                            severity=severity,
+                            suggestion=suggestion,
+                        ))
+
+        has_high = any(f.severity == "high" for f in flags)
+        has_medium = any(f.severity == "medium" for f in flags)
+
+        if has_high:
+            overall_risk = "high_risk"
+        elif has_medium:
+            overall_risk = "medium_risk"
+        elif flags:
+            overall_risk = "low_risk"
+        else:
+            overall_risk = "safe"
+
+        return ModerationOutput(
+            flags=flags,
+            is_safe=not has_high,
+            overall_risk=overall_risk,
+            total_flags=len(flags),
+        )

viral_script_engine/agents/originality_agent.py

@@ -0,0 +1,117 @@
+import json
+import re
+from difflib import SequenceMatcher
+from pathlib import Path
+from typing import Dict, List
+
+from pydantic import BaseModel
+
+
+class OriginalityFlag(BaseModel):
+    template_type: str
+    matched_pattern: str
+    script_excerpt: str
+    suggestion: str
+
+
+class OriginalityOutput(BaseModel):
+    flags: List[OriginalityFlag]
+    originality_score: float
+    is_generic: bool
+    unique_elements: List[str]
+
+
+_TEMPLATE_TYPE_MAP = {
+    "overused_hooks": "overused_hook",
+    "overused_structures": "overused_structure",
+    "overused_cta_phrases": "overused_cta",
+    "overused_transitions": "overused_transition",
+}
+
+_SUGGESTIONS = {
+    "overused_hook": "Rewrite the hook with a specific data point, personal story, or unexpected angle.",
+    "overused_structure": "Try an unconventional narrative arc — start mid-story or end with the question.",
+    "overused_cta": "Replace with a specific, contextual call-to-action tied to the video's content.",
+    "overused_transition": "Cut the transition filler and jump directly to the next point.",
+}
+
+_FUZZY_THRESHOLD = 0.75
+
+
+def _split_script(script: str) -> Dict[str, str]:
+    sentences = re.split(r'(?<=[.!?])\s+', script.strip())
+    if len(sentences) <= 5:
+        return {"hook": script, "body": "", "cta": ""}
+    hook = " ".join(sentences[:3])
+    cta = " ".join(sentences[-2:])
+    body = " ".join(sentences[3:-2])
+    return {"hook": hook, "body": body, "cta": cta}
+
+
+def _fuzzy_match(text: str, pattern: str) -> bool:
+    text_lower = text.lower()
+    pattern_lower = pattern.lower()
+    if pattern_lower in text_lower:
+        return True
+    ratio = SequenceMatcher(None, text_lower, pattern_lower).ratio()
+    return ratio >= _FUZZY_THRESHOLD
+
+
+class OriginalityAgent:
+    """
+    Measures how distinct the script sounds compared to overused Reels formats.
+    Zero LLM calls — fuzzy string matching against viral_templates.json.
+    Uses difflib.SequenceMatcher (threshold: 0.75 similarity).
+    """
+
+    def __init__(self, templates_path: str = "data/viral_templates.json"):
+        resolved = Path(templates_path)
+        if not resolved.is_absolute():
+            resolved = Path(__file__).parent.parent / templates_path
+        with open(resolved) as f:
+            self._templates: Dict[str, List[str]] = json.load(f)
+
+    def check(self, script: str) -> OriginalityOutput:
+        sections = _split_script(script)
+        flags: List[OriginalityFlag] = []
+        matched_sections = set()
+
+        for category, patterns in self._templates.items():
+            template_type = _TEMPLATE_TYPE_MAP.get(category, category)
+            suggestion = _SUGGESTIONS.get(template_type, "Make this section more original.")
+            for pos, text in sections.items():
+                if not text:
+                    continue
+                sentences = re.split(r'(?<=[.!?])\s+', text.strip())
+                for sentence in sentences:
+                    for pattern in patterns:
+                        if _fuzzy_match(sentence, pattern):
+                            section_key = f"{pos}:{sentence[:40]}"
+                            matched_sections.add(section_key)
+                            flags.append(OriginalityFlag(
+                                template_type=template_type,
+                                matched_pattern=pattern,
+                                script_excerpt=sentence[:80],
+                                suggestion=suggestion,
+                            ))
+
+        all_sentences = re.split(r'(?<=[.!?])\s+', script.strip())
+        total = max(len(all_sentences), 1)
+        matched_count = len(matched_sections)
+        originality_score = max(0.0, min(1.0, 1.0 - (matched_count / total)))
+
+        unique_elements = [
+            s for s in all_sentences
+            if not any(
+                _fuzzy_match(s, pattern)
+                for patterns in self._templates.values()
+                for pattern in patterns
+            )
+        ]
+
+        return OriginalityOutput(
+            flags=flags,
+            originality_score=originality_score,
+            is_generic=originality_score < 0.4,
+            unique_elements=unique_elements,
+        )

viral_script_engine/data/shadowban_triggers.json

@@ -0,0 +1,134 @@
+{
+  "hate_speech_patterns": [
+    "go back to your country",
+    "sub-human",
+    "vermin",
+    "parasite",
+    "pest",
+    "replace the whites",
+    "white genocide",
+    "great replacement",
+    "race traitor",
+    "race mixing is wrong",
+    "demographic replacement",
+    "they control everything",
+    "globalist agenda",
+    "kalergi plan",
+    "blood and soil",
+    "14 words",
+    "heil",
+    "racial purity",
+    "ethnic cleansing",
+    "gas the"
+  ],
+  "misleading_health_claims": [
+    "cure",
+    "doctors don't want you to know",
+    "guaranteed weight loss",
+    "100% natural treatment",
+    "miracle remedy",
+    "big pharma hiding",
+    "instant cure",
+    "detox your body in 24 hours",
+    "reverses diabetes naturally",
+    "shrinks tumors",
+    "eliminate cancer",
+    "fda banned",
+    "secret ingredient doctors hate",
+    "heal yourself at home",
+    "no side effects guaranteed",
+    "clears arteries overnight",
+    "secret ancient remedy",
+    "boosts immunity by 1000%",
+    "prevents all diseases",
+    "one weird trick doctors"
+  ],
+  "copyright_bait_phrases": [
+    "full movie",
+    "free download",
+    "watch without ads",
+    "leaked footage",
+    "full episode free",
+    "no copyright",
+    "watch full film",
+    "download for free",
+    "stream free online",
+    "bypass paywall",
+    "full series free",
+    "watch hd without paying",
+    "crack version",
+    "pirated",
+    "torrent link",
+    "free streaming no sign up",
+    "leaked scene",
+    "free premium account",
+    "account generator free",
+    "watch full length movie"
+  ],
+  "engagement_bait": [
+    "comment if you agree",
+    "share to save",
+    "follow or bad luck",
+    "tag 3 friends",
+    "double tap if",
+    "like if you think",
+    "share if you care",
+    "type yes if",
+    "comment amen",
+    "repost to spread awareness",
+    "tag someone who needs to see this",
+    "like for part 2",
+    "comment your answer below",
+    "share to your story if you agree",
+    "send this to 10 people",
+    "type 1 if yes 2 if no",
+    "follow to find out",
+    "like to support",
+    "comment done when you finish",
+    "share with every parent you know"
+  ],
+  "spam_signals": [
+    "link in bio for free",
+    "dm me the word",
+    "click the link below for",
+    "comment to get access",
+    "free gift in my bio",
+    "limited time only dm",
+    "get yours now in bio",
+    "dm for price",
+    "free pdf in bio",
+    "drop your email below",
+    "click link in story",
+    "comment your phone number",
+    "dm for exclusive access",
+    "free course in bio link",
+    "type below to get the template",
+    "visit my website in bio",
+    "dm for the checklist",
+    "grab the free guide in link below",
+    "swipe up and get it free",
+    "first 100 comments get free"
+  ],
+  "platform_policy_violations": [
+    "buy followers",
+    "get rich quick",
+    "make $x in y days guaranteed",
+    "buy instagram likes",
+    "boost your followers instantly",
+    "earn money doing nothing",
+    "passive income no effort",
+    "100k in 30 days",
+    "work from home no experience $500/day",
+    "financial freedom in 30 days",
+    "easy money from your phone",
+    "turn $100 into $10,000",
+    "forex signals guaranteed profit",
+    "crypto pump group",
+    "ponzi scheme",
+    "pyramid scheme",
+    "make money fast guaranteed",
+    "binary options guaranteed",
+    "offshore account secret",
+    "tax evasion method"
+  ]
+}

viral_script_engine/data/viral_templates.json

@@ -0,0 +1,102 @@
+{
+  "overused_hooks": [
+    "pov: you finally figured out",
+    "nobody talks about this but",
+    "things that are actually red flags",
+    "tell me you're x without telling me you're x",
+    "as someone who has done x for y years",
+    "the reason you're not seeing results is",
+    "stop doing x immediately",
+    "x things i wish i knew before",
+    "wait for it",
+    "this changed everything for me",
+    "i can't believe i didn't know this sooner",
+    "if you're struggling with x watch this",
+    "the truth about x nobody tells you",
+    "i tried x for 30 days and here's what happened",
+    "you've been doing x wrong your whole life",
+    "why i quit x after y years",
+    "the x that changed my life",
+    "how i went from x to y in z days",
+    "day x of doing y",
+    "let me show you something crazy",
+    "here's what they don't want you to know",
+    "this is your sign to",
+    "can we normalize",
+    "unpopular opinion but"
+  ],
+  "overused_structures": [
+    "hook → 3 numbered tips → cta to follow",
+    "controversial take → explanation → agree with me?",
+    "before and after → what changed → product mention",
+    "problem → agitate → solution",
+    "story time → lesson learned → apply it",
+    "myth busting → real answer → follow for more",
+    "countdown from 5 to 1 → reveal at end",
+    "reaction to trending topic → opinion → like if you agree",
+    "day in my life → relatable moments → subscribe",
+    "this or that comparison → winner announced → share",
+    "product review → pros cons → buy link in bio",
+    "step 1 step 2 step 3 → results revealed → cta",
+    "question hook → answer delayed → follow to find out",
+    "challenge accepted → process montage → final result",
+    "morning routine → productivity tips → follow for inspo",
+    "hot take → justification → engage in comments",
+    "transformation reveal → how i did it → coaching plug",
+    "ask me anything → batch answers → comment more questions",
+    "mistakes i made → lessons → save this post",
+    "trend recreation → personal twist → duet with me",
+    "storytime gossip → drama recap → give your opinion",
+    "meet my x → intro → follow for more content"
+  ],
+  "overused_cta_phrases": [
+    "follow for more",
+    "save this for later",
+    "share with someone who needs this",
+    "comment your thoughts below",
+    "like if you agree",
+    "drop a comment if this helped",
+    "hit the follow button",
+    "bookmark this",
+    "share to your story",
+    "tag a friend who needs to hear this",
+    "let me know in the comments",
+    "smash that like button",
+    "turn on notifications",
+    "click the link in bio",
+    "follow for part 2",
+    "share this before it gets removed",
+    "comment yes if you want more",
+    "send this to your bestie",
+    "like and subscribe",
+    "save this post it will help you later",
+    "follow now don't regret it",
+    "repost if you found this useful"
+  ],
+  "overused_transitions": [
+    "but wait there's more",
+    "and here's the thing",
+    "plot twist",
+    "but actually",
+    "real talk though",
+    "here's where it gets interesting",
+    "stay with me",
+    "now here's the kicker",
+    "this is the part nobody talks about",
+    "i know what you're thinking",
+    "but before i get into that",
+    "and this is the important part",
+    "okay so",
+    "so basically",
+    "long story short",
+    "here's the truth",
+    "i have to be honest",
+    "not gonna lie",
+    "the crazy part is",
+    "fast forward to",
+    "spoiler alert",
+    "and that's when it hit me",
+    "here's what blew my mind",
+    "and guess what happened next"
+  ]
+}

viral_script_engine/environment/env.py

@@ -11,11 +11,15 @@ from viral_script_engine.environment.episode_state import EpisodeState
 from viral_script_engine.environment.observations import (
     DebateRound, Observation, RewardComponents,
 )
+from viral_script_engine.agents.moderation_agent import ModerationAgent
+from viral_script_engine.agents.originality_agent import OriginalityAgent
 from viral_script_engine.rewards.r1_hook_strength import HookStrengthReward
 from viral_script_engine.rewards.r2_coherence import CoherenceReward
 from viral_script_engine.rewards.r3_cultural_alignment import CulturalAlignmentReward
 from viral_script_engine.rewards.r4_debate_resolution import DebateResolutionReward
 from viral_script_engine.rewards.r5_defender_preservation import DefenderPreservationReward
+from viral_script_engine.rewards.r6_safety import SafetyReward
+from viral_script_engine.rewards.r7_originality import OriginalityReward
 from viral_script_engine.rewards.reward_aggregator import RewardAggregator
 
 _TIERS = {
@@ -59,6 +63,10 @@ class ViralScriptEnv:
         self.r3 = CulturalAlignmentReward(knowledge_base_path=cultural_kb_path)
         self.r4 = DebateResolutionReward(critic_agent=self.critic)
         self.r5 = DefenderPreservationReward()
+        self.r6 = SafetyReward()
+        self.r7 = OriginalityReward()
+        self.moderation_agent = ModerationAgent()
+        self.originality_agent = OriginalityAgent()
         self.aggregator = RewardAggregator()
         self._state: Optional[EpisodeState] = None
 
@@ -125,10 +133,16 @@ class ViralScriptEnv:
         r1_result = self.r1.score(script["script_text"])
         r2_result = self.r2.score(script["script_text"], script["script_text"])
         r3_result = self.r3.score(script["script_text"], script.get("region", "pan_india_english"))
+        mod_out = self.moderation_agent.check(script["script_text"])
+        orig_out = self.originality_agent.check(script["script_text"])
+        r6_result = self.r6.score(mod_out)
+        r7_result = self.r7.score(orig_out)
         initial_rewards = RewardComponents(
             r1_hook_strength=r1_result.score,
             r2_coherence=r2_result.score,
             r3_cultural_alignment=r3_result.score,
+            r6_safety=r6_result.score,
+            r7_originality=r7_result.score,
         )
         initial_rewards.compute_total()
 
@@ -186,12 +200,19 @@ class ViralScriptEnv:
 
         r5_result = self.r5.score(defender_output, new_script)
 
+        moderation_out = self.moderation_agent.check(new_script)
+        originality_out = self.originality_agent.check(new_script)
+        r6_result = self.r6.score(moderation_out)
+        r7_result = self.r7.score(originality_out)
+
         components = RewardComponents(
             r1_hook_strength=r1_result.score,
             r2_coherence=r2_result.score,
             r3_cultural_alignment=r3_result.score,
             r4_debate_resolution=r4_result.score if r4_result else None,
             r5_defender_preservation=r5_result.score,
+            r6_safety=r6_result.score,
+            r7_originality=r7_result.score,
         )
 
         self._state.action_history.append(arb_action.action_type)
@@ -222,6 +243,8 @@ class ViralScriptEnv:
             arbitrator_action=arb_action,
             rewrite_diff=rewrite_result.diff,
             reward_components=components,
+            moderation_output=moderation_out.model_dump(),
+            originality_output=originality_out.model_dump(),
         )
         self._state.debate_history.append(round_)
         self._state.current_script = new_script
@@ -251,6 +274,8 @@ class ViralScriptEnv:
             "anti_gaming_triggered": anti_log.triggered,
             "penalty_reason": anti_log.rule_triggered,
             "anti_gaming_log": anti_log.model_dump(),
+            "moderation_output": moderation_out.model_dump(),
+            "originality_output": originality_out.model_dump(),
         }
         return self._build_observation().model_dump(), components.total, terminated, False, info
 
@@ -278,6 +303,13 @@ class ViralScriptEnv:
 
     def _build_observation(self) -> Observation:
         s = self._state
+        last_round = s.debate_history[-1] if s.debate_history else None
+        mod_flags = []
+        orig_flags = []
+        if last_round and last_round.moderation_output:
+            mod_flags = last_round.moderation_output.get("flags", [])
+        if last_round and last_round.originality_output:
+            orig_flags = last_round.originality_output.get("flags", [])
         return Observation(
             current_script=s.current_script,
             original_script=s.original_script,
@@ -290,4 +322,6 @@ class ViralScriptEnv:
             reward_components=s.last_reward_components,
             difficulty_level=s.difficulty_level,
             episode_id=s.episode_id,
+            current_moderation_flags=mod_flags,
+            current_originality_flags=orig_flags,
         )

viral_script_engine/environment/observations.py

@@ -6,7 +6,8 @@ from viral_script_engine.agents.critic import CritiqueClaim
 from viral_script_engine.environment.actions import ArbitratorAction
 
 _WEIGHTS: Dict[str, float] = {
-    "r1": 0.25, "r2": 0.20, "r3": 0.20, "r4": 0.20, "r5": 0.15
+    "r1": 0.20, "r2": 0.15, "r3": 0.15, "r4": 0.15, "r5": 0.15,
+    "r6": 0.10, "r7": 0.10,
 }
 
 
@@ -16,6 +17,8 @@ class RewardComponents(BaseModel):
     r3_cultural_alignment: Optional[float] = None
     r4_debate_resolution: Optional[float] = None
     r5_defender_preservation: Optional[float] = None
+    r6_safety: Optional[float] = None
+    r7_originality: Optional[float] = None
     anti_gaming_penalty: float = 0.0
     total: float = 0.0
 
@@ -26,6 +29,8 @@ class RewardComponents(BaseModel):
             "r3": self.r3_cultural_alignment,
             "r4": self.r4_debate_resolution,
             "r5": self.r5_defender_preservation,
+            "r6": self.r6_safety,
+            "r7": self.r7_originality,
         }
         active = {k: v for k, v in vals.items() if v is not None}
         if not active:
@@ -44,6 +49,8 @@ class DebateRound(BaseModel):
     arbitrator_action: Optional[ArbitratorAction] = None
     rewrite_diff: Optional[str] = None
     reward_components: Optional[RewardComponents] = None
+    moderation_output: Optional[Any] = None
+    originality_output: Optional[Any] = None
 
 
 class Observation(BaseModel):
@@ -58,3 +65,5 @@ class Observation(BaseModel):
     reward_components: RewardComponents
     difficulty_level: str
     episode_id: str
+    current_moderation_flags: List[Any] = []
+    current_originality_flags: List[Any] = []

viral_script_engine/rewards/r6_safety.py

@@ -0,0 +1,52 @@
+from pydantic import BaseModel
+
+from viral_script_engine.agents.moderation_agent import ModerationOutput
+
+
+class SafetyRewardResult(BaseModel):
+    score: float
+    flag_count: int
+    highest_severity: str
+    breakdown: str
+
+
+class SafetyReward:
+    """
+    Converts ModerationOutput into a reward signal.
+
+    Scoring:
+    - Zero flags:                    1.0
+    - Only low-severity flags:       0.8
+    - Any medium-severity flag:      0.5
+    - Any high-severity flag:        0.0  (hard zero — non-negotiable per platform policy)
+    """
+
+    def score(self, moderation_output: ModerationOutput) -> SafetyRewardResult:
+        if moderation_output.total_flags == 0:
+            return SafetyRewardResult(
+                score=1.0,
+                flag_count=0,
+                highest_severity="none",
+                breakdown="No flags detected.",
+            )
+
+        severities = [f.severity for f in moderation_output.flags]
+        if "high" in severities:
+            highest = "high"
+            reward = 0.0
+            breakdown = "Hard zero: high-severity flag present (platform policy violation)."
+        elif "medium" in severities:
+            highest = "medium"
+            reward = 0.5
+            breakdown = f"Medium-severity flags detected ({moderation_output.total_flags} total)."
+        else:
+            highest = "low"
+            reward = 0.8
+            breakdown = f"Only low-severity flags detected ({moderation_output.total_flags} total)."
+
+        return SafetyRewardResult(
+            score=reward,
+            flag_count=moderation_output.total_flags,
+            highest_severity=highest,
+            breakdown=breakdown,
+        )

viral_script_engine/rewards/r7_originality.py

@@ -0,0 +1,46 @@
+from pydantic import BaseModel
+
+from viral_script_engine.agents.originality_agent import OriginalityOutput
+
+
+class OriginalityRewardResult(BaseModel):
+    score: float
+    originality_score: float
+    flag_count: int
+    breakdown: str
+
+
+class OriginalityReward:
+    """
+    Converts OriginalityOutput into a reward signal.
+
+    Scoring maps directly from originality_score:
+    - originality_score >= 0.8:  reward = 1.0  (genuinely distinctive)
+    - originality_score 0.6–0.8: reward = originality_score
+    - originality_score 0.4–0.6: reward = 0.3  (mediocre — generic but not terrible)
+    - originality_score < 0.4:   reward = 0.0  (template clone — cliff penalty)
+    """
+
+    def score(self, originality_output: OriginalityOutput) -> OriginalityRewardResult:
+        os_ = originality_output.originality_score
+        flag_count = len(originality_output.flags)
+
+        if os_ >= 0.8:
+            reward = 1.0
+            breakdown = f"Highly original (score={os_:.2f}). No dominant template patterns."
+        elif os_ >= 0.6:
+            reward = os_
+            breakdown = f"Moderately original (score={os_:.2f}). Some template overlap detected."
+        elif os_ >= 0.4:
+            reward = 0.3
+            breakdown = f"Generic content (score={os_:.2f}). Multiple overused patterns present."
+        else:
+            reward = 0.0
+            breakdown = f"Template clone (score={os_:.2f}). Script heavily relies on overused formats."
+
+        return OriginalityRewardResult(
+            score=reward,
+            originality_score=os_,
+            flag_count=flag_count,
+            breakdown=breakdown,
+        )

viral_script_engine/rewards/reward_aggregator.py

@@ -11,6 +11,7 @@ logger = logging.getLogger(__name__)
 _COMPONENT_FIELDS = [
     "r1_hook_strength", "r2_coherence", "r3_cultural_alignment",
     "r4_debate_resolution", "r5_defender_preservation",
+    "r6_safety", "r7_originality",
 ]
 
 _DROP_THRESHOLD = 0.25
@@ -36,6 +37,26 @@ class RewardAggregator:
         episode_id: str = "",
         step_num: int = 0,
     ) -> Tuple[RewardComponents, AntiGamingLog]:
+        # Hard zero: if R6 (safety) is 0.0, the entire step reward is zeroed out
+        # regardless of other component scores — any shadowban trigger is non-negotiable.
+        if components.r6_safety is not None and components.r6_safety == 0.0:
+            components.compute_total()
+            pre_penalty_total = components.total
+            components.total = 0.0
+            components.anti_gaming_penalty = 1.0
+            logger.warning("R6 safety hard zero triggered — shadowban content detected, zeroing step reward.")
+            log = AntiGamingLog(
+                episode_id=episode_id,
+                step_num=step_num,
+                triggered=True,
+                rule_triggered="r6_safety_hard_zero",
+                component_that_dropped="r6_safety",
+                penalty_applied=1.0,
+                pre_penalty_total=pre_penalty_total,
+                post_penalty_total=0.0,
+            )
+            return components, log
+
         components.compute_total()
         pre_penalty_total = components.total
 

viral_script_engine/scripts/run_dummy_episode.py

@@ -21,6 +21,11 @@ console = Console()
 BASE_DIR = Path(__file__).parent.parent
 
 
+def _bar(score: float, width: int = 8) -> str:
+    filled = round(score * width)
+    return "#" * filled + "." * (width - filled)
+
+
 def build_random_action(action_type: ActionType) -> dict:
     labels = {
         ActionType.HOOK_REWRITE: ("hook", "Rewrite the hook to open with a specific number or bold claim."),
@@ -48,7 +53,7 @@ def run_episode(difficulty: str, steps: int, verbose: bool) -> dict:
         f"Difficulty: {difficulty}  |  Max steps: {steps}\n"
         f"Region: {obs['region']}  |  Platform: {obs['platform']}  |  Niche: {obs['niche']}\n"
         f"Episode ID: {obs['episode_id']}",
-        title="[bold blue]Phase 1 Demo Episode[/bold blue]",
+        title="[bold blue]Phase 6 Demo Episode[/bold blue]",
         border_style="blue",
     ))
 
@@ -65,22 +70,61 @@ def run_episode(difficulty: str, steps: int, verbose: bool) -> dict:
 
         obs, reward, terminated, truncated, info = env.step(action)
         rc = info["reward_components"]
+        mod_out = info.get("moderation_output", {})
+        orig_out = info.get("originality_output", {})
 
         if verbose:
             t = Table(title=f"Step {step_num + 1} — {action_type.value}", box=box.SIMPLE_HEAD)
             t.add_column("Metric", style="cyan", min_width=22)
-            t.add_column("Value", min_width=12)
-            r1_val = rc.get("r1_hook_strength")
-            r2_val = rc.get("r2_coherence")
-            t.add_row("R1 Hook Strength", f"{r1_val:.3f}" if r1_val is not None else "N/A")
-            t.add_row("R2 Coherence", f"{r2_val:.3f}" if r2_val is not None else "N/A")
-            t.add_row("Total Reward", f"[bold]{reward:.3f}[/bold]")
+            t.add_column("Score", min_width=12)
+            t.add_column("Bar", min_width=10)
+
+            def _row(label, key, suffix=""):
+                val = rc.get(key)
+                score_str = f"{val:.3f}" if val is not None else "N/A"
+                bar_str = _bar(val) if val is not None else ""
+                t.add_row(label, score_str + suffix, bar_str)
+
+            _row("R1 Hook Strength", "r1_hook_strength")
+            _row("R2 Coherence", "r2_coherence")
+            _row("R3 Cultural", "r3_cultural_alignment")
+            _row("R4 Resolution", "r4_debate_resolution")
+            _row("R5 Preservation", "r5_defender_preservation")
+
+            r6_val = rc.get("r6_safety")
+            r6_suffix = "  [OK] No flags" if mod_out.get("total_flags", 0) == 0 else f"  [!] {mod_out.get('total_flags', 0)} flag(s)"
+            r6_str = (f"{r6_val:.3f}{r6_suffix}" if r6_val is not None else "N/A")
+            t.add_row("R6 Safety", r6_str, _bar(r6_val) if r6_val is not None else "")
+
+            r7_val = rc.get("r7_originality")
+            orig_flags = len(orig_out.get("flags", []))
+            r7_suffix = f"  [!] {orig_flags} template match(es)" if orig_flags > 0 else "  [OK] Original"
+            r7_str = (f"{r7_val:.3f}{r7_suffix}" if r7_val is not None else "N/A")
+            t.add_row("R7 Originality", r7_str, _bar(r7_val) if r7_val is not None else "")
+
+            t.add_row("-" * 22, "-" * 12, "-" * 10)
+            t.add_row("[bold]Total[/bold]", f"[bold]{reward:.3f}[/bold]", _bar(reward))
+
             if info.get("anti_gaming_triggered"):
-                t.add_row("Anti-Gaming Penalty", f"[red]{rc.get('anti_gaming_penalty', 0):.3f}[/red]")
-                t.add_row("Penalty Reason", f"[red]{info.get('penalty_reason', '')}[/red]")
-            t.add_row("Terminated", str(terminated))
+                t.add_row("Anti-Gaming Penalty", f"[red]{rc.get('anti_gaming_penalty', 0):.3f}[/red]", "")
+                t.add_row("Penalty Reason", f"[red]{info.get('penalty_reason', '')}[/red]", "")
+            t.add_row("Terminated", str(terminated), "")
             console.print(t)
 
+            # Show moderation flags in red panel if any
+            mod_flags = mod_out.get("flags", [])
+            if mod_flags:
+                flag_lines = []
+                for fl in mod_flags:
+                    flag_lines.append(
+                        f"  [{fl['severity']}] {fl['category']} in {fl['position']}: \"{fl['trigger_phrase']}\" → {fl['suggestion']}"
+                    )
+                console.print(Panel(
+                    "\n".join(flag_lines),
+                    title="[bold red]!! MODERATION FLAGS DETECTED[/bold red]",
+                    border_style="red",
+                ))
+
             if obs.get("debate_history"):
                 latest = obs["debate_history"][-1]
                 if latest.get("rewrite_diff"):
@@ -95,6 +139,8 @@ def run_episode(difficulty: str, steps: int, verbose: bool) -> dict:
             "action": action,
             "reward": reward,
             "reward_components": rc,
+            "moderation_output": mod_out,
+            "originality_output": orig_out,
             "anti_gaming": info.get("anti_gaming_triggered", False),
             "terminated": terminated,
         })
@@ -108,8 +154,10 @@ def run_episode(difficulty: str, steps: int, verbose: bool) -> dict:
 
     console.print(Panel(
         f"[bold green]Final Reward:[/bold green] {final_rc.get('total', 0):.3f}\n"
-        f"R1 Hook Strength: {final_rc.get('r1_hook_strength', 'N/A')}\n"
-        f"R2 Coherence: {final_rc.get('r2_coherence', 'N/A')}\n"
+        f"R1 Hook Strength:    {final_rc.get('r1_hook_strength', 'N/A')}\n"
+        f"R2 Coherence:        {final_rc.get('r2_coherence', 'N/A')}\n"
+        f"R6 Safety:           {final_rc.get('r6_safety', 'N/A')}\n"
+        f"R7 Originality:      {final_rc.get('r7_originality', 'N/A')}\n"
         f"Steps completed: {final_state['step_num']}",
         title="Episode Summary",
         border_style="green",
@@ -119,7 +167,7 @@ def run_episode(difficulty: str, steps: int, verbose: bool) -> dict:
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Run Phase 1 dummy episode")
+    parser = argparse.ArgumentParser(description="Run Phase 6 dummy episode")
     parser.add_argument("--difficulty", default="easy", choices=["easy", "medium", "hard"])
     parser.add_argument("--steps", type=int, default=3)
     parser.add_argument("--verbose", action="store_true")
@@ -136,12 +184,15 @@ def main():
 
     final_rc = episode_log["final_state"]["reward_components"]
     gate_pass = (
-        final_rc.get("r1_hook_strength") is not None
-        and final_rc.get("r2_coherence") is not None
+        final_rc.get("r6_safety") is not None
+        and final_rc.get("r7_originality") is not None
         and log_path.exists()
     )
     style = "bold green" if gate_pass else "bold red"
-    label = f"PHASE 1 GATE: {'PASS' if gate_pass else 'FAIL'}"
+    if gate_pass:
+        label = "PHASE 6 GATE: PASS — R6 (safety) and R7 (originality) active. Total reward components: 7."
+    else:
+        label = "PHASE 6 GATE: FAIL — R6 or R7 missing from reward output."
     console.print(Panel(f"[{style}]{label}[/{style}]", border_style="green" if gate_pass else "red"))
 
 

viral_script_engine/tests/test_phase6.py

@@ -0,0 +1,318 @@
+"""Phase 6 tests: ModerationAgent, OriginalityAgent, R6/R7 rewards, aggregator, env.step()."""
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from viral_script_engine.agents.moderation_agent import ModerationAgent, ModerationOutput
+from viral_script_engine.agents.originality_agent import OriginalityAgent, OriginalityOutput
+from viral_script_engine.rewards.r6_safety import SafetyReward
+from viral_script_engine.rewards.r7_originality import OriginalityReward
+from viral_script_engine.rewards.reward_aggregator import RewardAggregator
+from viral_script_engine.environment.observations import RewardComponents
+
+BASE_DIR = Path(__file__).parent.parent
+
+
+@pytest.fixture
+def moderation_agent():
+    return ModerationAgent(kb_path=str(BASE_DIR / "data" / "shadowban_triggers.json"))
+
+
+@pytest.fixture
+def originality_agent():
+    return OriginalityAgent(templates_path=str(BASE_DIR / "data" / "viral_templates.json"))
+
+
+@pytest.fixture
+def r6():
+    return SafetyReward()
+
+
+@pytest.fixture
+def r7():
+    return OriginalityReward()
+
+
+# ── ModerationAgent ────────────────────────────────────────────────────────────
+
+class TestModerationAgent:
+    def test_flags_high_severity_health_claim(self, moderation_agent):
+        script = (
+            "Doctors don't want you to know this miracle remedy. "
+            "It is a guaranteed weight loss solution that cures everything. "
+            "Get started today."
+        )
+        result = moderation_agent.check(script)
+        assert result.total_flags > 0
+        severities = [f.severity for f in result.flags]
+        assert "high" in severities
+
+    def test_flags_policy_violation(self, moderation_agent):
+        script = (
+            "Want to grow your audience fast? Buy followers today. "
+            "Make $5000 in 30 days guaranteed — it's the easiest passive income. "
+            "Get rich quick with our proven method."
+        )
+        result = moderation_agent.check(script)
+        assert result.total_flags > 0
+        categories = [f.category for f in result.flags]
+        assert "policy_violation" in categories
+
+    def test_flags_engagement_bait(self, moderation_agent):
+        script = (
+            "Here's something nobody talks about in fitness. "
+            "These 3 exercises changed my life completely. "
+            "Comment if you agree and tag 3 friends who need this."
+        )
+        result = moderation_agent.check(script)
+        assert result.total_flags > 0
+
+    def test_clean_script_is_safe(self, moderation_agent):
+        script = (
+            "I tested three different morning routines for 30 days each. "
+            "The data surprised me — the simplest one produced the best results. "
+            "Here's what I found and what I now do every day."
+        )
+        result = moderation_agent.check(script)
+        assert result.is_safe is True
+        assert result.overall_risk == "safe"
+
+    def test_high_severity_flag_sets_is_safe_false(self, moderation_agent):
+        script = (
+            "This miracle remedy cures cancer permanently. "
+            "Big pharma is hiding this from you. "
+            "Share before it gets taken down."
+        )
+        result = moderation_agent.check(script)
+        assert result.is_safe is False
+
+
+# ── SafetyReward ───────────────────────────────────────────────────────────────
+
+class TestSafetyReward:
+    def test_zero_score_on_high_severity(self, moderation_agent, r6):
+        script = (
+            "This miracle remedy cures all diseases overnight. "
+            "Buy followers now to grow faster. "
+            "Make $10,000 in 30 days guaranteed."
+        )
+        mod_out = moderation_agent.check(script)
+        result = r6.score(mod_out)
+        assert result.score == 0.0
+
+    def test_full_score_on_clean_script(self, moderation_agent, r6):
+        script = (
+            "I spent 6 months studying sleep science. "
+            "These 3 evidence-based habits improved my sleep quality measurably. "
+            "Start with the simplest one first."
+        )
+        mod_out = moderation_agent.check(script)
+        result = r6.score(mod_out)
+        assert result.score == 1.0
+
+    def test_medium_score_on_medium_severity(self, moderation_agent, r6):
+        script = (
+            "This app is a must-have. "
+            "Watch the full movie version for free on our site. "
+            "Click the link below for the download."
+        )
+        mod_out = moderation_agent.check(script)
+        result = r6.score(mod_out)
+        # medium or high severity — score should be <= 0.5
+        assert result.score <= 0.5
+
+
+# ── OriginalityAgent ────────────��──────────────────────────────────────────────
+
+class TestOriginalityAgent:
+    def test_detects_overused_hook(self, originality_agent):
+        script = (
+            "Nobody talks about this but your morning routine is wrong. "
+            "Here are three things I wish I knew before starting. "
+            "Follow for more tips."
+        )
+        result = originality_agent.check(script)
+        assert len(result.flags) > 0
+        template_types = [f.template_type for f in result.flags]
+        assert any(t in ("overused_hook", "overused_cta") for t in template_types)
+
+    def test_unique_script_scores_high(self, originality_agent):
+        script = (
+            "In 2019, the average Indian millennial checked their phone 94 times a day. "
+            "I tracked my own usage for a month and found a pattern nobody warned me about. "
+            "The solution had nothing to do with willpower."
+        )
+        result = originality_agent.check(script)
+        assert result.originality_score >= 0.8
+
+    def test_template_clone_is_generic(self, originality_agent):
+        script = (
+            "Nobody talks about this but you have been doing it wrong your whole life. "
+            "Stop doing this immediately and save this for later. "
+            "Follow for more and share with someone who needs this."
+        )
+        result = originality_agent.check(script)
+        assert result.is_generic is True or result.originality_score < 0.6
+
+
+# ── OriginalityReward ──────────────────────────────────────────────────────────
+
+class TestOriginalityReward:
+    def test_zero_score_on_template_clone(self, originality_agent, r7):
+        script = (
+            "Nobody talks about this but you have been doing it wrong your whole life. "
+            "Stop doing this immediately and save this for later. "
+            "Follow for more and share with someone who needs this."
+        )
+        orig_out = originality_agent.check(script)
+        # Force a low originality_score scenario
+        from viral_script_engine.agents.originality_agent import OriginalityOutput
+        low_out = OriginalityOutput(
+            flags=orig_out.flags,
+            originality_score=0.2,
+            is_generic=True,
+            unique_elements=[],
+        )
+        result = r7.score(low_out)
+        assert result.score == 0.0
+
+    def test_full_score_on_high_originality(self, originality_agent, r7):
+        from viral_script_engine.agents.originality_agent import OriginalityOutput
+        high_out = OriginalityOutput(
+            flags=[],
+            originality_score=0.95,
+            is_generic=False,
+            unique_elements=["unique sentence 1", "unique sentence 2"],
+        )
+        result = r7.score(high_out)
+        assert result.score == 1.0
+
+
+# ── RewardAggregator with R6/R7 ────────────────────────────────────────────────
+
+class TestRewardAggregatorPhase6:
+    def test_r6_r7_included_in_total(self):
+        agg = RewardAggregator()
+        components = RewardComponents(
+            r1_hook_strength=0.8,
+            r2_coherence=0.7,
+            r3_cultural_alignment=0.75,
+            r4_debate_resolution=0.6,
+            r5_defender_preservation=0.7,
+            r6_safety=1.0,
+            r7_originality=0.9,
+        )
+        start = RewardComponents(
+            r1_hook_strength=0.5,
+            r2_coherence=0.5,
+            r3_cultural_alignment=0.5,
+            r4_debate_resolution=0.5,
+            r5_defender_preservation=0.5,
+            r6_safety=1.0,
+            r7_originality=0.9,
+        )
+        result, log = agg.compute(components, start, [], episode_id="test", step_num=1)
+        assert result.total > 0.0
+        assert not log.triggered
+
+    def test_catastrophic_drop_fires_on_r6_zero(self):
+        agg = RewardAggregator()
+        components = RewardComponents(
+            r1_hook_strength=0.8,
+            r2_coherence=0.7,
+            r3_cultural_alignment=0.75,
+            r4_debate_resolution=0.6,
+            r5_defender_preservation=0.7,
+            r6_safety=0.0,
+            r7_originality=0.9,
+        )
+        start = RewardComponents(
+            r1_hook_strength=0.8,
+            r2_coherence=0.7,
+            r3_cultural_alignment=0.75,
+            r4_debate_resolution=0.6,
+            r5_defender_preservation=0.7,
+            r6_safety=1.0,
+            r7_originality=0.9,
+        )
+        result, log = agg.compute(components, start, [], episode_id="test", step_num=1)
+        assert result.total == 0.0
+        assert log.triggered
+        assert log.rule_triggered == "r6_safety_hard_zero"
+
+
+# ── env.step() integration ──────────────────────────���──────────────────────────
+
+class TestEnvStepPhase6:
+    def test_step_includes_moderation_and_originality(self, monkeypatch):
+        from unittest.mock import MagicMock
+        from viral_script_engine.environment.env import ViralScriptEnv
+        from viral_script_engine.agents.critic import CritiqueOutput, CritiqueClaim
+        from viral_script_engine.agents.defender import DefenderOutput
+        from viral_script_engine.agents.rewriter import RewriteResult
+
+        env = ViralScriptEnv(
+            scripts_path=str(BASE_DIR / "data" / "test_scripts" / "scripts.json"),
+            max_steps=1,
+            difficulty="easy",
+            use_escalation=False,
+        )
+
+        dummy_claim = CritiqueClaim(
+            claim_id="C1",
+            critique_class="hook_weakness",
+            claim_text="Hook is weak",
+            timestamp_range="0-3s",
+            evidence="Opening is vague",
+            is_falsifiable=True,
+            severity="medium",
+        )
+        dummy_critique = CritiqueOutput(
+            claims=[dummy_claim],
+            overall_severity="medium",
+            raw_response="Hook is weak",
+        )
+        dummy_defender = DefenderOutput(
+            core_strength="The hook has genuine curiosity value.",
+            core_strength_quote="First sentence",
+            defense_argument="The structure is sound; only specificity needs improvement.",
+            flagged_critic_claims=["C1"],
+            regional_voice_elements=["regional phrase"],
+        )
+        dummy_rewrite = RewriteResult(
+            rewritten_script="3 things nobody tells you about morning routines that actually work.",
+            diff="- Old hook\n+ 3 things nobody tells you about morning routines that actually work.",
+            word_count_delta=2,
+        )
+
+        from viral_script_engine.rewards.r4_debate_resolution import DebateResolutionResult
+        dummy_r4 = DebateResolutionResult(
+            score=0.7,
+            resolution_status="resolved",
+            original_claim_id="C1",
+            original_claim_class="hook_weakness",
+            new_claims_count=0,
+        )
+
+        monkeypatch.setattr(env.critic, "critique", lambda *a, **kw: dummy_critique)
+        monkeypatch.setattr(env.defender, "defend", lambda **kw: dummy_defender)
+        monkeypatch.setattr(env.rewriter, "rewrite", lambda script, action: dummy_rewrite)
+        monkeypatch.setattr(env.r4, "score", lambda **kw: dummy_r4)
+
+        env.reset()
+        action = {
+            "action_type": "hook_rewrite",
+            "target_section": "hook",
+            "instruction": "Make the hook more engaging.",
+            "critique_claim_id": "C1",
+            "reasoning": "test",
+        }
+        _, _, _, _, info = env.step(action)
+        assert "moderation_output" in info
+        assert "originality_output" in info
+        rc = info["reward_components"]
+        assert rc.get("r6_safety") is not None
+        assert rc.get("r7_originality") is not None