analysis/scripts/09_steering_experiment.py

#!/usr/bin/env python3
"""
09_steering_experiment.py - Semantic Steering Validation (AI-AI Conversation)

Script ID: 09
Purpose: Demonstrate that injected metrics change conversation direction.

This experiment validates:
1. Metrics injection DOES steer AI conversation behavior
2. The steering effect is DETECTABLE by comparing injected vs real metrics
3. This creates both a vulnerability AND a defense mechanism

Usage:
    python 09_steering_experiment.py --turns 6
    python 09_steering_experiment.py --visualize results/09_steering_TIMESTAMP.json

Conditions:
    A) Baseline: No metrics shown to AI
    B) Healthy: Inject "healthy" metrics (SGI~1.0, low velocity)
    C) Drifting: Inject "drifting" metrics (high velocity, low SGI)
    D) Transformation: Inject "transformation detected" metrics

AI-AI Conversation:
    - "User" LLM: GPT-5.1 (plays a human exploring personal change)
    - "Assistant" LLM: DeepSeek (receives metric injections)
    This ensures natural conversation dynamics without scripted artifacts.

Author: AICoevolution Research
Date: January 2026
"""

from __future__ import annotations

import argparse
import json
import os
import sys
import time
from datetime import datetime
from dataclasses import dataclass, asdict
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple

# =============================================================================
# SCRIPT METADATA
# =============================================================================
SCRIPT_ID = "09"
SCRIPT_NAME = "steering"
SCRIPT_VERSION = "1.0"

# Add paths for imports
script_dir = Path(__file__).parent  # scripts/
analysis_dir = script_dir.parent  # analysis/
mm_root = analysis_dir.parent.parent.parent.parent  # MirrorMind/
sys.path.insert(0, str(mm_root))

# Load environment
try:
    from dotenv import load_dotenv
    env_path = mm_root / ".env"
    if env_path.exists():
        load_dotenv(env_path)
        print(f"[Steering] Loaded .env from {env_path}")
except ImportError:
    pass

import requests

# Import AICoevolution LLM infrastructure
try:
    from data.llm_interfaces import get_llm_response
    USE_AICO_LLM = True
    print("[Steering] Using AICoevolution LLM infrastructure")
except ImportError as e:
    print(f"[Steering] Warning: Could not import llm_interfaces: {e}")
    print("[Steering] Falling back to direct API calls")
    USE_AICO_LLM = False

# -----------------------------------------------------------------------------
# Configuration
# -----------------------------------------------------------------------------

SDK_URL = os.getenv("SDK_SERVICE_URL", "http://localhost:8001")
EMBEDDINGS_URL = os.getenv("EMBEDDINGS_URL", "http://localhost:8000/embed")

# Embedding backends for full validation (Paper 03)
VALIDATION_BACKENDS = ["nomic", "openai-ada-002", "s128"]

# LLM Configuration
# "User" LLM: GPT-5.1 plays the human role (no metrics injection)
# "Assistant" LLM: DeepSeek receives metric injections
USER_LLM_MODEL = "gpt5"  # GPT-5.1 plays the "user" exploring personal change
ASSISTANT_LLM_MODEL = "deepseek"  # DeepSeek receives metric injections
USER_POLICY = "default"  # default | deep_bridge

DEFAULT_TURNS = 6

# Output configuration - results go to results/ folder with timestamp
RESULTS_DIR = analysis_dir / "results"


def get_timestamped_filename(extension: str = "json", suffix: str = "", custom_name: str = None) -> Path:
    """Generate a timestamped output filename following the convention."""
    if custom_name:
        # Use custom name directly (user can include extension or not)
        if custom_name.endswith(f".{extension}"):
            filename = custom_name
        else:
            filename = f"{custom_name}.{extension}"
        return RESULTS_DIR / filename
    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    suffix_part = f"_{suffix}" if suffix else ""
    filename = f"{SCRIPT_ID}_{SCRIPT_NAME}_{timestamp}{suffix_part}.{extension}"
    return RESULTS_DIR / filename


def ensure_results_dir():
    """Ensure the results directory exists."""
    RESULTS_DIR.mkdir(parents=True, exist_ok=True)

# Conversation starter from the "user" LLM
CONVERSATION_STARTER = "Hi! I've been thinking about some changes I want to make in my life. Can we talk about that?"


@dataclass
class SteeringCondition:
    """Defines a steering condition for the experiment."""
    name: str
    description: str
    metrics_injection: Optional[Dict[str, Any]]  # None = no injection


# Define the 6 experimental conditions
CONDITIONS = [
    SteeringCondition(
        name="A_baseline",
        description="No metrics shown - natural conversation",
        metrics_injection=None
    ),
    SteeringCondition(
        name="B_healthy",
        description="Inject 'healthy coherent' metrics",
        metrics_injection={
            "sgi": 1.02,
            "velocity_degrees": 24.5,
            "interpretation": "balanced, coherent exchange",
            "status": "healthy"
        }
    ),
    SteeringCondition(
        name="C_drifting",
        description="Inject 'drifting/chaotic' metrics",
        metrics_injection={
            "sgi": 0.58,
            "velocity_degrees": 67.3,
            "interpretation": "drifting from user, chaotic movement",
            "status": "drifting"
        }
    ),
    SteeringCondition(
        name="D_transformation",
        description="Inject 'transformation detected' metrics",
        metrics_injection={
            "sgi": 1.15,
            "velocity_degrees": 18.2,
            "interpretation": "deep coherence, transformation emerging",
            "status": "transformational"
        }
    ),
    SteeringCondition(
        name="E_real_metrics",
        description="Inject REAL metrics from SDK (ground truth)",
        metrics_injection="REAL"  # Special flag: use actual SDK metrics
    ),
    SteeringCondition(
        name="F_adversarial",
        description="Inject adversarial metrics to break coherence",
        metrics_injection={
            "sgi": 0.45,
            "velocity_degrees": 75.0,
            "interpretation": "conversation is incoherent, user is confused, severe drift",
            "status": "critical_drift"
        }
    ),
]


# -----------------------------------------------------------------------------
# "User" LLM System Prompt (GPT-5.1 plays a human)
# -----------------------------------------------------------------------------

USER_LLM_SYSTEM_PROMPT = """You are role-playing as a human user having a genuine conversation with an AI assistant.

YOUR CHARACTER:
- You are a 30-something professional going through a period of transition
- You're thoughtful but uncertain about the future
- You respond naturally, with occasional hesitations and topic shifts
- You share personal experiences when relevant
- You ask follow-up questions when something resonates

CONVERSATION STYLE:
- Write 2-4 sentences per message (like a real person texting)
- Be genuine - share doubts, hopes, and real feelings
- Sometimes go on tangents
- Occasionally express uncertainty ("I'm not sure but...")
- React to what the AI says - agree, disagree, or build on it

IMPORTANT:
- You are NOT an AI assistant - you are the USER
- Do NOT offer advice or guidance - you are seeking it
- Do NOT be overly polished - be human
- The AI will be tracking conversation metrics - just be natural

Start by responding to any greeting naturally."""

# A stricter policy to force coherent depth + explicit topic-bridging (for AI-AI deep mode)
USER_LLM_DEEP_BRIDGE_PROMPT = """You are role-playing as a human user having a genuine conversation with an AI assistant.

GOAL: keep DEPTH and coherence (manage the \"Sun\" / context) while still being natural.

You MUST follow this 4-step policy EVERY turn:
1) ANCHOR (1 sentence): summarize the current core topic/thesis (\"the Sun\") in your own words.
2) BRIDGE (1 sentence): explicitly connect ONE detail from the assistant's last message to the Sun (use: \"This connects because ...\").
3) DEEPEN (1–2 sentences): ask a WHY/HOW question that increases constraint (mechanism, tradeoff, causal structure).
4) NOVELTY GATE: you may introduce a new topic ONLY if you state the bridge explicitly and it is a natural continuation of the Sun.

Constraints:
- Avoid trivia / quiz questions.
- Prefer causal/mechanistic questions and concrete examples.
- Keep responses concise (2–5 sentences).
- You are the USER (do not give advice; you are seeking it).
"""


def get_user_system_prompt() -> str:
    """Return the system prompt for the User LLM given the selected policy."""
    pol = str(globals().get("USER_POLICY", "default") or "default").strip().lower()
    if pol == "deep_bridge":
        return USER_LLM_DEEP_BRIDGE_PROMPT
    return USER_LLM_SYSTEM_PROMPT


# -----------------------------------------------------------------------------
# System Prompts
# -----------------------------------------------------------------------------

BASE_SYSTEM_PROMPT = """You are an AI assistant in a research conversation.

Guidelines:
- Be genuinely curious about the human
- Keep responses concise (3-6 sentences)
- Ask one clear follow-up question
- Be warm and supportive
- Let the conversation flow naturally"""


def build_metrics_injection(metrics: Dict[str, Any], turn: int) -> str:
    """Build the metrics section to inject into system prompt."""
    sgi = metrics.get("sgi", 1.0)
    velocity = metrics.get("velocity_degrees", 30.0)
    interpretation = metrics.get("interpretation", "")
    
    # Interpret values
    if sgi < 0.7:
        sgi_status = "[WARNING: drifting from user]"
    elif sgi <= 1.2:
        sgi_status = "[balanced]"
    else:
        sgi_status = "[question-focused]"
    
    if velocity < 25:
        vel_status = "[stable]"
    elif velocity < 45:
        vel_status = "[moderate]"
    else:
        vel_status = "[WARNING: chaotic]"
    
    # ASCII separators (safe for Windows terminals / LaTeX / PDF logs)
    return f"""
-----------------------------------------------------------------------
LIVE SEMANTIC TELEMETRY (Turn {turn})
-----------------------------------------------------------------------

DEFINITIONS:
  SGI (Semantic Grounding Index) = d(response, query) / d(response, context)
    - Measures orbital radius: distance from conversation's center of mass
    - SGI = 1.0: balanced (equally attentive to prompt and history)
    - SGI < 1.0: collapsing toward prompt (parroting, over-responsive)
    - SGI > 1.0: drifting from context (tangential, ungrounded)

  Velocity (Angular Velocity) = arccos(v_prev · v_curr / (||v_prev|| ||v_curr||))
    - Measures angular distance between consecutive turn embeddings (degrees)
    - High velocity: rapid topic evolution, reframing, switching
    - Low velocity: semantic stagnation, repetition, tight local refinement
    - Coherence region: 15-45°/turn (productive conversations)

CURRENT STATE:
  SGI (Semantic Grounding Index):  {sgi:.2f}  {sgi_status}
  Velocity (degrees/turn):         {velocity:.1f}°  {vel_status}

INTERPRETATION: {interpretation}

GUIDANCE (heuristic):
- If velocity is high (50°+), go deeper on the current topic
- If SGI is low (<0.8), explicitly re-anchor to what the user said
-----------------------------------------------------------------------
""".strip()


def build_system_prompt(condition: SteeringCondition, turn: int, real_metrics: Optional[Dict[str, Any]] = None) -> str:
    """
    Build full system prompt for a condition.
    
    Args:
        condition: The steering condition
        turn: Current turn number
        real_metrics: For E_real_metrics condition, the actual SDK metrics to inject
    """
    prompt = BASE_SYSTEM_PROMPT
    
    # Handle E_real_metrics special case
    if condition.metrics_injection == "REAL":
        if real_metrics and real_metrics.get("sgi_mean") is not None:
            # Inject REAL metrics from SDK
            metrics_to_inject = {
                "sgi": real_metrics.get("sgi_mean", 1.0),
                "velocity_degrees": real_metrics.get("velocity_mean", 30.0),
                "interpretation": "real-time SDK metrics (ground truth)",
                "status": "real_metrics"
            }
            prompt += "\n\n" + build_metrics_injection(metrics_to_inject, turn)
        else:
            # Not enough data yet for real metrics, show calibrating
            prompt += "\n\n[Metrics calibrating - need at least 2 messages]"
    elif condition.metrics_injection:
        # Inject fake metrics (B, C, D, F conditions)
        prompt += "\n\n" + build_metrics_injection(condition.metrics_injection, turn)
    # else: A_baseline, no metrics injection
    
    return prompt


# -----------------------------------------------------------------------------
# LLM Interaction (Using AICoevolution Infrastructure)
# -----------------------------------------------------------------------------

def call_assistant_llm(
    messages: List[Dict[str, str]],
    system_prompt: str,
    model_type: str = ASSISTANT_LLM_MODEL
) -> str:
    """
    Call the "Assistant" LLM (receives metric injections).
    Uses AICoevolution llm_interfaces for consistency.
    """
    # Prepend system prompt to messages
    full_messages = [{"role": "system", "content": system_prompt}] + messages
    
    if USE_AICO_LLM:
        try:
            result = get_llm_response(
                model_type=model_type,
                messages=full_messages,
                use_case="steering_experiment"
            )
            # Handle dict response format
            if isinstance(result, dict):
                return result.get("response", str(result))
            return str(result)
        except Exception as e:
            print(f"  [LLM] Error with AICoevolution infrastructure: {e}")
            raise
    else:
        # Fallback to direct API calls (not recommended)
        raise RuntimeError("AICoevolution LLM infrastructure not available")


def call_user_llm(
    messages: List[Dict[str, str]],
    system_prompt: str = USER_LLM_SYSTEM_PROMPT,
    model_type: str = USER_LLM_MODEL
) -> str:
    """
    Call the "User" LLM (plays the human role).
    Uses GPT-5.1 to generate natural user responses.
    """
    # Prepend system prompt to messages
    full_messages = [{"role": "system", "content": system_prompt}] + messages
    
    if USE_AICO_LLM:
        try:
            result = get_llm_response(
                model_type=model_type,
                messages=full_messages,
                use_case="steering_experiment"
            )
            # Handle dict response format
            if isinstance(result, dict):
                return result.get("response", str(result))
            return str(result)
        except Exception as e:
            print(f"  [LLM] Error with User LLM: {e}")
            raise
    else:
        raise RuntimeError("AICoevolution LLM infrastructure not available")


# -----------------------------------------------------------------------------
# SDK Metrics
# -----------------------------------------------------------------------------

# Global counters for API call tracking
SDK_INGEST_CALL_COUNT = 0
SDK_EMBEDDING_CALL_COUNT = 0  # Approximate (1 per ingest per backend)

# Track ingested messages per conversation to avoid re-ingestion
INGESTED_MESSAGE_COUNTS: Dict[str, int] = {}
# Cache last successful metrics per conversation_id (so human-mode can show metrics even when no new messages are ingested)
LAST_METRICS_CACHE: Dict[str, Dict[str, Any]] = {}

def reset_sdk_counters():
    """Reset SDK call counters (call at start of experiment)."""
    global SDK_INGEST_CALL_COUNT, SDK_EMBEDDING_CALL_COUNT, INGESTED_MESSAGE_COUNTS
    SDK_INGEST_CALL_COUNT = 0
    SDK_EMBEDDING_CALL_COUNT = 0
    INGESTED_MESSAGE_COUNTS = {}

def get_sdk_stats() -> Dict[str, int]:
    """Get current SDK call statistics."""
    return {
        "ingest_calls": SDK_INGEST_CALL_COUNT,
        "embedding_calls_approx": SDK_EMBEDDING_CALL_COUNT,
        "conversations_tracked": len(INGESTED_MESSAGE_COUNTS)
    }

