auto_session.py

# auto_session.py
# Runs automated training sessions with Task Agent and Grader Agent.
# Includes curriculum rotation: subject selection and lesson picking.

import os
import json
import re
import argparse
from datetime import datetime
from typing import Optional
import torch
# Model loading delegated to model_cache.py (per-process cache)
from openai import OpenAI

from config import (
    LOG_DIR,
    PROMPT_TUTOR_KICKOFF,
    PROMPT_TUTOR_PRIMER,
    PROMPT_SOPHIE_LESSON_SELECT,
    PROMPT_SOPHIE_POST_GRADE,
    PROMPT_SOPHIE_REACT_TEACHING,
    PROMPT_TUTOR_WRAPUP,
    PROMPT_SOPHIE_WRAPUP,
    PROMPT_TUTOR_PHASE_B,
    PROMPT_TUTOR_PHASE_F,
    get_age_band_natural_description,
    get_length_guidance,
    get_max_tokens_ceiling,
    get_task_guidance_for_age_band,
    PROMPT_TASK_VALIDATOR,
    PROMPT_TASK_NATURALIZER,
    TASK_NATURALIZER_CACHE_FILE,
    TASK_NATURALIZER_MODEL,
    TUTOR_MODEL,
    SOPHIE_MODEL,
    TASK_AGENT_MODEL,
    SESSION_MAX_TURNS,
    GRADE_EVERY_N_TURNS,
    BASIL_MAX_TOKENS,
    CONTEXT_WINDOW_LINES,
    SCORE_FLOOR,
    SCORE_FLOOR_WINDOW,
    score_to_weight,
    get_basil_model_name,
    DEBUG_SESSION,
    USE_LLM_TUTOR_FOR_AGE_BAND_0,
    # Phase 4 lifecycle settings
    MIN_GRADED_TURNS_PER_SESSION,
    MAX_GRADED_TURNS_PER_SESSION,
    EARLY_STOP_WINDOW_TURNS,
    EARLY_STOP_MIN_AVG_SCORE,
    EARLY_STOP_MAX_COMPLIANCE,
    ENABLE_GRACEFUL_WRAPUP,
    WRAPUP_TURNS,
    COMPLIANCE_SCORE_THRESHOLD,
    # Contract validation
    STRICT_TASK_CONTRACT,
    ALLOW_DEPRECATED_TOPIC_CHECK,
    # Logging
    LOG_TEACHING_PREVIEW_CHARS,
    # Training threshold
    get_train_every_graded_turns,
    # Popquiz
    POPQUIZ_ENABLED,
    PROMPT_TUTOR_QUIZ_SOPHIE,
    get_basil_generation_settings,
)
from task_contract import (
    normalize_token,
    normalize_targets,
    text_contains_token,
    validate_task_spec_contract,
    validate_naturalized_contains_targets,
)
from task_agent import generate_task, generate_task_candidates, select_best_task, _enforce_target_invariants
from grader_agent import grade_response
from score_override import apply_score_floor
from assessment_agent import assess_developmental_age_band
from memory_manager import (
    update_metrics_after_turn,
    update_metrics_after_session,
    generate_session_summary,
    load_metrics,
    load_basil_assessment,
    update_basil_assessment,
    get_assessment_for_prompt,
)
from curriculum_manager import (
    record_subject,
    record_lesson,
    get_blacklists,
    format_blacklist_for_prompt,
    normalize_subject,
    load_used_lessons,
    add_used_lesson,
    check_lesson_overlap,
)
from dedup_utils import fuzzy_match as dedup_fuzzy_match
from file_lock_utils import get_lock
from subject_generator import generate_subject_candidates
from teaching_angle_generator import pick_angle
from subject_topic_generator import pick_topic
from metrics_manager import (
    create_session_metrics,
    load_rolling_metrics,
    save_session_metrics,
    update_rolling_metrics,
)

from llm_client import create_smart_client
client = create_smart_client()

# Stopwords for keyword extraction (excluded from topic keywords)
STOPWORDS = {
    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
    "have", "has", "had", "do", "does", "did", "will", "would", "could",
    "should", "may", "might", "must", "can", "about", "above", "after",
    "again", "all", "and", "any", "because", "before", "being", "below",
    "between", "both", "but", "by", "could", "during", "each", "few",
    "for", "from", "further", "here", "how", "into", "its", "just",
    "more", "most", "not", "now", "off", "only", "other", "our", "out",
    "over", "own", "same", "some", "such", "than", "that", "their",
    "them", "then", "there", "these", "they", "this", "those", "through",
    "too", "under", "until", "very", "what", "when", "where", "which",
    "while", "who", "why", "with", "you", "your", "today", "things",
}

SOPHIE_SCORE_REACTIONS = {
    0: ("Basil produced no English at all (0/7).",
        "Be gentle and warm. Don't reference what Basil said. Just encourage trying again."),
    1: ("Basil said an English word, but it had nothing to do with the lesson (1/7).",
        "Acknowledge the effort kindly. Note that Basil is finding words, even if they're not on topic yet."),
    2: ("Basil used several English words, but none related to the lesson topic (2/7).",
        "Supportive and patient. Basil is speaking more but hasn't connected to the lesson yet."),
    3: ("Basil used a word from the lesson topic -- real progress! (3/7).",
        "Noticeably pleased! Basil is starting to connect words to what's being taught. Show you noticed."),
    4: ("Basil used words directly related to the question -- getting close! (4/7).",
        "Excited and encouraging. Basil is clearly understanding the lesson. Cheer them on."),
    5: ("Basil tried to answer in the right format but didn't quite get the target word (5/7).",
        "Genuinely impressed! Basil almost got it. Express that you can tell Basil is so close."),
    6: ("Basil said the target word! It was buried in extra words, but it was there (6/7).",
        "Thrilled! Celebrate that Basil found the word. Be proud and specific about what Basil got right."),
    7: ("Basil nailed it -- clean, correct response! (7/7).",
        "Over the moon! This is a big deal. Celebrate genuinely with real excitement and pride."),
}

# Prompt cache for episode-specific prompts
_prompt_cache = {}

def _load_episode_prompt(file_path: str, prompt_name: str) -> str:
    """Load and cache an episode prompt file."""
    if file_path not in _prompt_cache:
        try:
            with open(file_path, "r") as f:
                _prompt_cache[file_path] = f.read()
            if DEBUG_SESSION:
                print(f"[Prompt] Loaded {prompt_name}: {file_path}")
        except FileNotFoundError:
            print(f"[Prompt] Warning: {file_path} not found, using fallback")
            _prompt_cache[file_path] = None
    return _prompt_cache.get(file_path)


# =============================================================================
# TASK NATURALIZER CACHE
# =============================================================================
# In-memory cache for task naturalization (persisted at session end)
_task_naturalizer_cache = {}
_task_naturalizer_cache_dirty = False


def _load_task_naturalizer_cache() -> dict:
    """Load task naturalizer cache from disk."""
    global _task_naturalizer_cache
    if _task_naturalizer_cache:
        return _task_naturalizer_cache
    try:
        if os.path.exists(TASK_NATURALIZER_CACHE_FILE):
            with open(TASK_NATURALIZER_CACHE_FILE, "r") as f:
                _task_naturalizer_cache = json.load(f)
            if DEBUG_SESSION:
                print(f"[TaskNaturalizer] Loaded cache with {len(_task_naturalizer_cache)} entries")
    except (json.JSONDecodeError, IOError) as e:
        print(f"[TaskNaturalizer] Cache load error: {e}")
        _task_naturalizer_cache = {}
    return _task_naturalizer_cache


def _save_task_naturalizer_cache():
    """Save task naturalizer cache to disk (called at session end). Process-safe via file lock."""
    global _task_naturalizer_cache_dirty
    if not _task_naturalizer_cache_dirty:
        return
    try:
        with get_lock(TASK_NATURALIZER_CACHE_FILE):
            # Re-read from disk under lock to merge any entries added by other workers
            disk_cache = {}
            if os.path.exists(TASK_NATURALIZER_CACHE_FILE):
                try:
                    with open(TASK_NATURALIZER_CACHE_FILE, "r") as f:
                        disk_cache = json.load(f)
                except (json.JSONDecodeError, IOError):
                    pass
            # Merge: our in-memory entries take precedence
            disk_cache.update(_task_naturalizer_cache)
            os.makedirs(os.path.dirname(TASK_NATURALIZER_CACHE_FILE), exist_ok=True)
            with open(TASK_NATURALIZER_CACHE_FILE, "w") as f:
                json.dump(disk_cache, f, indent=2)
        _task_naturalizer_cache_dirty = False
        if DEBUG_SESSION:
            print(f"[TaskNaturalizer] Saved cache with {len(_task_naturalizer_cache)} entries")
    except IOError as e:
        print(f"[TaskNaturalizer] Cache save error: {e}")


def _get_naturalizer_cache_key(task_text: str, task_category: str, age_band: int, speaker: str) -> str:
    """Generate a cache key for task naturalization."""
    import hashlib
    key_str = f"{age_band}|{task_category}|{speaker}|{task_text.strip().lower()}"
    return hashlib.md5(key_str.encode()).hexdigest()[:16]


def parse_lesson_from_response(response: str) -> Optional[str]:
    """
    Parse LESSON_OF_THE_DAY: <lesson title> from Sophie's response.
    
    Returns the lesson title or None if not found.
    """
    # Look for the marker
    pattern = r'LESSON_OF_THE_DAY:\s*(.+?)(?:\n|$)'
    match = re.search(pattern, response, re.IGNORECASE)
    
    if match:
        lesson = match.group(1).strip()
        # Clean up any trailing punctuation or formatting
        lesson = lesson.rstrip('.,;:')
        return lesson
    
    return None


