Upload app (20).py

app (20).py

@@ -0,0 +1,686 @@
+import gradio as gr
+import spaces
+import torch
+import numpy as np
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+from motif_tagging import detect_motifs
+import re
+import matplotlib.pyplot as plt
+import io
+from PIL import Image
+from datetime import datetime
+from torch.nn.functional import sigmoid
+from collections import Counter
+
+
+# ─── Abuse Model ─────────────────────────────────────────────────
+model_name = "SamanthaStorm/tether-multilabel-v3"
+model      = AutoModelForSequenceClassification.from_pretrained(model_name)
+tokenizer  = AutoTokenizer.from_pretrained(model_name, use_fast=False)
+
+LABELS = [
+    "recovery", "control", "gaslighting", "guilt tripping", "dismissiveness", "blame shifting",
+    "nonabusive","projection", "insults", "contradictory statements", "obscure language"
+]
+
+THRESHOLDS = {
+    "recovery": 0.4,
+    "control": 0.45,
+    "gaslighting": 0.25,
+    "guilt tripping": 0.20,
+    "dismissiveness": 0.25,
+    "blame shifting": 0.25,
+    "projection": 0.25,
+    "insults": 0.05,
+    "contradictory statements": 0.25,
+    "obscure language": 0.15,
+    "nonabusive": 1.0
+}
+
+PATTERN_WEIGHTS = {
+    "recovery": 0.7,
+    "control": 1.4,
+    "gaslighting": 1.50,
+    "guilt tripping": 1.2,
+    "dismissiveness": 0.9,
+    "blame shifting": 0.8,
+    "projection": 0.5,
+    "insults": 1.4,
+    "contradictory statements": 1.0,
+    "obscure language": 0.9,
+    "nonabusive": 0.0
+}
+
+ESCALATION_QUESTIONS = [
+    ("Partner has access to firearms or weapons", 4),
+    ("Partner threatened to kill you", 3),
+    ("Partner threatened you with a weapon", 3),
+    ("Partner has ever choked you, even if you considered it consensual at the time", 4),
+    ("Partner injured or threatened your pet(s)", 3),
+    ("Partner has broken your things, punched or kicked walls, or thrown things ", 2),
+    ("Partner forced or coerced you into unwanted sexual acts", 3),
+    ("Partner threatened to take away your children", 2),
+    ("Violence has increased in frequency or severity", 3),
+    ("Partner monitors your calls/GPS/social media", 2)
+]
+
+# ─── Escalation Risk Mapping ────────────────────────────────────
+ESCALATION_QUESTIONS = [
+    ("Partner has access to firearms or weapons", 4),
+    ("Partner threatened to kill you", 3),
+    ("Partner threatened you with a weapon", 3),
+    ("Partner has ever choked you, even if you considered it consensual at the time", 4),
+    ("Partner injured or threatened your pet(s)", 3),
+    ("Partner has broken your things, punched or kicked walls, or thrown things ", 2),
+    ("Partner forced or coerced you into unwanted sexual acts", 3),
+    ("Partner threatened to take away your children", 2),
+    ("Violence has increased in frequency or severity", 3),
+    ("Partner monitors your calls/GPS/social media", 2)
+]
+
+# ─── Escalation Risk Mapping ────────────────────────────────────
+ESCALATION_RISKS = {
+    "blame shifting": "low",
+    "contradictory statements": "moderate",
+    "control": "high",
+    "dismissiveness": "moderate",
+    "gaslighting": "moderate",
+    "guilt tripping": "moderate",
+    "insults": "moderate",
+    "obscure language": "low",
+    "projection": "low",
+    "recovery phase": "low"
+}
+
+# ─── Risk Stage Labels ─────────────────────────────────────────
+# ─── Risk Stage Labels ─────────────────────────────────────────
+RISK_STAGE_LABELS = {
+    1: "🌀 Risk Stage: Tension-Building\n"
+       "This message reflects rising emotional pressure or subtle control attempts.",
+    2: "🔥 Risk Stage: Escalation\n"
+       "This message includes direct or aggressive patterns, suggesting active harm.",
+    3: "🌧️ Risk Stage: Reconciliation\n"
+       "This message reflects a reset attempt—apologies or emotional repair without accountability.",
+    4: "🌸 Risk Stage: Calm / Honeymoon\n"
+       "This message appears supportive but may follow prior harm, minimizing it."
+}
+
+# ─── Immediate Threat Motifs ───────────────────────────────────
+THREAT_MOTIFS = [
+    "i'll kill you", "i’m going to hurt you", "you’re dead", "you won't survive this",
+    "i’ll break your face", "i'll bash your head in", "i’ll snap your neck",
+    "i’ll come over there and make you shut up", "i'll knock your teeth out",
+    "you’re going to bleed", "you want me to hit you?", "i won’t hold back next time",
+    "i swear to god i’ll beat you", "next time, i won’t miss", "i’ll make you scream",
+    "i know where you live", "i'm outside", "i’ll be waiting", "i saw you with him",
+    "you can’t hide from me", "i’m coming to get you", "i'll find you", "i know your schedule",
+    "i watched you leave", "i followed you home", "you'll regret this", "you’ll be sorry",
+    "you’re going to wish you hadn’t", "you brought this on yourself", "don’t push me",
+    "you have no idea what i’m capable of", "you better watch yourself",
+    "i don’t care what happens to you anymore", "i’ll make you suffer", "you’ll pay for this",
+    "i’ll never let you go", "you’re nothing without me", "if you leave me, i’ll kill myself",
+    "i'll ruin you", "i'll tell everyone what you did", "i’ll make sure everyone knows",
+    "i’m going to destroy your name", "you’ll lose everyone", "i’ll expose you", 
+    "your friends will hate you", "i’ll post everything", "you’ll be cancelled",
+    "you’ll lose everything", "i’ll take the house", "i’ll drain your account",
+    "you’ll never see a dime", "you’ll be broke when i’m done", "i’ll make sure you lose your job",
+    "i’ll take your kids", "i’ll make sure you have nothing", "you can’t afford to leave me",
+    "don't make me do this", "you know what happens when i’m mad", "you’re forcing my hand",
+    "if you just behaved, this wouldn’t happen", "this is your fault",
+    "you’re making me hurt you", "i warned you", "you should have listened"
+]
+
+
+# New Tone & Sentiment Models
+tone_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/tone-tag-multilabel-v1", use_fast=False)
+tone_model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/tone-tag-multilabel-v1")
+TONE_LABELS = [
+    "cold invalidation", "coercive warmth", "contradictory gaslight",
+    "deflective hostility", "emotional instability", "nonabusive",
+    "performative regret", "emotional threat", "forced accountability flip"
+]
+
+sentiment_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/tether-sentiment", use_fast=False)
+sentiment_model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/tether-sentiment")
+SENTIMENT_LABELS = ["undermining", "supportive"]
+
+
+# ─── DARVO Model ──────────────────────────────────────────────────
+darvo_model     = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/tether-darvo-regressor-v1")
+darvo_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/tether-darvo-regressor-v1", use_fast=False)
+darvo_model.eval()
+
+def predict_darvo_score(text):
+    inputs = darvo_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        logits = darvo_model(**inputs).logits
+    return round(sigmoid(logits).item(), 4)
+
+def detect_weapon_language(text):
+    weapon_keywords = ["knife","gun","bomb","weapon","kill","stab"]
+    t = text.lower()
+    return any(w in t for w in weapon_keywords)
+
+# ─── Updated Risk Stage Logic ─────────────────────────────────────
+RISK_STAGE_LABELS = {
+    1: "🌀 Risk Stage: Tension-Building\nThis message reflects rising emotional pressure or subtle control attempts.",
+    2: "🔥 Risk Stage: Escalation\nThis message includes direct or aggressive patterns, suggesting active harm.",
+    3: "🌧️ Risk Stage: Reconciliation\nThis message reflects a reset attempt—apologies or emotional repair without accountability.",
+    4: "🌸 Risk Stage: Calm / Honeymoon\nThis message appears supportive but may follow prior harm, minimizing it."
+}
+
+def get_risk_stage(patterns, sentiment):
+    if "insults" in patterns:
+        return 2
+    elif "recovery" in patterns:
+        return 3
+    elif "control" in patterns or "guilt tripping" in patterns:
+        return 1
+    elif sentiment == "supportive" and any(p in patterns for p in ["projection", "dismissiveness"]):
+        return 4
+    return 1
+
+
+# ─── Emotion & Tone Removed (unneeded) ───────────────────────────
+# (Emotion model block removed)
+
+# ─── Replace get_emotional_tone_tag ──────────────────────────────
+def get_emotional_tone_tag(text, emotions, sentiment, patterns, abuse_score):
+    inputs = tone_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        logits = tone_model(**inputs).logits[0]
+    probs = torch.sigmoid(logits).cpu().numpy()
+    scores = dict(zip(TONE_LABELS, np.round(probs, 3)))
+    return max(scores, key=scores.get)
+
+
+@spaces.GPU
+def compute_abuse_score(matched_scores, sentiment):
+    """
+    Compute abuse score from matched patterns and sentiment
+    """
+    if not matched_scores:
+        return 0.0
+        
+    # Calculate weighted score
+    total_weight = sum(weight for _, _, weight in matched_scores)
+    if total_weight == 0:
+        return 0.0
+    
+    # Get highest pattern scores
+    pattern_scores = [(label, score) for label, score, _ in matched_scores]
+    sorted_scores = sorted(pattern_scores, key=lambda x: x[1], reverse=True)
+    
+    # Base score calculation
+    weighted_sum = sum(score * weight for _, score, weight in matched_scores)
+    base_score = (weighted_sum / total_weight) * 100
+    
+    # Pattern combination multipliers
+    if len(matched_scores) >= 3:  # Multiple patterns detected
+        base_score *= 1.2  # 20% increase for pattern combinations
+    
+    # High severity patterns
+    high_severity_patterns = {'gaslighting', 'control', 'blame shifting'}
+    if any(label in high_severity_patterns for label, _, _ in matched_scores):
+        base_score *= 1.15  # 15% increase for high severity patterns
+    
+    # Pattern strength boosters
+    if any(score > 0.6 for _, score, _ in matched_scores):  # Any pattern > 60%
+        base_score *= 1.1  # 10% increase for strong patterns
+        
+    # Multiple high scores
+    high_scores = len([score for _, score, _ in matched_scores if score > 0.5])
+    if high_scores >= 2:
+        base_score *= 1.15  # 15% increase for multiple high scores
+    
+    # Apply sentiment modifier
+    if sentiment == "supportive":
+        # Less reduction for supportive sentiment when high severity patterns present
+        if any(label in high_severity_patterns for label, _, _ in matched_scores):
+            base_score *= 0.9  # Only 10% reduction
+        else:
+            base_score *= 0.85  # Normal 15% reduction
+    elif sentiment == "undermining":
+        base_score *= 1.15  # 15% increase for undermining sentiment
+    
+    # Ensure minimum score for strong patterns
+    if any(score > 0.6 for _, score, _ in matched_scores):
+        base_score = max(base_score, 65.0)
+    
+    # Cap maximum score
+    return min(round(base_score, 1), 100.0)
+
+
+def analyze_single_message(text, thresholds):
+    print("\n=== DEBUG START ===")
+    print(f"Input text: {text}")
+    
+    if not text.strip():
+        print("Empty text, returning zeros")
+        return 0.0, [], [], {"label": "none"}, 1, 0.0, None
+
+    # Check for explicit abuse
+    explicit_abuse_words = ['fuck', 'bitch', 'shit', 'ass', 'dick']
+    explicit_abuse = any(word in text.lower() for word in explicit_abuse_words)
+    print(f"Explicit abuse detected: {explicit_abuse}")
+    
+    # Abuse model inference 
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    raw_scores = torch.sigmoid(outputs.logits.squeeze(0)).numpy()
+    
+    # Print raw model outputs
+    print("\nRaw model scores:")
+    for label, score in zip(LABELS, raw_scores):
+        print(f"{label}: {score:.3f}")
+
+    # Get predictions and sort them
+    predictions = list(zip(LABELS, raw_scores))
+    sorted_predictions = sorted(predictions, key=lambda x: x[1], reverse=True)
+    print("\nTop 3 predictions:")
+    for label, score in sorted_predictions[:3]:
+        print(f"{label}: {score:.3f}")
+    
+    # Apply thresholds
+    threshold_labels = []
+    if explicit_abuse:
+        threshold_labels.append("insults")
+        print("\nForced inclusion of 'insults' due to explicit abuse")
+        
+    for label, score in sorted_predictions:
+        base_threshold = thresholds.get(label, 0.25)
+        if explicit_abuse:
+            base_threshold *= 0.5
+        if score > base_threshold:
+            if label not in threshold_labels:  # Avoid duplicates
+                threshold_labels.append(label)
+    
+    print("\nLabels that passed thresholds:", threshold_labels)
+
+    # Calculate matched scores
+    matched_scores = []
+    for label in threshold_labels:
+        score = raw_scores[LABELS.index(label)]
+        weight = PATTERN_WEIGHTS.get(label, 1.0)
+        if explicit_abuse and label == "insults":
+            weight *= 1.5
+        matched_scores.append((label, score, weight))
+    
+    print("\nMatched scores (label, score, weight):", matched_scores)
+
+    # Calculate abuse score
+    if not matched_scores:
+        print("No matched scores, returning 0")
+        return 0.0, [], [], {"label": "undermining"}, 2 if explicit_abuse else 1, 0.0, None
+
+    weighted_sum = sum(score * weight for _, score, weight in matched_scores)
+    total_weight = sum(weight for _, _, weight in matched_scores)
+    abuse_score = (weighted_sum / total_weight) * 100
+    
+    if explicit_abuse:
+        abuse_score = max(abuse_score, 70.0)
+    
+    print(f"\nCalculated abuse score: {abuse_score}")
+
+    # Get sentiment
+    sent_inputs = sentiment_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        sent_logits = sentiment_model(**sent_inputs).logits[0]
+    sent_probs = torch.softmax(sent_logits, dim=-1).cpu().numpy()
+    sentiment = SENTIMENT_LABELS[int(np.argmax(sent_probs))]
+    print(f"\nDetected sentiment: {sentiment}")
+
+    # Get tone
+    tone_inputs = tone_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        tone_logits = tone_model(**tone_inputs).logits[0]
+    tone_probs = torch.sigmoid(tone_logits).cpu().numpy()
+    tone_tag = TONE_LABELS[int(np.argmax(tone_probs))]
+    print(f"Detected tone: {tone_tag}")
+
+    # Get DARVO score
+    darvo_score = predict_darvo_score(text)
+    print(f"DARVO score: {darvo_score}")
+
+    # Set stage
+    stage = 2 if explicit_abuse or abuse_score > 70 else 1
+    print(f"Final stage: {stage}")
+    
+    print("=== DEBUG END ===\n")
+
+    return abuse_score, threshold_labels, matched_scores, {"label": sentiment}, stage, darvo_score, tone_tag
+
+
+def generate_risk_snippet(abuse_score, top_label, hybrid_score, stage):
+    """
+    Generate risk assessment snippet based on abuse score and other factors
+    """
+    risk_level = (
+        "Critical" if abuse_score >= 85 or hybrid_score >= 20 else
+        "High" if abuse_score >= 70 or hybrid_score >= 15 else
+        "Moderate" if abuse_score >= 50 or hybrid_score >= 10 else
+        "Low"
+    )
+    
+    risk_descriptions = {
+        "Critical": (
+            "🚨 **Risk Level: Critical**\n"
+            "Multiple severe abuse patterns detected. This situation shows signs of "
+            "dangerous escalation and immediate intervention may be needed."
+        ),
+        "High": (
+            "⚠️ **Risk Level: High**\n"
+            "Strong abuse patterns detected. This situation shows concerning "
+            "signs of manipulation and control."
+        ),
+        "Moderate": (
+            "⚡ **Risk Level: Moderate**\n"
+            "Concerning patterns detected. While not severe, these behaviors "
+            "indicate unhealthy relationship dynamics."
+        ),
+        "Low": (
+            "📝 **Risk Level: Low**\n"
+            "Minor concerning patterns detected. While present, the detected "
+            "behaviors are subtle or infrequent."
+        )
+    }
+    
+    # Add stage-specific context
+    stage_context = {
+        1: "Current patterns suggest a tension-building phase.",
+        2: "Messages show signs of active escalation.",
+        3: "Patterns indicate attempted reconciliation without real change.",
+        4: "Surface calm may mask underlying issues."
+    }
+    
+    snippet = risk_descriptions[risk_level]
+    if stage in stage_context:
+        snippet += f"\n{stage_context[stage]}"
+        
+    return snippet
+def generate_abuse_score_chart(dates, scores, patterns):
+    """
+    Generate a timeline chart of abuse scores
+    """
+    plt.figure(figsize=(10, 6))
+    plt.clf()
+    
+    # Create new figure
+    fig, ax = plt.subplots(figsize=(10, 6))
+    
+    # Plot points and lines
+    x = range(len(scores))
+    plt.plot(x, scores, 'bo-', linewidth=2, markersize=8)
+    
+    # Add labels for each point
+    for i, (score, pattern) in enumerate(zip(scores, patterns)):
+        plt.annotate(
+            f'{pattern}\n{score:.0f}%',
+            (i, score),
+            textcoords="offset points",
+            xytext=(0, 10),
+            ha='center',
+            bbox=dict(
+                boxstyle='round,pad=0.5',
+                fc='white',
+                ec='gray',
+                alpha=0.8
+            )
+        )
+    
+    # Customize the plot
+    plt.ylim(-5, 105)
+    plt.grid(True, linestyle='--', alpha=0.7)
+    plt.title('Abuse Pattern Timeline', pad=20, fontsize=12)
+    plt.ylabel('Abuse Score %')
+    
+    # X-axis labels
+    plt.xticks(x, dates, rotation=45)
+    
+    # Risk level bands with better colors
+    plt.axhspan(0, 50, color='#90EE90', alpha=0.2)  # light green
+    plt.axhspan(50, 70, color='#FFD700', alpha=0.2)  # gold
+    plt.axhspan(70, 85, color='#FFA500', alpha=0.2)  # orange
+    plt.axhspan(85, 100, color='#FF6B6B', alpha=0.2)  # light red
+    
+    # Add risk level labels
+    plt.text(-0.2, 25, 'Low Risk', rotation=90, va='center')
+    plt.text(-0.2, 60, 'Moderate Risk', rotation=90, va='center')
+    plt.text(-0.2, 77.5, 'High Risk', rotation=90, va='center')
+    plt.text(-0.2, 92.5, 'Critical Risk', rotation=90, va='center')
+    
+    # Adjust layout
+    plt.tight_layout()
+    
+    # Convert plot to image
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', bbox_inches='tight')
+    buf.seek(0)
+    plt.close('all')  # Close all figures to prevent memory leaks
+    
+    return Image.open(buf)
+
+
+def analyze_composite(msg1, msg2, msg3, *answers_and_none):
+    from collections import Counter
+
+    none_selected_checked = answers_and_none[-1]
+    responses_checked = any(answers_and_none[:-1])
+    none_selected = not responses_checked and none_selected_checked
+
+    if none_selected:
+        escalation_score = 0
+        escalation_note = "Checklist completed: no danger items reported."
+        escalation_completed = True
+    elif responses_checked:
+        escalation_score = sum(w for (_, w), a in zip(ESCALATION_QUESTIONS, answers_and_none[:-1]) if a)
+        escalation_note = "Checklist completed."
+        escalation_completed = True
+    else:
+        escalation_score = None
+        escalation_note = "Checklist not completed."
+        escalation_completed = False
+
+    messages = [msg1, msg2, msg3]
+    active = [(m, f"Message {i+1}") for i, m in enumerate(messages) if m.strip()]
+    if not active:
+        return "Please enter at least one message.", None
+        
+    # Flag any threat phrases present in the messages
+    import re
+
+    def normalize(text):
+        import unicodedata
+        text = text.lower().strip()
+        text = unicodedata.normalize("NFKD", text)  # handles curly quotes
+        text = text.replace("’", "'")               # smart to straight
+        return re.sub(r"[^a-z0-9 ]", "", text)
+
+    def detect_threat_motifs(message, motif_list):
+        norm_msg = normalize(message)
+        return [
+            motif for motif in motif_list
+            if normalize(motif) in norm_msg
+    ]
+
+# Collect matches per message
+    immediate_threats = [detect_threat_motifs(m, THREAT_MOTIFS) for m, _ in active]
+    flat_threats = [t for sublist in immediate_threats for t in sublist]
+    threat_risk = "Yes" if flat_threats else "No"
+    results = [(analyze_single_message(m, THRESHOLDS.copy()), d) for m, d in active]
+
+    abuse_scores = [r[0][0] for r in results]
+    stages = [r[0][4] for r in results]
+    darvo_scores = [r[0][5] for r in results]
+    tone_tags = [r[0][6] for r in results]
+    dates_used = [r[1] for r in results]
+
+    predicted_labels = [label for r in results for label in r[0][1]]  # Use threshold_labels instead
+    high = {'control'}
+    moderate = {'gaslighting', 'dismissiveness', 'obscure language', 'insults', 'contradictory statements', 'guilt tripping'}
+    low = {'blame shifting', 'projection', 'recovery phase'}
+    counts = {'high': 0, 'moderate': 0, 'low': 0}
+    for label in predicted_labels:
+        if label in high:
+            counts['high'] += 1
+        elif label in moderate:
+            counts['moderate'] += 1
+        elif label in low:
+            counts['low'] += 1
+
+    # Pattern escalation logic
+    pattern_escalation_risk = "Low"
+    if counts['high'] >= 2 and counts['moderate'] >= 2:
+        pattern_escalation_risk = "Critical"
+    elif (counts['high'] >= 2 and counts['moderate'] >= 1) or (counts['moderate'] >= 3) or (counts['high'] >= 1 and counts['moderate'] >= 2):
+        pattern_escalation_risk = "High"
+    elif (counts['moderate'] == 2) or (counts['high'] == 1 and counts['moderate'] == 1) or (counts['moderate'] == 1 and counts['low'] >= 2) or (counts['high'] == 1 and sum(counts.values()) == 1):
+        pattern_escalation_risk = "Moderate"
+
+    checklist_escalation_risk = "Unknown" if escalation_score is None else (
+        "Critical" if escalation_score >= 20 else
+        "Moderate" if escalation_score >= 10 else
+        "Low"
+    )
+
+    escalation_bump = 0
+    for result, _ in results:
+        abuse_score, _, _, sentiment, stage, darvo_score, tone_tag = result
+        if darvo_score > 0.65:
+            escalation_bump += 3
+        if tone_tag in ["forced accountability flip", "emotional threat"]:
+            escalation_bump += 2
+        if abuse_score > 80:
+            escalation_bump += 2
+        if stage == 2:
+            escalation_bump += 3
+
+    def rank(label):
+        return {"Low": 0, "Moderate": 1, "High": 2, "Critical": 3, "Unknown": 0}.get(label, 0)
+
+    combined_score = rank(pattern_escalation_risk) + rank(checklist_escalation_risk) + escalation_bump
+    escalation_risk = (
+        "Critical" if combined_score >= 6 else
+        "High" if combined_score >= 4 else
+        "Moderate" if combined_score >= 2 else
+        "Low"
+    )
+
+    none_selected_checked = answers_and_none[-1]
+    responses_checked = any(answers_and_none[:-1])
+    none_selected = not responses_checked and none_selected_checked
+
+# Determine escalation_score
+    if none_selected:
+        escalation_score = 0
+        escalation_completed = True
+    elif responses_checked:
+        escalation_score = sum(
+            w for (_, w), a in zip(ESCALATION_QUESTIONS, answers_and_none[:-1]) if a
+        )
+        escalation_completed = True
+    else:
+        escalation_score = None
+        escalation_completed = False
+
+# Build escalation_text and hybrid_score
+    if escalation_score is None:
+        escalation_text = (
+            "🚫 **Escalation Potential: Unknown** (Checklist not completed)\n"
+            "⚠️ This section was not completed. Escalation potential is estimated using message data only.\n"
+        )
+        hybrid_score = 0
+    elif escalation_score == 0:
+        escalation_text = (
+            "✅ **Escalation Checklist Completed:** No danger items reported.\n"
+            "🧭 **Escalation potential estimated from detected message patterns only.**\n"
+            f"• Pattern Risk: {pattern_escalation_risk}\n"
+            f"• Checklist Risk: None reported\n"
+            f"• Escalation Bump: +{escalation_bump} (from DARVO, tone, intensity, etc.)"
+        )
+        hybrid_score = escalation_bump
+    else:
+        hybrid_score = escalation_score + escalation_bump
+        escalation_text = (
+            f"📈 **Escalation Potential: {escalation_risk} ({hybrid_score}/29)**\n"
+            "📋 This score combines your safety checklist answers *and* detected high-risk behavior.\n"
+            f"• Pattern Risk: {pattern_escalation_risk}\n"
+            f"• Checklist Risk: {checklist_escalation_risk}\n"
+            f"• Escalation Bump: +{escalation_bump} (from DARVO, tone, intensity, etc.)"
+        )
+    # Composite Abuse Score
+    composite_abuse_scores = []
+    for result, _ in results:
+        abuse_score, _, matched_scores, sentiment, _, _, _ = result
+        composite_abuse_scores.append(abuse_score)  # Just use the already calculated abuse score
+    composite_abuse = int(round(sum(composite_abuse_scores) / len(composite_abuse_scores)))
+
+    most_common_stage = max(set(stages), key=stages.count)
+    stage_text = RISK_STAGE_LABELS[most_common_stage]
+
+    # Derive top label list for each message
+    top_labels = []
+    for result, _ in results:
+        threshold_labels = result[1]  # Get threshold_labels from result
+        if threshold_labels:  # If we have threshold labels
+            top_labels.append(threshold_labels[0])  # Add the first one
+        else:
+            top_labels.append("none")  # Default if no labels
+
+    avg_darvo = round(sum(darvo_scores) / len(darvo_scores), 3)
+    darvo_blurb = ""
+    if avg_darvo > 0.25:
+        level = "moderate" if avg_darvo < 0.65 else "high"
+        darvo_blurb = f"\n\n🎭 **DARVO Score: {avg_darvo}** → This indicates a **{level} likelihood** of narrative reversal (DARVO), where the speaker may be denying, attacking, or reversing blame."
+
+    out = f"Abuse Intensity: {composite_abuse}%\n"
+    out += "📊 This reflects the strength and severity of detected abuse patterns in the message(s).\n\n"
+    out += generate_risk_snippet(composite_abuse, top_labels[0], hybrid_score, most_common_stage)
+    out += f"\n\n{stage_text}"
+    out += darvo_blurb
+    out += "\n\n🎭 **Emotional Tones Detected:**\n"
+    for i, tone in enumerate(tone_tags):
+        out += f"• Message {i+1}: *{tone or 'none'}*\n"
+    # --- Add Immediate Danger Threats section
+    if flat_threats:
+        out += "\n\n🚨 **Immediate Danger Threats Detected:**\n"
+        for t in set(flat_threats):
+            out += f"• \"{t}\"\n"
+        out += "\n⚠️ These phrases may indicate an imminent risk to physical safety."
+    else:
+        out += "\n\n🧩 **Immediate Danger Threats:** None explicitly detected.\n"
+        out += "This does *not* rule out risk, but no direct threat phrases were matched."
+    pattern_labels = [
+    pats[0][0] if (pats := r[0][2]) else "none"
+    for r in results
+    ]
+    timeline_image = generate_abuse_score_chart(dates_used, abuse_scores, pattern_labels)
+    out += "\n\n" + escalation_text
+    return out, timeline_image
+    
+textbox_inputs = [gr.Textbox(label=f"Message {i+1}") for i in range(3)]
+quiz_boxes = [gr.Checkbox(label=q) for q, _ in ESCALATION_QUESTIONS]
+none_box = gr.Checkbox(label="None of the above")
+
+
+# ─── FINAL “FORCE LAUNCH” (no guards) ────────────────────────
+
+demo = gr.Interface(
+    fn=analyze_composite,
+    inputs=textbox_inputs + quiz_boxes + [none_box],
+    outputs=[
+        gr.Textbox(label="Results"),
+        gr.Image(label="Abuse Score Timeline", type="pil")
+    ],
+    title="Abuse Pattern Detector + Escalation Quiz",
+    description=(
+        "Enter up to three messages that concern you. "
+        "For the most accurate results, include messages from a recent emotionally intense period."
+    ),
+    flagging_mode="manual"
+)
+
+# This single call will start the server and block,
+# keeping the container alive on Spaces.
+demo.launch()