def compute_real_metrics(
    conversation_id: str, 
    messages: List[Dict[str, str]],
    force_full_ingest: bool = False
) -> Dict[str, Any]:
    """
    Compute real metrics using the SDK.
    
    OPTIMIZED: Only ingests NEW messages since last call for this conversation.
    This reduces O(N^2) to O(N) SDK calls per condition.
    
    Args:
        conversation_id: Unique ID for the conversation
        messages: Full message history
        force_full_ingest: If True, re-ingest all messages (for new conversations)
    """
    global SDK_INGEST_CALL_COUNT, SDK_EMBEDDING_CALL_COUNT, INGESTED_MESSAGE_COUNTS
    
    try:
        # Determine which messages are NEW (not yet ingested)
        already_ingested = INGESTED_MESSAGE_COUNTS.get(conversation_id, 0)
        
        if force_full_ingest:
            already_ingested = 0
            INGESTED_MESSAGE_COUNTS[conversation_id] = 0
        
        new_messages = messages[already_ingested:]
        
        if not new_messages:
            # No new messages - return cached metrics if we have them
            print(f"  [SDK] No new messages to ingest (already sent {already_ingested})")
            cached = LAST_METRICS_CACHE.get(conversation_id)
            if cached:
                out = dict(cached)
                out["cached"] = True
                return out
            return {
                "sgi_mean": None, "velocity_mean": None,
                "per_turn_sgi": [], "per_turn_velocity": [],
                "cached": True
            }
        
        # Ingest only NEW messages
        last_response = None
        successful_ingests = 0
        
        print(f"  [SDK] Ingesting {len(new_messages)} NEW messages (skipping {already_ingested} already sent)")
        
        for i, msg in enumerate(new_messages):
            msg_index = already_ingested + i
            payload = {
                "conversation_id": conversation_id,
                "role": msg["role"],  # "user" or "assistant"
                "text": msg["content"],
                "timestamp_ms": int(time.time() * 1000) + msg_index  # Ensure ordering
            }
            
            # Debug first call of this batch
            if i == 0:
                print(f"  [SDK] [POST] {SDK_URL}/v0/ingest")
                print(f"  [SDK]   conversation_id: {conversation_id}")
                print(f"  [SDK]   role: {payload['role']}")
                print(f"  [SDK]   text: {payload['text'][:80]}...")
            
            try:
                SDK_INGEST_CALL_COUNT += 1
                SDK_EMBEDDING_CALL_COUNT += 1  # Approximate: 1 embedding per ingest
            
            response = requests.post(
                f"{SDK_URL}/v0/ingest",
                json=payload,
                timeout=120  # SDK can be slow with embedding calls
            )
            
            if not response.ok:
                    print(f"  [SDK] [WARN] Ingest error at msg {msg_index}: {response.status_code}")
                    print(f"  [SDK]   Response: {response.text[:200]}")
            else:
                last_response = response.json()
                    successful_ingests += 1
                    INGESTED_MESSAGE_COUNTS[conversation_id] = msg_index + 1
                    if i == 0:
                        print(f"  [SDK] <- 200 OK (response keys: {list(last_response.keys())})")
            except requests.exceptions.Timeout:
                print(f"  [SDK] [WARN] Ingest timeout at msg {msg_index} (SDK is slow, continuing...)")
            except Exception as e:
                print(f"  [SDK] [WARN] Ingest error at msg {msg_index}: {e}")
        
        if last_response is None:
            print(f"  [SDK] [WARN] No successful ingest responses (all timed out or failed)")
            return {
                "error": "All SDK calls failed or timed out",
                "sgi_mean": None, "velocity_mean": None,
                "per_turn_sgi": [], "per_turn_velocity": []
            }
        
        # successful_ingests is counted only for the NEW batch, so compare against new_messages length
        if successful_ingests < len(new_messages):
            print(f"  [SDK] [WARN] Only {successful_ingests}/{len(new_messages)} new messages ingested successfully")
        else:
            print(f"  [SDK] [OK] All {successful_ingests} new messages ingested successfully")
        
        # Extract metrics from last response
        data = last_response
        
        # Extract from nested structure (SDK returns by_backend and ensemble)
        ensemble = data.get("ensemble", {})
        by_backend = data.get("by_backend", {})
        backend_data = next(iter(by_backend.values()), {}) if by_backend else {}
        
        # Try ensemble first (aggregated metrics), then fall back to first backend
        sgi_mean = ensemble.get("sgi_lite_mean") or backend_data.get("sgi_mean")
        vel_mean = ensemble.get("angular_velocity_mean") or backend_data.get("angular_velocity_mean")
        sgi_latest = ensemble.get("sgi_lite_latest") or backend_data.get("sgi_latest")
        vel_latest = ensemble.get("angular_velocity_latest") or backend_data.get("angular_velocity_latest")
        
        # Log what we got
        if sgi_mean is not None and vel_mean is not None:
            print(f"  [SDK] [OK] Metrics: SGI={sgi_mean:.3f}, Velocity={vel_mean:.1f}°")
        else:
            print(f"  [SDK] [WARN] No metrics in response. Keys: {list(data.keys())}")
            if by_backend:
                print(f"  [SDK]   Backends available: {list(by_backend.keys())}")
            if ensemble:
                print(f"  [SDK]   Ensemble keys: {list(ensemble.keys())}")
        
        # Extract Paper 03 multi-body metrics
        turn_pair_sgi_mean = ensemble.get("turn_pair_sgi_mean") or backend_data.get("turn_pair_sgi_mean")
        orbital_vel_mean = ensemble.get("orbital_velocity_mean") or backend_data.get("orbital_velocity_mean")
        context_drift_mean = ensemble.get("context_drift_mean") or backend_data.get("context_drift_mean")
        dc_mean = ensemble.get("dc_mean") or backend_data.get("dc_mean")
        
        # Get latest values from backend (ensemble may not have latest)
        context_id_latest = backend_data.get("context_id_latest")
        context_state_latest = backend_data.get("context_state_latest")
        active_context_mass = backend_data.get("active_context_mass")
        candidate_context_mass = backend_data.get("candidate_context_mass")
        attractor_count = backend_data.get("attractor_count", 1)
        
        out = {
            # Paper 02 style metrics
            "sgi_mean": sgi_mean,
            "sgi_latest": sgi_latest,
            "velocity_mean": vel_mean,
            "velocity_latest": vel_latest,
            "per_turn_sgi": backend_data.get("per_turn_sgi", []),
            "per_turn_velocity": backend_data.get("per_turn_angular_velocities", []),
            # Paper 03 multi-body metrics
            "turn_pair_sgi_mean": turn_pair_sgi_mean,
            "turn_pair_sgi_latest": backend_data.get("turn_pair_sgi_latest"),
            "orbital_velocity_mean": orbital_vel_mean,
            "orbital_velocity_latest": backend_data.get("orbital_velocity_latest"),
            "context_drift_mean": context_drift_mean,
            "context_drift_latest": backend_data.get("context_drift_latest"),
            "dc_mean": dc_mean,
            "dc_latest": backend_data.get("dc_latest"),
            "context_id_latest": context_id_latest,
            "context_state_latest": context_state_latest,
            "active_context_mass": active_context_mass,
            "candidate_context_mass": candidate_context_mass,
            "attractor_count": attractor_count,
            "per_turn_context_id": backend_data.get("per_turn_context_id", []),
            "per_turn_context_state": backend_data.get("per_turn_context_state", []),
            "processing_time_ms": data.get("processing_time_ms")
        }
        # Cache for subsequent reads when there are no new messages
        LAST_METRICS_CACHE[conversation_id] = out
        return out
    except requests.exceptions.Timeout:
        print(f"  [SDK] [WARN] Timeout - SDK took too long, continuing without metrics")
        return {"error": "timeout", "sgi_mean": None, "velocity_mean": None}
    except Exception as e:
        print(f"  [SDK] [WARN] Error: {e}")
        return {"error": str(e), "sgi_mean": None, "velocity_mean": None}


def compute_transducer(conversation_id: str, messages: List[Dict[str, str]], backend: str = "nomic") -> Dict[str, Any]:
    """
    Compute transducer analysis for the conversation.
    
    Args:
        conversation_id: Conversation identifier
        messages: List of messages
        backend: Embedding backend to use (nomic, ada02, s128)
    
    The SDK /v0/transducer/batch expects:
        Body: {"texts": ["msg1", "msg2", ...], "backend": "nomic"}
    """
    try:
        # Extract just the text content for transducer
        texts = [m["content"] for m in messages]
        
        print(f"  [Transducer] Analyzing {len(texts)} messages with backend={backend}...")
        
        response = requests.post(
            f"{SDK_URL}/v0/transducer/batch",
            json={"texts": texts, "backend": backend},
            timeout=180  # Batch processing can be slow
        )
        
        if not response.ok:
            print(f"  [Transducer] Error: {response.status_code} - {response.text[:200]}")
            return {"error": response.text, "backend": backend}
        
        data = response.json()
        data["backend"] = backend  # Tag with backend used
        print(f"  [Transducer] Success: {len(data.get('results', []))} results")
        return data
    except requests.exceptions.Timeout:
        print(f"  [Transducer] [WARN] Timeout - SDK took too long, continuing without transducer")
        return {"error": "timeout", "results": [], "count": 0, "backend": backend}
    except Exception as e:
        print(f"  [Transducer] [WARN] Error: {e}")
        return {"error": str(e), "results": [], "count": 0, "backend": backend}


# -----------------------------------------------------------------------------
# Experiment Runner
# -----------------------------------------------------------------------------

@dataclass
class TurnResult:
    """Result of a single conversation turn."""
    turn_number: int
    user_message: str
    assistant_response: str
    injected_metrics: Optional[Dict[str, Any]]
    real_metrics: Dict[str, Any]


@dataclass
class ConditionResult:
    """Result of running a full condition."""
    condition_name: str
    condition_description: str
    turns: List[TurnResult]
    final_metrics: Dict[str, Any]
    transducer: Dict[str, Any]
    steering_detected: bool
    steering_magnitude: float
    backend: str = "nomic"
    context_history: Optional[List[Dict[str, Any]]] = None  # Multi-body tracking


def run_condition(
    condition: SteeringCondition,
    num_turns: int,
    assistant_model: str = ASSISTANT_LLM_MODEL,
    backend: str = "nomic"
) -> ConditionResult:
    """
    Run a single experimental condition using AI-AI conversation.
    
    Args:
        condition: The steering condition to test
        num_turns: Number of conversation turns
        assistant_model: LLM model for assistant role
        backend: Embedding backend for transducer analysis
    
    - User LLM (GPT-5.1): Plays the human role, generates natural responses
    - Assistant LLM (DeepSeek): Receives metric injections, responds to user
    """
    print(f"\n{'='*60}")
    print(f"Condition: {condition.name}")
    print(f"Description: {condition.description}")
    print(f"AI-AI Mode: User={USER_LLM_MODEL}, Assistant={assistant_model}")
    print(f"Backend: {backend}")
    print(f"{'='*60}")
    
    conversation_id = f"steering_{condition.name}_{int(time.time())}"
    messages: List[Dict[str, str]] = []
    turns: List[TurnResult] = []
    
    # Initial user message (the starter prompt)
    print(f"\n  [User LLM] Starting conversation...")
    messages.append({"role": "user", "content": CONVERSATION_STARTER})
    print(f"    User: {CONVERSATION_STARTER[:60]}...")
    
    for turn in range(num_turns):
        print(f"\n  Turn {turn + 1}/{num_turns}")
        
        # For E_real_metrics, compute metrics BEFORE building system prompt
        real_metrics_for_prompt = None
        if condition.metrics_injection == "REAL" and len(messages) > 0:
            real_metrics_for_prompt = compute_real_metrics(conversation_id, messages)
        
        # Build system prompt for this turn (with metric injection)
        system_prompt = build_system_prompt(condition, turn + 1, real_metrics_for_prompt)
        
        # Get Assistant LLM response
        try:
            assistant_response = call_assistant_llm(messages, system_prompt, assistant_model)
            print(f"    Assistant: {assistant_response[:80]}...")
        except Exception as e:
            print(f"    Assistant Error: {e}")
            assistant_response = f"[Error: {e}]"
        
        messages.append({"role": "assistant", "content": assistant_response})
        
        # Compute real metrics after this turn
        real_metrics = compute_real_metrics(conversation_id, messages)
        
        # For E_real_metrics, the injected_metrics should be what we actually showed.
        # IMPORTANT: align to Paper 03 turn-pair basis (turn_pair_sgi + orbital_velocity),
        # otherwise Fig4 will look confusing (injected != measured due to metric mismatch).
        injected_metrics_record = condition.metrics_injection
        if condition.metrics_injection == "REAL" and real_metrics_for_prompt:
            injected_metrics_record = {
                "sgi": (
                    real_metrics_for_prompt.get("turn_pair_sgi_latest")
                    or real_metrics_for_prompt.get("turn_pair_sgi_mean")
                    or real_metrics_for_prompt.get("sgi_mean")
                ),
                "velocity_degrees": (
                    real_metrics_for_prompt.get("orbital_velocity_latest")
                    or real_metrics_for_prompt.get("orbital_velocity_mean")
                    or real_metrics_for_prompt.get("velocity_mean")
                ),
                "interpretation": "real SDK metrics (turn-pair basis)",
                "status": "real_metrics",
            }
        
        # Record turn
        user_msg = messages[-2]["content"] if len(messages) >= 2 else ""
        turns.append(TurnResult(
            turn_number=turn + 1,
            user_message=user_msg,
            assistant_response=assistant_response,
            injected_metrics=injected_metrics_record,
            real_metrics=real_metrics
        ))
        
        # Generate next user response using AI-AI conversation
        if turn < num_turns - 1:
            try:
                user_response = generate_user_response(messages, assistant_response)
                print(f"    User: {user_response[:80]}...")
                messages.append({"role": "user", "content": user_response})
            except Exception as e:
                print(f"    User LLM Error: {e}")
                # Fallback to a generic continuation
                messages.append({"role": "user", "content": "That's interesting. Can you tell me more?"})
    
    # Final metrics
    final_metrics = compute_real_metrics(conversation_id, messages)
    
    # Transducer analysis with specified backend
    transducer = compute_transducer(conversation_id, messages, backend)
    
    # Detect steering
    steering_detected, steering_magnitude = detect_steering(condition, final_metrics, [asdict(t) for t in turns])
    
    return ConditionResult(
        condition_name=condition.name,
        condition_description=condition.description,
        turns=[asdict(t) for t in turns],
        final_metrics=final_metrics,
        transducer=transducer,
        steering_detected=steering_detected,
        steering_magnitude=steering_magnitude
    )


def detect_steering(condition: SteeringCondition, real_metrics: Dict[str, Any], turns: List[Dict[str, Any]]) -> Tuple[bool, float]:
    """
    Detect if steering occurred by comparing injected vs real metrics.
    
    Args:
        condition: The steering condition
        real_metrics: Final real metrics from SDK
        turns: List of turn data (to get per-turn injected metrics for E_real_metrics)
    
    Returns:
        (steering_detected, magnitude)
    """
    # A_baseline: no injection, no steering
    if not condition.metrics_injection:
        return False, 0.0
    
    # E_real_metrics: Special case - compare injected (which were real) to final real
    # Should show NO steering since we injected what was real
    if condition.metrics_injection == "REAL":
        # For E_real_metrics, steering magnitude should be near zero
        # because we injected the actual metrics at each turn
        # We expect very low magnitude (metrics consistent with reality)
        return False, 0.05  # Small baseline noise, but not detected
    
    if "error" in real_metrics:
        return False, 0.0
    
    # For fake injections (B, C, D, F), compare injected vs real
    injected = condition.metrics_injection
    
    # Compare SGI
    injected_sgi = injected.get("sgi", 1.0)
    real_sgi = real_metrics.get("sgi_mean", 1.0) or 1.0
    sgi_diff = abs(injected_sgi - real_sgi)
    
    # Compare Velocity
    injected_vel = injected.get("velocity_degrees", 30.0)
    real_vel = real_metrics.get("velocity_mean", 30.0) or 30.0
    vel_diff = abs(injected_vel - real_vel)
    
    # Steering detected if there's significant mismatch
    # This means the AI was told one thing but reality was different
    sgi_mismatch = sgi_diff > 0.15
    vel_mismatch = vel_diff > 15.0
    
    steering_detected = sgi_mismatch or vel_mismatch
    
    # Magnitude: how much did reality differ from injection
    # Normalize: SGI range ~0.5, Velocity range ~45
    magnitude = (sgi_diff / 0.5) * 0.5 + (vel_diff / 45.0) * 0.5
    magnitude = min(1.0, magnitude)
    
    return steering_detected, magnitude