class AutoSession:
    """Runs an automated Basil training session with curriculum support."""
    
    def __init__(
        self,
        session_id: Optional[str] = None,
        include_sophie: bool = True,
        content_snippet: str = "",
        subject: Optional[str] = None,  # Override subject selection
        verbose: bool = True,
        training_phase: str = "normal",  # "normal", "pretrain_eval", "posttrain_eval"
        batch_graded_path: Optional[str] = None,   # Batch-level graded JSONL (append)
        batch_sessions_path: Optional[str] = None,  # Batch-level debug log (append)
        batch_meta_path: Optional[str] = None,      # Batch-level metrics+summaries (append)
        model_path: Optional[str] = None,           # Override model path (experiment support)
        lora_strength: Optional[float] = None,      # Override LoRA strength (experiment support)
        skip_assessment: bool = False,               # Skip assessment/metrics updates (experiment eval)
    ):
        self.session_id = session_id or datetime.now().strftime("%Y%m%d_%H%M%S")
        # Store experiment overrides for _load_basil_model
        self._model_path_override = model_path
        self._lora_strength_override = lora_strength
        self.skip_assessment = skip_assessment
        self.include_sophie = include_sophie
        self.verbose = verbose
        self.training_phase = training_phase
        
        # Batch file paths (None = standalone mode, creates per-session files)
        self.batch_graded_path = batch_graded_path
        self.batch_sessions_path = batch_sessions_path
        self.batch_meta_path = batch_meta_path
        
        # Session state
        self.transcript = []  # List of (speaker, text) tuples
        self.graded_turns = []  # List of graded turn data
        self.turn_number = 0
        self._quiz_words_used = []  # Track quiz answer words to avoid repetition
        self.graded_turn_count = 0  # Phase 4: explicit graded turn counter
        self.recent_scores = []  # For rolling average (used for early stopping)
        self.total_basil_tokens = 0  # Track token usage
        self.episode_transcript_start = 0  # Index into self.transcript where current episode began
        self.recent_tasks = []  # List of (task_category, task_text) tuples for anti-repetition
        self.recent_sophie_questions = []  # List of normalized question topics for novelty
        self.recent_teaching_facts = []  # List of recent key facts/details used in teaching (for variety)
        self.previous_askers = []  # Track who asked recent tasks (for variety)
        self.recent_targets = []  # List of recent target words used in tasks (for variety)
        
        # Phase 4: stop state
        self.early_stopped = False
        self.stop_reason = "completed"
        
        # Curriculum state
        self.subject_of_the_day = subject  # Will be set in prelude if None
        self.lesson_of_the_day = None
        self.topic = None  # Set during prelude (Subject -> Topic -> Lesson hierarchy)
        self.teaching_angle = None  # Set during prelude (age_band >= 4 only)
        self.blacklists = get_blacklists()
        
        # Load Basil assessment
        self.assessment = get_assessment_for_prompt()
        self.age_band_start = self.assessment.get("age_band", 0)  # Track starting age_band
        basil_gen_settings = get_basil_generation_settings(self.age_band_start)
        self.basil_max_tokens = basil_gen_settings["max_tokens"]
        self.basil_temperature = basil_gen_settings["temperature"]
        
        # Load prompts
        self.tutor_kickoff_template = self._load_file(PROMPT_TUTOR_KICKOFF)
        self.tutor_primer_template = self._load_file(PROMPT_TUTOR_PRIMER)
        # Load separate Sophie prompts for lesson selection, reaction to teaching, and post-grade
        self.sophie_lesson_select_template = self._load_file(PROMPT_SOPHIE_LESSON_SELECT) if include_sophie else None
        self.sophie_react_teaching_template = self._load_file(PROMPT_SOPHIE_REACT_TEACHING) if include_sophie else None
        self.sophie_post_grade_template = self._load_file(PROMPT_SOPHIE_POST_GRADE) if include_sophie else None
        self.tutor_wrapup_template = self._load_file(PROMPT_TUTOR_WRAPUP)
        self.sophie_wrapup_template = self._load_file(PROMPT_SOPHIE_WRAPUP) if include_sophie else None
        
        # Load Basil model
        self._load_basil_model()
        
        if self.verbose:
            print(f"[Session {self.session_id}] Initialized")
            print(f"  - Sophie: {'enabled' if include_sophie else 'disabled'}")
            print(f"  - Training phase: {training_phase}")
            print(f"  - Graded turns: min={MIN_GRADED_TURNS_PER_SESSION}, max={MAX_GRADED_TURNS_PER_SESSION}")
            print(f"  - Basil age_band: {self.assessment['age_band']} ({self.assessment['age_band_description']})")
            print(f"  - Basil max tokens: {self.basil_max_tokens}")
    
    def _load_file(self, filepath: str) -> str:
        """Load a text file."""
        if os.path.exists(filepath):
            with open(filepath, "r") as f:
                return f.read()
        return ""
    
    def _load_basil_model(self):
        """Load the Basil model, using per-process cache to avoid reloading every session.
        
        Supports model path override via:
          1. self.model_path (constructor parameter)
          2. BASIL_MODEL_PATH env var (from config)
          3. get_basil_model_name() (default: latest model)
        
        LoRA strength resolution (first non-None wins):
          1. self._lora_strength_override (constructor parameter)
          2. BASIL_LORA_STRENGTH env var (from config, for experiments)
          3. lora_strength_for_age_band(age_band) — smooth 0.0→1.0 scaling
        
        Always calls set_lora_strength() to ensure the adapter contribution is
        correctly scaled — even for age_band=0 (sets to 0.0, effectively trunk-only).
        """
        from model_cache import get_cached_model, set_lora_strength
        from config import BASIL_MODEL_PATH, BASIL_LORA_STRENGTH, lora_strength_for_age_band
        
        # Resolve model path: constructor param > env var > default
        if hasattr(self, '_model_path_override') and self._model_path_override:
            model_path = self._model_path_override
        elif BASIL_MODEL_PATH:
            model_path = BASIL_MODEL_PATH
        else:
            model_path = get_basil_model_name()
        
        if self.verbose:
            print(f"  - Basil model: {model_path}")
        self.model, self.tokenizer, self.device = get_cached_model(
            model_path, verbose=self.verbose, age_band=self.age_band_start)
        
        # Resolve LoRA strength: constructor override > env var > age-band scaling
        lora_strength = getattr(self, '_lora_strength_override', None)
        if lora_strength is None and BASIL_LORA_STRENGTH is not None:
            lora_strength = BASIL_LORA_STRENGTH
        if lora_strength is None:
            lora_strength = lora_strength_for_age_band(self.age_band_start)
        # Always apply — even 0.0 is meaningful (trunk-only at early age bands)
        set_lora_strength(self.model, lora_strength, verbose=self.verbose)
    
    def _get_recent_conversation(self, n_lines: int = None, clean_for_training: bool = True) -> str:
        """
        Get recent conversation as formatted text.
        
        Shows the full session transcript up to this point (not just current episode)
        to prevent intra-session repetition across episodes.
        
        Args:
            n_lines: Number of transcript entries to include (defaults to CONTEXT_WINDOW_LINES)
            clean_for_training: If True, strips machine markers (TASK:, SUBJECT_OF_THE_DAY:, etc.)
                               to keep training data natural
        """
        # Use last N entries from the full session transcript
        n = n_lines or CONTEXT_WINDOW_LINES
        recent = self.transcript[-n:] if self.transcript else []
        
        lines = []
        for speaker, text in recent:
            if clean_for_training:
                text = self._clean_transcript_for_training(text)
            lines.append(f"{speaker}: {text}")
        
        return "\n".join(lines)
    
    def _clean_transcript_for_training(self, text: str) -> str:
        """Delegate to shared utility so inference and LoRA training use same cleaning."""
        from utils.transcript import clean_transcript_for_training
        return clean_transcript_for_training(text)
    
    def _get_session_text_before_basil(self) -> str:
        """
        Get all Tutor/Sophie text from the transcript up to the current point.
        
        Used for session-word override: checks if Basil repeated any word
        that Tutor or Sophie said earlier in the session (kickoff, lesson
        selection, primer, episode content). Excludes prior Basil turns.
        """
        parts = []
        for speaker, text in self.transcript:
            if speaker != "Basil":
                parts.append(text)
        return " ".join(parts)

    def _get_rolling_transcript_window(self, max_entries: int = 20, max_chars: int = 3000, clean_for_training: bool = True) -> str:
        """
        Get a rolling transcript window for Tutor prompts.
        
        Returns formatted dialogue context, bounded by both entry count and character limit.
        Truncates oldest entries first if over limit.
        
        Args:
            max_entries: Maximum number of transcript entries to include
            max_chars: Maximum total characters (truncates oldest first)
            clean_for_training: If True, strips machine markers
        
        Returns:
            Formatted string of recent dialogue: "Role: content\n..."
        """
        if not self.transcript:
            return "[No conversation yet]"
        
        # Get last N entries
        recent = self.transcript[-max_entries:]
        
        # Format entries
        formatted_lines = []
        total_chars = 0
        
        # Work backwards from most recent to oldest
        for speaker, text in reversed(recent):
            # Clean markers if requested
            if clean_for_training:
                text = self._clean_transcript_for_training(text)
            
            # Skip empty entries after cleaning
            if not text:
                continue
            
            # Truncate individual entries if too long
            if len(text) > 300:
                text = text[:300] + "..."
            
            line = f"{speaker}: {text}"
            
            # Check if adding this line would exceed limit
            if total_chars + len(line) + 1 > max_chars:
                # Stop adding more entries
                break
            
            formatted_lines.insert(0, line)  # Insert at beginning to maintain order
            total_chars += len(line) + 1  # +1 for newline
        
        if not formatted_lines:
            # At minimum include the most recent entry
            speaker, text = self.transcript[-1]
            if len(text) > 300:
                text = text[:300] + "..."
            formatted_lines = [f"{speaker}: {text}"]
        
        return "\n".join(formatted_lines)
    
    def _get_episode_transcript(self, clean_for_training: bool = True) -> str:
        """
        Get only the current episode's transcript entries.
        
        Used for Basil (Phase C) and Grader (Phase D) which only need to see
        the current episode, not the full session history.
        """
        episode_entries = self.transcript[self.episode_transcript_start:]
        if not episode_entries:
            return ""
        
        lines = []
        for speaker, text in episode_entries:
            if clean_for_training:
                text = self._clean_transcript_for_training(text)
            if text:
                lines.append(f"{speaker}: {text}")
        
        return "\n".join(lines)
    
    def _get_full_session_transcript(self, max_chars: int = 15000, clean_for_training: bool = True) -> str:
        """
        Get the full session transcript up to this point.
        
        Used for Tutor, Sophie, and TaskAgent prompts that benefit from seeing
        the entire session context to avoid repetition and maintain continuity.
        
        Args:
            max_chars: Safety cap on total characters. Truncates oldest entries first.
            clean_for_training: If True, strips machine markers.
        """
        if not self.transcript:
            return "[No conversation yet]"
        
        # Format all entries
        formatted_lines = []
        total_chars = 0
        
        # Work backwards from most recent, stop when we hit the char limit
        for speaker, text in reversed(self.transcript):
            if clean_for_training:
                text = self._clean_transcript_for_training(text)
            if not text:
                continue
            # Truncate individual entries if very long
            if len(text) > 400:
                text = text[:400] + "..."
            
            line = f"{speaker}: {text}"
            if total_chars + len(line) + 1 > max_chars:
                break
            
            formatted_lines.insert(0, line)
            total_chars += len(line) + 1
        
        if not formatted_lines:
            speaker, text = self.transcript[-1]
            if len(text) > 400:
                text = text[:400] + "..."
            formatted_lines = [f"{speaker}: {text}"]
        
        return "\n".join(formatted_lines)
    
    def _debug_session_state(self, agent_name: str, context_preview: str = ""):
        """Debug instrumentation: print session state continuity info."""
        if not DEBUG_SESSION:
            return
        
        print(f"\n[DEBUG] {agent_name} Input:")
        print(f"  Session ID: {id(self)}")
        print(f"  Transcript ID: {id(self.transcript)}")
        print(f"  Transcript length: {len(self.transcript)} entries")
        print(f"  Turn number: {self.turn_number}")
        
        # Show last 3 messages
        if self.transcript:
            print(f"  Last 3 transcript entries:")
            for i, (speaker, text) in enumerate(self.transcript[-3:], 1):
                preview = text[:120] + "..." if len(text) > 120 else text
                print(f"    {i}. {speaker}: {preview}")
        
        if context_preview:
            print(f"  Context preview: {context_preview[:200]}...")
        print()
    
    def _debug_prompt_payload(self, episode_id: str, phase: str, agent_name: str, 
                               messages_or_prompt, recent_conv: str = None):
        """
        Debug instrumentation: log the EXACT prompt payload being sent to LLM.
        
        Args:
            episode_id: Current episode ID
            phase: Current phase (A/B/C/D/E/F)
            agent_name: Agent being called
            messages_or_prompt: Either the messages list (for chat models) or prompt string
            recent_conv: The recent_conversation string if available
        """
        if not DEBUG_SESSION:
            return
        
        print(f"\n{'='*60}")
        print(f"[PROMPT DEBUG] Episode: {episode_id} | Phase: {phase} | Agent: {agent_name}")
        print(f"{'='*60}")
        
        # Show transcript state
        print(f"Transcript entries: {len(self.transcript)}")
        
        # Show last 5 messages from transcript
        if self.transcript:
            print(f"\nLast 5 transcript entries (role + first 120 chars):")
            for i, (speaker, text) in enumerate(self.transcript[-5:], 1):
                preview = text[:120].replace('\n', ' ')
                if len(text) > 120:
                    preview += "..."
                print(f"  {i}. [{speaker}]: {preview}")
        
        # Show recent_conversation if provided
        if recent_conv is not None:
            print(f"\nrecent_conversation length: {len(recent_conv)} chars")
            if recent_conv:
                print(f"recent_conversation last 400 chars:")
                print(f"  ...{recent_conv[-400:]}")
            else:
                print("  [EMPTY - THIS IS A BUG!]")
        
        # Show the actual prompt payload
        if isinstance(messages_or_prompt, list):
            # Chat format (list of message dicts)
            print(f"\nMessages list length: {len(messages_or_prompt)}")
            for i, msg in enumerate(messages_or_prompt):
                role = msg.get('role', '?')
                content = msg.get('content', '')
                print(f"\n  Message {i+1} [{role}] - {len(content)} chars:")
                # Show last 800 chars of each message
                if len(content) > 800:
                    print(f"    ...{content[-800:]}")
                else:
                    print(f"    {content}")
        else:
            # String prompt
            prompt_str = str(messages_or_prompt)
            print(f"\nPrompt string length: {len(prompt_str)} chars")
            print(f"Last 800 chars of rendered prompt:")
            if len(prompt_str) > 800:
                print(f"  ...{prompt_str[-800:]}")
            else:
                print(f"  {prompt_str}")
        
        print(f"{'='*60}\n")
    
    def _format_prompt_vars(self) -> dict:
        """Get common prompt template variables."""
        # Format assessment for prompt injection
        assessment_text = self._format_assessment_for_prompt()
        age_band = self.assessment.get("age_band", 0)
        basil_age_description = get_age_band_natural_description(age_band)
        
        # Get used lessons for the current training run
        used_lessons = load_used_lessons()
        
        # Build the optional teaching angle section (age_band >= 4 only)
        if self.teaching_angle:
            teaching_angle_section = (
                f"\n**Teaching Angle (bonus complexity):** \"{self.teaching_angle}\"\n"
                f"The teaching angle is an extra creative lens to push toward a less-obvious lesson. "
                f"Use it if it naturally fits the topic — but if the combination is forced, "
                f"just let it inspire a less-obvious direction. The goal is a FRESH lesson, not a forced one.\n"
            )
        else:
            teaching_angle_section = ""

        return {
            "session_transcript": self._get_full_session_transcript() or "(Session just started)",
            "subject_of_the_day": self.subject_of_the_day or "(Not yet selected)",
            "lesson_of_the_day": self.lesson_of_the_day or "(Not yet selected)",
            "topic": self.topic or "(general)",
            "teaching_angle": self.teaching_angle or "(general exploration)",
            "teaching_angle_section": teaching_angle_section,
            "recent_subjects": format_blacklist_for_prompt(self.blacklists["recent_subjects"]),
            "used_lessons": format_blacklist_for_prompt(used_lessons, max_items=999),
            # Assessment variables
            "basil_assessment": assessment_text,
            "basil_age_description": basil_age_description,
        }
    
    def _format_assessment_for_prompt(self) -> str:
        """Format Basil assessment as readable text for prompt injection."""
        # Only pass age_band_description - it's human-readable and self-explanatory
        age_band_desc = self.assessment.get('age_band_description', 'unknown')
        return f"Age Band: {age_band_desc}"
    
    def _generate_tutor_kickoff(self) -> str:
        """Generate Tutor's session kickoff: greet, announce subject, ask Sophie for lesson."""
        vars = self._format_prompt_vars()
        
        try:
            prompt = self.tutor_kickoff_template.format(**vars)
        except KeyError as e:
            print(f"[Session] Warning: Missing prompt variable {e}")
            prompt = f"Recent conversation:\n{vars['session_transcript']}\n\nContinue as Tutor."
        
        system_msg = f"You are Tutor. This is the FIRST turn. You MUST include 'SUBJECT_OF_THE_DAY: {self.subject_of_the_day}' and ask Sophie to choose a lesson."
        
        try:
            response = client.chat.completions.create(
                model=TUTOR_MODEL,
                messages=[
                    {"role": "system", "content": system_msg},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.7,
                max_tokens=200,
            )
            result = response.choices[0].message.content.strip()
            # Fix "Tutor: Tutor:" double prefix
            if result.startswith("Tutor:"):
                result = result[6:].strip()
            return result
        except Exception as e:
            print(f"[Session] Tutor kickoff error: {e}")
            return f"SUBJECT_OF_THE_DAY: {self.subject_of_the_day}\n\nHello everyone! Today we're going to learn about {self.subject_of_the_day}. Sophie, what specific lesson should we explore today?"
    
    def _generate_sophie_lesson_select(self, rejected_lessons: list = None, temperature: float = 0.7) -> str:
        """Generate Sophie's lesson selection response during session prelude.
        
        Args:
            rejected_lessons: List of previously rejected lesson names within the
                              current topic, used as feedback so the LLM avoids similar picks.
            temperature: LLM temperature for this call (ramps on retries).
        """
        if not self.include_sophie:
            return ""
        
        vars = self._format_prompt_vars()
        recent_conv = vars.get('session_transcript', '')
        self._debug_session_state("Sophie-LessonSelect", recent_conv)
        
        # Use the dedicated lesson selection prompt
        try:
            if self.sophie_lesson_select_template:
                prompt = self.sophie_lesson_select_template.format(**vars)
            else:
                # Fallback if template missing
                prompt = f"Subject: {self.subject_of_the_day}\n\nPick a lesson and respond as Sophie."
        except KeyError as e:
            print(f"[Session] Warning: Missing prompt variable {e}")
            prompt = f"Subject: {self.subject_of_the_day}\n\nPick a lesson and respond as Sophie."
        
        if rejected_lessons:
            prompt += (
                f"\n\nIMPORTANT: These lessons from {self.topic} were already used or "
                f"too similar: {', '.join(rejected_lessons)}. "
                f"Pick a DIFFERENT lesson from {self.topic} that is clearly distinct."
            )
        
        system_msg = f"You are Sophie picking today's lesson. Subject is {self.subject_of_the_day}. You MUST include 'LESSON_OF_THE_DAY: <lesson title>' in your response. Keep under 80 words."
        
        try:
            response = client.chat.completions.create(
                model=SOPHIE_MODEL,
                messages=[
                    {"role": "system", "content": system_msg},
                    {"role": "user", "content": prompt}
                ],
                temperature=temperature,
                max_tokens=100,
            )
            return response.choices[0].message.content.strip()
        except Exception as e:
            print(f"[Session] Sophie lesson selection error: {e}")
            return f"LESSON_OF_THE_DAY: Introduction to {self.subject_of_the_day}\n\nLet's start with the basics today!"
    
    def _generate_basil_turn(self, prompt_suffix: str = "Basil:") -> str:
        """Generate Basil's response using model.generate() directly."""
        # Build context from current episode only (Basil doesn't need full session history)
        context = self._get_episode_transcript()
        full_prompt = f"{context}\n{prompt_suffix}" if context else prompt_suffix
        
        # Truncate to fit within GPT-2's 1024 token limit
        # Reserve tokens for generation (basil_max_tokens) plus safety margin
        max_context_tokens = 1024 - self.basil_max_tokens - 20  # ~970 tokens for context
        
        # Tokenize with attention mask
        inputs = self.tokenizer(
            full_prompt,
            return_tensors="pt",
            truncation=True,
            max_length=max_context_tokens,
            padding=False,
        )
        
        input_ids = inputs["input_ids"].to(self.device)
        attention_mask = inputs["attention_mask"].to(self.device)
        
        if input_ids.shape[1] >= max_context_tokens:
            print(f"[Session] Context truncated to {input_ids.shape[1]} tokens")
        
        try:
            # Sampling for all age bands — temperature scales from 1.4 (band 0,
            # encourages discovery via randomness) down to 1.0 (band 7, more
            # precise).  No repetition_penalty: repetition is penalized through
            # the training signal (grading), not at inference time.
            with torch.no_grad():
                output_ids = self.model.generate(
                    input_ids=input_ids,
                    attention_mask=attention_mask,
                    max_new_tokens=self.basil_max_tokens,
                    do_sample=True,
                    temperature=self.basil_temperature,
                    top_k=50,
                    pad_token_id=self.tokenizer.eos_token_id,
                    eos_token_id=self.tokenizer.eos_token_id,
                )
            
            # Decode full output
            full_output = self.tokenizer.decode(output_ids[0], skip_special_tokens=True)
            
            # Extract just Basil's response (after the prompt)
            if "Basil:" in full_output:
                response = full_output.split("Basil:")[-1].strip()
            else:
                # Get only the newly generated tokens
                prompt_len = len(self.tokenizer.decode(input_ids[0], skip_special_tokens=True))
                response = full_output[prompt_len:].strip()
            
            # Truncate at newline (stop at first turn boundary)
            if "\n" in response:
                response = response.split("\n")[0].strip()

            return response
        except Exception as e:
            print(f"[Session] Basil generation error: {e}")
            return ""
    
    def _should_stop_early(self) -> tuple:
        """
        Check if session should stop based on hybrid stop policy.
        
        Returns:
            (should_stop: bool, reason: str)
        """
        # Hard max: always stop at MAX_GRADED_TURNS_PER_SESSION
        if self.graded_turn_count >= MAX_GRADED_TURNS_PER_SESSION:
            return True, "max_graded_turns"
        
        # Don't stop before minimum unless hard failure
        if self.graded_turn_count < MIN_GRADED_TURNS_PER_SESSION:
            return False, ""
        
        # Early stop: check rolling window for low signal
        if len(self.recent_scores) >= EARLY_STOP_WINDOW_TURNS:
            window_scores = self.recent_scores[-EARLY_STOP_WINDOW_TURNS:]
            avg_score = sum(window_scores) / len(window_scores)
            
            # Compute compliance over the window
            compliant_count = sum(1 for s in window_scores if s >= COMPLIANCE_SCORE_THRESHOLD)
            compliance_rate = compliant_count / len(window_scores)
            
            # Early stop if BOTH score and compliance are below thresholds
            if avg_score < EARLY_STOP_MIN_AVG_SCORE and compliance_rate < EARLY_STOP_MAX_COMPLIANCE:
                if self.verbose:
                    print(f"[Session] Early stop: avg_score={avg_score:.2f} < {EARLY_STOP_MIN_AVG_SCORE}, "
                          f"compliance={compliance_rate:.1%} < {EARLY_STOP_MAX_COMPLIANCE:.0%}")
                return True, "early_stop_low_signal"
        
        # Legacy: also check old SCORE_FLOOR logic
        if len(self.recent_scores) >= SCORE_FLOOR_WINDOW:
            recent_avg = sum(self.recent_scores[-SCORE_FLOOR_WINDOW:]) / SCORE_FLOOR_WINDOW
            if recent_avg < SCORE_FLOOR:
                if self.verbose:
                    print(f"[Session] Stopping: rolling avg {recent_avg:.2f} < {SCORE_FLOOR}")
                return True, "score_floor"
        
        return False, ""
    
    def _generate_wrapup_tutor(self) -> str:
        """Generate Tutor's wrap-up recap line (no graded task)."""
        avg_score = 0
        if self.graded_turns:
            avg_score = sum(t["grade"]["score"] for t in self.graded_turns) / len(self.graded_turns)
        
        # Fallback messages calibrated to performance
        if avg_score >= 5.0:
            fallback = f"Nice work today on {self.lesson_of_the_day}, Basil! You're getting the hang of it."
        elif avg_score >= 3.0:
            fallback = f"Good try today, Basil! Learning {self.lesson_of_the_day} takes practice."
        else:
            fallback = f"Thanks for trying today, Basil. We'll practice {self.lesson_of_the_day} more next time."
        
        early_stop_note = ""
        if self.early_stopped:
            early_stop_note = "Note: The session ended early. Close gently with 'We'll stop here for today and try again soon.'"
        
        session_transcript = self._get_full_session_transcript()
        
        # Use prompt template
        wrapup_prompt = None
        if self.tutor_wrapup_template:
            try:
                wrapup_prompt = self.tutor_wrapup_template.format(
                    subject=self.subject_of_the_day or "(unknown)",
                    lesson=self.lesson_of_the_day or "(unknown)",
                    graded_turns=self.graded_turn_count,
                    avg_score=f"{avg_score:.1f}",
                    early_stop_note=early_stop_note,
                    session_transcript=session_transcript,
                    basil_age_description=get_age_band_natural_description(self.age_band_start),
                    length_guidance=get_length_guidance("tutor_wrapup", self.age_band_start),
                )
            except KeyError as e:
                print(f"[Session] Warning: Missing wrapup prompt variable {e}")
                wrapup_prompt = None
        
        # Fallback inline prompt
        if not wrapup_prompt:
            length_hint = get_length_guidance("tutor_wrapup", self.age_band_start)
            wrapup_prompt = f"""This session on "{self.lesson_of_the_day}" is ending.
Subject: {self.subject_of_the_day}
Graded turns: {self.graded_turn_count}
Average score: {avg_score:.1f}/7
{early_stop_note}

{length_hint} Your recap should:
1. Thank Basil for being here
2. Be HONEST about how it went (no false praise if score is low)
3. End warmly

DO NOT ask any questions or give any tasks. Just an honest, warm closing."""
        
        system_msg = "You are Tutor giving a session recap. Be honest but kind. Match your praise to actual performance. NO questions. End with a statement."
        
        try:
            response = client.chat.completions.create(
                model=TUTOR_MODEL,
                messages=[
                    {"role": "system", "content": system_msg},
                    {"role": "user", "content": wrapup_prompt}
                ],
                temperature=0.7,
                max_tokens=get_max_tokens_ceiling("tutor_wrapup"),
            )
            result = response.choices[0].message.content.strip()
            result = self._strip_trailing_questions(result)
            return result
        except Exception as e:
            print(f"[Session] Tutor wrapup error: {e}")
            return fallback
    
    def _generate_wrapup_sophie(self) -> str:
        """Generate Sophie's wrap-up closing line (no graded task)."""
        if not self.include_sophie:
            return ""
        
        # Simple fallbacks based on session state
        if self.early_stopped:
            fallback = "Bye Basil! We'll play again soon!"
        else:
            fallback = "Bye Basil! See you next time!"
        
        early_stop_note = ""
        if self.early_stopped:
            early_stop_note = "Note: The session ended early. Keep your goodbye simple and brief."
        
        session_transcript = self._get_full_session_transcript()
        
        # Use prompt template
        wrapup_prompt = None
        if self.sophie_wrapup_template:
            try:
                wrapup_prompt = self.sophie_wrapup_template.format(
                    lesson=self.lesson_of_the_day or "(unknown)",
                    early_stop_note=early_stop_note,
                    session_transcript=session_transcript,
                    length_guidance=get_length_guidance("sophie_wrapup", self.age_band_start),
                )
            except KeyError as e:
                print(f"[Session] Warning: Missing Sophie wrapup prompt variable {e}")
                wrapup_prompt = None
        
        # Fallback inline prompt
        if not wrapup_prompt:
            length_hint = get_length_guidance("sophie_wrapup", self.age_band_start)
            wrapup_prompt = f"""The session on "{self.lesson_of_the_day}" is ending.
{early_stop_note}
{length_hint} Say goodbye warmly from Sophie:
1. Says goodbye warmly
2. Maybe mentions next time
DO NOT ask questions. Just a warm, simple goodbye."""
        
        length_hint_sys = get_length_guidance("sophie_wrapup", self.age_band_start)
        system_msg = f"You are Sophie saying goodbye. {length_hint_sys} NO questions. End with a statement."
        
        try:
            response = client.chat.completions.create(
                model=SOPHIE_MODEL,
                messages=[
                    {"role": "system", "content": system_msg},
                    {"role": "user", "content": wrapup_prompt}
                ],
                temperature=0.7,
                max_tokens=get_max_tokens_ceiling("sophie_wrapup"),
            )
            result = response.choices[0].message.content.strip()
            result = self._strip_trailing_questions(result)
            return result
        except Exception as e:
            print(f"[Session] Sophie wrapup error: {e}")
            return fallback
    
    def run_wrapup(self):
        """
        Run graceful session wrap-up.
        
        Generates closing lines from Tutor and Sophie (not graded).
        """
        if not ENABLE_GRACEFUL_WRAPUP:
            return
        
        if self.verbose:
            print("\n--- Session Wrap-up ---")
        
        # Tutor recap
        tutor_line = self._generate_wrapup_tutor()
        self.transcript.append(("Tutor", f"[WRAPUP] {tutor_line}"))
        if self.verbose:
            print(f"Tutor: {tutor_line}")
        
        # Sophie closing (if enabled and WRAPUP_TURNS >= 2)
        if self.include_sophie and WRAPUP_TURNS >= 2:
            sophie_line = self._generate_wrapup_sophie()
            if sophie_line:
                self.transcript.append(("Sophie", f"[WRAPUP] {sophie_line}"))
                if self.verbose:
                    print(f"Sophie: {sophie_line}")
        
        if self.verbose:
            print("--- Wrap-up Complete ---\n")
    
    def run_identity_probe(self) -> dict:
        """
        Run the end-of-session "Who are you?" identity probe.
        
        IMPORTANT:
        - This response is logged for ANALYSIS ONLY
        - It is NOT graded or used for training
        - It is NOT injected into future session prompts
        
        Returns:
            dict with question, answer, timestamp, age_band
        """
        if self.verbose:
            print("\n--- Identity Probe ---")
        
        probe_question = "Who are you?"
        
        # Add probe to transcript temporarily for context
        self.transcript.append(("Tutor", f"[IDENTITY_PROBE] {probe_question}"))
        if self.verbose:
            print(f"Tutor: {probe_question}")
        
        # Generate Basil's response (no system prompt, just conversation context)
        basil_response = self._generate_basil_turn(prompt_suffix="Basil:")
        
        # Log as identity probe
        self.transcript.append(("Basil", f"[IDENTITY_PROBE] {basil_response}"))
        if self.verbose:
            print(f"Basil: {basil_response}")
        
        # Get current age_band (after any updates during session)
        current_assessment = get_assessment_for_prompt()
        age_band_end = current_assessment.get("age_band", self.age_band_start)
        
        identity_probe_result = {
            "type": "identity_probe",
            "question": probe_question,
            "answer": basil_response,
            "timestamp": datetime.now().isoformat(),
            "age_band": age_band_end,
            "session_id": self.session_id,
        }
        
        if self.verbose:
            print(f"[Identity logged for analysis only]")
            print("--- Identity Probe Complete ---\n")
        
        return identity_probe_result
    
    def run_prelude(self):
        """
        Run the session prelude: generate subjects, pick one, announce it, have Sophie pick lesson.
        
        This establishes the topic for the session before regular turns begin.
        """
        if self.verbose:
            print(f"\n--- Session Prelude ---")
        
        # 1. Pick subject (if not overridden)
        if self.subject_of_the_day is None:
            self.subject_of_the_day = self._select_subject()
        
        # Record the chosen subject in rotation state
        record_subject(self.subject_of_the_day)
        
        if self.verbose:
            print(f"[Curriculum] Subject: {self.subject_of_the_day}")
        
        # 2. Tutor announces subject and asks Sophie for lesson
        tutor_line = self._generate_tutor_kickoff()
        
        # Ensure subject marker is present
        if f"SUBJECT_OF_THE_DAY:" not in tutor_line:
            tutor_line = f"SUBJECT_OF_THE_DAY: {self.subject_of_the_day}\n\n{tutor_line}"
        
        self.transcript.append(("Tutor", tutor_line))
        if self.verbose:
            print(f"Tutor: {tutor_line}")
        
        # 3. Sophie picks a lesson (nested hierarchy with dedup retry)
        #   Outer loop: spin a new topic + angle (max 3)
        #   Inner loop: retry within same topic (max 5) with rejection feedback
        #   This mines each topic deeper before burning it, maximizing variety.
        if self.include_sophie:
            max_topic_retries = 3
            max_lesson_retries_per_topic = 5
            used_topics_this_session = []
            used_angles_this_session = []
            age_band = self.assessment.get("age_band", 0)
            accepted = False
            
            for topic_attempt in range(max_topic_retries):
                topic = pick_topic(
                    self.subject_of_the_day,
                    basil_assessment=self.assessment,
                    used_topics_this_session=used_topics_this_session,
                )
                used_topics_this_session.append(topic)
                self.topic = topic
                rejected_in_topic = []
                
                if self.verbose:
                    print(f"[Curriculum] Topic: {topic} (topic {topic_attempt+1}/{max_topic_retries})")
                
                if age_band >= 4:
                    angle = pick_angle(self.assessment, used_angles_this_session=used_angles_this_session)
                    used_angles_this_session.append(angle)
                    self.teaching_angle = angle
                    if self.verbose:
                        print(f"[Curriculum] Teaching angle: {angle}")
                else:
                    self.teaching_angle = None
                
                for lesson_attempt in range(max_lesson_retries_per_topic):
                    used_lessons = load_used_lessons()
                    sophie_line = self._generate_sophie_lesson_select(
                        rejected_lessons=rejected_in_topic if rejected_in_topic else None,
                        temperature=0.7 + (lesson_attempt * 0.1),
                    )
                    
                    if topic_attempt == 0 and lesson_attempt == 0:
                        self.transcript.append(("Sophie", sophie_line))
                    else:
                        self.transcript[-1] = ("Sophie", sophie_line)
                    
                    if self.verbose:
                        print(f"Sophie: {sophie_line}")
                    
                    lesson = parse_lesson_from_response(sophie_line)
                    
                    if lesson:
                        self.lesson_of_the_day = lesson
                    else:
                        self.lesson_of_the_day = f"{self.subject_of_the_day} — General"
                        if self.verbose:
                            print(f"[Curriculum] Warning: Could not parse lesson, using fallback")
                        accepted = True
                        break
                    
                    # Layer 1: Fast fuzzy word-overlap check (no API call)
                    is_fuzzy, fuzzy_matched = dedup_fuzzy_match(
                        self.lesson_of_the_day, used_lessons,
                    )
                    if is_fuzzy:
                        rejected_in_topic.append(self.lesson_of_the_day)
                        if self.verbose:
                            print(f"[Curriculum] Lesson '{self.lesson_of_the_day}' fuzzy-matches '{fuzzy_matched}', retrying within {topic} ({lesson_attempt+1}/{max_lesson_retries_per_topic})")
                        continue
                    
                    # Layer 2: LLM semantic overlap check (only if fuzzy didn't flag)
                    if not check_lesson_overlap(self.lesson_of_the_day, used_lessons):
                        accepted = True
                        break
                    
                    rejected_in_topic.append(self.lesson_of_the_day)
                    if self.verbose:
                        print(f"[Curriculum] Lesson '{self.lesson_of_the_day}' semantic overlap, retrying within {topic} ({lesson_attempt+1}/{max_lesson_retries_per_topic})")
                
                if accepted:
                    break
                if self.verbose:
                    if topic_attempt < max_topic_retries - 1:
                        print(f"[Curriculum] Topic '{topic}' exhausted after {max_lesson_retries_per_topic} retries, spinning new topic...")
                    else:
                        print(f"[Curriculum] All topic retries exhausted, accepting last pick")
            
            # Record accepted lesson in rotation state (for historical tracking)
            record_lesson(self.subject_of_the_day, self.lesson_of_the_day)
            
            # Add to used lessons for this training run
            add_used_lesson(self.lesson_of_the_day)
            
            if self.verbose:
                print(f"[Curriculum] Lesson: {self.lesson_of_the_day}")
        else:
            # No Sophie, use generic lesson
            self.lesson_of_the_day = f"{self.subject_of_the_day} — General"
        
        # 6. Tutor gives a brief primer (2-4 sentences) and sets expectations
        primer_line = self._generate_tutor_primer()
        self.transcript.append(("Tutor", primer_line))
        if self.verbose:
            print(f"Tutor (Primer): {primer_line}")
        
        if self.verbose:
            print(f"--- Prelude Complete ---\n")
    
    def _select_subject(self) -> str:
        """
        Select today's subject using dynamic generation.
        
        1. Load basil assessment
        2. Get recent subjects from blacklist
        3. Call subject generator to get candidates
        4. Randomly select one
        """
        import random
        
        # Get full assessment (not just prompt version)
        assessment = load_basil_assessment()
        
        # Get recent subjects (for prompt injection into generator)
        recent_subjects = self.blacklists.get("recent_subjects", [])
        
        if self.verbose:
            print(f"[Subject Generator] Generating candidates for age_band={assessment.get('age_band', 0)}...")
        
        # Generate candidates (generator handles its own blacklist filtering)
        candidates = generate_subject_candidates(
            basil_assessment=assessment,
            recent_subjects=recent_subjects,
            n_min=15,
            n_max=40,
        )
        
        if not candidates:
            # Fallback
            if self.verbose:
                print("[Subject Generator] No candidates generated, using fallback")
            return "Language Arts"
        
        # Randomly select from candidates
        chosen = random.choice(candidates)
        if self.verbose:
            print(f"[Subject Generator] Selected '{chosen}' from {len(candidates)} candidates")
        return chosen
    
    def run_episode(self) -> dict:
        """
        Run a single episode of the session using the correct phase order.
        
        Episode Flow:
        A) TaskAgent produces TaskSpec (source of truth)
        B) Tutor outputs: teaching snippet + instruction_text from TaskSpec
        C) Basil generates attempt
        D) Grader runs silently against TaskSpec
        E) Sophie responds AFTER grade, truthfully referencing Basil attempt
        F) Tutor answers Sophie's question
        
        Transcript order: Tutor(B) → Basil(C) → [Grade silent] → Sophie(E) → Tutor(F)
        """
        import random
        
        self.turn_number += 1
        episode_id = f"{self.session_id}_ep{self.turn_number}"
        
        # Decide popquiz placement: 50/50 before or after Basil's turn
        popquiz_after_basil = random.random() < 0.5
        
        # Mark the start of this episode in the transcript for scoping
        self.episode_transcript_start = len(self.transcript)
        
        if self.verbose:
            print(f"\n--- Episode {self.turn_number} ---")
        
        episode_data = {
            "episode_id": episode_id,
            "turn": self.turn_number,
            "subject": self.subject_of_the_day,
            "lesson": self.lesson_of_the_day,
            "messages": [],  # Full message list for JSONL
            "graded": True,  # All episodes are graded in new model
            "popquiz_after_basil": popquiz_after_basil,
        }
        
        # ========================================
        # PHASE B.1: Generate and append teaching paragraph
        # ========================================
        if self.verbose:
            print("[PHASE B.1] Tutor generating teaching paragraph...")
        
        # CANARY TOKEN TEST: Insert unique marker for episode 2 to verify buffer is passed
        if self.turn_number == 2 and DEBUG_SESSION:
            canary = f"[CANARY_EPISODE_{self.turn_number}]"
            self.transcript.append(("DEBUG", canary))
            print(f"\n[CANARY] Inserted '{canary}' into transcript. Should appear in Tutor prompt.\n")
        
        # Generate teaching paragraph
        tutor_teaching = self._generate_tutor_teaching_only(None, episode_id=episode_id)
        
        # Store teaching for task selector to use
        self._current_teaching_snippet = tutor_teaching
        
        if self.verbose:
            if LOG_TEACHING_PREVIEW_CHARS:
                preview = tutor_teaching[:LOG_TEACHING_PREVIEW_CHARS] + "..."
            else:
                preview = tutor_teaching
            print(f"Tutor teaching: {preview}")
        
        # Append teaching to transcript immediately
        self.transcript.append(("Tutor", tutor_teaching))
        episode_data["tutor_teaching"] = tutor_teaching
        episode_data["messages"].append({"role": "Tutor", "content": tutor_teaching, "phase": "B-teaching"})
        
        # ========================================
        # PHASE B.2: Sophie reacts to teaching
        # ========================================
        if self.include_sophie:
            if self.verbose:
                print("[PHASE B.2] Sophie reacting to teaching...")
            
            sophie_reaction = self._generate_sophie_reaction_to_teaching(
                teaching_text=tutor_teaching,
                episode_id=episode_id,
            )
            self.transcript.append(("Sophie", sophie_reaction))
            self._track_teaching_fact(sophie_reaction)  # Track Sophie's facts for anti-repetition
            episode_data["sophie_reaction"] = sophie_reaction
            episode_data["messages"].append({"role": "Sophie", "content": sophie_reaction, "phase": "B-reaction"})
            
            if self.verbose:
                print(f"Sophie: {sophie_reaction}")
        
        # ========================================
        # PHASE B.2b: Popquiz — Tutor quizzes Sophie (modeling for Basil)
        # Placed before Basil ~50% of the time; after Basil the other ~50%.
        # ========================================
        if POPQUIZ_ENABLED and self.include_sophie and not popquiz_after_basil:
            if self.verbose:
                print("[PHASE B.2b] Popquiz (before Basil): Tutor quizzing Sophie...")
            
            quiz_question, quiz_answer, quiz_reaction = self._generate_sophie_quiz(
                teaching_text=tutor_teaching,
                topic=self.lesson_of_the_day or self.subject_of_the_day or "",
                episode_id=episode_id,
            )
            if quiz_question and quiz_answer:
                self.transcript.append(("Tutor", quiz_question))
                self.transcript.append(("Sophie", quiz_answer))
                episode_data["messages"].append({"role": "Tutor", "content": quiz_question, "phase": "B-quiz"})
                episode_data["messages"].append({"role": "Sophie", "content": quiz_answer, "phase": "B-quiz-answer"})
                
                if quiz_reaction:
                    self.transcript.append(("Tutor", quiz_reaction))
                    episode_data["messages"].append({"role": "Tutor", "content": quiz_reaction, "phase": "B-quiz-reaction"})
                
                if self.verbose:
                    print(f"Tutor (quiz): {quiz_question}")
                    print(f"Sophie (answer): {quiz_answer}")
                    if quiz_reaction:
                        print(f"Tutor (reaction): {quiz_reaction}")
            else:
                if self.verbose:
                    print("[PHASE B.2b] Popquiz skipped (generation failed)")
        
        # ========================================
        # PHASE B.3: TaskAgent generates TaskSpec (now sees teaching + Sophie reaction in transcript)
        # ========================================
        if self.verbose:
            print("[PHASE B.3] TaskAgent generating TaskSpec...")
        self._debug_session_state("PHASE B.3: TaskAgent", self._get_recent_conversation())
        
        task_spec = self._generate_task_spec(teaching_snippet=tutor_teaching)
        episode_data["task_spec"] = task_spec
        
        if self.verbose:
            print(f"  TaskSpec: [{task_spec['task_category']}] {task_spec['task_text']}")
        
        # ========================================
        # PHASE B.4: Task delivery
        # ========================================
        if self.verbose:
            print("[PHASE B.4] Task delivery...")
        task_entries = self._deliver_task(task_spec, episode_id=episode_id)
        for entry in task_entries:
            self.transcript.append((entry["speaker"], entry["text"]))
            episode_data["messages"].append({
                "role": entry["speaker"], 
                "content": entry["text"], 
                "phase": entry["phase"]
            })
            if self.verbose:
                print(f"{entry['speaker']}: {entry['text']}")
        
        episode_data["task_asker"] = task_spec.get("asker", "tutor")
        
        # ========================================
        # PHASE C: Basil generates attempt
        # ========================================
        if self.verbose:
            print("[PHASE C] Basil responding...")
        
        basil_line = self._generate_basil_turn("Basil:")
        self.transcript.append(("Basil", basil_line))
        episode_data["basil"] = basil_line
        episode_data["messages"].append({"role": "Basil", "content": basil_line, "phase": "C"})
        
        # Track Basil token count
        basil_tokens = len(self.tokenizer.encode(basil_line)) if basil_line else 0
        self.total_basil_tokens += basil_tokens
        episode_data["basil_tokens"] = basil_tokens
        
        if self.verbose:
            print(f"Basil: {basil_line}")
        
        # ========================================
        # PHASE D: Grader runs silently against TaskSpec
        # ========================================
        if self.verbose:
            print("[PHASE D] Grader evaluating...")
        
        # Use LLM grader for all age bands (unified grading pathway)
        grade = self._grade_with_llm_safe(task_spec, basil_line)
        
        # Programmatic floors: Englishness (0-2) + target-word presence (6).
        # Final score = max(grader_score, programmatic_floor).
        session_text = self._get_session_text_before_basil()
        targets = task_spec.get("targets", [])
        grade = apply_score_floor(
            grade, basil_line, session_text,
            targets=targets, verbose=self.verbose
        )
        
        episode_data["grade"] = grade
        episode_data["weight"] = score_to_weight(grade["score"])
        episode_data["task_category"] = task_spec["task_category"]
        episode_data["age_band"] = self.assessment.get("age_band", 0)
        
        # Update session tracking
        self.graded_turns.append(episode_data)
        self.recent_scores.append(grade["score"])
        self.graded_turn_count += 1
        update_metrics_after_turn(grade["score"], task_spec["task_category"])
        
        if self.verbose:
            print(f"  [Grade: {grade['score']}/7] {grade.get('justification', '')[:80]}")
        
        # ========================================
        # PHASE E: Sophie responds AFTER grade, truthfully
        # ========================================
        if self.include_sophie:
            if self.verbose:
                print("[PHASE E] Sophie responding (post-grade)...")
            
            sophie_line = self._generate_sophie_post_grade(
                basil_attempt=basil_line,
                grade=grade,
                task_spec=task_spec,
                episode_id=episode_id,
            )
            self.transcript.append(("Sophie", sophie_line))
            episode_data["sophie"] = sophie_line
            episode_data["messages"].append({"role": "Sophie", "content": sophie_line, "phase": "E"})
            
            if self.verbose:
                print(f"Sophie: {sophie_line}")
        
        # ========================================
        # PHASE E.5: Popquiz AFTER Basil (when popquiz_after_basil=True)
        # Sophie's post-grade reaction is a separate line, so masking
        # cleanly ends at Zone B before this popquiz starts.
        # ========================================
        if POPQUIZ_ENABLED and self.include_sophie and popquiz_after_basil:
            if self.verbose:
                print("[PHASE E.5] Popquiz (after Basil): Tutor quizzing Sophie...")
            
            quiz_question, quiz_answer, quiz_reaction = self._generate_sophie_quiz(
                teaching_text=tutor_teaching,
                topic=self.lesson_of_the_day or self.subject_of_the_day or "",
                episode_id=episode_id,
            )
            if quiz_question and quiz_answer:
                self.transcript.append(("Tutor", quiz_question))
                self.transcript.append(("Sophie", quiz_answer))
                episode_data["messages"].append({"role": "Tutor", "content": quiz_question, "phase": "E5-quiz"})
                episode_data["messages"].append({"role": "Sophie", "content": quiz_answer, "phase": "E5-quiz-answer"})
                
                if quiz_reaction:
                    self.transcript.append(("Tutor", quiz_reaction))
                    episode_data["messages"].append({"role": "Tutor", "content": quiz_reaction, "phase": "E5-quiz-reaction"})
                
                if self.verbose:
                    print(f"Tutor (quiz): {quiz_question}")
                    print(f"Sophie (answer): {quiz_answer}")
                    if quiz_reaction:
                        print(f"Tutor (reaction): {quiz_reaction}")
            else:
                if self.verbose:
                    print("[PHASE E.5] Popquiz skipped (generation failed)")
        
        # ========================================
        # PHASE F: Tutor answers Sophie's question
        # ========================================
        if self.include_sophie:
            if self.verbose:
                print("[PHASE F] Tutor answering Sophie...")
            
            tutor_answer = self._generate_tutor_answer_sophie(
                sophie_question=sophie_line,
                grade=grade,
                episode_id=episode_id,
            )
            self.transcript.append(("Tutor", tutor_answer))
            self._track_teaching_fact(tutor_answer)  # Track Tutor's answer facts for anti-repetition
            episode_data["tutor_answer"] = tutor_answer
            episode_data["messages"].append({"role": "Tutor", "content": tutor_answer, "phase": "F"})
            
            if self.verbose:
                print(f"Tutor: {tutor_answer}")
        
        # Save episode to JSONL log
        self._save_episode_log(episode_data)
        
        return episode_data
    
    def _build_related_terms_from_context(self):
        """
        Build related_terms set from lesson context (Sophie's lesson selection, primer).
        
        This is a topic-agnostic approach: extracts meaningful words from
        the actual session transcript so far, rather than relying only on
        curated keyword maps.
        
        Caps at ~30 terms to avoid becoming too permissive.
        """
        self.related_terms = set()
        
        # Extract words from recent transcript entries (prelude context)
        stopwords = {"the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
                     "have", "has", "had", "do", "does", "did", "will", "would", "could",
                     "should", "may", "might", "can", "shall", "to", "of", "in", "for",
                     "on", "with", "at", "by", "from", "as", "or", "and", "but", "if",
                     "then", "so", "than", "too", "very", "just", "only", "also", "how",
                     "what", "when", "where", "which", "who", "why", "this", "that",
                     "these", "those", "i", "you", "he", "she", "it", "we", "they", "me",
                     "him", "her", "us", "them", "my", "your", "his", "its", "our",
                     "their", "all", "each", "every", "both", "few", "more", "most",
                     "other", "some", "such", "no", "not", "any", "about", "into",
                     "through", "during", "before", "after", "above", "below", "up",
                     "down", "out", "off", "over", "under", "again", "further",
                     "once", "here", "there", "really", "quite", "well", "even",
                     "basil", "sophie", "tutor", "today", "let", "lesson", "subject",
                     "learn", "practice", "try", "say", "said", "think", "know", "want"}
        
        # Look through transcript for lesson-relevant content
        for speaker, text in self.transcript[-10:]:  # Last 10 entries (prelude)
            # Skip system markers
            if text.startswith('['):
                continue
            
            # Extract words
            words = re.findall(r'\b[a-z]{3,12}\b', text.lower())
            
            for word in words:
                if word not in stopwords and len(word) >= 3:
                    self.related_terms.add(word)
        
        # Also extract from lesson/subject names with more permissive splitting
        for text in [self.subject_of_the_day, self.lesson_of_the_day]:
            if text:
                words = re.findall(r'\b[a-z]{3,12}\b', text.lower())
                for word in words:
                    if word not in stopwords:
                        self.related_terms.add(word)
        
        # Cap at 30 terms (prioritize by length - longer words are more specific)
        if len(self.related_terms) > 30:
            sorted_terms = sorted(self.related_terms, key=lambda x: -len(x))
            self.related_terms = set(sorted_terms[:30])
    
    def _is_task_on_topic(self, task_spec: dict) -> bool:
        """
        DEPRECATED: Heuristic topic validation removed. Use _validate_task_with_llm instead.
        
        This method now raises RuntimeError to prevent silent misuse.
        Set ALLOW_DEPRECATED_TOPIC_CHECK=true env var only for migration testing.
        """
        if ALLOW_DEPRECATED_TOPIC_CHECK:
            # Migration escape hatch - logs warning but returns True
            print("[WARNING] _is_task_on_topic() is deprecated. Use _validate_task_with_llm()")
            return True
        
        raise RuntimeError(
            "DEPRECATED: _is_task_on_topic() has been removed. "
            "Use _validate_task_with_llm() for LLM-based semantic validation. "
            "Set ALLOW_DEPRECATED_TOPIC_CHECK=true to temporarily bypass (not recommended)."
        )
    
    def _validate_task_with_llm(self, task_spec: dict, teaching_snippet: str = "") -> dict:
        """
        LLM-based task validation: Is this task a natural fit for the lesson?
        
        This replaces the rigid keyword-based validation with semantic understanding.
        The LLM sees the lesson context, teaching content, and proposed task, and
        determines if the task is on-topic.
        
        Args:
            task_spec: The proposed task specification
            teaching_snippet: The current episode's teaching paragraph (if available)
            
        Returns:
            dict with keys:
                - valid: bool
                - reason: str (brief explanation)
                - suggested_task: str or None (alternative if invalid)
        """
        task_text = task_spec.get("task_text", "")
        age_band = self.assessment.get("age_band", 0)
        
        # Load prompt template
        try:
            with open(PROMPT_TASK_VALIDATOR, 'r') as f:
                prompt_template = f.read()
        except FileNotFoundError:
            if self.verbose:
                print("[TaskValidator] Prompt file not found, defaulting to accept")
            return {"valid": True, "reason": "Validator unavailable", "suggested_task": None}
        
        # Get Sophie's lesson selection text (from transcript)
        sophie_lesson_text = ""
        for speaker, text in self.transcript:
            if speaker == "Sophie" and "LESSON_OF_THE_DAY" in text:
                sophie_lesson_text = text
                break
        
        # Format prompt
        prompt = prompt_template.format(
            subject_of_the_day=self.subject_of_the_day or "Unknown",
            lesson_of_the_day=self.lesson_of_the_day or "Unknown",
            age_band=age_band,
            sophie_lesson_text=sophie_lesson_text or "(Not available)",
            teaching_snippet=teaching_snippet or "(Not yet generated)",
            task_text=task_text,
        )
        
        try:
            response = client.chat.completions.create(
                model=TASK_AGENT_MODEL,  # gpt-4o-mini
                messages=[
                    {"role": "system", "content": "You are a task validator. Output valid JSON only."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.3,  # Low temperature for consistent validation
                max_tokens=200,
            )
            
            result_text = response.choices[0].message.content.strip()
            
            # Parse JSON (handle markdown code blocks)
            if result_text.startswith("```"):
                result_text = re.sub(r'^```(?:json)?\n?', '', result_text)
                result_text = re.sub(r'\n?```$', '', result_text)
            
            result = json.loads(result_text)
            
            # Normalize result
            valid = result.get("valid", True)
            reason = result.get("reason", "")
            suggested = result.get("suggested_task")
            
            if self.verbose:
                status = "VALID" if valid else "INVALID"
                print(f"  [TaskValidator] {status}: '{task_text[:40]}...' - {reason}")
                if suggested:
                    print(f"  [TaskValidator] Suggested: '{suggested}'")
            
            return {
                "valid": valid,
                "reason": reason,
                "suggested_task": suggested
            }
            
        except json.JSONDecodeError as e:
            if self.verbose:
                print(f"  [TaskValidator] JSON parse error: {e}")
            # Default to accepting the task if validator fails
            return {"valid": True, "reason": "Validator parse error", "suggested_task": None}
        except Exception as e:
            if self.verbose:
                print(f"  [TaskValidator] Error: {e}")
            return {"valid": True, "reason": f"Validator error: {e}", "suggested_task": None}
    
    # =========================================================================
    # DEPRECATED HEURISTIC FUNCTIONS
    # These are kept as minimal stubs for backward compatibility only.
    # Use task_spec["targets"] and task_spec["choices"] instead.
    # LLM-based validation via _validate_task_with_llm is now authoritative.
    # =========================================================================
    
    def _is_morphological_variant(self, word1: str, word2: str) -> bool:
        """DEPRECATED: Heuristic removed. Use task_spec['targets'] instead."""
        return word1.lower() == word2.lower()
    
    def _is_fuzzy_match(self, word1: str, word2: str, max_distance: int = 1) -> bool:
        """DEPRECATED: Heuristic removed. Use task_spec['targets'] instead."""
        return word1.lower() == word2.lower()
    
    def _extract_choice_options(self, task_text: str) -> list:
        """DEPRECATED: Use task_spec['choices'] instead."""
        return []
    
    def _generate_on_topic_fallback_task(self) -> dict:
        """
        Generate a safe on-topic fallback task when TaskAgent fails.
        
        Derives keywords from lesson/subject and rotates among task types:
        - Single word repetition (Say 'X')
        - Yes/no about lesson facts
        - A/B choice between two lesson words
        
        Ensures variety and age-band appropriateness.
        """
        import random
        
        age_band = self.assessment.get("age_band", 0)
        
        # Derive keywords from lesson and subject (simple extraction)
        keywords = set()
        for text in [self.lesson_of_the_day, self.subject_of_the_day]:
            if text:
                words = re.split(r'[\s\-_/]+', text.lower())
                for word in words:
                    word = re.sub(r'[^a-z]', '', word)
                    if len(word) >= 3 and word not in STOPWORDS:
                        keywords.add(word)
        
        # Get on-topic keywords (exclude universal words for main targets)
        usable_keywords = [k for k in keywords 
                          if k not in {"yes", "no", "hello", "hi", "bye"} and len(k) <= 8]
        
        # Get recently used words to avoid
        recent_task_words = set()
        for _, text in self.recent_tasks[-3:]:
            recent_task_words.update(re.findall(r'\b[a-z]+\b', text.lower()))
        
        # Filter to available (not recently used) keywords
        available_keywords = [k for k in usable_keywords if k not in recent_task_words]
        if not available_keywords:
            available_keywords = usable_keywords if usable_keywords else ["yes"]
        
        # Determine which task pattern to use (rotate for variety)
        pattern_idx = len(self.recent_tasks) % 3  # 0, 1, 2 rotation
        
        # Initialize targets and choices - will be set per pattern
        targets = []
        choices = []
        
        # For age_band 0-3: use ultra-simple control tasks that are unambiguous
        # Avoid "facty" yes/no questions like "Is 'black' part of Color Matching?"
        if age_band <= 3:
            # age_band=0 specific patterns: simple and grader-friendly
            if pattern_idx == 0:
                # Pattern 0: Single word vocab (most common)
                target_word = available_keywords[0]
                task_text = f"Basil, reply with exactly this one word: {target_word}"
                task_category = "vocab"
                targets = [target_word]
                choices = []
                grader_instructions = f"Award 7 points if '{target_word}' appears cleanly in output."
                rubric = {
                    "0": "Zero English words — every token is gibberish or non-English",
                    "1": "At least one real English word, but none related to the lesson topic",
                    "2": "Multiple different English words, but none related to the lesson topic",
                    "3": "English words from the lesson domain present, but does not attempt the task",
                    "4": "On-topic vocabulary directly related to the question, but target word absent",
                    "5": "Related concept-word from the lesson produced, attempts the task format",
                    "6": f"'{target_word}' present but mixed with noise or extra words",
                    "7": f"Said '{target_word}' cleanly"
                }
            elif pattern_idx == 1:
                # Pattern 1: Simple "Say yes" or "Say no" (unambiguous control)
                import random
                yes_or_no = random.choice(["yes", "no"])
                task_text = f"Say {yes_or_no}."
                task_category = "control"
                targets = [yes_or_no]
                choices = []
                grader_instructions = f"Award 7 points if '{yes_or_no}' appears cleanly in output."
                rubric = {
                    "0": "Zero English words — every token is gibberish or non-English",
                    "1": "At least one real English word, but none related to the lesson topic",
                    "2": "Multiple different English words, but none related to the lesson topic",
                    "3": "English words from the lesson domain present, but no yes/no attempt",
                    "4": "On-topic vocabulary directly related to the question, but no yes/no attempt",
                    "5": f"Attempts yes/no format (e.g. 'yeah', 'nah') but '{yes_or_no}' not clearly present",
                    "6": f"'{yes_or_no}' present but mixed with noise or extra words",
                    "7": f"Said '{yes_or_no}' cleanly"
                }
            else:
                # Pattern 2: "Choose one: yes or no" (either answer is correct)
                task_text = "Choose one: yes or no."
                task_category = "control"
                targets = ["yes", "no"]
                choices = ["yes", "no"]
                grader_instructions = "Award 7 points if 'yes' OR 'no' appears cleanly as a STANDALONE answer. If BOTH 'yes' AND 'no' appear (e.g., 'Yes or no?'), that is echoing the question — cap at score 5."
                rubric = {
                    "0": "Zero English words — every token is gibberish or non-English",
                    "1": "At least one real English word, but none related to the lesson topic",
                    "2": "Multiple different English words, but none related to the lesson topic",
                    "3": "English words from the lesson domain present, but no yes/no attempt",
                    "4": "On-topic vocabulary directly related to the question, but no yes/no attempt",
                    "5": "Attempts yes/no format (e.g. 'yeah', 'nah') but neither 'yes' nor 'no' clearly present",
                    "6": "'yes' or 'no' present but mixed with noise or extra words",
                    "7": "Said 'yes' or 'no' cleanly"
                }
        else:
            # age_band >= 1: original patterns with more variety
            if pattern_idx == 0 or len(available_keywords) < 2:
                # Pattern 1: Single word repetition
                target_word = available_keywords[0]
                task_text = f"Can you say '{target_word}'?"
                task_category = "vocab"
                targets = [target_word]
                choices = []
                grader_instructions = f"Award 7 points if '{target_word}' appears cleanly in output."
                rubric = {
                    "0": "Zero English words — every token is gibberish or non-English",
                    "1": "At least one real English word, but none related to the lesson topic",
                    "2": "Multiple different English words, but none related to the lesson topic",
                    "3": "English words from the lesson domain present, but does not attempt the task",
                    "4": "On-topic vocabulary directly related to the question, but target word absent",
                    "5": "Related concept-word from the lesson produced, attempts task format",
                    "6": f"'{target_word}' present but mixed with noise or extra words",
                    "7": f"Said '{target_word}' cleanly"
                }
            elif pattern_idx == 1:
                # Pattern 2: Yes/no question about lesson
                target_word = available_keywords[0]
                lesson = self.lesson_of_the_day or "this topic"
                task_text = f"Is '{target_word}' part of {lesson}? Say yes or no."
                task_category = "control"
                targets = ["yes", "no"]
                choices = ["yes", "no"]
                grader_instructions = "Award 7 points if 'yes' OR 'no' appears cleanly as a STANDALONE answer. If BOTH 'yes' AND 'no' appear (e.g., 'Yes or no?'), that is echoing the question — cap at score 5."
                rubric = {
                    "0": "Zero English words — every token is gibberish or non-English",
                    "1": "At least one real English word, but none related to the lesson topic",
                    "2": "Multiple different English words, but none related to the lesson topic",
                    "3": "English words from the lesson domain present, but no yes/no attempt",
                    "4": "On-topic vocabulary directly related to the question, but no yes/no attempt",
                    "5": "Attempts yes/no format or uses question words, but correct answer not clearly present",
                    "6": "'yes' or 'no' present but mixed with noise or extra words",
                    "7": "Said 'yes' or 'no' correctly"
                }
            else:
                # Pattern 3: A/B choice between two lesson words
                word_a = available_keywords[0]
                word_b = available_keywords[1] if len(available_keywords) > 1 else "other"
                task_text = f"{word_a.capitalize()} or {word_b}?"
                task_category = "control"
                targets = [word_a, word_b]
                choices = [word_a, word_b]
                grader_instructions = f"Award 7 points if '{word_a}' or '{word_b}' appears cleanly in output."
                rubric = {
                    "0": "Zero English words — every token is gibberish or non-English",
                    "1": "At least one real English word, but none related to the lesson topic",
                    "2": "Multiple different English words, but none related to the lesson topic",
                    "3": "English words from the lesson domain present, but neither choice attempted",
                    "4": "On-topic vocabulary directly related to the question, but neither choice present",
                    "5": f"Related word from the lesson produced, but neither '{word_a}' nor '{word_b}' present",
                    "6": f"'{word_a}' or '{word_b}' present but mixed with noise or extra words",
                    "7": f"Said '{word_a}' or '{word_b}' cleanly"
                }
        
        # Vary asker, respecting variety constraint
        if len(self.previous_askers) >= 2 and self.previous_askers[-1] == self.previous_askers[-2]:
            fallback_asker = "sophie" if self.previous_askers[-1] == "tutor" else "tutor"
        else:
            fallback_asker = random.choice(["tutor", "sophie"])
        
        return {
            "task_text": task_text,
            "task_category": task_category,
            "stage_hint": age_band,
            "asker": fallback_asker,
            "targets": targets,  # Explicit targets for grader
            "choices": choices,  # Explicit choices for MCQ
            "rubric": rubric,
            "grader_instructions": grader_instructions,
            "max_tokens": self.basil_max_tokens
        }
    
    def _generate_task_spec(self, teaching_snippet: str = "") -> dict:
        """
        Generate TaskSpec via single merged LLM call.
        
        Replaces the old two-step generate-then-select with a single call that
        mentally generates candidates, evaluates them, and returns the best one.
        Saves one API round-trip per episode (~2-4s).
        
        Args:
            teaching_snippet: The Tutor's teaching paragraph for this episode.
                             Used by the LLM to prefer tasks using words from teaching.
        """
        try:
            episode_transcript = self._get_episode_transcript()
            age_band = self.assessment.get("age_band", 0)
            task_guidance = get_task_guidance_for_age_band(age_band)
            recent_targets_str = ", ".join(self.recent_targets[-6:]) if self.recent_targets else "(none)"

            prompt = f"""You are a task designer for an AI training program for a toddler-level student named Basil.

## Episode Context
{episode_transcript}

## Teaching Snippet
{teaching_snippet}

## Session Info
Subject: {self.subject_of_the_day or ""}
Lesson: {self.lesson_of_the_day or ""}
Age band: {age_band} ({get_age_band_natural_description(age_band)})
Basil max tokens: {self.basil_max_tokens}
Recent targets (AVOID reusing): {recent_targets_str}

## Task Design Guidance
{task_guidance}

## Instructions
1. Mentally generate 5-6 diverse candidate tasks covering different categories (vocab, control, relevance, phonics)
2. Evaluate each: uses vocabulary from the teaching snippet, age-appropriate, clear binary success criteria, avoids recent targets
3. Select THE SINGLE BEST candidate
4. Write specific grader_instructions

## Output (valid JSON only)
{{
  "task_text": "exact task instruction",
  "task_category": "vocab|control|relevance|phonics",
  "targets": ["target_word"],
  "choices": [],
  "stage_hint": {age_band},
  "asker": "tutor|sophie",
  "rubric": {{
    "0": "No English at all",
    "1": "English word but off-topic",
    "2": "Multiple English words, off-topic",
    "3": "Lesson/domain word present",
    "4": "On-topic vocabulary",
    "5": "Attempts task format",
    "6": "Correct answer with noise",
    "7": "Clean correct answer"
  }},
  "grader_instructions": "specific grading instructions for this task",
  "max_tokens": {self.basil_max_tokens},
  "selection_reason": "why this was chosen"
}}"""

            response = client.chat.completions.create(
                model=TASK_AGENT_MODEL,
                messages=[
                    {"role": "system", "content": "You are a task designer. Output valid JSON only."},
                    {"role": "user", "content": prompt},
                ],
                temperature=0.6,
                max_tokens=400,
            )

            text = response.choices[0].message.content.strip()

            # Parse JSON (handle markdown code blocks)
            if text.startswith("```"):
                text = re.sub(r'^```(?:json)?\s*', '', text)
                text = re.sub(r'\s*```$', '', text)

            task_spec = json.loads(text)

            # Apply defaults and normalization
            task_spec.setdefault("task_text", "Say 'hello'.")
            task_spec.setdefault("task_category", "vocab")
            task_spec.setdefault("targets", [])
            task_spec.setdefault("choices", [])
            task_spec.setdefault("asker", "tutor")
            task_spec.setdefault("grader_instructions", "")
            task_spec.setdefault("max_tokens", self.basil_max_tokens)
            task_spec.setdefault("stage_hint", age_band)

            # Ensure rubric is a dict (grader expects dict with score keys)
            rubric = task_spec.get("rubric", {})
            if isinstance(rubric, str):
                rubric = {
                    "0": "No English", "3": "Domain word",
                    "5": "Attempts format", "7": rubric or "Clean correct answer",
                }
            task_spec["rubric"] = rubric

            # Normalize targets and enforce invariants
            task_spec["targets"] = normalize_targets(task_spec["targets"])
            task_spec["choices"] = normalize_targets(task_spec["choices"])
            task_spec = _enforce_target_invariants(task_spec)

            # Check for repetition
            task_key = (task_spec.get("task_category"), task_spec.get("task_text", "").lower())
            is_repeat = any(
                (cat, txt.lower()) == task_key
                for cat, txt in self.recent_tasks[-3:]
            )

            if is_repeat:
                if self.verbose:
                    print(f"  [TaskAgent] Selected task is a repeat, using fallback")
                task_spec = self._generate_on_topic_fallback_task()

        except Exception as e:
            if self.verbose:
                print(f"  [TaskAgent] Merged task generation failed: {e}")
            task_spec = self._generate_on_topic_fallback_task()
        
        # Track this task
        self.recent_tasks.append((task_spec.get("task_category"), task_spec.get("task_text", "")))
        if len(self.recent_tasks) > 5:
            self.recent_tasks.pop(0)
        
        # Track targets for variety
        new_targets = task_spec.get("targets", [])
        for t in new_targets:
            if t not in self.recent_targets:
                self.recent_targets.append(t)
        if len(self.recent_targets) > 8:
            self.recent_targets = self.recent_targets[-8:]
        
        # Enforce asker variety: no more than 2 in a row from same asker
        proposed_asker = task_spec.get("asker", "tutor").lower()
        if proposed_asker not in ("tutor", "sophie"):
            proposed_asker = "tutor"
        
        # Check if we've had 2+ in a row from the same asker
        if len(self.previous_askers) >= 2:
            last_two = self.previous_askers[-2:]
            if all(a == proposed_asker for a in last_two):
                # Force switch to the other asker
                forced_asker = "sophie" if proposed_asker == "tutor" else "tutor"
                if self.verbose:
                    print(f"  [TaskAgent] Forcing asker variety: {proposed_asker} → {forced_asker}")
                task_spec["asker"] = forced_asker
                proposed_asker = forced_asker
        
        self.previous_askers.append(proposed_asker)
        if len(self.previous_askers) > 5:
            self.previous_askers.pop(0)
        
        return task_spec
    
    def _create_task_spec_from_suggestion(self, suggested_task: str) -> dict:
        """
        Create a task_spec dict from an LLM validator's suggested task text.
        
        Used when the LLM validator rejects a task and suggests an alternative.
        Creates a simple vocab/control task appropriate for the current age_band.
        """
        age_band = self.assessment.get("age_band", 0)
        task_text = suggested_task.strip()
        
        # Infer task category from the suggestion
        task_lower = task_text.lower()
        if "yes or no" in task_lower or task_lower.startswith("say yes") or task_lower.startswith("say no"):
            task_category = "control"
        elif " or " in task_lower and "?" in task_text:
            task_category = "control"
        else:
            task_category = "vocab"
        
        # Extract target words for grader (store in task_spec)
        target_words = self._extract_target_words_legacy(task_text)
        target_str = ", ".join(target_words) if target_words else "the target word"
        
        # Build choices list for MCQ tasks
        choices = target_words if " or " in task_lower else []
        
        return {
            "task_text": task_text,
            "task_category": task_category,
            "stage_hint": age_band,
            "asker": "tutor",  # Default to tutor for suggestions
            "targets": target_words,  # Explicit targets for grader
            "choices": choices,
            "rubric": {
                "0": "No recognizable output — pure gibberish",
                "1": "Any English word, not on-topic",
                "2": "Multiple different English words, not on-topic",
                "3": "English word from the lesson domain",
                "4": "On-topic vocabulary related to the question",
                "5": "Attempts the task format",
                "6": "Close to target but with noise",
                "7": f"Said {target_str} clearly"
            },
            "grader_instructions": f"Award 7 points if {target_str} appears cleanly in output.",
            "max_tokens": self.basil_max_tokens
        }
    
    def _generate_tutor_teaching_only(self, task_spec: dict, episode_id: str = "") -> str:
        """
        Generate Tutor's teaching paragraph ONLY (no task instruction).
        
        Output: teaching paragraph (3-6 sentences), no TASK line.
        Task delivery is handled separately by _deliver_task().
        
        Uses LLM for all age_bands (including 0) when USE_LLM_TUTOR_FOR_AGE_BAND_0=True.
        Falls back to templates if flag is False or on error.
        """
        age_band = self.assessment.get("age_band", 0)
        
        # Optional: use simple templates for age_band 0-1 if flag is disabled
        if age_band <= 1 and not USE_LLM_TUTOR_FOR_AGE_BAND_0:
            return self._generate_tutor_teaching_simple_only()
        
        # Get full session transcript for context
        session_transcript = self._get_full_session_transcript()
        
        # Format recent facts for variety constraint (show last 6 of 8 tracked)
        recent_facts_str = ", ".join(self.recent_teaching_facts[-6:]) if self.recent_teaching_facts else "(none yet)"
        
        # Load prompt template from file
        prompt_template = _load_episode_prompt(PROMPT_TUTOR_PHASE_B, "Phase B")
        
        if prompt_template:
            # Use file-based prompt
            teaching_prompt = prompt_template.format(
                lesson=self.lesson_of_the_day or "(unknown)",
                subject=self.subject_of_the_day or "(unknown)",
                session_transcript=session_transcript,
                basil_age_description=get_age_band_natural_description(age_band),
                recent_facts=recent_facts_str,
                length_guidance=get_length_guidance("tutor_teaching", age_band),
            )
        else:
            # Fallback to inline prompt
            length_hint = get_length_guidance("tutor_teaching", age_band)
            teaching_prompt = f"""You are Tutor teaching Basil about {self.lesson_of_the_day}.

Subject: {self.subject_of_the_day}
Lesson: {self.lesson_of_the_day}
Age band: {age_band}

Recently used details (avoid repeating): {recent_facts_str}

=== Recent Conversation ===
{session_transcript}
=== End Conversation ===

{length_hint} Include NEW concrete facts.
Use simple words for age_band 0-1.
Do NOT include any TASK instruction - it will be added automatically.
"""
        
        # System message emphasizes age-appropriate style
        teaching_length = get_length_guidance("tutor_teaching", age_band)
        if age_band <= 3:
            system_msg = f"You are Tutor. {teaching_length} Use SIMPLE words, short sentences, no jargon. Include NEW concrete facts. Do NOT include any task instruction."
        else:
            system_msg = f"You are Tutor. {teaching_length} Include NEW concrete facts. Do NOT include any task instruction."
        
        messages = [
            {"role": "system", "content": system_msg},
            {"role": "user", "content": teaching_prompt}
        ]
        
        # Debug: log exact prompt payload
        self._debug_prompt_payload(episode_id, "B", "Tutor-Teaching", messages, session_transcript)
        
        try:
            # Fixed max_tokens ceiling — prompt length_guidance drives actual length
            response = client.chat.completions.create(
                model=TUTOR_MODEL,
                messages=messages,
                temperature=0.9,  # Up from 0.7 for more varied outputs
                max_tokens=get_max_tokens_ceiling("tutor_teaching"),
                presence_penalty=0.5,  # Discourage repeating tokens already in context
                frequency_penalty=0.3,  # Discourage repeating tokens based on frequency
            )
            snippet = response.choices[0].message.content.strip()
            
            # Strip any prefix
            if snippet.startswith("Tutor:"):
                snippet = snippet[6:].strip()
            
            # CRITICAL: Remove any accidental TASK text from LLM output
            snippet = self._strip_task_from_output(snippet)
            
            # Remove any other accidental task patterns (task_spec may be None)
            task_text_for_cleanup = task_spec['task_text'] if task_spec else ""
            snippet = self._clean_teaching_snippet(snippet, task_text_for_cleanup)
            
            # Extract and track a key fact from this teaching (for variety)
            self._track_teaching_fact(snippet)
            
            # Return teaching only (no TASK)
            return snippet
        except Exception as e:
            print(f"[Session] Tutor teaching error: {e}")
            # Fallback to template on error
            if age_band <= 1:
                return self._generate_tutor_teaching_simple_only()
            return f"Let's learn about {self.lesson_of_the_day}!"
    
    def _generate_tutor_teaching_simple_only(self) -> str:
        """
        Generate simple teaching for age_band=0 (no TASK line).
        
        Uses templates to ensure short, concrete, no-jargon output.
        Max 2 sentences.
        """
        lesson = self.lesson_of_the_day or self.subject_of_the_day
        
        # Simple teaching templates for age_band=0
        templates = [
            f"{lesson} is fun to learn about!",
            f"Let's learn about {lesson} together!",
            f"Today we're practicing {lesson}.",
            f"{lesson} is so interesting!",
            f"I love teaching you about {lesson}!",
        ]
        
        import random
        return random.choice(templates)
    
    def _deliver_task(self, task_spec: dict, episode_id: str = "") -> list:
        """
        Deliver the task to Basil, asked by either Tutor or Sophie.
        
        Returns a list of transcript entries (speaker, text) to be appended.
        Each entry is also a dict suitable for episode_data["messages"].
        
        Structure:
        - If Sophie asks: Tutor handoff → Sophie natural task request
        - If Tutor asks: Tutor natural task request
        
        The transcript uses NATURAL phrasing (no "TASK:" marker) so Basil
        trains on natural conversation. The canonical task_text is stored
        separately in task_spec for the grader.
        
        Validates TaskSpec contract after naturalization.
        """
        asker = task_spec.get("asker", "tutor").lower()
        task_text = task_spec.get("task_text", "Say hello.")
        
        entries = []
        natural_task = None
        
        if asker == "sophie" and self.include_sophie:
            # Sophie asks - add a brief handoff from Tutor first
            handoff = self._generate_tutor_handoff_to_sophie(task_text=task_text)
            entries.append({
                "speaker": "Tutor",
                "text": handoff,
                "phase": "B-handoff",
            })
            
            # Sophie delivers task naturally (no TASK: marker)
            natural_task = self._naturalize_task_text(task_text, "sophie", task_spec)
            entries.append({
                "speaker": "Sophie",
                "text": natural_task,
                "phase": "B-task",
                "canonical_task": task_text,  # Keep canonical for grader
            })
        else:
            # Tutor delivers task naturally (no TASK: marker)
            natural_task = self._naturalize_task_text(task_text, "tutor", task_spec)
            entries.append({
                "speaker": "Tutor",
                "text": natural_task,
                "phase": "B-task",
                "canonical_task": task_text,  # Keep canonical for grader
            })
        
        # Validate TaskSpec contract (single source of truth)
        # This runs once per episode after naturalization
        validate_task_spec_contract(
            task_spec=task_spec,
            naturalized_task_text=natural_task,
            strict=STRICT_TASK_CONTRACT,
            episode_id=episode_id,
            session_id=self.session_id,
            age_band=self.assessment.get("age_band", 0),
        )
        
        return entries
    
    def _naturalize_task_text(self, task_text: str, asker: str, task_spec: dict = None) -> str:
        """
        Convert a task instruction into natural conversational phrasing.
        
        Uses LLM-based naturalization with caching. Falls back to deterministic
        rules if LLM fails or returns invalid output.
        
        Args:
            task_text: Raw task instruction (e.g., "Say 'fire'")
            asker: "tutor" or "sophie"
            task_spec: Optional task spec dict with category, targets, etc.
        
        Returns:
            Natural phrasing like "Basil, can you say 'fire'?"
        """
        task_category = (task_spec or {}).get("task_category", "vocab")
        age_band = self.assessment.get("age_band", 0)
        
        # Check cache first
        cache = _load_task_naturalizer_cache()
        cache_key = _get_naturalizer_cache_key(task_text, task_category, age_band, asker)
        
        if cache_key in cache:
            cached = cache[cache_key]
            if DEBUG_SESSION:
                print(f"[TaskNaturalizer] Cache hit: '{task_text[:30]}...' → '{cached[:30]}...'")
            return cached
        
        # Try LLM-based naturalization
        try:
            result = self._naturalize_task_text_with_llm(task_text, asker, task_spec)
            
            # Validate result
            if result and self._validate_naturalized_task(result, task_text, task_spec):
                # Cache the successful result
                global _task_naturalizer_cache_dirty
                cache[cache_key] = result
                _task_naturalizer_cache_dirty = True
                
                if DEBUG_SESSION:
                    print(f"[TaskNaturalizer] LLM success: '{task_text[:30]}...' → '{result[:30]}...'")
                return result
            else:
                if DEBUG_SESSION:
                    print(f"[TaskNaturalizer] LLM validation failed, using fallback")
        except Exception as e:
            if DEBUG_SESSION:
                print(f"[TaskNaturalizer] LLM error: {e}, using fallback")
        
        # Fall back to deterministic naturalization
        return self._naturalize_task_text_deterministic(task_text, asker)
    
    def _naturalize_task_text_with_llm(self, task_text: str, asker: str, task_spec: dict = None) -> str:
        """
        Use LLM to naturalize a task instruction.
        
        Args:
            task_text: Raw task instruction
            asker: "tutor" or "sophie"
            task_spec: Optional task spec with category, targets, etc.
        
        Returns:
            Naturalized task text or None if LLM fails
        """
        # Load prompt template
        template = _load_episode_prompt(PROMPT_TASK_NATURALIZER, "task_naturalizer")
        if not template:
            return None
        
        task_category = (task_spec or {}).get("task_category", "vocab")
        age_band = self.assessment.get("age_band", 0)
        
        # Extract target words for validation
        target_words = self._extract_target_words_simple(task_text)
        target_words_str = ", ".join(target_words) if target_words else "(none extracted)"
        
        # Build prompt
        prompt = template.format(
            raw_task=task_text,
            speaker=asker.capitalize(),
            task_category=task_category,
            age_band=age_band,
            subject=self.subject_of_the_day or "(unknown)",
            lesson=self.lesson_of_the_day or "(unknown)",
            target_words=target_words_str,
        )
        
        # Call LLM
        response = client.chat.completions.create(
            model=TASK_NATURALIZER_MODEL,
            messages=[
                {"role": "system", "content": "You rewrite task instructions into natural dialogue. Output ONLY the rewritten line, nothing else."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7,
            max_tokens=60,
        )
        
        result = response.choices[0].message.content.strip()
        
        # Clean up any accidental quotes or formatting
        result = result.strip('"\'')
        
        # Remove any TASK: prefix if LLM accidentally added one
        if result.upper().startswith("TASK:"):
            result = result[5:].strip()
        
        return result
    
    def _validate_naturalized_task(self, result: str, original: str, task_spec: dict = None) -> bool:
        """
        Validate that naturalized output is acceptable.
        
        Uses explicit task_spec["targets"] and task_spec["choices"] for validation.
        Falls back to legacy extraction only if task_spec not provided.
        
        Checks:
        - Not empty
        - Short enough (< 120 chars)
        - Contains all target/choice tokens (word-boundary aware)
        - No forbidden markers
        - Ends with proper punctuation
        """
        if not result or len(result) > 120:
            return False
        
        # Check for forbidden markers
        forbidden = ["TASK:", "LESSON_OF_THE_DAY:", "SUBJECT_OF_THE_DAY:"]
        if any(f in result.upper() for f in forbidden):
            return False
        
        # Get targets from task_spec (preferred) or fall back to extraction
        if task_spec and task_spec.get("targets"):
            targets = normalize_targets(task_spec.get("targets", []))
            choices = normalize_targets(task_spec.get("choices", []))
        else:
            # Legacy fallback - should rarely happen now
            targets = self._extract_target_words_simple(original)
            choices = []
            if DEBUG_SESSION:
                print(f"[TaskNaturalizer] WARNING: Using legacy target extraction")
        
        # Validate using contract function (word-boundary aware)
        is_valid, missing = validate_naturalized_contains_targets(result, targets, choices)
        
        if not is_valid:
            if DEBUG_SESSION:
                print(f"[TaskNaturalizer] Validation failed: missing tokens {missing}")
            return False
        
        # Check ends with punctuation
        if not result.rstrip().endswith(("?", "!", ".")):
            return False
        
        return True
    
    def _extract_target_words_simple(self, task_text: str) -> list:
        """
        DEPRECATED: Legacy target extraction from task text.
        
        Used only when task_spec["targets"] is not available.
        New code should always provide task_spec with explicit targets.
        """
        targets = []
        
        # Pattern: Say 'word' or Say "word"
        quoted = re.findall(r"[Ss]ay\s+['\"]([^'\"]+)['\"]", task_text)
        targets.extend(quoted)
        
        # Pattern: Say word (single word after "Say")
        say_match = re.search(r"^[Ss]ay\s+(\w+)\.?$", task_text.strip())
        if say_match:
            word = say_match.group(1).lower()
            if word not in ["yes", "no", "a", "or", "one", "the"]:
                targets.append(word)
        
        # Pattern: X or Y? (A/B choice)
        ab_match = re.match(r"^(\w+)\s+or\s+(\w+)\??$", task_text.strip(), re.IGNORECASE)
        if ab_match:
            targets.extend([ab_match.group(1).lower(), ab_match.group(2).lower()])
        
        # Pattern: "reply with exactly this one word: X"
        reply_match = re.search(r':\s*(\w+)\s*$', task_text.strip())
        if reply_match and "reply with exactly" in task_text.lower():
            targets.append(reply_match.group(1).lower())
        
        # Pattern: yes or no
        if "yes or no" in task_text.lower():
            targets.extend(["yes", "no"])
        
        return list(set(targets))
    
    def _naturalize_task_text_deterministic(self, task_text: str, asker: str) -> str:
        """
        Deterministic fallback for task naturalization.
        
        Simple, minimal rules - no longer the primary path.
        Used when LLM fails or returns invalid output.
        """
        import random
        
        task_lower = task_text.lower().strip()
        
        # Build prefix based on asker
        if asker == "sophie":
            prefixes = ["Basil, ", "Hey Basil, ", "Come on Basil, "]
        else:
            prefixes = ["Basil, ", "Okay Basil, ", "Now Basil, "]
        
        prefix = random.choice(prefixes)
        
        # Already starts with "Basil" - light touch
        if task_lower.startswith("basil"):
            if not task_text.rstrip().endswith(("?", "!")):
                return task_text.rstrip(".") + "!"
            return task_text
        
        # Simple transformation: add prefix, ensure punctuation
        result = f"{prefix}{task_text}"
        if not result.rstrip().endswith(("?", "!", ".")):
            result = result.rstrip() + "!"
        
        return result
    
    def _generate_tutor_handoff_to_sophie(self, task_text: str = "") -> str:
        """
        Generate a brief, varied handoff line from Tutor to Sophie.
        Used when Sophie is the one asking Basil the task.
        
        Incorporates the task concept so the handoff isn't a vague
        "this one" with no antecedent.
        """
        import random
        import re
        
        # Extract key concept from task text for a natural handoff
        # e.g. "Say 'nebula'." → "nebula", "Is pink a shade? Yes or no?" → "pink"
        concept = ""
        if task_text:
            # Try quoted word first: Say 'word'
            match = re.search(r"['\"](\w+)['\"]", task_text)
            if match:
                concept = match.group(1)
            else:
                # Try to extract the subject noun from yes/no questions
                # "Is pink a shade of color?" → "pink"
                match = re.search(r"(?:Is|Are|Do|Does|Can)\s+(\w+)", task_text, re.IGNORECASE)
                if match:
                    word = match.group(1)
                    # Skip generic words
                    if word.lower() not in ("it", "this", "that", "there", "they", "we", "you", "basil"):
                        concept = word
        
        if concept:
            handoffs = [
                f"Sophie, can you ask Basil about {concept}?",
                f"Sophie, let's see if Basil can practice with {concept}.",
                f"Your turn, Sophie! See what Basil does with {concept}.",
                f"Sophie, why don't you quiz Basil on {concept}?",
                f"Alright Sophie, ask Basil something about {concept}.",
            ]
        else:
            handoffs = [
                "Sophie, would you like to ask Basil something?",
                "Sophie, can you give Basil a little task?",
                "Your turn, Sophie! Ask Basil to practice.",
                "Alright Sophie, you can ask Basil now.",
                "Over to you, Sophie!",
            ]
        
        return random.choice(handoffs)
    
    def _clean_teaching_snippet(self, snippet: str, task_text: str) -> str:
        """Remove any accidental task text from teaching snippet."""
        # Remove the task text if it appears
        if task_text in snippet:
            snippet = snippet.replace(task_text, "").strip()
        
        # Remove common task prefixes that shouldn't be in teaching
        task_patterns = [
            r"Now,?\s*Basil,?\s*",
            r"Basil,?\s*say\s+",
            r"Say\s+['\"]?\w+['\"]?\.?$",
            r"TASK:.*$",
        ]
        for pattern in task_patterns:
            snippet = re.sub(pattern, "", snippet, flags=re.IGNORECASE).strip()
        
        # Clean up trailing punctuation issues
        snippet = snippet.rstrip(",").strip()
        if snippet and not snippet[-1] in ".!?":
            snippet += "."
        
        return snippet
    
    def _strip_task_from_output(self, text: str) -> str:
        """
        Remove any TASK: line from LLM output.
        
        If the LLM accidentally includes "TASK:" in its output,
        strip everything from "TASK:" onward to avoid duplication.
        """
        # Case-insensitive search for TASK:
        task_idx = text.lower().find("task:")
        if task_idx != -1:
            # Keep everything before TASK:
            text = text[:task_idx].strip()
        
        # Also remove "Now, Basil..." type endings
        patterns_to_strip = [
            r"\s*Now,?\s+Basil.*$",
            r"\s*Basil,?\s+can you.*$",
            r"\s*Can you say.*$",
            r"\s*Say\s+['\"]?\w+['\"]?\.?\s*$",
        ]
        for pattern in patterns_to_strip:
            text = re.sub(pattern, "", text, flags=re.IGNORECASE).strip()
        
        return text
    
    def _strip_trailing_questions(self, text: str) -> str:
        """
        Remove trailing question sentences from text.
        
        Used for phases where Basil won't respond next (Phase F, wrap-up).
        This prevents "dangling questions" in training data.
        
        Only modifies the final sentence(s) if they end in '?'.
        """
        if not text or '?' not in text:
            return text
        
        # Split into sentences (preserve sentence boundaries)
        # Use a pattern that keeps the delimiter attached
        sentence_pattern = r'(?<=[.!?])\s+'
        sentences = re.split(sentence_pattern, text.strip())
        
        if not sentences:
            return text
        
        # Work backwards removing question sentences
        result_sentences = []
        found_statement = False
        
        for sentence in reversed(sentences):
            sentence = sentence.strip()
            if not sentence:
                continue
            
            # If we've found a statement, keep all remaining sentences
            if found_statement:
                result_sentences.insert(0, sentence)
                continue
            
            # Check if this sentence ends with ?
            if sentence.rstrip().endswith('?'):
                # Skip this question sentence
                # But convert rhetorical questions to statements if possible
                rhetorical_patterns = [
                    (r"[,\s]isn't it\?$", "."),
                    (r"[,\s]don't you think\?$", "."),
                    (r"[,\s]right\?$", "."),
                    (r"[,\s]okay\?$", "."),
                    (r"^Ready to\b.*\?$", None),  # Drop entirely
                    (r"^Can you\b.*\?$", None),   # Drop entirely
                    (r"^Do you want to\b.*\?$", None),  # Drop entirely
                ]
                
                converted = None
                for pattern, replacement in rhetorical_patterns:
                    if re.search(pattern, sentence, re.IGNORECASE):
                        if replacement:
                            converted = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)
                        break
                
                if converted:
                    result_sentences.insert(0, converted)
                    found_statement = True
                # else: drop this question sentence entirely
            else:
                result_sentences.insert(0, sentence)
                found_statement = True
        
        result = ' '.join(result_sentences).strip()
        
        # Ensure we return something meaningful
        if not result and text:
            # If we stripped everything, keep the first statement-like part
            first_statement = re.split(r'\?', text)[0].strip()
            if first_statement:
                result = first_statement + '.'
            else:
                result = text.replace('?', '.')  # Convert all ? to .
        
        return result
    
    def _track_teaching_fact(self, teaching_text: str):
        """
        Extract a key fact/detail from teaching text and add to recent_teaching_facts.
        
        Heuristic: Take the first sentence that contains a concrete detail
        (numbers, colors, comparisons, or specific nouns).
        """
        if not teaching_text:
            return
        
        # Split into sentences
        sentences = re.split(r'[.!?]+', teaching_text)
        
        # Look for a sentence with concrete content
        for sentence in sentences:
            sentence = sentence.strip()
            if len(sentence) < 10:
                continue
            
            # Check for concrete indicators
            has_number = bool(re.search(r'\d+', sentence))
            has_color = bool(re.search(r'\b(red|blue|green|yellow|orange|purple|pink|black|white|brown)\b', sentence, re.IGNORECASE))
            has_comparison = bool(re.search(r'\b(big|small|tall|short|fast|slow|loud|quiet|hot|cold)\b', sentence, re.IGNORECASE))
            has_specific_noun = bool(re.search(r'\b(dog|cat|bird|fire|water|truck|car|tree|flower|sun|moon)\b', sentence, re.IGNORECASE))
            
            if has_number or has_color or has_comparison or has_specific_noun:
                # Truncate to a short key phrase
                fact_key = sentence[:60].strip()
                if len(sentence) > 60:
                    fact_key += "..."
                
                # Add to tracking list
                self.recent_teaching_facts.append(fact_key)
                
                # Keep only last 8 (expanded from 5 for better variety)
                if len(self.recent_teaching_facts) > 8:
                    self.recent_teaching_facts.pop(0)
                
                return
        
        # Fallback: just use first sentence
        if sentences and sentences[0].strip():
            fact_key = sentences[0].strip()[:50]
            self.recent_teaching_facts.append(fact_key)
            if len(self.recent_teaching_facts) > 8:
                self.recent_teaching_facts.pop(0)
    
    def _grade_deterministic(self, task_spec: dict, basil_output: str) -> dict:
        """
        Deterministic grading for age_band=0 vocab/control tasks.
        
        For vocab tasks: score=5 if ANY target word appears (case-insensitive), else 0.
        For control tasks: score=5 if ANY target appears, else 0.
        
        Uses task_spec["targets"] directly - no extraction needed.
        """
        task_text = task_spec.get("task_text", "")
        task_category = task_spec.get("task_category", "vocab")
        
        # Use targets from task_spec (set by TaskAgent)
        # Fallback to extraction only if targets not provided (legacy compatibility)
        targets = task_spec.get("targets", [])
        if not targets:
            # Legacy fallback - should rarely happen now
            targets = self._extract_target_words_legacy(task_text)
            if self.verbose:
                print(f"  [Deterministic grader] WARNING: Using legacy target extraction")
        
        # Debug: log the target list for transparency
        if self.verbose:
            print(f"  [Deterministic grader] Task: '{task_text[:60]}...' → Targets: {targets}")
        
        if not targets:
            # Fallback: can't determine target - score=0, not auto-upgraded
            # This keeps training signals honest
            if self.verbose:
                print(f"  [Deterministic grader] WARNING: No targets extracted!")
            return {
                "score": 0,
                "justification": "Could not extract target word from task.",
                "evidence": [],
                "notes": f"Deterministic grader: target extraction failed for '{task_text[:50]}'.",
                "compliance": False,
                "grader_error": True,  # Flag for tracking
            }
        
        # Normalize basil output for matching
        basil_lower = basil_output.lower()
        basil_tokens = set(re.findall(r'\b\w+\b', basil_lower))
        
        # Check if ANY target word appears (success if at least one matches)
        # Use token-boundary-aware matching only (no substring matching to avoid false positives)
        matched_target = None
        for target in targets:
            target_lower = target.lower()
            # Only check as whole token (prevents "no" matching inside "know", etc.)
            if target_lower in basil_tokens:
                matched_target = target
                break
        
        if matched_target:
            # Check cleanliness: clean responses (<=3 tokens) get full score, noisy get partial
            total_tokens = len(basil_tokens)
            if total_tokens <= 3:
                score = 5  # Clean response
                note = "clean match"
            else:
                score = 3  # Target present but noisy (4+ tokens)
                note = f"noisy match ({total_tokens} tokens)"
            
            if self.verbose:
                print(f"  [Deterministic grader] MATCH: '{matched_target}' found in output ({note})")
            return {
                "score": score,
                "justification": f"Target word '{matched_target}' found in output ({note}).",
                "evidence": [self._sanitize_evidence(basil_output[:100])],
                "notes": f"Deterministic grader: matched '{matched_target}' from targets {targets} ({note}).",
                "compliance": True,
            }
        else:
            # Check for partial/attempt signals (any recognizable English)
            english_words = {'the', 'a', 'is', 'it', 'and', 'to', 'of', 'in', 'for', 'on', 'that', 'this'}
            has_english = bool(basil_tokens & english_words)
            
            if self.verbose:
                print(f"  [Deterministic grader] NO MATCH: Basil tokens={list(basil_tokens)[:10]}")
            
            if has_english:
                return {
                    "score": 1,
                    "justification": f"None of targets {targets} found, but some English detected.",
                    "evidence": [self._sanitize_evidence(basil_output[:100])],
                    "notes": f"Deterministic grader: checked targets {targets}, no match, attempt signal.",
                    "compliance": False,
                }
            else:
                return {
                    "score": 0,
                    "justification": f"None of targets {targets} found. Output unintelligible.",
                    "evidence": [self._sanitize_evidence(basil_output[:100])],
                    "notes": f"Deterministic grader: checked targets {targets}, no match, no attempt.",
                    "compliance": False,
                }
    
    def _extract_target_words_legacy(self, task_text: str) -> list:
        """
        DEPRECATED: Legacy target word extraction from task text.
        
        This function is kept for backward compatibility only.
        New code should use task_spec["targets"] which is set by TaskAgent.
        
        Handles patterns like:
        - "Say yes or no." → ['yes', 'no']  (PRIORITY - checked first!)
        - "Say 'flower'" → ['flower']
        - "Say 'red' or 'blue'" → ['red', 'blue']
        - "Say 'X' or 'Y' or 'Z'" → ['x', 'y', 'z']
        - "Say one word: please." → ['please']
        - "Say one word: please" → ['please']
        - "Fire or water?" → ['fire', 'water']
        - "Say dog" → ['dog']
        """
        targets = []
        
        # =====================================================================
        # PRIORITY Pattern: "Say yes or no" MUST be checked FIRST
        # This ensures "Is 'black' part of X? Say yes or no." → ['yes', 'no']
        # NOT ['black'] from the quoted word
        # =====================================================================
        if re.search(r"\bsay\s+yes\s+or\s+no\b", task_text, re.IGNORECASE):
            return ['yes', 'no']
        
        # Also handle "choose one: yes or no" and "yes or no?" patterns
        if re.search(r"\bchoose\s+one:\s*yes\s+or\s+no\b", task_text, re.IGNORECASE):
            return ['yes', 'no']
        if re.search(r"\byes\s+or\s+no\?\s*$", task_text, re.IGNORECASE):
            return ['yes', 'no']
        
        # Handle simple "Say yes." or "Say no." (age_band=0 control tasks)
        if re.search(r"^say\s+yes\.?\s*$", task_text, re.IGNORECASE):
            return ['yes']
        if re.search(r"^say\s+no\.?\s*$", task_text, re.IGNORECASE):
            return ['no']
        
        # Pattern 1: Quoted words (single or double quotes) - handles multiple
        # This catches "Say 'X' or 'Y' or 'Z'" patterns
        quoted = re.findall(r"['\"](\w+)['\"]", task_text)
        if quoted:
            targets.extend([w.lower() for w in quoted])
            return targets  # If we found quoted words, use those
        
        # Pattern 2: "Say one word: X" or "Say one word: X." (colon pattern)
        colon_match = re.search(r":\s*(\w+)\.?$", task_text.strip())
        if colon_match:
            word = colon_match.group(1).lower()
            # Filter out non-target words
            if word not in ('a', 'an', 'the', 'is', 'it', 'or'):
                targets.append(word)
                return targets
        
        # Pattern 4: Multi-word "or" chains: "X or Y or Z?" 
        # Find all words in "A or B or C" pattern
        or_chain_match = re.findall(r'\b(\w+)\s+or\b', task_text, re.IGNORECASE)
        if or_chain_match:
            # Also get the last word after the final "or"
            final_or_match = re.search(r'\bor\s+(\w+)\??\s*$', task_text, re.IGNORECASE)
            skip_words = {'say', 'is', 'it', 'a', 'an', 'the', 'can', 'you', 'basil'}
            for word in or_chain_match:
                if word.lower() not in skip_words:
                    targets.append(word.lower())
            if final_or_match:
                final_word = final_or_match.group(1).lower()
                if final_word not in skip_words and final_word not in targets:
                    targets.append(final_word)
            if targets:
                return targets
        
        # Pattern 5: Simple "X or Y?" (A/B choice at end) - fallback for pattern 4
        ab_match = re.search(r"(\w+)\s+or\s+(\w+)\??\s*$", task_text)
        if ab_match:
            a, b = ab_match.group(1).lower(), ab_match.group(2).lower()
            skip_words = {'say', 'is', 'it', 'a', 'an', 'the', 'yes', 'can', 'you'}
            if a not in skip_words:
                targets.append(a)
            if b not in skip_words:
                targets.append(b)
            if targets:
                return targets
        
        # Pattern 6: Simple "Say X" without quotes (last resort)
        say_match = re.search(r"\bsay\s+(\w+)", task_text, re.IGNORECASE)
        if say_match:
            word = say_match.group(1).lower()
            # Skip structural words
            if word not in ('one', 'a', 'an', 'the', 'yes', 'no', 'or', 'your', 'my'):
                targets.append(word)
        
        return targets
    
    def _sanitize_evidence(self, text: str) -> str:
        """Sanitize text for JSON by replacing control characters."""
        if not text:
            return ""
        # Replace control characters (except space) with space
        sanitized = re.sub(r'[\x00-\x1f\x7f-\x9f]', ' ', text)
        # Collapse multiple spaces
        sanitized = re.sub(r' +', ' ', sanitized)
        return sanitized.strip()
    
    def _grade_with_llm_safe(self, task_spec: dict, basil_output: str) -> dict:
        """
        Grade using LLM with sanitized input/output to prevent JSON parse errors.
        
        Wraps basil_output and evidence with proper escaping.
        """
        try:
            # Sanitize basil output before sending to grader
            sanitized_output = self._sanitize_evidence(basil_output)
            
            from config import AGE_BAND_DESCRIPTIONS
            age_band = self.assessment.get("age_band", 0)
            age_band_desc = AGE_BAND_DESCRIPTIONS.get(age_band, f"age band {age_band}")
            
            grade = grade_response(
                task_text=task_spec["task_text"],
                rubric=task_spec["rubric"],
                grader_instructions=task_spec["grader_instructions"],
                basil_output=sanitized_output,
                context=self._get_episode_transcript(),
                age_band=age_band,
                age_band_description=age_band_desc,
                subject=getattr(self, "subject_of_the_day", "") or "",
                lesson=getattr(self, "lesson_of_the_day", "") or "",
            )
            
            # Sanitize any evidence in the response
            if "evidence" in grade and isinstance(grade["evidence"], list):
                grade["evidence"] = [self._sanitize_evidence(e) for e in grade["evidence"]]
            
            # Ensure compliance field exists
            if "compliance" not in grade:
                grade["compliance"] = grade.get("score", 0) >= COMPLIANCE_SCORE_THRESHOLD
            
            return grade
        except Exception as e:
            print(f"[Session] LLM grader error: {e}")
            # Fallback grade - never use "automatic grade due to error" for age_band=0
            return {
                "score": 0,
                "justification": f"Grading error: {str(e)[:50]}",
                "evidence": [self._sanitize_evidence(basil_output[:50])],
                "notes": "LLM grader failed; fallback score assigned.",
                "compliance": False,
            }
    
    def _generate_sophie_reaction_to_teaching(self, teaching_text: str, episode_id: str = "") -> str:
        """
        Generate Sophie's reaction to Tutor's teaching paragraph.
        
        Sophie can acknowledge, add facts, or build on what Tutor said.
        This happens BEFORE the task is given to Basil.
        """
        age_band = self.assessment.get("age_band", 0)
        basil_age_description = get_age_band_natural_description(age_band)
        
        # Get full session transcript for context
        session_transcript = self._get_full_session_transcript()
        
        # Use the react-teaching prompt template if available
        if self.sophie_react_teaching_template:
            try:
                sophie_prompt = self.sophie_react_teaching_template.format(
                    subject=self.subject_of_the_day or "(unknown)",
                    lesson=self.lesson_of_the_day or "(unknown)",
                    basil_age_description=basil_age_description,
                    teaching_text=teaching_text,
                    session_transcript=session_transcript,
                    length_guidance=get_length_guidance("sophie_reaction", age_band),
                )
            except KeyError as e:
                print(f"[Session] Warning: Missing prompt variable {e}")
                sophie_prompt = None
        else:
            sophie_prompt = None
        
        # Fallback inline prompt if template not available
        if not sophie_prompt:
            sophie_prompt = f"""You are Sophie, Basil's older sibling.

Subject: {self.subject_of_the_day}
Lesson: {self.lesson_of_the_day}
Basil is currently {basil_age_description}

Session conversation so far:
{session_transcript}

Tutor just said: "{teaching_text[:200]}"

React naturally to what Tutor just taught. {get_length_guidance("sophie_reaction", age_band)}
- Acknowledge or show interest in what Tutor said
- You can ADD an additional fact or BUILD on what Tutor said
- Don't repeat facts already covered in the session above
- Keep it warm and conversational
- Do NOT mention Basil or tasks yet
"""
        
        system_msg = f"You are Sophie. React naturally to Tutor's teaching. You can add facts or build on what Tutor said. {get_length_guidance('sophie_reaction', age_band)}"
        
        messages = [
            {"role": "system", "content": system_msg},
            {"role": "user", "content": sophie_prompt}
        ]
        
        # Debug: log exact prompt payload
        debug_context = f"Teaching: {teaching_text[:100]}"
        self._debug_prompt_payload(episode_id, "B.2", "Sophie-ReactTeaching", messages, debug_context)
        
        try:
            # Fixed max_tokens ceiling — prompt length_guidance drives actual length
            response = client.chat.completions.create(
                model=SOPHIE_MODEL,
                messages=messages,
                temperature=0.8,  # Higher temp for variety in reactions/facts
                max_tokens=get_max_tokens_ceiling("sophie_reaction"),
            )
            result = response.choices[0].message.content.strip()
            
            # Basic cleanup
            result = result.strip()
            if result.startswith("Sophie:"):
                result = result[7:].strip()
            
            return result
            
        except Exception as e:
            print(f"[Session] Sophie reaction generation error: {e}")
            # Simple fallback
            return "That's interesting, Tutor!"
    
    # Templates for wrapping Sophie's bare quiz answer in natural phrasing
    _SOPHIE_SAY_WORD_TEMPLATES = [
        "Sure, Tutor! {answer}.",
        "That's easy — {answer}!",
        "Oh, I know this one! {answer}.",
        "{answer}! That's a fun word.",
        "Hmm, let me think... {answer}!",
    ]
    _SOPHIE_YES_NO_TEMPLATES = [
        "{answer}!",
        "{answer}, definitely!",
        "Hmm... {answer}!",
        "I think so — {answer}!",
        "Oh, {answer}!",
    ]

    def _generate_sophie_quiz(self, teaching_text: str, topic: str, episode_id: str = "") -> tuple:
        """
        Generate a Tutor→Sophie comprehension quiz exchange.
        
        Tutor sees the full session transcript, reacts naturally, then asks
        Sophie a simple question (yes/no or say-word). Sophie answers naturally.
        Tutor then confirms and adds a bonus fact. This models simple Q&A for
        Basil to overhear in the trunk training data.
        
        Returns:
            (tutor_question, sophie_answer, tutor_reaction) or (None, None, None) on failure
        """
        import random
        
        age_band = self.assessment.get("age_band", 0)
        
        # Choose format based on age_band (mirror Basil's task types)
        if age_band <= 1:
            format_hint = random.choice(["say_word", "say_word", "yes_no"])  # Prefer say_word
        elif age_band <= 3:
            format_hint = random.choice(["yes_no", "say_word"])
        else:
            format_hint = random.choice(["yes_no", "yes_no", "say_word"])  # More yes/no at higher bands
        
        if format_hint == "yes_no":
            format_guidance = (
                'Ask a YES/NO question. Format: "Sophie, is [fact from teaching]? Yes or no?"\n'
                'The answer must be "Yes" or "No".'
            )
        else:
            format_guidance = (
                'Ask Sophie to say a KEY WORD from the teaching. Format: "Sophie, can you say \'[word]\'?"\n'
                'Pick a simple, concrete noun from the teaching (like \'roots\', \'fire\', \'moon\').\n'
                'The answer must be just the word (e.g. "Roots").'
            )
        
        # Age-band-appropriate difficulty
        if age_band <= 1:
            difficulty_guidance = "Keep the question very simple — a toddler should be able to follow along."
        elif age_band <= 3:
            difficulty_guidance = "The question can use slightly more challenging vocabulary, but should still be straightforward."
        elif age_band <= 5:
            difficulty_guidance = "Ask a question that requires understanding a specific fact from the teaching."
        else:
            difficulty_guidance = "Ask a question that tests comprehension — Sophie should need to think for a moment before answering."
        
        # Anti-repetition: list recently used quiz words
        if self._quiz_words_used:
            avoid_words = "IMPORTANT: Do NOT reuse these words/answers from earlier quizzes: " + ", ".join(self._quiz_words_used) + ". Pick a DIFFERENT word or fact.\n"
        else:
            avoid_words = ""
        
        # Full session transcript — same as other prompts
        session_transcript = self._get_recent_conversation()
        
        # Load prompt template
        quiz_prompt_template = _load_episode_prompt(PROMPT_TUTOR_QUIZ_SOPHIE, "Tutor Quiz Sophie")
        if not quiz_prompt_template:
            return (None, None, None)
        
        try:
            quiz_prompt = quiz_prompt_template.format(
                session_transcript=session_transcript,
                topic=topic or "(unknown)",
                format_guidance=format_guidance,
                difficulty_guidance=difficulty_guidance,
                avoid_words=avoid_words,
            )
        except KeyError as e:
            print(f"[Popquiz] Warning: Missing prompt variable {e}")
            return (None, None, None)
        
        system_msg = "You are Tutor. Output valid JSON only."
        
        try:
            response = client.chat.completions.create(
                model=TUTOR_MODEL,
                messages=[
                    {"role": "system", "content": system_msg},
                    {"role": "user", "content": quiz_prompt}
                ],
                temperature=0.7,
                max_tokens=200,
            )
            raw = response.choices[0].message.content.strip()
            
            # Parse JSON response
            # Strip markdown code fences if present
            if raw.startswith("```"):
                raw = raw.split("\n", 1)[-1].rsplit("```", 1)[0].strip()
            
            result = json.loads(raw)
            question = result.get("question", "").strip()
            answer = result.get("answer", "").strip()
            reaction = result.get("reaction", "").strip()
            
            if not question or not answer:
                print(f"[Popquiz] Empty question or answer in response: {raw[:100]}")
                return (None, None, None)
            
            # Clean up: ensure answer is short (1-3 words)
            answer_words = answer.split()
            if len(answer_words) > 5:
                print(f"[Popquiz] Answer too long ({len(answer_words)} words), skipping")
                return (None, None, None)
            
            # Capitalize answer for proper sentence placement in templates
            answer = answer[0].upper() + answer[1:] if answer else answer
            
            # Wrap bare answer in natural Sophie phrasing (format-aware)
            if format_hint == "yes_no":
                natural_answer = random.choice(self._SOPHIE_YES_NO_TEMPLATES).format(answer=answer)
            else:
                natural_answer = random.choice(self._SOPHIE_SAY_WORD_TEMPLATES).format(answer=answer)
            
            # Track used quiz word for anti-repetition
            self._quiz_words_used.append(answer.lower())
            
            if self.verbose:
                print(f"[Popquiz] Tutor: {question}")
                print(f"[Popquiz] Sophie: {natural_answer}")
                if reaction:
                    print(f"[Popquiz] Tutor (reaction): {reaction}")
            
            return (question, natural_answer, reaction)
            
        except (json.JSONDecodeError, KeyError) as e:
            print(f"[Popquiz] JSON parse error: {e}")
            return (None, None, None)
        except Exception as e:
            print(f"[Popquiz] LLM error: {e}")
            return (None, None, None)
    
    def _generate_sophie_post_grade(self, basil_attempt: str, grade: dict, task_spec: dict, episode_id: str = "") -> str:
        """
        Generate Sophie's response AFTER seeing the grade.
        
        Uses a single merged LLM call that embeds generation + validation rules
        directly in the prompt. Saves one API round-trip per episode (~1-2s)
        compared to the old generate-then-validate approach.
        """
        score = grade.get("score", 0)
        age_band = self.assessment.get("age_band", 0)
        success_threshold = COMPLIANCE_SCORE_THRESHOLD  # 4 on 0-7 scale
        
        score_desc, tone_guidance = SOPHIE_SCORE_REACTIONS.get(
            score, SOPHIE_SCORE_REACTIONS[0]
        )
        
        session_transcript = self._get_full_session_transcript()
        recent_facts = ", ".join(self.recent_teaching_facts[-6:]) if self.recent_teaching_facts else "(none yet)"
        recent_q = "\n".join(f"- {q}" for q in self.recent_sophie_questions[-5:]) if self.recent_sophie_questions else "(none)"
        
        sophie_prompt = f"""You are Sophie, a bright and enthusiastic 12-year-old student helping teach Basil.

## Session So Far
{session_transcript}

## Context
Subject: {self.subject_of_the_day or ""}
Lesson: {self.lesson_of_the_day or ""}
Basil's developmental stage: {get_age_band_natural_description(age_band)}
Performance: {score_desc}
Recent teaching facts: {recent_facts}

## Tone
{tone_guidance}

## Your Task
Respond to Basil's attempt with EXACTLY 2 sentences:
- Sentence 1: Brief, warm encouragement for Basil (match the tone above)
- Sentence 2: A single curiosity question directed at Tutor

## STRICT Rules
1. EXACTLY 2 sentences total, under 40 words
2. Question must be about a CONCRETE entity within the lesson, NOT the lesson title
3. No generic questions like "What is [lesson]?" or "Tell me about [lesson]"
4. No treating the lesson title as a physical object
5. Childlike, curious, age-appropriate

Recent questions to AVOID repeating:
{recent_q}

Output ONLY Sophie's 2-sentence response. Nothing else."""
        
        length_hint = get_length_guidance("sophie_post_grade", age_band)
        
        messages = [
            {"role": "system", "content": f"You are Sophie, a bright 12-year-old. {length_hint} Follow the formatting rules exactly."},
            {"role": "user", "content": sophie_prompt},
        ]
        
        # Debug: log exact prompt payload
        debug_context = f"Basil output: {basil_attempt[:100]} | Grade: {score}/7"
        self._debug_prompt_payload(episode_id, "E", "Sophie-PostGrade", messages, debug_context)
        
        try:
            response = client.chat.completions.create(
                model=SOPHIE_MODEL,
                messages=messages,
                temperature=0.7,
                max_tokens=get_max_tokens_ceiling("sophie_post_grade"),
            )
            result = response.choices[0].message.content.strip()
            
            # Quick regex truthfulness check (no API call needed)
            result = self._validate_sophie_response(result, score, success_threshold)
            
            # Basic sanity check - should have a question mark
            if "?" not in result:
                if self.verbose:
                    print(f"  [Sophie] Missing question in response, using fallback")
                return self._sophie_safe_keyword_fallback(score, success_threshold)
            
            # Track the question for future novelty checks
            if "?" in result:
                question_part = result.split("?")[0].split("!")[-1].strip()
                self.recent_sophie_questions.append(question_part)
                if len(self.recent_sophie_questions) > 10:
                    self.recent_sophie_questions.pop(0)
            
            return result
            
        except Exception as e:
            print(f"[Session] Sophie post-grade error: {e}")
            return self._sophie_safe_keyword_fallback(score, success_threshold)
    
    # =========================================================================
    # DEPRECATED: The following methods are no longer used.
    # Sophie question validation is now handled by _sophie_validate_or_rewrite()
    # These stubs are kept for backward compatibility and will be removed.
    # =========================================================================
    
    def _extract_question_topic(self, text: str) -> str:
        """DEPRECATED: Use _sophie_validate_or_rewrite() instead."""
        # Simple extraction for backward compatibility
        if "?" in text:
            return text.split("?")[0].split("!")[-1].strip()[:50]
        return ""
    
    def _is_duplicate_question(self, topic: str) -> bool:
        """DEPRECATED: Novelty is now handled by LLM validator."""
        return False  # Always return False, LLM validator handles duplicates
    
    def _extract_wrapper_pattern(self, text: str) -> str:
        """DEPRECATED: Pattern detection moved to LLM validator."""
        return ""  # No longer used
    
    def _sophie_novel_fallback(self, score: int, threshold: int) -> str:
        """
        Generate a novel Sophie response using concrete keywords.
        
        DEPRECATED: Use _sophie_safe_keyword_fallback instead.
        This method now delegates to the safe keyword fallback.
        """
        return self._sophie_safe_keyword_fallback(score, threshold)
    
    def _sophie_safe_keyword_fallback(self, score: int, threshold: int) -> str:
        """
        Generate a safe Sophie response using concrete keywords derived from lesson/subject.
        
        This deterministic fallback produces questions about specific entities
        within the lesson, never about the lesson title itself.
        """
        import random
        
        # Get concrete keywords (filter out lesson/subject title words and stopwords)
        lesson_words = set(w.lower() for w in (self.lesson_of_the_day or "").split() if len(w) >= 3)
        subject_words = set(w.lower() for w in (self.subject_of_the_day or "").split() if len(w) >= 3)
        title_words = lesson_words | subject_words
        
        # Derive keywords from lesson and subject
        keywords = set()
        for text in [self.lesson_of_the_day, self.subject_of_the_day]:
            if text:
                words = re.split(r'[\s\-_/]+', text.lower())
                for word in words:
                    word = re.sub(r'[^a-z]', '', word)
                    if len(word) >= 3 and word not in STOPWORDS:
                        keywords.add(word)
        
        # Filter to get concrete nouns/entities (exclude title words and stopwords)
        concrete_keywords = []
        skip_words = {"the", "yes", "no", "hello", "hi", "bye", "and", "for", "with", "about"}
        for kw in keywords:
            kw_lower = kw.lower()
            # Skip if it's a title word or too short
            if kw_lower in title_words or len(kw_lower) < 3:
                continue
            # Skip common stopwords and abstract words
            if kw_lower in skip_words:
                continue
            concrete_keywords.append(kw_lower)
        
        # If no concrete keywords, use some safe defaults based on lesson context
        if not concrete_keywords:
            concrete_keywords = self._get_safe_fallback_keywords()
        
        # Question templates that work with concrete nouns
        question_templates = [
            "what does a {keyword} do",
            "what sound does a {keyword} make",
            "what color is a {keyword}",
            "where can we find a {keyword}",
            "what is a fun fact about {keyword}",
            "how do we use a {keyword}",
            "what do {keyword}s look like",
            "why do we need {keyword}s",
        ]
        
        # Pick a keyword not recently used in questions
        available_keywords = [kw for kw in concrete_keywords 
                             if not self._is_duplicate_question(kw)]
        if not available_keywords:
            available_keywords = concrete_keywords if concrete_keywords else ["things", "animals", "people"]
        
        keyword = random.choice(available_keywords)
        template = random.choice(question_templates)
        question = template.format(keyword=keyword)
        
        # Track this topic
        self.recent_sophie_questions.append(keyword)
        if len(self.recent_sophie_questions) > 10:
            self.recent_sophie_questions.pop(0)
        
        # Calibrated encouragement based on actual score (0-7 scale)
        if score >= 6:
            encouragement = "Great job, Basil!"
        elif score >= 4:
            encouragement = "Nice try, Basil!"
        else:
            encouragement = "That was a hard one, Basil, keep trying!"
        
        return f"{encouragement} Tutor, {question}?"
    
    def _get_safe_fallback_keywords(self) -> list:
        """
        Get safe fallback keywords when no concrete keywords can be derived from lesson/subject.
        
        Returns generic but concrete nouns based on lesson category.
        """
        lesson_lower = (self.lesson_of_the_day or "").lower()
        subject_lower = (self.subject_of_the_day or "").lower()
        combined = lesson_lower + " " + subject_lower
        
        # Map common lesson types to concrete fallback keywords
        keyword_map = {
            "animal": ["dog", "cat", "cow", "pig", "horse", "bird", "fish"],
            "farm": ["cow", "pig", "chicken", "tractor", "barn", "horse"],
            "family": ["mom", "dad", "brother", "sister", "baby", "grandma"],
            "food": ["apple", "banana", "bread", "milk", "cookie", "carrot"],
            "color": ["apple", "sky", "grass", "sun", "flower", "truck"],
            "vehicle": ["car", "truck", "bus", "train", "bike", "airplane"],
            "weather": ["rain", "sun", "cloud", "snow", "wind", "rainbow"],
            "manner": ["friend", "teacher", "helper", "neighbor", "guest"],
            "greeting": ["friend", "neighbor", "teacher", "guest", "visitor"],
            "body": ["hand", "foot", "eye", "ear", "nose", "mouth"],
            "toy": ["ball", "doll", "block", "train", "car", "teddy bear"],
            "plant": ["flower", "tree", "leaf", "seed", "garden", "grass"],
            "insect": ["bee", "butterfly", "ant", "ladybug", "spider", "caterpillar"],
        }
        
        for category, keywords in keyword_map.items():
            if category in combined:
                return keywords
        
        # Ultimate fallback - very generic concrete nouns
        return ["friend", "teacher", "helper", "animal", "food", "toy"]
    
    def _validate_sophie_response(self, response: str, score: int, threshold: int) -> str:
        """
        Validate Sophie's response for truthfulness.
        
        Only suppress success language for scores 0-2. At score 3+ Sophie's
        tone guidance already encourages excitement, so mild success language
        is appropriate and adds diversity to the training transcripts.
        """
        if score >= 3:
            return response
        
        # Check for inappropriate success language
        success_patterns = [
            "great job", "you did it", "perfect", "excellent", "wonderful",
            "that's right", "correct", "well done", "amazing", "fantastic",
            "you got it", "nailed it"
        ]
        
        response_lower = response.lower()
        for pattern in success_patterns:
            if pattern in response_lower:
                if self.verbose:
                    print(f"  [Sophie Validator] Detected false success language: '{pattern}'")
                # Replace with templated response
                return f"Keep practicing, Basil! You're learning. Tutor, can you tell us more about {self.lesson_of_the_day}?"
        
        return response
    
    def _sophie_validate_or_rewrite(
        self, 
        raw_sophie_text: str, 
        subject: str, 
        lesson: str, 
        age_band: int, 
        recent_questions: list
    ) -> str:
        """
        LLM-based validator/rewriter for Sophie's post-grade response.
        
        Takes Sophie's raw 2-sentence output and returns either:
        - the same text (if valid), or
        - a rewritten version that fixes bad question patterns, repeats, vagueness
        
        Returns exactly 2 sentences, under 40 words, second sentence is a question to Tutor.
        """
        # Build the recent questions list (last 5)
        recent_q_str = "\n".join(f"- {q}" for q in recent_questions[-5:]) if recent_questions else "(none)"
        
        validator_prompt = f"""You are a strict validator for a child character named Sophie. 

## Input
Subject: {subject}
Lesson: {lesson}
Age band: {age_band}
Raw Sophie text: "{raw_sophie_text}"

Recent questions (AVOID repeating or paraphrasing these):
{recent_q_str}

## Rules
1. Output must be exactly 2 sentences total
2. Sentence 1 is encouragement (keep as-is if appropriate)
3. Sentence 2 must be a single curiosity question directed to Tutor
4. The question must be about a CONCRETE entity inside the lesson, NOT the lesson title itself
5. Avoid generic questions like "What is {lesson}?" or "Tell me about {lesson}"
6. Avoid questions that treat the lesson title as a physical object (e.g., "What color is {lesson}?")
7. Do NOT repeat or closely paraphrase any of the recent questions
8. Keep it childlike and age-appropriate
9. Under 40 words total

## Output Format (JSON only)
{{"valid": true/false, "fixed_text": "..."}}

If the raw text is valid, set valid=true and fixed_text equal to the raw text.
If invalid, set valid=false and provide a corrected fixed_text.

Output ONLY valid JSON, no other text."""

        try:
            response = client.chat.completions.create(
                model=SOPHIE_MODEL,
                messages=[
                    {"role": "system", "content": "You are a strict validator. Output valid JSON only."},
                    {"role": "user", "content": validator_prompt}
                ],
                temperature=0.3,
                max_tokens=150,
            )
            
            result_text = response.choices[0].message.content.strip()
            
            # Parse JSON response
            # Handle potential markdown code blocks
            if result_text.startswith("```"):
                result_text = re.sub(r'^```(?:json)?\s*', '', result_text)
                result_text = re.sub(r'\s*```$', '', result_text)
            
            result = json.loads(result_text)
            fixed_text = result.get("fixed_text", raw_sophie_text)
            
            # Basic sanity check - should have a question mark
            if "?" not in fixed_text:
                if self.verbose:
                    print(f"  [Sophie Validator] Fixed text missing question, using raw")
                return raw_sophie_text
            
            return fixed_text
            
        except json.JSONDecodeError as e:
            if self.verbose:
                print(f"  [Sophie Validator] JSON parse error: {e}")
            return raw_sophie_text
        except Exception as e:
            if self.verbose:
                print(f"  [Sophie Validator] Error: {e}")
            return raw_sophie_text
    
    # =========================================================================
    # DEPRECATED METHODS - Kept for backward compatibility, will be removed
    # These regex-based validators are replaced by _sophie_validate_or_rewrite()
    # =========================================================================
    
    def _validate_sophie_question(self, response: str) -> tuple[bool, str]:
        """DEPRECATED: Question validation moved to LLM validator."""
        return (True, "")  # Always valid, LLM validator handles this
    
    def _get_title_variants(self, title: str) -> set:
        """DEPRECATED: No longer needed with LLM validator."""
        return set()  # Empty set, not used
    
    def _generate_tutor_answer_sophie(self, sophie_question: str, grade: dict, episode_id: str = "") -> str:
        """
        Generate Tutor's answer to Sophie's curiosity question.
        
        Must provide a substantive answer (paragraph) with concrete facts.
        Uses LLM for all age_bands (including 0) when USE_LLM_TUTOR_FOR_AGE_BAND_0=True.
        """
        age_band = self.assessment.get("age_band", 0)
        
        # Optional: use simple templated answers for age_band 0-1 if flag is disabled
        if age_band <= 1 and not USE_LLM_TUTOR_FOR_AGE_BAND_0:
            return self._generate_tutor_answer_simple(sophie_question)
        
        # Get full session transcript for context
        session_transcript = self._get_full_session_transcript()
        basil_age_description = get_age_band_natural_description(age_band)
        recent_facts_str = ", ".join(self.recent_teaching_facts[-6:]) if self.recent_teaching_facts else "(none yet)"
        
        # Load prompt template from file
        prompt_template = _load_episode_prompt(PROMPT_TUTOR_PHASE_F, "Phase F")
        
        if prompt_template:
            # Use file-based prompt
            tutor_prompt = prompt_template.format(
                lesson=self.lesson_of_the_day or "(unknown)",
                subject=self.subject_of_the_day or "(unknown)",
                session_transcript=session_transcript,
                sophie_question=sophie_question,
                basil_age_description=basil_age_description,
                recent_facts=recent_facts_str,
                length_guidance=get_length_guidance("tutor_answer", age_band),
            )
        else:
            # Fallback to inline prompt
            age_note = ""
            if age_band <= 1:
                age_note = """
CRITICAL: Use VERY SIMPLE words (1-2 syllables). Short sentences (5-10 words).
Talk about things you can SEE, HEAR, TOUCH. Give ONE concrete example.
NO abstract concepts, history, or linguistic analysis."""
            
            length_hint = get_length_guidance("tutor_answer", age_band)
            tutor_prompt = f"""You are Tutor answering Sophie's curiosity question about {self.lesson_of_the_day}.

Subject: {self.subject_of_the_day}
Lesson: {self.lesson_of_the_day}
Basil is currently {basil_age_description}
{age_note}

=== Recent Conversation ===
{session_transcript}
=== End Conversation ===

Sophie just asked: "{sophie_question}"

DIRECTLY ANSWER Sophie's question. {length_hint} Include concrete examples.
No empty filler answers!
"""
        
        # System message emphasizes age-appropriate style
        if age_band <= 3:
            system_msg = "You are Tutor. Answer Sophie with 3-5 VERY SHORT sentences. Use SIMPLE words a toddler knows. Talk about things you can see/touch/hear. Include ONE concrete example. NO history, linguistics, or abstract concepts. No filler."
        else:
            system_msg = "You are Tutor. Answer Sophie with 3-5 sentences including concrete facts. Keep it grounded with examples. No filler."
        
        messages = [
            {"role": "system", "content": system_msg},
            {"role": "user", "content": tutor_prompt}
        ]
        
        # Debug: log exact prompt payload
        self._debug_prompt_payload(episode_id, "F", "Tutor-AnswerSophie", messages, session_transcript)
        
        try:
            # Fixed max_tokens ceiling — prompt length_guidance drives actual length
            response = client.chat.completions.create(
                model=TUTOR_MODEL,
                messages=messages,
                temperature=0.7,
                max_tokens=get_max_tokens_ceiling("tutor_answer"),
            )
            result = response.choices[0].message.content.strip()
            
            # Strip double prefix
            if result.startswith("Tutor:"):
                result = result[6:].strip()
            
            # Strip any accidental TASK text
            result = self._strip_task_from_output(result)
            
            # CRITICAL: Strip trailing questions - Basil won't respond to Phase F
            result = self._strip_trailing_questions(result)
            
            return result
        except Exception as e:
            print(f"[Session] Tutor answer error: {e}")
            # Fallback to template on error
            if age_band <= 1:
                return self._generate_tutor_answer_simple(sophie_question)
            return f"{self.lesson_of_the_day} is really interesting. There's so much to learn about it."
    
    def _generate_tutor_answer_simple(self, sophie_question: str) -> str:
        """Generate simple Tutor answer for age_band=0 using templates."""
        lesson = self.lesson_of_the_day or self.subject_of_the_day
        
        # Extract topic from Sophie's question
        q_lower = sophie_question.lower()
        
        # Simple templated answers based on common question patterns
        if "color" in q_lower or "colorful" in q_lower:
            answers = [
                f"Things in nature come in lots of colors! It makes the world pretty.",
                f"Colors are everywhere! Red, blue, yellow - so many to see.",
                f"Nature loves colors! They help us tell things apart.",
            ]
        elif "why" in q_lower:
            answers = [
                f"That's a great question! Nature works in amazing ways.",
                f"Good thinking, Sophie! There's so much to discover.",
                f"I love that question! Let's keep exploring together.",
            ]
        elif "what" in q_lower or "which" in q_lower:
            answers = [
                f"There are so many things to learn about {lesson}!",
                f"Great question! {lesson} has lots of fun facts.",
                f"Let me tell you - {lesson} is full of surprises!",
            ]
        else:
            answers = [
                f"Good question, Sophie! {lesson} is fun to learn about.",
                f"I like how curious you are! Let's keep learning.",
                f"That's interesting to think about!",
            ]
        
        import random
        return random.choice(answers)
    
    def _truncate_to_sentences(self, text: str, max_chars: int) -> str:
        """Truncate text at sentence boundary within max_chars."""
        if len(text) <= max_chars:
            return text
        
        # Find last sentence ending before max_chars
        truncated = text[:max_chars]
        last_period = truncated.rfind('.')
        last_exclaim = truncated.rfind('!')
        last_question = truncated.rfind('?')
        
        last_end = max(last_period, last_exclaim, last_question)
        
        if last_end > 20:  # Ensure we have at least some content
            return text[:last_end + 1]
        else:
            return truncated.rstrip() + "..."
    
    def _generate_tutor_primer(self) -> str:
        """
        Generate Tutor's response after Sophie picks the lesson.
        
        Acknowledges Sophie's choice, echoes LESSON_OF_THE_DAY, involves Basil,
        and gives a brief primer (2-4 sentences) about the lesson.
        """
        age_band = self.assessment.get("age_band", 0)
        basil_age_description = get_age_band_natural_description(age_band)
        session_transcript = self._get_full_session_transcript()
        
        # Use prompt template
        primer_prompt = None
        if self.tutor_primer_template:
            try:
                primer_prompt = self.tutor_primer_template.format(
                    subject=self.subject_of_the_day or "(unknown)",
                    lesson=self.lesson_of_the_day or "(unknown)",
                    basil_age_description=basil_age_description,
                    session_transcript=session_transcript,
                )
            except KeyError as e:
                print(f"[Session] Warning: Missing primer prompt variable {e}")
                primer_prompt = None
        
        # Fallback inline prompt
        if not primer_prompt:
            primer_prompt = f"""You are Tutor preparing to teach Basil (a baby language model).

Subject: {self.subject_of_the_day}
Lesson: {self.lesson_of_the_day}

Session so far:
{session_transcript}

Sophie has just chosen today's lesson. Now you need to:
1. Acknowledge Sophie's choice warmly
2. Echo the lesson with: LESSON_OF_THE_DAY: {self.lesson_of_the_day}
3. Involve Basil naturally in the transition
4. Give a brief primer about the lesson (2-4 sentences)

Keep it SHORT and engaging - this is just an introduction before the exercises begin.
You MUST include 'LESSON_OF_THE_DAY: {self.lesson_of_the_day}' on its own line.
"""
        
        system_msg = f"You are Tutor. Acknowledge Sophie's lesson choice, include 'LESSON_OF_THE_DAY: {self.lesson_of_the_day}', and give a brief engaging primer. Be warm."
        
        try:
            response = client.chat.completions.create(
                model=TUTOR_MODEL,
                messages=[
                    {"role": "system", "content": system_msg},
                    {"role": "user", "content": primer_prompt}
                ],
                temperature=0.7,
                max_tokens=150,
            )
            result = response.choices[0].message.content.strip()
            
            # Strip double prefix
            if result.startswith("Tutor:"):
                result = result[6:].strip()
            
            # Ensure LESSON_OF_THE_DAY marker is present
            if "LESSON_OF_THE_DAY:" not in result:
                result = f"LESSON_OF_THE_DAY: {self.lesson_of_the_day}\n\n{result}"
            
            return result
        except Exception as e:
            print(f"[Session] Tutor primer error: {e}")
            return f"Great choice, Sophie!\n\nLESSON_OF_THE_DAY: {self.lesson_of_the_day}\n\nToday we're going to learn about {self.lesson_of_the_day}. Let's start with some simple exercises and build from there!"
    
    def _save_episode_log(self, episode_data: dict):
        """Save episode data to JSONL log with all required fields.
        
        In batch mode, appends to the shared batch_sessions_path.
        In standalone mode, writes to per-session episodes file.
        """
        # Extract task_spec for verification
        task_spec = episode_data.get("task_spec", {})
        grade = episode_data.get("grade", {})
        
        # Create structured episode record with all required fields
        record = {
            "record_type": "episode",
            "session_id": self.session_id,
            "episode_id": episode_data["episode_id"],
            "timestamp": datetime.now().isoformat(),
            "subject": episode_data["subject"],
            "lesson": episode_data["lesson"],
            # Core episode data
            "task_spec": {
                "task_text": task_spec.get("task_text"),
                "task_category": task_spec.get("task_category"),
                "grader_instructions": task_spec.get("grader_instructions"),
                "rubric": task_spec.get("rubric"),
            },
            "teaching_snippet": episode_data.get("tutor_teaching", ""),
            "basil_output": self._sanitize_evidence(episode_data.get("basil", "")),
            "grade": {
                "score": grade.get("score", 0),
                "justification": grade.get("justification", ""),
                "compliance": grade.get("compliance", False),
                "evidence": [self._sanitize_evidence(e) for e in grade.get("evidence", [])],
                "notes": grade.get("notes", ""),
            },
            "sophie_text": episode_data.get("sophie", ""),
            "tutor_answer": episode_data.get("tutor_answer", ""),
            "strategy": "maintain",  # Legacy field, strategy system removed
            # Verification: confirm task_spec and grader target match
            "grader_target_match": task_spec.get("task_text") is not None,
            # Additional metadata
            "basil_tokens": episode_data.get("basil_tokens", 0),
            "age_band": episode_data.get("age_band", 0),
            "messages": episode_data.get("messages", []),
        }
        
        if self.batch_sessions_path:
            with open(self.batch_sessions_path, "a") as f:
                f.write(json.dumps(record) + "\n")
        else:
            episode_log_path = os.path.join(LOG_DIR, f"session_{self.session_id}_episodes.jsonl")
            with open(episode_log_path, "a") as f:
                f.write(json.dumps(record) + "\n")
    
    # Backward compatibility alias
    def run_turn(self) -> dict:
        """Backward compatibility alias for run_episode."""
        return self.run_episode()
    
    def run(self) -> dict:
        """Run the full session and return session result with metrics."""
        if self.verbose:
            print(f"\n{'='*60}")
            print(f"Starting Session {self.session_id}")
            print(f"{'='*60}")
        
        # Run prelude to establish subject and lesson
        self.run_prelude()
        
        # Run turns with hybrid stop policy
        try:
            while self.turn_number < SESSION_MAX_TURNS:
                turn_data = self.run_turn()
                
                should_stop, reason = self._should_stop_early()
                if should_stop:
                    self.early_stopped = True
                    self.stop_reason = reason
                    break
                
                if self.verbose:
                    print()  # Blank line between turns
        except Exception as e:
            print(f"[Session] Exception during session: {e}")
            self.early_stopped = True
            self.stop_reason = "exception"
        
        # Run graceful wrap-up
        self.run_wrapup()
        
        # Compute session metrics
        avg_score = 0
        compliance_rate = 0
        usable_turns = 0
        if self.graded_turns:
            from config import is_usable_turn
            current_age_band = self.assessment.get("age_band", 0)
            scores = [t["grade"]["score"] for t in self.graded_turns]
            avg_score = sum(scores) / len(scores)
            compliant_count = sum(1 for s in scores if s >= COMPLIANCE_SCORE_THRESHOLD)
            compliance_rate = compliant_count / len(scores)
            usable_turns = sum(1 for s in scores if is_usable_turn(s, current_age_band))
        
        # Compute progress signal
        progress_signal = self._compute_progress_signal(compliance_rate, avg_score)
        
        # Compute task category counts
        task_category_counts = {}
        for turn in self.graded_turns:
            cat = turn.get("task_category", "unknown")
            task_category_counts[cat] = task_category_counts.get(cat, 0) + 1
        
        # Average Basil tokens
        avg_basil_tokens = None
        if self.graded_turn_count > 0:
            avg_basil_tokens = self.total_basil_tokens / self.graded_turn_count
        
        # Note: progress toward training target is tracked by parallel_generate.py
        # when running in parallel mode; no per-session progress display needed.
        progress_info = None
        
        if self.verbose:
            print(f"\n{'='*60}")
            print(f"Session Complete")
            print(f"  Subject: {self.subject_of_the_day}")
            print(f"  Lesson: {self.lesson_of_the_day}")
            print(f"  Graded turns: {self.graded_turn_count}")
            print(f"  Average score: {avg_score:.2f}/7")
            print(f"  Compliance rate: {compliance_rate:.1%}")
            print(f"  Progress signal: {progress_signal}")
            print(f"  Early stopped: {self.early_stopped} ({self.stop_reason})")
            if progress_info:
                print(f"  Progress toward next training round: {progress_info['graded_turns']} out of {progress_info['threshold']} graded turns ({progress_info['percentage']:.1f}%)")
            print(f"{'='*60}\n")
        
        # Save artifacts
        transcript_path, graded_path = self._save_artifacts()
        
        # Update curriculum rotation with session score
        if not self.skip_assessment:
            record_lesson(self.subject_of_the_day, self.lesson_of_the_day, score=avg_score)
        
        # Get age_band after potential update
        age_band_end = self.age_band_start
        assessed_age_band = None  # Initialize for use in session_metrics
        
        # Update Basil assessment based on this session's performance
        if self.graded_turns and not self.skip_assessment:
            # Assess developmental age_band from full session transcript
            # Only assess if we have enough graded turns (assessment needs meaningful data)
            if len(self.graded_turns) >= MIN_GRADED_TURNS_PER_SESSION:
                try:
                    session_transcript = self._get_full_session_transcript(max_chars=15000, clean_for_training=False)
                    assessed_age_band = assess_developmental_age_band(
                        session_transcript=session_transcript,
                        current_age_band=self.age_band_start
                    )
                    if self.verbose:
                        print(f"[Assessment] Developmental assessment: age_band={assessed_age_band} (current: {self.age_band_start})")
                except Exception as e:
                    print(f"[Assessment] Assessment agent error: {e}, using score-based fallback")
                    assessed_age_band = None  # Fall back to score-based logic
            else:
                if self.verbose:
                    print(f"[Assessment] Skipping assessment: only {len(self.graded_turns)} graded turns (need {MIN_GRADED_TURNS_PER_SESSION})")
            
            # Update assessment with assessed_age_band if available
            updated_assessment = update_basil_assessment(
                avg_score, 
                self.graded_turns,
                assessed_age_band=assessed_age_band,
                session_id=self.session_id
            )
            age_band_end = updated_assessment.get("age_band", self.age_band_start)
            if self.verbose:
                print(f"[Assessment] Updated: age_band={age_band_end}, "
                      f"basil_max_tokens={updated_assessment['output_caps']['basil_max_tokens']}")
        elif self.skip_assessment and self.verbose:
            print(f"[Assessment] Skipped (skip_assessment=True, experiment eval mode)")
        
        # Update metrics
        if not self.skip_assessment:
            update_metrics_after_session(self.session_id)
        
        # Create session metrics (Phase 4)
        session_metrics = create_session_metrics(
            session_id=self.session_id,
            subject_of_the_day=self.subject_of_the_day,
            lesson_of_the_day=self.lesson_of_the_day,
            age_band_start=self.age_band_start,
            age_band_end=age_band_end,
            graded_turns_count=self.graded_turn_count,
            usable_turns_count=usable_turns,
            avg_score_session=avg_score,
            compliance_rate_session=compliance_rate,
            progress_signal_session=progress_signal,
            task_category_counts=task_category_counts,
            avg_basil_tokens=avg_basil_tokens,
            early_stopped=self.early_stopped,
            stop_reason=self.stop_reason,
            training_phase=self.training_phase,
            transcript_path=transcript_path,
            graded_path=graded_path,
            assessed_age_band=assessed_age_band,
        )
        
        # Save session metrics
        if self.batch_meta_path:
            # Batch mode: append to batch meta file
            with open(self.batch_meta_path, "a") as f:
                f.write(json.dumps(session_metrics) + "\n")
            metrics_path = self.batch_meta_path
        else:
            # Standalone mode: per-session file
            metrics_path = save_session_metrics(session_metrics)
        if self.verbose:
            print(f"[Session] Saved metrics to {metrics_path}")
        
        # Update rolling metrics
        if not self.skip_assessment:
            update_rolling_metrics(session_metrics)
        
        # Persist task naturalizer cache
        _save_task_naturalizer_cache()
        
        # Return session result
        return {
            "session_id": self.session_id,
            "session_metrics": session_metrics,
            "transcript_path": transcript_path,
            "graded_path": graded_path,
        }
    
    def _compute_progress_signal(self, compliance_rate: float, avg_score: float) -> bool:
        """
        Compute progress signal from session metrics.
        
        MVP rule:
        - True if compliance >= 0.60 OR (avg_score >= 4.0 AND compliance >= 0.40)
        """
        if compliance_rate >= 0.60:
            return True
        if avg_score >= 4.0 and compliance_rate >= 0.40:
            return True
        return False
    
    def _save_artifacts(self) -> tuple:
        """
        Save session artifacts.
        
        In batch mode, appends to shared batch files (graded, sessions, meta).
        In standalone mode, creates per-session files (backward compat).
        
        Returns:
            (transcript_path_or_None, graded_path)
        """
        os.makedirs(LOG_DIR, exist_ok=True)
        
        if self.batch_sessions_path:
            # --- Batch mode: append transcript + structured data to batch sessions file ---
            session_header = {
                "record_type": "session_start",
                "session_id": self.session_id,
                "subject": self.subject_of_the_day,
                "lesson": self.lesson_of_the_day,
                "training_phase": self.training_phase,
                "early_stopped": self.early_stopped,
                "stop_reason": self.stop_reason,
                "timestamp": datetime.now().isoformat(),
            }
            with open(self.batch_sessions_path, "a") as f:
                f.write(json.dumps(session_header) + "\n")
                # Write transcript lines
                for speaker, text in self.transcript:
                    entry = {
                        "record_type": "transcript",
                        "session_id": self.session_id,
                        "speaker": speaker,
                        "text": text,
                    }
                    if text.startswith("[WRAPUP]"):
                        entry["is_wrapup"] = True
                    elif text.startswith("[IDENTITY_PROBE]"):
                        entry["type"] = "identity_probe"
                    f.write(json.dumps(entry) + "\n")
            transcript_path = None  # No separate transcript file in batch mode
        else:
            # --- Standalone mode: per-session files ---
            # Save raw transcript
            transcript_path = os.path.join(LOG_DIR, f"session_{self.session_id}_transcript.txt")
            with open(transcript_path, "w") as f:
                f.write(f"Subject: {self.subject_of_the_day}\n")
                f.write(f"Lesson: {self.lesson_of_the_day}\n")
                f.write(f"Training Phase: {self.training_phase}\n")
                f.write(f"Early Stopped: {self.early_stopped} ({self.stop_reason})\n")
                f.write(f"{'='*40}\n\n")
                for speaker, text in self.transcript:
                    f.write(f"{speaker}: {text}\n")
            
            # Save structured log (JSONL format compatible with training)
            structured_path = os.path.join(LOG_DIR, f"session_{self.session_id}_structured.jsonl")
            with open(structured_path, "w") as f:
                meta = {
                    "type": "session_meta",
                    "session_id": self.session_id,
                    "subject": self.subject_of_the_day,
                    "lesson": self.lesson_of_the_day,
                    "training_phase": self.training_phase,
                    "early_stopped": self.early_stopped,
                    "stop_reason": self.stop_reason,
                }
                f.write(json.dumps(meta) + "\n")
                for speaker, text in self.transcript:
                    if text.startswith("[WRAPUP]"):
                        entry = {"speaker": speaker, "text": text, "is_wrapup": True}
                    elif text.startswith("[IDENTITY_PROBE]"):
                        entry = {"speaker": speaker, "text": text, "type": "identity_probe"}
                    else:
                        entry = {"speaker": speaker, "text": text}
                    f.write(json.dumps(entry) + "\n")
        
        # --- Graded turns: always save ---
        if self.batch_graded_path:
            # Batch mode: append with session_id embedded
            graded_path = self.batch_graded_path
            with open(graded_path, "a") as f:
                for turn in self.graded_turns:
                    turn_with_session = {**turn, "session_id": self.session_id}
                    f.write(json.dumps(turn_with_session) + "\n")
        else:
            # Standalone mode
            graded_path = os.path.join(LOG_DIR, f"session_{self.session_id}_graded.jsonl")
            with open(graded_path, "w") as f:
                for turn in self.graded_turns:
                    f.write(json.dumps(turn) + "\n")
        
        # Generate and save session summary
        generate_session_summary(
            session_id=self.session_id,
            transcript=self.transcript,
            graded_turns=self.graded_turns,
            subject=self.subject_of_the_day,
            lesson=self.lesson_of_the_day,
        )
        
        if self.verbose:
            mode_label = "batch" if self.batch_graded_path else "standalone"
            print(f"[Session] Saved artifacts ({mode_label} mode) to {LOG_DIR}")
        
        return transcript_path, graded_path


def run_session(
    include_sophie: bool = True,
    content_snippet: str = "",
    subject: Optional[str] = None,
    verbose: bool = True,
    training_phase: str = "normal",
    session_id: Optional[str] = None,
    batch_graded_path: Optional[str] = None,
    batch_sessions_path: Optional[str] = None,
    batch_meta_path: Optional[str] = None,
    model_path: Optional[str] = None,
    lora_strength: Optional[float] = None,
    skip_assessment: bool = False,
) -> dict:
    """
    Convenience function to run a single session.
    
    Args:
        include_sophie: Whether to include Sophie in the conversation
        content_snippet: Optional content to discuss
        subject: Optional subject override (otherwise picked from rotation)
        verbose: Whether to print progress
        training_phase: Phase label ("normal", "pretrain_eval", "posttrain_eval")
        session_id: Optional session ID override
        batch_graded_path: Batch-level graded JSONL path (append mode)
        batch_sessions_path: Batch-level debug log path (append mode)
        batch_meta_path: Batch-level metrics+summaries path (append mode)
        model_path: Optional model path override (experiment support)
        lora_strength: Optional LoRA strength override (experiment support)
        skip_assessment: Skip assessment/metrics updates (experiment eval mode)
    
    Returns:
        Session results dict with session_metrics
    """
    session = AutoSession(
        session_id=session_id,
        include_sophie=include_sophie,
        content_snippet=content_snippet,
        subject=subject,
        verbose=verbose,
        training_phase=training_phase,
        batch_graded_path=batch_graded_path,
        batch_sessions_path=batch_sessions_path,
        batch_meta_path=batch_meta_path,
        model_path=model_path,
        lora_strength=lora_strength,
        skip_assessment=skip_assessment,
    )
    return session.run()


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Run an automated Basil training session")
    parser.add_argument("--no-sophie", action="store_true", help="Disable Sophie")
    parser.add_argument("--subject", type=str, default=None, help="Override subject selection")
    parser.add_argument("--quiet", action="store_true", help="Reduce output")
    parser.add_argument("--verbose", action="store_true", help="Enable verbose output (default)")
    parser.add_argument("--turns", type=int, help="Override max turns")
    args = parser.parse_args()
    
    if args.turns:
        import config
        config.SESSION_MAX_TURNS = args.turns
    
    # --verbose is default; --quiet overrides it
    verbose = not args.quiet or args.verbose
    
    results = run_session(
        include_sophie=not args.no_sophie,
        subject=args.subject,
        verbose=verbose,
    )
    
    print(f"\nSession Results: {json.dumps(results, indent=2)}")