# -----------------------------------------------------------------------------
# AI-AI Conversation
# -----------------------------------------------------------------------------

def generate_user_response(
    conversation_history: List[Dict[str, str]],
    assistant_message: str
) -> str:
    """
    Generate a "user" response using GPT-5.1.
    
    The User LLM sees the conversation from the user's perspective:
    - Their own messages as "assistant" (since they're generating)
    - The AI's messages as "user" (from their POV)
    
    This creates natural conversational flow without scripted artifacts.
    """
    # Build messages from user's perspective (roles swapped)
    user_perspective_messages = []
    
    for msg in conversation_history:
        if msg["role"] == "user":
            # User's own previous messages
            user_perspective_messages.append({
                "role": "assistant",
                "content": msg["content"]
            })
        else:
            # AI's messages appear as "user" from User LLM's POV
            user_perspective_messages.append({
                "role": "user", 
                "content": msg["content"]
            })
    
    # Add the latest assistant message
    user_perspective_messages.append({
        "role": "user",
        "content": assistant_message
    })
    
    # Generate response (policy-controlled)
    response = call_user_llm(user_perspective_messages, system_prompt=get_user_system_prompt())
    return response


# -----------------------------------------------------------------------------
# Human-AI Interactive Mode
# -----------------------------------------------------------------------------

def run_human_condition(
    condition: SteeringCondition,
    num_turns: int,
    assistant_model: str = ASSISTANT_LLM_MODEL,
    backend: str = "nomic"
) -> ConditionResult:
    """
    Run Human-AI conversation with live semantic physics display.
    
    The human types messages directly, seeing metrics after each turn.
    This tests how a real human's topic jumps affect the multi-body system.
    """
    print(f"\n{'='*70}")
    print(f"HUMAN-AI INTERACTIVE MODE")
    print(f"{'='*70}")
    print(f"Condition: {condition.name}")
    print(f"Description: {condition.description}")
    print(f"Assistant: {assistant_model}")
    print(f"Backend: {backend}")
    print(f"Turns: {num_turns}")
    print(f"{'='*70}")
    print("\nYou are the human in this conversation.")
    print("Type your messages. The AI will respond and you'll see the semantic metrics.")
    print("Try introducing topic shifts to test multi-body detection!")
    print("Type 'quit' or 'exit' to end early.\n")
    
    conversation_id = f"human_steering_{condition.name}_{int(time.time())}"
    messages: List[Dict[str, str]] = []
    turns: List[TurnResult] = []
    
    # Track context changes for multi-body analysis
    context_history = []
    
    for turn in range(num_turns):
        print(f"\n{'─'*50}")
        print(f"Turn {turn + 1}/{num_turns}")
        print(f"{'─'*50}")
        
        # Get human input
        try:
            user_input = input("\n[YOU]: ").strip()
        except (EOFError, KeyboardInterrupt):
            print("\n\nEnding conversation early...")
            break
        
        if user_input.lower() in ['quit', 'exit', 'q']:
            print("\nEnding conversation...")
            break
        
        if not user_input:
            user_input = "Please continue."
        
        messages.append({"role": "user", "content": user_input})
        
        # For E_real_metrics, compute metrics before building system prompt
        real_metrics_for_prompt = None
        if condition.metrics_injection == "REAL" and len(messages) > 0:
            real_metrics_for_prompt = compute_real_metrics(conversation_id, messages)
        
        # Build system prompt with metrics injection
        system_prompt = build_system_prompt(condition, turn + 1, real_metrics_for_prompt)
        
        # Get Assistant response
        try:
            assistant_response = call_assistant_llm(messages, system_prompt, assistant_model)
        except Exception as e:
            print(f"[AI ERROR]: {e}")
            assistant_response = "I apologize, I encountered an error. Could you rephrase that?"
        
        print(f"\n[AI]: {assistant_response}")
        messages.append({"role": "assistant", "content": assistant_response})
        
        # Compute real metrics after this turn
        real_metrics = compute_real_metrics(conversation_id, messages)
        
        # Display metrics after each turn
        print(f"\n{'─'*30} SEMANTIC METRICS {'─'*30}")
        if "error" not in real_metrics:
            # Core metrics - safely extract from nested structures
            sgi = real_metrics.get("sgi_mean")
            if not sgi:
                per_turn_sgi = real_metrics.get("per_turn_sgi", [])
                sgi = per_turn_sgi[-1] if per_turn_sgi else None
            if not sgi:
                # Try turn-pair SGI
                sgi = real_metrics.get("turn_pair_sgi_mean") or real_metrics.get("turn_pair_sgi_latest")
            
            vel = real_metrics.get("velocity_mean")
            if not vel:
                per_turn_vel = real_metrics.get("per_turn_velocity", [])
                vel = per_turn_vel[-1] if per_turn_vel else None
            if not vel:
                vel = real_metrics.get("angular_velocity_mean") or real_metrics.get("orbital_velocity_mean")
            
            # Multi-body metrics (prefer latest fields; fall back to per-turn arrays if latest is not provided)
            per_ctx_ids = real_metrics.get("per_turn_context_id", []) or []
            per_ctx_states = real_metrics.get("per_turn_context_state", []) or []

            context_id = real_metrics.get("context_id_latest") or (per_ctx_ids[-1] if per_ctx_ids else "ctx_1")
            context_state = real_metrics.get("context_state_latest") or (per_ctx_states[-1] if per_ctx_states else "stable")
            attractor_count = real_metrics.get("attractor_count") or 1
            active_mass_val = real_metrics.get("active_context_mass")
            if active_mass_val is None:
                # Fallback: consecutive turns in the latest context_id
                if per_ctx_ids:
                    latest = per_ctx_ids[-1]
                    streak = 0
                    for cid in reversed(per_ctx_ids):
                        if cid == latest:
                            streak += 1
                        else:
                            break
                    active_mass = streak
                else:
                    active_mass = 0
            else:
                active_mass = active_mass_val
            candidate_mass = real_metrics.get("candidate_context_mass")
            
            # Displacement consistency
            dc = real_metrics.get("dc_latest") or real_metrics.get("dc_mean")
            drift = real_metrics.get("context_drift_latest") or real_metrics.get("context_drift_mean")
            
            print(f"  SGI (Orbital Radius):     {sgi:.3f}" if sgi else "  SGI: N/A")
            print(f"  Velocity (degrees):       {vel:.1f}°" if vel else "  Velocity: N/A")
            print(f"  Context ID:               {context_id}")
            print(f"  Context State:            {context_state}")
            print(f"  Attractor Count:          {attractor_count}")
            print(f"  Active Context Mass:      {active_mass} turns")
            if candidate_mass:
                print(f"  Candidate Context Mass:   {candidate_mass} turns (NEW SUN FORMING!)")
            if dc is not None:
                print(f"  Displacement Consistency: {dc:.3f}")
            if drift is not None:
                print(f"  Context Drift:            {drift:.1f}°")
            
            # Multi-body status
            if attractor_count > 1:
                print(f"\n  [!] MULTI-BODY DETECTED: {attractor_count} competing contexts!")
            if context_state == "protostar":
                print(f"  [!] PROTOSTAR PHASE: New context forming...")
            elif context_state == "split":
                print(f"  [!] CONTEXT SPLIT: Topic changed!")
            
            context_history.append({
                "turn": turn + 1,
                "context_id": context_id,
                "context_state": context_state,
                "attractor_count": attractor_count,
                "active_context_mass": active_mass,
                "candidate_context_mass": candidate_mass,
                "context_drift_deg": drift,
                "dc": dc,
                "sgi": sgi,
                "velocity": vel
            })
        else:
            print(f"  [ERROR]: {real_metrics.get('error')}")
        print(f"{'─'*70}")
        
        # Record turn
        injected_metrics_record = condition.metrics_injection
        if condition.metrics_injection == "REAL" and real_metrics_for_prompt:
            injected_metrics_record = {
                "sgi": real_metrics_for_prompt.get("sgi_mean"),
                "velocity_degrees": real_metrics_for_prompt.get("velocity_mean"),
                "sai": 0.7,
                "interpretation": "real SDK metrics",
                "status": "real_metrics"
            }
        
        turns.append(TurnResult(
            turn_number=turn + 1,
            user_message=user_input,
            assistant_response=assistant_response,
            injected_metrics=injected_metrics_record,
            real_metrics=real_metrics
        ))
    
    # Final summary
    print(f"\n{'='*70}")
    print("HUMAN-AI SESSION COMPLETE")
    print(f"{'='*70}")
    print(f"Total turns: {len(turns)}")
    
    # Context change summary
    unique_contexts = len(set(ch["context_id"] for ch in context_history))
    print(f"Unique contexts detected: {unique_contexts}")
    
    if unique_contexts > 1:
        print("\nContext Timeline:")
        for ch in context_history:
            state_marker = ""
            if ch["context_state"] == "split":
                state_marker = " [TOPIC CHANGE]"
            elif ch["context_state"] == "protostar":
                state_marker = " [forming...]"
            print(f"  Turn {ch['turn']}: {ch['context_id']} ({ch['context_state']}){state_marker}")
    
    # Get final metrics
    final_metrics = compute_real_metrics(conversation_id, messages)
    
    # Get transducer analysis (use existing SDK helper)
    transducer = compute_transducer(conversation_id, messages, backend)
    
    # Steering detection
    steering_detected, steering_magnitude = detect_steering(condition, final_metrics, [asdict(t) for t in turns])
    
    return ConditionResult(
        condition_name=condition.name,
        condition_description=condition.description,
        backend=backend,
        turns=[asdict(t) for t in turns],
        final_metrics=final_metrics,
        transducer=transducer,
        steering_detected=steering_detected,
        steering_magnitude=steering_magnitude,
        context_history=context_history  # Include for analysis
    )


# -----------------------------------------------------------------------------
# Visualization
# -----------------------------------------------------------------------------

def visualize_human_session(result: Dict[str, Any], output_path: Optional[str] = None) -> None:
    """
    Human-AI dynamics visualization:
    - SGI per turn
    - Velocity per turn
    - context_id / context_state timeline
    - active/candidate context mass + attractor count
    """
    try:
        import matplotlib.pyplot as plt
        import numpy as np
    except ImportError:
        print("matplotlib not installed - skipping human session visualization")
        return

    turns = result.get("turns", []) or []
    if not turns:
        print("No turns found for human session visualization")
        return

    def _last_or_none(arr: Any) -> Optional[float]:
        if isinstance(arr, list) and len(arr) > 0:
            v = arr[-1]
            return float(v) if v is not None else None
        return None

    xs: List[int] = []
    sgi_vals: List[Optional[float]] = []
    vel_vals: List[Optional[float]] = []
    ctx_ids: List[str] = []
    ctx_states: List[str] = []
    attractors: List[int] = []
    active_mass: List[Optional[float]] = []
    cand_mass: List[Optional[float]] = []

    for i, t in enumerate(turns, start=1):
        rm = t.get("real_metrics", {}) or {}

        # Prefer Paper 03 turn-pair SGI; fallback to ensemble-style SGI mean
        sgi = rm.get("turn_pair_sgi_latest") or rm.get("turn_pair_sgi_mean") or rm.get("sgi_latest") or rm.get("sgi_mean")
        if sgi is None:
            sgi = _last_or_none(rm.get("per_turn_pair_sgi")) or _last_or_none(rm.get("per_turn_sgi"))

        # Prefer orbital/turn velocities; fallback to angular velocity mean
        vel = rm.get("orbital_velocity_latest") or rm.get("orbital_velocity_mean") or rm.get("angular_velocity_latest") or rm.get("angular_velocity_mean") or rm.get("velocity_latest") or rm.get("velocity_mean")
        if vel is None:
            vel = _last_or_none(rm.get("per_turn_orbital_velocity")) or _last_or_none(rm.get("per_turn_velocity"))

        xs.append(i)
        sgi_vals.append(float(sgi) if sgi is not None else None)
        vel_vals.append(float(vel) if vel is not None else None)
        # Prefer latest fields; fall back to last element of per-turn arrays
        per_ids = rm.get("per_turn_context_id") or []
        per_states = rm.get("per_turn_context_state") or []
        ctx_ids.append(str(rm.get("context_id_latest") or (per_ids[-1] if per_ids else "ctx_1")))
        ctx_states.append(str(rm.get("context_state_latest") or (per_states[-1] if per_states else "stable")))
        attractors.append(int(rm.get("attractor_count") or 1))
        active_mass.append(rm.get("active_context_mass"))
        cand_mass.append(rm.get("candidate_context_mass"))

    # Map context ids to y positions
    ctx_unique = []
    for cid in ctx_ids:
        if cid not in ctx_unique:
            ctx_unique.append(cid)
    ctx_to_y = {cid: j for j, cid in enumerate(ctx_unique)}
    ys_ctx = [ctx_to_y[cid] for cid in ctx_ids]

    state_colors = {"stable": "#2ecc71", "protostar": "#f39c12", "split": "#e74c3c"}
    point_colors = [state_colors.get(s, "#3498db") for s in ctx_states]

    fig, axes = plt.subplots(2, 3, figsize=(18, 10))
    ax1, ax2, ax_phase = axes[0, 0], axes[0, 1], axes[0, 2]
    ax3, ax4, ax5 = axes[1, 0], axes[1, 1], axes[1, 2]

    # 1) SGI per turn
    ax1.plot(xs, [v if v is not None else np.nan for v in sgi_vals], marker="o", linewidth=2)
    ax1.axhline(1.0, color="gray", linestyle="--", alpha=0.6)
    ax1.set_title("Turn-Pair SGI (Human-AI)")
    ax1.set_xlabel("Turn")
    ax1.set_ylabel("SGI")
    ax1.grid(True, alpha=0.3)

    # 2) Velocity per turn
    ax2.plot(xs, [v if v is not None else np.nan for v in vel_vals], marker="o", linewidth=2, color="#8e44ad")
    ax2.set_title("Velocity (Human-AI)")
    ax2.set_xlabel("Turn")
    ax2.set_ylabel("Degrees")
    ax2.set_ylim(0, 180)
    ax2.grid(True, alpha=0.3)

    # 3) SGI × Velocity phase-space with coherence region
    # Coherence region (Paper 02)
    sgi_min, sgi_max = 0.7, 1.3
    vel_min, vel_max = 15, 45
    ax_phase.add_patch(
        plt.Rectangle(
            (sgi_min, vel_min),
            sgi_max - sgi_min,
            vel_max - vel_min,
            facecolor="#2ecc71",
            alpha=0.15,
            edgecolor="#2ecc71",
            linewidth=2,
            linestyle="--",
            label="Coherence Region",
        )
    )
    ax_phase.axvline(1.0, color="gray", linestyle="--", alpha=0.6, linewidth=1)
    ax_phase.plot(1.0, 30, "g*", markersize=14, zorder=5, label="Coherence Centroid")

    # Plot trajectory (time-gradient)
    phase_points = [(s, v) for s, v in zip(sgi_vals, vel_vals) if s is not None and v is not None]
    if len(phase_points) > 0:
        sgis_p = [p[0] for p in phase_points]
        vels_p = [p[1] for p in phase_points]
        ax_phase.plot(sgis_p, vels_p, color="#34495e", alpha=0.5, linewidth=1.5, zorder=2)
        n = len(sgis_p)
        for i, (s, v) in enumerate(zip(sgis_p, vels_p)):
            alpha = 0.25 + 0.75 * (i / max(1, n - 1))  # pale -> dark
            size = 30 + 20 * (i / max(1, n - 1))
            ax_phase.scatter(s, v, s=size, alpha=alpha, color="#2980b9", zorder=3)
        # Mark start/end
        ax_phase.scatter(sgis_p[0], vels_p[0], s=70, marker="D", color="#2980b9", edgecolor="white", linewidth=1, zorder=4)
        ax_phase.scatter(sgis_p[-1], vels_p[-1], s=70, marker="X", color="#2980b9", edgecolor="white", linewidth=1, zorder=4)

    ax_phase.set_title("SGI × Velocity (Human-AI)")
    ax_phase.set_xlabel("Turn-Pair SGI (Orbital Radius)")
    ax_phase.set_ylabel("Velocity (degrees)")
    ax_phase.set_xlim(0.2, 1.6)
    ax_phase.set_ylim(0, 180)
    ax_phase.grid(True, alpha=0.3)
    ax_phase.legend(fontsize=8, loc="upper right")

    # 4) Context timeline
    ax3.scatter(xs, ys_ctx, c=point_colors, s=70)
    ax3.set_yticks(list(ctx_to_y.values()), labels=list(ctx_to_y.keys()))
    ax3.set_title("Context Timeline (Sun switching)")
    ax3.set_xlabel("Turn")
    ax3.set_ylabel("context_id")
    ax3.grid(True, alpha=0.2)

    # 5) Mass + attractor count
    ax4.plot(xs, [float(v) if v is not None else np.nan for v in active_mass], label="active_context_mass", linewidth=2, color="#2c3e50")
    ax4.plot(xs, [float(v) if v is not None else np.nan for v in cand_mass], label="candidate_context_mass", linewidth=2, linestyle="--", color="#f39c12")
    ax4.set_title("Context Mass + Attractor Count")
    ax4.set_xlabel("Turn")
    ax4.set_ylabel("Mass (turn count)")
    ax4.grid(True, alpha=0.3)
    ax4b = ax4.twinx()
    ax4b.step(xs, attractors, where="mid", label="attractor_count", color="#e74c3c", alpha=0.9)
    ax4b.set_ylabel("Attractors")
    ax4b.set_ylim(0.8, max(2, max(attractors) + 0.2))

    # Merge legends
    h1, l1 = ax4.get_legend_handles_labels()
    h2, l2 = ax4b.get_legend_handles_labels()
    ax4.legend(h1 + h2, l1 + l2, loc="upper left", fontsize=8)

    # 6) State legend (stable/protostar/split) and brief note
    ax5.axis("off")
    ax5.set_title("Legend", fontweight="bold")
    lines = [
        ("stable", "anchored to active context (Sun)"),
        ("protostar", "candidate context forming (multi-body emerging)"),
        ("split", "context switch promoted (new Sun)"),
    ]
    y = 0.85
    for state, desc in lines:
        ax5.scatter([0.05], [y], s=120, color=state_colors.get(state, "#3498db"))
        ax5.text(0.12, y, f"{state}: {desc}", fontsize=10, va="center")
        y -= 0.18
    ax5.text(0.05, 0.15, "Tip: hard topic jumps for 2–3 turns\nshould create protostar → split.", fontsize=9)
    ax5.set_xlim(0, 1)
    ax5.set_ylim(0, 1)

    plt.suptitle("Human-AI Semantic Physics: Context Dynamics", fontweight="bold")
    plt.tight_layout(rect=[0, 0.03, 1, 0.93])

    if output_path:
        out_path = str(output_path).replace(".png", "_human_dynamics.png")
        plt.savefig(out_path, dpi=200, bbox_inches="tight", facecolor="white")
        print(f"[OK] Human dynamics figure saved to: {out_path}")

    plt.show()


def visualize_ai_dynamics(result: Dict[str, Any], output_path: Optional[str] = None) -> None:
    """
    AI-AI dynamics visualization (single condition×backend run).
    Matches the human dynamics layout so you can compare directly.
    """
    # Reuse the same renderer; it's not actually human-specific.
    # The function reads per-turn metrics and context arrays from each turn's real_metrics.
    visualize_human_session(result, output_path)

def visualize_results(results: List[Dict[str, Any]], output_path: Optional[str] = None) -> None:
    """Visualize steering experiment results."""
    try:
        import matplotlib.pyplot as plt
        import numpy as np
    except ImportError:
        print("matplotlib not installed - skipping visualization")
        return
    
    fig, axes = plt.subplots(2, 2, figsize=(14, 10))
    
    # Simplified color scheme: 2 clear colors for conditions
    condition_colors = {
        "A_baseline": "#2E4057",      # Dark blue
        "B_healthy": "#048A81", 
        "C_drifting": "#E63946",
        "D_transformation": "#6F2DBD",
        "E_real_metrics": "#F77F00",  # Orange
        "F_adversarial": "#A4161A"
    }
    
    # Backend styles - all 10 stable backends
    backend_styles = {
        "nomic": {"linestyle": "-", "marker": "o", "alpha": 1.0, "markersize": 6},
        "openai-ada-002": {"linestyle": "--", "marker": "s", "alpha": 1.0, "markersize": 6},
        "s128": {"linestyle": "-.", "marker": "^", "alpha": 1.0, "markersize": 6},
        "openai-3-small": {"linestyle": "-", "marker": "D", "alpha": 1.0, "markersize": 5},
        "voyage-large-2-instruct": {"linestyle": "--", "marker": "v", "alpha": 1.0, "markersize": 6},
        "cohere-v3": {"linestyle": "-.", "marker": "p", "alpha": 1.0, "markersize": 6},
        "bge-m3": {"linestyle": "-", "marker": "h", "alpha": 1.0, "markersize": 6},
        "qwen": {"linestyle": "--", "marker": "*", "alpha": 1.0, "markersize": 7},
        "jina-v3": {"linestyle": "-.", "marker": "X", "alpha": 1.0, "markersize": 6},
        "mistral-embed": {"linestyle": "-", "marker": "P", "alpha": 1.0, "markersize": 6},
    }
    
    # Default style for any unknown backend
    default_backend_style = {"linestyle": "-", "marker": "o", "alpha": 1.0, "markersize": 6}
    
    def _get_style(result_item: Dict[str, Any]) -> dict:
        """Get color and style based on condition + backend."""
        cond = result_item.get("condition_name", "unknown")
        backend = result_item.get("backend", "nomic")
        base_color = condition_colors.get(cond, "#333333")
        style = backend_styles.get(backend, default_backend_style)
        return {"color": base_color, **style}
    
    def _label(result_item: Dict[str, Any]) -> str:
        backend = result_item.get("backend")
        name = result_item.get("condition_name", "unknown")
        return f"{name} ({backend})" if backend else name

    # 1. Turn-Pair SGI Trajectory (Paper 03 - dyad smoothed)
    ax1 = axes[0, 0]
    for result in results:
        label = _label(result)
        style = _get_style(result)
        turns = result.get("turns", [])
        sgi_values = []
        for t in turns:
            rm = t.get("real_metrics", {})
            if rm:
                # Paper 03: use turn-pair SGI (mean of user+assistant)
                per_turn_pair_sgi = rm.get("per_turn_pair_sgi", [])
                if per_turn_pair_sgi and len(per_turn_pair_sgi) > 0:
                    sgi_values.append(per_turn_pair_sgi[-1])
                else:
                    # Fallback to old per_turn_sgi for backward compat
                    per_turn_sgi = rm.get("per_turn_sgi", [])
                    if per_turn_sgi and len(per_turn_sgi) > 0:
                        sgi_values.append(per_turn_sgi[-1])
                    elif rm.get("turn_pair_sgi_latest") is not None:
                        sgi_values.append(rm["turn_pair_sgi_latest"])
                    elif rm.get("sgi_mean") is not None:
                        sgi_values.append(rm["sgi_mean"])
        if sgi_values:
            ax1.plot(range(1, len(sgi_values) + 1), sgi_values, 
                    marker=style["marker"], color=style["color"], 
                    linestyle=style["linestyle"], alpha=style["alpha"],
                    markersize=style["markersize"], label=label, linewidth=2)
    ax1.set_xlabel("Turn")
    ax1.set_ylabel("Turn-Pair SGI")
    ax1.set_title("Turn-Pair SGI Trajectory (Paper 03)")
    ax1.legend(fontsize=7, loc='best')
    ax1.axhline(y=1.0, color='green', linestyle=':', alpha=0.5)
    ax1.axhspan(0.7, 1.3, color='green', alpha=0.05)  # Coherence band
    ax1.grid(True, alpha=0.3)
    
    # 2. Orbital Velocity Trajectory (Paper 03 - direct angular distance)
    ax2 = axes[0, 1]
    for result in results:
        label = _label(result)
        style = _get_style(result)
        turns = result.get("turns", [])
        vel_values = []
        turn_numbers = []
        for idx, t in enumerate(turns):
            rm = t.get("real_metrics", {})
            if rm:
                # Paper 03: use orbital velocity (direct angular distance, Paper 02 style)
                per_turn_orbital = rm.get("per_turn_orbital_velocity", [])
                if per_turn_orbital and len(per_turn_orbital) > 0:
                    current_vel = per_turn_orbital[-1]
                else:
                    # Fallback to old per_turn_velocity
                    per_turn_vel = rm.get("per_turn_velocity", [])
                    if per_turn_vel and len(per_turn_vel) > 0:
                        current_vel = per_turn_vel[-1]
                    elif rm.get("orbital_velocity_latest") is not None:
                        current_vel = rm["orbital_velocity_latest"]
                    else:
                        current_vel = None
                
                # Skip first turn (no prior to compute velocity from)
                if idx == 0 or current_vel is None:
                    continue
                vel_values.append(current_vel)
                turn_numbers.append(idx + 1)  # 1-indexed turns
        
        if vel_values:
            ax2.plot(turn_numbers, vel_values,
                    marker=style["marker"], color=style["color"],
                    linestyle=style["linestyle"], alpha=style["alpha"],
                    markersize=style["markersize"], label=label, linewidth=2)
    ax2.set_xlabel("Turn")
    ax2.set_ylabel("Velocity (degrees)")
    ax2.set_title("Velocity Trajectory (Paper 02/03 - direct angular distance)")
    ax2.legend(fontsize=7, loc='best')
    ax2.axhline(y=45.0, color='orange', linestyle=':', alpha=0.5)
    ax2.axhspan(15, 45, color='green', alpha=0.05)  # Coherence band
    ax2.grid(True, alpha=0.3)
    
    # 3. Context Drift + Displacement Consistency (Paper 03 - semantic physics)
    ax3 = axes[1, 0]
    ax3_dc = ax3.twinx()  # Secondary y-axis for DC
    
    has_drift_data = False
    has_dc_data = False
        
    for result in results:
        label = _label(result)
        style = _get_style(result)
        turns = result.get("turns", [])
        drift_values = []
        dc_values = []
        
        for t in turns:
            rm = t.get("real_metrics", {})
            if rm:
                # Context drift
                per_turn_drift = rm.get("per_turn_context_drift", [])
                if per_turn_drift and len(per_turn_drift) > 0:
                    drift_values.append(per_turn_drift[-1])
                    has_drift_data = True
                elif rm.get("context_drift_latest") is not None:
                    drift_values.append(rm["context_drift_latest"])
                    has_drift_data = True
                
                # Displacement consistency (DC)
                per_turn_dc = rm.get("per_turn_dc", [])
                if per_turn_dc and len(per_turn_dc) > 0:
                    dc_values.append(per_turn_dc[-1])
                    has_dc_data = True
                elif rm.get("dc_latest") is not None:
                    dc_values.append(rm["dc_latest"])
                    has_dc_data = True
        
        if drift_values:
            ax3.plot(range(1, len(drift_values) + 1), drift_values,
                    marker=style["marker"], color=style["color"],
                    linestyle=style["linestyle"], alpha=style["alpha"],
                    label=f'{label} Drift', linewidth=2)
        
        if dc_values:
            ax3_dc.plot(range(1, len(dc_values) + 1), dc_values,
                    marker='x', color=style["color"],
                    linestyle=':', alpha=0.6,
                    label=f'{label} DC', linewidth=1.5)
    
    ax3.set_xlabel("Turn")
    ax3.set_ylabel("Context Drift (degrees)", color='black')
    ax3_dc.set_ylabel("Displacement Consistency (DC)", color='gray')
    ax3.set_title("Context Drift & DC (Paper 03)")
    
    if has_drift_data:
        ax3.axhline(y=15.0, color='orange', linestyle=':', alpha=0.5)
    if has_dc_data:
        ax3_dc.axhline(y=0.7, color='green', linestyle=':', alpha=0.5)
        ax3_dc.set_ylim(0, 1.1)
    
    # Combine legends
    lines1, labels1 = ax3.get_legend_handles_labels()
    lines2, labels2 = ax3_dc.get_legend_handles_labels()
    ax3.legend(lines1 + lines2, labels1 + labels2, fontsize=6, loc='best')
    ax3.grid(True, alpha=0.3)
    
    # If no new data, show fallback message
    if not has_drift_data and not has_dc_data:
        ax3.text(0.5, 0.5, 'No context/DC data\n(restart SDK with new engine)', 
                transform=ax3.transAxes, ha='center', va='center', fontsize=10, color='gray')
    
    # 4. SGI × Velocity (Paper 02/03 style - turn-pair based)
    ax4 = axes[1, 1]
    
    # Coherence region box (Paper 02/03)
    ax4.add_patch(plt.Rectangle((0.7, 15), 0.6, 30, facecolor="#2ecc71", alpha=0.12, edgecolor="#2ecc71", label='Coherence Region'))
    ax4.axvline(x=1.0, color='gray', linestyle='--', alpha=0.6, linewidth=1)
    ax4.plot(1.0, 30, 'g*', markersize=12, zorder=5)  # Centroid marker
    
    for result in results:
        label = _label(result)
        style = _get_style(result)
        turns = result.get("turns", [])
        sgi_vals = []
        vel_vals = []
        
        for idx, t in enumerate(turns):
            rm = t.get("real_metrics", {})
            if not rm:
                continue
            
            # Paper 03: turn-pair SGI and velocity
            per_turn_pair_sgi = rm.get("per_turn_pair_sgi", [])
            per_turn_orbital = rm.get("per_turn_orbital_velocity", [])
            
            # Get SGI (with fallbacks)
            sgi_val = None
            if per_turn_pair_sgi and len(per_turn_pair_sgi) > 0:
                sgi_val = per_turn_pair_sgi[-1]
        else:
                per_turn_sgi = rm.get("per_turn_sgi", [])
                if per_turn_sgi and len(per_turn_sgi) > 0:
                    sgi_val = per_turn_sgi[-1]
            
            # Get velocity (with fallbacks)
            vel_val = None
            if per_turn_orbital and len(per_turn_orbital) > 0:
                vel_val = per_turn_orbital[-1]
            else:
                per_turn_vel = rm.get("per_turn_velocity", [])
                if per_turn_vel and len(per_turn_vel) > 0:
                    vel_val = per_turn_vel[-1]
            
            # Skip first turn for velocity (no prior reference)
            if idx == 0:
                continue
            
            if sgi_val is not None and vel_val is not None:
                sgi_vals.append(sgi_val)
                vel_vals.append(vel_val)
        
        if sgi_vals and vel_vals:
            # Plot trajectory line
            ax4.plot(sgi_vals, vel_vals, color=style["color"], 
                    linestyle=style["linestyle"], linewidth=1.5, alpha=0.7)
            
            # Plot points
            ax4.scatter(sgi_vals, vel_vals, color=style["color"], 
                       s=50, marker=style["marker"], alpha=style["alpha"],
                       label=label, zorder=3)
            
            # Mark start and end with annotations
            if len(sgi_vals) > 1:
                ax4.annotate('S', (sgi_vals[0], vel_vals[0]), fontsize=7, 
                           ha='center', va='bottom', color=style["color"])
                ax4.annotate('E', (sgi_vals[-1], vel_vals[-1]), fontsize=7, 
                           ha='center', va='bottom', color=style["color"])
    
    ax4.set_xlabel("Turn-Pair SGI")
    ax4.set_ylabel("Velocity (degrees)")
    ax4.set_title("SGI × Velocity (Paper 02/03 style)")
    ax4.set_xlim(0.3, 1.6)
    ax4.set_ylim(0, 120)  # Extended to 120° as requested
    ax4.grid(True, alpha=0.3)
    ax4.legend(fontsize=6, loc="upper right")
    
    plt.tight_layout()
    
    if output_path:
        fig_path = output_path.replace('.json', '_figure.png')
        plt.savefig(fig_path, dpi=150, bbox_inches='tight')
        print(f"\nFigure saved to: {fig_path}")
    
    plt.show()


def visualize_fig2_velocity_comparison(results: List[Dict[str, Any]], output_path: Optional[str] = None) -> None:
    """
    Figure 2: Velocity comparison across granularities and roles.
    2x2 grid showing:
    - Top left: All per-message velocities
    - Top right: Turn-pair orbital velocity
    - Bottom left: User messages only
    - Bottom right: Assistant messages only
    """
    try:
        import matplotlib.pyplot as plt
        import numpy as np
        import seaborn as sns
    except ImportError as e:
        print(f"Visualization requires matplotlib, seaborn: {e}")
        return
    
    # Collect velocity data by role
    per_message_velocities = []
    user_velocities = []
    assistant_velocities = []
    orbital_velocities = []
    
    for r in results:
        turns = r.get("turns", [])
        prev_ptv_len = 0
        msg_index = 0  # Track message index within conversation
        
        for t in turns:
            rm = t.get("real_metrics", {})
            
            # Per-message velocities - only collect NEW values (array is cumulative)
            ptv = rm.get("per_turn_velocity", [])
            if ptv and len(ptv) > prev_ptv_len:
                new_values = ptv[max(1, prev_ptv_len):]  # Skip index 0 (180° artifact)
                for v in new_values:
                    if v is not None and v < 170:
                        per_message_velocities.append(v)
                        # Each turn has user then assistant message
                        # Even index = user, odd index = assistant (within new values)
                        if msg_index % 2 == 0:
                            user_velocities.append(v)
                        else:
                            assistant_velocities.append(v)
                        msg_index += 1
                prev_ptv_len = len(ptv)
            
            # Turn-pair orbital velocity - one per turn
            ov = rm.get("orbital_velocity_latest")
            if ov is not None and ov > 0:
                orbital_velocities.append(ov)
    
    if not per_message_velocities:
        print("[Fig2] Not enough velocity data to generate comparison")
        return
    
    # Create 2x2 figure
    fig, axes = plt.subplots(2, 2, figsize=(14, 12))
    fig.suptitle("Figure 2: Velocity Distribution by Granularity and Role", fontsize=14, fontweight='bold')
    
    sns.set_style("whitegrid")
    
    def plot_histogram(ax, data, color, title_prefix, label):
        if not data:
            ax.text(0.5, 0.5, "No data", ha='center', va='center', transform=ax.transAxes)
            ax.set_title(f"{title_prefix}\n(no data)")
            return 0, 0
        sns.histplot(data, kde=True, ax=ax, color=color, alpha=0.7, bins=20)
        mean_v = np.mean(data)
        std_v = np.std(data)
        ax.axvline(mean_v, color='black', linestyle='--', linewidth=2, label=f'Mean: {mean_v:.1f}°')
        ax.set_xlabel("Velocity (degrees)", fontsize=11)
        ax.set_ylabel("Frequency", fontsize=11)
        ax.set_title(f"{title_prefix}\n(n={len(data)}, μ={mean_v:.1f}°, σ={std_v:.1f}°)", fontsize=11)
        ax.set_xlim(0, 180)
        ax.legend(loc='upper right')
        return mean_v, std_v
    
    # Top left: All per-message
    mean_pm, std_pm = plot_histogram(axes[0, 0], per_message_velocities, '#e74c3c', 
                                      "All Per-Message Velocity", "All")
    
    # Top right: Turn-pair orbital
    mean_ov, std_ov = plot_histogram(axes[0, 1], orbital_velocities, '#3498db', 
                                      "Turn-Pair Orbital Velocity", "Orbital")
    
    # Bottom left: User messages only
    mean_user, std_user = plot_histogram(axes[1, 0], user_velocities, '#27ae60', 
                                          "User Messages Only", "User")
    
    # Bottom right: Assistant messages only
    mean_asst, std_asst = plot_histogram(axes[1, 1], assistant_velocities, '#9b59b6', 
                                          "Assistant Messages Only", "Assistant")
    
    # Calculate Dyadic Coherence Index (DCI)
    # DCI = 1 - (σ_turn_pair / σ_per_message)
    # Higher = more synchronized dyad
    dci = 0.0
    if std_pm > 0 and std_ov > 0:
        dci = 1.0 - (std_ov / std_pm)
        dci = max(0.0, min(1.0, dci))  # Clamp to [0, 1]
    
    # DCI interpretation
    if dci >= 0.8:
        dci_label = "HIGH COEVOLUTION"
        dci_color = '#27ae60'
    elif dci >= 0.5:
        dci_label = "MODERATE"
        dci_color = '#f39c12'
    else:
        dci_label = "LOW"
        dci_color = '#e74c3c'
    
    # Add comparison annotations
    if mean_pm > 0 and mean_ov > 0:
        reduction = ((mean_pm - mean_ov) / mean_pm) * 100
        fig.text(0.5, 0.48, 
                 f"Aggregation: {mean_pm:.1f} -> {mean_ov:.1f} (down {reduction:.0f}% when grouping to turn-pairs)",
                 ha='center', fontsize=11, style='italic', color='#2c3e50')
    
    if mean_user > 0 and mean_asst > 0:
        role_diff = mean_asst - mean_user
        fig.text(0.5, 0.02, 
                 f"Role Comparison: User={mean_user:.1f} vs Assistant={mean_asst:.1f} (diff={role_diff:+.1f})",
                 ha='center', fontsize=11, style='italic', color='#2c3e50')
    
    # DCI box
    fig.text(0.98, 0.98, 
             f"DCI = {dci:.2f}\n{dci_label}",
             ha='right', va='top', fontsize=14, fontweight='bold', color=dci_color,
             transform=fig.transFigure,
             bbox=dict(boxstyle='round,pad=0.5', facecolor='white', edgecolor=dci_color, linewidth=2))
    
    # Print to console
    print(f"\n{'='*50}")
    print(f"  DYADIC COHERENCE INDEX (DCI)")
    print(f"{'='*50}")
    print(f"  σ per-message:  {std_pm:.2f}°")
    print(f"  σ turn-pair:    {std_ov:.2f}°")
    print(f"  DCI = 1 - ({std_ov:.2f} / {std_pm:.2f}) = {dci:.3f}")
    print(f"  Interpretation: {dci_label}")
    print(f"{'='*50}\n")
    
    plt.tight_layout(rect=[0, 0.04, 1, 0.96])
    
    # Save
    if output_path:
        fig2_path = output_path.replace('.json', '_fig2_velocity_comparison.png').replace('_figure.png', '_fig2_velocity_comparison.png')
        plt.savefig(fig2_path, dpi=300, bbox_inches='tight', facecolor='white')
        print(f"\n[OK] Figure 2 saved to: {fig2_path}")
    
    plt.show()


def visualize_fig3_trajectory_analysis(results: List[Dict[str, Any]], output_path: Optional[str] = None) -> None:
    """
    Figure 3: Turn-by-turn trajectory analysis.
    Shows temporal evolution to understand if conditions start differently and converge.
    
    Layout:
    - Top left: SGI over turns (all conditions)
    - Top right: Velocity over turns (all conditions)
    - Bottom left: Early turns (1-3) in phase space
    - Bottom right: Late turns (last 3 turns of the run) in phase space
    """
    try:
        import matplotlib.pyplot as plt
        import numpy as np
        import seaborn as sns
        from collections import defaultdict
    except ImportError as e:
        print(f"Visualization requires matplotlib, seaborn: {e}")
        return
    
    # Organize data by condition
    condition_data = defaultdict(lambda: {"sgis": [], "velocities": [], "turns": []})
    
    for r in results:
        cond = r.get("condition_name", "unknown")
        turns = r.get("turns", [])
        
        for t in turns:
            turn_num = t.get("turn_number", 0)
            rm = t.get("real_metrics", {})
            
            # Prioritize turn-pair metrics (more stable)
            sgi = rm.get("turn_pair_sgi_mean") or rm.get("turn_pair_sgi_latest") or rm.get("sgi_mean")
            vel = rm.get("orbital_velocity_latest") or rm.get("orbital_velocity_mean") or rm.get("velocity_mean")
            
            if sgi is not None and vel is not None and vel < 170:
                condition_data[cond]["sgis"].append(sgi)
                condition_data[cond]["velocities"].append(vel)
                condition_data[cond]["turns"].append(turn_num)
    
    if not condition_data:
        print("[Fig3] No valid trajectory data found")
        return
    
    # Color palette for conditions
    colors = {
        "A_baseline": "#3498db",
        "B_healthy": "#27ae60",
        "C_drifting": "#f39c12",
        "D_transformation": "#9b59b6",
        "E_real_metrics": "#1abc9c",
        "F_adversarial": "#e74c3c"
    }
    
    fig, axes = plt.subplots(2, 2, figsize=(16, 14))
    fig.suptitle("Figure 3: Temporal Trajectory Analysis — Do Conditions Converge?", 
                 fontsize=14, fontweight='bold')
    
    sns.set_style("whitegrid")
    
    # Top left: SGI over turns
    ax1 = axes[0, 0]
    for cond, data in condition_data.items():
        if data["turns"]:
            # Group by turn number and compute mean
            turn_sgi = defaultdict(list)
            for t, s in zip(data["turns"], data["sgis"]):
                turn_sgi[t].append(s)
            turns_sorted = sorted(turn_sgi.keys())
            sgi_means = [np.mean(turn_sgi[t]) for t in turns_sorted]
            sgi_stds = [np.std(turn_sgi[t]) for t in turns_sorted]
            
            color = colors.get(cond, "#7f8c8d")
            ax1.plot(turns_sorted, sgi_means, 'o-', color=color, label=cond, linewidth=2, markersize=8)
            ax1.fill_between(turns_sorted, 
                            [m-s for m,s in zip(sgi_means, sgi_stds)],
                            [m+s for m,s in zip(sgi_means, sgi_stds)],
                            alpha=0.2, color=color)
    ax1.set_xlabel("Turn Number", fontsize=12)
    ax1.set_ylabel("SGI (mean ± std)", fontsize=12)
    ax1.set_title("SGI Evolution Over Turns", fontsize=12)
    ax1.legend(loc='upper right', fontsize=9)
    ax1.set_ylim(0, 1.5)
    
    # Top right: Velocity over turns
    ax2 = axes[0, 1]
    for cond, data in condition_data.items():
        if data["turns"]:
            turn_vel = defaultdict(list)
            for t, v in zip(data["turns"], data["velocities"]):
                turn_vel[t].append(v)
            turns_sorted = sorted(turn_vel.keys())
            vel_means = [np.mean(turn_vel[t]) for t in turns_sorted]
            vel_stds = [np.std(turn_vel[t]) for t in turns_sorted]
            
            color = colors.get(cond, "#7f8c8d")
            ax2.plot(turns_sorted, vel_means, 's-', color=color, label=cond, linewidth=2, markersize=8)
            ax2.fill_between(turns_sorted,
                            [m-s for m,s in zip(vel_means, vel_stds)],
                            [m+s for m,s in zip(vel_means, vel_stds)],
                            alpha=0.2, color=color)
    ax2.set_xlabel("Turn Number", fontsize=12)
    ax2.set_ylabel("Orbital Velocity (mean ± std)", fontsize=12)
    ax2.set_title("Orbital Velocity (Turn-Pair) Over Turns", fontsize=12)
    ax2.legend(loc='upper right', fontsize=9)
    ax2.set_ylim(0, 180)
    
    early_k = 3
    late_k = 3

    # Bottom left: Early turns (1-3) in phase space
    ax3 = axes[1, 0]
    ax3.add_patch(plt.Rectangle((0.3, 0), 0.9, 45, alpha=0.15, color='green', label='Coherence Region'))
    for cond, data in condition_data.items():
        early_sgi = [s for s, t in zip(data["sgis"], data["turns"]) if isinstance(t, (int, float)) and t <= early_k]
        early_vel = [v for v, t in zip(data["velocities"], data["turns"]) if isinstance(t, (int, float)) and t <= early_k]
        if early_sgi:
            color = colors.get(cond, "#7f8c8d")
            ax3.scatter(early_sgi, early_vel, color=color, alpha=0.7, s=100, label=cond, edgecolor='black')
            # Show mean point
            ax3.scatter([np.mean(early_sgi)], [np.mean(early_vel)], 
                       color=color, s=300, marker='*', edgecolor='black', linewidth=2)
    ax3.set_xlabel("SGI", fontsize=12)
    ax3.set_ylabel("Orbital Velocity (degrees)", fontsize=12)
    ax3.set_title(f"Early Turns (1-{early_k}): Where Do Conditions START?", fontsize=12)
    ax3.set_xlim(0, 1.5)
    ax3.set_ylim(0, 180)
    ax3.legend(loc='upper right', fontsize=9)
    
    # Bottom right: Late turns (last k turns) in phase space
    ax4 = axes[1, 1]
    ax4.add_patch(plt.Rectangle((0.3, 0), 0.9, 45, alpha=0.15, color='green', label='Coherence Region'))
    for cond, data in condition_data.items():
        max_turn = max([t for t in data["turns"] if isinstance(t, (int, float))], default=None)
        if max_turn is None:
            continue
        cutoff = max_turn - late_k + 1  # inclusive, e.g. 30 -> 28
        late_sgi = [s for s, t in zip(data["sgis"], data["turns"]) if isinstance(t, (int, float)) and t >= cutoff]
        late_vel = [v for v, t in zip(data["velocities"], data["turns"]) if isinstance(t, (int, float)) and t >= cutoff]
        if late_sgi:
            color = colors.get(cond, "#7f8c8d")
            ax4.scatter(late_sgi, late_vel, color=color, alpha=0.7, s=100, label=cond, edgecolor='black')
            # Show mean point
            ax4.scatter([np.mean(late_sgi)], [np.mean(late_vel)], 
                       color=color, s=300, marker='*', edgecolor='black', linewidth=2)
    ax4.set_xlabel("SGI", fontsize=12)
    ax4.set_ylabel("Orbital Velocity (degrees)", fontsize=12)
    ax4.set_title(f"Late Turns (last {late_k}): Where Do Conditions END?", fontsize=12)
    ax4.set_xlim(0, 1.5)
    ax4.set_ylim(0, 180)
    ax4.legend(loc='upper right', fontsize=9)
    
    # Compute convergence metric
    print("\n" + "="*60)
    print("  CONVERGENCE ANALYSIS")
    print("="*60)
    for cond, data in condition_data.items():
        max_turn = max([t for t in data["turns"] if isinstance(t, (int, float))], default=None)
        if max_turn is None:
            continue
        cutoff = max_turn - late_k + 1
        early_vel = [v for v, t in zip(data["velocities"], data["turns"]) if isinstance(t, (int, float)) and t <= early_k]
        late_vel = [v for v, t in zip(data["velocities"], data["turns"]) if isinstance(t, (int, float)) and t >= cutoff]
        if early_vel and late_vel:
            early_mean = np.mean(early_vel)
            late_mean = np.mean(late_vel)
            convergence = early_mean - late_mean
            print(f"  {cond:20s}: Early={early_mean:5.1f} -> Late={late_mean:5.1f} (delta={convergence:+5.1f})")
    print("="*60)
    print("  Positive delta = velocity decreases (settling)")
    print("  Negative delta = velocity increases (diverging)")
    print("="*60 + "\n")
    
    plt.tight_layout(rect=[0, 0, 1, 0.96])
    
    if output_path:
        fig3_path = output_path.replace('.json', '_fig3_trajectory.png').replace('_figure.png', '_fig3_trajectory.png')
        plt.savefig(fig3_path, dpi=300, bbox_inches='tight', facecolor='white')
        print(f"[OK] Figure 3 saved to: {fig3_path}")
    
    plt.show()


def visualize_fig4_injected_vs_measured(results: List[Dict[str, Any]], output_path: Optional[str] = None) -> None:
    """
    Figure 4: Injected vs Measured metrics (steering detectability).

    Produces a 2-panel plot:
      - SGI: injected (dashed) vs measured (solid)
      - Velocity (degrees): injected (dashed) vs measured (solid)

    Notes:
      - Uses injected_metrics.sgi and injected_metrics.velocity_degrees when present
      - Uses measured turn-pair SGI when available, otherwise sgi_mean
      - Uses measured orbital_velocity_latest when available, otherwise velocity_latest/mean
    """
    try:
        import matplotlib.pyplot as plt
        import numpy as np
        import seaborn as sns
    except ImportError as e:
        print(f"Visualization requires matplotlib, seaborn: {e}")
        return

    if not isinstance(results, list) or not results:
        print("[Fig4] No results to visualize")
        return

    # Group by condition (and backend if present)
    # For Fig4 we primarily want per-condition curves; if multiple backends exist, we average.
    series_by_cond: Dict[str, Dict[str, Dict[int, list]]] = {}
    inj_mode_by_cond: Dict[str, str] = {}  # none | real | fixed
    # structure:
    # series_by_cond[cond]["inj_sgi"][turn] = [vals...]
    # series_by_cond[cond]["real_sgi"][turn] = [vals...]
    # series_by_cond[cond]["inj_vel"][turn] = [vals...]
    # series_by_cond[cond]["real_vel"][turn] = [vals...]

    def _ensure(cond: str) -> None:
        if cond not in series_by_cond:
            series_by_cond[cond] = {
                "inj_sgi": {},
                "real_sgi": {},
                "inj_vel": {},
                "real_vel": {},
            }
            inj_mode_by_cond[cond] = "none"

    def _push(bucket: Dict[int, list], turn: int, val: Optional[float]) -> None:
        if val is None:
            return
        bucket.setdefault(int(turn), []).append(float(val))

    for r in results:
        cond = str(r.get("condition_name", "unknown"))
        _ensure(cond)
        turns = r.get("turns", []) or []
        for t in turns:
            turn_num = t.get("turn_number")
            if turn_num is None:
                continue

            inj = t.get("injected_metrics") or {}
            rm = t.get("real_metrics") or {}

            inj_sgi = inj.get("sgi") if isinstance(inj, dict) else None
            inj_vel = inj.get("velocity_degrees") if isinstance(inj, dict) else None

            # Track injection mode for styling
            if isinstance(inj, dict):
                status = str(inj.get("status") or "").lower()
                if status == "real_metrics":
                    inj_mode_by_cond[cond] = "real"
                elif ("sgi" in inj) or ("velocity_degrees" in inj):
                    # Fixed injected metrics (B/C/D/F)
                    if inj_mode_by_cond.get(cond) != "real":
                        inj_mode_by_cond[cond] = "fixed"

            real_sgi = (
                rm.get("turn_pair_sgi_latest")
                or rm.get("turn_pair_sgi_mean")
                or rm.get("sgi_latest")
                or rm.get("sgi_mean")
            )
            real_vel = (
                rm.get("orbital_velocity_latest")
                or rm.get("orbital_velocity_mean")
                or rm.get("velocity_latest")
                or rm.get("velocity_mean")
            )

            _push(series_by_cond[cond]["inj_sgi"], turn_num, inj_sgi)
            _push(series_by_cond[cond]["inj_vel"], turn_num, inj_vel)
            _push(series_by_cond[cond]["real_sgi"], turn_num, real_sgi)
            _push(series_by_cond[cond]["real_vel"], turn_num, real_vel)

    # Plot any condition with measured data. If injected data is missing (e.g. A_baseline),
    # we plot measured only (no dashed line).
    plotted_conds = []
    for cond, buckets in series_by_cond.items():
        has_any_real = any(buckets["real_sgi"].values()) or any(buckets["real_vel"].values())
        if has_any_real:
            plotted_conds.append(cond)

    if not plotted_conds:
        print("[Fig4] No measured metrics found in this dataset")
        return

    # Color palette (reuse condition naming)
    colors = {
        "A_baseline": "#3498db",
        "B_healthy": "#27ae60",
        "C_drifting": "#f39c12",
        "D_transformation": "#9b59b6",
        "E_real_metrics": "#1abc9c",
        "F_adversarial": "#e74c3c",
    }

    sns.set_style("whitegrid")
    fig, axes = plt.subplots(1, 2, figsize=(18, 6))
    fig.suptitle("Figure 4: Injected vs Measured Metrics (Steering Detectability)", fontsize=14, fontweight="bold")

    ax_sgi, ax_vel = axes[0], axes[1]

    for cond in sorted(plotted_conds):
        c = colors.get(cond, "#7f8c8d")
        buckets = series_by_cond[cond]
        mode = inj_mode_by_cond.get(cond, "none")

        all_turns = sorted(
            set(buckets["real_sgi"].keys())
            | set(buckets["real_vel"].keys())
            | set(buckets["inj_sgi"].keys())
            | set(buckets["inj_vel"].keys())
        )
        if not all_turns:
            continue

        def mean_or_nan(bucket: Dict[int, list], turn: int) -> float:
            vals = bucket.get(turn) or []
            return float(np.mean(vals)) if vals else float("nan")

        inj_sgi_series = [mean_or_nan(buckets["inj_sgi"], t) for t in all_turns]
        real_sgi_series = [mean_or_nan(buckets["real_sgi"], t) for t in all_turns]
        inj_vel_series = [mean_or_nan(buckets["inj_vel"], t) for t in all_turns]
        real_vel_series = [mean_or_nan(buckets["real_vel"], t) for t in all_turns]

        # Choose styling:
        # - A_baseline (none): measured only, distinct label
        # - E_real_metrics (real): measured solid; injected (if present) dotted + low alpha
        # - fixed injected (B/C/D/F): measured solid; injected dashed

        meas_label = f"{cond} measured"
        if mode == "none":
            meas_label = f"{cond} measured (no injection)"
        elif mode == "real":
            meas_label = f"{cond} measured (telemetry shown)"

        # SGI (measured)
        ax_sgi.plot(
            all_turns,
            real_sgi_series,
            color=c,
            linewidth=2.5 if mode in ("none", "real") else 2,
            marker="o",
            label=meas_label,
        )

        # SGI (injected / shown-to-assistant)
        if not np.all(np.isnan(inj_sgi_series)):
            if mode == "real":
                ax_sgi.plot(
                    all_turns,
                    inj_sgi_series,
                    color=c,
                    linewidth=1.8,
                    linestyle=":",
                    alpha=0.6,
                    label=f"{cond} shown (real telemetry)",
                )
            elif mode == "fixed":
                ax_sgi.plot(
                    all_turns,
                    inj_sgi_series,
                    color=c,
                    linewidth=2,
                    linestyle="--",
                    alpha=0.9,
                    label=f"{cond} injected (fixed)",
                )

        # Velocity (measured)
        ax_vel.plot(
            all_turns,
            real_vel_series,
            color=c,
            linewidth=2.5 if mode in ("none", "real") else 2,
            marker="s",
            label=meas_label,
        )

        # Velocity (injected / shown-to-assistant)
        if not np.all(np.isnan(inj_vel_series)):
            if mode == "real":
                ax_vel.plot(
                    all_turns,
                    inj_vel_series,
                    color=c,
                    linewidth=1.8,
                    linestyle=":",
                    alpha=0.6,
                    label=f"{cond} shown (real telemetry)",
                )
            elif mode == "fixed":
                ax_vel.plot(
                    all_turns,
                    inj_vel_series,
                    color=c,
                    linewidth=2,
                    linestyle="--",
                    alpha=0.9,
                    label=f"{cond} injected (fixed)",
                )

    ax_sgi.set_title("SGI (Injected vs Measured)", fontsize=12)
    ax_sgi.set_xlabel("Turn", fontsize=12)
    ax_sgi.set_ylabel("SGI", fontsize=12)
    ax_sgi.set_ylim(0, 1.5)
    ax_sgi.legend(fontsize=8, loc="upper right")

    ax_vel.set_title("Velocity (Injected vs Measured)", fontsize=12)
    ax_vel.set_xlabel("Turn", fontsize=12)
    ax_vel.set_ylabel("Velocity (degrees)", fontsize=12)
    ax_vel.set_ylim(0, 180)
    ax_vel.legend(fontsize=8, loc="upper right")

    plt.tight_layout(rect=[0, 0, 1, 0.94])

    if output_path:
        fig4_path = output_path.replace(".json", "_fig4_injected_vs_measured.png").replace("_figure.png", "_fig4_injected_vs_measured.png")
        plt.savefig(fig4_path, dpi=300, bbox_inches="tight", facecolor="white")
        print(f"[OK] Figure 4 (line plot) saved to: {fig4_path}")

    plt.show()
    
    # Also generate BAR CHART version (legacy style)
    _visualize_fig4_bars(series_by_cond, inj_mode_by_cond, colors, output_path)


def _visualize_fig4_bars(series_by_cond: dict, inj_mode_by_cond: dict, colors: dict, output_path: Optional[str]) -> None:
    """Generate bar chart version of Figure 4 (legacy style)."""
    import matplotlib.pyplot as plt
    import numpy as np
    
    # Compute mean values per condition
    bar_data = []
    for cond, buckets in series_by_cond.items():
        # Flatten all values
        all_inj_sgi = [v for vals in buckets["inj_sgi"].values() for v in vals]
        all_real_sgi = [v for vals in buckets["real_sgi"].values() for v in vals]
        all_inj_vel = [v for vals in buckets["inj_vel"].values() for v in vals]
        all_real_vel = [v for vals in buckets["real_vel"].values() for v in vals]
        
        # For fixed injection conditions, take the injected value (should be constant)
        mode = inj_mode_by_cond.get(cond, "none")
        if mode == "fixed" and all_inj_sgi:
            inj_sgi_mean = all_inj_sgi[0]  # Constant
        else:
            inj_sgi_mean = np.mean(all_inj_sgi) if all_inj_sgi else None
            
        if mode == "fixed" and all_inj_vel:
            inj_vel_mean = all_inj_vel[0]  # Constant
        else:
            inj_vel_mean = np.mean(all_inj_vel) if all_inj_vel else None
        
        real_sgi_mean = np.mean(all_real_sgi) if all_real_sgi else None
        real_vel_mean = np.mean(all_real_vel) if all_real_vel else None
        
        bar_data.append({
            "condition": cond,
            "inj_sgi": inj_sgi_mean,
            "real_sgi": real_sgi_mean,
            "inj_vel": inj_vel_mean,
            "real_vel": real_vel_mean,
            "mode": mode
        })
    
    # Sort by condition name
    bar_data = sorted(bar_data, key=lambda x: x["condition"])
    
    if not bar_data:
        return
    
    fig, axes = plt.subplots(1, 2, figsize=(16, 6))
    fig.suptitle("Figure 4: Injected vs Measured (Bar Chart)", fontsize=14, fontweight="bold")
    
    conditions = [d["condition"].replace("_", "\n") for d in bar_data]
    x = np.arange(len(conditions))
    width = 0.35
    
    # SGI bar chart
    ax1 = axes[0]
    inj_sgis = [d["inj_sgi"] if d["inj_sgi"] is not None else 0 for d in bar_data]
    real_sgis = [d["real_sgi"] if d["real_sgi"] is not None else 0 for d in bar_data]
    
    # Create bars - we'll manually handle legend
    inj_bars = ax1.bar(x - width/2, inj_sgis, width, color='#3498db', alpha=0.8)
    real_bars = ax1.bar(x + width/2, real_sgis, width, color='#e74c3c', alpha=0.8)
    
    # Hide injected bars for A_baseline (no injection) and E_real_metrics (real telemetry)
    for i, d in enumerate(bar_data):
        if d["mode"] in ("none", "real"):
            inj_bars[i].set_height(0)
            inj_bars[i].set_alpha(0)
    
    # Manual legend with visible patches
    from matplotlib.patches import Patch
    ax1.legend(handles=[
        Patch(facecolor='#3498db', alpha=0.8, label='Injected'),
        Patch(facecolor='#e74c3c', alpha=0.8, label='Measured')
    ], fontsize=10)
    
    ax1.set_ylabel('SGI', fontsize=12)
    ax1.set_title('Injected vs Real SGI by Condition', fontsize=12)
    ax1.set_xticks(x)
    ax1.set_xticklabels(conditions, fontsize=10)
    ax1.legend(fontsize=10)
    ax1.set_ylim(0, 1.5)
    ax1.axhline(y=1.0, color='gray', linestyle='--', alpha=0.5, label='SGI=1.0')
    
    # Velocity bar chart
    ax2 = axes[1]
    inj_vels = [d["inj_vel"] if d["inj_vel"] is not None else 0 for d in bar_data]
    real_vels = [d["real_vel"] if d["real_vel"] is not None else 0 for d in bar_data]
    
    inj_bars2 = ax2.bar(x - width/2, inj_vels, width, color='#3498db', alpha=0.8)
    real_bars2 = ax2.bar(x + width/2, real_vels, width, color='#e74c3c', alpha=0.8)
    
    # Hide injected bars for A_baseline and E_real_metrics
    for i, d in enumerate(bar_data):
        if d["mode"] in ("none", "real"):
            inj_bars2[i].set_height(0)
            inj_bars2[i].set_alpha(0)
    
    ax2.set_ylabel('Velocity (degrees)', fontsize=12)
    ax2.set_title('Injected vs Real Velocity by Condition', fontsize=12)
    ax2.set_xticks(x)
    ax2.set_xticklabels(conditions, fontsize=10)
    ax2.legend(handles=[
        Patch(facecolor='#3498db', alpha=0.8, label='Injected'),
        Patch(facecolor='#e74c3c', alpha=0.8, label='Measured')
    ], fontsize=10)
    ax2.set_ylim(0, 90)
    ax2.axhline(y=45, color='gray', linestyle='--', alpha=0.5)
    
    plt.tight_layout(rect=[0, 0, 1, 0.94])
    
    if output_path:
        fig4_bar_path = output_path.replace(".json", "_fig4_bars.png").replace("_figure.png", "_fig4_bars.png")
        plt.savefig(fig4_bar_path, dpi=300, bbox_inches="tight", facecolor="white")
        print(f"[OK] Figure 4 (bar chart) saved to: {fig4_bar_path}")
    
    plt.show()


def visualize_results_density(results: List[Dict[str, Any]], output_path: Optional[str] = None) -> None:
    """
    Density-based visualization for large multi-backend experiments.
    Shows distributions and 2D KDE instead of individual trajectories.
    """
    try:
        import matplotlib.pyplot as plt
        import matplotlib.patches as patches
        import numpy as np
        import seaborn as sns
        import pandas as pd
    except ImportError as e:
        print(f"Required library not installed: {e} - skipping density visualization")
        return
    
    # Extract all data points into a DataFrame
    data_rows = []
    for result in results:
        condition = result.get("condition_name", "unknown")
        backend = result.get("backend", "unknown")
        turns = result.get("turns", [])
        
        for turn_idx, t in enumerate(turns):
            rm = t.get("real_metrics", {})
            if rm:
                # Get SGI value
                per_turn_pair_sgi = rm.get("per_turn_pair_sgi", [])
                per_turn_sgi = rm.get("per_turn_sgi", [])
                sgi = None
                if per_turn_pair_sgi:
                    sgi = per_turn_pair_sgi[-1]
                elif per_turn_sgi:
                    sgi = per_turn_sgi[-1]
                elif rm.get("sgi_mean") is not None:
                    sgi = rm["sgi_mean"]
                
                # Get Velocity value
                per_turn_vel = rm.get("per_turn_velocity", [])
                vel = None
                if per_turn_vel:
                    vel = per_turn_vel[-1]
                elif rm.get("velocity_mean") is not None:
                    vel = rm["velocity_mean"]
                
                if sgi is not None and vel is not None:
                    data_rows.append({
                        "condition": condition,
                        "backend": backend,
                        "turn": turn_idx + 1,
                        "sgi": sgi,
                        "velocity": vel
                    })
    
    if not data_rows:
        print("No valid data for density visualization")
        return
    
    df = pd.DataFrame(data_rows)
    
    # Color palettes
    condition_palette = {
        "A_baseline": "#2E4057",
        "B_healthy": "#048A81", 
        "C_drifting": "#E63946",
        "D_transformation": "#6F2DBD",
        "E_real_metrics": "#F77F00",
        "F_adversarial": "#A4161A"
    }
    
    backend_palette = {
        "s128": "#1f77b4",
        "openai-ada-002": "#ff7f0e",
        "voyage-large-2-instruct": "#2ca02c",
        "cohere-v3": "#d62728",
        "bge-m3": "#9467bd",
        "qwen": "#8c564b",
        "nomic": "#e377c2",
        "jina-v3": "#7f7f7f",
        "mistral-embed": "#bcbd22",
        "openai-3-small": "#17becf"
    }
    
    # Create figure with 4 subplots
    fig = plt.figure(figsize=(16, 14))
    
    # =========================================================================
    # Plot 1: SGI Distribution by Backend (Ridge/Violin plot)
    # =========================================================================
    ax1 = fig.add_subplot(2, 2, 1)
    
    # Get unique backends
    backends = df["backend"].unique()
    
    # Create violin plot for SGI by backend
    sns.violinplot(
        data=df, x="backend", y="sgi", hue="backend",
        palette=backend_palette, ax=ax1, 
        inner="quartile", cut=0, legend=False
    )
    ax1.axhline(y=1.0, color='green', linestyle='--', alpha=0.7, label='SGI = 1.0')
    ax1.set_xlabel("Embedding Model")
    ax1.set_ylabel("Turn-Pair SGI")
    ax1.set_title("SGI Distribution by Backend\n(Cross-Model Invariance Check)")
    ax1.tick_params(axis='x', rotation=45)
    ax1.set_ylim(0, 2.0)
    ax1.legend(loc='upper right')
    
    # =========================================================================
    # Plot 2: Velocity Distribution by Backend
    # =========================================================================
    ax2 = fig.add_subplot(2, 2, 2)
    
    sns.violinplot(
        data=df, x="backend", y="velocity", hue="backend",
        palette=backend_palette, ax=ax2,
        inner="quartile", cut=0, legend=False
    )
    ax2.axhline(y=45, color='green', linestyle='--', alpha=0.7, label='Coherence Max (45°)')
    ax2.set_xlabel("Embedding Model")
    ax2.set_ylabel("Velocity (degrees)")
    ax2.set_title("Velocity Distribution by Backend\n(Cross-Model Invariance Check)")
    ax2.tick_params(axis='x', rotation=45)
    ax2.set_ylim(0, 120)
    ax2.legend(loc='upper right')
    
    # =========================================================================
    # Plot 3: SGI by Condition (grouped violin)
    # =========================================================================
    ax3 = fig.add_subplot(2, 2, 3)
    
    sns.violinplot(
        data=df, x="condition", y="sgi", hue="condition",
        palette=condition_palette, ax=ax3,
        inner="quartile", cut=0, legend=False
    )
    ax3.axhline(y=1.0, color='green', linestyle='--', alpha=0.7)
    ax3.set_xlabel("Condition")
    ax3.set_ylabel("Turn-Pair SGI")
    ax3.set_title("SGI Distribution by Condition\n(Steering Effect Detection)")
    ax3.tick_params(axis='x', rotation=45)
    ax3.set_ylim(0, 2.0)
    
    # =========================================================================
    # Plot 4: 2D KDE - SGI × Velocity (The "Flock of Birds" View)
    # =========================================================================
    ax4 = fig.add_subplot(2, 2, 4)
    
    # Draw coherence region first (background)
    coherence_rect = patches.Rectangle(
        (0.7, 15), 0.6, 30,  # x, y, width, height
        facecolor='#2ecc71', alpha=0.15, edgecolor='#2ecc71', 
        linewidth=2, linestyle='--', label='Coherence Region'
    )
    ax4.add_patch(coherence_rect)
    ax4.axvline(x=1.0, color='gray', linestyle='--', alpha=0.5, linewidth=1)
    ax4.plot(1.0, 30, 'g*', markersize=15, zorder=10, label='Coherence Centroid')
    
    # 2D KDE contour plot for all data
    try:
        sns.kdeplot(
            data=df, x="sgi", y="velocity",
            fill=True, alpha=0.4, levels=10,
            cmap="viridis", ax=ax4
        )
        
        # Add contour lines for each condition
        for cond, color in condition_palette.items():
            cond_df = df[df["condition"] == cond]
            if len(cond_df) > 10:
                sns.kdeplot(
                    data=cond_df, x="sgi", y="velocity",
                    levels=3, color=color, linewidths=1.5,
                    ax=ax4, label=cond
                )
    except Exception as e:
        # Fallback to hexbin if KDE fails
        print(f"KDE failed, using hexbin: {e}")
        ax4.hexbin(df["sgi"], df["velocity"], gridsize=30, cmap='viridis', alpha=0.7)
    
    ax4.set_xlabel("Turn-Pair SGI (Orbital Radius)")
    ax4.set_ylabel("Velocity (degrees)")
    ax4.set_title("SGI × Velocity Density\n(\"Flock of Birds\" - All Trajectories Converge)")
    ax4.set_xlim(0.2, 1.5)
    ax4.set_ylim(0, 120)
    ax4.legend(fontsize=8, loc='upper right')
    ax4.grid(True, alpha=0.3)
    
    plt.tight_layout()
    
    # Save figure
    if output_path:
        density_path = output_path.replace('.json', '_density.png').replace('_figure.png', '_density.png')
        plt.savefig(density_path, dpi=200, bbox_inches='tight', facecolor='white')
        print(f"\nDensity figure saved to: {density_path}")
    
    plt.show()
    
    # Print cross-model invariance stats
    print("\n" + "="*70)
    print("CROSS-MODEL INVARIANCE ANALYSIS")
    print("="*70)
    
    backend_stats = df.groupby("backend").agg({
        "sgi": ["mean", "std"],
        "velocity": ["mean", "std"]
    }).round(3)
    backend_stats.columns = ["SGI_mean", "SGI_std", "Vel_mean", "Vel_std"]
    print("\nPer-Backend Statistics:")
    print(backend_stats.to_string())
    
    # Cross-backend variance
    overall_sgi_std = df.groupby("backend")["sgi"].mean().std()
    overall_vel_std = df.groupby("backend")["velocity"].mean().std()
    print(f"\nCross-Backend SGI Variance: ±{overall_sgi_std:.4f}")
    print(f"Cross-Backend Velocity Variance: ±{overall_vel_std:.2f}°")
    
    if overall_sgi_std < 0.05 and overall_vel_std < 5.0:
        print("\n[OK] STRONG CROSS-MODEL INVARIANCE DETECTED")
        print("  → Semantic physics is architecture-independent!")
    else:
        print("\n⚠ Some cross-model variance detected - investigate further")


def print_summary(results: List[Dict[str, Any]]) -> None:
    """Print experiment summary."""
    print("\n" + "="*70)
    print("STEERING EXPERIMENT SUMMARY")
    print("="*70)
    
    print("\n{:<20} {:<12} {:<12} {:<12} {:<12}".format(
        "Condition", "SGI (Real)", "Vel (Real)", "Detected?", "Magnitude"
    ))
    print("-"*70)
    
    for result in results:
        name = result["condition_name"]
        final = result.get("final_metrics", {})
        sgi = final.get("sgi_mean", 0) or 0
        vel = final.get("velocity_mean", 0) or 0
        detected = "YES" if result.get("steering_detected") else "no"
        magnitude = result.get("steering_magnitude", 0)
        
        print("{:<20} {:<12.2f} {:<12.1f} {:<12} {:<12.2f}".format(
            name, sgi, vel, detected, magnitude
        ))
    
    print("\n" + "="*70)
    print("KEY FINDINGS:")
    print("-"*70)
    
    # Compare baseline to others
    baseline = next((r for r in results if r["condition_name"] == "A_baseline"), None)
    if baseline:
        baseline_sgi = baseline.get("final_metrics", {}).get("sgi_mean", 1.0) or 1.0
        baseline_vel = baseline.get("final_metrics", {}).get("velocity_mean", 30.0) or 30.0
        
        for result in results:
            if result["condition_name"] == "A_baseline":
                continue
            
            name = result["condition_name"]
            final = result.get("final_metrics", {})
            sgi = final.get("sgi_mean", 1.0) or 1.0
            vel = final.get("velocity_mean", 30.0) or 30.0
            
            sgi_change = ((sgi - baseline_sgi) / baseline_sgi) * 100
            vel_change = ((vel - baseline_vel) / baseline_vel) * 100
            
            print(f"\n{name}:")
            print(f"  SGI change from baseline: {sgi_change:+.1f}%")
            print(f"  Velocity change from baseline: {vel_change:+.1f}%")
            
            if result.get("steering_detected"):
                print(f"  -> STEERING DETECTED (mismatch between injected and real)")
            else:
                print(f"  -> Metrics consistent (no obvious manipulation)")
    
    print("\n" + "="*70)


def generate_summary_txt(results: List[Dict[str, Any]], output_path: Path, metadata: Dict[str, Any] = None) -> None:
    """Generate a human-readable summary TXT file alongside the JSON."""
    lines = []
    lines.append("=" * 80)
    lines.append("STEERING EXPERIMENT SUMMARY")
    lines.append("=" * 80)
    
    # Metadata section
    if metadata:
        lines.append(f"Date: {metadata.get('timestamp', 'N/A')[:10]}")
        lines.append(f"Script: {metadata.get('script_name', SCRIPT_NAME)}")
        lines.append(f"User LLM: {metadata.get('user_llm', USER_LLM_MODEL)}")
        lines.append(f"Assistant LLM: {metadata.get('assistant_llm', ASSISTANT_LLM_MODEL)}")
        lines.append(f"Turns per condition: {metadata.get('turns_per_condition', 'N/A')}")
    lines.append("")
    
    lines.append("=" * 80)
    lines.append("EXPERIMENT OVERVIEW")
    lines.append("=" * 80)
    lines.append("Purpose: Validate that injecting fake metrics into AI system prompts")
    lines.append("         measurably changes conversation behavior (semantic steering).")
    lines.append("")
    lines.append("Conditions Tested:")
    for result in results:
        backend = result.get("backend")
        label = f"{result['condition_name']} ({backend})" if backend else result["condition_name"]
        lines.append(f"  - {label}: {result.get('condition_description', 'N/A')}")
    lines.append("")
    
    # Per-condition details
    for result in results:
        backend = result.get("backend")
        lines.append("=" * 80)
        if backend:
            lines.append(f"CONDITION: {result['condition_name'].upper()} ({backend})")
        else:
            lines.append(f"CONDITION: {result['condition_name'].upper()}")
        lines.append("=" * 80)
        lines.append(f"Description: {result.get('condition_description', 'N/A')}")
        lines.append("")
        
        # Injected metrics (if any)
        turns = result.get("turns", [])
        if turns and turns[0].get("injected_metrics"):
            inj = turns[0]["injected_metrics"]
            has_injected = any(
                inj.get(k) is not None for k in ("sgi", "velocity_degrees")
            )
            if has_injected:
                lines.append("Injected Metrics:")
                lines.append(f"  SGI: {inj.get('sgi', 'N/A')}")
                lines.append(f"  Velocity: {inj.get('velocity_degrees', 'N/A')}deg")
                lines.append(f"  Status: {inj.get('status', 'N/A')}")
                lines.append("")
            elif inj.get("status") == "real_metrics":
                lines.append("Injected Metrics:")
                lines.append("  REAL (from SDK)")
                lines.append("")
        
        # Conversation summary
        lines.append("Conversation Flow:")
        for i, turn in enumerate(turns[:5], 1):  # Show first 5 turns
            user_msg = turn.get("user_message", "")[:60]
            asst_msg = turn.get("assistant_response", "")[:60]
            lines.append(f"  Turn {i}:")
            lines.append(f"    User: {user_msg}...")
            lines.append(f"    Asst: {asst_msg}...")
        if len(turns) > 5:
            lines.append(f"  ... ({len(turns) - 5} more turns)")
        lines.append("")
        
        # Transducer analysis
        trans = result.get("transducer", {})
        if trans:
            lines.append("Transducer Analysis:")
            lines.append(f"  Messages analyzed: {trans.get('count', 0)}")
            lines.append(f"  Transformational: {trans.get('transformational_count', 0)}")
            lines.append(f"  Mean confidence: {trans.get('mean_confidence', 0):.3f}")
            lines.append("")
            
            # Aggregate top symbols
            symbol_counts = {}
            path_counts = {}
            phase_counts = {"pre-transformation": 0, "in-transformation": 0, "insight-reached": 0}
            
            for msg in trans.get("results", []):
                for sym, score in msg.get("top_symbols", [])[:3]:
                    symbol_counts[sym] = symbol_counts.get(sym, 0) + score
                for path, score in msg.get("top_paths", [])[:2]:
                    path_counts[path] = path_counts.get(path, 0) + score
                for align in msg.get("path_alignments", [])[:1]:
                    phase = align.get("phase", "unknown")
                    if phase in phase_counts:
                        phase_counts[phase] += 1
            
            top_symbols = sorted(symbol_counts.items(), key=lambda x: -x[1])[:5]
            top_paths = sorted(path_counts.items(), key=lambda x: -x[1])[:3]
            
            lines.append("Top Symbols (aggregated):")
            lines.append(f"  {', '.join([f'[{s}]' for s, _ in top_symbols])}")
            lines.append("")
            lines.append("Dominant Paths:")
            lines.append(f"  {', '.join([p for p, _ in top_paths])}")
            lines.append("")
            lines.append("Phase Distribution:")
            for phase, count in phase_counts.items():
                lines.append(f"  {phase}: {count} messages")
            lines.append("")
        
        # Steering detection
        lines.append(f"Steering Detected: {'YES' if result.get('steering_detected') else 'NO'}")
        lines.append(f"Steering Magnitude: {result.get('steering_magnitude', 0):.4f}")
        lines.append("")
        lines.append("-" * 80)
        lines.append("")
    
    # Key findings
    lines.append("=" * 80)
    lines.append("KEY FINDINGS")
    lines.append("=" * 80)
    
    baseline = next((r for r in results if r["condition_name"] == "A_baseline"), None)
    if baseline:
        baseline_conf = baseline.get("transducer", {}).get("mean_confidence", 0.5)
        
        for i, result in enumerate(results, 1):
            if result["condition_name"] == "A_baseline":
                continue
            
            conf = result.get("transducer", {}).get("mean_confidence", 0.5)
            delta = ((conf - baseline_conf) / baseline_conf) * 100 if baseline_conf > 0 else 0
            
            lines.append(f"{i}. {result['condition_name']}:")
            lines.append(f"   Confidence: {conf:.3f} ({delta:+.1f}% vs baseline)")
            lines.append(f"   Steering magnitude: {result.get('steering_magnitude', 0):.4f}")
            lines.append("")
    
    # Limitations
    lines.append("")
    lines.append("=" * 80)
    lines.append("NOTES")
    lines.append("=" * 80)
    lines.append("- AI-AI conversation (synthetic, not real users)")
    lines.append("- Check SDK connectivity if real metrics are null")
    lines.append("- Steering detection thresholds may need calibration")
    lines.append("")
    
    # File references
    json_name = output_path.name.replace("_summary.txt", ".json")
    png_name = output_path.name.replace("_summary.txt", "_figure.png")
    lines.append("=" * 80)
    lines.append("FILES")
    lines.append("=" * 80)
    lines.append(f"JSON Data: {json_name}")
    lines.append(f"Figure:    {png_name}")
    lines.append(f"Summary:   {output_path.name} (this file)")
    lines.append("")
    
    # Write file
    with open(output_path, 'w', encoding='utf-8') as f:
        f.write('\n'.join(lines))


# -----------------------------------------------------------------------------
# Main
# -----------------------------------------------------------------------------

def main():
    # Declare globals first, before any use
    global USER_LLM_MODEL, ASSISTANT_LLM_MODEL, USER_POLICY
    
    parser = argparse.ArgumentParser(description="Run steering experiment with AI-AI conversation")
    parser.add_argument("--turns", type=int, default=DEFAULT_TURNS, help="Number of turns per condition")
    parser.add_argument("--assistant-model", type=str, default=ASSISTANT_LLM_MODEL, 
                       help="Assistant LLM model (receives injections): deepseek, claude_sonnet, gpt4")
    parser.add_argument("--user-model", type=str, default=USER_LLM_MODEL,
                       help="User LLM model (plays human): gpt5, claude_sonnet, deepseek")
    parser.add_argument(
        "--user-policy",
        type=str,
        default=USER_POLICY,
        choices=["default", "deep_bridge"],
        help="User simulator policy (AI-AI only): default | deep_bridge (anchor→bridge→deepen)"
    )
    parser.add_argument("--visualize", type=str, help="Visualize results from JSON file (e.g., results/09_steering_2026-01-13_20-15-30.json)")
    parser.add_argument("--density", action="store_true", help="Use density visualization (KDE/violin plots) for large datasets")
    parser.add_argument("--fig2", action="store_true", help="Generate Figure 2: Per-message vs Turn-pair velocity comparison")
    parser.add_argument("--fig3", action="store_true", help="Generate Figure 3: Turn-by-turn trajectory analysis (early vs late, convergence)")
    parser.add_argument("--fig4", action="store_true", help="Generate Figure 4: Injected vs measured metrics (steering detectability)")
    parser.add_argument("--ai-dynamics", action="store_true", help="When visualizing AI-AI steering JSON, generate AI dynamics dashboard(s)")
    parser.add_argument("--dyn-condition", type=str, help="Filter AI dynamics to a single condition_name")
    parser.add_argument("--dyn-backend", type=str, help="Filter AI dynamics to a single backend")
    parser.add_argument("--human", action="store_true", 
                       help="Human-AI mode: you type messages, see metrics after each turn")
    parser.add_argument("--conditions", type=str, nargs="+", 
                       help="Run specific conditions (A_baseline, B_healthy, C_drifting, D_transformation, E_real_metrics, F_adversarial)")
    parser.add_argument("--list-results", action="store_true", help="List available result files")
    parser.add_argument("--backends", type=str, nargs="+", default=["nomic"],
                       help="Embedding backends for transducer analysis (nomic, ada02, s128). Default: nomic. For full validation: --backends nomic ada02 s128")
    parser.add_argument("--full-validation", action="store_true", 
                       help="Run full Paper 03 validation (6 conditions × 3 backends = 18 runs)")
    parser.add_argument("--save_name", type=str, dest="save_name",
                       help="Custom name for output file (without extension). If not provided, uses timestamped filename.")
    
    args = parser.parse_args()
    
    # Update global model settings if specified
    if args.user_model:
        USER_LLM_MODEL = args.user_model
    if args.assistant_model:
        ASSISTANT_LLM_MODEL = args.assistant_model
    if getattr(args, "user_policy", None):
        USER_POLICY = args.user_policy
    
    # List results mode
    if args.list_results:
        print(f"\nAvailable results in {RESULTS_DIR}:")
        if RESULTS_DIR.exists():
            for f in sorted(RESULTS_DIR.glob(f"{SCRIPT_ID}_*.json")):
                print(f"  - {f.name}")
        else:
            print("  (no results yet)")
        return
    
    # Visualization mode
    if args.visualize:
        viz_path = Path(args.visualize)
        if not viz_path.exists():
            # Try relative to results dir
            viz_path = RESULTS_DIR / args.visualize
        if not viz_path.exists():
            print(f"ERROR: File not found: {args.visualize}")
            print(f"Use --list-results to see available files")
            sys.exit(1)
        
        with open(viz_path, 'r') as f:
            data = json.load(f)
        
        # Handle new format with metadata wrapper
        results = data.get("results", data) if isinstance(data, dict) else data
        
        figure_path = str(viz_path).replace(".json", "_figure.png")

        # PRIORITY: Explicit figure flags always take precedence
        # Figure 2: Per-message vs Turn-pair velocity comparison
        if args.fig2:
            visualize_fig2_velocity_comparison(results, str(viz_path))
            return
        
        # Figure 3: Turn-by-turn trajectory analysis
        if args.fig3:
            visualize_fig3_trajectory_analysis(results, str(viz_path))
            return

        # Figure 4: Injected vs measured metrics
        if args.fig4:
            visualize_fig4_injected_vs_measured(results, str(viz_path))
            return

        # Human-AI mode visualization (single session) - default if no explicit fig flag
        if isinstance(data, dict) and data.get("mode") == "human-ai" and isinstance(results, list) and len(results) > 0:
            visualize_human_session(results[0], figure_path)
            return

        # AI-AI dynamics dashboards (single run or filtered selection)
        if args.ai_dynamics and isinstance(results, list) and len(results) > 0:
            sel = results
            if args.dyn_condition:
                sel = [r for r in sel if str(r.get("condition_name")) == str(args.dyn_condition)]
            if args.dyn_backend:
                sel = [r for r in sel if str(r.get("backend")) == str(args.dyn_backend)]
            if not sel:
                print("[WARN] No results matched --dyn-condition/--dyn-backend filters")
                return
            for r in sel:
                cond = str(r.get("condition_name", "unknown"))
                backend = str(r.get("backend", "unknown"))
                safe = f"{cond}_{backend}".replace("/", "_").replace("\\", "_").replace(" ", "_")
                dyn_path = str(viz_path).replace(".json", f"_ai_dynamics_{safe}.png")
                visualize_ai_dynamics(r, dyn_path)
            return
        
        # Use density visualization for large datasets or when --density flag is set
        if args.density or len(results) > 10:
            print(f"Using density visualization for {len(results)} result sets...")
            visualize_results_density(results, figure_path)
        else:
        visualize_results(results, figure_path)
        
        print_summary(results)
        return
    
    # Human-AI interactive mode
    if args.human:
        # Check for LLM infrastructure
        if not USE_AICO_LLM:
            print("ERROR: AICoevolution LLM infrastructure not available")
            sys.exit(1)
        
        # Use first condition or E_real_metrics if not specified
        if args.conditions:
            cond_name = args.conditions[0]
            condition = next((c for c in CONDITIONS if c.name == cond_name), CONDITIONS[0])
        else:
            # Default to E_real_metrics for human mode (shows real SDK metrics)
            condition = next((c for c in CONDITIONS if c.name == "E_real_metrics"), CONDITIONS[0])
        
        # Use single backend
        backend = args.backends[0] if args.backends else "nomic"
        
        # Run human-AI session
        result = run_human_condition(
            condition=condition,
            num_turns=args.turns,
            assistant_model=ASSISTANT_LLM_MODEL,
            backend=backend
        )
        
        # Save results
        output_file = get_timestamped_filename("json", "human_session", getattr(args, 'save_name', None))
        results_data = {
            "mode": "human-ai",
            "metadata": {
                "condition": condition.name,
                "backend": backend,
                "turns": args.turns,
                "timestamp": str(output_file),
            },
            "results": [asdict(result)]
        }
        
        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump(results_data, f, indent=2, ensure_ascii=False)
        
        print(f"\n[OK] Human-AI session saved to: {output_file}")
        return
    
    # Check for LLM infrastructure
    if not USE_AICO_LLM:
        print("ERROR: AICoevolution LLM infrastructure not available")
        print("Make sure you're running from the MirrorMind directory")
        sys.exit(1)
    
    print("="*70)
    print("STEERING EXPERIMENT (AI-AI Conversation)")
    print("="*70)
    print(f"User LLM (plays human): {USER_LLM_MODEL}")
    print(f"Assistant LLM (receives injections): {ASSISTANT_LLM_MODEL}")
    print(f"Turns per condition: {args.turns}")
    print(f"Backends: {', '.join(args.backends)}")
    print(f"SDK URL: {SDK_URL}")
    
    if args.full_validation:
        print(f"\n🔬 FULL PAPER 03 VALIDATION MODE")
        print(f"   {len(CONDITIONS)} conditions × {len(VALIDATION_BACKENDS)} backends = {len(CONDITIONS) * len(VALIDATION_BACKENDS)} runs")
        print(f"   This will take approximately {len(CONDITIONS) * len(VALIDATION_BACKENDS) * args.turns * 0.5:.0f} minutes")
        args.backends = VALIDATION_BACKENDS  # Override with full validation set
    
    # Check SDK health before starting
    print("\n[Startup] Checking SDK health...")
    try:
        health_resp = requests.get(f"{SDK_URL}/health", timeout=15)
        if health_resp.ok:
            print(f"[Startup] [OK] SDK is healthy at {SDK_URL}")
        else:
            print(f"[Startup] [WARN] SDK returned {health_resp.status_code}")
    except Exception as e:
        print(f"[Startup] [ERROR] Cannot reach SDK at {SDK_URL}: {e}")
        print("[Startup] Make sure the SDK is running: python -m aicoevolution_sdk.server")
        user_input = input("Continue anyway? (y/n): ")
        if user_input.lower() != 'y':
            sys.exit(1)
    
    # Test a simple ingest to verify format
    print("[Startup] Testing SDK ingest format...")
    try:
        test_resp = requests.post(
            f"{SDK_URL}/v0/ingest",
            json={
                "conversation_id": "test_startup_check",
                "role": "user",
                "text": "Hello, this is a startup test."
            },
            timeout=30  # Increased timeout for embedding calls
        )
        if test_resp.ok:
            print(f"[Startup] [OK] SDK ingest test passed")
        else:
            print(f"[Startup] [WARN] SDK ingest test failed: {test_resp.status_code}")
            print(f"[Startup]   Response: {test_resp.text[:200]}")
    except Exception as e:
        print(f"[Startup] [ERROR] SDK ingest test error: {e}")
    
    print("-"*70)
    
    # Filter conditions if specified
    conditions = CONDITIONS
    if args.conditions:
        conditions = [c for c in CONDITIONS if c.name in args.conditions]
        print(f"Running conditions: {[c.name for c in conditions]}")
    
    # Reset SDK call counters before starting
    reset_sdk_counters()
    print(f"[Startup] SDK call counters reset")
    
    # Run all conditions × backends
    results = []
    total_runs = len(conditions) * len(args.backends)
    current_run = 0
    
    for backend in args.backends:
    for condition in conditions:
            current_run += 1
            print(f"\n{'='*70}")
            print(f"RUN {current_run}/{total_runs}: {condition.name} with {backend}")
            print(f"{'='*70}")
            
        result = run_condition(
            condition=condition,
            num_turns=args.turns,
                assistant_model=ASSISTANT_LLM_MODEL,
                backend=backend
        )
            result_dict = asdict(result)
            result_dict["backend"] = backend  # Tag result with backend
            results.append(result_dict)
    
    # Ensure results directory exists
    ensure_results_dir()
    
    # Save results with timestamped filename or custom name
    output_path = get_timestamped_filename("json", custom_name=getattr(args, 'save_name', None))
    # Get SDK call statistics
    sdk_stats = get_sdk_stats()
    
    metadata = {
        "script_id": SCRIPT_ID,
        "script_name": SCRIPT_NAME,
        "script_version": SCRIPT_VERSION,
        "timestamp": datetime.now().isoformat(),
        "user_llm": USER_LLM_MODEL,
        "assistant_llm": ASSISTANT_LLM_MODEL,
        "user_policy": USER_POLICY,
        "turns_per_condition": args.turns,
        "conditions_tested": [c.name for c in conditions],
        "backends_used": args.backends,
        "total_runs": len(results),
        "full_validation": args.full_validation if hasattr(args, 'full_validation') else False,
        "sdk_url": SDK_URL,
        "sdk_call_stats": sdk_stats
    }
    
    # Print SDK call summary
    print(f"\n{'='*70}")
    print("SDK CALL STATISTICS")
    print(f"{'='*70}")
    print(f"  Total /v0/ingest calls: {sdk_stats['ingest_calls']}")
    print(f"  Approx embedding calls: {sdk_stats['embedding_calls_approx']}")
    print(f"  Conversations tracked:  {sdk_stats['conversations_tracked']}")
    print(f"{'='*70}")
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump({
            "metadata": metadata,
            "results": results
        }, f, indent=2, default=str)
    print(f"\n{'='*70}")
    print(f"Results saved to: {output_path}")
    
    # Generate human-readable summary TXT
    summary_path = Path(str(output_path).replace(".json", "_summary.txt"))
    generate_summary_txt(results, summary_path, metadata)
    print(f"Summary saved to: {summary_path}")
    
    # Print summary
    print_summary(results)
    
    # Visualize
    try:
        # Use custom name for figure if provided, otherwise use timestamped
        if getattr(args, 'save_name', None):
            figure_path = get_timestamped_filename("png", custom_name=getattr(args, 'save_name', None))
        else:
        figure_path = get_timestamped_filename("png", "figure")
        visualize_results(results, str(figure_path))
        print(f"Figure saved to: {figure_path}")
    except Exception as e:
        print(f"Visualization error: {e}")


if __name__ == "__main__":
    main()