diff --git a/.env.example b/.env.example
deleted file mode 100644
index 6964366142b75192c5c126b34554df5347036032..0000000000000000000000000000000000000000
--- a/.env.example
+++ /dev/null
@@ -1,5 +0,0 @@
-GOOGLE_API_KEY=your-gemini-api-key-here
-
-# OCR Mode: development = Stitch & Strip engine (new, single-pass)
-#            production  = Triple-Pass legacy (safe, proven)
-OCR_STRIP_MODE=development
diff --git a/.gcloudignore b/.gcloudignore
deleted file mode 100644
index c38c377617a6bf0e972f4fb618b7c7f7bc61b336..0000000000000000000000000000000000000000
--- a/.gcloudignore
+++ /dev/null
@@ -1,16 +0,0 @@
-.gcloudignore
-.git
-.gitignore
-venv/
-.venv/
-.venv_fix/
-__pycache__/
-*.pyc
-*.pyo
-*.pyd
-.pytest_cache/
-tests/
-test_results/
-logs/
-server.log
-deploy_hf/
diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index b3b91b31ea5e55a2322a4334fc1606d4b030ea5a..0000000000000000000000000000000000000000
--- a/.gitignore
+++ /dev/null
@@ -1,9 +0,0 @@
-__pycache__/
-*.pyc
-*.pyo
-serviceAccountKey*.json
-*credentials.json
-.env
-output_locus.txt
-*.log
-.DS_Store
diff --git a/Dockerfile b/Dockerfile
index 86392be9c8898bb3823a21789e6bae3757e2628d..16d8c5bf250720a03f2b0f072cbd1b7696eaba07 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,31 +1,22 @@
-# Dockerfile - V8.0 FIXED (Uvicorn + SymPy Support)
-FROM python:3.11-slim
+FROM python:3.10-slim
 
-WORKDIR /app
+RUN apt-get update && apt-get install -y wget build-essential && rm -rf /var/lib/apt/lists/*
 
-# התקנת תלויות מערכת (פונטים לגרפים)
-RUN apt-get update && apt-get install -y \
-    libgl1 \
-    libglib2.0-0 \
-    fonts-dejavu-core \
-    fontconfig \
-    && rm -rf /var/lib/apt/lists/* \
-    && fc-cache -f -v
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
 
-# התקנת ספריות פייתון
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+WORKDIR $HOME/app
 
-# העתקת קבצי האפליקציה
-COPY . .
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-# יצירת משתמש לא-root (דרישת אבטחה)
-RUN useradd -m -u 1000 user
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
+# Download DictaLM 2.0 Q4_K_M GGUF
+RUN wget -q -O model.gguf "https://huggingface.co/dicta-il/dictalm2.0-instruct-GGUF/resolve/main/dictalm2.0-instruct.Q4_K_M.gguf"
 
-# חשיפת פורט 7860
-EXPOSE 7860
+COPY --chown=user . .
 
-# --- התיקון הקריטי: הרצה עם uvicorn ---
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
\ No newline at end of file
+# Run llama-cpp-python server
+# Port 7860 is required for HF Spaces
+CMD ["python", "-m", "llama_cpp.server", "--model", "model.gguf", "--host", "0.0.0.0", "--port", "7860", "--n_ctx", "4096", "--chat_format", "llama-2"]
diff --git a/README.md b/README.md
index 46002a38ab1cb6e17cbdb60250f26abdfe8655ca..0583ea13f0b0b45b400c7c24997d359effba4616 100644
--- a/README.md
+++ b/README.md
@@ -1,37 +1,9 @@
 ---
-title: BuddyMath
+title: BuddyMath Dicta API
 emoji: 🧮
 colorFrom: blue
-colorTo: green
+colorTo: purple
 sdk: docker
-pinned: false
+app_port: 7860
 ---
-
-# BuddyMath Server V3.1
-
-מורה פרטי AI למתמטיקה לתלמידים ישראליים 🇮🇱
-
-## API Endpoints
-
-| Endpoint | Method | Description |
-|----------|--------|-------------|
-| `/` | GET | Health check |
-| `/health` | GET | Server status |
-| `/solve_stream` | POST | פתרון בעיה (SSE) |
-
-## Modes
-
-- `solve` - פתור לי
-- `teach_me` - למד אותי  
-- `check` - בדוק אותי
-
-## Parameters
-
-```
-image: File (required)
-grade: string (required)
-mode: string (default: "solve")
-student_name: string (default: "תלמיד/ה")
-student_gender: string (default: "male")
-user_note: string (optional)
-```
+API Server for DictaLM 2.0
diff --git a/all_users.json b/all_users.json
deleted file mode 100644
index bf0860eb98eabb9d00d726bc0ce0f523414f4ee3..0000000000000000000000000000000000000000
--- a/all_users.json
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-  "test_user_123": {
-    "last_seen": "2026-02-15T12:49:04.304849",
-    "id": "test_user_123"
-  },
-  "\u05d3\u05d5\u05ea\u05df": {
-    "last_seen": "2026-03-08T15:18:08.252094",
-    "id": "\u05d3\u05d5\u05ea\u05df"
-  },
-  "stress_user_1": {
-    "last_seen": "2026-02-27T12:03:10.171108",
-    "id": "stress_user_1"
-  },
-  "stress_user_2": {
-    "last_seen": "2026-02-27T12:03:10.221285",
-    "id": "stress_user_2"
-  },
-  "stress_user_3": {
-    "last_seen": "2026-02-27T12:03:10.263698",
-    "id": "stress_user_3"
-  },
-  "stress_user_4": {
-    "last_seen": "2026-02-27T12:03:10.332969",
-    "id": "stress_user_4"
-  },
-  "stress_user_0": {
-    "last_seen": "2026-02-27T12:03:10.382946",
-    "id": "stress_user_0"
-  },
-  "diagnostic": {
-    "last_seen": "2026-02-28T11:19:56.770735",
-    "id": "diagnostic"
-  }
-}
\ No newline at end of file
diff --git a/analytics.py b/analytics.py
deleted file mode 100644
index 566cfb0a2070856c429f62819ecac6fe6625e146..0000000000000000000000000000000000000000
--- a/analytics.py
+++ /dev/null
@@ -1,77 +0,0 @@
-import datetime
-import logging
-from firebase_admin import firestore
-from firebase_manager import firebase_manager
-
-logger = logging.getLogger("HamoraServer")
-
-class AnalyticsManager:
-    """
-    Manages AI Assessment Telemetry and Weekly Reports.
-    """
-    def _get_db(self):
-        return firebase_manager.get_db()
-
-    def update_weekly_analytics(self, uid: str, assessment: dict):
-        """
-        Updates the weekly analytics document for a user using atomic operations.
-        Runs silently.
-        """
-        if not uid or not assessment:
-            return
-
-        db = self._get_db()
-        if not db:
-            logger.error("❌ [ANALYTICS] Firestore DB not available.")
-            return
-
-        try:
-            # 1. Parse assessment data
-            primary_skill = assessment.get("primary_skill", "Unknown")
-            sub_skill = assessment.get("sub_skill", "")
-            mastery_score = assessment.get("mastery_score", 0)
-            parent_note = assessment.get("parent_note", "")
-
-            # Ensure score is an integer
-            try:
-                mastery_score = int(mastery_score)
-            except (ValueError, TypeError):
-                mastery_score = 0
-
-            # 2. Compute week_id (e.g., week_11_2026)
-            today = datetime.date.today()
-            year, week_num, _ = today.isocalendar()
-            week_id = f"week_{week_num:02d}_{year}"
-
-            # 3. Construct the document reference
-            # Path: users/{uid}/analytics/{week_id}
-            doc_ref = db.collection("users").document(uid).collection("analytics").document(week_id)
-
-            # 4. Construct payload with FieldValue operations for atomic updates
-            # Create the nested skill payload
-            skill_payload = {
-                "sum_scores": firestore.Increment(mastery_score),
-                "count": firestore.Increment(1)
-            }
-            if sub_skill:
-                skill_payload["sub_skills"] = firestore.ArrayUnion([sub_skill])
-
-            # Combine into final payload
-            payload = {
-                "total_exercises": firestore.Increment(1),
-                f"skills_data.{primary_skill}": skill_payload,
-                "last_updated": firestore.SERVER_TIMESTAMP
-            }
-            
-            if parent_note:
-                payload["parent_notes"] = firestore.ArrayUnion([parent_note])
-
-            # 5. Set with merge=True
-            doc_ref.set(payload, merge=True)
-            logger.info(f"📊 [ANALYTICS] Successfully updated telemetry for {uid} in {week_id}.")
-
-        except Exception as e:
-            logger.error(f"❌ [ANALYTICS] Error updating analytics for {uid}: {e}")
-
-# Global instance
-analytics_manager = AnalyticsManager()
diff --git a/audio_generator.py b/audio_generator.py
deleted file mode 100644
index 7c3db3279b0155e3ae19f8130eba285864a1858e..0000000000000000000000000000000000000000
--- a/audio_generator.py
+++ /dev/null
@@ -1,267 +0,0 @@
-# audio_generator.py - V273.0 (Google Cloud TTS - High Quality Hebrew)
-import asyncio
-import base64
-import os
-import tempfile
-import logging
-
-# Configure Logging
-logger = logging.getLogger(__name__)
-
-# ═══════════════════════════════════════════════════════════════
-# 🎙️ Google Cloud TTS Configuration
-# ═══════════════════════════════════════════════════════════════
-# 
-# קולות עבריים זמינים:
-# - he-IL-Wavenet-A (נקבה, איכות גבוהה) ⭐ מומלץ
-# - he-IL-Wavenet-B (זכר, איכות גבוהה)
-# - he-IL-Standard-A (נקבה, איכות רגילה)
-# - he-IL-Standard-B (זכר, איכות רגילה)
-#
-# Free Tier: 1 מיליון תווים/חודש (WaveNet: 1M, Standard: 4M)
-# ═══════════════════════════════════════════════════════════════
-
-GOOGLE_VOICE_NAME = "he-IL-Wavenet-A"  # Female, high quality
-GOOGLE_LANGUAGE_CODE = "he-IL"
-SPEAKING_RATE = 0.95  # מעט יותר איטי לבהירות
-PITCH = 1.0  # גובה קול רגיל
-
-# Fallback to edge-tts if Google Cloud not configured
-USE_EDGE_TTS_FALLBACK = True
-EDGE_TTS_VOICE = "he-IL-HilaNeural"
-
-from firebase_manager import firebase_manager  # V261.17
-
-
-def _is_google_cloud_configured() -> bool:
-    """בדיקה אם Google Cloud מוגדר"""
-    # Option 1: Environment variable
-    if os.environ.get("GOOGLE_APPLICATION_CREDENTIALS"):
-        return True
-    # Option 2: Check for credentials file in common locations
-    common_paths = [
-        "/app/google-credentials.json",
-        "./google-credentials.json",
-        os.path.expanduser("~/.config/gcloud/application_default_credentials.json")
-    ]
-    for path in common_paths:
-        if os.path.exists(path):
-            os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = path
-            return True
-    return False
-
-
-async def _generate_with_google_cloud(text: str, output_path: str) -> bool:
-    """
-    יצירת אודיו עם Google Cloud TTS
-    מחזיר True אם הצליח, False אם נכשל
-    """
-    try:
-        from google.cloud import texttospeech
-        
-        # Create client
-        client = texttospeech.TextToSpeechClient()
-        
-        # Build the voice request
-        voice = texttospeech.VoiceSelectionParams(
-            language_code=GOOGLE_LANGUAGE_CODE,
-            name=GOOGLE_VOICE_NAME,
-        )
-        
-        # Select the audio format
-        audio_config = texttospeech.AudioConfig(
-            audio_encoding=texttospeech.AudioEncoding.MP3,
-            speaking_rate=SPEAKING_RATE,
-            pitch=PITCH,
-        )
-        
-        # Build the synthesis input
-        synthesis_input = texttospeech.SynthesisInput(text=text)
-        
-        # Perform the text-to-speech request
-        logger.info(f"🎙️ Google Cloud TTS: Generating audio for {len(text)} chars...")
-        
-        # Run in thread pool to not block async
-        loop = asyncio.get_running_loop()
-        response = await loop.run_in_executor(
-            None,
-            lambda: client.synthesize_speech(
-                input=synthesis_input,
-                voice=voice,
-                audio_config=audio_config
-            )
-        )
-        
-        # Write the audio content to file
-        with open(output_path, "wb") as out:
-            out.write(response.audio_content)
-        
-        logger.info(f"✅ Google Cloud TTS: Audio saved to {output_path}")
-        return True
-        
-    except ImportError:
-        logger.warning("⚠️ google-cloud-texttospeech not installed. Run: pip install google-cloud-texttospeech")
-        return False
-    except Exception as e:
-        logger.error(f"❌ Google Cloud TTS failed: {e}")
-        return False
-
-
-async def _generate_with_edge_tts(text: str, output_path: str) -> bool:
-    """
-    יצירת אודיו עם edge-tts (Fallback)
-    """
-    try:
-        import edge_tts
-        
-        logger.info(f"🎙️ Edge TTS (Fallback): Generating audio...")
-        communicate = edge_tts.Communicate(text, EDGE_TTS_VOICE)
-        await communicate.save(output_path)
-        
-        logger.info(f"✅ Edge TTS: Audio saved to {output_path}")
-        return True
-        
-    except Exception as e:
-        logger.error(f"❌ Edge TTS failed: {e}")
-        return False
-
-
-async def generate_teacher_audio(text: str, output_path: str = None) -> str:
-    """
-    V273.0: יצירת אודיו עם Google Cloud TTS (איכות גבוהה)
-    
-    מנסה קודם Google Cloud TTS, אם לא מוגדר/נכשל → edge-tts fallback
-    
-    Returns: 
-        - Public URL (if Firebase upload success)
-        - Base64 string (fallback)
-        - None (if all failed)
-    """
-    try:
-        if not text:
-            return None
-        
-        # Clean text for TTS (remove emojis and special chars that cause issues)
-        clean_text = _clean_text_for_tts(text)
-        
-        if not clean_text:
-            return None
-            
-        logger.info(f"🎙️ TTS Request: {clean_text[:50]}...")
-        
-        # Determine output path
-        if output_path:
-            os.makedirs(os.path.dirname(output_path), exist_ok=True)
-            final_path = output_path
-        else:
-            timestamp = int(asyncio.get_event_loop().time() * 1000)
-            final_path = os.path.join(tempfile.gettempdir(), f"audio_{timestamp}.mp3")
-
-        # Try Google Cloud TTS first
-        success = False
-        if _is_google_cloud_configured():
-            success = await _generate_with_google_cloud(clean_text, final_path)
-        else:
-            logger.info("ℹ️ Google Cloud not configured, using Edge TTS")
-        
-        # Fallback to edge-tts
-        if not success and USE_EDGE_TTS_FALLBACK:
-            success = await _generate_with_edge_tts(clean_text, final_path)
-        
-        if not success:
-            logger.error("❌ All TTS methods failed")
-            return None
-
-        # Try Firebase Upload
-        try:
-            blob_name = f"audio/{os.path.basename(final_path)}"
-            loop = asyncio.get_running_loop()
-            
-            public_url = await loop.run_in_executor(
-                None, 
-                lambda: firebase_manager.upload_file(final_path, blob_name)
-            )
-            
-            if public_url:
-                logger.info(f"☁️ Firebase URL: {public_url}")
-                # Clean up local file
-                if not output_path:
-                    os.remove(final_path)
-                return public_url
-        except Exception as fb_err:
-            logger.warning(f"⚠️ Firebase upload failed ({fb_err}). Using Base64.")
-
-        # Fallback: Return Base64
-        with open(final_path, "rb") as audio_file:
-            audio_bytes = audio_file.read()
-            audio_base64 = base64.b64encode(audio_bytes).decode('utf-8')
-            
-        # Clean up temp file
-        if not output_path:
-            os.remove(final_path)
-            
-        return audio_base64
-
-    except Exception as e:
-        logger.error(f"❌ TTS Generation Failed: {e}")
-        return None
-
-
-def _clean_text_for_tts(text: str) -> str:
-    """
-    ניקוי טקסט לפני TTS - הסרת אימוג'ים וסימנים בעייתיים
-    """
-    import re
-    
-    if not text:
-        return ""
-    
-    # Remove emojis
-    emoji_pattern = re.compile("["
-        u"\U0001F600-\U0001F64F"  # emoticons
-        u"\U0001F300-\U0001F5FF"  # symbols & pictographs
-        u"\U0001F680-\U0001F6FF"  # transport & map symbols
-        u"\U0001F1E0-\U0001F1FF"  # flags
-        u"\U00002702-\U000027B0"
-        u"\U000024C2-\U0001F251"
-        "]+", flags=re.UNICODE)
-    
-    clean = emoji_pattern.sub('', text)
-    
-    # Remove multiple spaces
-    clean = re.sub(r'\s+', ' ', clean)
-    
-    # Remove LaTeX remnants that might have slipped through
-    clean = clean.replace('$', '').replace('\\', '')
-    
-    return clean.strip()
-
-
-# ═══════════════════════════════════════════════════════════════
-# 🧪 Testing
-# ═══════════════════════════════════════════════════════════════
-
-if __name__ == "__main__":
-    async def main():
-        text = """
-        איזה יופי של תרגיל! היינו צריכים למצוא את נקודות הקיצון של הפונקציה.
-        השתמשנו בנגזרת ראשונה כדי למצוא איפה השיפוע מתאפס.
-        הטריק לזכור - נגזרת אפס תמיד מסמנת נקודת קיצון אפשרית.
-        כל הכבוד על ההתמדה!
-        """
-        
-        print(f"🎙️ Testing TTS...")
-        print(f"📝 Text length: {len(text)} chars")
-        print(f"☁️ Google Cloud configured: {_is_google_cloud_configured()}")
-        
-        result = await generate_teacher_audio(text)
-        
-        if result:
-            if result.startswith("http"):
-                print(f"✅ Got URL: {result}")
-            else:
-                print(f"✅ Got Base64: {len(result)} chars")
-        else:
-            print("❌ TTS failed")
-    
-    asyncio.run(main())
\ No newline at end of file
diff --git a/backend/__init__.py b/backend/__init__.py
deleted file mode 100644
index 7c7ae39d6c465edc3f4bb484a37c486d5a7ca61a..0000000000000000000000000000000000000000
--- a/backend/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-# backend/__init__.py
-# BuddyMath V2.0 backend package
diff --git a/backend/extractor.py b/backend/extractor.py
deleted file mode 100644
index 0510466776f2ccd68ee300906aa6a23699249480..0000000000000000000000000000000000000000
--- a/backend/extractor.py
+++ /dev/null
@@ -1,127 +0,0 @@
-# backend/extractor.py
-# BuddyMath V2.0 — Stage 1: Extraction LLM
-#
-# RULES (from spec):
-# 1. Extract ONLY. Never solve.
-# 2. If a value is unclear from OCR/text → return null. NO guessing.
-# 3. `find` must list what the question asks, not intermediate steps.
-# 4. `constraints` must list verbal/diagram constraints verbatim.
-# ─────────────────────────────────────────────────────────────────────────
-
-from __future__ import annotations
-
-import json
-import logging
-import re
-from typing import Any, Optional
-
-import google.generativeai as genai
-
-from backend.math_schema import MathProblemSchema
-
-logger = logging.getLogger(__name__)
-
-# ── Extraction-only system prompt ────────────────────────────────────────
-_EXTRACTION_SYSTEM_PROMPT = """
-You are a MATH DATA EXTRACTOR. Your ONLY job is to parse the problem and output a strict JSON object.
-
-ABSOLUTE RULES:
-1. DO NOT solve the problem. DO NOT calculate anything.
-2. If a value is unclear, ambiguous, or the OCR image is blurry → use JSON null for that field.
-   null ≠ "field not in problem". null = "field exists in problem but value is unreadable/unclear".
-3. Every field in `given` that the problem mentions must appear — even if its value is null.
-4. `find` must list exactly what the question asks to find/prove/calculate.
-5. `constraints` must list verbal/diagram rules (e.g. "M is the midpoint of AD").
-
-OUTPUT FORMAT (strict JSON, no markdown, no explanation):
-{
-  "problem_type": "<geometry|algebra|probability|statistics|trigonometry|calculus>",
-  "sub_type": "<e.g. circle, quadratic, normal_distribution>",
-  "given": {
-    "<label>": <value_or_null>
-  },
-  "find": ["<what to find 1>", "<what to find 2>"],
-  "constraints": ["<constraint 1>", "<constraint 2>"]
-}
-""".strip()
-
-
-class Extractor:
-    """
-    Calls Gemini Flash to extract structured data from a math problem.
-    Never solves — only parses.
-    """
-
-    def __init__(self, model_name: str = "gemini-2.0-flash"):
-        self._model = genai.GenerativeModel(
-            model_name=model_name,
-            system_instruction=_EXTRACTION_SYSTEM_PROMPT,
-        )
-
-    def extract(
-        self,
-        problem_text: str,
-        image_data: Optional[bytes] = None,
-    ) -> MathProblemSchema:
-        """
-        Extract structured data from a math problem (text + optional image).
-
-        Args:
-            problem_text: The problem as plain text (from OCR or direct input).
-            image_data:   Raw image bytes if the problem came from a photo.
-
-        Returns:
-            MathProblemSchema with verification_status="pending".
-        """
-        logger.info("📥 [EXTRACTOR] Starting extraction...")
-
-        # Build the prompt parts
-        parts: list[Any] = [problem_text]
-        if image_data:
-            parts.append({"mime_type": "image/jpeg", "data": image_data})
-
-        try:
-            response = self._model.generate_content(parts)
-            raw_text = response.text.strip()
-            logger.debug("📄 [EXTRACTOR] Raw LLM output:\n%s", raw_text)
-
-            parsed = self._parse_response(raw_text)
-            schema = MathProblemSchema(**parsed)
-
-            # Log null fields as warnings
-            null_keys = schema.null_fields()
-            if null_keys:
-                for k in null_keys:
-                    msg = f"Null field after extraction: '{k}' — OCR unclear or ambiguous"
-                    schema.warnings.append(msg)
-                    logger.warning("⚠️  [EXTRACTOR] %s", msg)
-
-            logger.info(
-                "✅ [EXTRACTOR] Done. Type=%s/%s | Given=%d fields | Nulls=%s | Find=%s",
-                schema.problem_type,
-                schema.sub_type,
-                len(schema.given),
-                null_keys or "none",
-                schema.find,
-            )
-            return schema
-
-        except Exception as e:
-            logger.error("❌ [EXTRACTOR] Failed: %s", e)
-            raise
-
-    def _parse_response(self, raw: str) -> dict:
-        """
-        Strip markdown fences if present and parse JSON.
-        Raises ValueError on invalid JSON.
-        """
-        # Strip ```json ... ``` if the model wrapped it
-        clean = re.sub(r"^```(?:json)?\s*", "", raw, flags=re.IGNORECASE)
-        clean = re.sub(r"\s*```$", "", clean).strip()
-
-        try:
-            data = json.loads(clean)
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Extractor returned invalid JSON: {e}\nRaw:\n{raw}") from e
-
-        return data
diff --git a/backend/math_schema.py b/backend/math_schema.py
deleted file mode 100644
index 412bab378e999eb77c4bec24749274cc7fca8e39..0000000000000000000000000000000000000000
--- a/backend/math_schema.py
+++ /dev/null
@@ -1,98 +0,0 @@
-# backend/math_schema.py
-# BuddyMath V2.0 — The "Truth Anchor" Architecture
-# Data Contract: MATH_PROBLEM_SCHEMA (Approved by Dotan, 2026-03-19)
-#
-# RULES:
-# - `given` fields are set by the Extractor only. Never by the Verifier.
-# - `verified` is set by the Verifier only. Never by the Extractor.
-# - `null` in `given` means "field was expected but OCR was unclear" — NOT "field doesn't exist".
-# - Only the pipeline (orchestrator) may change `verification_status`.
-# ─────────────────────────────────────────────────────────────────────────
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Literal, Optional
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class MathProblemSchema(BaseModel):
-    """
-    The single source of truth for a parsed math problem.
-    Flows through: Extractor → Verifier → Pinner → LLM.
-    """
-
-    model_config = ConfigDict(
-        # Allow None values in `given` dict (explicit null support)
-        arbitrary_types_allowed=True,
-    )
-
-    # ── What type of problem ────────────────────────────────────────────
-    problem_type: Literal[
-        "geometry",
-        "algebra",
-        "probability",
-        "statistics",
-        "trigonometry",
-        "calculus",
-    ]
-    sub_type: str  # e.g. "circle", "quadratic", "normal_distribution"
-
-    # ── What is given (Extractor fills this) ────────────────────────────
-    # null value = "was expected but OCR/text was unclear" (not the same as absent key)
-    given: Dict[str, Any] = Field(
-        default_factory=dict,
-        description=(
-            "Key=label, Value=extracted value or null. "
-            "null means unclear, NOT missing from the problem."
-        ),
-        examples=[
-            {"A": [0, 1], "D": [0, 9], "radius": None},
-            {"equation": "x^2 - 5x + 6 = 0", "domain": None},
-        ],
-    )
-
-    # ── What the question asks to find ──────────────────────────────────
-    find: List[str] = Field(
-        default_factory=list,
-        description="What the question explicitly asks to calculate or prove.",
-        examples=[["center of circle", "radius"], ["roots of equation"]],
-    )
-
-    # ── Verbal constraints (from text / diagram labels) ─────────────────
-    constraints: List[str] = Field(
-        default_factory=list,
-        examples=[["AD is a diameter", "M is the center of the circle"]],
-    )
-
-    # ── Populated ONLY by the Verifier ──────────────────────────────────
-    verified: Dict[str, Any] = Field(
-        default_factory=dict,
-        description=(
-            "Algebraically proven values. "
-            "These are Ground Truth — the LLM must not re-derive them."
-        ),
-    )
-
-    # ── Pipeline status ─────────────────────────────────────────────────
-    verification_status: Literal[
-        "verified",        # all `find` targets are algebraically confirmed
-        "partial",         # some targets verified, others not
-        "contradiction",   # algebraic result contradicts extracted data
-        "insufficient_data",  # too many null fields to verify
-        "pending",         # default before Verifier runs
-    ] = "pending"
-
-    warnings: List[str] = Field(
-        default_factory=list,
-        description="Non-fatal issues: OCR gaps, null substitutions, etc.",
-    )
-
-    def null_fields(self) -> List[str]:
-        """Returns list of keys in `given` that are explicitly null."""
-        return [k for k, v in self.given.items() if v is None]
-
-    def is_ready_to_verify(self) -> bool:
-        """True if no critical null fields block verification."""
-        # Verifier can still run on partial data; it will set status accordingly
-        return True  # Always try; Verifier decides the status
diff --git a/backend/pipeline.py b/backend/pipeline.py
deleted file mode 100644
index dec8291e03b38e17e876cf06c74bef7e895d5aa1..0000000000000000000000000000000000000000
--- a/backend/pipeline.py
+++ /dev/null
@@ -1,102 +0,0 @@
-# backend/pipeline.py
-# BuddyMath V2.0 — Task 5: Pipeline Integration
-#
-# The full pipeline: OCR → EXTRACT → VERIFY → PIN → LLM
-# All 4 stages are logged to console for every question.
-#
-# RED LINES (from spec):
-# - Never deploy without logs from all pipeline stages.
-# - The Solver is the existing LLM; this module only prepares its input.
-# ─────────────────────────────────────────────────────────────────────────
-
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass, field
-from typing import Optional
-
-from backend.extractor import Extractor
-from backend.math_schema import MathProblemSchema
-from backend.universal_verifier import UniversalVerifier
-from backend.variable_pinner import VariablePinner
-
-logger = logging.getLogger(__name__)
-
-# Singletons — instantiated once, reused across requests
-_extractor = Extractor()
-_verifier = UniversalVerifier()
-_pinner = VariablePinner()
-
-
-@dataclass
-class PipelineResult:
-    """The complete output of one pipeline run, ready for the LLM."""
-    schema: MathProblemSchema
-    pin_block: str          # inject this into the LLM prompt
-    stage_log: list[str] = field(default_factory=list)
-
-
-def run_v2_pipeline(
-    problem_text: str,
-    image_data: Optional[bytes] = None,
-) -> PipelineResult:
-    """
-    Execute the full V2.0 Truth-Anchor pipeline.
-
-    Args:
-        problem_text: The math problem as plain text (post-OCR or raw).
-        image_data:   Optional raw image bytes for OCR-aware extraction.
-
-    Returns:
-        PipelineResult with schema, pin_block, and stage_log.
-
-    Spec requirement:
-        Console log must show all 4 stages for every question.
-    """
-    log: list[str] = []
-
-    def _log(stage: int, name: str, detail: str) -> None:
-        msg = f"[PIPELINE] Stage {stage}/4 — {name}: {detail}"
-        log.append(msg)
-        logger.info(msg)
-
-    # ── Stage 1: OCR (already done upstream; we receive problem_text) ──
-    _log(1, "OCR/INPUT", f"Received problem ({len(problem_text)} chars, image={'yes' if image_data else 'no'})")
-
-    # ── Stage 2: EXTRACT ──────────────────────────────────────────────
-    schema = _extractor.extract(problem_text, image_data=image_data)
-    null_fields = schema.null_fields()
-    _log(
-        2, "EXTRACT",
-        f"type={schema.problem_type}/{schema.sub_type} | given={list(schema.given.keys())} | "
-        f"nulls={null_fields or 'none'} | find={schema.find}"
-    )
-
-    # ── Stage 3: VERIFY ───────────────────────────────────────────────
-    schema = _verifier.verify(schema)
-    _log(
-        3, "VERIFY",
-        f"status={schema.verification_status} | verified={list(schema.verified.keys())} | "
-        f"warnings={len(schema.warnings)}"
-    )
-    if schema.warnings:
-        for w in schema.warnings:
-            logger.warning("[PIPELINE] ⚠️  %s", w)
-
-    # ── Stage 4: PIN ──────────────────────────────────────────────────
-    pin_block = _pinner.build_pin_block(schema)
-    _log(
-        4, "PIN",
-        f"pin_block_len={len(pin_block)} chars | status={schema.verification_status}"
-    )
-
-    # ── Summary log ───────────────────────────────────────────────────
-    logger.info(
-        "✅ [PIPELINE] Complete — %s | null=%s | pinned=%s | status=%s",
-        f"{schema.problem_type}/{schema.sub_type}",
-        null_fields or "none",
-        list(schema.verified.keys()),
-        schema.verification_status,
-    )
-
-    return PipelineResult(schema=schema, pin_block=pin_block, stage_log=log)
diff --git a/backend/tests/test_pipeline.py b/backend/tests/test_pipeline.py
deleted file mode 100644
index 95edaecc51a17e9b10237bfc341b108b940484c9..0000000000000000000000000000000000000000
--- a/backend/tests/test_pipeline.py
+++ /dev/null
@@ -1,397 +0,0 @@
-# backend/tests/test_pipeline.py
-# BuddyMath V2.0 — Acceptance Tests (v2 — Post Priority Fix)
-#
-# CRITICAL RULE (from review):
-# M=(0,5) via midpoint of chord AD is the HALLUCINATION we are preventing.
-# M=(3,5) via intersection of diameter lines is the ONLY correct answer.
-#
-# Run with: python -m pytest backend/tests/test_pipeline.py -v
-# ─────────────────────────────────────────────────────────────────────────
-
-from __future__ import annotations
-
-import logging
-import sys
-import os
-import unittest
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
-
-from backend.math_schema import MathProblemSchema
-from backend.universal_verifier import UniversalVerifier
-from backend.variable_pinner import VariablePinner
-
-logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
-
-verifier = UniversalVerifier()
-pinner = VariablePinner()
-
-
-# ============================================================
-# Task 2/3: Verifier robustness — always returns valid schema
-# ============================================================
-class TestVerifierRobustness(unittest.TestCase):
-
-    def test_circle_insufficient_data(self):
-        """All-null geometry → insufficient_data, never crashes."""
-        schema = MathProblemSchema(
-            problem_type="geometry",
-            sub_type="circle",
-            given={"A": None, "D": None, "radius": None},
-            find=["center of circle"],
-            constraints=["AD is a diameter"],
-        )
-        result = verifier.verify(schema)
-        self.assertIn(result.verification_status,
-                      ["insufficient_data", "partial", "contradiction"])
-        self.assertIsInstance(result.warnings, list)
-
-    def test_circle_chord_midpoint_fallback(self):
-        """
-        FALLBACK ONLY test: A(0,1), D(0,9) named as diameter chord (no lines given).
-        Result must be M=(0.0, 5.0).
-        NOTE: This is the CORRECT result for this specific input.
-              It is WRONG to use midpoint when diameter lines are also available.
-        """
-        schema = MathProblemSchema(
-            problem_type="geometry",
-            sub_type="circle",
-            given={"A": [0, 1], "D": [0, 9]},
-            find=["center of circle", "radius"],
-            constraints=["AD is a diameter"],
-        )
-        result = verifier.verify(schema)
-        # Chord midpoint fallback is always partial — center is unconfirmed without line eqs
-        self.assertEqual(result.verification_status, "partial")
-        center = result.verified.get("center")
-        self.assertIsNotNone(center, "Center must be in verified")
-        self.assertAlmostEqual(center[0], 0.0, places=4)
-        self.assertAlmostEqual(center[1], 5.0, places=4)
-        self.assertAlmostEqual(result.verified.get("radius"), 4.0, places=4)
-        self.assertEqual(result.verified.get("verification_method"), "chord_midpoint_fallback")
-
-    def test_algebra_insufficient_data(self):
-        schema = MathProblemSchema(
-            problem_type="algebra",
-            sub_type="quadratic",
-            given={"equation": None},
-            find=["roots"],
-            constraints=[],
-        )
-        result = verifier.verify(schema)
-        self.assertEqual(result.verification_status, "insufficient_data")
-
-    def test_algebra_quadratic(self):
-        schema = MathProblemSchema(
-            problem_type="algebra",
-            sub_type="quadratic",
-            given={"equation": "x**2 - 5*x + 6"},
-            find=["roots"],
-            constraints=[],
-        )
-        result = verifier.verify(schema)
-        self.assertEqual(result.verification_status, "verified")
-        solutions = result.verified.get("solutions", [])
-        self.assertIn("2", solutions)
-        self.assertIn("3", solutions)
-
-    def test_probability_sum_to_one(self):
-        schema = MathProblemSchema(
-            problem_type="probability",
-            sub_type="basic",
-            given={"probabilities": [0.2, 0.3, 0.5]},
-            find=["verify distribution"],
-            constraints=[],
-        )
-        result = verifier.verify(schema)
-        self.assertEqual(result.verification_status, "verified")
-
-    def test_probability_contradiction(self):
-        schema = MathProblemSchema(
-            problem_type="probability",
-            sub_type="basic",
-            given={"probabilities": [0.5, 0.6]},
-            find=["verify distribution"],
-            constraints=[],
-        )
-        result = verifier.verify(schema)
-        self.assertEqual(result.verification_status, "contradiction")
-
-    def test_statistics_verified(self):
-        schema = MathProblemSchema(
-            problem_type="statistics",
-            sub_type="descriptive",
-            given={"data": [2, 4, 6]},
-            find=["mean"],
-            constraints=[],
-        )
-        result = verifier.verify(schema)
-        self.assertAlmostEqual(result.verified.get("mean"), 4.0, places=4)
-
-    def test_calculus_derivative(self):
-        schema = MathProblemSchema(
-            problem_type="calculus",
-            sub_type="differentiation",
-            given={"function": "x**2", "point": 3},
-            find=["derivative at x=3"],
-            constraints=[],
-        )
-        result = verifier.verify(schema)
-        self.assertAlmostEqual(result.verified.get("derivative_at_point"), 6.0, places=4)
-
-
-# ============================================================
-# THE KEY TEST — Task 4 "M=3,5" Acceptance Criterion
-# ============================================================
-class TestDiameterLineIntersection(unittest.TestCase):
-    """
-    This is THE acceptance test.
-
-    Problem: A(0,1), D(0,9)
-    Two diameters: y = 4/3*x + 1  and  y = -4/3*x + 9
-    Algebraic intersection: x=3, y=5 → M=(3,5)
-
-    ❌ WRONG (hallucination): M=(0,5) — midpoint of chord AD
-    ✅ CORRECT (algebraic):   M=(3,5) — intersection of diameter lines
-    """
-
-    def _make_schema(self) -> MathProblemSchema:
-        return MathProblemSchema(
-            problem_type="geometry",
-            sub_type="circle",
-            given={
-                "A": [0, 1],
-                "D": [0, 9],
-                "diameter_lines": ["y=4/3*x+1", "y=-4/3*x+9"],
-            },
-            find=["center of circle M"],
-            constraints=["AC and DB are diameters", "M is the center"],
-        )
-
-    def test_center_is_3_5_not_0_5(self):
-        """
-        ACCEPTANCE TEST: M must be (3,5) — intersection of diameters.
-        M=(0,5) means the verifier used midpoint of chord AD. This is the hallucination.
-        """
-        schema = self._make_schema()
-        result = verifier.verify(schema)
-
-        M = result.verified.get("M")
-        self.assertIsNotNone(M, "M must be in verified dict")
-        self.assertAlmostEqual(M[0], 3.0, places=4,
-                               msg=f"M.x should be 3.0 (got {M[0]}) — midpoint fallback not allowed here")
-        self.assertAlmostEqual(M[1], 5.0, places=4,
-                               msg=f"M.y should be 5.0 (got {M[1]})")
-
-        # Explicitly assert the WRONG answer doesn't appear
-        self.assertFalse(
-            abs(M[0] - 0.0) < 0.01 and abs(M[1] - 5.0) < 0.01,
-            "CRITICAL FAILURE: M=(0,5) detected — this is the chord midpoint hallucination!"
-        )
-
-    def test_center_method_is_line_intersection(self):
-        """Verify the method field is set correctly."""
-        schema = self._make_schema()
-        result = verifier.verify(schema)
-        method = result.verified.get("center_method")
-        self.assertEqual(method, "diameter_line_intersection")
-
-    def test_verification_status_is_verified(self):
-        schema = self._make_schema()
-        result = verifier.verify(schema)
-        self.assertIn(result.verification_status, ["verified", "partial"])
-
-    def test_pin_block_contains_correct_center(self):
-        """The PIN block must show M=(3.0, 5.0), not (0.0, 5.0)."""
-        schema = self._make_schema()
-        result = verifier.verify(schema)
-        block = pinner.build_pin_block(result)
-
-        self.assertIn("GROUND TRUTH", block)
-        self.assertIn("3.0", block, "Pin block must contain x=3.0 for center M")
-        self.assertIn("5.0", block, "Pin block must contain y=5.0 for center M")
-
-    def test_pin_block_aggressive_on_contradiction(self):
-        """Pin block flags CONTRADICTION when center_method = chord_midpoint with lines available."""
-        schema = MathProblemSchema(
-            problem_type="geometry",
-            sub_type="circle",
-            given={
-                "A": [0, 1],
-                "D": [0, 9],
-                "diameter_lines": ["y=4/3*x+1", "y=-4/3*x+9"],
-            },
-            find=["center"],
-            constraints=["AC and DB are diameters"],
-            # Simulate the hallucination being injected from outside
-            verified={"M": (0.0, 5.0), "center_method": "diameter_chord_midpoint"},
-            verification_status="contradiction",
-            warnings=["CRITICAL CONTRADICTION: LLM assumed M(0,5) from chord, correct is M(3,5)"],
-        )
-        block = pinner.build_pin_block(schema)
-        self.assertIn("CONTRADICTION", block)
-
-
-# ============================================================
-# Task 4: Pin block structure
-# ============================================================
-class TestVariablePinner(unittest.TestCase):
-
-    def test_pin_block_contains_ground_truth_header(self):
-        schema = MathProblemSchema(
-            problem_type="geometry",
-            sub_type="circle",
-            given={"A": [0, 1], "D": [0, 9]},
-            find=["center"],
-            constraints=["AD is a diameter"],
-            verified={"center": (0.0, 5.0), "radius": 4.0},
-            verification_status="verified",
-        )
-        block = pinner.build_pin_block(schema)
-        self.assertIn("GROUND TRUTH", block)
-        self.assertIn("center", block)
-        self.assertIn("radius", block)
-
-    def test_pin_block_null_warning(self):
-        schema = MathProblemSchema(
-            problem_type="geometry",
-            sub_type="circle",
-            given={"radius": None},
-            find=["center"],
-            constraints=[],
-            verification_status="insufficient_data",
-        )
-        block = pinner.build_pin_block(schema)
-        self.assertIn("INSUFFICIENT_DATA", block)
-        self.assertIn("radius", block)
-
-    def test_pin_block_contradiction_warning(self):
-        schema = MathProblemSchema(
-            problem_type="algebra",
-            sub_type="quadratic",
-            given={"equation": "x**2 - 5*x + 6", "solution": 99},
-            find=["roots"],
-            constraints=[],
-            verification_status="contradiction",
-        )
-        block = pinner.build_pin_block(schema)
-        self.assertIn("CONTRADICTION", block)
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
-
-
-# ============================================================
-# Phase C — 5-Domain Acceptance Suite
-# Each test verifies: (1) correct result, (2) verification_method field
-# ============================================================
-class TestPhaseCDomainCoverage(unittest.TestCase):
-    """
-    Phase C acceptance criterion:
-    Each domain must report WHAT was verified AND HOW (verification_method).
-    5 exam-style exercises, one per remaining domain.
-    """
-
-    # 🔴 ALGEBRA: substitution into original equation
-    def test_algebra_cubic_roots_and_method(self):
-        """x^3 - 6x^2 + 11x - 6 = 0 → roots [1, 2, 3]"""
-        schema = MathProblemSchema(
-            problem_type="algebra",
-            sub_type="cubic",
-            given={"equation": "x**3 - 6*x**2 + 11*x - 6"},
-            find=["roots"],
-            constraints=[],
-        )
-        result = verifier.verify(schema)
-        self.assertEqual(result.verification_status, "verified")
-        solutions = result.verified.get("solutions", [])
-        self.assertIn("1", solutions)
-        self.assertIn("2", solutions)
-        self.assertIn("3", solutions)
-        self.assertEqual(result.verified.get("verification_method"), "sympy_solve_substitution")
-        print(f"  [algebra] method={result.verified.get('verification_method')}")
-
-    # 🔴 GEOMETRY: diameter line intersection (already covered, here as Phase C entry)
-    def test_geometry_circle_diameter_intersection_and_method(self):
-        """y=2x+1 ∩ y=-2x+9 → center (2, 5)"""
-        schema = MathProblemSchema(
-            problem_type="geometry",
-            sub_type="circle",
-            given={"diameter_lines": ["y=2*x+1", "y=-2*x+9"]},
-            find=["center"],
-            constraints=["given lines are diameters"],
-        )
-        result = verifier.verify(schema)
-        self.assertIn(result.verification_status, ["verified", "partial"])
-        M = result.verified.get("M")
-        self.assertIsNotNone(M)
-        self.assertAlmostEqual(M[0], 2.0, places=3)
-        self.assertAlmostEqual(M[1], 5.0, places=3)
-        self.assertEqual(result.verified.get("verification_method"), "diameter_line_intersection")
-        print(f"  [geometry] M={M} method={result.verified.get('verification_method')}")
-
-    # 🟡 PROBABILITY: sum-to-1 check
-    def test_probability_three_event_distribution_and_method(self):
-        """P(A)=1/3, P(B)=1/2, P(C)=1/6 → sum=1"""
-        schema = MathProblemSchema(
-            problem_type="probability",
-            sub_type="discrete_distribution",
-            given={"probabilities": ["1/3", "1/2", "1/6"]},
-            find=["verify distribution is valid"],
-            constraints=["A, B, C are mutually exclusive and exhaustive"],
-        )
-        result = verifier.verify(schema)
-        self.assertEqual(result.verification_status, "verified")
-        self.assertAlmostEqual(result.verified.get("sum"), 1.0, places=9)
-        self.assertEqual(result.verified.get("verification_method"), "sympy_rational_sum")
-        print(f"  [probability] sum={result.verified.get('sum')} method={result.verified.get('verification_method')}")
-
-    # 🟡 STATISTICS: mean and std via NumPy
-    def test_statistics_exam_scores_and_method(self):
-        """Scores [70, 80, 90, 100] → mean=85, std=11.18"""
-        schema = MathProblemSchema(
-            problem_type="statistics",
-            sub_type="descriptive",
-            given={"data": [70, 80, 90, 100]},
-            find=["mean", "standard deviation"],
-            constraints=[],
-        )
-        result = verifier.verify(schema)
-        self.assertEqual(result.verification_status, "verified")
-        self.assertAlmostEqual(result.verified.get("mean"), 85.0, places=4)
-        self.assertAlmostEqual(result.verified.get("std"), 11.1803, places=3)
-        self.assertEqual(result.verified.get("verification_method"), "numpy_population_stats")
-        print(f"  [statistics] mean={result.verified.get('mean')} method={result.verified.get('verification_method')}")
-
-    # 🟢 CALCULUS: derivative at a point
-    def test_calculus_polynomial_derivative_and_method(self):
-        """f(x) = x^3 - 4x → f'(2) = 3*4 - 4 = 8"""
-        schema = MathProblemSchema(
-            problem_type="calculus",
-            sub_type="differentiation",
-            given={"function": "x**3 - 4*x", "point": 2},
-            find=["derivative at x=2"],
-            constraints=[],
-        )
-        result = verifier.verify(schema)
-        self.assertEqual(result.verification_status, "verified")
-        self.assertAlmostEqual(result.verified.get("derivative_at_point"), 8.0, places=4)
-        self.assertEqual(result.verified.get("verification_method"), "sympy_differentiation")
-        print(f"  [calculus] f'(2)={result.verified.get('derivative_at_point')} method={result.verified.get('verification_method')}")
-
-    # 🟢 TRIGONOMETRY: identity verification
-    def test_trigonometry_pythagorean_identity_and_method(self):
-        """sin(x)**2 + cos(x)**2 = 1 → must simplify to 0 symbolically"""
-        schema = MathProblemSchema(
-            problem_type="trigonometry",
-            sub_type="identity",
-            given={"identity": "sin(x)**2 + cos(x)**2 = 1"},
-            find=["verify Pythagorean identity"],
-            constraints=[],
-        )
-        result = verifier.verify(schema)
-        self.assertEqual(result.verification_status, "verified")
-        self.assertTrue(result.verified.get("identity_valid"))
-        self.assertEqual(result.verified.get("verification_method"), "sympy_symbolic_simplification")
-        print(f"  [trig] identity_valid={result.verified.get('identity_valid')} method={result.verified.get('verification_method')}")
diff --git a/backend/universal_verifier.py b/backend/universal_verifier.py
deleted file mode 100644
index 7e622bd2a2beb6632f6999224160ba10b7fa1405..0000000000000000000000000000000000000000
--- a/backend/universal_verifier.py
+++ /dev/null
@@ -1,480 +0,0 @@
-# backend/universal_verifier.py
-# BuddyMath V2.0 — Stage 2: SymPy-based Universal Verifier
-#
-# PRIORITY ORDER FOR CIRCLE CENTER (non-negotiable):
-# 1. diameter_lines in given → center = algebraic intersection (ALWAYS preferred)
-# 2. Midpoint of named diameter chord → FALLBACK ONLY (no lines available)
-#
-# A chord midpoint is NOT a center unless it is proven to be a diameter.
-# If diameter line equations exist, they override ALL midpoint calculations.
-# ─────────────────────────────────────────────────────────────────────────
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Dict, List, Optional, Tuple
-
-import sympy as sp
-
-from backend.math_schema import MathProblemSchema
-
-logger = logging.getLogger(__name__)
-
-
-# ── Helpers ──────────────────────────────────────────────────────────────
-def _to_point(value: Any) -> Optional[sp.Point2D]:
-    """Convert [x, y] list → sympy.Point2D, or None if invalid."""
-    if isinstance(value, (list, tuple)) and len(value) == 2:
-        try:
-            return sp.Point2D(sp.Rational(value[0]), sp.Rational(value[1]))
-        except Exception:
-            pass
-    return None
-
-
-def _to_rational(value: Any) -> Optional[sp.Rational]:
-    """Convert numeric value → sympy.Rational, or None."""
-    if value is None:
-        return None
-    try:
-        return sp.Rational(value)
-    except Exception:
-        return None
-
-
-# ── Domain dispatchers ────────────────────────────────────────────────────
-class UniversalVerifier:
-    """
-    Routes a MathProblemSchema to the appropriate domain verifier.
-    Guaranteed to never raise an exception to the caller.
-    """
-
-    _DISPATCH: Dict[str, str] = {
-        "geometry":     "_verify_geometry",
-        "algebra":      "_verify_algebra",
-        "probability":  "_verify_probability",
-        "statistics":   "_verify_statistics",
-        "trigonometry": "_verify_trigonometry",
-        "calculus":     "_verify_calculus",
-    }
-
-    def verify(self, schema: MathProblemSchema) -> MathProblemSchema:
-        """Entry point. Always returns a valid schema."""
-        logger.info(
-            "🔍 [VERIFIER] Starting. type=%s/%s | find=%s",
-            schema.problem_type, schema.sub_type, schema.find,
-        )
-        null_keys = schema.null_fields()
-        if null_keys:
-            logger.warning("⚠️  [VERIFIER] Null fields: %s", null_keys)
-
-        try:
-            method_name = self._DISPATCH.get(schema.problem_type)
-            if method_name:
-                getattr(self, method_name)(schema)
-            else:
-                schema.warnings.append(f"No verifier for problem_type='{schema.problem_type}'")
-                schema.verification_status = "partial"
-        except Exception as e:
-            logger.error("❌ [VERIFIER] Unexpected error: %s", e)
-            schema.warnings.append(f"Verifier internal error: {e}")
-            schema.verification_status = "partial"
-
-        logger.info(
-            "✅ [VERIFIER] Done. status=%s | verified=%s | warnings=%d",
-            schema.verification_status,
-            list(schema.verified.keys()),
-            len(schema.warnings),
-        )
-        return schema
-
-    # ── GEOMETRY ─────────────────────────────────────────────────────────
-    def _verify_geometry(self, schema: MathProblemSchema) -> None:
-        g = schema.given
-        verified = {}
-        sub = schema.sub_type.lower()
-        if "circle" in sub:
-            self._verify_circle(schema, g, verified)
-        elif any(k in sub for k in ("line", "linear", "segment")):
-            self._verify_linear(schema, g, verified)
-        else:
-            schema.warnings.append(f"No geometry handler for sub_type='{schema.sub_type}'")
-            schema.verification_status = "partial"
-
-    def _verify_circle(self, schema: MathProblemSchema, g: dict, verified: dict) -> None:
-        """
-        PRIORITY 1: diameter_lines → center = algebraic intersection.
-        PRIORITY 2: diameter chord → midpoint (only if no lines given).
-        """
-        import re as _re
-
-        # ═══════════════════════════════════════════════════════════════
-        # PRIORITY 1: Diameter line equations — MANDATORY if present
-        # ═══════════════════════════════════════════════════════════════
-        diameter_lines = g.get("diameter_lines")
-        if diameter_lines and len(diameter_lines) >= 2:
-            logger.info(
-                "🔑 [VERIFIER/circle] diameter_lines detected — using intersection method"
-            )
-            center, method = _find_center_from_diameter_lines(diameter_lines, schema)
-            if center is not None:
-                cx, cy = float(center.x), float(center.y)
-                verified["M"] = (cx, cy)
-                verified["center"] = (cx, cy)
-                verified["center_method"] = "diameter_line_intersection"
-                verified["verification_method"] = "diameter_line_intersection"
-                schema.verified.update(verified)
-                logger.info(
-                    "✅ [VERIFIER/circle] M = (%s, %s) via %s (method=diameter_line_intersection)",
-                    cx, cy, method,
-                )
-
-                # Verify radius from a known point
-                _compute_radius_from_center(g, center, verified, schema)
-                schema.verified.update(verified)
-
-                # Cross-check if radius also given
-                given_r = g.get("radius")
-                if given_r and "radius" in verified:
-                    if abs(float(given_r) - verified["radius"]) > 1e-6:
-                        schema.warnings.append(
-                            f"CONTRADICTION: given radius={given_r} vs "
-                            f"computed={verified['radius']:.4f}"
-                        )
-                        schema.verification_status = "contradiction"
-                        return
-
-                schema.verification_status = "partial" if schema.null_fields() else "verified"
-                return
-            else:
-                schema.warnings.append(
-                    f"diameter_lines parsing/solve failed: {method} — falling back to chord"
-                )
-
-        # ═══════════════════════════════════════════════════════════════
-        # PRIORITY 2: Midpoint of diameter chord (FALLBACK)
-        # ═══════════════════════════════════════════════════════════════
-        points = {}
-        for k, v in g.items():
-            if v is None:
-                continue
-            p = _to_point(v)
-            if p:
-                points[k] = p
-
-        radius_raw = g.get("radius")
-        radius = _to_rational(radius_raw)
-
-        diameter_pairs: List[Tuple[str, str]] = []
-        has_diameter_constraint = False
-        for c in schema.constraints:
-            if "diameter" in c.lower():
-                has_diameter_constraint = True
-                labels = _re.findall(r"\b([A-Za-z]{1,2})\b", c)
-                matched = [lbl for lbl in labels if lbl in points]
-                if len(matched) >= 2:
-                    diameter_pairs.append((matched[0], matched[1]))
-
-        # Auto-pick first 2 points if labels ambiguous
-        if not diameter_pairs and has_diameter_constraint and len(points) >= 2:
-            keys = list(points.keys())
-            diameter_pairs.append((keys[0], keys[1]))
-            logger.info(
-                "📐 [VERIFIER/circle/fallback] Using points %s, %s as diameter chord",
-                keys[0], keys[1],
-            )
-
-        if not diameter_pairs:
-            msg = "No diameter_lines and no named diameter chord — insufficient data"
-            schema.warnings.append(msg)
-            schema.verification_status = "insufficient_data"
-            return
-
-        for p1_label, p2_label in diameter_pairs:
-            p1, p2 = points[p1_label], points[p2_label]
-            cx = (p1.x + p2.x) / 2
-            cy = (p1.y + p2.y) / 2
-            center = sp.Point2D(cx, cy)
-            computed_radius = p1.distance(p2) / 2
-
-            verified["center"] = (float(cx), float(cy))
-            verified["M"] = (float(cx), float(cy))
-            verified["radius"] = float(computed_radius)
-            verified["center_method"] = "chord_midpoint_fallback"
-            verified["verification_method"] = "chord_midpoint_fallback"
-            schema.verified.update(verified)
-
-            logger.info(
-                "📐 [VERIFIER/circle/fallback] midpoint(%s,%s) → center=%s radius=%s [FALLBACK — status=partial]",
-                p1_label, p2_label, center, computed_radius,
-            )
-
-            if radius is not None and abs(float(computed_radius) - float(radius)) > 1e-6:
-                msg = (
-                    f"CONTRADICTION: given radius={radius_raw} but "
-                    f"computed from chord {p1_label}{p2_label}={float(computed_radius):.4f}"
-                )
-                schema.warnings.append(msg)
-                logger.error("🚨 [VERIFIER/circle] %s", msg)
-                schema.verification_status = "contradiction"
-                return
-
-            for label, pt in points.items():
-                if label in (p1_label, p2_label):
-                    continue
-                dist = float(pt.distance(center))
-                r = float(computed_radius)
-                if abs(dist - r) < 1e-6:
-                    verified[f"{label}_on_circle"] = True
-                else:
-                    schema.warnings.append(
-                        f"Point {label} NOT on circle (dist={dist:.4f}, r={r:.4f})"
-                    )
-
-        schema.verified.update(verified)
-        # Chord midpoint fallback is always partial — center is unconfirmed without lines
-        if schema.verified.get("center_method") == "chord_midpoint_fallback":
-            schema.verification_status = "partial"
-        else:
-            schema.verification_status = "partial" if schema.null_fields() else "verified"
-
-    def _verify_linear(self, schema: MathProblemSchema, g: dict, verified: dict) -> None:
-        schema.warnings.append("Linear geometry verifier: basic — extend as needed")
-        schema.verification_status = "partial"
-
-    # ── ALGEBRA ──────────────────────────────────────────────────────────
-    def _verify_algebra(self, schema: MathProblemSchema) -> None:
-        g = schema.given
-        verified = schema.verified
-        equation_str = g.get("equation")
-        if equation_str is None:
-            schema.warnings.append("Algebra: 'equation' is null")
-            schema.verification_status = "insufficient_data"
-            return
-        try:
-            if "=" in str(equation_str):
-                lhs_s, rhs_s = str(equation_str).split("=", 1)
-                x = sp.Symbol("x")
-                expr = sp.sympify(lhs_s.strip()) - sp.sympify(rhs_s.strip())
-            else:
-                x = sp.Symbol("x")
-                expr = sp.sympify(str(equation_str))
-            solutions = sp.solve(expr, x)
-            verified["solutions"] = [str(s) for s in solutions]
-            verified["verification_method"] = "sympy_solve_substitution"
-            logger.info("📐 [VERIFIER/algebra] Solutions: %s (method=sympy_solve_substitution)", solutions)
-            given_solution = g.get("solution")
-            if given_solution is not None:
-                given_val = sp.Rational(given_solution)
-                if given_val not in solutions:
-                    schema.warnings.append(
-                        f"CONTRADICTION: given solution={given_solution} not in {solutions}"
-                    )
-                    schema.verification_status = "contradiction"
-                    return
-            schema.verification_status = "partial" if schema.null_fields() else "verified"
-        except Exception as e:
-            schema.warnings.append(f"Algebra verifier error: {e}")
-            schema.verification_status = "partial"
-
-    # ── PROBABILITY ───────────────────────────────────────────────────────
-    def _verify_probability(self, schema: MathProblemSchema) -> None:
-        g = schema.given
-        verified = schema.verified
-        probs = g.get("probabilities")
-        if probs is None:
-            schema.warnings.append("Probability: 'probabilities' is null")
-            schema.verification_status = "insufficient_data"
-            return
-        try:
-            total = sum(sp.Rational(str(p)) for p in probs)
-            verified["sum"] = float(total)
-            verified["verification_method"] = "sympy_rational_sum"
-            logger.info("📐 [VERIFIER/probability] sum=%s (method=sympy_rational_sum)", float(total))
-            if total != 1:
-                schema.warnings.append(
-                    f"CONTRADICTION: probabilities sum to {float(total):.4f}, not 1.0"
-                )
-                schema.verification_status = "contradiction"
-            else:
-                schema.verification_status = "verified"
-        except Exception as e:
-            schema.warnings.append(f"Probability verifier error: {e}")
-            schema.verification_status = "partial"
-
-    # ── STATISTICS ────────────────────────────────────────────────────────
-    def _verify_statistics(self, schema: MathProblemSchema) -> None:
-        import numpy as np
-        g = schema.given
-        verified = schema.verified
-        data = g.get("data")
-        if data is None:
-            schema.warnings.append("Statistics: 'data' is null")
-            schema.verification_status = "insufficient_data"
-            return
-        try:
-            arr = np.array([float(x) for x in data])
-            verified["mean"] = float(np.mean(arr))
-            verified["std"] = float(np.std(arr, ddof=0))
-            verified["verification_method"] = "numpy_population_stats"
-            logger.info(
-                "📐 [VERIFIER/statistics] mean=%.4f std=%.4f (method=numpy_population_stats)",
-                verified["mean"], verified["std"],
-            )
-            for key in ("mean", "std"):
-                given_val = g.get(key)
-                if given_val is not None and abs(float(given_val) - verified[key]) > 1e-6:
-                    schema.warnings.append(
-                        f"CONTRADICTION: given {key}={given_val} vs computed={verified[key]:.6f}"
-                    )
-                    schema.verification_status = "contradiction"
-                    return
-            schema.verification_status = "verified"
-        except Exception as e:
-            schema.warnings.append(f"Statistics verifier error: {e}")
-            schema.verification_status = "partial"
-
-    # ── TRIGONOMETRY ──────────────────────────────────────────────────────
-    def _verify_trigonometry(self, schema: MathProblemSchema) -> None:
-        g = schema.given
-        verified = schema.verified
-        identity = g.get("identity")
-        angle_deg = g.get("angle_deg")
-        if identity is None:
-            schema.warnings.append("Trigonometry: 'identity' is null")
-            schema.verification_status = "insufficient_data"
-            return
-        try:
-            theta = sp.Symbol("theta")
-            lhs_s, rhs_s = str(identity).split("=", 1)
-            lhs = sp.sympify(lhs_s.strip())
-            rhs = sp.sympify(rhs_s.strip())
-            diff = sp.simplify(lhs - rhs)
-            if diff == 0:
-                verified["identity_valid"] = True
-                verified["verification_method"] = "sympy_symbolic_simplification"
-                logger.info("✅ [VERIFIER/trig] Identity valid (method=sympy_symbolic_simplification)")
-                schema.verification_status = "verified"
-            elif angle_deg is not None:
-                angle_rad = sp.Rational(angle_deg) * sp.pi / 180
-                val = float(diff.subs(theta, angle_rad))
-                verified["identity_at_angle"] = (abs(val) < 1e-9)
-                schema.verification_status = "partial" if abs(val) < 1e-9 else "contradiction"
-            else:
-                schema.warnings.append("Trig identity could not be simplified to zero")
-                schema.verification_status = "partial"
-        except Exception as e:
-            schema.warnings.append(f"Trigonometry verifier error: {e}")
-            schema.verification_status = "partial"
-
-    # ── CALCULUS ──────────────────────────────────────────────────────────
-    def _verify_calculus(self, schema: MathProblemSchema) -> None:
-        g = schema.given
-        verified = schema.verified
-        func_str = g.get("function")
-        point_raw = g.get("point")
-        if func_str is None:
-            schema.warnings.append("Calculus: 'function' is null")
-            schema.verification_status = "insufficient_data"
-            return
-        try:
-            x = sp.Symbol("x")
-            f = sp.sympify(str(func_str))
-            deriv = sp.diff(f, x)
-            verified["derivative"] = str(deriv)
-            verified["verification_method"] = "sympy_differentiation"
-            logger.info("📐 [VERIFIER/calculus] f'(x)=%s (method=sympy_differentiation)", deriv)
-            if point_raw is not None:
-                pt = _to_rational(point_raw)
-                val = float(deriv.subs(x, pt))
-                verified["derivative_at_point"] = val
-                given_dv = g.get("derivative_at_point")
-                if given_dv is not None and abs(float(given_dv) - val) > 1e-9:
-                    schema.warnings.append(
-                        f"CONTRADICTION: given f'({point_raw})={given_dv} vs computed={val:.6f}"
-                    )
-                    schema.verification_status = "contradiction"
-                    return
-            schema.verification_status = "verified"
-        except Exception as e:
-            schema.warnings.append(f"Calculus verifier error: {e}")
-            schema.verification_status = "partial"
-
-
-# ── Module-level helpers ──────────────────────────────────────────────────
-def _find_center_from_diameter_lines(
-    diameter_lines: list,
-    schema: "MathProblemSchema",
-) -> Tuple[Optional[sp.Point2D], str]:
-    """
-    Solve the intersection of two diameter line equations.
-    Returns (sp.Point2D, description) or (None, reason).
-    """
-    if len(diameter_lines) < 2:
-        return None, "need at least 2 diameter lines"
-
-    x, y = sp.symbols("x y")
-
-    def _parse_line(eq_str: str) -> Optional[sp.Eq]:
-        eq_str = str(eq_str).strip().replace(" ", "")
-        if "=" not in eq_str:
-            return None
-        lhs_s, rhs_s = eq_str.split("=", 1)
-        try:
-            return sp.Eq(sp.sympify(lhs_s), sp.sympify(rhs_s))
-        except Exception as e:
-            logger.error("❌ [VERIFIER/diameters] Cannot parse '%s': %s", eq_str, e)
-            return None
-
-    eq1 = _parse_line(diameter_lines[0])
-    eq2 = _parse_line(diameter_lines[1])
-
-    if eq1 is None or eq2 is None:
-        return None, "line parsing failed"
-
-    logger.info(
-        "📐 [VERIFIER/diameters] Solving:\n  L1=%s\n  L2=%s", eq1, eq2
-    )
-
-    try:
-        sol = sp.solve([eq1, eq2], [x, y])
-        if not sol:
-            schema.warnings.append("Diameter lines are parallel — no intersection")
-            return None, "parallel lines"
-
-        if isinstance(sol, dict):
-            cx, cy = sol[x], sol[y]
-        elif isinstance(sol, (list, tuple)) and sol:
-            first = sol[0]
-            cx, cy = first[0], first[1]
-        else:
-            return None, "unexpected solution format"
-
-        center = sp.Point2D(cx, cy)
-        logger.info("✅ [VERIFIER/diameters] Center = (%s, %s)", cx, cy)
-        return center, f"intersection of {diameter_lines[0]} ∩ {diameter_lines[1]}"
-
-    except Exception as e:
-        logger.error("❌ [VERIFIER/diameters] Solve error: %s", e)
-        return None, f"solve error: {e}"
-
-
-def _compute_radius_from_center(
-    g: dict, center: sp.Point2D, verified: dict, schema: "MathProblemSchema"
-) -> None:
-    """Compute radius as distance from center to the first known point."""
-    for k, v in g.items():
-        if k in ("diameter_lines", "radius"):
-            continue
-        if v is None:
-            continue
-        p = _to_point(v)
-        if p:
-            r = float(p.distance(center))
-            verified["radius"] = r
-            logger.info("📐 [VERIFIER/circle] radius = dist(%s, center) = %.4f", k, r)
-            return
-    # Fallback: use given radius
-    given_r = g.get("radius")
-    if given_r is not None:
-        verified["radius"] = float(given_r)
diff --git a/backend/variable_pinner.py b/backend/variable_pinner.py
deleted file mode 100644
index 9681ee55b27a1be47373d209d6a1389df6a15742..0000000000000000000000000000000000000000
--- a/backend/variable_pinner.py
+++ /dev/null
@@ -1,113 +0,0 @@
-# backend/variable_pinner.py
-# BuddyMath V2.0 — Stage 3: Variable Pinning
-#
-# PURPOSE:
-# Converts verified data from MathProblemSchema into a hard constraint block
-# that is injected into the LLM's prompt as GROUND TRUTH.
-#
-# THE MESSAGE TO THE LLM (verbatim from spec):
-# "The values below were verified algebraically. They are Ground Truth.
-#  Do NOT recalculate them. If your intuition contradicts them — the table is correct."
-# ─────────────────────────────────────────────────────────────────────────
-
-from __future__ import annotations
-
-import logging
-from typing import Optional
-
-from backend.math_schema import MathProblemSchema
-
-logger = logging.getLogger(__name__)
-
-_PIN_HEADER = """
-╔══════════════════════════════════════════════════════════════════════╗
-║           🔒  ALGEBRAICALLY VERIFIED — GROUND TRUTH                 ║
-║   The values below were computed deterministically (SymPy).         ║
-║   DO NOT recalculate them. DO NOT trust visual intuition over them. ║
-║   If your reasoning contradicts any value here — the table wins.    ║
-╚══════════════════════════════════════════════════════════════════════╝
-""".strip()
-
-_NULL_WARNING = """
-⚠️  INSUFFICIENT_DATA WARNING:
-    The following fields could NOT be verified due to unclear OCR/input:
-{null_list}
-    For these fields, reason carefully from the available constraints.
-    DO NOT invent values. State explicitly that these are assumed/estimated.
-""".strip()
-
-_CONTRADICTION_WARNING = """
-🚨  CONTRADICTION DETECTED:
-    The verifier found inconsistencies between the extracted data and
-    algebraic facts. Proceed with the ALGEBRAICALLY COMPUTED values,
-    NOT the extracted ones.
-""".strip()
-
-
-class VariablePinner:
-    """
-    Generates the pinning block that is injected into the LLM prompt
-    BEFORE the main pedagogical reasoning begins.
-    """
-
-    def build_pin_block(self, schema: MathProblemSchema) -> str:
-        """
-        Build the full pinning block string.
-
-        This string must be injected into the LLM prompt verbatim,
-        before the main solver / explainer instruction.
-
-        Returns:
-            str: Formatted pinning block ready for prompt injection.
-        """
-        lines: list[str] = [_PIN_HEADER, ""]
-
-        # ── Status-specific header ────────────────────────────────────
-        if schema.verification_status == "contradiction":
-            lines.append(_CONTRADICTION_WARNING)
-            lines.append("")
-        elif schema.verification_status == "insufficient_data":
-            null_keys = schema.null_fields()
-            null_list = "\n".join(f"    • {k}" for k in null_keys)
-            lines.append(_NULL_WARNING.format(null_list=null_list))
-            lines.append("")
-
-        # ── Verified facts table ──────────────────────────────────────
-        if schema.verified:
-            lines.append("📌 PINNED VALUES (Ground Truth):")
-            for key, val in schema.verified.items():
-                lines.append(f"   {key:30s} = {val}")
-            lines.append("")
-
-        # ── What to find ─────────────────────────────────────────────
-        if schema.find:
-            lines.append("🎯 QUESTION TARGETS (what to find):")
-            for target in schema.find:
-                lines.append(f"   • {target}")
-            lines.append("")
-
-        # ── Constraints ───────────────────────────────────────────────
-        if schema.constraints:
-            lines.append("📋 PROBLEM CONSTRAINTS:")
-            for c in schema.constraints:
-                lines.append(f"   • {c}")
-            lines.append("")
-
-        # ── Non-fatal warnings ────────────────────────────────────────
-        if schema.warnings:
-            lines.append("⚠️  WARNINGS (for LLM awareness):")
-            for w in schema.warnings:
-                lines.append(f"   ! {w}")
-            lines.append("")
-
-        pin_block = "\n".join(lines)
-
-        logger.info(
-            "📌 [PINNER] Built pin block | status=%s | pinned_keys=%s | null_fields=%s",
-            schema.verification_status,
-            list(schema.verified.keys()),
-            schema.null_fields(),
-        )
-        logger.debug("📌 [PINNER] Full block:\n%s", pin_block)
-
-        return pin_block
diff --git a/config.py b/config.py
deleted file mode 100644
index 99514dfece9da00d20336b527e06089f4dadb269..0000000000000000000000000000000000000000
--- a/config.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# config.py - V1.1 (Central Config - Force Rebuild)
-import os
-from dotenv import load_dotenv
-
-# Load environment variables from .env file
-load_dotenv()
-
-# Determine Environment
-# V5.9.3: Detailed logging for Hugging Face environment detection
-raw_env = os.getenv("ENV", "").lower()
-space_id = os.getenv("SPACE_ID", "").lower()
-
-print(f"🔍 [DEBUG-CONFIG] raw_env: '{raw_env}', space_id: '{space_id}'")
-
-if not raw_env:
-    # Check for keywords that indicate a dev space
-    if any(k in space_id for k in ["buddymath-dev", "-dev", "sandbox"]):
-        ENV = "development"
-        print(f"✨ [DEBUG-CONFIG] Auto-detected DEVELOPMENT mode (space_id match).")
-    else:
-        ENV = "production"
-        print(f"🛡️ [DEBUG-CONFIG] Defaulting to PRODUCTION mode.")
-else:
-    ENV = raw_env
-    print(f"📍 [DEBUG-CONFIG] Using explicit ENV from settings: {ENV}")
-
-IS_PRODUCTION = ENV == "production"
-
-# V5.9.1: DEV Auth Bypass Token (Whitelisted only in non-prod environments)
-DEV_BYPASS_TOKEN = "BUDDY-MATH-DEV-2026-BYPASS"
-
-# Firebase Configuration
-# V5.11.3: DEPRECATED local JSON files for security. 
-# Credentials must be provided via FIREBASE_CREDENTIALS environment variable.
-if IS_PRODUCTION:
-    # PROD: bussymath
-    FIREBASE_CREDENTIALS_PATH = None 
-    STORAGE_BUCKET = "bussymath.firebasestorage.app"
-    PROJECT_ID = "bussymath"
-else:
-    # DEV: buddy-math-dev
-    FIREBASE_CREDENTIALS_PATH = None
-    STORAGE_BUCKET = "buddy-math-dev.firebasestorage.app"
-    PROJECT_ID = "buddy-math-dev"
-
-# Server Configuration
-HOST = "0.0.0.0"
-PORT = 8000 if not IS_PRODUCTION else 7860 # HF Spaces/Cloud Run often use 7860 or PORT env
-
-# V3.1.2: Adaptive Failure Mode - Confidence Thresholds
-# V3.1.3: Recalibrated (Hard Floor 0.55)
-# V4.2.11: Lowered for DEV to unblock geometry diagnostics
-CONFIDENCE_THRESHOLD_HIGH = 0.75
-CONFIDENCE_THRESHOLD_MEDIUM = 0.55 if IS_PRODUCTION else 0.01
-
-print(f"[CONFIG] Loading {ENV.upper()} configuration.")
-print(f"[CONFIG] Project: {PROJECT_ID}")
-print(f"[CONFIG] Bucket: {STORAGE_BUCKET}")
- 
-# V3.1.3: Model Hardening - Restricted to gemini-2.0-flash ONLY
-# To change model, update the environment variable 'GEMINI_MODEL'
-GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.0-flash")
-print(f"[CONFIG] Active Model: {GEMINI_MODEL}")
diff --git a/constraint_checks.py b/constraint_checks.py
deleted file mode 100644
index 8ee51e1c3369e9f386f589c7ee5bd76f82c96cdb..0000000000000000000000000000000000000000
--- a/constraint_checks.py
+++ /dev/null
@@ -1,159 +0,0 @@
-# constraint_checks.py - V1.0 (Geometric Constraint Validator)
-# Deterministic algebraic checks using SymPy.
-# Each function verifies a specific geometric relationship and logs
-# the result to the GeometryAnchor (verified_facts or warnings).
-
-import logging
-from sympy import simplify, symbols, Eq, solve, Rational
-
-from geometry_types import Point, Line, Segment, Circle, GeometryAnchor
-
-logger = logging.getLogger(__name__)
-
-
-def check_point_on_circle(p: Point, circle: Circle, anchor: GeometryAnchor):
-    """
-    Verifies algebraically whether point p lies on the circle boundary.
-    Injects a verified_fact or a warning into the anchor.
-    """
-    try:
-        if circle.contains(p):
-            anchor.add_fact(
-                f"✓ הנקודה {p} נמצאת על המעגל (מרכז {circle.center}, r={circle.radius})"
-            )
-        else:
-            lhs = (p.x - circle.center.x)**2 + (p.y - circle.center.y)**2
-            anchor.add_warning(
-                f"✗ הנקודה {p} אינה על המעגל — "
-                f"חישוב: {simplify(lhs)} ≠ r²={simplify(circle.radius**2)}. "
-                f"ייתכן שה-OCR חילץ קואורדינטות שגויות."
-            )
-    except Exception as e:
-        logger.error(f"[CONSTRAINT] check_point_on_circle failed: {e}")
-        anchor.add_warning(f"⚠️ לא ניתן לאמת שהנקודה {p.name} על המעגל: {e}")
-
-
-def check_point_on_line(p: Point, line: Line, anchor: GeometryAnchor):
-    """
-    Verifies algebraically whether point p lies on the line ax + by + c = 0.
-    """
-    try:
-        if line.contains(p):
-            anchor.add_fact(
-                f"✓ הנקודה {p} נמצאת על הישר {line}"
-            )
-        else:
-            val = simplify(line.a * p.x + line.b * p.y + line.c)
-            anchor.add_warning(
-                f"✗ הנקודה {p} אינה על הישר {line} — "
-                f"הצבה נותנת {val} ≠ 0"
-            )
-    except Exception as e:
-        logger.error(f"[CONSTRAINT] check_point_on_line failed: {e}")
-        anchor.add_warning(f"⚠️ לא ניתן לאמת שהנקודה {p.name} על הישר: {e}")
-
-
-def check_is_diameter(segment: Segment, circle: Circle, anchor: GeometryAnchor):
-    """
-    Checks if a segment is a diameter by verifying its midpoint equals the circle center.
-    This is the most critical check for preventing midpoint hallucination.
-    """
-    try:
-        mid = segment.midpoint()
-        center = circle.center
-        if mid == center:
-            anchor.add_fact(
-                f"✓ הקטע {segment.p1.name}{segment.p2.name} הוא קוטר — "
-                f"אמצעו {mid} = מרכז המעגל {center}"
-            )
-        else:
-            anchor.add_warning(
-                f"✗ הקטע {segment.p1.name}{segment.p2.name} אינו קוטר — "
-                f"אמצע הקטע הוא {mid}, אך מרכז המעגל הוא {center}. "
-                f"⚠️ אל תניח שמרכז המעגל הוא נקודת האמצע של קטע זה!"
-            )
-    except Exception as e:
-        logger.error(f"[CONSTRAINT] check_is_diameter failed: {e}")
-        anchor.add_warning(f"⚠️ לא ניתן לאמת האם הקטע {segment} הוא קוטר: {e}")
-
-
-def check_perpendicular_lines(slope1, slope2, anchor: GeometryAnchor, label1="ישר 1", label2="ישר 2"):
-    """
-    Verifies that two lines (given by slopes) are perpendicular: m1 * m2 = -1.
-    """
-    try:
-        product = simplify(slope1 * slope2)
-        if product == -1:
-            anchor.add_fact(
-                f"✓ {label1} ו-{label2} מאונכים — מכפלת שיפועים = {product} = -1"
-            )
-        else:
-            anchor.add_warning(
-                f"✗ {label1} ו-{label2} אינם מאונכים — מכפלת שיפועים = {product} ≠ -1"
-            )
-    except Exception as e:
-        logger.error(f"[CONSTRAINT] check_perpendicular_lines failed: {e}")
-        anchor.add_warning(f"⚠️ לא ניתן לאמת אנכיות: {e}")
-
-
-def find_circle_center_from_diameters(
-    d1: Segment,
-    d2: Segment,
-    anchor: GeometryAnchor
-) -> Point:
-    """
-    Finds the circle center deterministically as the intersection of two diameter segments.
-    This eliminates any need for the LLM to 'guess' the center.
-    """
-    try:
-        x, y = symbols('x y')
-
-        def line_eq_through(p1: Point, p2: Point):
-            if simplify(p2.x - p1.x) == 0:
-                # Vertical line
-                return Eq(x, p1.x)
-            slope = Rational(p2.y - p1.y, p2.x - p1.x)
-            return Eq(y, slope * (x - p1.x) + p1.y)
-
-        eq1 = line_eq_through(d1.p1, d1.p2)
-        eq2 = line_eq_through(d2.p1, d2.p2)
-
-        solution = solve([eq1, eq2], [x, y])
-
-        if not solution:
-            anchor.add_warning(
-                "[SOLVER] לא ניתן לחשב מרכז מעגל מחיתוך שני קטרים — הישרים מקבילים?"
-            )
-            return None
-
-        cx = solution[x] if isinstance(solution, dict) else solution[0]
-        cy = solution[y] if isinstance(solution, dict) else solution[1]
-        center = Point(name="M", x=simplify(cx), y=simplify(cy))
-        anchor.add_fact(
-            f"✓ מרכז המעגל M חושב כחיתוך קטרים: M = {center}"
-        )
-        return center
-
-    except Exception as e:
-        logger.error(f"[CONSTRAINT] find_circle_center_from_diameters failed: {e}")
-        anchor.add_warning(f"⚠️ חישוב מרכז ממעגל נכשל: {e}")
-        return None
-
-
-def check_distance(p1: Point, p2: Point, expected_distance, anchor: GeometryAnchor, label=""):
-    """
-    Verifies the distance between two points matches an expected value.
-    """
-    try:
-        actual = simplify(p1.distance_to(p2))
-        expected = simplify(expected_distance)
-        desc = label or f"{p1.name}↔{p2.name}"
-        if simplify(actual - expected) == 0:
-            anchor.add_fact(f"✓ המרחק {desc} = {actual} (תואם לנתון)")
-        else:
-            anchor.add_warning(
-                f"✗ המרחק {desc}: חישוב={actual} ≠ נתון={expected}"
-            )
-    except Exception as e:
-        logger.error(f"[CONSTRAINT] check_distance failed: {e}")
-        anchor.add_warning(f"⚠️ בדיקת מרחק נכשלה: {e}")
diff --git a/cost_tracker.py b/cost_tracker.py
deleted file mode 100644
index 5e34fb27e42a85dec4a7a3dd2596a42079bde8f7..0000000000000000000000000000000000000000
--- a/cost_tracker.py
+++ /dev/null
@@ -1,93 +0,0 @@
-PRICING = { "input": 0.10, "output": 0.40 }
-
-class CostTracker:
-    def __init__(self):
-        self.input_tokens = 0
-        self.output_tokens = 0
-
-    def add(self, usage_metadata):
-        if usage_metadata:
-            self.input_tokens += getattr(usage_metadata, 'prompt_token_count', 0)
-            self.output_tokens += getattr(usage_metadata, 'candidates_token_count', 0)
-
-    def add_manual(self, inp, out):
-        self.input_tokens += inp
-        self.output_tokens += out
-
-    def get_cost(self):
-        return (self.input_tokens / 1e6 * PRICING["input"]) + (self.output_tokens / 1e6 * PRICING["output"])
-
-    def get_summary(self): # ✅ הפונקציה שהייתה חסרה
-        return {
-            "input_tokens": self.input_tokens,
-            "output_tokens": self.output_tokens,
-            "cost_usd": self.get_cost()
-        }
-
-    def print_report(self):
-        print(f"💰 COST: ${self.get_cost():.6f}")
-
-# Static Logger
-import os
-import json
-import time
-import tempfile
-
-# V260.9: Smarter logging path
-def get_log_file_path():
-    base_dir = os.path.join(os.getcwd(), "logs")
-    # Try creating/accessing local logs dir
-    try:
-        if not os.path.exists(base_dir):
-            os.makedirs(base_dir)
-        # Test write permission
-        test_file = os.path.join(base_dir, ".test_write")
-        with open(test_file, "w") as f: f.write("ok")
-        os.remove(test_file)
-        return os.path.join(base_dir, "usage.jsonl")
-    except (PermissionError, OSError):
-        # Fallback to temp
-        return os.path.join(tempfile.gettempdir(), "buddy_math_usage.jsonl")
-
-LOG_FILE = get_log_file_path()
-LOG_DIR = os.path.dirname(LOG_FILE)
-
-import contextvars
-
-# Stores the total tokens used in the current solve request
-current_request_tokens = contextvars.ContextVar('current_request_tokens', default=0)
-
-def log_api_usage(usage_metadata, source="unknown"):
-    """Log API usage to proper location and add to current ContextVar"""
-    if not usage_metadata:
-        return
-
-    try:
-        # LOG_DIR check is now redundant but safe
-        if not os.path.exists(LOG_DIR):
-            os.makedirs(LOG_DIR, exist_ok=True)
-            
-        entry = {
-            "timestamp": time.time(),
-            "source": source,
-            "input_tokens": getattr(usage_metadata, 'prompt_token_count', 0),
-            "output_tokens": getattr(usage_metadata, 'candidates_token_count', 0),
-            "total_tokens": getattr(usage_metadata, 'total_token_count', 0)
-        }
-        
-        with open(LOG_FILE, "a", encoding="utf-8") as f:
-            f.write(json.dumps(entry) + "\n")
-            
-        # Update the ContextVar for the current request
-        try:
-            current_request_tokens.set(current_request_tokens.get() + entry["total_tokens"])
-        except Exception:
-            pass
-
-        # Also print to stdout for immediate visibility in console logs
-        print(f"💰 [USAGE] {source}: In={entry['input_tokens']}, Out={entry['output_tokens']}")
-        
-    except Exception as e:
-        # Fallback to pure stdout if file logging completely fails
-        print(f"💰 [USAGE-STDOUT only] {source}: In={getattr(usage_metadata, 'prompt_token_count', 0)}, Out={getattr(usage_metadata, 'candidates_token_count', 0)}")
-        print(f"⚠️ [USAGE LOG ERROR] Failed to log to file {LOG_FILE}: {e}")
\ No newline at end of file
diff --git a/create_mock_user.py b/create_mock_user.py
deleted file mode 100644
index 3aea8509bee4f5eb62a1a83d937e21f46edb5d69..0000000000000000000000000000000000000000
--- a/create_mock_user.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import firebase_admin
-from firebase_admin import credentials, firestore
-import json
-import os
-
-# Manual init for script
-FIREBASE_CREDENTIALS_PATH = "serviceAccountKey.json"
-STORAGE_BUCKET = "bussymath.firebasestorage.app"
-
-if not firebase_admin._apps:
-    with open(FIREBASE_CREDENTIALS_PATH, "r", encoding="utf-8") as f:
-        cred_dict = json.load(f)
-    cred = credentials.Certificate(cred_dict)
-    firebase_admin.initialize_app(cred, {
-        'storageBucket': STORAGE_BUCKET
-    })
-
-db = firestore.client()
-
-def create_mock_user():
-    uid = "dev-bypass-user"
-    user_ref = db.collection('users').document(uid)
-    
-    today = "2026-03-12" # Static for bypass
-    month = "2026-03"
-    
-    user_data = {
-        'uid': uid,
-        'name': 'Dev Bypass User',
-        'status': 'approved',
-        'tier': 'student_premium',
-        'used_today': 0,
-        'used_tokens_this_month': 0,
-        'monthly_token_budget': 9999999,
-        'last_usage_month': month,
-        'quota': {
-            'limit': 9999,
-            'used_today': 0,
-            'last_reset_date': today,
-        },
-        'isAdmin': True,
-        'role': 'admin'
-    }
-    
-    user_ref.set(user_data, merge=True)
-    print(f"✅ Created mock user: {uid}")
-
-if __name__ == "__main__":
-    create_mock_user()
diff --git a/curriculum_engine.py b/curriculum_engine.py
deleted file mode 100644
index 102e7ed9ccc43e18061bbea210e7d77eaa58ff83..0000000000000000000000000000000000000000
--- a/curriculum_engine.py
+++ /dev/null
@@ -1,115 +0,0 @@
-# curriculum_engine.py - V4.0 (Curriculum Oracle)
-# Defines pedagogical boundaries according to the Israeli Ministry of Education (Mafmar).
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-CURRICULUM_RULES = {
-    # grade: { blacklist: [operators], whitelist: [operators], descriptions: {operator: hebrew_name} }
-    7: {
-        "blacklist": ["SYSTEM_OF_EQUATIONS", "QUADRATIC_EQUATION", "DERIVATIVE", "INTEGRAL", "TRIGONOMETRY"],
-        "whitelist": ["LINEAR_EQUATION", "FRACTIONS", "EXPONENTS_BASIC", "PERCENTAGES"],
-        "descriptions": {
-            "SYSTEM_OF_EQUATIONS": "מערכת משוואות בשני נעלמים",
-            "QUADRATIC_EQUATION": "משוואה ריבועית",
-            "DERIVATIVE": "נגזרות",
-            "TRIGONOMETRY": "טריגונומטריה"
-        }
-    },
-    8: {
-        "blacklist": ["QUADRATIC_EQUATION", "DERIVATIVE", "INTEGRAL", "TRIG_Trig_ADVANCED"],
-        "whitelist": ["LINEAR_EQUATION", "SYSTEM_OF_EQUATIONS", "BASIC_GEOMETRY", "PYTHAGOREAN_THEOREM"],
-        "descriptions": {
-            "QUADRATIC_EQUATION": "משוואה ריבועית",
-            "DERIVATIVE": "נגזרות"
-        }
-    },
-    9: {
-        "blacklist": ["DERIVATIVE", "INTEGRAL", "LOGARITHM"],
-        "whitelist": ["QUADRATIC_EQUATION", "SYSTEM_OF_EQUATIONS", "SIMILAR_TRIANGLES", "CIRCLE_BASIC"],
-        "descriptions": {
-            "DERIVATIVE": "נגזרות",
-            "LOGARITHM": "לוגריתמים"
-        }
-    },
-    10: {
-        "blacklist": ["INTEGRAL_ADVANCED", "VECTORS"],
-        "whitelist": ["DERIVATIVE_POLYNOMIAL", "TRIGONOMETRY_BASIC", "CIRCLE_EQUATION_BASIC"],
-        "descriptions": {
-            "INTEGRAL_ADVANCED": "אינטגרלים מורכבים",
-            "VECTORS": "ווקטורים"
-        }
-    },
-    # V286.0: Grade 11 — 4 יח"ל focus
-    11: {
-        "blacklist": ["VECTORS_3D", "ADVANCED_INTEGRATION", "SOLID_GEOMETRY_ADVANCED"],
-        "whitelist": ["DERIVATIVE", "TRIGONOMETRY", "LOGARITHM", "SEQUENCES", "COMPLEX_NUMBERS_BASIC",
-                      "FUNCTION_ANALYSIS", "PROBABILITY_BASIC", "CIRCLE_EQUATION"],
-        "descriptions": {
-            "VECTORS_3D": "וקטורים במרחב",
-            "ADVANCED_INTEGRATION": "אינטגרציה מתקדמת"
-        }
-    },
-    # V286.0: Grade 12 / 5 יח"ל — full access
-    12: {
-        "blacklist": [],
-        "whitelist": ["DERIVATIVE", "INTEGRAL", "INTEGRAL_ADVANCED", "TRIGONOMETRY",
-                      "TRIGONOMETRY_ADVANCED", "LOGARITHM", "SEQUENCES", "COMPLEX_NUMBERS",
-                      "COMPLEX_ANALYSIS", "VECTORS", "VECTORS_3D", "FUNCTION_ANALYSIS",
-                      "PROBABILITY", "COMBINATORICS", "SOLID_GEOMETRY", "LIMITS",
-                      "OPTIMIZATION", "INDUCTION", "GEOMETRY_ANALYTIC", "CIRCLE_EQUATION"],
-        "descriptions": {}
-    }
-}
-
-def get_allowed_math_operators(grade_str: str, level: str = "4", topic: str = "GENERAL") -> dict:
-    """
-    Returns the pedagogical boundary rules for a specific student profile.
-    
-    Args:
-        grade_str: Student grade (e.g. "7", "י", "י\"א")
-        level: Units level for high school (3, 4, 5)
-        topic: Current mathematical topic
-        
-    Returns:
-        dict: { "allowed": [], "forbidden": [], "reason_map": {} }
-    """
-    # 1. Normalize grade
-    from topic_taxonomy import _extract_grade_number
-    grade_num = _extract_grade_number(grade_str)
-    
-    print(f"🎓 [CURRICULUM] Fetching rules for Grade {grade_num}, Level {level} units")
-    
-    rules = CURRICULUM_RULES.get(grade_num, {
-        "blacklist": [],
-        "whitelist": ["GENERAL"],
-        "descriptions": {}
-    })
-    
-    # 2. Add Level-specific tweaks (Epic V4.1+)
-    if grade_num >= 10:
-        if level == "3":
-            rules["blacklist"].extend(["COMPLEX_ANALYSIS", "IMPLICIT_DERIVATIVE"])
-        elif level == "5":
-            rules["whitelist"].extend(["COMPLEX_ANALYSIS", "ADVANCED_CALCULUS"])
-            
-    return {
-        "allowed": rules.get("whitelist", []),
-        "forbidden": rules.get("blacklist", []),
-        "reason_map": rules.get("descriptions", {})
-    }
-
-def is_operator_allowed(operator: str, grade_str: str, level: str = "4") -> bool:
-    """Helper to check a single operator."""
-    rules = get_allowed_math_operators(grade_str, level)
-    if operator in rules["forbidden"]:
-        return False
-    return True
-
-if __name__ == "__main__":
-    # Test
-    print(get_allowed_math_operators("7"))
-    print(is_operator_allowed("DERIVATIVE", "7"))
-    print(is_operator_allowed("SYSTEM_OF_EQUATIONS", "7"))
-    print(is_operator_allowed("SYSTEM_OF_EQUATIONS", "8"))
diff --git a/curriculum_israel.py b/curriculum_israel.py
deleted file mode 100644
index 91aadcbd2c1f62757c8335f56e3e9651c78dcfab..0000000000000000000000000000000000000000
--- a/curriculum_israel.py
+++ /dev/null
@@ -1,579 +0,0 @@
-# curriculum_israel.py - תוכנית הלימודים במתמטיקה לפי משרד החינוך
-# ====================================================================
-# מותאם לכל כיתה ורמה (ז'-י"ב) לפי תוכנית הלימודים הישראלית
-# כל התוכן בעברית!
-
-"""
-מבנה מערכת החינוך בישראל - מתמטיקה:
-======================================
-חטיבת ביניים (ז'-ט'): רמה א' מצטיינים, רמה א' רגילה, רמה ב'
-חטיבה עליונה (י'-י"ב): 3 יח"ל, 4 יח"ל, 5 יח"ל
-"""
-
-# =============================================================================
-# פרופילי כיתות - מה לומדים בכל כיתה
-# =============================================================================
-
-GRADE_PROFILES = {
-    
-    # ═══════════════════════════════════════════════════════════════════════
-    # כיתה ז'
-    # ═══════════════════════════════════════════════════════════════════════
-    "ז": {
-        "name": "כיתה ז'",
-        "age_range": "12-13",
-        "levels": {
-            "א_מצטיינים": {
-                "name": "רמה א' מצטיינים",
-                "topics": [
-                    "מספרים שליליים וחיוביים",
-                    "חזקות ושורשים",
-                    "ביטויים אלגבריים",
-                    "משוואות ממעלה ראשונה",
-                    "יחס ופרופורציה",
-                    "אחוזים",
-                    "גאומטריה: זוויות, משולשים, מרובעים",
-                    "שטח והיקף",
-                    "נפח ושטח פנים",
-                    "סטטיסטיקה תיאורית",
-                ],
-                "expected_level": "מתקדם - שאלות מאתגרות, חשיבה מתמטית",
-                "explanation_style": "הסברים מעמיקים עם הרחבות",
-            },
-            "א_רגילה": {
-                "name": "רמה א' רגילה",
-                "topics": [
-                    "מספרים שליליים וחיוביים",
-                    "חזקות בסיסיות",
-                    "ביטויים אלגבריים פשוטים",
-                    "משוואות ממעלה ראשונה",
-                    "יחס ופרופורציה",
-                    "אחוזים",
-                    "גאומטריה בסיסית",
-                    "שטח והיקף",
-                ],
-                "expected_level": "סטנדרטי - בניית בסיס חזק",
-                "explanation_style": "הסברים ברורים עם דוגמאות רבות",
-            },
-            "ב": {
-                "name": "רמה ב'",
-                "topics": [
-                    "מספרים שלמים",
-                    "פעולות חשבון בסיסיות",
-                    "שברים ומספרים עשרוניים",
-                    "אחוזים פשוטים",
-                    "גאומטריה בסיסית",
-                    "מדידה",
-                ],
-                "expected_level": "בסיסי - חיזוק יסודות",
-                "explanation_style": "הסברים פשוטים מאוד, צעד אחר צעד, עם הרבה עידוד",
-            },
-        },
-    },
-    
-    # ═══════════════════════════════════════════════════════════════════════
-    # כיתה ח'
-    # ═══════════════════════════════════════════════════════════════════════
-    "ח": {
-        "name": "כיתה ח'",
-        "age_range": "13-14",
-        "levels": {
-            "א_מצטיינים": {
-                "name": "רמה א' מצטיינים",
-                "topics": [
-                    "פונקציה לינארית",
-                    "מערכת משוואות",
-                    "אי-שוויונות",
-                    "משולשים: חפיפה ודמיון",
-                    "משפט פיתגורס",
-                    "מעגל",
-                    "הסתברות",
-                    "סטטיסטיקה",
-                ],
-                "expected_level": "מתקדם - הכנה לתיכון ברמה גבוהה",
-                "explanation_style": "הסברים מעמיקים עם קישורים בין נושאים",
-            },
-            "א_רגילה": {
-                "name": "רמה א' רגילה",
-                "topics": [
-                    "פונקציה לינארית",
-                    "מערכת משוואות פשוטה",
-                    "אי-שוויונות פשוטים",
-                    "משולשים וחפיפה",
-                    "משפט פיתגורס",
-                    "הסתברות בסיסית",
-                ],
-                "expected_level": "סטנדרטי",
-                "explanation_style": "הסברים ברורים ומסודרים",
-            },
-            "ב": {
-                "name": "רמה ב'",
-                "topics": [
-                    "משוואות פשוטות",
-                    "גרפים בסיסיים",
-                    "גאומטריה: משולשים ומרובעים",
-                    "מדידה ושטחים",
-                    "הסתברות פשוטה",
-                ],
-                "expected_level": "בסיסי",
-                "explanation_style": "הסברים פשוטים עם דוגמאות מחיי היומיום",
-            },
-        },
-    },
-    
-    # ═══════════════════════════════════════════════════════════════════════
-    # כיתה ט'
-    # ═══════════════════════════════════════════════════════════════════════
-    "ט": {
-        "name": "כיתה ט'",
-        "age_range": "14-15",
-        "levels": {
-            "א_מצטיינים": {
-                "name": "רמה א' מצטיינים",
-                "topics": [
-                    "פונקציה ריבועית",
-                    "משוואה ריבועית ונוסחת השורשים",
-                    "אי-שוויון ריבועי",
-                    "דמיון משולשים מתקדם",
-                    "משפט תאלס",
-                    "טריגונומטריה במשולש ישר-זווית",
-                    "מעגל: זוויות היקפיות ומרכזיות",
-                    "הסתברות מתקדמת",
-                ],
-                "expected_level": "מתקדם - הכנה ל-5 יח\"ל",
-                "explanation_style": "הסברים מעמיקים עם הוכחות",
-            },
-            "א_רגילה": {
-                "name": "רמה א' רגילה",
-                "topics": [
-                    "פונקציה ריבועית",
-                    "משוואה ריבועית",
-                    "דמיון משולשים",
-                    "טריגונומטריה בסיסית",
-                    "מעגל",
-                ],
-                "expected_level": "סטנדרטי - הכנה ל-4 יח\"ל",
-                "explanation_style": "הסברים מסודרים עם תרגול",
-            },
-            "ב": {
-                "name": "רמה ב'",
-                "topics": [
-                    "פונקציה לינארית",
-                    "משוואות פשוטות",
-                    "גאומטריה בסיסית",
-                    "הסתברות פשוטה",
-                ],
-                "expected_level": "בסיסי - הכנה ל-3 יח\"ל",
-                "explanation_style": "הסברים פשוטים ומעודדים",
-            },
-        },
-    },
-    
-    # ═══════════════════════════════════════════════════════════════════════
-    # כיתה י' - תחילת לימודי בגרות
-    # ═══════════════════════════════════════════════════════════════════════
-    "י": {
-        "name": "כיתה י'",
-        "age_range": "15-16",
-        "levels": {
-            "3_יחידות": {
-                "name": "3 יחידות לימוד",
-                "topics": [
-                    "אלגברה: משוואות ואי-שוויונות",
-                    "פונקציות: לינארית וריבועית",
-                    "גאומטריה אנליטית בסיסית",
-                    "טריגונומטריה במשולש",
-                    "סטטיסטיקה והסתברות",
-                ],
-                "bagrut_format": True,
-                "expected_level": "בגרות 3 יח\"ל - דגש על יישומים",
-                "explanation_style": "הסברים ברורים בפורמט בגרות, דגש על שאלות מילוליות",
-            },
-            "4_יחידות": {
-                "name": "4 יחידות לימוד",
-                "topics": [
-                    "אלגברה מתקדמת",
-                    "פונקציות: ריבועית, שורש, ערך מוחלט",
-                    "גאומטריה אנליטית",
-                    "טריגונומטריה: משפטי סינוסים וקוסינוסים",
-                    "סדרות חשבוניות והנדסיות",
-                    "הסתברות",
-                ],
-                "bagrut_format": True,
-                "expected_level": "בגרות 4 יח\"ל - רמה בינונית-גבוהה",
-                "explanation_style": "הסברים מפורטים בפורמט בגרות עם נימוקים",
-            },
-            "5_יחידות": {
-                "name": "5 יחידות לימוד",
-                "topics": [
-                    "אלגברה מתקדמת",
-                    "פונקציות מורכבות",
-                    "גאומטריה אנליטית מתקדמת",
-                    "טריגונומטריה מתקדמת",
-                    "סדרות והוכחות",
-                    "מבוא לחשבון דיפרנציאלי",
-                ],
-                "bagrut_format": True,
-                "expected_level": "בגרות 5 יח\"ל - רמה גבוהה",
-                "explanation_style": "הסברים מעמיקים עם הוכחות ונימוקים מלאים",
-            },
-        },
-    },
-    
-    # ═══════════════════════════════════════════════════════════════════════
-    # כיתה י"א
-    # ═══════════════════════════════════════════════════════════════════════
-    "יא": {
-        "name": "כיתה י\"א",
-        "age_range": "16-17",
-        "levels": {
-            "3_יחידות": {
-                "name": "3 יחידות לימוד",
-                "topics": [
-                    "חזרה והעמקה באלגברה",
-                    "פונקציות ויישומים",
-                    "סטטיסטיקה מתקדמת",
-                    "הסתברות",
-                    "גאומטריה במישור",
-                ],
-                "bagrut_format": True,
-                "expected_level": "הכנה לבגרות 3 יח\"ל",
-                "explanation_style": "תרגול בגרויות עם הסברים",
-            },
-            "4_יחידות": {
-                "name": "4 יחידות לימוד",
-                "topics": [
-                    "חדו\"א: נגזרות",
-                    "חקירת פונקציות פולינומיאליות",
-                    "גאומטריה אנליטית: ישר ומעגל",
-                    "טריגונומטריה מתקדמת",
-                    "סדרות",
-                    "הסתברות מותנית",
-                ],
-                "bagrut_format": True,
-                "expected_level": "בגרות 4 יח\"ל",
-                "explanation_style": "פורמט בגרות מלא עם כל הנימוקים",
-            },
-            "5_יחידות": {
-                "name": "5 יחידות לימוד",
-                "topics": [
-                    "חדו\"א: נגזרות ואינטגרלים",
-                    "חקירת פונקציות מורכבות",
-                    "גאומטריה אנליטית מתקדמת",
-                    "מספרים מרוכבים",
-                    "הסתברות מתקדמת",
-                    "אינדוקציה",
-                ],
-                "bagrut_format": True,
-                "expected_level": "בגרות 5 יח\"ל - רמה גבוהה",
-                "explanation_style": "הוכחות מלאות, נימוקים פורמליים",
-            },
-        },
-    },
-    
-    # ═══════════════════════════════════════════════════════════════════════
-    # כיתה י"ב
-    # ═══════════════════════════════════════════════════════════════════════
-    "יב": {
-        "name": "כיתה י\"ב",
-        "age_range": "17-18",
-        "levels": {
-            "3_יחידות": {
-                "name": "3 יחידות לימוד",
-                "topics": [
-                    "חזרה מקיפה לבגרות",
-                    "פתרון בגרויות קודמות",
-                    "כל נושאי 3 יח\"ל",
-                ],
-                "bagrut_format": True,
-                "expected_level": "הכנה אינטנסיבית לבגרות",
-                "explanation_style": "פתרון בגרויות עם טיפים למבחן",
-            },
-            "4_יחידות": {
-                "name": "4 יחידות לימוד",
-                "topics": [
-                    "חזרה מקיפה לבגרות",
-                    "חדו\"א: אינטגרלים ושטחים",
-                    "גאומטריה אנליטית מתקדמת",
-                    "פתרון בגרויות",
-                ],
-                "bagrut_format": True,
-                "expected_level": "הכנה אינטנסיבית לבגרות 4 יח\"ל",
-                "explanation_style": "פתרון מבחנים עם אסטרטגיות",
-            },
-            "5_יחידות": {
-                "name": "5 יחידות לימוד",
-                "topics": [
-                    "חדו\"א מתקדם",
-                    "אינטגרלים ויישומים",
-                    "משוואות דיפרנציאליות פשוטות",
-                    "גאומטריה אנליטית: אליפסה והיפרבולה",
-                    "מספרים מרוכבים מתקדם",
-                    "וקטורים",
-                    "הכנה לבגרות",
-                ],
-                "bagrut_format": True,
-                "expected_level": "הכנה אינטנסיבית לבגרות 5 יח\"ל",
-                "explanation_style": "פתרון מלא עם כל ההוכחות והנימוקים",
-            },
-        },
-    },
-}
-
-
-# =============================================================================
-# כללי בגרות לפי נושא (מתוך מסמך משרד החינוך)
-# =============================================================================
-
-BAGRUT_RULES = {
-    "גאומטריה": {
-        "חובה": [
-            "לנמק בהגדרות ומשפטים גאומטריים בלבד",
-            "לציין את המשולש/מרובע שאליו מתייחסים",
-            "להגדיר זווית ב-3 אותיות או אות אחת + שם המשולש",
-        ],
-        "לא_נדרש": [
-            "'כל גודל שווה לעצמו'",
-            "'כלל החיבור'",
-            "'כלל החיסור'",
-            "לרשום שקטעים מקבילים אם כתבנו שישרים מקבילים",
-        ],
-        "נימוקים_נפוצים": [
-            "נתון",
-            "זוויות מתחלפות בין ישרים מקבילים",
-            "זוויות חד-צדדיות משלימות ל-180°",
-            "זוויות קודקודיות שוות",
-            "סכום זוויות במשולש = 180°",
-            "משפט פיתגורס",
-            "משפט תאלס",
-            "חפיפת משולשים (צ.ז.צ / ז.צ.ז / צ.צ.צ)",
-            "דמיון משולשים (ז.ז / צ.ז.צ / צ.צ.צ)",
-        ],
-    },
-    
-    "חדוא": {
-        "חובה": [
-            "תחום הגדרה: לכתוב אי-שוויון נכון (חזק ≠ חלש)",
-            "באינטגרל: לכתוב פונקציה קדומה + הצבת גבולות",
-            "לכתוב dx וסוגריים במקום הנכון",
-        ],
-        "לא_נדרש": [
-            "לפרט חישובי גבולות לאסימפטוטות",
-            "לפרט הצבות בקביעת סוג קיצון",
-        ],
-        "טעויות_קריטיות": [
-            "תחום הגדרה עם כיוון אי-שוויון שגוי = 0 נקודות",
-            "אינטגרל ללא פונקציה קדומה = 0 נקודות",
-        ],
-    },
-    
-    "הסתברות": {
-        "חובה": [
-            "להגדיר כל מאורע (A, B) במילים",
-            "בהסתברות מותנית: לרשום P(B|A) ואז להציב בנוסחה",
-            "להראות כל חישוב",
-        ],
-    },
-    
-    "אלגברה": {
-        "חובה": [
-            "להראות דרך פתרון מלאה",
-            "תשובה סופית ללא דרך = לא נבדק",
-            "במשוואה ריבועית: להראות נוסחה או פירוק",
-        ],
-    },
-    
-    "אינדוקציה": {
-        "חובה": [
-            "משפטי קישור: 'נבדוק עבור n=1', 'נניח עבור n=k', 'נוכיח עבור n=k+1'",
-            "לרשום נכון מה צריך להוכיח",
-        ],
-        "טעויות_קריטיות": [
-            "'נניח לכל n טבעי' = הורדה של 20%",
-            "רישום שגוי של מה שצריך להוכיח = לא בודקים המשך",
-        ],
-    },
-    
-    "טריגונומטריה": {
-        "4_יחידות": [
-            "לפשט sin(180°-x) וכדומה",
-        ],
-        "5_יחידות": [
-            "לעבוד ברדיאנים בלבד (מעלות = 0 נקודות)",
-        ],
-    },
-
-    "סדרות": {
-        "חובה": [
-            "לרשום את סוג הסדרה (חשבונית/הנדסית) ואת הנוסחה הכללית",
-            "בסכום חלקי: לרשום את הנוסחה ולהציב",
-            "בהוכחת נוסחה: להשתמש באינדוקציה מלאה",
-        ],
-    },
-
-    "מספרים_מרוכבים": {
-        "חובה": [
-            "לרשום z בצורה אלגברית (a+bi) וגם בצורה טריגונומטרית אם נדרש",
-            "להראות חישוב מודולוס וארגומנט",
-            "בשורשים: להשתמש בנוסחת דה-מואבר ולרשום את כל השורשים",
-        ],
-    },
-
-    "וקטורים": {
-        "חובה": [
-            "לרשום וקטור כצמד מוסדר",
-            "במכפלה סקלרית: להראות חישוב בשתי דרכים (קואורדינטות וזווית)",
-            "להוכיח ניצבות דרך מכפלה סקלרית = 0",
-        ],
-    },
-
-    "סטטיסטיקה": {
-        "חובה": [
-            "לרשום את נוסחת הממוצע/שונות/סטיית תקן",
-            "בהתפלגות נורמלית: לציין Z-score ולהשתמש בטבלאות",
-            "בהתפלגות בינומית: לרשום n, p, ולהציב בנוסחה",
-        ],
-    },
-}
-
-
-# =============================================================================
-# סגנונות הסבר לפי גיל
-# =============================================================================
-
-EXPLANATION_STYLES = {
-    "חטיבת_ביניים": {
-        "שפה": "פשוטה ונגישה",
-        "דוגמאות": "מחיי היומיום",
-        "עידוד": "הרבה חיזוקים חיוביים",
-        "קצב": "איטי ומפורט",
-        "אימוג'ים": "כן, בכמות מתונה",
-    },
-    "חטיבה_עליונה_3_יחידות": {
-        "שפה": "ברורה עם מונחים מתמטיים בסיסיים",
-        "דוגמאות": "יישומיות",
-        "עידוד": "מתון",
-        "קצב": "רגיל",
-        "פורמט": "בגרות",
-    },
-    "חטיבה_עליונה_4_יחידות": {
-        "שפה": "מתמטית עם הסברים",
-        "דוגמאות": "מתמטיות",
-        "עידוד": "ממוקד",
-        "קצב": "רגיל-מהיר",
-        "פורמט": "בגרות מלא",
-    },
-    "חטיבה_עליונה_5_יחידות": {
-        "שפה": "מתמטית פורמלית",
-        "דוגמאות": "הוכחות ונימוקים",
-        "עידוד": "מינימלי",
-        "קצב": "מהיר",
-        "פורמט": "בגרות מלא עם הוכחות",
-    },
-}
-
-
-# =============================================================================
-# פונקציות עזר
-# =============================================================================
-
-def get_grade_profile(grade: str, level: str = None) -> dict:
-    """מחזיר פרופיל כיתה ורמה"""
-    
-    # נרמול שם הכיתה
-    grade_map = {
-        "ז'": "ז", "ז": "ז", "7": "ז",
-        "ח'": "ח", "ח": "ח", "8": "ח",
-        "ט'": "ט", "ט": "ט", "9": "ט",
-        "י'": "י", "י": "י", "10": "י",
-        "י\"א": "יא", "יא": "יא", "11": "יא",
-        "י\"ב": "יב", "יב": "יב", "12": "יב",
-    }
-    
-    grade_key = grade_map.get(grade, "י")
-    profile = GRADE_PROFILES.get(grade_key, GRADE_PROFILES["י"])
-    
-    # נרמול רמה
-    if level:
-        level_map = {
-            "3 יח\"ל": "3_יחידות", "3 יחידות": "3_יחידות", "3": "3_יחידות",
-            "4 יח\"ל": "4_יחידות", "4 יחידות": "4_יחידות", "4": "4_יחידות",
-            "5 יח\"ל": "5_יחידות", "5 יחידות": "5_יחידות", "5": "5_יחידות",
-            "רמה א' מצטיינים": "א_מצטיינים", "מצטיינים": "א_מצטיינים",
-            "רמה א' רגילה": "א_רגילה", "רגילה": "א_רגילה",
-            "רמה ב'": "ב", "ב": "ב",
-        }
-        level_key = level_map.get(level, list(profile["levels"].keys())[0])
-        level_profile = profile["levels"].get(level_key, list(profile["levels"].values())[0])
-    else:
-        level_profile = list(profile["levels"].values())[0]
-    
-    return {
-        "grade": profile,
-        "level": level_profile,
-    }
-
-
-def get_explanation_style(grade: str, level: str = None) -> dict:
-    """מחזיר סגנון הסבר מותאם"""
-    
-    profile = get_grade_profile(grade, level)
-    
-    # זיהוי אם חטיבת ביניים או עליונה
-    if grade in ["ז", "ז'", "ח", "ח'", "ט", "ט'", "7", "8", "9"]:
-        return EXPLANATION_STYLES["חטיבת_ביניים"]
-    
-    # חטיבה עליונה - לפי יחידות
-    level_name = profile["level"].get("name", "")
-    if "3 יחידות" in level_name:
-        return EXPLANATION_STYLES["חטיבה_עליונה_3_יחידות"]
-    elif "4 יחידות" in level_name:
-        return EXPLANATION_STYLES["חטיבה_עליונה_4_יחידות"]
-    else:
-        return EXPLANATION_STYLES["חטיבה_עליונה_5_יחידות"]
-
-
-def get_bagrut_rules(topic: str) -> dict:
-    """מחזיר כללי בגרות לנושא מסוים"""
-    
-    topic_map = {
-        "גאומטריה": "גאומטריה",
-        "geometry": "גאומטריה",
-        "חדוא": "חדוא",
-        "calculus": "חדוא",
-        "חקירה": "חדוא",
-        "נגזרת": "חדוא",
-        "אינטגרל": "חדוא",
-        "הסתברות": "הסתברות",
-        "probability": "הסתברות",
-        "אלגברה": "אלגברה",
-        "algebra": "אלגברה",
-        "משוואה": "אלגברה",
-        "אינדוקציה": "אינדוקציה",
-        "induction": "אינדוקציה",
-        "טריגונומטריה": "טריגונומטריה",
-        "trigonometry": "טריגונומטריה",
-        "סדרה": "סדרות",
-        "סדרות": "סדרות",
-        "sequence": "סדרות",
-        "מרוכב": "מספרים_מרוכבים",
-        "complex": "מספרים_מרוכבים",
-        "וקטור": "וקטורים",
-        "vector": "וקטורים",
-        "סטטיסטיקה": "סטטיסטיקה",
-        "statistics": "סטטיסטיקה",
-        "ממוצע": "סטטיסטיקה",
-        "התפלגות": "סטטיסטיקה",
-    }
-    
-    for key, value in topic_map.items():
-        if key in topic.lower():
-            return BAGRUT_RULES.get(value, {})
-    
-    return {}
-
-
-def is_bagrut_level(grade: str, level: str = None) -> bool:
-    """בודק אם זו רמת בגרות"""
-    profile = get_grade_profile(grade, level)
-    return profile["level"].get("bagrut_format", False)
diff --git a/debug_llm_payload.py b/debug_llm_payload.py
deleted file mode 100644
index 4ef4a38145f2eb270aac2e6d1504c55a1eafb20a..0000000000000000000000000000000000000000
--- a/debug_llm_payload.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import asyncio
-import os
-import sys
-
-# Set encoding for Windows console (just in case)
-if sys.platform == 'win32':
-    sys.stdout.reconfigure(encoding='utf-8')
-    sys.stderr.reconfigure(encoding='utf-8')
-
-from orchestrator import BuddyOrchestrator
-from domain.processing_strategy import ProcessingStrategy
-from smart_solver import SmartSolver
-
-async def debug_orchestrator():
-    orchestrator = BuddyOrchestrator()
-    problem_text = "פתור את המשוואה הטריגונומטרית: sin x = 0.5"
-    grade = "10"
-    student_name = "דוד"
-
-    print("🚀 Starting Smart Solver Trace...")
-    try:
-        data_anchor = {"function_equations": ["sin x = 0.5"]}
-        result = await orchestrator.smart_solve(
-            problem_text=problem_text,
-            data_anchor=data_anchor,
-            grade=grade,
-            category="ALGEBRA",
-            processing_strategy=ProcessingStrategy.STRICT_SYMBOLIC
-        )
-        
-        import json
-        with open("debug_output.json", "w", encoding="utf-8") as f:
-            json.dump(result, f, indent=2, ensure_ascii=False)
-        print("✅ Saved to debug_output.json")
-
-    except Exception as e:
-        print(f"❌ Error during execution: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    asyncio.run(debug_orchestrator())
diff --git a/deploy_dev.ps1 b/deploy_dev.ps1
deleted file mode 100644
index 3b09898ff2b69494175d0188059c17901cb86d29..0000000000000000000000000000000000000000
--- a/deploy_dev.ps1
+++ /dev/null
@@ -1,31 +0,0 @@
-$PROJECT_ID = "buddy-math-dev"
-$SERVICE_NAME = "buddy-math-server"
-$REGION = "europe-west3" 
-$IMAGE_NAME = "gcr.io/$PROJECT_ID/$SERVICE_NAME"
-
-Write-Host "--- Starting Deployment for BuddyMath Server (DEV) ---" -ForegroundColor Cyan
-
-# 1. Check for gcloud
-if (!(Get-Command gcloud -ErrorAction SilentlyContinue)) {
-    Write-Error "❌ gcloud CLI not found."
-    exit
-}
-
-# 2. Set Project
-gcloud config set project $PROJECT_ID
-
-# 3. Build Image
-Write-Host "Building Image..."
-gcloud builds submit --tag $IMAGE_NAME .
-
-# 4. Deploy to Cloud Run (Including Secrets & 60s Timeout)
-Write-Host "Deploying to Cloud Run..."
-gcloud run deploy $SERVICE_NAME --image $IMAGE_NAME --platform managed --region $REGION --allow-unauthenticated --set-env-vars "ENV=development,OCR_STRIP_MODE=development" --set-secrets "GOOGLE_API_KEY=GOOGLE_API_KEY:latest,FIREBASE_CREDENTIALS=FIREBASE_CREDENTIALS:latest" --timeout 60
-
-Write-Host "Deployment Complete!" -ForegroundColor Green
-
-# 5. Storage Lifecycle Rule
-Write-Host "Applying Storage Lifecycle Rule..." -ForegroundColor Yellow
-gcloud storage buckets update gs://buddy-math-dev.firebasestorage.app --lifecycle-file=gcs_lifecycle_rule.json
-
-Write-Host "DONE: Everything is up and running!" -ForegroundColor Green
\ No newline at end of file
diff --git a/deploy_dev.sh b/deploy_dev.sh
deleted file mode 100644
index 17185666d3c6a5998e2124972bcb0738bd46e5bc..0000000000000000000000000000000000000000
--- a/deploy_dev.sh
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/bin/bash
-# deploy_dev.sh - Tutor Mode Deployment Script (DEV)
-# V3.18.0 - Includes Phase C Environment Variables
-
-PROJECT_ID="buddy-math-dev"
-SERVICE_NAME="buddy-math-server"
-REGION="europe-west3" # Change if needed
-IMAGE_NAME="gcr.io/$PROJECT_ID/$SERVICE_NAME"
-
-echo "🚀 Starting Deployment for BuddyMath Server (DEV)..."
-
-# 1. Check for gcloud
-if ! command -v gcloud &> /dev/null
-then
-    echo "❌ gcloud CLI not found. Please install it: https://cloud.google.com/sdk/docs/install"
-    exit
-fi
-
-# 2. Set Project
-echo "📍 Setting GCP Project to $PROJECT_ID..."
-gcloud config set project $PROJECT_ID
-
-# 3. Build Image using Cloud Build
-echo "🏗️ Submitting build to Cloud Build..."
-gcloud builds submit --tag $IMAGE_NAME .
-
-# 4. Deploy to Cloud Run
-echo "☁️ Deploying to Cloud Run..."
-gcloud run deploy $SERVICE_NAME \
-    --image $IMAGE_NAME \
-    --platform managed \
-    --region $REGION \
-    --allow-unauthenticated \
-    --set-env-vars "ENV=development,OCR_STRIP_MODE=development"
-
-echo "✅ Deployment Complete!"
-
-# 5. Reminder for Storage Lifecycle
-echo -e "\n🔔 [IMPORTANT] Don't forget to apply the Storage Lifecycle Rule if you haven't yet:"
-echo "gsutil lifecycle set gcs_lifecycle_rule.json gs://buddy-math-dev.firebasestorage.app"
diff --git a/deploy_hf b/deploy_hf
deleted file mode 160000
index ebcf3058d7ba593763ac0ff97ea695b1d67955ec..0000000000000000000000000000000000000000
--- a/deploy_hf
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit ebcf3058d7ba593763ac0ff97ea695b1d67955ec
diff --git a/docs/legacy_prompts_backup.txt b/docs/legacy_prompts_backup.txt
deleted file mode 100644
index 1b3fc54c90b663845868cc598f87dc4114b86c52..0000000000000000000000000000000000000000
--- a/docs/legacy_prompts_backup.txt
+++ /dev/null
@@ -1,937 +0,0 @@
-# prompts.py - V275.0 (Enhanced OCR for Nested Fractions)
-# Based on BUDDYMATH_COMPLETE_GUIDE V230.8 §1.3, §4.1, §6.1
-import json
-
-
-def _get_grade_features(grade: str, category: str = "") -> dict:
-    """התאמת רמת הפירוט לפי יחידות לימוד (§5.1)"""
-    is_investigation = (category == "INVESTIGATION")
-    
-    if "5 יח\"ל" in grade:
-        style = "הוכחה דקדקנית של כל מעבר, כולל נגזרות שנייה, קמירות ואסימפטוטות" if is_investigation else "הוכחה דקדקנית של כל מעבר ודיוק אלגברי מירבי"
-        return {
-            "depth": "אקדמי ומעמיק",
-            "style": style,
-            "tone": "מעצים ומאתגר, כביר של בגרות 5 יח\"ל"
-        }
-    elif "4 יח\"ל" in grade:
-        style = "הסבר ברור של חוקי האלגברה עם דגש על כלל שרשרת" if is_investigation else "הסבר ברור של חוקי האלגברה ופירוט תהליכי הפתרון"
-        return {
-            "depth": "מפורט ותומך",
-            "style": style,
-            "tone": "מעודד ומפורט, שלב אחר שלב"
-        }
-    else:
-        return {
-            "depth": "פשוט, ברור ומדובר 'בגובה העיניים' (מבחן הילד בן ה-16)",
-            "style": "צעד אחר צעד, בקריאה שוטפת. חובה להשתמש במשפטי קישור ומעבר מילוליים (כמו 'נציב את הנתונים בנוסחה:', 'כעת נבדוק את תחום ההגדרה:'). אסור להרצות.",
-            "tone": "חם, סבלני, מלא התלהבות ועידוד תמידי. כמו מורה אהובה שעוזרת באופן פרטי."
-        }
-
-def _detect_relevant_rules(text: str, category: str = "") -> list:
-    """זיהוי כללים רלוונטיים לפי קטגוריה — מבוסס-הקשר (§4.1, V231.1)"""
-    rules = []
-    t = text.lower()
-    
-    # === GEOMETRY rules (only for GEOMETRY category) ===
-    if category != "INVESTIGATION":
-        if any(x in t for x in ["מעגל", "מרכז", "רדיוס", "מקום גיאומטרי"]):
-            rules.append(r"משוואת מעגל: $(x-a)^2 + (y-b)^2 = r^2$")
-            rules.append(r"היקף מעגל: $2\\pi r$")
-        if "מרחק" in t or "d =" in t or "מקום גיאומטרי" in t:
-            rules.append(r"דיסטנס: $d = \\sqrt{(x_2-x_1)^2 + (y_2-y_1)^2}$")
-        if any(x in t for x in ["ישר", "שיפוע"]):
-            rules.append(r"משוואת ישר: $y = mx + b$")
-        if any(x in t for x in ["משולש", "שטח"]):
-            rules.append(r"שטח משולש: $S = \\frac{1}{2} \\cdot a \\cdot h$")
-        if any(x in t for x in ["משיק", "אנך"]):
-            rules.append(r"שיפועים אנכיים: $m_1 \\cdot m_2 = -1$")
-        if "מקום גיאומטרי" in t:
-             rules.append(r"פרבולה: מרחק מנקודה שווה למרחק מישר.")
-             rules.append(r"אליפסה: סכום מרחקים מ-2 נקודות קבוע ($d_1+d_2=k$).")
-             rules.append(r"היפרבולה: הפרש מרחקים מ-2 נקודות קבוע ($|d_1-d_2|=k$).")
-        if "מקום גיאומטרי" in t:
-             rules.append(r"⚠️ הנחיה קריטית: אל תנחש את הצורה! פיתוח המשוואה חייב להיעשות צעד-אחר-צעד מההגדרה המילולית.")
-             rules.append(r"דוגמה לשימוש בהגדרה: אם רשום שמרחק נקודה $P(x,y)$ ממיקום א' שווה למרחקה ממיקום ב', רשום משוואה מהצורה $d_1 = d_2$. הצב את נוסחאות המרחק, העלה בריבוע ופשט.")
-             rules.append(r"בביטויים עם שורשים: בודד שורש אחד -> עלה בריבוע -> בודד את השורש השני -> עלה בריבוע שוב.")
-    
-        # === PROOF-specific rules (V282.0) ===
-        if any(x in t for x in ["הוכח", "הוכיח", "הוכיחו", "הראה כי", "הראי כי", "הוכח כי", "הוכיחי"]):
-            rules.append(r"⚠️ זוהי שאלת הוכחה! חובה להראות את כל שרשרת ההיגיון, לא רק את התוצאה.")
-            rules.append(r"מבנה הוכחה: נתון -> מסקנה ביניים (+ נימוק/משפט) -> מסקנה הבאה -> ... -> מ.ש.ל.")
-            rules.append(r"לכל מעבר לוגי חובה לציין את הנימוק: שם המשפט, התכונה, או הכלל.")
-            rules.append(r"משולש שווה שוקיים -> זוויות בסיס שוות, חוצה זווית = תיכון = גובה לבסיס.")
-            rules.append(r"משולשים חופפים: צ.צ.צ / צ.ז.צ / ז.צ.ז - ציין איזה קריטריון נבחר ולמה.")
-            rules.append(r"אם צריך להוכיח שוויון קטעים - חפש משולשים חופפים, או תכונות של צורות מיוחדות.")
-
-        rules.append(r"בגיאומטריה אנליטית: לפני חישוב, בצע 'בדיקת שפיות' (Sanity Check).")
-        rules.append(r"אם נתון ש-AC קוטר, המרכז M *חייב* להיות האמצע שלו. אם החישוב מראה אחרת - הנתונים שהוצאת שגויים! נסה לקרוא שוב.")
-        rules.append(r"עדיפות לנתונים: טקסט כתוב > משוואות > שרטוט ויזואלי.")
-        rules.append(r"הימנע משימוש ב-\\\\ בתוך בלוקים של מתמטיקה, השתמש בצעדים נפרדים.")
-        
-    # V8.6.3: Contextual Logic Guardrails
-    if category == "GEOMETRY":
-        rules.append(r"ZERO ASSUMPTIONS RULE: NEVER assume, guess, or invent ANY geometric property (e.g., 'this segment is a diameter', 'this angle is 90 degrees', 'this triangle is isosceles') unless it is EXPLICITLY WRITTEN in the provided text. You are strictly forbidden from fabricating data or relationships just because the coordinates look convenient. Work ONLY with the exact facts stated in the OCR text and Data Anchor.")
-        rules.append(r"CRITICAL GEOMETRY RULE: You MUST strictly adhere to the geometric layout described in the problem text. If your calculation leads to a paradox (e.g., length 0, points colliding, or negative area), YOUR assumption is wrong. Recalculate based strictly on the given explicit constraints. DO NOT change the given equations.")
-
-    if category in ["CALCULUS", "FUNCTION_ANALYSIS", "INVESTIGATION"]:
-        rules.append(r"GRAPH MATCHING PROTOCOL: When asked to select a correct graph from multiple options (I, II, III, IV), you MUST first perform a visual scan: explicitly describe what you see in EACH given graph (e.g., 'Graph I shows asymptotes at... Graph II shows a hole at...'). Only AFTER describing all options, match your mathematical deductions to the correct visual description and select the final answer.")
-
-    if category == "CALCULUS":
-        if any(x in t for x in ["נגזרת", "גזור", "f'", "חקור"]):
-            rules.append(r"כלל החזקה: $(x^n)' = nx^{n-1}$")
-            if any(x in t for x in ["/", "frac", "מנה", "חילוק"]):
-                rules.append(r"נגזרת מנה: $(\\frac{u}{v})' = \\frac{u'v - uv'}{v^2}$")
-            if any(x in t for x in ["מכפלה", "כפל"]):
-                rules.append(r"נגזרת מכפלה: $(u \\cdot v)' = u'v + uv'$")
-            if any(x in t for x in ["שרשרת", "הרכבה", "sin", "cos"]):
-                rules.append(r"כלל שרשרת: $[f(g(x))]' = f'(g(x)) \\cdot g'(x)$")
-        if any(x in t for x in ["אינטגרל", "שטח מתחת"]):
-            rules.append(r"אינטגרל חזקה: $\\int x^n dx = \\frac{x^{n+1}}{n+1} + C$")
-        if any(x in t for x in ["דיפרנציאלית", "y'", "dy/dx"]):
-            rules.append(r"משוואה דיפרנציאלית: הפרד משתנים, אינטגרל משני הצדדים.")
-
-    # === SEQUENCES rules ===
-    if any(x in t for x in ["סדרה", "חשבונית", "הנדסית", "סכום חלקי", "הפרש"]):
-        rules.append(r"סדרה חשבונית: $a_n = a_1 + (n-1)d$, סכום: $S_n = \\frac{n}{2}(a_1 + a_n)$")
-        rules.append(r"סדרה הנדסית: $a_n = a_1 \\cdot q^{n-1}$, סכום: $S_n = a_1 \\cdot \\frac{q^n - 1}{q - 1}$")
-        if "אינסופי" in t or "גבול" in t:
-            rules.append(r"סכום סדרה הנדסית אינסופית ($|q|<1$): $S = \\frac{a_1}{1-q}$")
-
-    # === COMPLEX NUMBERS rules ===
-    if any(x in t for x in ["מרוכב", "מדומה", "i²", "i^2"]):
-        rules.append(r"$i^2 = -1$, מספר מרוכב: $z = a + bi$")
-        rules.append(r"מודולוס: $|z| = \\sqrt{a^2 + b^2}$, צמוד: $\\bar{z} = a - bi$")
-        if any(x in t for x in ["קוטבי", "דה-מואבר", "טריגונומטרי"]):
-            rules.append(r"צורה טריגונומטרית: $z = r(\\cos\\theta + i\\sin\\theta)$")
-            rules.append(r"דה-מואבר: $z^n = r^n(\\cos(n\\theta) + i\\sin(n\\theta))$")
-
-    # === VECTORS rules ===
-    if any(x in t for x in ["וקטור", "וקטורים"]):
-        rules.append(r"$\\vec{u} = (a,b)$, $|\\vec{u}| = \\sqrt{a^2+b^2}$")
-        rules.append(r"מכפלה סקלרית: $\\vec{u}\\cdot\\vec{v} = a_1 a_2 + b_1 b_2 = |u||v|\\cos\\alpha$")
-        rules.append(r"וקטורים מאונכים: $\\vec{u}\\cdot\\vec{v} = 0$")
-        # V286.0: 3D Vectors (5 יח"ל)
-        if any(x in t for x in ["מרחב", "מישור", "תלת", "z", "פרמטרי", "ניצב למישור"]):
-            rules.append(r"וקטור במרחב: $\vec{u} = (a,b,c)$, $|\vec{u}| = \sqrt{a^2+b^2+c^2}$")
-            rules.append(r"מכפלה סקלרית 3D: $\vec{u}\cdot\vec{v} = a_1 a_2 + b_1 b_2 + c_1 c_2 = |u||v|\cos\alpha$")
-            rules.append(r"מכפלה וקטורית (Cross Product): $\vec{u}\times\vec{v} = (b_1 c_2 - c_1 b_2,\; c_1 a_2 - a_1 c_2,\; a_1 b_2 - b_1 a_2)$. הוקטור שמתקבל ניצב לשני הוקטורים המקוריים.")
-            rules.append(r"מציאת נורמלי למישור: השתמש במכפלה וקטורית של שני וקטורי כיוון הפורשים את המישור.")
-            rules.append(r"משוואת מישור: $Ax + By + Cz + D = 0$. הנורמלי הוא $\vec{n} = (A,B,C)$.")
-            rules.append(r"ישר במרחב (הצגה פרמטרית): $\vec{r} = \vec{p} + t\vec{v}$")
-            rules.append(r"מרחק נקודה $(x_0,y_0,z_0)$ ממישור $Ax+By+Cz+D=0$: $d = \frac{|Ax_0+By_0+Cz_0+D|}{\sqrt{A^2+B^2+C^2}}$")
-            rules.append(r"זווית $\alpha$ בין שני מישורים: $\cos\alpha = \frac{|\vec{n_1}\cdot\vec{n_2}|}{|\vec{n_1}||\vec{n_2}|}$")
-            rules.append(r"זווית $\beta$ בין ישר למישור: $\sin\beta = \frac{|\vec{v}\cdot\vec{n}|}{|\vec{v}||\vec{n}|}$ (כאשר $\vec{n}$ הוא נורמלי למישור).")
-            rules.append(r"מכפלה משולשת (נפח מקבילון): $V = |\vec{a}\cdot(\vec{b}\times\vec{c})|$")
-
-    # === STATISTICS rules ===
-    if any(x in t for x in ["ממוצע", "חציון", "שכיח", "סטיית תקן", "שונות"]):
-        rules.append(r"ממוצע: $\\bar{x} = \\frac{\\sum x_i}{n}$")
-        rules.append(r"שונות: $\\sigma^2 = \\frac{\\sum(x_i - \\bar{x})^2}{n}$, סטיית תקן: $\\sigma = \\sqrt{\\sigma^2}$")
-    if any(x in t for x in ["התפלגות", "נורמלית", "בינומית"]):
-        rules.append(r"התפלגות בינומית: $P(X=k) = \\binom{n}{k}p^k(1-p)^{n-k}$")
-        rules.append(r"התפלגות נורמלית: כלל 68-95-99.7 (אחוזים בטווח 1-2-3 סטיות תקן)")
-
-    # === INDUCTION rules ===
-    if any(x in t for x in ["אינדוקציה", "הוכח כי לכל", "n טבעי"]):
-        rules.append(r"שלב 1 (בסיס): הוכח עבור $n=1$. שלב 2 (הנחה): הנח עבור $n=k$. שלב 3 (צעד): הוכח עבור $n=k+1$.")
-        rules.append(r"⚠️ חובה לרשום בפירוש: 'מה צריך להוכיח', 'הנחת האינדוקציה', 'מ.ש.ל'.")
-
-    # === TRIGONOMETRY LAW rules ===
-    if any(x in t for x in ["סינוסים", "קוסינוסים", "משולש", "זווית"]):
-        if "סינוסים" in t:
-            rules.append(r"משפט הסינוסים: $\\frac{a}{\\sin A} = \\frac{b}{\\sin B} = \\frac{c}{\\sin C}$")
-        if "קוסינוסים" in t:
-            rules.append(r"משפט הקוסינוסים: $c^2 = a^2 + b^2 - 2ab\\cos C$")
-        rules.append(r"שטח משולש לפי שתי צלעות וזווית: $S = \\frac{1}{2}ab\\sin C$")
-    if any(x in t for x in ["זהות", "טריגונומטרית"]):
-        rules.append(r"$\\sin^2(x) + \\cos^2(x) = 1$")
-        rules.append(r"$\\sin(2x) = 2\\sin(x)\\cos(x)$, $\\cos(2x) = \\cos^2(x) - \\sin^2(x)$")
-    # V286.0: Advanced Trigonometry (5 יח"ל)
-    if any(x in t for x in ["sin", "cos", "tan", "trig", "טריגונומטר", "sin(", "cos("]):
-        if any(x in t for x in ["סכום", "הפרש", "α+β", "α-β", "alpha"]):
-            rules.append(r"$\\sin(\\alpha \\pm \\beta) = \\sin\\alpha\\cos\\beta \\pm \\cos\\alpha\\sin\\beta$")
-            rules.append(r"$\\cos(\\alpha \\pm \\beta) = \\cos\\alpha\\cos\\beta \\mp \\sin\\alpha\\sin\\beta$")
-            rules.append(r"$\\tan(\\alpha + \\beta) = \\frac{\\tan\\alpha + \\tan\\beta}{1 - \\tan\\alpha\\tan\\beta}$")
-        if any(x in t for x in ["חצי זווית", "sin²", "cos²"]):
-            rules.append(r"$\\sin^2\\frac{x}{2} = \\frac{1-\\cos x}{2}$, $\\cos^2\\frac{x}{2} = \\frac{1+\\cos x}{2}$")
-    if any(x in t for x in ["פתור משוואה טריגונומטרית", "sinx=", "cosx=", "sin x =", "cos x ="]):
-        rules.append(r"$\\sin x = a \\Rightarrow x = (-1)^n \\arcsin a + \\pi n$, $n \\in \\mathbb{Z}$")
-        rules.append(r"$\\cos x = a \\Rightarrow x = \\pm \\arccos a + 2\\pi n$, $n \\in \\mathbb{Z}$")
-        rules.append(r"$\\tan x = a \\Rightarrow x = \\arctan a + \\pi n$, $n \\in \\mathbb{Z}$")
-
-    # === VOLUME & SURFACE AREA rules ===
-    if any(x in t for x in ["נפח", "שטח פנים", "גליל", "חרוט", "כדור"]):
-        rules.append(r"נפח גליל: $V = \\pi r^2 h$, נפח חרוט: $V = \\frac{1}{3}\\pi r^2 h$")
-        rules.append(r"נפח כדור: $V = \\frac{4}{3}\\pi r^3$, שטח פנים כדור: $S = 4\\pi r^2$")
-
-    # V286.0: Solid Geometry (גיאומטריה מרחבית — 5 יח"ל)
-    if any(x in t for x in ["פירמידה", "מנסרה", "תיבה", "חתך", "אפותם", "מקצוע צדדי", "פאות"]):
-        rules.append(r"נפח פירמידה: $V = \frac{1}{3} S_{base} \cdot h$")
-        rules.append(r"נפח מנסרה: $V = S_{base} \cdot h$")
-        rules.append(r"שטח פנים של פירמידה: $S = S_{base} + \sum S_{faces}$")
-        rules.append(r"זווית $\alpha$ בין מקצוע צדדי לבסיס: זווית במשולש ישר-זווית הנוצר ע\"י המקצוע, הטלו על הבסיס והגובה.")
-        rules.append(r"זווית $\beta$ בין פאה צדדית לבסיס: זווית במשולש ישר-זווית הנוצר ע\"י האפותם של הפאה, הטלו על הבסיס והגובה.")
-        rules.append(r"חישובים מרחביים: השתמש תמיד במשפט פיתגורס וטריגונומטריה בתוך משולשים ישרי-זווית המקשרים פנים וחוץ.")
-
-    # === INEQUALITY rules ===
-    if any(x in t for x in ["אי-שוויון", "אי שוויון"]):
-        rules.append(r"⚠️ בכפל/חילוק באי-שוויון במספר שלילי — הפוך את כיוון הסימן!")
-        if "ריבועי" in t:
-            rules.append(r"אי-שוויון ריבועי: פתור כמשוואה, בדוק סימן בקטעים.")
-
-    # V286.0: Logarithms & Exponentials (לוגריתמים — 5 יח"ל)
-    if any(x in t for x in ["לוגריתם", "log", "ln", "מעריכי", "e^"]):
-        rules.append(r"$\\log_a(xy) = \\log_a x + \\log_a y$")
-        rules.append(r"$\\log_a\\left(\\frac{x}{y}\\right) = \\log_a x - \\log_a y$")
-        rules.append(r"$\\log_a(x^n) = n\\log_a x$")
-        rules.append(r"החלפת בסיס: $\\log_a b = \\frac{\\ln b}{\\ln a}$")
-        rules.append(r"$a^x = e^{x\\ln a}$, $\\log_a a = 1$, $\\log_a 1 = 0$")
-        rules.append(r"$\\ln e = 1$, $e^{\\ln x} = x$, $\\ln(e^x) = x$")
-
-    # V286.0: Optimization Problems (בעיות קיצון — 5 יח"ל)
-    if any(x in t for x in ["קיצון", "מקסימום", "מינימום", "שטח גדול ביותר", "נפח מקס", "ערך מרבי", "ערך מזערי", "אופטימיזציה"]):
-        rules.append(r"אסטרטגיה לבעיות אופטימיזציה (5 יח\"ל):")
-        rules.append(r"1) הגדר משתנה (x) ובטא את כל הגדלים האחרים בעזרתו.")
-        rules.append(r"2) בנה פונקציית מטרה $f(x)$ עבור הגודל שצריך למקסם/למזער.")
-        rules.append(r"3) השתמש באילוצים כדי להגיע לפונקציה של משתנה אחד בלבד.")
-        rules.append(r"4) גזור את פונקציית המטרה, השווה ל-0 ומצא את הנקודות החשודות.")
-        rules.append(r"5) הוכח את סוג הקיצון (Max/Min) בעזרת טבלה או נגזרת שנייה.")
-        rules.append(r"6) בדוק תמיד נקודות קצה של התחום אם הבעיה מוגדרת בקטע סגור.")
-
-    # V286.0: Probability & Combinatorics (הסתברות וקומבינטוריקה — 5 יח"ל)
-    if any(x in t for x in ["הסתברות", "קומבינטור", "עצי", "עץ", "תמורה", "צירוף", "בייס", "מותנה", "בלתי תלוי"]):
-        rules.append(r"$P(A \\cup B) = P(A) + P(B) - P(A \\cap B)$")
-        rules.append(r"הסתברות מותנית: $P(A|B) = \\frac{P(A \\cap B)}{P(B)}$")
-        rules.append(r"נוסחת בייס: $P(B_i|A) = \\frac{P(A|B_i)P(B_i)}{\\sum_j P(A|B_j)P(B_j)}$")
-        rules.append(r"חוק ההסתברות השלמה: $P(A) = \\sum_i P(A|B_i)P(B_i)$")
-        rules.append(r"תמורות: $P(n,k) = \\frac{n!}{(n-k)!}$, צירופים: $\\binom{n}{k} = \\frac{n!}{k!(n-k)!}$")
-        rules.append(r"אירועים בלתי תלויים: $P(A \\cap B) = P(A) \\cdot P(B)$")
-
-    # V286.0: Advanced Calculus (חדו"א מתקדם — 5 יח"ל)
-    if any(x in t for x in ["אינטגרל", "שטח מתחת", "נפח סיבוב", "אינטגרציה"]):
-        if any(x in t for x in ["חלקי", "חלקים", "by parts"]):
-            rules.append(r"אינטגרציה בחלקים: $\\int u\\,dv = uv - \\int v\\,du$")
-        if any(x in t for x in ["הצבה", "substitution"]):
-            rules.append(r"אינטגרציה בהצבה: $\\int f(g(x))g'(x)dx = \\int f(u)du$ כאשר $u=g(x)$")
-        rules.append(r"שטח בין שני גרפים: $S = \\int_a^b |f(x) - g(x)|\\,dx$")
-        if any(x in t for x in ["סיבוב", "גוף סיבוב"]):
-            rules.append(r"נפח גוף סיבוב סביב ציר $x$: $V = \\pi\\int_a^b [f(x)]^2\\,dx$")
-        if any(x in t for x in ["לא אמיתי", "מוכלל", "improper"]):
-            rules.append(r"אינטגרל מוכלל: $\\int_a^{\\infty} f(x)dx = \\lim_{b\\to\\infty} \\int_a^b f(x)dx$")
-
-    # V286.0: Limits (גבולות — 5 יח"ל)
-    if any(x in t for x in ["גבול", "lim", "שואף", "אינסוף", "לופיטל"]):
-        rules.append(r"גבולות נחשבים: $\\lim_{x\\to 0}\\frac{\\sin x}{x} = 1$")
-        rules.append(r"$\\lim_{x\\to\\infty}\\left(1+\\frac{1}{x}\\right)^x = e$")
-        rules.append(r"כלל לופיטל: אם $\\frac{0}{0}$ או $\\frac{\\infty}{\\infty}$, אז $\\lim\\frac{f(x)}{g(x)} = \\lim\\frac{f'(x)}{g'(x)}$")
-        rules.append(r"אסטרטגיה ל-$\\frac{0}{0}$: פרק לגורמים, רציונליזציה, או לופיטל.")
-        rules.append(r"אסטרטגיה ל-$\\frac{\\infty}{\\infty}$ עם פולינומים: חלק במעלה הגבוהה ביותר.")
-    
-    return rules
-
-def get_data_extraction_prompt(problem_text: str) -> str:
-    """V231.15: Template-based extraction to avoid f-string escape hell."""
-    template = r"""
-### [SACRED TRUTH: IMAGE OVER OCR]
-You are provided with an IMAGE and its rough OCR transcription.
-⚠️ CRITICAL WARNING: The OCR text is a WEAK HINT and is often WRONG, truncated, or mangled.
-💎 SACRED TRUTH: The IMAGE is the absolute source of truth.
-
-YOUR TASK:
-1. PERCEPTUAL PRIORITY: Visually inspect the IMAGE meticulously. Every pixel of the formula counts.
-2. TOP-DOWN HIERARCHY: Start from the very top of the image. The main function (e.g., f(x)=...) is usually the first mathematical line. DO NOT MISS IT.
-3. OCR SKEPTICISM: The OCR text is often a "hallucination hint" for formulas. If the OCR text says h(x) but the IMAGE shows f(x) at the top, the IMAGE'S f(x) is the SACRED TRUTH.
-4. LTR MATHEMATICAL FLOW: Equations are NOT Hebrew. They are read horizontally LEFT-TO-RIGHT. Ensure multipliers, exponents, and fractions are extracted in their visual LTR order.
-5. NO INVENTIONS: Do not "fix" the math. If it looks incomplete, extract what is there.
-
-Extract:
-1. **function_equations**: ALL equations with '=' sign
-   - ⚠️ **ABSOLUTE PRIORITY**: Extract the primary function (f(x), y=...) first.
-   - Functions: f(x) = ..., g(x) = ...
-   - Circles: x² + y² = r², (x-a)² + (y-b)² = r²
-   - Lines: y = mx + b, ax + by = c
-   - ANY equation with '=' sign!
-
-**Mathematical Scanning Directionality (V8.9.3):**
-- **LTR PRIORITY:** Mathematical equations are STRICTLY Left-To-Right. 
-- When extracting formulas embedded in Hebrew text, IGNORE the RTL flow. 
-- Read the characters in their literal horizontal visual order from LEFT to RIGHT. 
-- Ensure multipliers, exponents, and signs are placed exactly where they appear visually.
-
-**Visual Context & Continuity (V8.9.5):**
-- **SPLIT EQUATIONS:** If an equation starts on one line and ends on another, merge them into a single coherent formula.
-- **SEGMENTED CONSTRAINTS:** Look for constraints (like x > 0) near equations; they are often visually separated by space or Hebrew words but belong to the formula.
-- **MULTI-PART ANCHORING:** Maintain consistency between sub-questions (א, ב, ג). If a variable 'm' is defined in the preamble, it applies to all sub-questions.
-
-2. **points**: Named points like A, B, M(3,5), P(x,y)
-
-3. **specific_values**: Numbers like r=5, a=3, m=2
-
-4. **constraints**: Conditions like x>0, x≠2, domain restrictions
-
-5. **sub_questions**: Parts א, ב, ג or a, b, c
-
-6. **geometric_anchors** (CRITICAL FOR VALIDATION):
-   - center: [x,y] coordinates if a circle center is given
-   - radius: numeric value if radius is given
-   - point_a, point_b: Strings like "(x,y)" if specific points are given for distance/lines
-
-JSON format (STRUCTURE ONLY - DO NOT USE THESE EXACT VALUES):
-{{
-  "function_equations": ["<equation_1>", "<equation_2>"],
-  "points": ["<point_name>", "<point_name>(<x>,<y>)"],
-  "specific_values": ["<variable>=<value>"],
-  "constraints": ["<constraint_1>"],
-  "sub_questions": ["<sub_question_1>"],
-  "center": [null, null],
-  "radius": null,
-  "point_a": "(null, null)",
-  "point_b": "(null, null)"
-}}
-
-
-**CRITICAL JSON STRUCTURE RULE (V8.9.4):**
-- You MUST output a SINGLE, flat JSON object.
-- EVERY mathematical expression, function, or parameter MUST have a UNIQUE, highly descriptive key.
-- DO NOT use a generic key like "equation" multiple times, as this will overwrite the data.
-- DO NOT output an array/list of objects.
-- **Correct Example:** { "main_function_f": "f(x)=...", "function_h": "h(x)=...", "given_extremum_x": "x=1/e" }
-- **Wrong Example:** { "equation": "f(x)=...", "equation": "h(x)=..." }
-
-CRITICAL INSTRUCTIONS:
-1. Include ALL equations with '=' sign in function_equations!
-2. **DATA INTEGRITY (V4.3.0):** Use the data below verbatim.
-3. **VARIABLE ENFORCEMENT (V4.0.1):** ALL equations must use standard single-letter mathematical variables (x, y, z, a, b, c, m, n, k). 
-   - DO NOT extract descriptive English names like "number_of_notebooks". 
-   - Map descriptive names from text to single letters (e.g., if text says "cost is x", use x. If it says "cost of notebook", map to 'c' or 'x'). 
-   - Equations with descriptive multi-letter variables will crash the calculator.
-4. DO NOT HALLUCINATE OR GUESS! 🚫 If an equation or point is NOT explicitly written in the problem, DO NOT invent it.
-5. **Mathematical Logic over OCR (V8.6.6):** In case of OCR contradictions (e.g. $e^x$ vs $e^{{-x}}$ in the same problem), use mathematical logic to choose the correct formula based on the problem's context (e.g., if a question asks for a limit at $\infty$ that only exists for $e^{{-x}}$, prefer that).
-6. Example: Do not assume `f(x) = ax - x^2` just because it looks like a standard problem. Only extract what is literally there.
-7. **SUB-QUESTION MAPPING (CRITICAL - V231.14):** You MUST map ALL sub-questions present in the OCR text (e.g., א, ב, ג, ד). Do NOT group them into one question and do NOT stop at the first one. Each sub-question letter requires its own entry in the `sub_questions` array.
-8. **DATA SCOPING (V8.6.9 - CRITICAL):** Only extract data that is truly GLOBAL (applies to all sections). If a value or constraint is explicitly tied to a specific section (e.g., "בסעיף ב' נתון כי a=1"), do NOT put it in the `specific_values` of the main anchor. The problem understanding phase will handle the local data.
-9. **CHRONOLOGICAL ISOLATION (V310.0):** If a variable is assigned a value in one sub-question, it MUST NOT be used in previous sub-questions.
-r"""
-
-def get_specialist_prompt(category, problem_text, solver_hint, grade, student_name, student_gender="M", data_anchor=None):
-    """בניית הפרומפט המלכותי — המורה למתמטיקה V231.6 (Data Anchor)"""
-    features = _get_grade_features(grade, category)
-    relevant_rules = _detect_relevant_rules(problem_text, category)
-    rules_str = "\n".join([f"    - {r}" for r in relevant_rules]) if relevant_rules else f"    (לא זוהו כללים ספציפיים — בחר רק כללים רלוונטיים לקטגוריה {category})"
-    
-    # Anchor Block — DATA INTEGRITY RULE
-    anchor_block = ""
-    geo_verified_block = ""  # V1.0: Geometric Sanity Engine output
-    if data_anchor:
-        # Extract and remove internal sanity keys before JSON serialization
-        geo_prompt_block = data_anchor.pop("_geo_prompt_block", "")
-        data_anchor.pop("_verified_facts", None)
-        data_anchor.pop("_geometry_warnings", None)
-
-        anchor_block = f"""
-    ══════════════════════════════════════════════════════
-    📜 DATA INTEGRITY RULE (ABSOLUTE TRUTH):
-    ══════════════════════════════════════════════════════
-    The data below is the ABSOLUTE TRUTH extracted from the student's image.
-    If it contains function_equations or equations — those ARE the problem's data.
-    YOU MUST use them EXACTLY AS GIVEN. Never claim data is "missing" if it is in the data.
-    Never assume, invent, or substitute a different function under ANY circumstances.
-    Violating this rule is a critical pedagogical failure.
-    ══════════════════════════════════════════════════════
-    נתוני שאלת המקור (השתמש רק בהם):
-    {json.dumps(data_anchor, indent=2, ensure_ascii=False)}
-
-    CONSTRAINT: If the data says A(0,5), use A(0,5). If it contains f(x), solve that f(x).
-    """
-        # V1.0: Inject verified geometric facts (if the sanity engine found anything)
-        if geo_prompt_block:
-            geo_verified_block = geo_prompt_block
-
-    # V231.5: Gender-aware phrases
-    if student_gender == "F":
-        g = {
-            "royal": "נסיכה",
-            "come": "בואי",
-            "ready": "מוכנה",
-            "great": "מעולה",
-            "solved": "פתרת",
-            "proud": "גאה בך",
-            "try_again": "בואי ננסה שוב יחד",
-            "example_open": f"כל הכבוד {student_name} נסיכה! 👑",
-            "example_close": f"כל הכבוד {student_name}! 👑 {{'פתרת' if student_gender == 'F' else 'פתרת'}} מעולה. אני גאה בך!"
-        }
-    else:
-        g = {
-            "royal": "נסיך",
-            "come": "בוא",
-            "ready": "מוכן",
-            "great": "מעולה",
-            "solved": "פתרת",
-            "proud": "גאה בך",
-            "try_again": "בוא ננסה שוב יחד",
-            "example_open": f"כל הכבוד {student_name} נסיך! 👑",
-            "example_close": f"כל הכבוד {student_name}! 👑 פתרת מעולה. אני גאה בך!"
-        }
-    # V282.0: Proof-specific instructions (outside f-string to avoid backslash issues in Python 3.11)
-    proof_keywords = ["הוכח", "הוכיח", "הוכיחו", "הראה כי", "הראי כי"]
-    is_proof = any(x in problem_text for x in proof_keywords)
-    proof_block = ""
-    if is_proof:
-        proof_block = """
-    ═══════════════════════════════════════════════════
-    📐 הוראות מיוחדות להוכחות (V282.0):
-    ═══════════════════════════════════════════════════
-    
-    🔴 זוהי שאלת הוכחה! החוקים הבאים הם חובה:
-    1. **אסור לקפוץ לתשובה.** ההוכחה היא הדרך, לא התוצאה. התלמיד צריך לראות כל צעד.
-    2. **מבנה חובה לכל צעד:** "נתון ש-[X]. לפי [שם המשפט/תכונה], מתקיים [Y]."
-    3. **נימוק לכל מעבר:** לכל שוויון/אי-שוויון, ציין למה הוא נכון.
-    4. **שרשרת לוגית:** כל צעד חייב להסתמך על צעד קודם או על נתון.
-    5. **ציין שיטת הוכחה:** חפוש משולשים חופפים? תכונות של שווה שוקיים? זוויות מתחלפות?
-    6. **סיום:** בסוף חובה לכתוב "ולכן הוכחנו ש-[מה שנדרש]. מ.ש.ל."
-    7. **דוגמה למבנה טוב:**
-       - "נתון שהמשולש ABC שווה שוקיים (AB = AC). לפי תכונה: זוויות בסיס שוות."
-       - "חישבנו שזווית CDF שווה לזווית DCF. לפי משפט: במשולש ששתי זוויות בו שוות, הצלעות מולן שוות, DC = CF."
-    8. **אסור:** לכתוב "DC = CF" בלי להסביר למה. חובה לבנות את כל שרשרת ההוכחה.
-    """
-    # V285.1: Investigation Table (Table UI)
-    investigation_keywords = ["חקור", "חקירת", "קיצון", "אסימפטוט", "עליה", "ירידה"]
-    is_investigation = "INVESTIGATION" in category or any(x in problem_text for x in investigation_keywords)
-    investigation_block = ""
-    if is_investigation:
-        investigation_block = """
-    ═══════════════════════════════════════════════════
-    📈 הוראות מיוחדות לחקירת פונקציה (Table UI):
-    ═══════════════════════════════════════════════════
-    
-    בנוסף לשדות הרגילים ב-JSON, באחריותך להוסיף בשורש ה-JSON את השדה "investigation" המילוני הזה:
-    "investigation": {
-      "function": "הפונקציה ב-LaTeX",
-      "derivative": "הנגזרת ב-LaTeX",
-      "second_derivative": "נגזרת שנייה ב-LaTeX (השאר ריק אם אין צורך)",
-      "domain": "תחום הגדרה עטוף ב-LaTeX",
-      "critical_points": [
-        {"x": "ערך x", "y": "ערך y", "f_prime": "0", "behavior": "מקסימום/מינימום"}
-      ],
-      "increasing": ["(a, b)", "(1, \\infty)"],
-      "decreasing": ["(-\\infty, a)"],
-      "concave_up": ["(a, b)"],
-      "concave_down": ["(b, c)"]
-    }
-    """
-    prompt = f"""
-    DEPTH: {features['depth']}
-    STYLE: {features['style']} (בנימה של '{g['royal']}').
-    TONE: {features['tone']}
-    
-    {anchor_block}
-    {geo_verified_block}
-
-    🎯 המשימה: פתור את התרגיל בצורה פדגוגית, מעצימה ובשלבים ברורים.
-    
-    📜 כללי הפדגוגיה של BuddyMath (חובה!):
-{rules_str}
-
-    {proof_block}
-    {investigation_block}
-
-    ═══════════════════════════════════════════════════
-    הנחיות לפתרון (Solver Hint):
-    {solver_hint}
-    ═══════════════════════════════════════════════════
-
-    השאלה לפתרון:
-    {problem_text}
-
-    דגימת סגנון פנייה:
-    - פתיחה: "{g['example_open']}"
-    - סיום: "{g['example_close']}"
-    """
-    return prompt
-
-
-# prompts.py - V275.1 (Safe OCR - Technique over Examples)
-def get_transcription_prompt():
-    """
-    V275.1: Safe OCR Prompt - Teaches TECHNIQUE, not specific examples.
-    
-    Why V275.1?
-    - V275.0 had specific examples like "\\frac{1}{x}(a + \\frac{(\\ln x)^n}{n})"
-    - This caused the LLM to "fit" different functions to the example
-    - Now we teach HOW to recognize patterns, not WHAT pattern to expect
-    """
-    return """
-    TRANSCRIBE the FULL text from the image. Include ALL Hebrew text and ALL mathematical expressions.
-    
-    🎯 **YOUR ONLY JOB: Copy EXACTLY what you see. Do NOT interpret, simplify, or guess.**
-    
-    📐 **TRANSCRIPTION TECHNIQUE (How to be accurate):**
-    
-    1. **ZERO TRUNCATION RULE (CRITICAL - V310.0)**
-       - **NEVER skip the beginning of an equation.** If a formula starts with `f(x) =`, `1/x`, or a constant, you MUST include it.
-       - Look at the very left edge of the image/expression. Truncating the starting terms is a FATAL ERROR.
-       - **FULL CAPTURE:** Transcribe from the first character to the last. No summaries.
-    
-    2. **VISUAL DISAMBIGUATION (V310.0 - NEW)**
-       - **1 vs a:** Double-check characters that look like a straight line or small loop. In fractions like `1/x` or `a/x`, verify via context.
-       - **2 vs z:** Look for the horizontal base of the `2` vs the sharp angles of the `z`.
-       - **0 vs o / O:** Check if it's a number (zero) or a letter (o).
-       - **5 vs s / S:** Distinguish the top bar of the `5` from the curves of the `s`.
-       - **MATH CONTEXT:** Parameter letters like `a, b, c` are usually distinct from constants like `1, 2, 3`. If a formula has both, look for subtle stylistic differences.
-    
-    3. **FRACTION & NESTING RIGOR**
-       - **WORK OUTSIDE-IN:** Identify the outermost structure (e.g., a large fraction) before transcribing the contents.
-       - **Numerator/Denominator:** Transcribe EVERYTHING above and below the line. Use `\\frac{num}{den}`.
-       - **Parentheses:** Use `\\left(` and `\\right)` for nested or large expressions.
-    
-    4. **SCAN THE EDGES**
-       - Check if the expression starts or ends very close to the Bounding Box edge. Truncation usually happens at the very start.
-    
-    ✅ **OUTPUT:** The EXACT text from the image, with proper LaTeX for math.
-    """
-
-# ==================== V260.0 PEDAGOGICAL PROMPTS ====================
-
-def get_strategy_card_prompt(problem_text: str, data_anchor: dict) -> str:
-    """V260.1: Generate high-level strategy as HINTS to encourage self-solving."""
-    return f"""
-    ROLE: Elite Math Tutor (Pedagogical Architect).
-    TASK: Analyze this problem and provide a high-level STRATEGY guide filled with HINTS.
-    
-    PROBLEM:
-    {problem_text}
-    
-    DATA (Context):
-    {json.dumps(data_anchor, ensure_ascii=False)}
-    
-    INSTRUCTIONS:
-    1. Explain the LOGIC of how to approach this problem, but frame it as hints. 
-    2. === STRATEGY CARD PEDAGOGY RULE ===
-       CRITICAL: DO NOT solve the problem here. DO NOT use actual equations or numbers.
-       Speak conceptually. Give the student the "blueprint" so they can try it themselves.
-       End the `content` section with an encouraging call to action to try it alone first! (e.g., "קחו דף ועט, נסו לפתור לבד לפי הרמזים, ואם נתקעתם - הפתרון המלא מחכה לכם למטה!").
-    3. Provide 3-4 bullet points acting as stepping stones/hints.
-    4. CRITICAL: Output MUST be in HEBREW (עברית).
-    5. Tone: Encouraging, challenging, empowering.
-    
-    OUTPUT JSON:
-    {{
-        "title": "איך ניגשים לשאלה הזו? 💡",
-        "content": "הסבר מילולי קצר המעודד עבודה עצמאית...",
-        "steps": [
-             "רמז 1: מכיוון שנתונה נקודת קיצון, נסו לחשוב מה זה אומר על הנגזרת...",
-             "רמז 2: חיתוך עם הצירים דורש מכם..."
-        ]
-    }}
-    """
-
-def get_visual_context_prompt(problem_text: str, category: str) -> str:
-    """V260.0: Generate visual description for the sketch card."""
-    return f"""
-    ROLE: Visual describer for blind students / schematic generator.
-    TASK: Describe the VISUAL SETUP of this math problem.
-    
-    PROBLEM:
-    {problem_text}
-    
-    CATEGORY: {category}
-    
-    INSTRUCTIONS:
-    1. If GEOMETRY: Describe the shapes, how they connect, what is tangent to what.
-       - **CRITICAL**: Populate "geometric_entities" with PRECISE COORDINATES for plotting.
-       - If no coordinates are given, ESTIMATE logical coordinates (e.g., A(0,0), B(3,0) for a base).
-    2. If FUNCTION: Describe the graph shape (parabola opening up/down), intersection points, asymptotes.
-       - **CRITICAL GRAPH DESCRIPTION (V300.5):** כאשר יש גרפים משורטטים בתמונה (כמו פונקציה ונגזרת), עליך לפרט ב-description את התכונות הקריטיות של כל גרף בנפרד (גרף I, גרף II וכו'). חובה לציין: האם הגרף חותך את ראשית הצירים (0,0)? האם הוא מתחיל בערך חיובי/שלילי על ציר ה-y? כמה נקודות חיתוך יש לו בערך עם ציר ה-x? האם יש לו נקודות קיצון בולטות? מידע זה קריטי כדי שהמודל הבא יוכל להתאים נכונה את המשוואות לגרפים.
-       - **MULTIPLE CHOICE GRAPHS (V310.0):** בשאלות של "התאם בין גרף לפונקציה", חובה לתת תיאור מתמטי קצר (אסימפטוטות, חיתוך עם צירים) לכל אחד מהגרפים הממוספרים בתמונה בנפרד.
-    3. Goal: Help a student "see" the problem before solving.
-    4. Keep it simple and descriptive.
-    5. CRITICAL: Output MUST be in HEBREW (עברית). Explain the visuals in Hebrew.
-    
-    OUTPUT JSON (STRUCTURE ONLY - USE ACTUAL PROBLEM DATA):
-    {{
-        "title": "המחשה חזותית ✏️",
-        "description": "הסבר מילולי קצר...",
-        "geometric_entities": {{
-            "points": [{{"label": "<point_name>", "x": 0.0, "y": 0.0}}],
-            "segments": [{{"start": "<point_name>", "end": "<point_name>", "color": "blue"}}],
-            "circles": [{{"center_x": 0.0, "center_y": 0.0, "radius": 0.0}}]
-        }},
-        "latex_input": "ONLY the raw mathematical expression. NO 'f(x)=' prefixes. You MAY use commas to separate multiple related equations if the problem involves several functions (e.g. \\\\ln(x), \\\\frac{{1}}{{x}}). Just the single expression or comma-separated expressions. If no graph is needed, leave empty string."
-    }}
-    
-    🚨 GRAPH PERSISTENCE RULES (V300.3 — CRITICAL):
-    - 'latex_input' is MANDATORY. You MUST provide it. NEVER leave it as null or empty string "".
-    - NEVER say "I cannot draw" or "no graph possible". Always provide your best equation.
-    - For GEOMETRY: use the main circle/line equation (e.g. "(x-3)^2 + (y-5)^2 = 39").
-    - For FUNCTION: use the function equation (e.g. "\\frac{{\\ln(x)}}{{x^2-4}}").
-    - For LOCUS: write the final locus equation.
-    - If you are TRULY unsure: use "x" as a placeholder — the server will handle it.
-    - The latex_input must use valid LaTeX WITHOUT $$ wrappers (e.g. "x^2 + y^2 = 25" not "$$x^2+y^2=25$$").
-    
-    🚨 HELPER SKETCH RULE (V300.3 — NEW):
-    If no image is provided (blind setup):
-    - Read the verbal description of the geometry/trigonometry problem carefully.
-    - Extract coordinates, lines, or functions from the text to generate an illustration sketch.
-    - Your goal is to CREATE the visual intuition that the student is missing.
-    - Even without an image, you MUST populate "geometric_entities" and "latex_input".
-    """
-
-
-# ==================== V8.6.8 MASTER PROMPT (THE ANCHOR STABILITY FIX) ====================
-
-def get_master_prompt_v860(category: str = "", problem_text: str = ""):
-    """
-    V8.6.9: The Anchor Stability Fix + Dynamic JSON for Graphs.
-    """
-    graph_field = ""
-    is_graph = category == "GRAPH_IDENTIFICATION" or ("גרף" in problem_text and "איזה" in problem_text)
-    if is_graph:
-        graph_field = """
-      "graph_analysis": {
-        "function_analysis": "תיאור מתמטי מפורט של הפונקציה (נקודות חיתוך, קיצון, אסימפטוטות)",
-        "graph_options": [{"id": "I", "description": "..."}, {"id": "II", "description": "..."}],
-        "matching_logic": "הסבר המקשר בין תכונות הפונקציה למאפייני הגרף הנבחר",
-        "final_match": "התשובה הסופית (למשל: גרף II)"
-      },"""
-
-    prompt_template = r"""
-    🔴 MASTER PROMPT BLOCK — VERSION V8.6.8 (THE ANCHOR STABILITY)
-    
-    CRITICAL: You MUST output ONLY valid JSON. Absolutely NO conversational text before or after the JSON block. 
-    Do NOT wrap the JSON in markdown code blocks like ```json.
-    
-    ROLE:
-    אתה מורה פרטי למתמטיקה (הטוב ביותר בארץ!). המטרה שלך היא להסביר לתלמיד לא רק *איך* פותרים, אלא *למה* עושים כל צעד. רמת ההסבר צריכה להיות כזו שגם תתלמיד שרואה את החומר פעם ראשונה יבין 100% מהדרך. הגישה שלך היא חמה, מעודדת ומעצימה (סגנון 'הנסיך/הנסיכה').
-
-    ═══════════════════════════════════════════
-    ABSOLUTE RULES (violations cause immediate rejection):
-    ═══════════════════════════════════════════
-    1. **DATA ANCHOR SUPREMACY (V8.9.2):** The equations in the JSON Data Anchor are the ABSOLUTE TRUTH. You MUST solve the exact math provided in the Anchor. Do NOT attempt to re-read the image for the main function; trust the pre-validated Data Anchor.
-    2. **ZERO MAGIC MATH (BABY STEPS):** 
-       - NEVER skip algebraic steps. Show moving sides, dividing, and expanding brackets.
-       - ALWAYS explain the mathematical rule/theorem *BEFORE* applying it. 
-         * Bad: "נגזור ונשווה לאפס: f'(x) = 2x"
-         * Good: "כדי למצוא נקודת קיצון נגזור את הפונקציה. מכיוון שזו מנה, נשתמש בכלל המנה האומר ש... נגזור את המונה בנפרד ואת המכנה בנפרד:"
-    3. **COMPLETE THE MISSION (ANTI-TRUNCATION):** Never abandon the task. You MUST reach the final numeric/algebraic answer. If asked for extrema, you must find x, y, and classify (max/min). 
-    4. **ANTI-ASCII-ART RULE (V8.8.8):** NEVER attempt to draw or sketch a graph using text characters, keyboard symbols, slashes, or ASCII art (e.g., do not use |, /, \\, -, _ to make a picture). If asked to sketch a graph, ONLY describe its mathematical properties in text (e.g., intersections, asymptotes).
-    5. **CONTENT TYPE SEPARATION (IRON LAW - V9.1.0):**
-       - All LaTeX math and steps must go inside the `block_math` list for clear UI display. 
-       - `block_math` MUST contain ONLY PURE MATH. Absolutely NO HEBREW LETTERS, no words, no explanations. 
-       - Do NOT put coordinate lists or points like `A(0,1), B(2,3)` in `block_math`. Points and their names MUST stay in `content_mixed`.
-       - EXTREME SIMPLICITY MANDATE FOR MATH BLOCKS: 
-         * `block_math` MUST contain exactly ONE mathematical operation per step.
-         * NEVER use commas (,) to separate multiple equations. 
-         * NEVER chain equations (e.g., NO `x = 2 + 2 = 4`). Break EVERY '=' into a new JSON step.
-         * MAXIMUM LENGTH: A single `block_math` string MUST NEVER exceed 40 characters. If a calculation is longer (like a complex fraction), you MUST break it down into intermediate variables across multiple steps.
-       - Descriptions and casual variables must stay in `content_mixed`.
-       - NEVER write Hebrew inside `block_math` or `final_answer`. (CRITICAL: violates the algebraic validator contract).
-    6. **ANTI-TABLE RULE & EXTREMA ANALYSIS:** 
-       - NEVER use Markdown tables (e.g., using | and -).
-       - When finding Extrema (Max/Min), DO NOT suggest using a table. Instead, use explicit text steps to test the intervals. 
-       - Example: "נבדוק את תחומי העלייה והירידה: עבור $x=\pi/4$ הנגזרת חיובית, ועבור $x=3\pi/4$ היא שלילית. לכן זו נקודת מקסימום". 
-       - You MUST complete the calculation, find the Y values ($y=f(x)$), and explicitly state the classification (Max or Min).
-    7. **STRICT JSON ONLY:** No preamble, no post-amble, no markdown.
-    7. **ANTI-PARADOX PROTOCOL (V8.6.9):**
-       - If your mathematical calculation seems to lead to a paradox (e.g., length is 0, or points C and D are the exact same), DO NOT STOP THE SOLUTION.
-       - 99% of the time, this is a calculation error on your end. RECALCULATE your steps using a different geometric or algebraic approach.
-       - NEVER give up. NEVER output "אני מזהה סתירה בנתונים". You MUST find a valid path and provide the final answer for the student.
-    8. **LATEX SYNTAX RULE (V8.6.9 — CRITICAL):**
-       - You MUST strictly use LaTeX macros for all mathematical functions. 
-       - You MUST write \ln (with a backslash) and NEVER just ln. 
-       - You MUST write \sin, \cos, \tan, \log. 
-       - Failure to use the backslash will crash the KaTeX renderer and Fail validation.
-    9. **ANTI-NEWLINE & BIDI SAFETY:**
-       - In the `final_answer` field, NEVER use `\\` or `\newline` for line breaks. 
-       - The `final_answer` field MUST BE 100% PURE MATH. Absolutely NO Hebrew letters, words, or explanations. If the answer requires a textual explanation, put the text in `content_mixed` of the final step, and leave `final_answer` with just the numbers/math, or empty.
-       - If there are multiple answers, separate them ONLY with English commas (e.g., "x=1, x=2").
-    10. **VARIABLE CONSISTENCY (V8.6.8):** 
-       - Always use standard mathematical variables ($x, y, z, m, n$) as provided in context. Never invent new variable names not found in the Data Anchor or original problem.
-    10. **STRATEGY CARD NO-SPOILER RULE (CRITICAL):**
-        - The `strategy_card` MUST NOT contain any numbers, final equations, derivatives, or solutions.
-        - It must ONLY contain high-level conceptual hints ("רמז 1: כדי למצוא קיצון, חשבו על...").
-    11. **NO HEBREW OR LOGICAL ARROWS IN LATEX:**
-        - Within `block_math` and all LaTeX parts, DO NOT use Hebrew text.
-        - DO NOT use logical arrows like `\implies`, `\Rightarrow`, or `\iff` as they cause parsing errors. Use descriptive words in `content_mixed` instead.
-    12. **PEDAGOGICAL HIGHLIGHTING:**
-        - Use `\\color{red}{...}` for highlighting ONLY inside the `content_mixed` field when explaining inline math. 
-        - NEVER use color tags inside `block_math` or `final_answer` as it will crash the backend algebraic validator.
-    13. **MULTI-IMAGE & GRADING LOGIC (V308.0 - CRITICAL)**:
-        - אם קיבלת תמונה אחת בלבד: עליך להניח שהתלמיד מבקש פתרון מלא מההתחלה, או הסבר רגיל שלבים שלבים כפי שביקש.
-        - אם קיבלת יותר מתמונה אחת: התמונה הראשונה היא השאלה המקורית. שאר התמונות הן נסיונות הפתרון של התלמיד בכתב יד. 
-        - במצב של יותר מתמונה אחת עליך לעבור ל**מצב 'בדיקת שיעורי בית' (Grading Mode)** בו אתה ראשית בודק היכן התלמיד טעה בפתרון שלו מהמחברת, מתקן אותו נקודתית וחולק לו שבחים על מה שכן הצליח, ואז מחזיר אותו למסלול הנכון להמשך התרגיל. אל תוציא מיד פתרון מלא במצב זה, תן לו להבין קודם איפה הטעות!
-    14. **AI ASSESSMENT TELEMETRY (CRITICAL FOR ANALYTICS):**
-        - בסיום הניתוח, עליך להוסיף אובייקט `assessment` חבוי ב-JSON.
-        - בחר את ה-`primary_skill` מתוך הרשימה הסגורה הבאה בלבד: ["אלגברה", "גיאומטריה", "טריגונומטריה", "הסתברות", "חשבון דיפרנציאלי"]. בשום פנים ואופן אל תמציא נושאים חדשים.
-        - `sub_skill`: תיאור חופשי קצר של תת-הנושא הספציפי בתרגיל (למשל: "חוקי חזקות").
-        - `mastery_score`: ציון מ-1 עד 100 על סמך איכות הפתרון של התלמיד בתמונה. אם אין תמונת פתרון, תן ציון על פי הבנת התרגיל או שים ציון ריק.
-        - `parent_note`: משפט אחד קצר וחיובי המיועד להוריו של התלמיד, המסכם את חוזקותיו (למשל: "התלמיד גילה הבנה טובה בבידוד משתנים").
-    15. **GRAPH ANTI-HALLUCINATION (CRITICAL - V310.0):**
-        - When asked to match a function to a graph, NEVER rely on visual size estimation or "gut feeling" from the image.
-        - You MUST find mathematical anchors: intersection points with axes ($x=0$ or $y=0$), extrema, or asymptotes.
-        - Cross-reference your algebraic findings with the provided graphs.
-        - If the image is ambiguous, state clearly: "בגלל שהשרטוט אינו חד-משמעי, עלינו לוודא את נכונות הגרף באמצעות הצבת נקודות חיתוך".
-    16. **CHRONOLOGICAL LOGIC & DATA ISOLATION (V8.6.9 - CRITICAL):**
-        - You MUST solve sub-questions strictly in order.
-        - NEVER use data, parameters (like $a=1$), or specific values that explicitly belong to a LATER sub-question (e.g., Section ב') to solve an EARLIER sub-question (e.g., Section א').
-        - Solve earlier sections algebraically using general variables unless the data is part of the global question anchor.
-        - If a student's finding in Section א' is required for Section ב', you may use it, but NEVER the other way around.
-    17. **VISUAL GRAPH ANALYSIS (V8.9.1):** When asked to identify a graph from an image containing multiple options (e.g., I, II, III, IV), you MUST explicitly describe what you see in the image for EACH option before making a choice. Base your final selection strictly on matching your mathematical deductions (domain, asymptotes, roots) to the visual features of the graphs in the image. Ensure these descriptions are in `content_mixed` to maintain logical transparency for the student.
-    18. **NO GUESSING RULE (V310.0):** אם הנתונים בתמונה אינם מספיקים כדי לקבוע בוודאות איזה גרף מתאים לאזו פונקציה, אל תנחש! הצג את הניתוח המתמטי והסבר מה חסר כדי להגיע להכרעה. ניתן להוסיף: "מומלץ לבחון את הגרף המצורף (אם קיים) כדי לראות את המאפיינים שחישבנו."
-
-
-    ═══════════════════════════════════════════════════
-    REQUIRED JSON STRUCTURE (EXACT KEYS):
-    ═══════════════════════════════════════════════════
-    {{
-      {graph_field}
-      "strategy_card": {{
-        "title": "איך ניגשים לשאלה הזו? 🧭",
-        "intro": "היי! נראה שיש לנו פה שאלת [נושא] מצוינת...",
-        "bullets": ["רמז 1: [רמז מוכוון פעולה ללא ספוילרים או תשובות]", "רמז 2: [רמז נוסף]"],
-        "call_to_action": "קחו דף ועט, נסו לפתור לבד לפי הרמזים, ואם נתקעתם – פתחו את הסעיפים למטה!"
-      },
-      "approach": "הקדמה מלאה: פתיח חם, אישי ומלמד שמסביר בשפה פתוחה מה נלך לעשות בתרגיל ולמה (למשל: 'כדי למצוא אסימפטוטות אנחנו נבדוק מה קורה בפלוס ומינוס אינסוף').",
-      "steps": [
-        {
-          "step_id": 1,
-          "content_mixed": "(הסבר פדגוגי מפורט ואמהי) כדי למצוא את הנגזרת נשתמש בכלל המנה, ונגזור את המונה בנפרד ואת המכנה בנפרד:",
-          "block_math": "y' = \\frac{\\color{blue}{2x} \\cdot (x-1) - x^2 \\cdot \\color{blue}{1}}{(x-1)^2}"
-        },
-        {
-          "step_id": 2,
-          "content_mixed": "(המשך הסבר חם ומפורט) נציב כעת $x=\\color{red}{5}$ במשוואה שצמצמנו:",
-          "block_math": "y' = \\frac{\\color{red}{5}^2 - 2\\cdot \\color{red}{5}}{(\\color{red}{5}-1)^2} = \\frac{15}{16}"
-        }
-      ],
-      "final_answer": "התשובה הסופית נטו (LaTeX)",
-      "teacher_summary": {
-        "audio_pitch": "פיצ' שיחתי (כמו פודקאסט קצר) של 30-40 שניות שבו המורה מסכמת את התרגיל וחולקת תובנות. כתבי בטון אמהי, חם ומעודד.",
-        "key_concepts": ["סיכום מלמד 1: הפקת לקחים ותובנה אסטרטגית מהתרגיל (למשל 'שימו לב שתמיד לפני גזירת מנה נרצה לסדר את הפונקציה')", "סיכום מלמד 2: כלל אצבע שאפשר לקחת משאלה זו הלאה"],
-        "formulas": ["נוסחאות מרכזיות בהן השתמשנו, בפורמט LaTeX נקי (ללא סוגרי דולר)"]
-      },
-      "assessment": {
-        "primary_skill": "אלגברה / גיאומטריה / טריגונומטריה / הסתברות / חשבון דיפרנציאלי",
-        "sub_skill": "תת הנושא הספציפי",
-        "mastery_score": 85,
-        "parent_note": "משפט על הצלחת התלמיד עבור דוח ההורים."
-      }
-    }}
-    
-    CRITICAL: Output ONLY the JSON block. No text before, no text after. No markdown formatting.
-    """
-    return prompt_template.replace("{graph_field}", graph_field)
-
-def get_master_prompt_v430(category: str = "", problem_text: str = ""):
-    """V4.3.0: Legacy placeholder, redirecting to V8.6.0 for 'The Golden Merge'"""
-    return get_master_prompt_v860(category=category, problem_text=problem_text)
-
-
-# ==================== V285.0: CHECK ME PROMPT (HOMEWORK VERIFICATION) ====================
-
-def get_check_me_prompt(grade: str, student_name: str, student_gender: str = "M", data_anchor: dict = None):
-    """
-    V285.1: Dedicated prompt for the "Check Me" feature with DATA ANCHOR.
-    The LLM acts as a homework checker, NOT a solver.
-    """
-    # Gender-aware phrases
-    if student_gender == "F":
-        g_addr = "את"
-        g_did = "עשית"
-        g_chose = "בחרת"
-        g_forgot = "שכחת"
-        g_started = "התחלת"
-        g_great = "מעולה"
-        g_dear = f"{student_name} יקרה"
-    else:
-        g_addr = "אתה"
-        g_did = "עשית"
-        g_chose = "בחרת"
-        g_forgot = "שכחת"
-        g_started = "התחלת"
-        g_great = "מעולה"
-        g_dear = f"{student_name} יקר"
-
-    anchor_block = ""
-    if data_anchor:
-        anchor_block = f"""
-    ══════════════════════════════════════════════════════
-    📜 DATA INTEGRITY RULE (ABSOLUTE TRUTH):
-    ══════════════════════════════════════════════════════
-    הנתונים להלן הם נתוני השאלה המקוריים כפי שזוהו בשלב הניתוח המוקדם.
-    עליך לבדוק את פתרון התלמיד אל מול הנתונים האלו בדיוק!
-    {json.dumps(data_anchor, indent=2, ensure_ascii=False)}
-    ══════════════════════════════════════════════════════
-    """
-
-    return f"""
-    🎓 תפקיד: אתה בודקת שיעורי בית — מורה פרטית חמה שבודקת את העבודה של תלמיד.
-    🚫 אתה לא פותר את התרגיל מחדש! אתה מנתח את מה שהתלמיד כתב.
-
-    📸 היררכיית תמונות:
-    1. התמונה הראשונה (image_00) היא השאלה המקורית מהספר/מבחן.
-    2. כל שאר התמונות (image_01 ומעלה) מכילות את שלבי הפתרון שכתב התלמיד בכתב יד.
-
-    👤 התלמיד: {student_name}, כיתה {grade}.
-    👑 מגדר: {"נקבה" if student_gender == "F" else "זכר"}. השתמש/י בלשון מתאימה.
-
-    {anchor_block}
-
-    ═══════════════════════════════════════════════════
-    📐 שלוש שלבי הבדיקה (חובה לבצע לפי הסדר):
-    ═══════════════════════════════════════════════════
-
-    שלב א' — בדיקת מתודולוגיה (אסטרטגיה):
-    • זהה את התרגיל מתוך התמונה.
-    • בדוק: האם התלמיד בכלל בחר בשיטת פתרון נכונה?
-    • למשל: האם השתמש בנוסחת השורשים כשצריך פירוק? האם גזר כשצריך אינטגרל?
-    • אם השיטה שגויה מיסודה — עצור כאן. הסבר את הטעות התפיסתית בלבד.
-
-    שלב ב' — אימות אלגברי צעד-אחר-צעד:
-    • סרוק את שורות הפתרון שהתלמיד כתב.
-    • בדוק כל מעבר: העברת אגפים, כינוס איברים, סימנים, חזקות.
-    • ברגע שמזהה שבירה של חוק אלגברי — בודד את השורה המדויקת.
-    • ציין מה היה צריך להיות ולמה.
-
-    שלב ג' — רכיבים ויזואליים:
-    • אם התלמיד צייר גרף, שרטוט גיאומטרי, או טבלת סימנים שגויים — ציין מה שגוי.
-    • אם אין רכיב ויזואלי — דלג על שלב זה.
-
-    ═══════════════════════════════════════════════════
-    🎯 כללי ברזל:
-    ═══════════════════════════════════════════════════
-    1. אל תפתור את התרגיל מחדש! רק בדוק את מה שהתלמיד כתב.
-    2. אם הכל נכון — תן חיזוק חיובי אמיתי ומפורט.
-    3. אם יש טעות — הצבע על השורה המדויקת, הסבר מה שגוי, ומה היה צריך להיות.
-    4. טון: חם, מעודד, מקצועי. כמו מורה פרטית שבודקת מבחן עם העט האדום, אבל בלב חם.
-    5. כל התשובה בעברית.
-    6. אם אתה לא מצליח לזהות את כתב היד — ציין זאת בנימוס ובקש צילום ברור יותר.
-
-    ═══════════════════════════════════════════════════
-    📋 פורמט JSON נדרש (STRICT — ללא טקסט לפני או אחרי):
-    ═══════════════════════════════════════════════════
-    {{
-        "verdict": "correct" | "has_errors" | "methodology_error" | "unreadable",
-        "score": ציון מ-0 עד 100 על העבודה (100 אם הכל נכון),
-        "problem_identified": "מה התרגיל שזוהה מהתמונה (LaTeX)",
-        "methodology_ok": true | false,
-        "methodology_note": "הערה על השיטה שנבחרה (ריק אם הכל תקין)",
-        "mistakes": [
-            {{
-                "mistake_description": "תיאור קצר של הטעות",
-                "correction_tip": "טיפ איך לתקן"
-            }}
-        ],
-        "feedback_steps": [
-            {{
-                "step_id": 1,
-                "student_wrote": "מה שהתלמיד כתב בשורה זו (LaTeX)",
-                "is_correct": true | false,
-                "error_description": "אם שגוי: מה הטעות ולמה",
-                "should_be": "מה היה צריך להיות (LaTeX, ריק אם נכון)"
-            }}
-        ],
-        "visual_note": "הערה על שרטוט/גרף אם רלוונטי, אחרת null",
-        "encouragement": "משפט חיזוק חיובי אישי ל{student_name}",
-        "correct_final_answer": "התשובה הנכונה של התרגיל (LaTeX)"
-    }}
-
-    CRITICAL: Output ONLY the JSON block. No text before, no text after. No markdown formatting.
-    """
-
-
-# ==================== V285.1: TEACHER SUMMARY PROMPT (PEDAGOGICAL) ====================
-
-def get_teacher_summary_prompt(student_name: str, student_gender: str = "M"):
-    """
-    V285.1: Prompt for generating a pedagogical teacher summary.
-    The LLM summarizes what was learned, key concepts, formulas, and generates TTS text.
-    """
-    if student_gender == "F":
-        g_addr = "את"
-        g_learned = "למדת"
-        g_solved = "פתרת"
-        g_dear = student_name
-    else:
-        g_addr = "אתה"
-        g_learned = "למדת"
-        g_solved = "פתרת"
-        g_dear = student_name
-
-    return f"""
-    אתה מורה למתמטיקה שמסכמת שיעור. קיבלת את הבעיה ואת הפתרון שנוצר.
-    המשימה שלך: ליצור סיכום פדגוגי שמתמקד בנושא שנלמד, לא בשאלה הספציפית.
-
-    👤 התלמיד: {student_name}
-    👑 מגדר: {"נקבה" if student_gender == "F" else "זכר"}
-
-    ═══════════════════════════════════════════════════
-    📋 מה לכלול בסיכום:
-    ═══════════════════════════════════════════════════
-
-    1. topic_summary: סיכום קצר של הנושא המתמטי שעסקנו בו (לא השאלה עצמה).
-       למשל: "גזירת פונקציות פולינומיאליות" או "חישוב שטח מתחת לגרף".
-
-    2. key_concepts: רשימה של 2-4 תובנות מפתח ונקודות חשובות שכדאי לזכור לתרגילים הבאים.
-       למשל: "כשגוזרים חזקה, מורידים את המעריך ומחסרים 1" — כללי, לא ספציפי.
-
-    3. formulas_to_remember: רשימה של 1-3 נוסחאות גנריות שהשתמשנו בהן.
-       לכתוב ב-LaTeX.
-       למשל: "\\\\frac{{d}}{{dx}} x^n = n \\\\cdot x^{{n-1}}"
-       אל תכלול ביטויים מספריים ספציפיים מהשאלה! רק נוסחאות כלליות.
-
-    4. tts_speech: טקסט דיבור קצר וחם למורה (4-6 משפטים).
-       ⚠️ כללי ברזל ל-TTS:
-       - עברית בלבד, ללא LaTeX, ללא סימנים מתמטיים, ללא אימוג'ים
-       - אל תקרא לתלמיד "נסיך", "נסיכה", "גיבור", "אלוף" - רק בשם {student_name}
-       - תדבר בגוף שני {"נקבה" if student_gender == "F" else "זכר"}
-       - טון: חם ומקצועי, כמו מורה פרטית שמסכמת שיעור
-       - ציין את הנושא שלמדנו, תובנה מרכזית אחת, ומשפט עידוד
-
-    ═══════════════════════════════════════════════════
-    📋 פורמט JSON נדרש:
-    ═══════════════════════════════════════════════════
-    {{
-        "topic_summary": "שם הנושא שנלמד (קצר)",
-        "key_concepts": ["תובנה 1", "תובנה 2", "תובנה 3"],
-        "formulas_to_remember": ["LaTeX נוסחה 1", "LaTeX נוסחה 2"],
-        "tts_speech": "טקסט דיבור עברי נקי ל-TTS"
-    }}
-    """
-
-def get_anchor_validation_prompt(ocr_json: dict) -> str:
-    """
-    V8.9.2: Dedicated prompt for the Orchestrator's Data Anchor Validator.
-    Takes the raw OCR JSON and the image to produce a syntactically perfect 'Absolute Truth'.
-    """
-    ocr_str = json.dumps(ocr_json, indent=2, ensure_ascii=False)
-    
-    return f"""
-    You are a strict Mathematical Transcriber & Validator. 
-    Look at the provided OCR JSON and the original image.
-    
-    OCR JSON (Raw Extraction):
-    {ocr_str}
-    
-    ⚠️ MISSION:
-    The OCR often corrupts complex fractions, missing brackets, or mangling operators.
-    Your ONLY job is to output a verified, syntactically perfect JSON containing the main mathematical functions and parameters exactly as they appear in the image.
-    
-    **CRITICAL VISION PROTOCOL:**
-    You are a strict Visual Validator, NOT a text auto-completer. When evaluating the extracted math, you MUST cross-reference the text directly against the ORIGINAL IMAGE.
-    If the input string is syntactically broken, truncated, or missing components (e.g., dropped fractions, missing multipliers outside parentheses), DO NOT delete terms to artificially 'fix' the equation.
-    You MUST visually reconstruct the EXACT mathematical expression pixel-for-pixel as it appears in the image. Do not hallucinate values (e.g., changing $e$ to $\sqrt{e}$). MATCH THE PIXELS EXACTLY.
-
-    RULES:
-    1. Fix any hanging operators (e.g., 'a+', 'x-').
-    2. Restore missing multipliers or fractions (e.g., if image shows '1/x' but OCR missed it).
-    3. Ensure all brackets are closed and standard variables are used.
-    4. If the OCR is correct, keep it as is.
-    5. CRITICAL: Do NOT solve the problem. Do NOT explain. 
-    6. Output ONLY the corrected JSON following the exact structure of the input.
-    7. V8.9.2: If you fix a critical syntax error (like 'a+' -> 'a+1/x^2'), ensure the final result is mathematically plausible based on the visual evidence.
-    8. **HORIZONTAL VERIFICATION (V8.9.3):** Check the horizontal order of elements. If an element is to the left of a bracket in the image, it MUST be to the left of the bracket in your JSON. Do NOT let the Hebrew text flow (RTL) swap the positions of multipliers or terms.
-    9. **CRITICAL JSON STRUCTURE RULE (V8.9.4):** Every output MUST be a flat JSON dictionary with UNIQUE keys. Do NOT use duplicate keys like "equation" multiple times. If there are multiple equations, use "equation_1", "equation_2", etc.
-    
-    Return ONLY the corrected JSON.
-    """
diff --git a/domain/curriculum_classifier.py b/domain/curriculum_classifier.py
deleted file mode 100644
index bcd92093a3dd1cb8dad00cf95e3f8ccaf45722de..0000000000000000000000000000000000000000
--- a/domain/curriculum_classifier.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# domain/curriculum_classifier.py
-import sympy as sp
-import logging
-
-logger = logging.getLogger(__name__)
-
-class CurriculumClassifier:
-    """
-    V6.1 Hybrid Architecture - Phase 1: Router Layer
-    Evaluates math complexity and injects grade-specific pedagogical prompts.
-    """
-    
-    @staticmethod
-    def estimate_complexity(math_string: str) -> int:
-        """
-        Calculates a complexity score (1-10) based on AST features.
-        """
-        score = 1
-        try:
-            # Parse multiple equations if necessary
-            expressions = []
-            
-            # Helper to quickly strip common LaTeX that crashes sympify
-            import re
-            cleaned_str = re.sub(r'\\[a-zA-Z]+', '', str(math_string))
-            cleaned_str = cleaned_str.replace('{', '(').replace('}', ')').replace('$', '')
-            
-            for part in cleaned_str.split(','):
-                expressions.append(sp.sympify(part.replace('=', '-'), evaluate=False))
-                
-            for expr in expressions:
-                # Number of variables
-                vars_count = len(expr.free_symbols)
-                if vars_count > 1:
-                    score += vars_count
-                
-                # Number of operations / tree depth mapping (approx)
-                ops_count = expr.count_ops()
-                score += ops_count // 3
-                
-                # Advanced functions (Trigonometry, Logarithms)
-                if expr.has(sp.sin, sp.cos, sp.tan, sp.log, sp.exp):
-                    score += 3
-                    
-                # High degree polynomials
-                if expr.is_polynomial():
-                    degrees = sp.degree_list(expr)
-                    max_deg = max(degrees) if degrees else 0
-                    if max_deg > 2:
-                        score += 2
-                        
-        except Exception as e:
-            # Fallback heuristic if SymPy parse fails entirely
-            raw_len = len(str(math_string))
-            fallback_score = 3 + (raw_len // 15)
-            logger.warning(f"Complexity estimation failed, falling back to len heuristic ({fallback_score}): {e}")
-            score = fallback_score
-
-            
-        final_score = min(max(int(score), 1), 10)
-        logger.info(f"[ROUTER] Intended Math Complexity Score: {final_score}/10")
-        return final_score
-
-    @staticmethod
-    def get_prompt_specialization(grade: str, intent_category: str) -> str:
-        """
-        Returns pedagogical prompt constraints based on the student's grade.
-        """
-        grade_num = 0
-        import re
-        match = re.search(r'\d+', str(grade))
-        if match:
-            grade_num = int(match.group())
-            
-        constraints = []
-        
-        # Base setup
-        constraints.append("אתה מורה פרטי למתמטיקה.")
-        
-        # Grade specific logic
-        if grade_num <= 7:
-            constraints.append("הסבר במונחים פשוטים מאוד. אל תשתמש במילים כמו 'נבודד' או 'נפשט', אלא 'נשאיר את הנעלם לבד' או 'נחשב את המספרים'.")
-        elif grade_num <= 9:
-            constraints.append("השתמש במונחי אלגברה תקניים כמו 'העברת אגפים', 'כינוס איברים דומים', ו'בידוד משתנה'. שמור על שפה מעודדת.")
-        elif grade_num <= 12:
-            constraints.append("הנח כי התלמיד מכיר מושגי יסוד באלגברה. התמקד בהיגיון העמוק של התרגיל ובחוקים המתמטיים (למשל חוקי חזקות, זהויות). הייה רשמי ומדויק.")
-            if "TRIGONOMETRY" in intent_category.upper():
-                constraints.append("במשוואות טריגונומטריות, הבהר תמיד את שיקולי המחזוריות או מעגל היחידה.")
-        else:
-            constraints.append("הסבר בבהירות ובצורה ישירה.")
-            
-        specialization = " ".join(constraints)
-        logger.info(f"[ROUTER] Prompt specialization applied for Grade {grade} ({intent_category})")
-        return specialization
diff --git a/domain/math_normalizer.py b/domain/math_normalizer.py
deleted file mode 100644
index 7c4c3f13990baa1d05e2badab2959d9329bb12e2..0000000000000000000000000000000000000000
--- a/domain/math_normalizer.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# domain/math_normalizer.py
-
-import re
-import logging
-
-logger = logging.getLogger(__name__)
-
-class MathCanonicalizer:
-    @staticmethod
-    def preprocess_ocr_string(math_string: str) -> str:
-        """
-        V6 Polish (P0): Aggressively cleans raw OCR math strings before SymPy parsing.
-        - Adds explicit multiplication.
-        - Wraps trigonometric functions in parentheses (e.g., sin x -> sin(x)).
-        - Normalizes basic artifacts.
-        """
-        if not math_string:
-            return ""
-            
-        clean_str = str(math_string).strip()
-        
-        # 1. Standardize Whitespace
-        clean_str = re.sub(r'\s+', ' ', clean_str)
-        
-        # 2. Add implicit multiplication between numbers and variables (e.g., 2x -> 2*x)
-        # Note: SymPy handles some of this, but we do it explicitly to be safe
-        clean_str = re.sub(r'(\d)([a-zA-Z])', r'\1*\2', clean_str)
-        
-        # 3. Trigonometric Functions Parentheses Guard
-        # Matches sin, cos, tan, cot, arcsin, arccos, arctan, etc. followed by space and a variable/number
-        # Example: 'sin x' -> 'sin(x)', 'cos 2x' -> 'cos(2*x)', 'tan ^2x' is trickier but we handle the basics.
-        trig_funcs = r'(sin|cos|tan|cot|sec|csc|arcsin|arccos|arctan)'
-        
-        # Match 'sin x' or 'sin 2*x' but not 'sin(x)'
-        # This regex looks for trig function, optional space, and then something that is not a parenthesis
-        clean_str = re.sub(fr'{trig_funcs}\s+([a-zA-Z0-9_*]+)(?!\()', r'\1(\2)', clean_str)
-        
-        return clean_str
diff --git a/domain/math_validator.py b/domain/math_validator.py
deleted file mode 100644
index 2b8f422d00cae31ec499bfd7ec43447fe8e1c314..0000000000000000000000000000000000000000
--- a/domain/math_validator.py
+++ /dev/null
@@ -1,316 +0,0 @@
-# domain/math_validator.py — V1.1 (STABLE REGEX POLYGRAPH)
-import re
-import logging
-import re
-import logging
-import time
-import asyncio
-from typing import Tuple, List, Optional, Any
-import sympy
-from sympy.parsing.sympy_parser import parse_expr
-from utils.math_utils import aggressive_sympy_sanitizer
-
-logger = logging.getLogger(__name__)
-
-# Expressions that are structurally unparseable but pedagogically harmless
-_PIPE_SEPARATED_RESULT = re.compile(r'\|')
-_HEBREW_ONLY = re.compile(r'^[\u0590-\u05FF\s]+$')
-
-# LaTeX commands that SymPy cannot parse — strip layout but KEEP math functions
-_LATEX_STRIP = re.compile(
-    r'\\(?:left|right|div|pm|mp|leq|geq|neq'
-    r'|approx|infty|text|mathrm|mathbf|boxed|underbrace|overbrace|hat|bar|vec|dot|overline|underline)\b'
-)
-
-# V307.0: Functions that often lack parentheses in LLM output (e.g. lnx)
-_MATH_FUNC_PARENS = ['ln', 'sin', 'cos', 'tan', 'sqrt', 'log', 'exp', 'Abs']
-
-def _latex_to_sympy_str(latex_str: str) -> str:
-    """
-    Best-effort LaTeX → SymPy-parseable string.
-    V310.0: Aggressive Hebrew stripping and malformed notation cleanup.
-    """
-    if latex_str is None:
-        return ""
-    s = str(latex_str).strip()
-    
-    # 0. V310.0: Strip Hebrew characters and BOM/Zero-width chars immediately
-    s = re.sub(r'[\u0590-\u05FF\u200B-\u200D\uFEFF]', ' ', s)
-    
-    # 1. Handle \frac{a}{b} → (a)/(b)
-    loop_counter = 0
-    max_loops = 15
-    while r'\frac' in s and loop_counter < max_loops:
-        old_s = s
-        s = re.sub(r'\\frac\s*\{([^{}]*)\}\s*\{([^{}]*)\}', r'(\1)/(\2)', s)
-        if old_s == s:
-            s = s.replace(r'\frac', '(frac_err)')
-            break
-        loop_counter += 1
-        
-    # 2. Convert LaTeX functions to plain words (e.g. \ln -> ln)
-    s = s.replace(r'\ln', ' ln ').replace(r'\sin', ' sin ').replace(r'\cos', ' cos ')
-    s = s.replace(r'\tan', ' tan ').replace(r'\sqrt', ' sqrt ').replace(r'\log', ' log ')
-    s = s.replace(r'\exp', ' exp ').replace(r'\pi', ' pi ').replace(r'\theta', ' theta ')
-
-    # --- 🚀 BEGIN HOTFIX V9.0.3: LATEX MULTIPLICATION ---
-    s = s.replace(r'\cdot', '*').replace(r'\times', '*')
-    # --- END HOTFIX ---
-
-    # 3. Remove remaining purely structural LaTeX commands
-    s = _LATEX_STRIP.sub(' ', s)
-    
-    # 4. Remove LaTeX delimiters/wrappers
-    s = s.replace('{', '(').replace('}', ')').replace('$', '')
-    s = s.replace(r'\left', '').replace(r'\right', '')
-    
-    # 5. V307.0: Fix implicit function arguments (e.g. lnx -> ln(x))
-    for func in _MATH_FUNC_PARENS:
-        pattern = r'\b' + func + r'\b\s*([^( \t\n\r\f\v,]+)'
-        s = re.sub(pattern, func + r'(\1)', s)
-
-    # 6. Handle absolute value pipes |x| -> Abs(x)
-    loop_counter = 0
-    while '|' in s and s.count('|') >= 2 and loop_counter < 10:
-        s = re.sub(r'\|([^|]+)\|', r'Abs(\1)', s)
-        loop_counter += 1
-        
-    # 7. Implicit multiplication: 2x → 2*x (only if not inside a word)
-    s = re.sub(r'(\d)([a-zA-Z(])', r'\1*\2', s)
-    
-    # 8. V280.0: Equals sign handling is now moved to _check_segment 
-    # for more robust parsing of equations.
-    
-    # 9. Final cleanup: Remove illegal SymPy chars like ', ", ?, !
-    s = re.sub(r'[?!\'"]', '', s)
-    s = re.sub(r'\s+', ' ', s)
-    return s.strip()
-
-def _is_plaintext(expr_str: str) -> bool:
-    if _HEBREW_ONLY.match(expr_str):
-        return True
-    if _PIPE_SEPARATED_RESULT.search(expr_str) and not any(c in expr_str for c in ['+', '-', '*', '/', '^', '=']):
-        return True
-    return False
-
-class MathPolygraph:
-    TIMEOUT_SECONDS = 3
-
-    @staticmethod
-    async def _validate_single(text: str, step_id) -> Tuple[bool, str]:
-        """
-        V280.0 REDESIGN: 
-        1. No Blind Stripping: Extracts $...$ or $$...$$ using re.finditer with DOTALL.
-        2. Security: Uses parse_expr(evaluate=False).
-        3. Equations: Splits by '=' and validates parts to bypass SymPy's '=' limitation.
-        4. Multi-Equal: Handles x=y=5 without crashing.
-        5. Empty Guard: Skips $$$$.
-        """
-        if not text or not text.strip():
-            return True, ""
-
-        # regex: find both $$display$$ and $inline$ blocks. DOTALL allows multi-line display math.
-        # Group 1 = display math, Group 2 = inline math
-        math_pattern = re.compile(r'\$\$(.*?)\$\$|\$(.*?)\$', re.DOTALL)
-        matches = list(re.finditer(math_pattern, text))
-        
-        if not matches:
-            # V280.0 Rule: If no delimiters are found, treat the whole string as plain text 
-            # or try to parse if it looks like math (existing behavior for backward compatibility)
-            if _is_plaintext(text):
-                return True, ""
-            return await MathPolygraph._check_segment(text, step_id)
-
-        for match in matches:
-            # Group 1 (Display) or Group 2 (Inline)
-            content = (match.group(1) or match.group(2) or "").strip()
-            
-            # 5. Empty String Guard
-            if not content:
-                continue
-            
-            # V280.0 Fix: Multi-line display math might contain multiple equations.
-            # Split by newline before validating segments.
-            sub_segments = [s.strip() for s in content.split('\n') if s.strip()]
-            for sub in sub_segments:
-                ok, reason = await MathPolygraph._check_segment(sub, step_id)
-                if not ok:
-                    return False, reason
-                
-        return True, ""
-
-    @staticmethod
-    async def _run_safe_math_op(func, *args, timeout_sec: float = 0.3) -> Any:
-        """
-        V9.0.5: Executes a CPU-bound SymPy operation in a separate thread with a strict timeout.
-        Returns the result of the function, or raises TimeoutError/Exception.
-        """
-        try:
-            return await asyncio.wait_for(
-                asyncio.to_thread(func, *args),
-                timeout=timeout_sec
-            )
-        except asyncio.TimeoutError:
-            raise asyncio.TimeoutError("SymPy operation timed out")
-
-    @staticmethod
-    async def _check_segment(raw_segment: str, step_id) -> Tuple[bool, str]:
-        """Internal helper to validate a single extracted math segment."""
-        # V9.0.1: Use Aggressive Sanitizer to handle Hebrew, Arrows, and Comma-splitting
-        sanitized_parts = aggressive_sympy_sanitizer(raw_segment)
-        
-        if not sanitized_parts:
-            return True, ""
-
-        for part in sanitized_parts:
-            sympy_str = _latex_to_sympy_str(part)
-            if not sympy_str or sympy_str in ('', '-', '()', '( )'):
-                continue
-                
-            try:
-                # V9.0.5: Wrap CPU-bound sympify/parsing in a non-blocking thread with 300ms timeout
-                # We bypass the slow multiprocessing approach for SSE safety.
-                def parse_and_eval(s):
-                    # Character Whitelist (from legacy _sympify_worker)
-                    safe_pattern = r'^[a-zA-Z0-9\s\+\-\*\/\^\(\)\.\,\!\%\=]+$'
-                    if not re.match(safe_pattern, s):
-                        return False
-                    res = parse_expr(s, evaluate=False)
-                    if res is not None:
-                        evaluated = res.doit()
-                        if hasattr(evaluated, 'is_finite') and evaluated.is_finite is False:
-                            return False
-                        if hasattr(evaluated, 'is_nan') and evaluated.is_nan:
-                            return False
-                    return True
-
-                status = await MathPolygraph._run_safe_math_op(parse_and_eval, sympy_str)
-                
-                if status is False:
-                    logger.warning(f"🛡️ [SOFT FAIL] SymPy Parse Error on part '{part}'. Bypassing validator.")
-                    return True, "" # Soft Fail: allow stream to continue
-                    
-            except asyncio.TimeoutError:
-                logger.warning(f"🛡️ [SOFT FAIL] SymPy TIMEOUT (300ms) on part '{part}'. Bypassing validator.")
-                return True, "" # Soft Fail: allow stream to continue
-            except Exception as e:
-                logger.warning(f"🛡️ [SOFT FAIL] Unexpected validation crash: {e} for part '{part}'. Bypassing.")
-                return True, "" # Soft Fail: allow stream to continue
-
-        return True, ""
-
-    @staticmethod
-    async def validate_step_sequence(steps: List[dict], topic: str = "GENERAL") -> Tuple[bool, str]:
-        if not steps:
-            return True, ""
-        
-        # V8.9.4: Skip deep SymPy parsing for discrete sequence steps to avoid false-positive SyntaxErrors
-        is_sequence = topic and "SEQUENCE" in topic.upper()
-        
-        for step in steps:
-            step_id = step.get('step_id', step.get('step_number', '?'))
-            math_fields = []
-            for field in ('math_latex', 'block_math', 'math'):
-                val = step.get(field)
-                if val and isinstance(val, str) and val.strip():
-                    math_fields.append(val.strip())
-            if not math_fields:
-                continue
-            
-            # If sequence, we only check if it's "valid-ish" LaTeX vs deep SymPy check
-            if is_sequence:
-                # Basic sanity check for LaTeX balance
-                if math_fields[0].count('{') != math_fields[0].count('}'):
-                    return False, f"LATEX_BRACKET_MISMATCH:step_{step_id}"
-                continue
-
-            ok, reason = await MathPolygraph._validate_single(math_fields[0], step_id)
-            if not ok:
-                return False, reason
-        return True, ""
-    @staticmethod
-    async def are_equivalent(latex1: str, latex2: str) -> bool:
-        """
-        V9.0.5: Checks if two LaTeX expressions are mathematically equivalent (Non-Blocking).
-        Supports expressions and equations (by converting to 'expr = 0').
-        """
-        try:
-            # 1. Handle Equations in Equivalence Check
-            if '=' in latex1 and '=' in latex2 and latex1.count('=') == 1 and latex2.count('=') == 1:
-                parts1 = [p.strip() for p in latex1.split('=') if p.strip()]
-                parts2 = [p.strip() for p in latex2.split('=') if p.strip()]
-                if len(parts1) == 2 and len(parts2) == 2:
-                    res1 = await MathPolygraph.are_equivalent(parts1[0], parts2[0])
-                    res2 = await MathPolygraph.are_equivalent(parts1[1], parts2[1])
-                    return res1 and res2
-
-            s1_raw = _latex_to_sympy_str(latex1)
-            s2_raw = _latex_to_sympy_str(latex2)
-            
-            # Check for inequalities in raw LaTeX to be safe
-            inequalities = ['<', '>', r'\leq', r'\geq', r'\neq', r'\leq', r'\geq']
-            if any(iq in latex1 for iq in inequalities) or any(iq in latex2 for iq in inequalities):
-                return latex1.strip() == latex2.strip()
-
-            # Security: Strict Whitelist for Equivalence Check
-            safe_pattern = r'^[a-zA-Z0-9\s\+\-\*\/\^\(\)\.\,\!\=]+$'
-            def is_safe(s): 
-                clean = s.replace('\\', '').replace('_', '').replace('{', '(').replace('}', ')')
-                return bool(re.match(safe_pattern, clean))
-                
-            if not (is_safe(s1_raw) and is_safe(s2_raw)):
-                return latex1.strip() == latex2.strip()
-
-            # V9.0.5: Wrap CPU-bound SymPy simplify in a thread with timeout
-            def calc_equivalence(str1, str2):
-                expr1 = parse_expr(str1, evaluate=False)
-                expr2 = parse_expr(str2, evaluate=False)
-                # "Variable Trap": Basic structural equivalence if variables are involved
-                if len(expr1.free_symbols) > 0 or len(expr2.free_symbols) > 0:
-                    return sympy.simplify(expr1 - expr2) == 0
-                # Numerical Identity check
-                diff = sympy.simplify(expr1 - expr2)
-                return diff == 0
-
-            return await MathPolygraph._run_safe_math_op(calc_equivalence, s1_raw, s2_raw)
-
-        except asyncio.TimeoutError:
-            logger.warning(f"🛡️ [SOFT FAIL] Equivalence check TIMEOUT (300ms) for {latex1} vs {latex2}")
-            return True # Soft Fail: Assume equivalent if we can't prove otherwise in time
-        except Exception as e:
-            logger.warning(f"🛡️ [SOFT FAIL] Equivalence check failed: {e}")
-            return True # Soft Fail: Assume equivalent on error
-
-    @staticmethod
-    async def verify_algebraic_consistency(steps: List[dict], topic: str = "GENERAL") -> Tuple[bool, str]:
-        """
-        V1.3: Checks if a sequence of steps is algebraically consistent.
-        Currently checks if subsequent steps are equivalent (for simplifications).
-        """
-        # V8.9.4: Skip deep SymPy parsing for discrete sequence steps
-        if topic and "SEQUENCE" in topic.upper():
-            return True, ""
-            
-        math_steps = []
-        for step in steps:
-            math = step.get('math_latex') or step.get('block_math') or step.get('math')
-            if math and isinstance(math, str) and math.strip():
-                # Avoid validating plaintext logic blocks
-                if not _is_plaintext(math):
-                    math_steps.append({'id': step.get('step_id', '?'), 'math': math})
-        
-        if len(math_steps) < 2:
-            return True, ""
-            
-        for i in range(len(math_steps) - 1):
-            s1 = math_steps[i]['math']
-            s2 = math_steps[i+1]['math']
-            
-            # Simple heuristic: Only verify if they look like comparable equations/expressions
-            if not await MathPolygraph.are_equivalent(s1, s2):
-                logger.info(f"[POLYGRAPH] Consistency warning between {s1} and {s2}")
-                # We return False only if we are VERY sure.
-                # For now, we'll return False to trigger self-correction as requested.
-                return False, f"ALGEBRAIC_INCONSISTENCY:step_{math_steps[i+1]['id']}"
-        
-        return True, ""
diff --git a/domain/ontology.py b/domain/ontology.py
deleted file mode 100644
index 6b36343d90e2683eb85739cce1c6928595bed997..0000000000000000000000000000000000000000
--- a/domain/ontology.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# domain/ontology.py
-
-GLOBAL_ONTOLOGY = {
-    "algebra": {
-        "solve_linear_system": {
-            "concepts": ["מערכת", "מערכת משוואות", "חיתוך ישרים", "השוואת ביטויים", "נעלמים", "נציב", "נחלץ", "משוואות", "משתנה", "ערך"],
-            "tag": "השוואה"
-        },
-        "isolate_variable": {
-            "concepts": ["בידוד משתנה", "העברת אגפים", "נחלק במקדם", "נחסר", "נכנס איברים דומים", "נפשט", "איברים"],
-            "tag": "בידוד משתנה"
-        },
-        "substitute": {
-            "concepts": ["הצבה", "נציב את הערך", "משוואה מקורית", "ערך ה-y", "ערך ה-x", "משתנה שני"],
-            "tag": "הצבה"
-        },
-        "general_algebra": {
-            "concepts": ["משוואה", "נעלם", "פתרון", "הסבר", "חישוב", "שלב"],
-            "tag": "אלגברה בסיסית"
-        }
-    },
-    "geometry": {
-        # Geometry terms will go here later
-    }
-}
-
-def get_allowed_concepts(category: str, rule_id: str) -> list[str]:
-    """Fetch allowed concepts from ontology"""
-    domain = GLOBAL_ONTOLOGY.get(category.lower(), {})
-    rule_data = domain.get(rule_id, domain.get("general_algebra", {"concepts": []}))
-    return rule_data.get("concepts", [])
-
-def get_pedagogical_tag(category: str, rule_id: str) -> str:
-    """Fetch pedagogical tag from ontology"""
-    domain = GLOBAL_ONTOLOGY.get(category.lower(), {})
-    rule_data = domain.get(rule_id, domain.get("general_algebra", {"tag": "כללי"}))
-    return rule_data.get("tag", "כללי")
diff --git a/domain/pedagogical_renderer.py b/domain/pedagogical_renderer.py
deleted file mode 100644
index d42116e2fd39ac1516bd94dc2b7ab3e4487f1aef..0000000000000000000000000000000000000000
--- a/domain/pedagogical_renderer.py
+++ /dev/null
@@ -1,264 +0,0 @@
-# domain/pedagogical_renderer.py - V7.2 (Deterministic Governed Reasoning Runtime)
-import re
-import logging
-from typing import List, Optional
-import domain.telemetry as telemetry
-from domain.semantic_bank import get_diversity_engine
-
-logger = logging.getLogger(__name__)
-
-
-
-# ==================== V7.2: PLACEHOLDER GUARD ====================
-
-def validate_placeholders(renderer_text: str, provided_ids: List[str]) -> bool:
-    """
-    V7.2: Bi-directional placeholder validation.
-    
-    Check 1: Every ID the server provided MUST appear in the text as {{id}}.
-    Check 2: No placeholder the LLM invented (not in provided_ids) may appear.
-    
-    Either failure → Fail Closed (Hint Mode).
-    """
-    # Check 1: All provided IDs must be referenced
-    for step_id in provided_ids:
-        expected = "{{" + step_id + "}}"
-        if expected not in renderer_text:
-            logger.warning(
-                f"[RENDERER GUARD] Missing placeholder for server-provided ID '{step_id}'. "
-                f"Expected '{expected}' in renderer output."
-            )
-            telemetry.emit_renderer_placeholder_violation("missing", step_id)
-            return False
-
-    # Check 2: No invented placeholders allowed
-    found_placeholders = re.findall(r'\{\{(\w+)\}\}', renderer_text)
-    for ph in found_placeholders:
-        if ph not in provided_ids:
-            logger.warning(
-                f"[RENDERER GUARD] Invented placeholder '{{{{{{ph}}}}}}'  detected! "
-                f"Not in server-provided IDs: {provided_ids}"
-            )
-            telemetry.emit_renderer_placeholder_violation("invented", ph)
-            return False
-
-    return True
-
-
-def inject_signed_results(renderer_text: str, signed_steps: List[dict]) -> str:
-    """
-    Replaces {{step_id}} placeholders in the renderer's text with the actual
-    computed expressions from the server's signed step list.
-    Only called AFTER validate_placeholders() passes.
-    """
-    result = renderer_text
-    for step in signed_steps:
-        placeholder = "{{" + step["id"] + "}}"
-        result = result.replace(placeholder, f"`{step['expression']}`")
-    return result
-
-
-# ==================== V7.2: PEDAGOGICAL RENDERER ====================
-
-class PedagogicalRenderer:
-    """
-    V7.2: LLM #2 — Pedagogical Renderer.
-    
-    Receives the server's signed step IDs (NOT expressions) and the Planner's rationale.
-    Produces a pedagogical explanation in Hebrew using only {{step_id}} placeholders.
-    Never computes or writes math itself.
-    """
-
-    def __init__(self, llm_gateway):
-        self.llm_gateway = llm_gateway
-
-    # V7.2.4 PROMPT — Updated by CTO: Pedagogical Narrator framing + 1 approved example.
-    # Any further changes require full regression (chaos_test.py 18/18) + CTO sign-off.
-    def _build_renderer_prompt(self, pedagogical_rationale: str, step_ids: List[str]) -> str:
-        ids_list = ", ".join(f"{{{{{sid}}}}}" for sid in step_ids)
-        return f"""You are a Pedagogical Narrator for a Hebrew math tutoring system.
-Your role is to explain the INTUITION behind each solution step, not to compute anything.
-The server has already computed all mathematics with certainty — your job is to tell the story.
-
-PEDAGOGICAL RATIONALE:
-{pedagogical_rationale}
-
-SERVER PLACEHOLDERS (use EXACTLY as written):
-{ids_list}
-
-RULES:
-1. Hebrew only.
-2. Explain the intuition and logic behind each step in human, encouraging language.
-   Use analogies, real-world stories, or visual metaphors.
-3. Embed ALL server placeholders exactly: {ids_list}
-4. FORBIDDEN — do NOT write: any digit, number, variable, operator, fraction, or math symbol.
-   Rule: if you feel the urge to write a number or expression, describe its meaning in words instead.
-   Use {{{{step_id}}}} to present the server's computed result. No '=', '/', '^', 'sin(x)', 'pi', etc.
-5. No invented placeholders. Only server-provided IDs above.
-
-EXAMPLE (single approved format — "math textbook narrator style"):
-  ✅ CORRECT: "כדי למצוא את נקודות החיתוך עם ציר ה-y, נציב אפס בערך ה-x ונקבל: {{{{step_1}}}}."
-  ❌ FORBIDDEN: "כדי למצוא את החיתוך נציב x=0 ונקבל y=4."  (raw numbers/symbols — blocked by Guardian)
-"""
-
-    async def render(
-        self,
-        pedagogical_rationale: str,
-        signed_steps: List[dict],
-        action: Optional[str] = None,  # V7.2.5: Planner Enum action for SemanticBank lookup
-    ) -> dict:
-        """
-        V7.2.5 Semantic Composer:
-        1. Try DiversityEngine.compose(action) — deterministic narrative from SemanticBank.
-        2. If no bank entry exists — falls back to LLM #2 (Graceful Degradation).
-        Both paths run renderer_guard() + scan_for_math_leakage() before returning.
-        """
-        step_ids = [s["id"] for s in signed_steps]
-
-        # ── Path A: Deterministic Semantic Composer ─────────────────────────────
-        if action is not None:
-            engine = get_diversity_engine()
-            composed = engine.compose(action, signed_steps)
-            if composed is not None:
-                logger.info(f"[RENDERER] 📚 SemanticBank hit for '{action}'. Using deterministic narrative.")
-                # Inject server results into {{placeholders}} in composed narrative
-                final_text = inject_signed_results(composed, signed_steps)
-                # Guard: composed output must still pass safety checks
-                if not renderer_guard(composed):  # check pre-injection text
-                    logger.error("[RENDERER] renderer_guard failed on SemanticBank output!")
-                    return {"success": False, "reason": "SEMANTIC_BANK_GUARD_VIOLATION"}
-                if not scan_for_math_leakage(final_text):
-                    logger.error("[RENDERER] Leakage scan failed on SemanticBank output!")
-                    return {"success": False, "reason": "SEMANTIC_BANK_LEAKAGE"}
-                logger.info("✅ [RENDERER] Semantic Composer output approved by all guards.")
-                return {"success": True, "rendered_text": final_text, "source": "semantic_bank"}
-
-        # ── Path B: LLM #2 Fallback (unknown action or no bank entry) ────────────
-        logger.info(f"[RENDERER] No SemanticBank entry for action='{action}'. Using LLM #2 fallback.")
-        step_ids = [s["id"] for s in signed_steps]
-
-        system_prompt = self._build_renderer_prompt(pedagogical_rationale, step_ids)
-        user_prompt = (
-            f"Write the pedagogical explanation for this solution. "
-            f"Use the placeholders: {', '.join(step_ids)}"
-        )
-
-        logger.info(f"[RENDERER] Requesting pedagogical explanation for steps: {step_ids}")
-
-        try:
-            raw_text = await self.llm_gateway.generate_raw(system_prompt, user_prompt)
-
-            # Bi-directional placeholder guard
-            if not validate_placeholders(raw_text, step_ids):
-                logger.error("[RENDERER] Placeholder guard FAILED. Failing closed.")
-                return {"success": False, "reason": "PLACEHOLDER_GUARD_VIOLATION"}
-
-            # ── Renderer Guard (V7.2.4) — strict keyword + digit blacklist ────
-            # Runs on raw LLM output BEFORE injection to catch trig keywords,
-            # individual digits, and operators the LLM "helpfully" wrote itself.
-            if not renderer_guard(raw_text):
-                logger.error("[RENDERER] renderer_guard FAILED on raw LLM output. Failing closed.")
-                telemetry.emit_renderer_leakage("renderer_guard_raw")
-                return {"success": False, "reason": "RENDERER_GUARD_VIOLATION"}
-
-            # Inject actual results from server
-            final_text = inject_signed_results(raw_text, signed_steps)
-
-            # ── Renderer Guardian Scan (V7.2.2/V7.2.3) — whitelist + consecutive chars ─
-            if not scan_for_math_leakage(final_text):
-                logger.error(
-                    "[RENDERER GUARDIAN] Math leakage in final injected text! Failing closed."
-                )
-                telemetry.emit_renderer_leakage("post-injection-leak")
-                return {"success": False, "reason": "RENDERER_GUARDIAN_LEAKAGE"}
-
-            logger.info("[RENDERER] ✅ Both guards passed. Pedagogical explanation approved.")
-            return {"success": True, "rendered_text": final_text}
-
-        except Exception as e:
-            logger.error(f"[RENDERER] LLM failure: {e}")
-            return {"success": False, "reason": f"LLM_FAILURE: {e}"}
-
-
-# ==================== V7.2.4: RENDERER GUARD (Strict Blacklist) ====================
-
-def renderer_guard(text: str) -> bool:
-    """
-    V7.2.4 Structural Output Lock — strict blacklist scan on RAW LLM output.
-    Runs BEFORE placeholder injection to catch violations at the source.
-
-    Blocks: individual digits, operator chars, named math functions (sin/cos/tan/sqrt/pi).
-    This is stricter than scan_for_math_leakage() which uses a whitelist on the FINAL text.
-
-    Returns True (safe) / False (fail closed).
-    """
-    # Remove valid server-provided {{placeholders}} first
-    clean = re.sub(r'\{\{.*?\}\}', '', text)
-
-    # Blacklist pattern: any digit, basic operator, or named math function
-    FORBIDDEN_PATTERN = r'[0-9]|[+*/^=]|(?<![a-zA-Z\u0590-\u05FF])(sin|cos|tan|sqrt|pi)(?![a-zA-Z\u0590-\u05FF])'
-
-    match = re.search(FORBIDDEN_PATTERN, clean)
-    if match:
-        logger.warning(
-            f"[RENDERER_GUARD] Forbidden content in raw LLM output: '{match.group(0)}'. "
-            f"Failing closed."
-        )
-        return False
-    return True
-
-
-# ==================== V7.2: TICKET 5 — UI GATE WHITELIST SCAN ====================
-
-def scan_for_math_leakage(rendered_text: str) -> bool:
-    """
-    V7.2.3 Hardened Whitelist Scan (NOT a blacklist).
-    After removing {{...}} placeholders, the remaining text may ONLY contain:
-    - Hebrew letters (Unicode block U+0590–U+05FF)
-    - English letters (for natural language words)
-    - Spaces and basic punctuation (. , ; : ! ? ' " -)
-
-    Two-pass enforcement:
-    Pass 1 — Full whitelist: any forbidden char → REJECT.
-    Pass 2 — Consecutive math chars: >2 consecutive math symbols outside {{}}
-              catches patterns like '3((9)*(+1))', '^2+4', '/6)' even if
-              pass 1 might miss edge-case single chars.
-    """
-    # Remove all valid server-provided {{placeholders}} first
-    clean_text = re.sub(r'\{\{\w+\}\}', '', rendered_text).strip()
-
-    # V7.2.5 FIX: Remove backtick-wrapped server-signed expressions.
-    # inject_signed_results() wraps each signed expression in `backticks`.
-    # These are TRUSTED server content (SymPy output) — NOT LLM-generated.
-    # They MUST be excluded from the leakage scan to avoid false positives.
-    clean_text = re.sub(r'`[^`]+`', '', clean_text).strip()
-
-    if not clean_text:
-        return True  # Text was purely placeholders + signed expressions — safe
-
-    # Pass 1: Full whitelist — Hebrew + English + basic punctuation + typography + backticks ONLY
-    ALLOWED_PATTERN = r'^[\u0590-\u05FFa-zA-Z\s.,;:!?\-\"\'\u2014\u2013\u2012\u200f\u200e`]+$'
-    whitelist_ok = bool(re.match(ALLOWED_PATTERN, clean_text))
-
-    if not whitelist_ok:
-        # Show all characters that were NOT in the whitelist (sync this regex with ALLOWED_PATTERN)
-        violations = re.sub(r'[\u0590-\u05FFa-zA-Z\s.,;:!?\-\"\'\u2014\u2013\u2012\u200f\u200e`]+', '', clean_text)
-        logger.warning(f"[UI_GATE] Math leakage detected! Offending chars: '{violations[:50]}'")
-        telemetry.emit_renderer_leakage(violations[:50])
-        return False
-
-    # Pass 2: Consecutive math char sequence detection (V7.2.3 hardening)
-    # Catches: '3((9', '^2+', '/6)', etc. — >2 non-whitespace math chars in a row
-    # IMPORTANT: exclude backtick (`) as it's used for styling, not as a math operator.
-    MATH_CHAR_PATTERN = r'[0-9=+\-*/^<>|\\(){}\[\]%@#&~]{3,}'
-    consecutive_match = re.search(MATH_CHAR_PATTERN, clean_text)
-    if consecutive_match:
-        chain = consecutive_match.group(0)
-        logger.warning(
-            f"[UI_GATE] Consecutive math char sequence detected: '{chain[:50]}'. "
-            f"Failing closed (Pass 2 — V7.2.3 hardening)."
-        )
-        telemetry.emit_renderer_leakage(f"consecutive_chain:{chain[:30]}")
-        return False
-
-    return True
diff --git a/domain/processing_strategy.py b/domain/processing_strategy.py
deleted file mode 100644
index c716edd9787916f934597f657fededae1435e197..0000000000000000000000000000000000000000
--- a/domain/processing_strategy.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from enum import Enum
-
-class ProcessingStrategy(str, Enum):
-    SIMPLE_ARITHMETIC = "SIMPLE_ARITHMETIC"      # Fast Path
-    STRICT_SYMBOLIC = "STRICT_SYMBOLIC"          # דורש הוכחה / מבנה סמלי
-    HEURISTIC_DEDUCTION = "HEURISTIC_DEDUCTION"  # טקסטואלי / גנרי
-    CONVERSATIONAL = "CONVERSATIONAL"            # שיח חופשי
diff --git a/domain/proposal_engine.py b/domain/proposal_engine.py
deleted file mode 100644
index fefaf2293162460d2616c6647b4a55114252dffb..0000000000000000000000000000000000000000
--- a/domain/proposal_engine.py
+++ /dev/null
@@ -1,189 +0,0 @@
-# domain/proposal_engine.py - V7.2 (Deterministic Governed Reasoning Runtime)
-import json
-import logging
-from typing import List
-from enum import Enum
-from pydantic import BaseModel, ValidationError
-from .ontology import get_allowed_concepts
-import domain.telemetry as telemetry
-
-logger = logging.getLogger(__name__)
-
-# ==================== V7.2: STRICT SCHEMA DEFINITIONS ====================
-
-class ComputeAction(str, Enum):
-    """V7.3: Hardcoded allowed actions. The Planner may NOT invent new ones."""
-    # ── Algebraic (V7.2) ──────────────────────────────────────────────────
-    SOLVE_EQUATION    = "SOLVE_EQUATION"
-    SIMPLIFY          = "SIMPLIFY"
-    FIND_DERIVATIVE   = "FIND_DERIVATIVE"
-    FIND_INTEGRAL     = "FIND_INTEGRAL"
-    FACTOR            = "FACTOR"
-    EXPAND            = "EXPAND"
-    SUBSTITUTE        = "SUBSTITUTE"
-    # ── Geometry / Analytic (V7.3) ──────────────────────────────────────
-    FIND_AXIS_INTERSECTIONS  = "FIND_AXIS_INTERSECTIONS"   # הצב x=0 / y=0 ופתור
-    CALCULATE_SLOPE_AND_LINE = "CALCULATE_SLOPE_AND_LINE"  # שיפוע + משואת ישר
-    CALCULATE_DISTANCE       = "CALCULATE_DISTANCE"        # נוסחת מרחק + בדיקת מיקום
-
-class ServerComputeTask(BaseModel):
-    action: ComputeAction         # Enum enforced: unknown action → ValidationError
-    target_step_ref: str          # AST Node ID only (e.g. "ast_node_2"), NOT a math expression
-
-class PlannerResponse(BaseModel):
-    pedagogical_rationale: str
-    requires_server_compute: List[ServerComputeTask]
-
-class PlannerFormatError(Exception):
-    """Raised when the Planner's response fails structural or schema validation."""
-    pass
-
-MAX_SERVER_STEPS = 8  # DOS Prevention: Planner cannot request more than 8 server tasks
-
-
-# ==================== V7.2: SAFE JSON EXTRACTION ====================
-
-def extract_and_validate_plan(raw_response: str) -> PlannerResponse:
-    """
-    V7.2: Index-based JSON extraction with PlannerFormatError on any failure.
-    Refuses split() to avoid silent IndexError.
-    """
-    if "<JSON_START>" not in raw_response or "<JSON_END>" not in raw_response:
-        raise PlannerFormatError("Missing explicit JSON boundaries <JSON_START>/<JSON_END>.")
-
-    start = raw_response.index("<JSON_START>") + len("<JSON_START>")
-    end = raw_response.index("<JSON_END>")
-    raw_json = raw_response[start:end].strip()
-
-    try:
-        plan = PlannerResponse.model_validate_json(raw_json)
-
-        # Guard: DOS Prevention
-        if len(plan.requires_server_compute) > MAX_SERVER_STEPS:
-            raise PlannerFormatError(
-                f"DOS Guard: Plan requested {len(plan.requires_server_compute)} steps, max is {MAX_SERVER_STEPS}."
-            )
-
-        return plan
-    except (ValidationError, json.JSONDecodeError) as e:
-        raise PlannerFormatError(f"Validation failed: {e}")
-    except PlannerFormatError:
-        raise
-    except Exception as e:
-        raise PlannerFormatError(f"Unexpected extraction error: {e}")
-
-
-# ==================== V7.2: PROPOSAL ENGINE ====================
-
-class ProposalEngine:
-    """
-    V7.2 Deterministic Governed Reasoning — Pedagogical Planner (LLM #1)
-    
-    The LLM receives only AST metadata (IDs and operations) and returns
-    a structured Plan (JSON). It NEVER writes math expressions — only references AST Node IDs.
-    """
-
-    def __init__(self, llm_gateway):
-        self.llm_gateway = llm_gateway
-
-    def _build_system_prompt(self, ast_metadata: dict, prompt_specialization: str, sub_question_text: str = "") -> str:
-        """Build the strict Planner system prompt including boundary enforcement."""
-        allowed_concepts = get_allowed_concepts(
-            ast_metadata.get("detected_operations", ["general"])[0],
-            "general_algebra"
-        )
-        concepts_str = ", ".join(allowed_concepts) if allowed_concepts else "מונחי אלגברה מדויקים"
-
-        sub_q_line = f"\nSUB-QUESTION TO SOLVE NOW: {sub_question_text}" if sub_question_text else ""
-
-        return f"""You are a Pedagogical Planner for a math tutoring system. 
-Your role is to plan HOW to solve a math problem, NOT to solve it yourself.
-
-PROBLEM CONTEXT (AST Metadata):
-{json.dumps(ast_metadata, ensure_ascii=False, indent=2)}{sub_q_line}
-
-CRITICAL RULES:
-1. You MUST wrap your entire JSON response between <JSON_START> and <JSON_END> tags.
-2. Do NOT write any math expressions or compute anything yourself.
-3. When referring to AST nodes, use their IDs only (e.g. "ast_node_0").
-4. Your response MUST conform to this exact JSON schema:
-{{
-    "pedagogical_rationale": "<short explanation of the teaching strategy in Hebrew>",
-    "requires_server_compute": [
-        {{"action": "<ENUM_ACTION>", "target_step_ref": "<ast_node_id>"}},
-        ...
-    ]
-}}
-5. Allowed actions (ENUM only): SOLVE_EQUATION, SIMPLIFY, FIND_DERIVATIVE, FIND_INTEGRAL, FACTOR, EXPAND, SUBSTITUTE, FIND_AXIS_INTERSECTIONS, CALCULATE_SLOPE_AND_LINE, CALCULATE_DISTANCE.
-6. Maximum {MAX_SERVER_STEPS} compute steps.
-7. Pedagogical Constraint: {prompt_specialization}
-8. Vocabulary: Prioritize these terms: [{concepts_str}].
-9. SINGLE-ACTION CONSTRAINT (critical): For complex equations (circles, trigonometry, systems),
-   always use SOLVE_EQUATION directly on ast_node_0. DO NOT chain operations that reference
-   intermediate result nodes (ast_node_1, ast_node_2, etc.) — those nodes do not exist in
-   the server registry. The SymPy engine handles simplification and expansion internally
-   as part of SOLVE_EQUATION. Violating this rule causes a server crash.
-10. CONTEXTUAL ROUTING (V7.3 — critical): Analyze the SUB-QUESTION TO SOLVE NOW carefully.
-    Select the action that matches the specific task:
-    - "חיתוך", "צירים" → FIND_AXIS_INTERSECTIONS
-    - "ישר", "שיפוע", "משואה" → CALCULATE_SLOPE_AND_LINE
-    - "מרחק", "נקודה על המעגל" → CALCULATE_DISTANCE
-    - General algebra/equation → SOLVE_EQUATION
-    You MUST choose the action that solves specifically this sub-question.
-    Do NOT use SOLVE_EQUATION when a more specific action applies."""
-
-
-    async def generate_draft_proposal(self, context_obj, prompt_specialization: str, ast_metadata: dict = None) -> dict:
-        """
-        Asks LLM #1 (Planner) to produce a structured action plan.
-        Returns {"success": True, "plan": PlannerResponse} or {"success": False, "reason": ...}.
-        """
-        if ast_metadata is None:
-            ast_metadata = {}
-
-        system_prompt = self._build_system_prompt(
-            ast_metadata, prompt_specialization,
-            sub_question_text=getattr(context_obj, 'sub_question_text', '')
-        )
-        user_prompt = (
-            f"Plan the solution for: {context_obj.math_input}\n"
-            f"Remember: Output JSON only, wrapped in <JSON_START>...<JSON_END> tags."
-        )
-
-        logger.info(f"[PLANNER] Requesting plan for: {context_obj.math_input}")
-
-        for attempt in range(2):  # Max 1 retry (Full Strategy Re-run)
-            try:
-                raw_response = await self.llm_gateway.generate_raw(system_prompt, user_prompt)
-                plan = extract_and_validate_plan(raw_response)
-
-                logger.info(
-                    f"[PLANNER] Valid plan received on attempt {attempt + 1}. "
-                    f"Actions: {[t.action for t in plan.requires_server_compute]}"
-                )
-                # Phase 1 Live: Track which Enum actions the Planner chose (drift detection)
-                chosen_actions = [task.action.value for task in plan.requires_server_compute]
-                telemetry.emit_planner_strategy_distribution(chosen_actions)
-                return {"success": True, "plan": plan}
-
-            except PlannerFormatError as e:
-                logger.warning(f"[PLANNER] Attempt {attempt + 1} failed: {e}")
-                if attempt == 0:
-                    # Full Strategy Re-run: inject hard feedback and retry
-                    user_prompt = (
-                        f"Your previous response was invalid: {e}\n"
-                        f"Try again. Plan the solution for: {context_obj.math_input}\n"
-                        f"You MUST use <JSON_START> and <JSON_END> tags. Output valid JSON only."
-                    )
-                    continue
-                else:
-                    logger.error("[PLANNER] Max retries exhausted. Failing closed.")
-                    return {"success": False, "reason": str(e)}
-
-            except Exception as e:
-                logger.error(f"[PLANNER] LLM failure on attempt {attempt + 1}: {e}")
-                if attempt == 0:
-                    continue
-                return {"success": False, "reason": f"LLM_FAILURE: {e}"}
-
-        return {"success": False, "reason": "MAX_RETRIES_EXHAUSTED"}
diff --git a/domain/risk_engine.py b/domain/risk_engine.py
deleted file mode 100644
index 8880bd06e850f5c0a9dc37972a057a32113c71ad..0000000000000000000000000000000000000000
--- a/domain/risk_engine.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# domain/risk_engine.py
-import logging
-from typing import Dict, Any, List
-from .curriculum_classifier import CurriculumClassifier
-
-logger = logging.getLogger(__name__)
-
-class CognitiveRiskEngine:
-    """
-    V6.1 Phase 4: Risk Scoring
-    Evaluates the cognitive risk of a proposal based on AST complexity, 
-    step count, retries, and symbolic stability.
-    """
-    
-    WEIGHTS = {
-        "ast_complexity": 0.30,
-        "reasoning_depth": 0.20,
-        "retry_penalty": 0.25,
-        "symbolic_instability": 0.25
-    }
-    
-    @classmethod
-    def calculate_risk_score(cls, 
-                             math_input: str, 
-                             draft_steps: List[Dict[str, Any]], 
-                             retry_count: int,
-                             validation_errors: int) -> Dict[str, Any]:
-        """
-        Calculates the Cognitive Risk Score (CRS) between 0.0 and 1.0.
-        """
-        # 1. AST Complexity (normalized 0-1)
-        # We reuse CurriculumClassifier's internal complexity estimation if possible, 
-        # but here we normalize it against a ceiling of 20.
-        raw_complexity = CurriculumClassifier.estimate_complexity(math_input)
-        ast_risk = min(raw_complexity / 20.0, 1.0)
-        
-        # 2. Reasoning Depth (normalized 0-1)
-        # 10 steps is considered high depth for our MVP
-        depth_risk = min(len(draft_steps) / 10.0, 1.0)
-        
-        # 3. Retry Penalty
-        # 0 retries = 0.0, 1 retry = 1.0 (since max retry is 1 in V6.1)
-        retry_risk = 1.0 if retry_count > 0 else 0.0
-        
-        # 4. Symbolic Instability
-        # Based on validation failures during the process
-        instability_risk = min(validation_errors / 5.0, 1.0)
-        
-        # Weighted Final Score
-        crs = (ast_risk * cls.WEIGHTS["ast_complexity"] +
-               depth_risk * cls.WEIGHTS["reasoning_depth"] +
-               retry_risk * cls.WEIGHTS["retry_penalty"] +
-               instability_risk * cls.WEIGHTS["symbolic_instability"])
-        
-        result = {
-            "risk_score": round(crs, 3),
-            "features": {
-                "ast_risk": round(ast_risk, 3),
-                "depth_risk": round(depth_risk, 3),
-                "retry_risk": retry_risk,
-                "instability_risk": round(instability_risk, 3)
-            }
-        }
-        
-        logger.info(f"🧠 [RISK_ENGINE] Calculated CRS: {result['risk_score']} (AST: {ast_risk}, Depth: {depth_risk}, Retry: {retry_risk})")
-        return result
diff --git a/domain/schemas.py b/domain/schemas.py
deleted file mode 100644
index 6e38dfb46f33774c611d3f8ead68678fec0cd88e..0000000000000000000000000000000000000000
--- a/domain/schemas.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from enum import Enum
-from typing import Optional, Any, Dict
-from pydantic import BaseModel, Field
-
-class BuddyState(str, Enum):
-    STRATEGY_READY = "STRATEGY_READY"
-    SECTION_WORKING = "SECTION_WORKING"
-    SECTION_READY = "SECTION_READY"
-    COMPLETE = "COMPLETE"
-    ERROR = "ERROR"
-
-class BuddyEvent(BaseModel):
-    question_id: str = Field(..., description="Unique ID for the question session")
-    state: BuddyState = Field(..., description="Current state of the micro-agent")
-    current_section_id: Optional[str] = Field(None, description="The ID of the section (e.g., 'א', 'ב') currently being processed")
-    payload: Dict[str, Any] = Field(default_factory=dict, description="Payload containing state-specific data")
-
-    class Config:
-        use_enum_values = True
diff --git a/domain/semantic_bank.py b/domain/semantic_bank.py
deleted file mode 100644
index 79a93473cd6b4076d395e3a1ac86a5934cf8ad30..0000000000000000000000000000000000000000
--- a/domain/semantic_bank.py
+++ /dev/null
@@ -1,366 +0,0 @@
-# domain/semantic_bank.py — V7.2.5: Semantic Composer
-#
-# The SemanticBank is a governed, deterministic source of pedagogical narratives.
-# Instead of letting LLM #2 generate free text (risky), the NarrativeComposer picks
-# from curated, teacher-grade Hebrew templates and injects server-signed results.
-#
-# CTO directive: text must sound like a real private tutor speaking to a 10th/12th grader.
-# Write at eye level — encouraging, intuitive, NOT like system error messages.
-
-import random
-import logging
-from dataclasses import dataclass, field
-from collections import Counter
-from typing import List, Dict, Optional
-
-from domain import telemetry
-
-logger = logging.getLogger(__name__)
-
-DRIFT_ALERT_THRESHOLD = 0.35  # Emit alert when one variant dominates above this fraction
-
-
-# ─── Data Model ───────────────────────────────────────────────────────────────
-
-@dataclass
-class SemanticEntry:
-    """
-    A single pedagogical concept in the bank.
-    Each entry holds multiple variant fragments to ensure narrative diversity.
-    """
-    concept_tag: str           # matches Planner Enum action (e.g. "SOLVE_EQUATION")
-    openings: List[str]        # 3 opening phrases — how to START the explanation
-    bridges: List[str]         # 3 logic bridges — HOW to connect the steps
-    analogies: List[str]       # 2 analogy/metaphor sentences — the "aha!" moments
-    closing: str               # 1 closing encouragement sentence
-
-
-# ─── The Bank ─────────────────────────────────────────────────────────────────
-
-SEMANTIC_BANK: Dict[str, SemanticEntry] = {
-
-    "SOLVE_EQUATION": SemanticEntry(
-        concept_tag="SOLVE_EQUATION",
-        openings=[
-            "בואו נפתור את המשוואה צעד אחר צעד, אל תדאג, זה פחות מפחיד משנראה.",
-            "כדי לגלות את ערך הנעלם, אנחנו הולכים לבודד אותו משני צידי המשוואה.",
-            "נחשוב על המשוואה כמו מאזניים: כל מה שעושים בצד ימין, עושים גם בצד שמאל.",
-        ],
-        bridges=[
-            "אחרי הפעולה הזו, כל מה שנותר הוא:",
-            "וכשנפשט את כל מה שקיבלנו, התוצאה מתגלה:",
-            "המשוואה 'התנקתה' ועכשיו ברור שהתשובה היא:",
-        ],
-        analogies=[
-            "חשוב על זה כמו חידה — אנחנו מסירים רמזים אחד אחד עד שהנעלם חשוף לגמרי.",
-            "בדיוק כמו שמשחקים מחבואים — אנחנו מחפשים את x עד שהוא כבר לא יכול להתחבא.",
-        ],
-        closing="עשית את זה! זו הדרך הרשמית שבה מתמטיקאים פותרים משוואות.",
-    ),
-
-    "SIMPLIFY": SemanticEntry(
-        concept_tag="SIMPLIFY",
-        openings=[
-            "הביטוי הזה נראה מסובך, אבל אם נסדר אותו — הוא מתקפל לצורה הרבה יותר נקייה.",
-            "בפישוט, המטרה היא לכתוב את אותו הדבר — רק בצורה המינימלית ביותר.",
-            "כמו לסדר חדר מבולגן — אנחנו אוספים איברים דומים ומסלקים מה שמיותר.",
-        ],
-        bridges=[
-            "אחרי שנאסוף את כל האיברים הדומים יחד, הביטוי הפשוט הוא:",
-            "כשמסלקים את כל 'הרעש המתמטי', מה שנשאר הוא:",
-            "הצורה הפשוטה והנקייה ביותר של הביטוי:",
-        ],
-        analogies=[
-            "דמיין שיש לך הרבה שטרות של כסף — אתה מחליף אותם לשטר אחד גדול. זה בדיוק מה שאנחנו עושים עם הביטוי.",
-            "כמו לקפל מפת ענק — בסוף קיבלת את אותו המידע, רק בגודל שנוח לשאת.",
-        ],
-        closing="יופי! פישוט זה אחת הכישורים הכי שימושיים במתמטיקה — ועכשיו אתה יודע לעשות את זה.",
-    ),
-
-    "FACTOR": SemanticEntry(
-        concept_tag="FACTOR",
-        openings=[
-            "פירוק לגורמים זה כמו למצוא את 'הבניינים' שמרכיבים את הביטוי שלנו.",
-            "במקום לראות ביטוי אחד גדול, אנחנו מחפשים שני ביטויים קטנים שמוכפלים זה בזה.",
-            "הטריק בפירוק לגורמים הוא לזהות מה 'מסתתר' בתוך הביטוי ואפשר להוציא החוצה.",
-        ],
-        bridges=[
-            "כשנוציא את הגורם המשותף, נקבל:",
-            "אחרי הפירוק, הביטוי נכתב בצורה הכפלית:",
-            "הגורמים שמרכיבים את הביטוי הם:",
-        ],
-        analogies=[
-            "פירוק לגורמים הוא כמו לפרק מספר לחלוקה ראשונית — אנחנו מוצאים את ה-DNA המתמטי של הביטוי.",
-            "דמיין שאתה מפרק ארגז גדול לקופסאות קטנות — כל קופסא היא גורם. ביחד הן מרכיבות את המקור.",
-        ],
-        closing="פירוק לגורמים הוא בדיוק מה שמאפשר לנו לפתור משוואות ריבועיות — תכיר את הכלי הזה טוב.",
-    ),
-
-    "EXPAND": SemanticEntry(
-        concept_tag="EXPAND",
-        openings=[
-            "עכשיו נפרוש את הסוגריים — נכפיל כל איבר בתוך הסוגריים עם כל מה שמחוצה להם.",
-            "פתיחת סוגריים היא כמו 'לפתוח' מתנה עטופה — מה שמסתתר בפנים יוצא לאור.",
-            "נשתמש בחוק הפילוג כדי להרחיב את הביטוי ולראות את כל האיברים בנפרד.",
-        ],
-        bridges=[
-            "לאחר פתיחת הסוגריים ואיסוף האיברים הדומים:",
-            "כשמרחיבים הכל ומסדרים:",
-            "הביטוי המורחב, עם כל האיברים גלויים:",
-        ],
-        analogies=[
-            "חשוב על זה כמו להכפיל תמחיר — אם קנית שלושה שקים, כל אחד עם תפוחים ובננות, אתה מחשב כמה תפוחים וכמה בננות יש בסך הכל.",
-            "פתיחת סוגריים היא כמו לגלגל בצק — לוחצים ומרחיבים עד שהכל שטוח ונראה.",
-        ],
-        closing="הרחבת הביטוי זו מיומנות בסיסית שתשתמש בה שוב ושוב — וכבר שלטת בה.",
-    ),
-
-    "FIND_DERIVATIVE": SemanticEntry(
-        concept_tag="FIND_DERIVATIVE",
-        openings=[
-            "הנגזרת אומרת לנו כמה מהר הפונקציה עולה או יורדת — היא כמו 'מד המהירות' של הגרף.",
-            "כדי למצוא את הנגזרת, אנחנו שואלים: אם x זז קצת קדימה — כמה y משתנה?",
-            "נחשב את הנגזרת לפי כללי הגזירה שנלמדו — זה הרבה יותר מהיר מההגדרה הבסיסית.",
-        ],
-        bridges=[
-            "לפי כלל הגזירה ורשימת הנגזרות, קיבלנו:",
-            "הנגזרת, שמייצגת את שיפוע המשיק לפונקציה, היא:",
-            "קצב השינוי המיידי של הפונקציה הוא:",
-        ],
-        analogies=[
-            "אם הפונקציה היא מסלול נסיעה, הנגזרת היא המד-מהירות — היא אומרת לך כמה מהר אתה נע בכל רגע.",
-            "דמיין שאתה מטפס על הר — הנגזרת אומרת לך בכל נקודה עד כמה התלילות. חיובית = עולים, שלילית = יורדים.",
-        ],
-        closing="הנגזרת פותחת עולם שלם — מניתוח קצוות ועד מכניקה. כל הכבוד על המיומנות הזו.",
-    ),
-
-    "FIND_INTEGRAL": SemanticEntry(
-        concept_tag="FIND_INTEGRAL",
-        openings=[
-            "האינטגרל הוא הפעולה ההפוכה לגזירה — אנחנו שואלים 'מה הפונקציה שהנגזרת שלה היא זו?'.",
-            "כדי לחשב את האינטגרל, נשתמש בנוסחאות הבסיסיות ובחוק ה-C, ה-קבוע האינטגרציה.",
-            "האינטגרל הלא מסוים נותן לנו משפחה שלמה של פונקציות — שונות זו מזו בקבוע בלבד.",
-        ],
-        bridges=[
-            "אחרי אינטגרציה לפי כלל ההפיכה של הנגזרת:",
-            "הפונקציה הפרימיטיבית שמרכיבה את האינטגרל היא:",
-            "ביצוע האינטגרציה נותן לנו:",
-        ],
-        analogies=[
-            "אם הנגזרת היא מד-המהירות, האינטגרל הוא מד-המרחק — הוא אוסף את כל השינויים הקטנים לסכום אחד.",
-            "חשוב על אינטגרציה כמו לגלגל סרט לאחור — אנחנו 'מחזירים' את הגזירה לנקודת המוצא שלה.",
-        ],
-        closing="אינטגרציה היא לב חשבון אינפיניטסימלי — ועכשיו יש לך את הכלי לחשב שטחים, נפחים ועוד.",
-    ),
-
-    "SUBSTITUTE": SemanticEntry(
-        concept_tag="SUBSTITUTE",
-        openings=[
-            "כדי לבדוק את הפתרון (או להשלים חישוב), נציב את הערך הידוע ונפשט.",
-            "ההצבה היא הדרך שלנו לחבר בין שני חלקי הבעיה — מציבים מה שיודעים ורואים מה יוצא.",
-            "נחליף את המשתנה בערך הנתון ונחשב — זה ישאיר לנו ביטוי הרבה יותר פשוט.",
-        ],
-        bridges=[
-            "לאחר ההצבה והפישוט:",
-            "כשנציב ונפשט את הביטוי שקיבלנו:",
-            "ערך ההצבה מניב:",
-        ],
-        analogies=[
-            "הצבה היא כמו למלא שם בטופס — אנחנו מחליפים את 'הנעלם' בערך הממשי שמצאנו.",
-            "דמיין מתכון שאומר 'ספל סוכר' — ברגע שאתה יודע כמה גדול הספל, אתה יכול לחשב כמות מדויקת.",
-        ],
-        closing="מצוין! ההצבה היא גם דרך מצוינת לבדוק שהפתרון שמצאת הוא נכון.",
-    ),
-
-    # ── V7.3: Geometry / Analytic Entries ────────────────────────────────────
-
-    "FIND_AXIS_INTERSECTIONS": SemanticEntry(
-        concept_tag="FIND_AXIS_INTERSECTIONS",
-        openings=[
-            "כדי לגלות איפה המעגל פוגש את הצירים, נשאל שאלה פשוטה: מה קורה כשנקודה נמצאת ממש על ציר ה-x? ה-y שלה שווה לאפס! ולהפך.",
-            "נקודות חיתוך עם הצירים הן הנקודות שבהן המעגל חוצה את 'הכבישים' של מערכת הצירים.",
-            "הדרך לאתר את נקודות החיתוך עם הצירים היא להציב אפס: פעם עבור x ופעם עבור y, ולראות מה הפתרון שיוצא.",
-        ],
-        bridges=[
-            "כשנציב ונפתור, הנקודות שמצאנו הן:",
-            "לאחר ההצבה וקבלת הפתרונות, נקודות החיתוך עם הצירים הן:",
-            "הפתרונות שקיבלנו מציינים את הנקודות שבהן המעגל חוצה את הצירים:",
-        ],
-        analogies=[
-            "חשוב על מעגל כמו כדור שמתגלגל על רצפה — נקודות החיתוך עם ציר ה-x הן בדיוק המקומות שהכדור נוגע ברצפה.",
-            "דמיין שאתה מסתכל על מפה ומחפש איפה כביש ראשי חוצה את הנהר — זה בדיוק מה שאנחנו עושים עם המעגל והצירים.",
-        ],
-        closing="מצאנו את כל נקודות המגע של המעגל עם מערכת הצירים — עבודה מדויקת!",
-    ),
-
-    "CALCULATE_SLOPE_AND_LINE": SemanticEntry(
-        concept_tag="CALCULATE_SLOPE_AND_LINE",
-        openings=[
-            "כדי למצוא את משוואת הישר העובר דרך שתי נקודות, נחשב קודם את השיפוע — כמה 'תלול' הישר.",
-            "שיפוע הישר הוא היחס בין השינוי בגובה לשינוי בהיקף: עלייה חלקי הזזה אופקית.",
-            "הישר שמחבר שתי נקודות מוגדר לחלוטין על ידי השיפוע שלו ונקודת מעבר אחת.",
-        ],
-        bridges=[
-            "לאחר חישוב השיפוע, משוואת הישר היא:",
-            "כשנוסיף את השיפוע שמצאנו לנוסחת הישר, נקבל:",
-            "הישר שמחבר מרכז המעגל לראשית הצירים הוא:",
-        ],
-        analogies=[
-            "שיפוע הוא כמו מדרגות — אם עולים ארבע קומות לכל שלושה צעדים קדימה, השיפוע הוא ארבעה חלקי שלושה.",
-            "דמיין ישר כמו דרך בין שתי ערים — השיפוע הוא כמה מטרים עולים לכל קילומטר שנוסעים.",
-        ],
-        closing="קיבלנו את משוואת הישר בצורה המפורשת — קו ישר שעובר בדיוק דרך שתי הנקודות הנתונות.",
-    ),
-
-    "CALCULATE_DISTANCE": SemanticEntry(
-        concept_tag="CALCULATE_DISTANCE",
-        openings=[
-            "כדי לבדוק האם נקודה נמצאת על המעגל, נמדוד את המרחק בינה לבין מרכז המעגל ונשווה לרדיוס.",
-            "נוסחת המרחק בין שתי נקודות היא שורש של סכום ריבועי ההפרשים — בדיוק כמו משפט פיתגורס.",
-            "השאלה פשוטה: האם הנקודה נמצאת בדיוק ברדיוס מהמרכז, קרוב יותר, או רחוק יותר?",
-        ],
-        bridges=[
-            "לאחר חישוב המרחק, הממצא הוא:",
-            "כשמשווים את המרחק שמצאנו לרדיוס המעגל, מתברר ש:",
-            "תוצאת חישוב המרחק מול הרדיוס:",
-        ],
-        analogies=[
-            "דמיין מדוזה עגולה — כל נקודה על גבה נמצאת בדיוק באותו מרחק מהמרכז. אם נקודה קרובה יותר — היא בתוכה. רחוקה יותר — מחוצה לה.",
-            "מרחק שתי נקודות זה כמו למדוד עם סרגל בין שתי ערים על מפה — פיתגורס עושה את העבודה.",
-        ],
-        closing="בדקנו מדויק: המרחק חושב, הושווה לרדיוס, ומיקום הנקודה נקבע בוודאות מתמטית.",
-    ),
-
-}
-
-
-# ─── Diversity Engine ──────────────────────────────────────────────────────────
-
-class DiversityEngine:
-    """
-    Selects narrative variants from the SemanticBank with diversity enforcement.
-
-    Tracks selection history per concept to detect "narrative laziness" (Drift):
-    if one variant is chosen more than DRIFT_ALERT_THRESHOLD fraction of the time,
-    emit a PEDAGOGICAL_DRIFT telemetry alert.
-    """
-
-    def __init__(self):
-        # Counter per concept_tag: tracks how many times each (variant_type, index) was picked
-        self._history: Dict[str, Counter] = {}
-
-    def _record(self, concept_tag: str, variant_key: str):
-        if concept_tag not in self._history:
-            self._history[concept_tag] = Counter()
-        self._history[concept_tag][variant_key] += 1
-
-    def drift_score(self, concept_tag: str) -> float:
-        """
-        Returns the dominance fraction of the most-selected variant for this concept.
-        Score = max_count / total_count.
-        0.0 = perfectly uniform, 1.0 = always the same variant.
-        """
-        if concept_tag not in self._history or not self._history[concept_tag]:
-            return 0.0
-        counts = self._history[concept_tag]
-        total = sum(counts.values())
-        if total == 0:
-            return 0.0
-        return max(counts.values()) / total
-
-    def _pick(self, concept_tag: str, variant_type: str, options: List[str]) -> str:
-        """
-        Weighted random selection that avoids the most recently over-used variants.
-        Falls back to uniform random if history is thin (< 5 picks).
-        """
-        n = len(options)
-        history_key_prefix = f"{variant_type}:"
-        if concept_tag not in self._history or sum(self._history[concept_tag].values()) < 5:
-            # Not enough history — uniform random
-            idx = random.randrange(n)
-        else:
-            counts = self._history[concept_tag]
-            # Weight = inverse of how often we've picked this index
-            weights = []
-            for i in range(n):
-                pick_count = counts.get(f"{history_key_prefix}{i}", 0)
-                weights.append(1.0 / (1 + pick_count))
-            # Weighted choice
-            total_w = sum(weights)
-            r = random.uniform(0, total_w)
-            cumulative = 0.0
-            idx = n - 1  # fallback
-            for i, w in enumerate(weights):
-                cumulative += w
-                if r <= cumulative:
-                    idx = i
-                    break
-
-        key = f"{history_key_prefix}{idx}"
-        self._record(concept_tag, key)
-
-        # Check drift and emit telemetry
-        score = self.drift_score(concept_tag)
-        if score > DRIFT_ALERT_THRESHOLD:
-            logger.warning(
-                f"[DRIFT_MONITOR] Pedagogical drift detected for '{concept_tag}': "
-                f"drift_score={score:.2f} > threshold={DRIFT_ALERT_THRESHOLD}. "
-                f"Selection history: {dict(self._history[concept_tag])}"
-            )
-            telemetry.emit_pedagogical_drift(concept_tag, score)
-
-        return options[idx]
-
-    def compose(self, action: str, signed_steps: list) -> str:
-        """
-        Main entry point: builds a full Hebrew pedagogical narrative for the given action.
-        Inserts {{step_id}} placeholders where the server results will be shown.
-
-        Returns a string with {{placeholder}} notation (not yet injected).
-        """
-        entry = SEMANTIC_BANK.get(action)
-        if entry is None:
-            logger.warning(
-                f"[SEMANTIC_BANK] No entry for action '{action}'. "
-                f"Falling back to LLM #2 renderer."
-            )
-            return None  # Signal to caller: use LLM fallback
-
-        concept_tag = entry.concept_tag
-
-        # Pick diverse variants
-        opening  = self._pick(concept_tag, "opening",  entry.openings)
-        bridge   = self._pick(concept_tag, "bridge",   entry.bridges)
-        analogy  = self._pick(concept_tag, "analogy",  entry.analogies)
-        closing  = entry.closing  # Always the same (one closing per concept by design)
-
-        # Build placeholder string from signed steps
-        if not signed_steps:
-            placeholder_str = ""
-        elif len(signed_steps) == 1:
-            placeholder_str = f"{{{{{signed_steps[0]['id']}}}}}"
-        else:
-            parts = [f"{{{{{s['id']}}}}}" for s in signed_steps]
-            placeholder_str = " ← ".join(parts)
-
-        # Compose the narrative (V7.2.5: no emojis/em-dashes — must pass scan_for_math_leakage)
-        narrative = (
-            f"{opening}\n\n"
-            f"{analogy}\n\n"
-            f"{bridge} {placeholder_str}\n\n"
-            f"{closing}"
-        )
-
-        logger.info(
-            f"[SEMANTIC_BANK] Composed narrative for '{action}' | "
-            f"drift_score={self.drift_score(concept_tag):.2f}"
-        )
-        return narrative
-
-
-# Module-level singleton — shared across all requests in the process
-_engine = DiversityEngine()
-
-def get_diversity_engine() -> DiversityEngine:
-    """Returns the process-level DiversityEngine singleton."""
-    return _engine
diff --git a/domain/step_types.py b/domain/step_types.py
deleted file mode 100644
index 9936b476176080b7e4d8c63d93760e8e31634735..0000000000000000000000000000000000000000
--- a/domain/step_types.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# domain/step_types.py - V7.4 (TYPED DOMAIN CONTRACTS)
-"""
-V7.4: Typed SignedStep — Domain-Aware Validation Contract.
-
-Replaces the raw dict `{"id", "hash", "expression"}` with a typed dataclass
-that carries a StepType so the ConsistencyGate validates by semantic domain,
-not by string shape.
-
-CTO directive:
-  - expression  → display string only (for renderer injection)
-  - payload     → semantic truth (list[str] for geometry, str for algebraic)
-  - step_type   → routing key for ConsistencyGate dispatch
-
-Backwards compatibility: SignedStep emulates a dict fully so ALL existing
-dict-access code (step["id"], step.get("hash"), "id" in step, step.items())
-in pedagogical_renderer.py / semantic_bank.py continues to work unchanged.
-"""
-from enum import Enum
-from dataclasses import dataclass, asdict
-from typing import Any, Optional
-
-
-class StepType(Enum):
-    ALGEBRAIC = "algebraic"   # SymPy-parseable expression — validated with sympify
-    GEOMETRY  = "geometry"    # Points, distances, labels — validated structurally
-    NUMERIC   = "numeric"     # Pure numeric results — future use
-
-
-@dataclass
-class SignedStep:
-    """
-    V7.4: Typed, SHA256-signed computation step.
-
-    Fields:
-        id          — step identifier used as {{id}} placeholder in renderer
-        expression  — human-readable display string (injected into pedagogy text)
-        payload     — semantic truth: list[str] for geometry, str for algebraic
-        step_type   — StepType enum — routes ConsistencyGate validation
-        hash        — SHA256 digest seeded with canonical form + problem_id + step_id
-    """
-    id: str
-    expression: str
-    payload: Any
-    step_type: StepType
-    hash: str
-
-    # ── Full dict emulation (CTO requirement) ─────────────────────────────────
-    # Allows ALL existing code using step["key"], step.get(...), "key" in step,
-    # step.items() to work without any changes.
-
-    _FIELDS = ("id", "expression", "payload", "step_type", "hash")
-
-    def __getitem__(self, key: str):
-        if key not in self._FIELDS:
-            raise KeyError(key)
-        return getattr(self, key)
-
-    def get(self, key: str, default=None):
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def keys(self):
-        return list(self._FIELDS)
-
-    def items(self):
-        return [(k, self[k]) for k in self._FIELDS]
-
-    def __contains__(self, key: object) -> bool:
-        return key in self._FIELDS
diff --git a/domain/telemetry.py b/domain/telemetry.py
deleted file mode 100644
index d59179cd176c75a6c29e85816f24d1a694245604..0000000000000000000000000000000000000000
--- a/domain/telemetry.py
+++ /dev/null
@@ -1,177 +0,0 @@
-# domain/telemetry.py - V7.2 Observability Layer
-"""
-BuddyMath V7.2 Runtime Telemetry
-Emits structured log-based metrics compatible with Datadog/Grafana log pipelines.
-
-All metrics are emitted as structured JSON log lines on the logger named "buddymath.metrics".
-DevOps should configure a log-based metric parser for lines containing "METRIC_EVENT".
-
-Metric naming convention: <component>.<event_name>
-"""
-import logging
-import json
-import time
-from datetime import datetime, timezone
-from typing import Optional
-
-metrics_logger = logging.getLogger("buddymath.metrics")
-
-# ==================== METRIC KEY CONSTANTS ====================
-# Use these constants everywhere to prevent typos and enable grep-ability.
-
-class M:
-    """V7.2 Metric Key Registry"""
-
-    # Core runtime outcome (feeds the Pie Chart)
-    RUNTIME_OUTCOME         = "runtime.outcome"        # values: success | hint_mode | planner_retry | leakage_fail | placeholder_fail | crs_block
-
-    # Fail Closed Rate (derived from RUNTIME_OUTCOME != success)
-    FAIL_CLOSED             = "fail_closed"            # emitted on any non-success outcome
-
-    # Planner (LLM #1)
-    PLANNER_RETRY           = "planner.retry.count"    # emitted on each retry attempt
-    PLANNER_ENUM_VIOLATION  = "planner.enum_violation" # emitted when ComputeAction enum is violated
-    PLANNER_JSON_ERROR      = "planner.json_error"     # emitted on JSON parse / boundary failure
-    PLANNER_STRATEGY_DIST   = "planner.strategy_distribution"  # which Enum actions are chosen (drift detection)
-
-    # Renderer (LLM #2)
-    RENDERER_LEAKAGE_FAIL       = "renderer.leakage_fail"          # Whitelist scan failed
-    RENDERER_PLACEHOLDER_FAIL   = "renderer.placeholder_violation"  # Missing or invented placeholder
-    RENDERER_LEAKAGE_CHARS      = "renderer.leakage_chars"          # Offending chars (for slicing)
-
-    # Solver / Server Determinism
-    SOLVER_EXECUTION_MS     = "solver.execution_time_ms"    # Math engine wall-clock time
-    SIGNATURE_HASH_COLLISION = "signature.hash_collision"   # MUST always be 0
-
-    # CRS Pre-Flight
-    CRS_BLOCK               = "crs.preflight_block"     # Emitted when CRS > 0.7 blocks LLM call
-    CRS_VALUE               = "crs.value"               # Raw CRS score for histogram
-
-    # Security
-    SUSPICIOUS_INPUT        = "suspicious.input_pattern"  # Potential prompt injection detected
-
-    # Pedagogical Diversity (V7.2.5)
-    PEDAGOGICAL_DRIFT       = "pedagogical.drift_score"   # Narrative laziness: > 0.35 = same template always chosen
-
-
-# ==================== EMITTER ====================
-
-def emit(metric: str, value, tags: Optional[dict] = None):
-    """
-    Emit a single metric event as a structured JSON log line.
-    Datadog/Grafana log-based metric pipelines should parse lines with 'METRIC_EVENT'.
-    
-    Format:
-    {"event": "METRIC_EVENT", "metric": "<name>", "value": <v>, "tags": {...}, "timestamp": "..."}
-    """
-    payload = {
-        "event":     "METRIC_EVENT",
-        "metric":    metric,
-        "value":     value,
-        "tags":      tags or {},
-        "timestamp": datetime.now(timezone.utc).isoformat()
-    }
-    metrics_logger.info(json.dumps(payload, ensure_ascii=False))
-
-
-def emit_runtime_outcome(outcome: str, problem_id: str = "unknown", grade: str = "unknown"):
-    """Feeds the main Pie Chart and Fail Closed Rate gauge."""
-    emit(M.RUNTIME_OUTCOME, outcome, {"problem_id": problem_id, "grade": grade})
-    if outcome != "success":
-        emit(M.FAIL_CLOSED, 1, {"reason": outcome})
-
-
-def emit_planner_retry(attempt: int, reason: str):
-    emit(M.PLANNER_RETRY, attempt, {"reason": reason})
-
-
-def emit_planner_error(error_type: str, details: str = ""):
-    """error_type: 'enum_violation' | 'json_error'"""
-    key = M.PLANNER_ENUM_VIOLATION if error_type == "enum_violation" else M.PLANNER_JSON_ERROR
-    emit(key, 1, {"details": details[:120]})
-
-
-def emit_planner_strategy_distribution(actions: list):
-    """
-    Phase 1 Live: Emit one metric event per chosen Enum action.
-    Feeds the planner.strategy_distribution dashboard panel.
-    A sudden shift in distribution signals Model Drift.
-    Example: [SOLVE_EQUATION, SIMPLIFY, SOLVE_EQUATION] → 3 events
-    """
-    for action in actions:
-        emit(M.PLANNER_STRATEGY_DIST, 1, {"action": str(action)})
-
-
-def emit_renderer_leakage(offending_chars: str):
-    emit(M.RENDERER_LEAKAGE_FAIL, 1, {"offending_chars": offending_chars[:50]})
-    emit(M.RENDERER_LEAKAGE_CHARS, offending_chars[:50])
-
-
-def emit_renderer_placeholder_violation(violation_type: str, missing_id: str = ""):
-    """violation_type: 'missing' | 'invented'"""
-    emit(M.RENDERER_PLACEHOLDER_FAIL, 1, {"type": violation_type, "id": missing_id})
-
-
-def emit_solver_timing(start_time: float):
-    """Call with time.time() snapshot taken BEFORE solver runs."""
-    elapsed_ms = round((time.time() - start_time) * 1000, 2)
-    emit(M.SOLVER_EXECUTION_MS, elapsed_ms)
-    return elapsed_ms
-
-
-def emit_hash_collision(step_id: str, problem_id: str):
-    """
-    CRITICAL: This MUST never be emitted in a correct system.
-    If it fires, it means two different expressions produced the same hash → P0 alert.
-    """
-    metrics_logger.critical(
-        json.dumps({
-            "event":      "METRIC_EVENT",
-            "metric":     M.SIGNATURE_HASH_COLLISION,
-            "value":      1,
-            "tags":       {"step_id": step_id, "problem_id": problem_id},
-            "timestamp":  datetime.now(timezone.utc).isoformat(),
-            "severity":   "P0_CRITICAL"
-        })
-    )
-
-
-def emit_crs_block(crs_value: float, problem_id: str = "unknown"):
-    emit(M.CRS_BLOCK, 1, {"crs": crs_value, "problem_id": problem_id})
-    emit(M.CRS_VALUE, crs_value)
-
-
-def emit_crs_value(crs_value: float):
-    emit(M.CRS_VALUE, crs_value)
-
-
-def emit_suspicious_input(pattern: str, problem_id: str = "unknown"):
-    emit(M.SUSPICIOUS_INPUT, 1, {"pattern": pattern[:80], "problem_id": problem_id})
-
-
-def emit_pedagogical_drift(concept_tag: str, drift_score: float):
-    """
-    V7.2.5: Emitted when DiversityEngine detects narrative laziness.
-    drift_score > 0.35 means one template variant is dominating selection.
-    Alert DevOps: Renderer is repeating the same pedagogical phrasing — student experience degrades.
-    """
-    emit(M.PEDAGOGICAL_DRIFT, round(drift_score, 3), {"concept": concept_tag})
-
-
-# ==================== TIMER CONTEXT MANAGER ====================
-
-class SolverTimer:
-    """
-    Context manager for measuring Math Engine execution time.
-    Usage:
-        with SolverTimer() as t:
-            result = sympy_solve(...)
-        print(t.elapsed_ms)
-    """
-    def __enter__(self):
-        self._start = time.time()
-        return self
-
-    def __exit__(self, *args):
-        self.elapsed_ms = round((time.time() - self._start) * 1000, 2)
-        emit(M.SOLVER_EXECUTION_MS, self.elapsed_ms)
diff --git a/domain/validator.py b/domain/validator.py
deleted file mode 100644
index 354b5b5f0c483f00db5e084ec94968645d660337..0000000000000000000000000000000000000000
--- a/domain/validator.py
+++ /dev/null
@@ -1,148 +0,0 @@
-# domain/validator.py - V7.4 (DOMAIN-AWARE CONSISTENCY GATE)
-"""
-V7.4 ConsistencyGate: Domain-Aware Validation.
-
-Validates by StepType — NOT by string shape.
-
-  ALGEBRAIC → sympy.sympify() (existing behaviour, unchanged)
-  GEOMETRY  → structural validation of payload (list[str])
-  NUMERIC   → {future expansion point}
-
-CTO directive:
-  - Geometry steps must NEVER reach sympify (Category Error prevention)
-  - Geometry gets its own structural validator, not a "skip blind"
-  - expression is display-only — validation uses payload for geometry
-"""
-import sympy
-import logging
-from typing import List, Tuple
-from domain.step_types import StepType, SignedStep
-
-logger = logging.getLogger(__name__)
-
-
-class ConsistencyGate:
-    """
-    V7.4 Wall 3: Post-Execution Domain-Aware Consistency Gate.
-
-    Receives the list of SignedStep objects from the Deterministic Solver and
-    verifies structural and logical integrity before passing to the Renderer.
-
-    Checks performed (all domains):
-    1. Non-empty: at least one signed step exists.
-    2. Hash integrity: every step has a non-empty SHA256 hash.
-    3a. ALGEBRAIC: expression is SymPy-parseable (sympy.sympify).
-    3b. GEOMETRY:  payload is a non-empty list[str] (structural validation).
-    """
-
-    @staticmethod
-    def _validate_algebraic(step: SignedStep) -> Tuple[bool, str]:
-        """
-        Validates an ALGEBRAIC step by attempting sympy.sympify on each
-        sub-expression (split on " OR " for multi-solution results).
-        """
-        expr_str = step.expression
-        if not expr_str:
-            logger.error(f"[CONSISTENCY_GATE] Step '{step.id}' has an empty expression.")
-            return False, f"EMPTY_EXPRESSION:{step.id}"
-
-        parts = [p.strip() for p in expr_str.split(" OR ")]
-        for part in parts:
-            try:
-                sympy.sympify(part)
-            except Exception as e:
-                logger.error(
-                    f"[CONSISTENCY_GATE] Step '{step.id}' expression not parseable: "
-                    f"'{part}' — {e}"
-                )
-                return False, f"UNPARSEABLE_EXPRESSION:{step.id}"
-        return True, ""
-
-    @staticmethod
-    def _validate_geometry(step: SignedStep) -> Tuple[bool, str]:
-        """
-        Validates a GEOMETRY step structurally via payload.
-
-        Geometry output (points, distances, labels) is NOT SymPy-parseable.
-        We verify:
-          - payload is a non-empty list
-          - every element is a string
-        Hash integrity (checked earlier) is the cryptographic guarantee.
-        """
-        payload = step.payload
-        if not isinstance(payload, list) or len(payload) == 0:
-            logger.error(
-                f"[CONSISTENCY_GATE] Geometry step '{step.id}' has empty or non-list payload."
-            )
-            return False, f"GEOMETRY_EMPTY_PAYLOAD:{step.id}"
-        if not all(isinstance(p, str) for p in payload):
-            logger.error(
-                f"[CONSISTENCY_GATE] Geometry step '{step.id}' payload contains non-string items."
-            )
-            return False, f"GEOMETRY_INVALID_PAYLOAD_TYPE:{step.id}"
-        logger.info(
-            f"[CONSISTENCY_GATE] Geometry step '{step.id}' passed structural validation "
-            f"({len(payload)} point(s))."
-        )
-        return True, ""
-
-    @staticmethod
-    def validate(
-        signed_steps: List,
-        ast_registry: dict,
-        problem_id: str
-    ) -> Tuple[bool, str]:
-        """
-        Returns (True, "") if all checks pass.
-        Returns (False, reason) if any check fails → caller must Fail Closed.
-
-        Accepts both SignedStep objects and legacy dicts for backwards compatibility
-        during any partial migration.
-        """
-        # Check 1: Non-empty output
-        if not signed_steps:
-            logger.error("[CONSISTENCY_GATE] No signed steps produced by solver.")
-            return False, "EMPTY_SOLVER_OUTPUT"
-
-        for step in signed_steps:
-            step_id = step.get("id", "?") if hasattr(step, "get") else step.get("id", "?")
-
-            # Check 2: Hash presence
-            h = step.get("hash", "") if hasattr(step, "get") else step.get("hash", "")
-            if not h or len(h) < 10:
-                logger.error(f"[CONSISTENCY_GATE] Step '{step_id}' is missing a valid SHA256 hash.")
-                return False, f"MISSING_HASH:{step_id}"
-
-            # Check 3: Domain-aware expression / payload validation
-            step_type = step.get("step_type") if hasattr(step, "get") else None
-
-            if step_type == StepType.GEOMETRY:
-                ok, reason = ConsistencyGate._validate_geometry(step)
-                if not ok:
-                    return False, reason
-
-            elif step_type == StepType.ALGEBRAIC or step_type is None:
-                # None = legacy dict without step_type → treat as ALGEBRAIC (backwards compat)
-                expr_str = step.get("expression", "")
-                if not expr_str:
-                    logger.error(f"[CONSISTENCY_GATE] Step '{step_id}' has an empty expression.")
-                    return False, f"EMPTY_EXPRESSION:{step_id}"
-                parts = [p.strip() for p in expr_str.split(" OR ")]
-                for part in parts:
-                    try:
-                        sympy.sympify(part)
-                    except Exception as e:
-                        logger.error(
-                            f"[CONSISTENCY_GATE] Step '{step_id}' expression not parseable: "
-                            f"'{part}' — {e}"
-                        )
-                        return False, f"UNPARSEABLE_EXPRESSION:{step_id}"
-
-            # StepType.NUMERIC → future expansion point
-            # Other unknown types → pass through (hash check is the integrity guarantee)
-
-        logger.info(
-            f"[CONSISTENCY_GATE] ✅ {len(signed_steps)} signed steps passed all checks "
-            f"for problem '{problem_id}'."
-        )
-        return True, ""
diff --git a/exercise_generator.py b/exercise_generator.py
deleted file mode 100644
index 149a74752e267b992767437b21e6868793f04a50..0000000000000000000000000000000000000000
--- a/exercise_generator.py
+++ /dev/null
@@ -1,89 +0,0 @@
-# buddy_math_server/exercise_generator.py
-import json
-import logging
-import time
-import google.generativeai as genai
-from pydantic import BaseModel, Field
-from typing import Optional
-from config import GEMINI_MODEL
-from firebase_manager import firebase_manager
-
-logger = logging.getLogger(__name__)
-
-class GeneratedExerciseSchema(BaseModel):
-    new_problem_latex: str = Field(description="The new exercise in LaTeX format")
-    hint_for_student: str = Field(description="A helpful hint for the student")
-    correct_answer_internal: str = Field(description="The correct answer for system verification")
-
-class ExerciseGenerator:
-    def __init__(self):
-        # We reuse the same model as orchestrator
-        self.model = genai.GenerativeModel(GEMINI_MODEL)
-
-    async def generate_challenge(self, original_problem: str, category: str, uid: str) -> Optional[dict]:
-        """
-        V318.0: Generates a similar challenge exercise based on a solved one.
-        """
-        prompt = f"""אתה מחולל תרגילים למתמטיקה. 
-המטרה: לייצר תרגיל 'אתגר' דומה לתרגיל שהתלמיד פתר בהצלחה.
-
-התרגיל המקורי:
-[ORIGINAL_PROBLEM]
-{original_problem}
-
-הקטגוריה:
-{category}
-
-הנחיות:
-1. ייצר תרגיל חדש באותה רמת קושי בדיוק, המבוסס על אותו עיקרון מתמטי.
-2. השתמש במספרים שונים.
-3. וודא שהפתרון יוצא מספר 'נח' (שלם או שבר פשוט) אם אפשר.
-4. החזר JSON בלבד לפי הסכימה המוגדרת.
-"""
-        
-        try:
-            generation_config = genai.GenerationConfig(
-                response_mime_type="application/json",
-                response_schema=GeneratedExerciseSchema,
-                temperature=0.8
-            )
-            
-            res = await self.model.generate_content_async(
-                prompt,
-                generation_config=generation_config
-            )
-            
-            data = json.loads(res.text)
-            
-            # Save to Firestore
-            self._save_to_suggestions(uid, data, category)
-            
-            return data
-            
-        except Exception as e:
-            logger.error(f"❌ [EXERCISE-GENERATOR] Error: {e}")
-            return None
-
-    def _save_to_suggestions(self, uid: str, data: dict, category: str):
-        """
-        Saves the generated exercise to users/{uid}/suggestions.
-        """
-        try:
-            db = firebase_manager.get_db()
-            if not db: return
-            
-            suggestion_ref = db.collection('users').document(uid).collection('suggestions').document()
-            suggestion_ref.set({
-                "problem_latex": data.get("new_problem_latex"),
-                "hint": data.get("hint_for_student"),
-                "answer": data.get("correct_answer_internal"),
-                "category": category,
-                "status": "pending",
-                "reminder_sent": False,
-                "created_at": time.time()
-            })
-            logger.info(f"✅ [EXERCISE-GENERATOR] Suggestion saved for user {uid}")
-        except Exception as e:
-            logger.error(f"❌ [EXERCISE-GENERATOR] Firestore Save Error: {e}")
-
-exercise_generator = ExerciseGenerator()
diff --git a/explanation_math_firewall.py b/explanation_math_firewall.py
deleted file mode 100644
index a88beddaf99b8b6b5625a5f312e776735888a91e..0000000000000000000000000000000000000000
--- a/explanation_math_firewall.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# explanation_math_firewall.py - V4.2 (Behavioral Firewall)
-# Prevents semantic leaks of forbidden mathematical concepts.
-
-import re
-import logging
-
-logger = logging.getLogger(__name__)
-
-# Concepts that are often "shadow paths" or over-qualified for lower grades
-FORBIDDEN_CONCEPTS = [
-    r"נגזרת", r"נגזור", r"גזירה", r"קיצון", r"מקסימום", r"מינימום", 
-    r"אינטגרל", r"אינטגרציה", r"הפרש", r"מערכת", r"נעלמים", r"שני נעלמים",
-    r"פיתגורס", r"שורשים", r"מכנה משותף" # Add more as needed
-]
-
-# Symbols that indicate over-qualified math
-FORBIDDEN_SYMBOLS = [
-    r"'", r"\\'", r"integral", r"\\int", r"\\Sigma", r"\\Delta"
-]
-
-def scan_explanation(text: str, proof_graph) -> tuple[bool, str]:
-    """
-    Scans explanation text for concepts NOT present in the ProofGraph.
-    Returns (is_safe, violation_reason).
-    """
-    if not text:
-        return True, ""
-
-    # 1. Check for Hebrew forbidden concepts
-    for pattern in FORBIDDEN_CONCEPTS:
-        if re.search(pattern, text):
-            # Check if this concept is "allowed" because it's in the ProofGraph
-            # (e.g., if we actually used a Derivative, it's fine to say 'נגזרת')
-            is_in_proof = False
-            if proof_graph:
-                for step in proof_graph.steps:
-                    if step.operator_used and pattern in step.logic_description:
-                        is_in_proof = True
-                        break
-            
-            if not is_in_proof:
-                logger.warning(f"🛡️ [FIREWALL] Semantic violation detected: '{pattern}'")
-                return False, f"Concept '{pattern}' found in text but not in ProofGraph."
-
-    # 2. Check for forbidden mathematical symbols
-    for symbol in FORBIDDEN_SYMBOLS:
-        if symbol in text:
-            # Similar logic: check if the symbol appears in math_content of proof_graph
-            is_in_proof = False
-            if proof_graph:
-                for step in proof_graph.steps:
-                    if symbol in str(step.math_content):
-                        is_in_proof = True
-                        break
-            
-            if not is_in_proof:
-                logger.warning(f"🛡️ [FIREWALL] Symbol violation detected: '{symbol}'")
-                return False, f"Symbol '{symbol}' found in text but not in ProofGraph."
-
-    return True, ""
diff --git a/find_admin.py b/find_admin.py
deleted file mode 100644
index 625f95138a8e9bc660e73e3c686b9af1fb76a1fd..0000000000000000000000000000000000000000
--- a/find_admin.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import firebase_admin
-from firebase_admin import credentials, firestore
-import json
-
-# Use the backup key found (it was for bussymath, but let's see if it works for dev or if I can use auth)
-# Actually, I'll try to use the Firebase CLI to find the UID since it worked for auth export.
-# But wait, I can't easily query firestore with CLI.
-
-# Let's try to just use the bussymath key, maybe it's the right one after all? 
-# Or maybe I should check the project ID in the key again.
-# It was 'bussymath'. 
-
-# I'll try a different approach: I'll use the 'firebase' CLI to get the user's data if I can.
-# 'firebase firestore:data:get' is not a command.
-
-# I'll try to find any other JSON files that might be service account keys.
diff --git a/find_dotan.py b/find_dotan.py
deleted file mode 100644
index 8f549a986fc012be5847fb0ca277c61d6caed926..0000000000000000000000000000000000000000
--- a/find_dotan.py
+++ /dev/null
@@ -1,25 +0,0 @@
-import firebase_admin
-from firebase_admin import credentials, firestore
-import json
-
-# Use the backup key found
-FIREBASE_CREDENTIALS_PATH = r"c:\Projects\BuddyMath\BuddyMathBackup\19_2\Server\serviceAccountKey.json"
-
-if not firebase_admin._apps:
-    with open(FIREBASE_CREDENTIALS_PATH, "r", encoding="utf-8") as f:
-        cred_dict = json.load(f)
-    cred = credentials.Certificate(cred_dict)
-    firebase_admin.initialize_app(cred)
-
-db = firestore.client()
-
-def find_user():
-    docs = db.collection('users').stream()
-    for doc in docs:
-        data = doc.to_dict()
-        name = data.get('name', '').lower()
-        if 'dotan' in name:
-            print(f"ID: {doc.id} | Name: {data.get('name')} | Balance: {data.get('wallet', {}).get('token_balance')}")
-
-if __name__ == "__main__":
-    find_user()
diff --git a/firebase_manager.py b/firebase_manager.py
deleted file mode 100644
index c801d1801044f2c34183e2852c63ad275ac8e530..0000000000000000000000000000000000000000
--- a/firebase_manager.py
+++ /dev/null
@@ -1,184 +0,0 @@
-import logging
-import os
-import firebase_admin
-from firebase_admin import credentials, storage, firestore, auth
-
-# Initialize logging
-logger = logging.getLogger("BIT-LOG")
-
-class FirebaseManager:
-    """
-    V261.17: Manages Firebase Storage uploads for resilient audio playback.
-    Replaces local static file serving which causes timeouts and 404s.
-    """
-    
-    _instance = None
-    _bucket = None
-    _db = None
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(FirebaseManager, cls).__new__(cls)
-            # Initialization is now handled explicitly in main.py lifespan
-        return cls._instance
-
-    def initialize(self):
-        """
-        V5.13.16: Explicit initialization for Firebase Admin SDK.
-        Guarantees initialize_app() runs once at startup.
-        """
-        if firebase_admin._apps:
-            logger.info("ℹ️ [FIREBASE] SDK already initialized. Skipping.")
-            self._bucket = storage.bucket()
-            self._db = firestore.client()
-            return
-
-        try:
-            from config import STORAGE_BUCKET, IS_PRODUCTION, FIREBASE_CREDENTIALS_PATH
-            import json
-
-            logger.info("🛠️ [FIREBASE] Starting initialization...")
-            
-            cred_dict = None
-            
-            # Mission 1: Try loading from environment variables (checking multiple names for safety)
-            creds_str = os.environ.get("FIREBASE_CREDENTIALS") or os.environ.get("FIREBASE_CREDENTIALS_JSON")
-            
-            if creds_str and len(creds_str.strip()) > 10:
-                try:
-                    cred_dict = json.loads(creds_str)
-                    logger.info("✅ [FIREBASE] Successfully parsed credentials from Environment Secrets!")
-                except Exception as e:
-                    logger.error(f"❌ [FIREBASE] Failed to parse Environment Credentials: {e}")
-
-            # Fallback to local file only for local development (if no secret is set)
-            if not cred_dict and FIREBASE_CREDENTIALS_PATH:
-                if os.path.exists(FIREBASE_CREDENTIALS_PATH):
-                    with open(FIREBASE_CREDENTIALS_PATH, "r", encoding="utf-8") as f:
-                        cred_dict = json.load(f)
-                    logger.info(f"📂 [FIREBASE] Loading credentials from file: {FIREBASE_CREDENTIALS_PATH}.")
-                else:
-                    logger.warning(f"⚠️ [FIREBASE] Credentials file not found at {FIREBASE_CREDENTIALS_PATH}.")
-            
-            if cred_dict:
-                cred = credentials.Certificate(cred_dict)
-                firebase_admin.initialize_app(cred, {
-                    'storageBucket': STORAGE_BUCKET
-                })
-                logger.info(f"🚀 [FIREBASE] SDK Initialized successfully for {'PROD' if IS_PRODUCTION else 'DEV'}.")
-            else:
-                logger.error("❌ [FIREBASE] CRITICAL ERROR: Firebase credentials not found! Firebase is OFFLINE.")
-            
-            self._bucket = storage.bucket()
-            self._db = firestore.client()
-            logger.info("✨ [FIREBASE] Storage and Firestore clients ready.")
-        except Exception as e:
-            logger.error(f"🔥 [FIREBASE] Initialization failed: {e}")
-
-    def get_db(self):
-        """V2: Returns the initialized Firestore client."""
-        if not self._db:
-            # Fallback to lazy init if not explicitly initialized
-            self.initialize()
-        return self._db
-
-    def verify_token(self, id_token: str):
-        """
-        V2: Verifies a Firebase Auth ID token.
-        Returns the decoded token dictionary (including 'uid') if valid, else None.
-        """
-        if not firebase_admin._apps:
-            self.initialize()
-
-        try:
-            decoded_token = auth.verify_id_token(id_token)
-            return decoded_token
-        except Exception as e:
-            if "expired" in str(e).lower():
-                logger.warning("⚠️ [FIREBASE] Token expired.")
-            else:
-                logger.error(f"❌ [FIREBASE] Error verifying token: {e}")
-            return None
-
-    def upload_file(self, local_path: str, destination_blob_name: str) -> str:
-        """
-        V273.1: Uploads local file and returns a Signed URL (CORS proof).
-        Signed URLs bypass public access restrictions and work reliably in production.
-        """
-        if not self._bucket:
-            self.initialize()
-        
-        if not self._bucket:
-            logger.error("❌ [FIREBASE] Not initialized. Cannot upload.")
-            return None
-
-        try:
-            blob = self._bucket.blob(destination_blob_name)
-            blob.upload_from_filename(local_path)
-            
-            # V273.1: Generate Signed URL instead of public_url to fix CORS
-            import datetime
-            signed_url = blob.generate_signed_url(
-                version="v4",
-                expiration=datetime.timedelta(hours=24),
-                method="GET",
-            )
-            
-            logger.info(f"UPLOAD: [FIREBASE] Signed URL generated for {destination_blob_name}")
-            return signed_url
-            
-        except Exception as e:
-            logger.error(f"ERROR: [FIREBASE] Upload failed for {local_path}: {e}")
-            return None
-
-    def save_chat_message(self, uid: str, session_id: str, role: str, content: str, image_urls: list = None, metadata: dict = None):
-        """
-        V318.0: Saves a message to the chat session history in Firestore.
-        Path: users/{uid}/chat_sessions/{session_id}/messages
-        """
-        db = self.get_db()
-        if not db:
-            logger.error("❌ [FIREBASE] Firestore DB not available for saving chat.")
-            return
-
-        try:
-            messages_ref = db.collection('users').document(uid).collection('chat_sessions').document(session_id).collection('messages')
-            
-            payload = {
-                "role": role,
-                "content": content,
-                "image_urls": image_urls or [],
-                "metadata": metadata or {},
-                "timestamp": firestore.SERVER_TIMESTAMP
-            }
-            
-            messages_ref.add(payload)
-            logger.info(f"💾 [FIREBASE] Saved {role} message to session {session_id} for {uid}.")
-        except Exception as e:
-            logger.error(f"❌ [FIREBASE] Failed to save chat message: {e}")
-
-    def get_chat_history(self, uid: str, session_id: str, limit: int = 10):
-        """
-        V318.0: Fetches the last N messages from a chat session, ordered by timestamp.
-        """
-        db = self.get_db()
-        if not db:
-            return []
-
-        try:
-            messages_ref = db.collection('users').document(uid).collection('chat_sessions').document(session_id).collection('messages')
-            query = messages_ref.order_by("timestamp", direction=firestore.Query.DESCENDING).limit(limit)
-            
-            # Note: Reversed order results (query is DESC, we want chronological ASC)
-            docs = query.get()
-            history = []
-            for doc in reversed(list(docs)):
-                history.append(doc.to_dict())
-            
-            return history
-        except Exception as e:
-            logger.error(f"❌ [FIREBASE] Failed to fetch chat history: {e}")
-            return []
-
-# Singleton accessor
-firebase_manager = FirebaseManager()
diff --git a/fix_dotan_balance_script.py b/fix_dotan_balance_script.py
deleted file mode 100644
index 2d27fb33fc9f95b47b569fcae4653fa4822a785e..0000000000000000000000000000000000000000
--- a/fix_dotan_balance_script.py
+++ /dev/null
@@ -1,54 +0,0 @@
-import firebase_admin
-from firebase_admin import credentials, firestore
-import sys
-
-# Configure stdout for UTF-8
-if sys.stdout.encoding != 'utf-8':
-    try:
-        import io
-        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
-    except Exception:
-        pass
-
-# Initialize with project ID only to trigger ADC
-if not firebase_admin._apps:
-    try:
-        firebase_admin.initialize_app(options={'projectId': 'buddy-math-dev'})
-        print("✅ Initialized using Applications Default Credentials (ADC).")
-    except Exception as e:
-        print(f"❌ Failed to initialize using ADC: {e}")
-        sys.exit(1)
-
-db = firestore.client()
-
-def find_dotan_admin():
-    print("Searching for 'Dotan Admin' or 'דותן אדמין' in 'buddy-math-dev'...")
-    try:
-        docs = db.collection('users').stream()
-        found = False
-        for doc in docs:
-            data = doc.to_dict()
-            name = data.get('name', 'N/A')
-            if 'admin' in name.lower() or 'אדמין' in name:
-                print(f"FOUND: ID: {doc.id} | Name: {name}")
-                wallet = data.get('wallet', {})
-                balance = wallet.get('token_balance')
-                print(f"Balance: {balance}")
-                found = True
-                
-                # Update if balance is negative or requested
-                if balance and balance < 0:
-                    new_balance = 464400
-                    print(f"FIXING balance to {new_balance}...")
-                    db.collection('users').doc(doc.id).update({
-                        'wallet.token_balance': new_balance
-                    })
-                    print("✅ SUCCESS: Balance updated.")
-        
-        if not found:
-            print("No admin users found.")
-    except Exception as e:
-        print(f"❌ Error during Firestore query: {e}")
-
-if __name__ == "__main__":
-    find_dotan_admin()
diff --git a/fix_now.py b/fix_now.py
deleted file mode 100644
index 94663f62aa21e59081792dddadb7220102518146..0000000000000000000000000000000000000000
--- a/fix_now.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import requests
-
-BASE_URL = "https://dotandru-buddymath-dev.hf.space"
-TOKEN = "BUDDY-MATH-DEV-2026-BYPASS"
-
-headers = {
-    "Authorization": f"Bearer {TOKEN}"
-}
-
-def fix_dotan_balance():
-    # 1. Get stats to find UID
-    print("FETCHING admin stats...")
-    res = requests.get(f"{BASE_URL}/admin/stats", headers=headers)
-    if res.status_code != 200:
-        print(f"FAILED to get stats: {res.status_code} {res.text}")
-        return
-
-    users = res.json().get('users', [])
-    uid = None
-    for user in users:
-        name = user.get('name', '').lower()
-        if 'dotan' in name:
-            uid = user.get('uid')
-            print(f"FOUND User: {user.get('name')} (UID: {uid})")
-            break
-    
-    if not uid:
-        print("NOT found in stats.")
-        return
-
-    # 2. Call fix_balance
-    print(f"FIXING balance for UID: {uid}...")
-    res = requests.post(f"{BASE_URL}/admin/fix_balance/{uid}", headers=headers)
-    print(f"RESULT: {res.status_code} {res.json()}")
-
-if __name__ == "__main__":
-    fix_dotan_balance()
diff --git a/fix_welcome_audio.py b/fix_welcome_audio.py
deleted file mode 100644
index 92bcc5c217ae8aa8b3bbd98140a77dfc71885412..0000000000000000000000000000000000000000
--- a/fix_welcome_audio.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import asyncio
-import os
-from audio_generator import generate_teacher_audio
-
-# הטקסט של המורה מדף הבית
-WELCOME_SCRIPT = (
-    "היי! ברוכים הבאים למורה למתמטיקה. איזה כיף שהצטרפתם אליי! "
-    "אני כאן כדי להפוך את המתמטיקה לחוויה ברורה וחזותית. "
-    "במסך כאן תמצאו שני כפתורים עיקריים. "
-    "לחצו על הכפור הירוק פתרי לי תרגיל, אם אתם צריכים פתרון מלא ומודרך מאפס. "
-    "או על הכפתור הוורוד בדקי לי תשובה, כדי שאעבור על הדרך שאתם עשיתם ואגיד לכם אם צדקתם. "
-    "חשוב שתדעו, אני תמיד כאן בשבילכם. "
-    "אם סיימתי לפתור ועדיין משהו לא מובן, פשוט תלחצו על הכפתור שאל את המורה. "
-    "אני אשמח להסביר הכל שוב עד שהכל יהיה ברור ומסודר בראש. "
-    "ועוד טיפ קטן ממני. "
-    "אם אתם יושבים ללמוד למבחן, הכי כדאי לעבוד עם מחשב ולא עם הטלפון, כי שם הכל הרבה יותר ברור. "
-    "כדי להתחבר, פשוט נכנסים לאתר מהמחשב ומאשרים את הכניסה דרך הטלפון שלכם. "
-    "שיהיה המון בהצלחה!"
-)
-
-async def fix_welcome():
-    print("TTS: Generating welcome audio in MP3 format...")
-    output_path = "static/welcome_teacher_v1.mp3"
-    
-    # שימוש במחולל האודיו הקיים שכבר יודע להעלות ל-Firebase
-    public_url = await generate_teacher_audio(WELCOME_SCRIPT, output_path)
-    
-    if public_url:
-        print(f"SUCCESS: Welcome audio fixed and uploaded!")
-        print(f"URL: {public_url}")
-    else:
-        print("ERROR: Failed to generate or upload welcome audio.")
-
-if __name__ == "__main__":
-    asyncio.run(fix_welcome())
diff --git a/gcs_lifecycle_rule.json b/gcs_lifecycle_rule.json
deleted file mode 100644
index ddbcb9e8db6dd6475a5c6f77f9e5b08459a1947f..0000000000000000000000000000000000000000
--- a/gcs_lifecycle_rule.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "rule": [
-    {
-      "action": {"type": "Delete"},
-      "condition": {
-        "age": 1,
-        "matchesPrefix": ["tts/"]
-      }
-    }
-  ]
-}
diff --git a/generate_dotan_report.py b/generate_dotan_report.py
deleted file mode 100644
index 838b89aeb0ba7c56558d5ee7dc360e451e9ce07d..0000000000000000000000000000000000000000
--- a/generate_dotan_report.py
+++ /dev/null
@@ -1,97 +0,0 @@
-# buddy_math_server/generate_dotan_report.py
-import asyncio
-import os
-import sys
-import logging
-
-# environment setup
-sys.path.append(os.getcwd())
-os.environ["SENDGRID_API_KEY"] = "SG.mock_key" # Replace with real if testing live
-
-from report_aggregator import report_aggregator
-from report_generator import report_generator
-from report_delivery_service import report_delivery_service
-from firebase_manager import firebase_manager
-from unittest.mock import MagicMock
-
-# Force mock before any calls
-firebase_manager.initialize = MagicMock()
-firebase_manager.get_db = MagicMock(return_value=None)
-
-async def generate_sample_report(uid, student_name, recipient_email):
-    print(f"📄 Generating Sample Report for {student_name} ({uid})...")
-    
-    # 1. Aggregate Data
-    # For testing, we might need to mock the aggregator if Firestore is empty
-    summary = report_aggregator.get_summary_for_period(uid)
-    
-    if not summary or summary["total_interactions"] == 0:
-        print("⚠️ No real data found. Using MOCK data for visibility.")
-        summary = {
-            "total_interactions": 15,
-            "completed_challenges": 4,
-            "avg_mastery": {
-                "אלגברה": 85.5,
-                "גיאומטריה": 92.0,
-                "פונקציות": 78.2,
-                "טריגונומטריה": 65.0
-            },
-            "teacher_notes": ["התלמיד שולט היטב בפתרון משוואות.", "יש לשים לב לדיוק בשרטוט גיאומטרי."]
-        }
-
-    # 2. AI Summary
-    print("🧠 Generating AI Summary...")
-    ai_summary = await report_generator.generate_ai_summary(summary, student_name)
-    print(f"Summary: {ai_summary}")
-
-    # 3. Radar Chart
-    print("📊 Generating Visuals...")
-    chart_url = report_generator.generate_radar_chart_url(summary["avg_mastery"])
-    
-    # 4. Render HTML
-    print("🎨 Rendering Template...")
-    template_data = {
-        "student_name": student_name,
-        "total_interactions": summary["total_interactions"],
-        "completed_challenges": summary["completed_challenges"],
-        "avg_mastery_pct": sum(summary["avg_mastery"].values()) / len(summary["avg_mastery"]),
-        "ai_summary": ai_summary,
-        "chart_url": chart_url
-    }
-    
-    html_content = report_delivery_service.render_html('report_template.html', template_data)
-    
-    # 5. Generate PDF
-    pdf_path = f"/tmp/BuddyMath_Report_{student_name}.pdf"
-    print("🖨️ Generating PDF...")
-    success = report_delivery_service.generate_pdf(html_content, pdf_path)
-    
-    if success:
-        print(f"✅ PDF Generated at: {pdf_path}")
-    else:
-        print("⚠️ PDF generation failed (likely xhtml2pdf missing). Saved as HTML.")
-        pdf_path = pdf_path.replace('.pdf', '.html')
-
-    # 6. Send Email (Mocked unless real key provided)
-    print(f"📧 Sending Email to {recipient_email}...")
-    subject = f"איך עבר השבוע של {student_name} ב-Buddy-Math? ✏️"
-    
-    # If using mock key, it will log error but we consider logic verified
-    email_success = report_delivery_service.send_email_with_attachment(
-        recipient_email, subject, ai_summary, pdf_path, student_name
-    )
-    
-    if email_success:
-        print("✅ Email sent successfully!")
-    else:
-        print("❌ Email delivery failed (verify SENDGRID_API_KEY).")
-
-if __name__ == "__main__":
-    # Ensure Firebase is initialized for real data lookup if available
-    try:
-        firebase_manager.initialize()
-    except Exception as e:
-        print(f"⚠️ Firebase initialization failed: {e}. Proceeding with mock data.")
-    
-    dotan_uid = "dotan_admin_uid" # Replace with actual if known
-    asyncio.run(generate_sample_report(dotan_uid, "דותן", "dotan@example.com"))
diff --git a/generate_new_welcome.py b/generate_new_welcome.py
deleted file mode 100644
index f7225d2374a0460fd66f22a65e62e9e1e53d8d24..0000000000000000000000000000000000000000
--- a/generate_new_welcome.py
+++ /dev/null
@@ -1,102 +0,0 @@
-import os
-import re
-import time
-import torch
-import torchaudio
-import warnings
-from pydub import AudioSegment
-
-warnings.filterwarnings("ignore")
-
-# =========================================================================
-# פתרון חסין לטעינה על CPU
-# =========================================================================
-original_load = torch.load
-
-def safe_load(*args, **kwargs):
-    if 'map_location' not in kwargs:
-        kwargs['map_location'] = 'cpu'
-    if 'weights_only' in kwargs:
-        kwargs['weights_only'] = False
-    return original_load(*args, **kwargs)
-
-torch.load = safe_load
-# =========================================================================
-
-try:
-    from chatterbox.mtl_tts import ChatterboxMultilingualTTS
-    from phonikud_onnx import Phonikud
-    from phonikud import lexicon
-except ImportError:
-    print("❌ שגיאה: חסרות ספריות. וודא שאתה ב-venv_fix והרצת pip install.")
-    exit()
-
-class TTSManager:
-    def __init__(self, reference_audio_path="new_teacher_reference.wav"):
-        print("⚙️  טוען מנוע 'המורה למתמטיקה' (ZipVoice Mode)...")
-        self.device = "cpu"
-        self.ref_audio_path = reference_audio_path
-        self.phonikud_model = Phonikud("phonikud-1.0.int8.onnx")
-        self.tts_model = ChatterboxMultilingualTTS.from_pretrained(device=self.device)
-        print("✅ המנוע מוכן.")
-
-    def _split_to_sentences(self, text):
-        return [s.strip() for s in re.split(r'(?<=[.!?]) +', text) if s.strip()]
-
-    def generate_audio(self, text, output_filename="welcome_speech_v2.wav"):
-        sentences = self._split_to_sentences(text)
-        print(f"📝 מעבד {len(sentences)} משפטים קצרים (למניעת 'נשימות')...")
-        
-        combined = AudioSegment.empty()
-        silence = AudioSegment.silent(duration=250) 
-
-        for i, sentence in enumerate(sentences):
-            temp_file = f"temp_part_{i}.wav"
-            print(f"🎙️  משפט {i+1}/{len(sentences)}: {sentence[:30]}...")
-            
-            # שלב 1: ניקוד אוטומטי
-            voweled = self.phonikud_model.add_diacritics(sentence)
-            voweled = re.sub(fr"[{lexicon.NON_STANDARD_DIAC}]", "", voweled)
-            
-            # שלב 2: תיקון כפוי לנקבה! מחליף "מורֶה" ב-"מורָה"
-            voweled = voweled.replace("מוֹרֶה", "מוֹרָה").replace("מּוֹרֶה", "מּוֹרָה")
-            
-            # ייצור הקול
-            wav = self.tts_model.generate(
-                voweled, 
-                language_id="he", 
-                audio_prompt_path=self.ref_audio_path,
-                cfg_weight=0.90 
-            )
-            torchaudio.save(temp_file, wav, self.tts_model.sr)
-            combined += AudioSegment.from_wav(temp_file) + silence
-            os.remove(temp_file)
-
-        combined.export(output_filename, format="wav")
-        print(f"✨ הושלם! הקובץ מחכה ב: {output_filename}")
-
-if __name__ == "__main__":
-    REFERENCE_FILE = "new_teacher_reference.wav"
-    
-    if not os.path.exists(REFERENCE_FILE):
-        print(f"❌ שגיאה: קובץ דגימה '{REFERENCE_FILE}' לא נמצא.")
-    else:
-        tts = TTSManager(reference_audio_path=REFERENCE_FILE)
-        
-        # הטקסט פוצל למשפטים קצרים עם נקודות למניעת רעשי נשימה ועומס על המודל
-        script = (
-            "היי! ברוכים הבאים למורה למתמטיקה. איזה כיף שהצטרפתם אליי! "
-            "אני כאן כדי להפוך את המתמטיקה לחוויה ברורה וחזותית. "
-            "במסך כאן תמצאו שני כפתורים עיקריים. "
-            "לחצו על הכפתור הירוק פתרי לי תרגיל, אם אתם צריכים פתרון מלא ומודרך מאפס. "
-            "או על הכפתור הוורוד בדקי לי תשובה, כדי שאעבור על הדרך שאתם עשיתם ואגיד לכם אם צדקתם. "
-            "חשוב שתדעו, אני תמיד כאן בשבילכם. "
-            "אם סיימתי לפתור ועדיין משהו לא מובן, פשוט תלחצו על הכפתור שאל את המורה. "
-            "אני אשמח להסביר הכל שוב עד שהכל יהיה ברור ומסודר בראש. "
-            "ועוד טיפ קטן ממני. "
-            "אם אתם יושבים ללמוד למבחן, הכי כדאי לעבוד עם מחשב ולא עם הטלפון, כי שם הכל הרבה יותר ברור. "
-            "כדי להתחבר, פשוט נכנסים לאתר מהמחשב ומאשרים את הכניסה דרך הטלפון שלכם. "
-            "שיהיה המון בהצלחה!"
-        )
-        
-        tts.generate_audio(script, "welcome_speech_v2.wav")
\ No newline at end of file
diff --git a/geometric_sanity.py b/geometric_sanity.py
deleted file mode 100644
index b1b21df1386fbdd889c57235fb54547a897493eb..0000000000000000000000000000000000000000
--- a/geometric_sanity.py
+++ /dev/null
@@ -1,191 +0,0 @@
-# geometric_sanity.py - V1.0 (Geometric Sanity Engine)
-# This module is the public entry point for the sanity check layer.
-#
-# Responsibilities:
-# 1. Parse the raw DataAnchor dict into typed geometric objects.
-# 2. Run all relevant constraint checks (via constraint_checks.py).
-# 3. Build the "VERIFIED FACTS" prompt block for injection into the LLM prompt.
-#
-# Design note: All errors are caught and logged. This module NEVER raises —
-# it always returns a valid (possibly empty) GeometryAnchor and prompt block.
-
-import logging
-from sympy import Rational, sympify
-
-from geometry_types import Point, Line, Segment, Circle, GeometryAnchor
-from constraint_checks import (
-    check_point_on_circle,
-    check_point_on_line,
-    check_is_diameter,
-    check_distance,
-    find_circle_center_from_diameters,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def _parse_point(raw: str, name: str) -> Point | None:
-    """
-    Parses a string like '(3, 5)' or '3,5' into a Point with SymPy Rational coords.
-    Returns None if unparseable (so the engine degrades gracefully).
-    """
-    try:
-        clean = raw.strip().strip("()")
-        parts = clean.split(",")
-        if len(parts) != 2:
-            return None
-        x = Rational(parts[0].strip())
-        y = Rational(parts[1].strip())
-        return Point(name=name, x=x, y=y)
-    except Exception as e:
-        logger.debug(f"[GEO-SANITY] Could not parse point '{raw}' as '{name}': {e}")
-        return None
-
-
-def _parse_radius(raw) -> object | None:
-    """
-    Parses a radius value into a SymPy Rational or expression.
-    """
-    try:
-        return Rational(raw)
-    except Exception:
-        try:
-            return sympify(str(raw))
-        except Exception as e:
-            logger.debug(f"[GEO-SANITY] Could not parse radius '{raw}': {e}")
-            return None
-
-
-def _build_prompt_block(anchor: GeometryAnchor) -> str:
-    """
-    Builds the 'VERIFIED MATHEMATICAL FACTS' block to be injected before LLM generation.
-    This is the final output consumed by prompts.py / strategy_manager.py.
-    """
-    facts_text = "\n".join(anchor.verified_facts) if anchor.verified_facts else "אין עובדות מאומתות."
-    warnings_text = "\n".join(anchor.warnings) if anchor.warnings else "אין סתירות."
-    
-    block = f"""
-╔══════════════════════════════════════════════════════╗
-║  VERIFIED MATHEMATICAL FACTS (GROUND TRUTH — V1.0)  ║
-╚══════════════════════════════════════════════════════╝
-{facts_text}
-
-╔══════════════════════════════════════════════════════╗
-║  CONSTRAINT VIOLATIONS (READ CAREFULLY)             ║
-╚══════════════════════════════════════════════════════╝
-{warnings_text}
-
-⚠️ הוראה קריטית: אם האינטואיציה שלך סותרת עובדה מאומתת לעיל,
-   **העובדה האלגברית תמיד מנצחת**. אל תמציא נתונים גיאומטריים
-   שאינם מאושרים כ-Verified Fact. כל ה-Verified Facts חושבו ע"י
-   SymPy ואינם ניתנים לערעור.
-╔══════════════════════════════════════════════════════╝
-"""
-    return block
-
-
-def run_geometric_sanity(data_anchor: dict) -> tuple[GeometryAnchor, str]:
-    """
-    V1.0: Main entry point. Parses the data_anchor dict and runs all applicable checks.
-    
-    Args:
-        data_anchor: dict — the raw anchor extracted by orchestrator._extract_key_data()
-    
-    Returns:
-        (GeometryAnchor, str) — the populated anchor + the prompt block for LLM injection.
-    
-    This function NEVER raises. All exceptions are caught and logged.
-    """
-    anchor = GeometryAnchor()
-
-    if not data_anchor:
-        logger.info("[GEO-SANITY] Empty data_anchor — skipping geometric checks.")
-        return anchor, ""
-
-    logger.info("[GEO-SANITY] 🔍 Starting Geometric Sanity Check...")
-
-    # ─── 1. Parse raw center & radius ───────────────────────────────────────────
-    raw_center = data_anchor.get("center")
-    raw_radius = data_anchor.get("radius")
-    circle = None
-
-    if raw_center and len(raw_center) == 2:
-        try:
-            cx = Rational(raw_center[0])
-            cy = Rational(raw_center[1])
-            center_point = Point(name="O", x=cx, y=cy)
-        except Exception as e:
-            center_point = None
-            logger.warning(f"[GEO-SANITY] Could not parse center {raw_center}: {e}")
-    else:
-        center_point = None
-
-    if center_point and raw_radius is not None:
-        r = _parse_radius(raw_radius)
-        if r is not None:
-            circle = Circle(center=center_point, radius=r)
-            anchor.circles.append(circle)
-            anchor.add_fact(f"✓ מעגל נטען: מרכז {center_point}, r={r}")
-
-    # ─── 2. Parse named points ────────────────────────────────────────────────
-    parsed_points: dict[str, Point] = {}
-
-    for field_name in ["point_a", "point_b", "point_c", "point_d"]:
-        raw = data_anchor.get(field_name)
-        if raw:
-            label = field_name.split("_")[-1].upper()
-            pt = _parse_point(str(raw), label)
-            if pt:
-                parsed_points[label] = pt
-                anchor.points.append(pt)
-
-    # Also parse points from the 'points' list (e.g., ["A(3,5)", "B(0,0)"])
-    for raw_point_str in data_anchor.get("points", []):
-        try:
-            # Match "A(3,5)" or "A(3, 5)"
-            import re
-            m = re.match(r'([A-Za-z]+)\s*\(([^)]+)\)', str(raw_point_str))
-            if m:
-                lbl = m.group(1)
-                coords = m.group(2).split(",")
-                if len(coords) == 2:
-                    px = Rational(coords[0].strip())
-                    py = Rational(coords[1].strip())
-                    pt = Point(name=lbl, x=px, y=py)
-                    parsed_points[lbl] = pt
-                    anchor.points.append(pt)
-        except Exception as e:
-            logger.debug(f"[GEO-SANITY] Could not parse points entry '{raw_point_str}': {e}")
-
-    # ─── 3. Run point-on-circle checks ───────────────────────────────────────
-    if circle:
-        for name, pt in parsed_points.items():
-            check_point_on_circle(pt, circle, anchor)
-
-    # ─── 4. Diameter check: if exactly 2 points, check if they form a diameter ─
-    if circle and len(parsed_points) >= 2:
-        names = list(parsed_points.keys())
-        for i in range(len(names)):
-            for j in range(i + 1, len(names)):
-                p_i = parsed_points[names[i]]
-                p_j = parsed_points[names[j]]
-                seg = Segment(p1=p_i, p2=p_j)
-                check_is_diameter(seg, circle, anchor)
-                anchor.segments.append(seg)
-
-    # ─── 5. Final summary log ─────────────────────────────────────────────────
-    logger.info(
-        f"[GEO-SANITY] ✅ Check complete. "
-        f"Facts: {len(anchor.verified_facts)}, Warnings: {len(anchor.warnings)}"
-    )
-
-    prompt_block = _build_prompt_block(anchor)
-    return anchor, prompt_block
-
-
-def build_verified_facts_prompt(anchor: GeometryAnchor) -> str:
-    """
-    Public helper: Re-builds the prompt block from an already-populated anchor.
-    Useful for re-injection after additional checks.
-    """
-    return _build_prompt_block(anchor)
diff --git a/geometry_types.py b/geometry_types.py
deleted file mode 100644
index 6d34f5f0dca8a2071587ddbc112b46115b83d940..0000000000000000000000000000000000000000
--- a/geometry_types.py
+++ /dev/null
@@ -1,122 +0,0 @@
-# geometry_types.py - V1.0 (Geometric Sanity Engine — Type Contracts)
-# CTO NOTE: All coordinate arithmetic uses SymPy Rational to guarantee
-# exact arithmetic — no float drift, no rounding surprises.
-
-from dataclasses import dataclass, field
-from sympy import Rational, simplify, sqrt
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class Point:
-    name: str
-    x: object  # SymPy expression or numeric
-    y: object
-
-    def __eq__(self, other):
-        if not isinstance(other, Point):
-            return False
-        return (simplify(self.x - other.x) == 0 and
-                simplify(self.y - other.y) == 0)
-
-    def __repr__(self):
-        return f"{self.name}({self.x}, {self.y})"
-
-    def distance_to(self, other: "Point"):
-        """Exact SymPy distance between two points."""
-        return sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
-
-
-@dataclass
-class Line:
-    """Represents the line ax + by + c = 0."""
-    a: object
-    b: object
-    c: object
-
-    def y_at(self, x_val):
-        """Compute y given x (assuming b ≠ 0)."""
-        if simplify(self.b) == 0:
-            raise ValueError("[Line.y_at] Vertical line — b=0, y is undefined for a given x.")
-        return Rational(-self.a * x_val - self.c, self.b)
-
-    def contains(self, p: "Point") -> bool:
-        """Returns True if point p satisfies ax + by + c = 0."""
-        val = simplify(self.a * p.x + self.b * p.y + self.c)
-        return val == 0
-
-    def __repr__(self):
-        return f"Line({self.a}x + {self.b}y + {self.c} = 0)"
-
-
-@dataclass
-class Segment:
-    p1: Point
-    p2: Point
-
-    def midpoint(self) -> Point:
-        """Returns the midpoint with exact rational arithmetic."""
-        from sympy import Rational as R
-        mid_x = (self.p1.x + self.p2.x) / 2
-        mid_y = (self.p1.y + self.p2.y) / 2
-        return Point(
-            name=f"mid_{self.p1.name}{self.p2.name}",
-            x=simplify(mid_x),
-            y=simplify(mid_y)
-        )
-
-    def length(self):
-        """Exact SymPy length of the segment."""
-        return self.p1.distance_to(self.p2)
-
-    def __repr__(self):
-        return f"Segment({self.p1.name}{self.p2.name})"
-
-
-@dataclass
-class Circle:
-    center: Point
-    radius: object  # SymPy expression (can be symbolic)
-
-    def contains(self, p: Point) -> bool:
-        """Returns True if p lies exactly on the circle boundary."""
-        lhs = (p.x - self.center.x)**2 + (p.y - self.center.y)**2
-        return simplify(lhs - self.radius**2) == 0
-
-    def __repr__(self):
-        return f"Circle(center={self.center}, r={self.radius})"
-
-
-@dataclass
-class GeometryAnchor:
-    """
-    V1.0: The single source of truth for verified geometric facts.
-    Populated by `constraint_checks.py` and consumed by `geometric_sanity.py`.
-    """
-    points: list = field(default_factory=list)
-    lines: list = field(default_factory=list)
-    segments: list = field(default_factory=list)
-    circles: list = field(default_factory=list)
-    verified_facts: list = field(default_factory=list)
-    warnings: list = field(default_factory=list)
-
-    def add_fact(self, fact: str):
-        logger.info(f"[GEO-ANCHOR] ✓ FACT: {fact}")
-        self.verified_facts.append(fact)
-
-    def add_warning(self, warning: str):
-        logger.warning(f"[GEO-ANCHOR] ✗ WARNING: {warning}")
-        self.warnings.append(warning)
-
-    def is_clean(self) -> bool:
-        """True if no geometric contradictions were detected."""
-        return len(self.warnings) == 0
-
-    def summary(self) -> dict:
-        return {
-            "verified_facts": self.verified_facts,
-            "warnings": self.warnings,
-            "has_contradictions": not self.is_clean()
-        }
diff --git a/gibberish_detector.py b/gibberish_detector.py
deleted file mode 100644
index 408e4bc8bc65618a1a5bb4310eb2bea7f5e2a02d..0000000000000000000000000000000000000000
--- a/gibberish_detector.py
+++ /dev/null
@@ -1,242 +0,0 @@
-# gibberish_detector.py - V274.1 (Multi-line LaTeX Fix + SymPy Separation)
-# STABLE VERSION - No aggressive Hebrew removal!
-import re, copy, asyncio
-from typing import Tuple, Dict, Any, List
-
-print("[BIT-LOG: GibberishDetector V274.1 Loaded (Multi-line LaTeX Fix)]")
-
-# ==================== REPAIR MAPS ====================
-
-# Simple replace fixes (Not regex)
-REPAIR_MAP = {
-    '\\\\\\\\\\\\\\\\': '\\\\\\\\',
-    '\\\\\\\\': '\\\\',
-    '$$$': '$$',
-    'תוילקבמ': 'מקביליות',
-    'םיחטש': 'שטחים',
-    'הדוקנה': 'הנקודה',
-}
-
-# Broken LaTeX patterns (Regex)
-LATEX_FIXES = {
-    r'\\rac\{': r'\\frac{',  # Missing 'f'
-    r'\\eta\{': r'\\beta{',  # Wrong letter
-    r'\\sqr\{': r'\\sqrt{',  # Missing 't'
-    r'(?<!\\)\b(sin|cos|tan|log|ln)\b': r'\\\1', # Missing backslash for funcs
-    r'(?<!\\)\b(alpha|beta|gamma|cdot)\b': r'\\\1', # Missing backslash for greek/symbols
-}
-
-PROTECTED_FIELDS = {'section_title', 'title', 'teacher_tip', 'teacher_closing'}
-MATH_ALLOWED_FIELDS = {'block_math', 'formulas', 'final_answer', 'function', 'derivative'}
-
-# ==================== DETECTION ====================
-
-def detect_gibberish_advanced(text: str) -> dict:
-    """
-    Advanced gibberish detection.
-    
-    Returns:
-        {
-            "has_issues": bool,
-            "issues": [...]
-        }
-    """
-    issues = []
-    
-    # 1. Reversed Hebrew
-    for wrong, correct in REPAIR_MAP.items():
-        if wrong in text and len(wrong) > 3:
-            issues.append({
-                "type": "REVERSED_HEBREW",
-                "wrong": wrong,
-                "correct": correct,
-                "fixable": True
-            })
-    
-    # 2. Broken LaTeX
-    for pattern, fix in LATEX_FIXES.items():
-        if re.search(pattern, text):
-            issues.append({
-                "type": "BROKEN_LATEX",
-                "pattern": pattern,
-                "fix": fix,
-                "fixable": True
-            })
-    
-    # 3. Hebrew inside $...$
-    hebrew_in_math = re.findall(r'\$[^$]*[\u0590-\u05FF][^$]*\$', text)
-    for match in hebrew_in_math:
-        issues.append({
-            "type": "HEBREW_IN_MATH",
-            "line": match,
-            "fixable": False,
-            "needs_llm": True
-        })
-    
-    # 4. Double $$ issues
-    if '$$$$' in text or '$$ $' in text:
-        issues.append({
-            "type": "DOUBLE_DOLLARS",
-            "fixable": True,
-            "fix": "$$"
-        })
-    
-    return {
-        "has_issues": len(issues) > 0,
-        "issues": issues
-    }
-
-
-# ==================== AUTO-FIX ====================
-
-def fix_multiline_latex_blocks(text: str) -> str:
-    """
-    V274.1: Fix multi-line LaTeX blocks that Flutter can't render.
-    
-    Converts:
-      $$$$line1
-      line2
-      line3$$$$
-    
-    To:
-      $$line1$$ ,
-      $$line2$$ ,
-      $$line3$$
-    """
-    def split_block(match):
-        content = match.group(1)
-        lines = [line.strip() for line in content.split('\n') if line.strip()]
-        if not lines: return ""
-        # V274.1: Add logical comma separation between blocks to prevent SymPy squashing
-        return ' , \n '.join(f'$${line}$$' for line in lines)
-    
-    return re.sub(r'\$\$\$\$(.*?)\$\$\$\$', split_block, text, flags=re.DOTALL)
-
-
-def auto_fix_gibberish(text: str) -> str:
-    """Auto-fix simple gibberish issues with regex/replace."""
-    if not text:
-        return text
-
-    fixed = text
-    
-    # V274.0: Fix multi-line LaTeX blocks FIRST
-    fixed = fix_multiline_latex_blocks(fixed)
-    
-    # Fix simple artifacts
-    for wrong, correct in REPAIR_MAP.items():
-        fixed = fixed.replace(wrong, correct)
-    
-    # Fix broken LaTeX
-    for pattern, replacement in LATEX_FIXES.items():
-        fixed = re.sub(pattern, replacement, fixed)
-    
-    # Fix dollar sign glitches
-    fixed = fixed.replace('$$ $', '$$')
-    fixed = fixed.replace('$ $$', '$$')
-    
-    return fixed
-
-
-# ==================== LLM RETRY ====================
-
-async def fix_line_with_llm(problematic_line: str, llm_model) -> str:
-    """Use LLM to fix complex gibberish (e.g., Hebrew in math)."""
-    prompt = f"""FIX THIS LINE ONLY:
-Problematic: "{problematic_line}"
-
-Rules:
-1. Hebrew text OUTSIDE $...$
-2. Math INSIDE $...$
-3. NO Hebrew inside math delimiters
-
-Output: Fixed line ONLY (one line, no explanation)
-"""
-    
-    try:
-        response = await asyncio.wait_for(
-            llm_model.generate_content_async(prompt),
-            timeout=10.0
-        )
-        return response.text.strip()
-    except Exception as e:
-        print(f"⚠️ [GIBBERISH] LLM fix failed: {e}")
-        return problematic_line
-
-
-# ==================== SMART FIX ====================
-
-async def fix_gibberish_smart(text: str, llm_model=None) -> str:
-    """Smart gibberish fixing."""
-    fixed = auto_fix_gibberish(text)
-    result = detect_gibberish_advanced(fixed)
-    
-    if not result["has_issues"]:
-        return fixed
-    
-    if llm_model:
-        for issue in result["issues"]:
-            if issue.get("needs_llm"):
-                line = issue["line"]
-                fixed_line = await fix_line_with_llm(line, llm_model)
-                fixed = fixed.replace(line, fixed_line)
-    
-    return fixed
-
-
-# ==================== LEGACY INTERFACE ====================
-
-def validate_and_fix_solution(solution: Dict[str, Any]) -> Tuple[Dict[str, Any], bool, str]:
-    """Legacy interface - now uses auto-fix"""
-    fixed = copy.deepcopy(solution)
-    
-    def process(obj, field=""):
-        if isinstance(obj, dict):
-            return {k: process(v, k) for k, v in obj.items()}
-        if isinstance(obj, list):
-            return [process(i, field) for i in obj]
-        if isinstance(obj, str):
-            return auto_fix_gibberish(_fix_string(obj, field))
-        return obj
-    
-    return process(fixed), False, ""
-
-
-def _fix_string(text: str, field: str) -> str:
-    """Legacy string fixing"""
-    if not text or text.lower() in ["none", "null"]:
-        return text
-    
-    res = text.replace(r'\f\frac', r'\frac')
-    
-    # V231.2: Skip $$ wrapping for :: format
-    if '::' in res:
-        for bad, good in REPAIR_MAP.items():
-            res = res.replace(bad, good)
-        return res
-    
-    # Hebrew-Safe $$ Rule — only for pure-math fields
-    if '\\' in res and '$$' not in res and field in MATH_ALLOWED_FIELDS:
-        if not bool(re.search(r'[\u0590-\u05FF]', res)):
-            res = f"$${res.replace('$', '')}$$"
-    
-    for bad, good in REPAIR_MAP.items():
-        res = res.replace(bad, good)
-    
-    return res
-
-
-def format_solution(data):
-    return data
-
-
-# ==================== USAGE EXAMPLE ====================
-
-if __name__ == "__main__":
-    test_text = "נשתמש בנוסחה $x = \\frac{1}{2}$ ונקבל \\rac{x}{y}"
-    
-    result = detect_gibberish_advanced(test_text)
-    print(f"Issues found: {result}")
-    
-    fixed = auto_fix_gibberish(test_text)
-    print(f"Auto-fixed: {fixed}")
diff --git a/implementation_plan.md b/implementation_plan.md
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/inactivity_poker.py b/inactivity_poker.py
deleted file mode 100644
index 6b3def20f1081b22b5b6b68a8ddc280c129e852f..0000000000000000000000000000000000000000
--- a/inactivity_poker.py
+++ /dev/null
@@ -1,70 +0,0 @@
-import os
-import datetime
-import firebase_admin
-from firebase_admin import credentials, firestore, messaging
-
-# V5.9.10: Inactivity Poker - Sends push to users inactive for 7 days
-def run_inactivity_check():
-    # 1. Initialize Firebase (assuming creds are in environment or default)
-    if not firebase_admin._apps:
-        cred = credentials.ApplicationDefault()
-        firebase_admin.initialize_app(cred)
-    
-    db = firestore.client()
-    
-    # 2. Fetch CMS templates
-    print("📡 Fetching CMS templates...")
-    cms_doc = db.collection('system_config').document('notifications').get()
-    if cms_doc.exists:
-        template = cms_doc.to_dict().get('practice_reminder', {})
-    else:
-        template = {
-            'title': 'המורה מתגעגעת 🧮',
-            'body': 'היי! לא תרגלנו כבר שבוע. יש משהו שאפשר לעזור בו?'
-        }
-    
-    print(f"📝 CMS Template loaded: {template.get('title')}")
-
-    # 3. Calculate 7 days ago
-    seven_days_ago = (datetime.datetime.now() - datetime.timedelta(days=7)).strftime('%Y-%m-%d')
-    print(f"🔍 Searching for users active last on: {seven_days_ago}")
-
-    # 4. Query users
-    users_ref = db.collection('users')
-    inactive_users = users_ref.where('last_active_date', '==', seven_days_ago).stream()
-
-    total_sent = 0
-    for user in inactive_users:
-        data = user.to_dict()
-        fcm_token = data.get('fcm_token') or data.get('fcmToken')
-        uid = data.get('uid')
-        name = data.get('name', 'תלמיד/ה')
-
-        if fcm_token:
-            print(f"🚀 Sending push to {name} ({uid})...")
-            try:
-                # Build localized message
-                body = template.get('body', '').replace('{name}', name)
-                
-                message = messaging.Message(
-                    notification=messaging.Notification(
-                        title=template.get('title'),
-                        body=body,
-                    ),
-                    token=fcm_token,
-                    data={
-                        'type': 'practice_reminder',
-                        'click_action': 'FLUTTER_NOTIFICATION_CLICK'
-                    }
-                )
-                messaging.send(message)
-                total_sent += 1
-            except Exception as e:
-                print(f"❌ Failed to send to {uid}: {e}")
-        else:
-            print(f"⚠️ No FCM token for {name} ({uid})")
-
-    print(f"✅ Inactivity check done. Total pushes sent: {total_sent}")
-
-if __name__ == "__main__":
-    run_inactivity_check()
diff --git a/logs/usage.jsonl b/logs/usage.jsonl
deleted file mode 100644
index f33c546c56d373aaf429c7b843c6d0ddf107c9d7..0000000000000000000000000000000000000000
--- a/logs/usage.jsonl
+++ /dev/null
@@ -1,1590 +0,0 @@
-{"timestamp": 1771693423.538, "source": "OCR_PASS_1", "input_tokens": 2828, "output_tokens": 105, "total_tokens": 2933}
-{"timestamp": 1771693425.9773674, "source": "OCR_PASS_2", "input_tokens": 2828, "output_tokens": 103, "total_tokens": 2931}
-{"timestamp": 1771693427.326977, "source": "OCR_PASS_3", "input_tokens": 2854, "output_tokens": 104, "total_tokens": 2958}
-{"timestamp": 1771693428.3058724, "source": "DATA_ANCHOR", "input_tokens": 597, "output_tokens": 126, "total_tokens": 723}
-{"timestamp": 1771693434.7120218, "source": "STRATEGY_CARD", "input_tokens": 491, "output_tokens": 774, "total_tokens": 1265}
-{"timestamp": 1771693437.2187765, "source": "VISUAL_CONTEXT", "input_tokens": 2853, "output_tokens": 263, "total_tokens": 3116}
-{"timestamp": 1771693445.691136, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 3279, "output_tokens": 1228, "total_tokens": 4507}
-{"timestamp": 1771693452.71575, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 3279, "output_tokens": 1019, "total_tokens": 4298}
-{"timestamp": 1771693456.4534245, "source": "TEACHER_SUMMARY", "input_tokens": 689, "output_tokens": 170, "total_tokens": 859}
-{"timestamp": 1771693723.9743402, "source": "OCR_PASS_1", "input_tokens": 2828, "output_tokens": 106, "total_tokens": 2934}
-{"timestamp": 1771693725.8095644, "source": "OCR_PASS_2", "input_tokens": 2828, "output_tokens": 105, "total_tokens": 2933}
-{"timestamp": 1771693727.267206, "source": "OCR_PASS_3", "input_tokens": 2854, "output_tokens": 107, "total_tokens": 2961}
-{"timestamp": 1771693728.2955537, "source": "DATA_ANCHOR", "input_tokens": 600, "output_tokens": 126, "total_tokens": 726}
-{"timestamp": 1771693734.129027, "source": "STRATEGY_CARD", "input_tokens": 494, "output_tokens": 630, "total_tokens": 1124}
-{"timestamp": 1771693736.62415, "source": "VISUAL_CONTEXT", "input_tokens": 2856, "output_tokens": 259, "total_tokens": 3115}
-{"timestamp": 1771693744.713374, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 3282, "output_tokens": 1271, "total_tokens": 4553}
-{"timestamp": 1771693749.00522, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 928, "output_tokens": 609, "total_tokens": 1537}
-{"timestamp": 1771693757.6733787, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 5716, "output_tokens": 1397, "total_tokens": 7113}
-{"timestamp": 1771693759.9973102, "source": "TEACHER_SUMMARY", "input_tokens": 693, "output_tokens": 161, "total_tokens": 854}
-{"timestamp": 1771705163.190006, "source": "OCR_PASS_1", "input_tokens": 2828, "output_tokens": 105, "total_tokens": 2933}
-{"timestamp": 1771705164.693675, "source": "OCR_PASS_2", "input_tokens": 2828, "output_tokens": 105, "total_tokens": 2933}
-{"timestamp": 1771705167.7348561, "source": "OCR_PASS_3", "input_tokens": 2854, "output_tokens": 105, "total_tokens": 2959}
-{"timestamp": 1771705168.6617742, "source": "DATA_ANCHOR", "input_tokens": 597, "output_tokens": 126, "total_tokens": 723}
-{"timestamp": 1771705174.3277152, "source": "STRATEGY_CARD", "input_tokens": 491, "output_tokens": 688, "total_tokens": 1179}
-{"timestamp": 1771705176.8081672, "source": "VISUAL_CONTEXT", "input_tokens": 2853, "output_tokens": 296, "total_tokens": 3149}
-{"timestamp": 1771705184.216854, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 3375, "output_tokens": 1200, "total_tokens": 4575}
-{"timestamp": 1771705187.6281483, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 830, "output_tokens": 433, "total_tokens": 1263}
-{"timestamp": 1771705196.1125476, "source": "STRATEGY_VISION_TRIGONOMETRY", "input_tokens": 5266, "output_tokens": 1262, "total_tokens": 6528}
-{"timestamp": 1771705199.068693, "source": "TEACHER_SUMMARY", "input_tokens": 700, "output_tokens": 168, "total_tokens": 868}
-{"timestamp": 1771707091.8494453, "source": "OCR_PASS_1", "input_tokens": 3860, "output_tokens": 191, "total_tokens": 4051}
-{"timestamp": 1771707094.6918614, "source": "OCR_PASS_2", "input_tokens": 3860, "output_tokens": 193, "total_tokens": 4053}
-{"timestamp": 1771707097.0384836, "source": "OCR_PASS_3", "input_tokens": 3886, "output_tokens": 191, "total_tokens": 4077}
-{"timestamp": 1771707098.2145278, "source": "DATA_ANCHOR", "input_tokens": 683, "output_tokens": 171, "total_tokens": 854}
-{"timestamp": 1771707109.3623402, "source": "STRATEGY_CARD", "input_tokens": 602, "output_tokens": 1079, "total_tokens": 1681}
-{"timestamp": 1771707113.133246, "source": "VISUAL_CONTEXT", "input_tokens": 3971, "output_tokens": 393, "total_tokens": 4364}
-{"timestamp": 1771707120.374277, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 4404, "output_tokens": 910, "total_tokens": 5314}
-{"timestamp": 1771707123.310944, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 359, "output_tokens": 390, "total_tokens": 749}
-{"timestamp": 1771707131.6315806, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 5539, "output_tokens": 1221, "total_tokens": 6760}
-{"timestamp": 1771707137.85813, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 5965, "output_tokens": 565, "total_tokens": 6530}
-{"timestamp": 1771707139.4957159, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 223, "output_tokens": 126, "total_tokens": 349}
-{"timestamp": 1771707146.6059453, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 6376, "output_tokens": 857, "total_tokens": 7233}
-{"timestamp": 1771707151.0825157, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 6999, "output_tokens": 336, "total_tokens": 7335}
-{"timestamp": 1771707152.3021426, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 259, "output_tokens": 115, "total_tokens": 374}
-{"timestamp": 1771707156.9751952, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 7477, "output_tokens": 405, "total_tokens": 7882}
-{"timestamp": 1771707162.1667395, "source": "TEACHER_SUMMARY", "input_tokens": 919, "output_tokens": 226, "total_tokens": 1145}
-{"timestamp": 1771707303.1486073, "source": "OCR_PASS_1", "input_tokens": 2312, "output_tokens": 333, "total_tokens": 2645}
-{"timestamp": 1771707306.3312893, "source": "OCR_PASS_2", "input_tokens": 2312, "output_tokens": 348, "total_tokens": 2660}
-{"timestamp": 1771707309.0251966, "source": "OCR_PASS_3", "input_tokens": 2338, "output_tokens": 330, "total_tokens": 2668}
-{"timestamp": 1771707310.6983006, "source": "DATA_ANCHOR", "input_tokens": 825, "output_tokens": 195, "total_tokens": 1020}
-{"timestamp": 1771707319.8062668, "source": "STRATEGY_CARD", "input_tokens": 767, "output_tokens": 936, "total_tokens": 1703}
-{"timestamp": 1771707323.065026, "source": "VISUAL_CONTEXT", "input_tokens": 2565, "output_tokens": 338, "total_tokens": 2903}
-{"timestamp": 1771707327.217843, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2860, "output_tokens": 468, "total_tokens": 3328}
-{"timestamp": 1771707328.4814675, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 258, "output_tokens": 123, "total_tokens": 381}
-{"timestamp": 1771707333.221795, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3606, "output_tokens": 732, "total_tokens": 4338}
-{"timestamp": 1771707339.8934233, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3790, "output_tokens": 1045, "total_tokens": 4835}
-{"timestamp": 1771707345.2224674, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 674, "output_tokens": 722, "total_tokens": 1396}
-{"timestamp": 1771707352.3656025, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 6046, "output_tokens": 1232, "total_tokens": 7278}
-{"timestamp": 1771707358.0804663, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5701, "output_tokens": 843, "total_tokens": 6544}
-{"timestamp": 1771707366.9331043, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5701, "output_tokens": 804, "total_tokens": 6505}
-{"timestamp": 1771707368.2040594, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 396, "output_tokens": 91, "total_tokens": 487}
-{"timestamp": 1771707375.8241384, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 6965, "output_tokens": 1292, "total_tokens": 8257}
-{"timestamp": 1771707380.6597838, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 7184, "output_tokens": 657, "total_tokens": 7841}
-{"timestamp": 1771707381.6251857, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 258, "output_tokens": 102, "total_tokens": 360}
-{"timestamp": 1771707385.5997605, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 8126, "output_tokens": 645, "total_tokens": 8771}
-{"timestamp": 1771707388.403119, "source": "TEACHER_SUMMARY", "input_tokens": 972, "output_tokens": 175, "total_tokens": 1147}
-{"timestamp": 1771752503.098016, "source": "OCR_PASS_1", "input_tokens": 1796, "output_tokens": 446, "total_tokens": 2242}
-{"timestamp": 1771752507.391836, "source": "OCR_PASS_2", "input_tokens": 1796, "output_tokens": 462, "total_tokens": 2258}
-{"timestamp": 1771752511.2062192, "source": "OCR_PASS_3", "input_tokens": 1822, "output_tokens": 448, "total_tokens": 2270}
-{"timestamp": 1771752512.9681115, "source": "DATA_ANCHOR", "input_tokens": 955, "output_tokens": 178, "total_tokens": 1133}
-{"timestamp": 1771752524.0713267, "source": "STRATEGY_CARD", "input_tokens": 883, "output_tokens": 832, "total_tokens": 1715}
-{"timestamp": 1771752526.5811582, "source": "VISUAL_CONTEXT", "input_tokens": 2179, "output_tokens": 181, "total_tokens": 2360}
-{"timestamp": 1771752530.4413433, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2300, "output_tokens": 264, "total_tokens": 2564}
-{"timestamp": 1771752531.5438244, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 223, "output_tokens": 79, "total_tokens": 302}
-{"timestamp": 1771752534.8133113, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2667, "output_tokens": 273, "total_tokens": 2940}
-{"timestamp": 1771752538.2960565, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2668, "output_tokens": 315, "total_tokens": 2983}
-{"timestamp": 1771752539.4933789, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 230, "output_tokens": 88, "total_tokens": 318}
-{"timestamp": 1771752542.5362265, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3176, "output_tokens": 320, "total_tokens": 3496}
-{"timestamp": 1771752545.3634338, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3233, "output_tokens": 282, "total_tokens": 3515}
-{"timestamp": 1771752546.1335268, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 216, "output_tokens": 38, "total_tokens": 254}
-{"timestamp": 1771752549.1750958, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3516, "output_tokens": 231, "total_tokens": 3747}
-{"timestamp": 1771752550.700018, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 223, "output_tokens": 135, "total_tokens": 358}
-{"timestamp": 1771752553.2720919, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3971, "output_tokens": 237, "total_tokens": 4208}
-{"timestamp": 1771752557.2852218, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3970, "output_tokens": 379, "total_tokens": 4349}
-{"timestamp": 1771752559.0240703, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 244, "output_tokens": 158, "total_tokens": 402}
-{"timestamp": 1771752562.318614, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 4595, "output_tokens": 370, "total_tokens": 4965}
-{"timestamp": 1771752563.886194, "source": "TEACHER_SUMMARY", "input_tokens": 986, "output_tokens": 168, "total_tokens": 1154}
-{"timestamp": 1771753224.1651053, "source": "DATA_ANCHOR", "input_tokens": 932, "output_tokens": 177, "total_tokens": 1109}
-{"timestamp": 1771753235.7315483, "source": "STRATEGY_CARD", "input_tokens": 858, "output_tokens": 859, "total_tokens": 1717}
-{"timestamp": 1771753238.2942786, "source": "VISUAL_CONTEXT", "input_tokens": 2155, "output_tokens": 142, "total_tokens": 2297}
-{"timestamp": 1771753242.7947776, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2322, "output_tokens": 435, "total_tokens": 2757}
-{"timestamp": 1771753244.0055053, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 237, "output_tokens": 119, "total_tokens": 356}
-{"timestamp": 1771753246.6830037, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2809, "output_tokens": 302, "total_tokens": 3111}
-{"timestamp": 1771753249.5743272, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2733, "output_tokens": 244, "total_tokens": 2977}
-{"timestamp": 1771753250.8779986, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 216, "output_tokens": 100, "total_tokens": 316}
-{"timestamp": 1771753255.4517028, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3061, "output_tokens": 601, "total_tokens": 3662}
-{"timestamp": 1771753262.694314, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3179, "output_tokens": 985, "total_tokens": 4164}
-{"timestamp": 1771753267.5338817, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 365, "output_tokens": 448, "total_tokens": 813}
-{"timestamp": 1771753274.5147538, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 4139, "output_tokens": 949, "total_tokens": 5088}
-{"timestamp": 1771753280.8924353, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 4132, "output_tokens": 702, "total_tokens": 4834}
-{"timestamp": 1771753282.9115841, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 343, "output_tokens": 162, "total_tokens": 505}
-{"timestamp": 1771753288.0923667, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5032, "output_tokens": 696, "total_tokens": 5728}
-{"timestamp": 1771753291.854688, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 4891, "output_tokens": 368, "total_tokens": 5259}
-{"timestamp": 1771753293.445371, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 251, "output_tokens": 134, "total_tokens": 385}
-{"timestamp": 1771753296.5017848, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5509, "output_tokens": 357, "total_tokens": 5866}
-{"timestamp": 1771753299.5257778, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5512, "output_tokens": 289, "total_tokens": 5801}
-{"timestamp": 1771753300.8275273, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 237, "output_tokens": 137, "total_tokens": 374}
-{"timestamp": 1771753307.2761223, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5984, "output_tokens": 883, "total_tokens": 6867}
-{"timestamp": 1771753309.2315829, "source": "TEACHER_SUMMARY", "input_tokens": 862, "output_tokens": 160, "total_tokens": 1022}
-{"timestamp": 1771754969.4579072, "source": "DATA_ANCHOR", "input_tokens": 598, "output_tokens": 125, "total_tokens": 723}
-{"timestamp": 1771754975.4803588, "source": "STRATEGY_CARD", "input_tokens": 491, "output_tokens": 630, "total_tokens": 1121}
-{"timestamp": 1771754977.9880898, "source": "VISUAL_CONTEXT", "input_tokens": 2854, "output_tokens": 254, "total_tokens": 3108}
-{"timestamp": 1771754987.1204975, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 3375, "output_tokens": 1114, "total_tokens": 4489}
-{"timestamp": 1771754992.8446796, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 736, "output_tokens": 584, "total_tokens": 1320}
-{"timestamp": 1771755003.051498, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 4939, "output_tokens": 1361, "total_tokens": 6300}
-{"timestamp": 1771755009.0815392, "source": "TEACHER_SUMMARY", "input_tokens": 695, "output_tokens": 196, "total_tokens": 891}
-{"timestamp": 1771755166.899693, "source": "DATA_ANCHOR", "input_tokens": 1006, "output_tokens": 221, "total_tokens": 1227}
-{"timestamp": 1771755179.4937794, "source": "STRATEGY_CARD", "input_tokens": 970, "output_tokens": 1042, "total_tokens": 2012}
-{"timestamp": 1771755182.3187122, "source": "VISUAL_CONTEXT", "input_tokens": 2229, "output_tokens": 213, "total_tokens": 2442}
-{"timestamp": 1771755185.4173741, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 2357, "output_tokens": 264, "total_tokens": 2621}
-{"timestamp": 1771755186.5311239, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 244, "output_tokens": 84, "total_tokens": 328}
-{"timestamp": 1771755189.0655563, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 2776, "output_tokens": 264, "total_tokens": 3040}
-{"timestamp": 1771755193.3143501, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 2735, "output_tokens": 440, "total_tokens": 3175}
-{"timestamp": 1771755197.0884075, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 358, "output_tokens": 352, "total_tokens": 710}
-{"timestamp": 1771755201.2623131, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 3640, "output_tokens": 522, "total_tokens": 4162}
-{"timestamp": 1771755207.551665, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 3450, "output_tokens": 720, "total_tokens": 4170}
-{"timestamp": 1771755209.1213577, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 459, "output_tokens": 129, "total_tokens": 588}
-{"timestamp": 1771755215.0799754, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 4536, "output_tokens": 837, "total_tokens": 5373}
-{"timestamp": 1771755220.170005, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 4678, "output_tokens": 710, "total_tokens": 5388}
-{"timestamp": 1771755221.3770254, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 332, "output_tokens": 103, "total_tokens": 435}
-{"timestamp": 1771755226.8653324, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 5803, "output_tokens": 868, "total_tokens": 6671}
-{"timestamp": 1771755233.2718825, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 5803, "output_tokens": 987, "total_tokens": 6790}
-{"timestamp": 1771755236.295438, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 4597, "output_tokens": 287, "total_tokens": 4884}
-{"timestamp": 1771755238.1214995, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 244, "output_tokens": 148, "total_tokens": 392}
-{"timestamp": 1771755242.107458, "source": "STRATEGY_VISION_TRIGONOMETRY", "input_tokens": 5149, "output_tokens": 429, "total_tokens": 5578}
-{"timestamp": 1771755247.3160625, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 5307, "output_tokens": 656, "total_tokens": 5963}
-{"timestamp": 1771755249.076046, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 313, "output_tokens": 133, "total_tokens": 446}
-{"timestamp": 1771755254.7641199, "source": "STRATEGY_VISION_TRIGONOMETRY", "input_tokens": 6319, "output_tokens": 838, "total_tokens": 7157}
-{"timestamp": 1771755257.122059, "source": "TEACHER_SUMMARY", "input_tokens": 846, "output_tokens": 200, "total_tokens": 1046}
-{"timestamp": 1771756279.5558336, "source": "DATA_ANCHOR", "input_tokens": 1014, "output_tokens": 211, "total_tokens": 1225}
-{"timestamp": 1771756291.689676, "source": "STRATEGY_CARD", "input_tokens": 976, "output_tokens": 887, "total_tokens": 1863}
-{"timestamp": 1771756293.8497357, "source": "VISUAL_CONTEXT", "input_tokens": 2411, "output_tokens": 128, "total_tokens": 2539}
-{"timestamp": 1771756297.3582652, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 2349, "output_tokens": 408, "total_tokens": 2757}
-{"timestamp": 1771756299.136471, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 316, "output_tokens": 113, "total_tokens": 429}
-{"timestamp": 1771756302.4182227, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 3034, "output_tokens": 382, "total_tokens": 3416}
-{"timestamp": 1771756305.3586693, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 2902, "output_tokens": 290, "total_tokens": 3192}
-{"timestamp": 1771756307.7844305, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 340, "output_tokens": 241, "total_tokens": 581}
-{"timestamp": 1771756313.0721037, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 3552, "output_tokens": 733, "total_tokens": 4285}
-{"timestamp": 1771756317.5596178, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 3552, "output_tokens": 610, "total_tokens": 4162}
-{"timestamp": 1771756322.702369, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 3651, "output_tokens": 663, "total_tokens": 4314}
-{"timestamp": 1771756325.4506834, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 466, "output_tokens": 316, "total_tokens": 782}
-{"timestamp": 1771756328.7949913, "source": "STRATEGY_VISION_TRIGONOMETRY", "input_tokens": 4948, "output_tokens": 405, "total_tokens": 5353}
-{"timestamp": 1771756333.7454417, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 4315, "output_tokens": 651, "total_tokens": 4966}
-{"timestamp": 1771756337.4370663, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 417, "output_tokens": 552, "total_tokens": 969}
-{"timestamp": 1771756345.4335597, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 5361, "output_tokens": 1216, "total_tokens": 6577}
-{"timestamp": 1771756350.4374948, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 5923, "output_tokens": 580, "total_tokens": 6503}
-{"timestamp": 1771756351.4316108, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 265, "output_tokens": 86, "total_tokens": 351}
-{"timestamp": 1771756355.2230475, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 6910, "output_tokens": 524, "total_tokens": 7434}
-{"timestamp": 1771756361.7278695, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 6815, "output_tokens": 937, "total_tokens": 7752}
-{"timestamp": 1771756363.1777136, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 390, "output_tokens": 159, "total_tokens": 549}
-{"timestamp": 1771756369.3447247, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 8220, "output_tokens": 971, "total_tokens": 9191}
-{"timestamp": 1771756371.3111422, "source": "TEACHER_SUMMARY", "input_tokens": 853, "output_tokens": 169, "total_tokens": 1022}
-{"timestamp": 1771756947.9657278, "source": "DATA_ANCHOR", "input_tokens": 892, "output_tokens": 161, "total_tokens": 1053}
-{"timestamp": 1771756959.3504677, "source": "STRATEGY_CARD", "input_tokens": 800, "output_tokens": 829, "total_tokens": 1629}
-{"timestamp": 1771756961.5711215, "source": "VISUAL_CONTEXT", "input_tokens": 2289, "output_tokens": 126, "total_tokens": 2415}
-{"timestamp": 1771756964.3119318, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 2274, "output_tokens": 149, "total_tokens": 2423}
-{"timestamp": 1771756966.0598848, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 209, "output_tokens": 158, "total_tokens": 367}
-{"timestamp": 1771756968.0310972, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 2598, "output_tokens": 149, "total_tokens": 2747}
-{"timestamp": 1771756970.4615104, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 2530, "output_tokens": 183, "total_tokens": 2713}
-{"timestamp": 1771756971.624457, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 216, "output_tokens": 100, "total_tokens": 316}
-{"timestamp": 1771756974.0495348, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 2857, "output_tokens": 175, "total_tokens": 3032}
-{"timestamp": 1771756977.998692, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 2919, "output_tokens": 505, "total_tokens": 3424}
-{"timestamp": 1771756979.4049644, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 216, "output_tokens": 94, "total_tokens": 310}
-{"timestamp": 1771756981.518639, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 3253, "output_tokens": 178, "total_tokens": 3431}
-{"timestamp": 1771756985.6552768, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 3178, "output_tokens": 471, "total_tokens": 3649}
-{"timestamp": 1771756986.9109085, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 286, "output_tokens": 86, "total_tokens": 372}
-{"timestamp": 1771756990.3975277, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 3963, "output_tokens": 471, "total_tokens": 4434}
-{"timestamp": 1771756992.910474, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 3831, "output_tokens": 245, "total_tokens": 4076}
-{"timestamp": 1771756993.91504, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 223, "output_tokens": 83, "total_tokens": 306}
-{"timestamp": 1771756996.3890793, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 4282, "output_tokens": 245, "total_tokens": 4527}
-{"timestamp": 1771757002.3995986, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 4274, "output_tokens": 746, "total_tokens": 5020}
-{"timestamp": 1771757003.361258, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 307, "output_tokens": 94, "total_tokens": 401}
-{"timestamp": 1771757008.300973, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 5451, "output_tokens": 742, "total_tokens": 6193}
-{"timestamp": 1771757012.239734, "source": "TEACHER_SUMMARY", "input_tokens": 910, "output_tokens": 185, "total_tokens": 1095}
-{"timestamp": 1771757103.7567604, "source": "DATA_ANCHOR", "input_tokens": 676, "output_tokens": 167, "total_tokens": 843}
-{"timestamp": 1771757115.4301178, "source": "STRATEGY_CARD", "input_tokens": 592, "output_tokens": 1144, "total_tokens": 1736}
-{"timestamp": 1771757119.7247527, "source": "VISUAL_CONTEXT", "input_tokens": 3622, "output_tokens": 512, "total_tokens": 4134}
-{"timestamp": 1771757125.4678662, "source": "STRATEGY_VISION_CIRCLE_EQUATION | LINE_EQUATION | GEOMETRY", "input_tokens": 3877, "output_tokens": 681, "total_tokens": 4558}
-{"timestamp": 1771757128.1720548, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 347, "output_tokens": 347, "total_tokens": 694}
-{"timestamp": 1771757136.3325803, "source": "STRATEGY_VISION_CIRCLE_EQUATION | LINE_EQUATION | GEOMETRY", "input_tokens": 5120, "output_tokens": 1054, "total_tokens": 6174}
-{"timestamp": 1771757141.9511313, "source": "STRATEGY_VISION_CIRCLE_EQUATION | LINE_EQUATION | GEOMETRY", "input_tokens": 4962, "output_tokens": 485, "total_tokens": 5447}
-{"timestamp": 1771757149.874282, "source": "STRATEGY_VISION_CIRCLE_EQUATION | LINE_EQUATION | GEOMETRY", "input_tokens": 4962, "output_tokens": 853, "total_tokens": 5815}
-{"timestamp": 1771757155.0187628, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 4937, "output_tokens": 375, "total_tokens": 5312}
-{"timestamp": 1771757156.1493435, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 227, "output_tokens": 74, "total_tokens": 301}
-{"timestamp": 1771757161.5970497, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 5282, "output_tokens": 520, "total_tokens": 5802}
-{"timestamp": 1771757164.424343, "source": "TEACHER_SUMMARY", "input_tokens": 833, "output_tokens": 213, "total_tokens": 1046}
-{"timestamp": 1771757865.0979748, "source": "DATA_ANCHOR", "input_tokens": 997, "output_tokens": 205, "total_tokens": 1202}
-{"timestamp": 1771757875.6039038, "source": "STRATEGY_CARD", "input_tokens": 951, "output_tokens": 765, "total_tokens": 1716}
-{"timestamp": 1771758093.1009266, "source": "DATA_ANCHOR", "input_tokens": 884, "output_tokens": 161, "total_tokens": 1045}
-{"timestamp": 1771758102.488648, "source": "STRATEGY_CARD", "input_tokens": 791, "output_tokens": 800, "total_tokens": 1591}
-{"timestamp": 1771758105.6661663, "source": "VISUAL_CONTEXT", "input_tokens": 2281, "output_tokens": 271, "total_tokens": 2552}
-{"timestamp": 1771758112.0578825, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2287, "output_tokens": 694, "total_tokens": 2981}
-{"timestamp": 1771758113.9055374, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 311, "output_tokens": 170, "total_tokens": 481}
-{"timestamp": 1771758119.908438, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3254, "output_tokens": 574, "total_tokens": 3828}
-{"timestamp": 1771758128.6182928, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2989, "output_tokens": 996, "total_tokens": 3985}
-{"timestamp": 1771758130.119488, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 286, "output_tokens": 129, "total_tokens": 415}
-{"timestamp": 1771758135.297605, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3874, "output_tokens": 627, "total_tokens": 4501}
-{"timestamp": 1771758139.4319062, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3740, "output_tokens": 402, "total_tokens": 4142}
-{"timestamp": 1771758140.631375, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 251, "output_tokens": 104, "total_tokens": 355}
-{"timestamp": 1771758144.3200266, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 4382, "output_tokens": 420, "total_tokens": 4802}
-{"timestamp": 1771758150.885881, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 4386, "output_tokens": 751, "total_tokens": 5137}
-{"timestamp": 1771758152.269584, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 321, "output_tokens": 156, "total_tokens": 477}
-{"timestamp": 1771758158.4989579, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5600, "output_tokens": 757, "total_tokens": 6357}
-{"timestamp": 1771758164.3083248, "source": "TEACHER_SUMMARY", "input_tokens": 922, "output_tokens": 186, "total_tokens": 1108}
-{"timestamp": 1771758515.460961, "source": "DATA_ANCHOR", "input_tokens": 702, "output_tokens": 175, "total_tokens": 877}
-{"timestamp": 1771758525.1338754, "source": "STRATEGY_CARD", "input_tokens": 625, "output_tokens": 1087, "total_tokens": 1712}
-{"timestamp": 1771758529.6346643, "source": "VISUAL_CONTEXT", "input_tokens": 3648, "output_tokens": 472, "total_tokens": 4120}
-{"timestamp": 1771758537.4674041, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 3882, "output_tokens": 829, "total_tokens": 4711}
-{"timestamp": 1771758539.019383, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 327, "output_tokens": 127, "total_tokens": 454}
-{"timestamp": 1771758551.0774696, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 4745, "output_tokens": 1539, "total_tokens": 6284}
-{"timestamp": 1771758557.3549273, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 6038, "output_tokens": 723, "total_tokens": 6761}
-{"timestamp": 1771758565.5866575, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 6038, "output_tokens": 1256, "total_tokens": 7294}
-{"timestamp": 1771758566.9191532, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 279, "output_tokens": 112, "total_tokens": 391}
-{"timestamp": 1771758577.4878988, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 6756, "output_tokens": 1285, "total_tokens": 8041}
-{"timestamp": 1771758589.1110713, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 6756, "output_tokens": 1855, "total_tokens": 8611}
-{"timestamp": 1771758595.846731, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 6014, "output_tokens": 596, "total_tokens": 6610}
-{"timestamp": 1771758597.5793052, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 299, "output_tokens": 147, "total_tokens": 446}
-{"timestamp": 1771758606.5587833, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 6934, "output_tokens": 1014, "total_tokens": 7948}
-{"timestamp": 1771758609.378746, "source": "TEACHER_SUMMARY", "input_tokens": 857, "output_tokens": 196, "total_tokens": 1053}
-{"timestamp": 1771760223.086328, "source": "DATA_ANCHOR", "input_tokens": 898, "output_tokens": 157, "total_tokens": 1055}
-{"timestamp": 1771760237.430929, "source": "STRATEGY_CARD", "input_tokens": 804, "output_tokens": 1108, "total_tokens": 1912}
-{"timestamp": 1771760239.727735, "source": "VISUAL_CONTEXT", "input_tokens": 2295, "output_tokens": 163, "total_tokens": 2458}
-{"timestamp": 1771760243.8833632, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 2270, "output_tokens": 356, "total_tokens": 2626}
-{"timestamp": 1771760246.002938, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 186, "total_tokens": 396}
-{"timestamp": 1771760250.6171076, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 3937, "output_tokens": 472, "total_tokens": 4409}
-{"timestamp": 1771760254.2955422, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 4536, "output_tokens": 404, "total_tokens": 4940}
-{"timestamp": 1771760256.3992496, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 159, "total_tokens": 369}
-{"timestamp": 1771760260.4681125, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 6432, "output_tokens": 468, "total_tokens": 6900}
-{"timestamp": 1771760268.6634147, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 6619, "output_tokens": 1145, "total_tokens": 7764}
-{"timestamp": 1771760271.6323638, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 287, "total_tokens": 497}
-{"timestamp": 1771760279.1321955, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 11759, "output_tokens": 1147, "total_tokens": 12906}
-{"timestamp": 1771760283.9845622, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 11525, "output_tokens": 584, "total_tokens": 12109}
-{"timestamp": 1771760285.893286, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 147, "total_tokens": 357}
-{"timestamp": 1771760290.2943766, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 14214, "output_tokens": 584, "total_tokens": 14798}
-{"timestamp": 1771760295.9845006, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 14213, "output_tokens": 612, "total_tokens": 14825}
-{"timestamp": 1771760298.7939487, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 248, "total_tokens": 458}
-{"timestamp": 1771760303.3573961, "source": "STRATEGY_VISION_DERIVATIVE_QUOTIENT", "input_tokens": 17073, "output_tokens": 610, "total_tokens": 17683}
-{"timestamp": 1771760308.020068, "source": "TEACHER_SUMMARY", "input_tokens": 2911, "output_tokens": 195, "total_tokens": 3106}
-{"timestamp": 1771762108.407385, "source": "DATA_ANCHOR", "input_tokens": 896, "output_tokens": 150, "total_tokens": 1046}
-{"timestamp": 1771762117.2103472, "source": "STRATEGY_CARD", "input_tokens": 801, "output_tokens": 625, "total_tokens": 1426}
-{"timestamp": 1771762120.0009716, "source": "VISUAL_CONTEXT", "input_tokens": 2294, "output_tokens": 216, "total_tokens": 2510}
-{"timestamp": 1771762125.755843, "source": "STRATEGY_VISION_DERIVATIVE_AND_FUNCTION_ANALYSIS", "input_tokens": 2284, "output_tokens": 697, "total_tokens": 2981}
-{"timestamp": 1771762130.8710115, "source": "STRATEGY_VISION_DERIVATIVE_AND_FUNCTION_ANALYSIS", "input_tokens": 2356, "output_tokens": 451, "total_tokens": 2807}
-{"timestamp": 1771762136.5215228, "source": "STRATEGY_VISION_DERIVATIVE_AND_FUNCTION_ANALYSIS", "input_tokens": 2379, "output_tokens": 703, "total_tokens": 3082}
-{"timestamp": 1771762147.7483187, "source": "STRATEGY_VISION_DERIVATIVE_AND_FUNCTION_ANALYSIS", "input_tokens": 2451, "output_tokens": 650, "total_tokens": 3101}
-{"timestamp": 1771762150.6751962, "source": "STRATEGY_VISION_DERIVATIVE_AND_FUNCTION_ANALYSIS", "input_tokens": 2298, "output_tokens": 215, "total_tokens": 2513}
-{"timestamp": 1771762154.9833813, "source": "STRATEGY_VISION_DERIVATIVE_AND_FUNCTION_ANALYSIS", "input_tokens": 2370, "output_tokens": 407, "total_tokens": 2777}
-{"timestamp": 1771762156.492939, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 141, "total_tokens": 351}
-{"timestamp": 1771762159.9379365, "source": "STRATEGY_VISION_DERIVATIVE_AND_FUNCTION_ANALYSIS", "input_tokens": 4150, "output_tokens": 341, "total_tokens": 4491}
-{"timestamp": 1771762165.254948, "source": "STRATEGY_VISION_DERIVATIVE_AND_FUNCTION_ANALYSIS", "input_tokens": 4222, "output_tokens": 608, "total_tokens": 4830}
-{"timestamp": 1771762169.0544658, "source": "STRATEGY_VISION_DERIVATIVE_AND_FUNCTION_ANALYSIS", "input_tokens": 2358, "output_tokens": 350, "total_tokens": 2708}
-{"timestamp": 1771762173.5558457, "source": "STRATEGY_VISION_DERIVATIVE_AND_FUNCTION_ANALYSIS", "input_tokens": 2430, "output_tokens": 437, "total_tokens": 2867}
-{"timestamp": 1771762175.3046172, "source": "TEACHER_SUMMARY", "input_tokens": 819, "output_tokens": 171, "total_tokens": 990}
-{"timestamp": 1771763904.938354, "source": "DATA_ANCHOR", "input_tokens": 1013, "output_tokens": 222, "total_tokens": 1235}
-{"timestamp": 1771763917.8792672, "source": "STRATEGY_CARD", "input_tokens": 980, "output_tokens": 987, "total_tokens": 1967}
-{"timestamp": 1771763920.2496233, "source": "VISUAL_CONTEXT", "input_tokens": 2410, "output_tokens": 119, "total_tokens": 2529}
-{"timestamp": 1771763924.4675975, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 2360, "output_tokens": 287, "total_tokens": 2647}
-{"timestamp": 1771763929.1726923, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 2432, "output_tokens": 478, "total_tokens": 2910}
-{"timestamp": 1771763930.345268, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 258, "output_tokens": 80, "total_tokens": 338}
-{"timestamp": 1771763933.5607326, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 3223, "output_tokens": 330, "total_tokens": 3553}
-{"timestamp": 1771763937.1707246, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 3295, "output_tokens": 327, "total_tokens": 3622}
-{"timestamp": 1771763941.3253133, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 3060, "output_tokens": 456, "total_tokens": 3516}
-{"timestamp": 1771763948.2171433, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 3132, "output_tokens": 786, "total_tokens": 3918}
-{"timestamp": 1771763949.2187645, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 274, "output_tokens": 79, "total_tokens": 353}
-{"timestamp": 1771763954.9902685, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 4177, "output_tokens": 681, "total_tokens": 4858}
-{"timestamp": 1771763960.5174477, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 4249, "output_tokens": 599, "total_tokens": 4848}
-{"timestamp": 1771763968.269019, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 3081, "output_tokens": 1017, "total_tokens": 4098}
-{"timestamp": 1771763971.0149732, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 3153, "output_tokens": 187, "total_tokens": 3340}
-{"timestamp": 1771763972.0790734, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 226, "output_tokens": 82, "total_tokens": 308}
-{"timestamp": 1771763978.9020836, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 3628, "output_tokens": 799, "total_tokens": 4427}
-{"timestamp": 1771763985.669887, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 3700, "output_tokens": 792, "total_tokens": 4492}
-{"timestamp": 1771763992.6632924, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 4534, "output_tokens": 852, "total_tokens": 5386}
-{"timestamp": 1771763999.3932662, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 4606, "output_tokens": 737, "total_tokens": 5343}
-{"timestamp": 1771764001.004174, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 319, "output_tokens": 115, "total_tokens": 434}
-{"timestamp": 1771764008.0848248, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 6291, "output_tokens": 1043, "total_tokens": 7334}
-{"timestamp": 1771764016.0337372, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 6363, "output_tokens": 1089, "total_tokens": 7452}
-{"timestamp": 1771764019.6799176, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 6932, "output_tokens": 369, "total_tokens": 7301}
-{"timestamp": 1771764024.935349, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 7004, "output_tokens": 603, "total_tokens": 7607}
-{"timestamp": 1771764025.8406162, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 250, "output_tokens": 78, "total_tokens": 328}
-{"timestamp": 1771764030.358574, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 8497, "output_tokens": 611, "total_tokens": 9108}
-{"timestamp": 1771764035.0707133, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 8569, "output_tokens": 603, "total_tokens": 9172}
-{"timestamp": 1771764041.156954, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 8495, "output_tokens": 847, "total_tokens": 9342}
-{"timestamp": 1771764047.3741043, "source": "STRATEGY_VISION_DERIVATIVE_AND_INTEGRAL", "input_tokens": 8567, "output_tokens": 676, "total_tokens": 9243}
-{"timestamp": 1771764049.6660433, "source": "TEACHER_SUMMARY", "input_tokens": 979, "output_tokens": 195, "total_tokens": 1174}
-{"timestamp": 1771764969.5030885, "source": "DATA_ANCHOR", "input_tokens": 936, "output_tokens": 173, "total_tokens": 1109}
-{"timestamp": 1771764980.6263196, "source": "STRATEGY_CARD", "input_tokens": 860, "output_tokens": 837, "total_tokens": 1697}
-{"timestamp": 1771764983.123988, "source": "VISUAL_CONTEXT", "input_tokens": 2333, "output_tokens": 191, "total_tokens": 2524}
-{"timestamp": 1771764987.4965975, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2296, "output_tokens": 376, "total_tokens": 2672}
-{"timestamp": 1771764990.872144, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2368, "output_tokens": 240, "total_tokens": 2608}
-{"timestamp": 1771764992.6093903, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 120, "total_tokens": 330}
-{"timestamp": 1771764995.572304, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3472, "output_tokens": 189, "total_tokens": 3661}
-{"timestamp": 1771764998.39374, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3544, "output_tokens": 240, "total_tokens": 3784}
-{"timestamp": 1771765003.3472652, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3421, "output_tokens": 397, "total_tokens": 3818}
-{"timestamp": 1771765008.0104487, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3493, "output_tokens": 549, "total_tokens": 4042}
-{"timestamp": 1771765009.9725955, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 187, "total_tokens": 397}
-{"timestamp": 1771765014.265887, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5865, "output_tokens": 380, "total_tokens": 6245}
-{"timestamp": 1771765019.3828986, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5937, "output_tokens": 560, "total_tokens": 6497}
-{"timestamp": 1771765022.2537165, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5928, "output_tokens": 217, "total_tokens": 6145}
-{"timestamp": 1771765027.1510954, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 6000, "output_tokens": 587, "total_tokens": 6587}
-{"timestamp": 1771765028.454646, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 234, "output_tokens": 154, "total_tokens": 388}
-{"timestamp": 1771765032.5483148, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 7110, "output_tokens": 452, "total_tokens": 7562}
-{"timestamp": 1771765037.553699, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 7182, "output_tokens": 556, "total_tokens": 7738}
-{"timestamp": 1771765042.8121603, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 7339, "output_tokens": 544, "total_tokens": 7883}
-{"timestamp": 1771765047.4370954, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 7411, "output_tokens": 499, "total_tokens": 7910}
-{"timestamp": 1771765048.6790175, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 242, "output_tokens": 91, "total_tokens": 333}
-{"timestamp": 1771765052.796187, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 8647, "output_tokens": 400, "total_tokens": 9047}
-{"timestamp": 1771765057.1936626, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 8719, "output_tokens": 499, "total_tokens": 9218}
-{"timestamp": 1771765062.7878842, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 8639, "output_tokens": 627, "total_tokens": 9266}
-{"timestamp": 1771765066.550712, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 8711, "output_tokens": 359, "total_tokens": 9070}
-{"timestamp": 1771765072.1371422, "source": "TEACHER_SUMMARY", "input_tokens": 1786, "output_tokens": 164, "total_tokens": 1950}
-{"timestamp": 1771765228.0701976, "source": "DATA_ANCHOR", "input_tokens": 703, "output_tokens": 173, "total_tokens": 876}
-{"timestamp": 1771765238.719619, "source": "STRATEGY_CARD", "input_tokens": 624, "output_tokens": 1250, "total_tokens": 1874}
-{"timestamp": 1771765242.968104, "source": "VISUAL_CONTEXT", "input_tokens": 3649, "output_tokens": 421, "total_tokens": 4070}
-{"timestamp": 1771765253.1269312, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 3882, "output_tokens": 915, "total_tokens": 4797}
-{"timestamp": 1771765264.484011, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 3954, "output_tokens": 1132, "total_tokens": 5086}
-{"timestamp": 1771765274.504207, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 3900, "output_tokens": 1183, "total_tokens": 5083}
-{"timestamp": 1771765285.5168936, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 3972, "output_tokens": 1347, "total_tokens": 5319}
-{"timestamp": 1771765290.0180404, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 3875, "output_tokens": 403, "total_tokens": 4278}
-{"timestamp": 1771765294.756716, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 3947, "output_tokens": 439, "total_tokens": 4386}
-{"timestamp": 1771765299.2488036, "source": "TEACHER_SUMMARY", "input_tokens": 790, "output_tokens": 205, "total_tokens": 995}
-{"timestamp": 1771766463.7529967, "source": "DATA_ANCHOR", "input_tokens": 936, "output_tokens": 177, "total_tokens": 1113}
-{"timestamp": 1771766475.2236567, "source": "STRATEGY_CARD", "input_tokens": 862, "output_tokens": 800, "total_tokens": 1662}
-{"timestamp": 1771766477.8018935, "source": "VISUAL_CONTEXT", "input_tokens": 2333, "output_tokens": 204, "total_tokens": 2537}
-{"timestamp": 1771766479.449379, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 1680, "output_tokens": 28, "total_tokens": 1708}
-{"timestamp": 1771766480.672064, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 94, "total_tokens": 304}
-{"timestamp": 1771766483.5451124, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 2045, "output_tokens": 175, "total_tokens": 2220}
-{"timestamp": 1771766485.1267958, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 126, "total_tokens": 336}
-{"timestamp": 1771766495.6999793, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 2806, "output_tokens": 1414, "total_tokens": 4220}
-{"timestamp": 1771766505.4756296, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 5769, "output_tokens": 1232, "total_tokens": 7001}
-{"timestamp": 1771766508.300222, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 521, "output_tokens": 346, "total_tokens": 867}
-{"timestamp": 1771766521.0818975, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 8973, "output_tokens": 1987, "total_tokens": 10960}
-{"timestamp": 1771766524.3318899, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 10761, "output_tokens": 270, "total_tokens": 11031}
-{"timestamp": 1771766525.7425437, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 226, "output_tokens": 103, "total_tokens": 329}
-{"timestamp": 1771766529.0834877, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 11493, "output_tokens": 272, "total_tokens": 11765}
-{"timestamp": 1771766535.824407, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 11526, "output_tokens": 761, "total_tokens": 12287}
-{"timestamp": 1771766537.0081613, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 301, "output_tokens": 83, "total_tokens": 384}
-{"timestamp": 1771766542.877855, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 13266, "output_tokens": 761, "total_tokens": 14027}
-{"timestamp": 1771766545.7565968, "source": "TEACHER_SUMMARY", "input_tokens": 936, "output_tokens": 140, "total_tokens": 1076}
-{"timestamp": 1771766796.598096, "source": "DATA_ANCHOR", "input_tokens": 816, "output_tokens": 200, "total_tokens": 1016}
-{"timestamp": 1771766806.680704, "source": "STRATEGY_CARD", "input_tokens": 766, "output_tokens": 901, "total_tokens": 1667}
-{"timestamp": 1771766809.2721658, "source": "VISUAL_CONTEXT", "input_tokens": 2730, "output_tokens": 217, "total_tokens": 2947}
-{"timestamp": 1771766810.9089148, "source": "STRATEGY_VISION_DERIVATIVE_ANALYSIS", "input_tokens": 2249, "output_tokens": 83, "total_tokens": 2332}
-{"timestamp": 1771766812.664156, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 162, "total_tokens": 372}
-{"timestamp": 1771766819.534371, "source": "STRATEGY_VISION_DERIVATIVE_ANALYSIS", "input_tokens": 2791, "output_tokens": 906, "total_tokens": 3697}
-{"timestamp": 1771766827.3307207, "source": "STRATEGY_VISION_DERIVATIVE_ANALYSIS", "input_tokens": 4341, "output_tokens": 1383, "total_tokens": 5724}
-{"timestamp": 1771766830.018588, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 519, "output_tokens": 356, "total_tokens": 875}
-{"timestamp": 1771766847.6036227, "source": "STRATEGY_VISION_DERIVATIVE_ANALYSIS", "input_tokens": 7893, "output_tokens": 3431, "total_tokens": 11324}
-{"timestamp": 1771766854.8621233, "source": "STRATEGY_VISION_DERIVATIVE_ANALYSIS", "input_tokens": 13216, "output_tokens": 1171, "total_tokens": 14387}
-{"timestamp": 1771766858.5195546, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 746, "output_tokens": 481, "total_tokens": 1227}
-{"timestamp": 1771766866.1743681, "source": "STRATEGY_VISION_DERIVATIVE_ANALYSIS", "input_tokens": 16354, "output_tokens": 1398, "total_tokens": 17752}
-{"timestamp": 1771766871.8785133, "source": "STRATEGY_VISION_DERIVATIVE_ANALYSIS", "input_tokens": 16749, "output_tokens": 780, "total_tokens": 17529}
-{"timestamp": 1771766872.804432, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 250, "output_tokens": 92, "total_tokens": 342}
-{"timestamp": 1771766877.7209897, "source": "STRATEGY_VISION_DERIVATIVE_ANALYSIS", "input_tokens": 18772, "output_tokens": 780, "total_tokens": 19552}
-{"timestamp": 1771766880.0657165, "source": "TEACHER_SUMMARY", "input_tokens": 919, "output_tokens": 165, "total_tokens": 1084}
-{"timestamp": 1771769111.9121296, "source": "DATA_ANCHOR", "input_tokens": 904, "output_tokens": 155, "total_tokens": 1059}
-{"timestamp": 1771769120.6572309, "source": "STRATEGY_CARD", "input_tokens": 807, "output_tokens": 486, "total_tokens": 1293}
-{"timestamp": 1771769123.4801095, "source": "VISUAL_CONTEXT", "input_tokens": 2301, "output_tokens": 188, "total_tokens": 2489}
-{"timestamp": 1771769132.314841, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 1868, "output_tokens": 1178, "total_tokens": 3046}
-{"timestamp": 1771769134.2971177, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 177, "total_tokens": 387}
-{"timestamp": 1771769143.995135, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 6947, "output_tokens": 1106, "total_tokens": 8053}
-{"timestamp": 1771769150.7309587, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 4516, "output_tokens": 1006, "total_tokens": 5522}
-{"timestamp": 1771769152.8677194, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 492, "output_tokens": 202, "total_tokens": 694}
-{"timestamp": 1771769161.8831103, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 7080, "output_tokens": 1393, "total_tokens": 8473}
-{"timestamp": 1771769166.0535426, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 7803, "output_tokens": 508, "total_tokens": 8311}
-{"timestamp": 1771769168.038515, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 186, "total_tokens": 396}
-{"timestamp": 1771769173.1006482, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 10152, "output_tokens": 676, "total_tokens": 10828}
-{"timestamp": 1771769179.7345366, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 9581, "output_tokens": 856, "total_tokens": 10437}
-{"timestamp": 1771769180.8325274, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 283, "output_tokens": 66, "total_tokens": 349}
-{"timestamp": 1771769188.326153, "source": "STRATEGY_VISION_DIFFERENTIAL_CALCULUS", "input_tokens": 11474, "output_tokens": 1182, "total_tokens": 12656}
-{"timestamp": 1771769195.4514706, "source": "TEACHER_SUMMARY", "input_tokens": 858, "output_tokens": 189, "total_tokens": 1047}
-{"timestamp": 1771769408.3984454, "source": "DATA_ANCHOR", "input_tokens": 733, "output_tokens": 175, "total_tokens": 908}
-{"timestamp": 1771769419.71499, "source": "STRATEGY_CARD", "input_tokens": 656, "output_tokens": 1022, "total_tokens": 1678}
-{"timestamp": 1771769423.3156497, "source": "VISUAL_CONTEXT", "input_tokens": 3679, "output_tokens": 380, "total_tokens": 4059}
-{"timestamp": 1771769429.2172167, "source": "STRATEGY_VISION_CIRCLE_EQUATION | GEOMETRY", "input_tokens": 3355, "output_tokens": 735, "total_tokens": 4090}
-{"timestamp": 1771769433.0242825, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 526, "output_tokens": 381, "total_tokens": 907}
-{"timestamp": 1771769443.9483159, "source": "STRATEGY_VISION_CIRCLE_EQUATION | GEOMETRY", "input_tokens": 5949, "output_tokens": 1198, "total_tokens": 7147}
-{"timestamp": 1771769452.60608, "source": "STRATEGY_VISION_CIRCLE_EQUATION | GEOMETRY", "input_tokens": 7307, "output_tokens": 897, "total_tokens": 8204}
-{"timestamp": 1771769453.9486248, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 465, "output_tokens": 105, "total_tokens": 570}
-{"timestamp": 1771769469.2650964, "source": "STRATEGY_VISION_CIRCLE_EQUATION | GEOMETRY", "input_tokens": 9931, "output_tokens": 1789, "total_tokens": 11720}
-{"timestamp": 1771769473.8974853, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 11730, "output_tokens": 468, "total_tokens": 12198}
-{"timestamp": 1771769475.6217563, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 410, "output_tokens": 151, "total_tokens": 561}
-{"timestamp": 1771769483.6350882, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 13298, "output_tokens": 1039, "total_tokens": 14337}
-{"timestamp": 1771769486.558857, "source": "TEACHER_SUMMARY", "input_tokens": 853, "output_tokens": 170, "total_tokens": 1023}
-{"timestamp": 1771772025.3498764, "source": "DATA_ANCHOR", "input_tokens": 919, "output_tokens": 165, "total_tokens": 1084}
-{"timestamp": 1771772035.2777429, "source": "STRATEGY_CARD", "input_tokens": 833, "output_tokens": 825, "total_tokens": 1658}
-{"timestamp": 1771772037.77487, "source": "VISUAL_CONTEXT", "input_tokens": 2316, "output_tokens": 204, "total_tokens": 2520}
-{"timestamp": 1771772039.6767745, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 1781, "output_tokens": 48, "total_tokens": 1829}
-{"timestamp": 1771772041.678186, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 217, "total_tokens": 427}
-{"timestamp": 1771772043.5156102, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 2175, "output_tokens": 105, "total_tokens": 2280}
-{"timestamp": 1771772045.6934733, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 2089, "output_tokens": 95, "total_tokens": 2184}
-{"timestamp": 1771772049.8794262, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 589, "total_tokens": 799}
-{"timestamp": 1771772052.2767632, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 2586, "output_tokens": 174, "total_tokens": 2760}
-{"timestamp": 1771772053.749261, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 218, "output_tokens": 142, "total_tokens": 360}
-{"timestamp": 1771772056.7262108, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 3161, "output_tokens": 261, "total_tokens": 3422}
-{"timestamp": 1771772059.059709, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 3238, "output_tokens": 203, "total_tokens": 3441}
-{"timestamp": 1771772060.7517078, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 155, "total_tokens": 365}
-{"timestamp": 1771772062.6077657, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 3755, "output_tokens": 98, "total_tokens": 3853}
-{"timestamp": 1771772069.1811194, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 3840, "output_tokens": 840, "total_tokens": 4680}
-{"timestamp": 1771772070.4935157, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 337, "output_tokens": 119, "total_tokens": 456}
-{"timestamp": 1771772076.5495656, "source": "STRATEGY_VISION_CALCULUS", "input_tokens": 5859, "output_tokens": 850, "total_tokens": 6709}
-{"timestamp": 1771772084.6147854, "source": "TEACHER_SUMMARY", "input_tokens": 913, "output_tokens": 168, "total_tokens": 1081}
-{"timestamp": 1771772274.559644, "source": "DATA_ANCHOR", "input_tokens": 706, "output_tokens": 172, "total_tokens": 878}
-{"timestamp": 1771772286.833428, "source": "STRATEGY_CARD", "input_tokens": 625, "output_tokens": 1396, "total_tokens": 2021}
-{"timestamp": 1771772290.9360166, "source": "VISUAL_CONTEXT", "input_tokens": 3652, "output_tokens": 423, "total_tokens": 4075}
-{"timestamp": 1771772296.864961, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 3351, "output_tokens": 671, "total_tokens": 4022}
-{"timestamp": 1771772298.2179804, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 242, "output_tokens": 104, "total_tokens": 346}
-{"timestamp": 1771772309.3853557, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 3833, "output_tokens": 1565, "total_tokens": 5398}
-{"timestamp": 1771772318.3546584, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 4526, "output_tokens": 1136, "total_tokens": 5662}
-{"timestamp": 1771772319.355441, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 400, "output_tokens": 66, "total_tokens": 466}
-{"timestamp": 1771772327.7147737, "source": "STRATEGY_VISION_CIRCLE_EQUATION", "input_tokens": 6944, "output_tokens": 1092, "total_tokens": 8036}
-{"timestamp": 1771772331.0537465, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 6551, "output_tokens": 243, "total_tokens": 6794}
-{"timestamp": 1771772332.2257416, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 250, "output_tokens": 108, "total_tokens": 358}
-{"timestamp": 1771772335.5081153, "source": "STRATEGY_VISION_GEOMETRY", "input_tokens": 7292, "output_tokens": 243, "total_tokens": 7535}
-{"timestamp": 1771772338.4471092, "source": "TEACHER_SUMMARY", "input_tokens": 852, "output_tokens": 152, "total_tokens": 1004}
-{"timestamp": 1771772472.2931895, "source": "DATA_ANCHOR", "input_tokens": 809, "output_tokens": 201, "total_tokens": 1010}
-{"timestamp": 1771772484.8172693, "source": "STRATEGY_CARD", "input_tokens": 755, "output_tokens": 1069, "total_tokens": 1824}
-{"timestamp": 1771772488.216361, "source": "VISUAL_CONTEXT", "input_tokens": 2722, "output_tokens": 316, "total_tokens": 3038}
-{"timestamp": 1771772491.54286, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 2334, "output_tokens": 260, "total_tokens": 2594}
-{"timestamp": 1771772492.7456968, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 234, "output_tokens": 116, "total_tokens": 350}
-{"timestamp": 1771772495.7806952, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3219, "output_tokens": 279, "total_tokens": 3498}
-{"timestamp": 1771772504.216008, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 3170, "output_tokens": 953, "total_tokens": 4123}
-{"timestamp": 1771772505.4770718, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 328, "output_tokens": 96, "total_tokens": 424}
-{"timestamp": 1771772513.7175267, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 5103, "output_tokens": 1151, "total_tokens": 6254}
-{"timestamp": 1771772520.0478497, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 4782, "output_tokens": 905, "total_tokens": 5687}
-{"timestamp": 1771772521.4115133, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 659, "output_tokens": 151, "total_tokens": 810}
-{"timestamp": 1771772529.6104827, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 7341, "output_tokens": 1213, "total_tokens": 8554}
-{"timestamp": 1771772531.138122, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 7908, "output_tokens": 29, "total_tokens": 7937}
-{"timestamp": 1771772533.064069, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 163, "total_tokens": 373}
-{"timestamp": 1771772534.5356438, "source": "STRATEGY_VISION_DERIVATIVE_APPLICATION", "input_tokens": 8181, "output_tokens": 57, "total_tokens": 8238}
-{"timestamp": 1771772536.753366, "source": "TEACHER_SUMMARY", "input_tokens": 915, "output_tokens": 177, "total_tokens": 1092}
-{"timestamp": 1771772631.2498233, "source": "FAST_SOLVE", "input_tokens": 1539, "output_tokens": 598, "total_tokens": 2137}
-{"timestamp": 1771773369.7520072, "source": "DATA_ANCHOR", "input_tokens": 1115, "output_tokens": 169, "total_tokens": 1284}
-{"timestamp": 1771773382.3432374, "source": "STRATEGY_CARD", "input_tokens": 1026, "output_tokens": 1042, "total_tokens": 2068}
-{"timestamp": 1771773385.4936156, "source": "VISUAL_CONTEXT", "input_tokens": 2512, "output_tokens": 206, "total_tokens": 2718}
-{"timestamp": 1771773387.8291998, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 1781, "output_tokens": 98, "total_tokens": 1879}
-{"timestamp": 1771773389.3005416, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 218, "output_tokens": 120, "total_tokens": 338}
-{"timestamp": 1771773391.7892144, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 2169, "output_tokens": 170, "total_tokens": 2339}
-{"timestamp": 1771773393.8564527, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 2558, "output_tokens": 117, "total_tokens": 2675}
-{"timestamp": 1771773395.5193398, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 218, "output_tokens": 167, "total_tokens": 385}
-{"timestamp": 1771773397.287576, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 2952, "output_tokens": 108, "total_tokens": 3060}
-{"timestamp": 1771773399.1752074, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 3039, "output_tokens": 103, "total_tokens": 3142}
-{"timestamp": 1771773400.369891, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 89, "total_tokens": 299}
-{"timestamp": 1771773402.3107047, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 3371, "output_tokens": 98, "total_tokens": 3469}
-{"timestamp": 1771773404.4679782, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 210, "output_tokens": 196, "total_tokens": 406}
-{"timestamp": 1771773406.1971498, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 3852, "output_tokens": 105, "total_tokens": 3957}
-{"timestamp": 1771773408.5156567, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 3659, "output_tokens": 176, "total_tokens": 3835}
-{"timestamp": 1771773409.850975, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 226, "output_tokens": 101, "total_tokens": 327}
-{"timestamp": 1771773412.2161717, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 4164, "output_tokens": 214, "total_tokens": 4378}
-{"timestamp": 1771773415.199778, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 4191, "output_tokens": 299, "total_tokens": 4490}
-{"timestamp": 1771773416.3147361, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 234, "output_tokens": 120, "total_tokens": 354}
-{"timestamp": 1771773421.1167502, "source": "STRATEGY_VISION_FUNCTION_ANALYSIS", "input_tokens": 5071, "output_tokens": 706, "total_tokens": 5777}
-{"timestamp": 1771773424.3500845, "source": "TEACHER_SUMMARY", "input_tokens": 1047, "output_tokens": 142, "total_tokens": 1189}
-{"timestamp": 1771775176.7658083, "source": "DATA_ANCHOR", "input_tokens": 1178, "output_tokens": 151, "total_tokens": 1329}
-{"timestamp": 1771775189.1163435, "source": "STRATEGY_CARD", "input_tokens": 1017, "output_tokens": 799, "total_tokens": 1816}
-{"timestamp": 1771775191.855918, "source": "VISUAL_CONTEXT", "input_tokens": 2510, "output_tokens": 205, "total_tokens": 2715}
-{"timestamp": 1771775196.2353196, "source": "STRATEGY_PAGINATED_DERIVATIVE_ANALYSIS", "input_tokens": 1678, "output_tokens": 393, "total_tokens": 2071}
-{"timestamp": 1771775197.5179703, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 310, "output_tokens": 145, "total_tokens": 455}
-{"timestamp": 1771775201.7852993, "source": "STRATEGY_PAGINATED_DERIVATIVE_ANALYSIS", "input_tokens": 2784, "output_tokens": 480, "total_tokens": 3264}
-{"timestamp": 1771775210.2594094, "source": "STRATEGY_PAGINATED_DERIVATIVE_ANALYSIS", "input_tokens": 2990, "output_tokens": 1231, "total_tokens": 4221}
-{"timestamp": 1771775211.268163, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 789, "output_tokens": 82, "total_tokens": 871}
-{"timestamp": 1771775220.3849256, "source": "STRATEGY_PAGINATED_DERIVATIVE_ANALYSIS", "input_tokens": 6319, "output_tokens": 1205, "total_tokens": 7524}
-{"timestamp": 1771775222.254825, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 468, "output_tokens": 167, "total_tokens": 635}
-{"timestamp": 1771775231.5851533, "source": "STRATEGY_PAGINATED_DERIVATIVE_ANALYSIS", "input_tokens": 9251, "output_tokens": 1580, "total_tokens": 10831}
-{"timestamp": 1771775235.216285, "source": "STRATEGY_PAGINATED_DERIVATIVE_ANALYSIS", "input_tokens": 9680, "output_tokens": 428, "total_tokens": 10108}
-{"timestamp": 1771775236.3837957, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 274, "output_tokens": 111, "total_tokens": 385}
-{"timestamp": 1771775240.0021286, "source": "STRATEGY_PAGINATED_DERIVATIVE_ANALYSIS", "input_tokens": 10771, "output_tokens": 423, "total_tokens": 11194}
-{"timestamp": 1771775246.977545, "source": "STRATEGY_PAGINATED_DERIVATIVE_ANALYSIS", "input_tokens": 10820, "output_tokens": 929, "total_tokens": 11749}
-{"timestamp": 1771775248.4446805, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 337, "output_tokens": 124, "total_tokens": 461}
-{"timestamp": 1771775256.261066, "source": "STRATEGY_PAGINATED_DERIVATIVE_ANALYSIS", "input_tokens": 12975, "output_tokens": 1142, "total_tokens": 14117}
-{"timestamp": 1771775260.2326598, "source": "TEACHER_SUMMARY", "input_tokens": 865, "output_tokens": 205, "total_tokens": 1070}
-{"timestamp": 1771782703.3971007, "source": "DATA_ANCHOR", "input_tokens": 1215, "output_tokens": 163, "total_tokens": 1378}
-{"timestamp": 1771782713.0985217, "source": "STRATEGY_CARD", "input_tokens": 1071, "output_tokens": 658, "total_tokens": 1729}
-{"timestamp": 1771782716.1179974, "source": "VISUAL_CONTEXT", "input_tokens": 2547, "output_tokens": 224, "total_tokens": 2771}
-{"timestamp": 1771782721.2319188, "source": "STRATEGY_PAGINATED_DERIVATIVE_QUOTIENT", "input_tokens": 1197, "output_tokens": 584, "total_tokens": 1781}
-{"timestamp": 1771782723.8033996, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 383, "output_tokens": 350, "total_tokens": 733}
-{"timestamp": 1771782730.713544, "source": "STRATEGY_PAGINATED_DERIVATIVE_QUOTIENT", "input_tokens": 2974, "output_tokens": 908, "total_tokens": 3882}
-{"timestamp": 1771782738.7229335, "source": "STRATEGY_PAGINATED_DERIVATIVE_QUOTIENT", "input_tokens": 3563, "output_tokens": 1134, "total_tokens": 4697}
-{"timestamp": 1771782741.2308552, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 667, "output_tokens": 342, "total_tokens": 1009}
-{"timestamp": 1771782748.7883735, "source": "STRATEGY_PAGINATED_DERIVATIVE_QUOTIENT", "input_tokens": 6777, "output_tokens": 1118, "total_tokens": 7895}
-{"timestamp": 1771782758.1292958, "source": "STRATEGY_PAGINATED_DERIVATIVE_QUOTIENT", "input_tokens": 6364, "output_tokens": 1311, "total_tokens": 7675}
-{"timestamp": 1771782759.194378, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 436, "output_tokens": 95, "total_tokens": 531}
-{"timestamp": 1771782769.612257, "source": "STRATEGY_PAGINATED_DERIVATIVE_QUOTIENT", "input_tokens": 9331, "output_tokens": 1575, "total_tokens": 10906}
-{"timestamp": 1771782775.4733584, "source": "STRATEGY_PAGINATED_DERIVATIVE_QUOTIENT", "input_tokens": 9992, "output_tokens": 750, "total_tokens": 10742}
-{"timestamp": 1771782776.3923123, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 385, "output_tokens": 95, "total_tokens": 480}
-{"timestamp": 1771782783.332021, "source": "STRATEGY_PAGINATED_DERIVATIVE_QUOTIENT", "input_tokens": 11857, "output_tokens": 1042, "total_tokens": 12899}
-{"timestamp": 1771782789.5325947, "source": "STRATEGY_PAGINATED_DERIVATIVE_QUOTIENT", "input_tokens": 12412, "output_tokens": 811, "total_tokens": 13223}
-{"timestamp": 1771782790.6701834, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 283, "output_tokens": 83, "total_tokens": 366}
-{"timestamp": 1771782796.068941, "source": "STRATEGY_PAGINATED_DERIVATIVE_QUOTIENT", "input_tokens": 14257, "output_tokens": 708, "total_tokens": 14965}
-{"timestamp": 1771782799.3183181, "source": "TEACHER_SUMMARY", "input_tokens": 835, "output_tokens": 181, "total_tokens": 1016}
-{"timestamp": 1771783240.382658, "source": "DATA_ANCHOR", "input_tokens": 796, "output_tokens": 173, "total_tokens": 969}
-{"timestamp": 1771783248.6903481, "source": "STRATEGY_CARD", "input_tokens": 652, "output_tokens": 880, "total_tokens": 1532}
-{"timestamp": 1771783252.378198, "source": "VISUAL_CONTEXT", "input_tokens": 3677, "output_tokens": 407, "total_tokens": 4084}
-{"timestamp": 1771783265.7944698, "source": "STRATEGY_PAGINATED_CIRCLE_EQUATION", "input_tokens": 1481, "output_tokens": 1455, "total_tokens": 2936}
-{"timestamp": 1771783271.599723, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 832, "output_tokens": 959, "total_tokens": 1791}
-{"timestamp": 1771783284.3660376, "source": "STRATEGY_PAGINATED_CIRCLE_EQUATION", "input_tokens": 5316, "output_tokens": 1775, "total_tokens": 7091}
-{"timestamp": 1771783296.0002232, "source": "STRATEGY_PAGINATED_CIRCLE_EQUATION", "input_tokens": 5820, "output_tokens": 1062, "total_tokens": 6882}
-{"timestamp": 1771783302.7983425, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 507, "output_tokens": 1040, "total_tokens": 1547}
-{"timestamp": 1771783314.5605166, "source": "STRATEGY_PAGINATED_GEOMETRY", "input_tokens": 8390, "output_tokens": 1189, "total_tokens": 9579}
-{"timestamp": 1771783318.676346, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 621, "output_tokens": 595, "total_tokens": 1216}
-{"timestamp": 1771783335.585866, "source": "STRATEGY_PAGINATED_GEOMETRY", "input_tokens": 11432, "output_tokens": 1164, "total_tokens": 12596}
-{"timestamp": 1771783342.5291414, "source": "TEACHER_SUMMARY", "input_tokens": 818, "output_tokens": 185, "total_tokens": 1003}
-{"timestamp": 1771785546.710609, "source": "DATA_ANCHOR", "input_tokens": 937, "output_tokens": 150, "total_tokens": 1087}
-{"timestamp": 1771785556.3028297, "source": "STRATEGY_CARD", "input_tokens": 777, "output_tokens": 953, "total_tokens": 1730}
-{"timestamp": 1771785558.6865067, "source": "VISUAL_CONTEXT", "input_tokens": 2269, "output_tokens": 148, "total_tokens": 2417}
-{"timestamp": 1771785562.7314546, "source": "STRATEGY_PAGINATED_FUNCTION_ANALYSIS", "input_tokens": 1166, "output_tokens": 442, "total_tokens": 1608}
-{"timestamp": 1771785563.5906909, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 317, "output_tokens": 62, "total_tokens": 379}
-{"timestamp": 1771785570.9817078, "source": "STRATEGY_PAGINATED_FUNCTION_ANALYSIS", "input_tokens": 2402, "output_tokens": 1082, "total_tokens": 3484}
-{"timestamp": 1771785574.6738217, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 406, "output_tokens": 428, "total_tokens": 834}
-{"timestamp": 1771785585.1341677, "source": "STRATEGY_PAGINATED_FUNCTION_ANALYSIS", "input_tokens": 4938, "output_tokens": 1685, "total_tokens": 6623}
-{"timestamp": 1771785589.6268096, "source": "STRATEGY_PAGINATED_FUNCTION_ANALYSIS", "input_tokens": 6205, "output_tokens": 622, "total_tokens": 6827}
-{"timestamp": 1771785590.785706, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 242, "output_tokens": 70, "total_tokens": 312}
-{"timestamp": 1771785595.2646825, "source": "STRATEGY_PAGINATED_FUNCTION_ANALYSIS", "input_tokens": 7687, "output_tokens": 622, "total_tokens": 8309}
-{"timestamp": 1771785602.4021063, "source": "STRATEGY_PAGINATED_FUNCTION_ANALYSIS", "input_tokens": 7670, "output_tokens": 891, "total_tokens": 8561}
-{"timestamp": 1771785603.559316, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 292, "output_tokens": 93, "total_tokens": 385}
-{"timestamp": 1771785611.4622698, "source": "STRATEGY_PAGINATED_FUNCTION_ANALYSIS", "input_tokens": 9945, "output_tokens": 1038, "total_tokens": 10983}
-{"timestamp": 1771785616.469572, "source": "TEACHER_SUMMARY", "input_tokens": 892, "output_tokens": 171, "total_tokens": 1063}
-{"timestamp": 1771785840.4686372, "source": "DATA_ANCHOR", "input_tokens": 579, "output_tokens": 103, "total_tokens": 682}
-{"timestamp": 1771785846.8648515, "source": "STRATEGY_CARD", "input_tokens": 391, "output_tokens": 633, "total_tokens": 1024}
-{"timestamp": 1771785849.2326427, "source": "VISUAL_CONTEXT", "input_tokens": 1912, "output_tokens": 139, "total_tokens": 2051}
-{"timestamp": 1771785855.4351752, "source": "STRATEGY_PAGINATED_FIND_EXTREMA", "input_tokens": 1113, "output_tokens": 228, "total_tokens": 1341}
-{"timestamp": 1771785858.1137145, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 226, "output_tokens": 157, "total_tokens": 383}
-{"timestamp": 1771785865.7210326, "source": "STRATEGY_PAGINATED_FIND_EXTREMA", "input_tokens": 1789, "output_tokens": 195, "total_tokens": 1984}
-{"timestamp": 1771785881.747085, "source": "TEACHER_SUMMARY", "input_tokens": 622, "output_tokens": 162, "total_tokens": 784}
-{"timestamp": 1771786743.5115259, "source": "DATA_ANCHOR", "input_tokens": 655, "output_tokens": 123, "total_tokens": 778}
-{"timestamp": 1771786749.7642694, "source": "STRATEGY_CARD", "input_tokens": 481, "output_tokens": 610, "total_tokens": 1091}
-{"timestamp": 1771786752.5871334, "source": "VISUAL_CONTEXT", "input_tokens": 4052, "output_tokens": 331, "total_tokens": 4383}
-{"timestamp": 1771786762.0874634, "source": "STRATEGY_PAGINATED_GEOMETRIC_LOCUS", "input_tokens": 4057, "output_tokens": 1631, "total_tokens": 5688}
-{"timestamp": 1771786766.9085474, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 1181, "output_tokens": 678, "total_tokens": 1859}
-{"timestamp": 1771786776.4086466, "source": "STRATEGY_PAGINATED_GEOMETRIC_LOCUS", "input_tokens": 8903, "output_tokens": 1754, "total_tokens": 10657}
-{"timestamp": 1771786779.514564, "source": "TEACHER_SUMMARY", "input_tokens": 751, "output_tokens": 184, "total_tokens": 935}
-{"timestamp": 1771787082.7766173, "source": "DATA_ANCHOR", "input_tokens": 599, "output_tokens": 118, "total_tokens": 717}
-{"timestamp": 1771787088.3088503, "source": "STRATEGY_CARD", "input_tokens": 422, "output_tokens": 460, "total_tokens": 882}
-{"timestamp": 1771787090.87946, "source": "VISUAL_CONTEXT", "input_tokens": 1931, "output_tokens": 119, "total_tokens": 2050}
-{"timestamp": 1771787096.2778347, "source": "STRATEGY_PAGINATED_GENERAL", "input_tokens": 1152, "output_tokens": 415, "total_tokens": 1567}
-{"timestamp": 1771787099.895307, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 366, "output_tokens": 455, "total_tokens": 821}
-{"timestamp": 1771787105.0846934, "source": "STRATEGY_PAGINATED_GENERAL", "input_tokens": 2336, "output_tokens": 801, "total_tokens": 3137}
-{"timestamp": 1771787109.9357474, "source": "TEACHER_SUMMARY", "input_tokens": 607, "output_tokens": 164, "total_tokens": 771}
-{"timestamp": 1771829730.2659914, "source": "DATA_ANCHOR", "input_tokens": 941, "output_tokens": 164, "total_tokens": 1105}
-{"timestamp": 1771829742.300171, "source": "STRATEGY_CARD", "input_tokens": 789, "output_tokens": 699, "total_tokens": 1488}
-{"timestamp": 1771829744.8633006, "source": "VISUAL_CONTEXT", "input_tokens": 2273, "output_tokens": 222, "total_tokens": 2495}
-{"timestamp": 1771829758.6150203, "source": "STRATEGY_PAGINATED_DIFFERENTIAL_CALCULUS", "input_tokens": 1185, "output_tokens": 1802, "total_tokens": 2987}
-{"timestamp": 1771829764.4289412, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 814, "output_tokens": 873, "total_tokens": 1687}
-{"timestamp": 1771829776.965325, "source": "STRATEGY_PAGINATED_DIFFERENTIAL_CALCULUS", "input_tokens": 5843, "output_tokens": 1802, "total_tokens": 7645}
-{"timestamp": 1771829784.6804242, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 814, "output_tokens": 1190, "total_tokens": 2004}
-{"timestamp": 1771829786.8891938, "source": "STRATEGY_PAGINATED_DIFFERENTIAL_CALCULUS", "input_tokens": 10368, "output_tokens": 142, "total_tokens": 10510}
-{"timestamp": 1771829788.50208, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 218, "output_tokens": 120, "total_tokens": 338}
-{"timestamp": 1771829791.1376035, "source": "STRATEGY_PAGINATED_DIFFERENTIAL_CALCULUS", "input_tokens": 10863, "output_tokens": 209, "total_tokens": 11072}
-{"timestamp": 1771829799.235301, "source": "STRATEGY_PAGINATED_DIFFERENTIAL_CALCULUS", "input_tokens": 10991, "output_tokens": 1049, "total_tokens": 12040}
-{"timestamp": 1771829801.4983726, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 529, "output_tokens": 262, "total_tokens": 791}
-{"timestamp": 1771829813.459243, "source": "STRATEGY_PAGINATED_DIFFERENTIAL_CALCULUS", "input_tokens": 13790, "output_tokens": 1572, "total_tokens": 15362}
-{"timestamp": 1771829819.213696, "source": "STRATEGY_PAGINATED_DIFFERENTIAL_CALCULUS", "input_tokens": 14685, "output_tokens": 649, "total_tokens": 15334}
-{"timestamp": 1771829820.292751, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 283, "output_tokens": 72, "total_tokens": 355}
-{"timestamp": 1771829825.4505472, "source": "STRATEGY_PAGINATED_DIFFERENTIAL_CALCULUS", "input_tokens": 16231, "output_tokens": 642, "total_tokens": 16873}
-{"timestamp": 1771829836.8809783, "source": "STRATEGY_PAGINATED_DIFFERENTIAL_CALCULUS", "input_tokens": 16219, "output_tokens": 1414, "total_tokens": 17633}
-{"timestamp": 1771829838.2739131, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 370, "output_tokens": 155, "total_tokens": 525}
-{"timestamp": 1771829849.8641858, "source": "STRATEGY_PAGINATED_DIFFERENTIAL_CALCULUS", "input_tokens": 19375, "output_tokens": 1579, "total_tokens": 20954}
-{"timestamp": 1771829853.5136914, "source": "TEACHER_SUMMARY", "input_tokens": 1086, "output_tokens": 194, "total_tokens": 1280}
-{"timestamp": 1771831056.8470416, "source": "DATA_ANCHOR", "input_tokens": 1005, "output_tokens": 147, "total_tokens": 1152}
-{"timestamp": 1771831070.678529, "source": "STRATEGY_CARD", "input_tokens": 841, "output_tokens": 742, "total_tokens": 1583}
-{"timestamp": 1771831073.3796036, "source": "VISUAL_CONTEXT", "input_tokens": 2337, "output_tokens": 224, "total_tokens": 2561}
-{"timestamp": 1771831077.4981508, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 2078, "output_tokens": 345, "total_tokens": 2423}
-{"timestamp": 1771831078.5911398, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 234, "output_tokens": 77, "total_tokens": 311}
-{"timestamp": 1771831086.1925237, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 2918, "output_tokens": 944, "total_tokens": 3862}
-{"timestamp": 1771831098.056742, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 4186, "output_tokens": 1663, "total_tokens": 5849}
-{"timestamp": 1771831102.3812985, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 991, "output_tokens": 438, "total_tokens": 1429}
-{"timestamp": 1771831112.3771021, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 8673, "output_tokens": 1471, "total_tokens": 10144}
-{"timestamp": 1771831121.3338358, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 8107, "output_tokens": 1214, "total_tokens": 9321}
-{"timestamp": 1771831123.0123165, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 453, "output_tokens": 148, "total_tokens": 601}
-{"timestamp": 1771831131.375692, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 11021, "output_tokens": 1204, "total_tokens": 12225}
-{"timestamp": 1771831136.7678523, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 10836, "output_tokens": 594, "total_tokens": 11430}
-{"timestamp": 1771831140.8544474, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 353, "output_tokens": 567, "total_tokens": 920}
-{"timestamp": 1771831151.6100771, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 12458, "output_tokens": 1510, "total_tokens": 13968}
-{"timestamp": 1771831159.8771405, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 14807, "output_tokens": 990, "total_tokens": 15797}
-{"timestamp": 1771831166.5794666, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 489, "output_tokens": 846, "total_tokens": 1335}
-{"timestamp": 1771831175.5314603, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 17161, "output_tokens": 1177, "total_tokens": 18338}
-{"timestamp": 1771831177.2849169, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 465, "output_tokens": 136, "total_tokens": 601}
-{"timestamp": 1771831186.8092973, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 19991, "output_tokens": 1306, "total_tokens": 21297}
-{"timestamp": 1771831197.5354977, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 20123, "output_tokens": 1424, "total_tokens": 21547}
-{"timestamp": 1771831198.7978594, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 421, "output_tokens": 83, "total_tokens": 504}
-{"timestamp": 1771831209.1698463, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 23320, "output_tokens": 1588, "total_tokens": 24908}
-{"timestamp": 1771831217.2533772, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 23676, "output_tokens": 964, "total_tokens": 24640}
-{"timestamp": 1771831220.5344853, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 470, "output_tokens": 368, "total_tokens": 838}
-{"timestamp": 1771831233.0608456, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 26122, "output_tokens": 1682, "total_tokens": 27804}
-{"timestamp": 1771831243.1930013, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 28012, "output_tokens": 1526, "total_tokens": 29538}
-{"timestamp": 1771831245.101435, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 887, "output_tokens": 155, "total_tokens": 1042}
-{"timestamp": 1771831258.2974627, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 32123, "output_tokens": 1834, "total_tokens": 33957}
-{"timestamp": 1771831288.5292685, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 32833, "output_tokens": 864, "total_tokens": 33697}
-{"timestamp": 1771831291.2012398, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 351, "output_tokens": 310, "total_tokens": 661}
-{"timestamp": 1771831303.0451806, "source": "STRATEGY_PAGINATED_CALCULUS", "input_tokens": 34926, "output_tokens": 1874, "total_tokens": 36800}
-{"timestamp": 1771831304.6674387, "source": "TEACHER_SUMMARY", "input_tokens": 871, "output_tokens": 155, "total_tokens": 1026}
-{"timestamp": 1771831474.12494, "source": "DATA_ANCHOR", "input_tokens": 817, "output_tokens": 135, "total_tokens": 952}
-{"timestamp": 1771831482.0594642, "source": "STRATEGY_CARD", "input_tokens": 672, "output_tokens": 598, "total_tokens": 1270}
-{"timestamp": 1771831486.2051678, "source": "VISUAL_CONTEXT", "input_tokens": 1892, "output_tokens": 447, "total_tokens": 2339}
-{"timestamp": 1771831491.326264, "source": "STRATEGY_PAGINATED_GEOMETRY", "input_tokens": 1753, "output_tokens": 709, "total_tokens": 2462}
-{"timestamp": 1771831494.7454562, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 459, "output_tokens": 403, "total_tokens": 862}
-{"timestamp": 1771831497.0747807, "source": "STRATEGY_PAGINATED_GEOMETRY", "input_tokens": 3936, "output_tokens": 246, "total_tokens": 4182}
-{"timestamp": 1771831503.5360184, "source": "STRATEGY_PAGINATED_GEOMETRY", "input_tokens": 2340, "output_tokens": 1046, "total_tokens": 3386}
-{"timestamp": 1771831507.5961568, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 637, "output_tokens": 683, "total_tokens": 1320}
-{"timestamp": 1771831514.3102741, "source": "STRATEGY_PAGINATED_GEOMETRY", "input_tokens": 5032, "output_tokens": 1037, "total_tokens": 6069}
-{"timestamp": 1771831520.9383383, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 637, "output_tokens": 976, "total_tokens": 1613}
-{"timestamp": 1771831525.3288913, "source": "TEACHER_SUMMARY", "input_tokens": 797, "output_tokens": 144, "total_tokens": 941}
-{"timestamp": 1771831802.245467, "source": "DATA_ANCHOR", "input_tokens": 893, "output_tokens": 175, "total_tokens": 1068}
-{"timestamp": 1771831815.8475857, "source": "STRATEGY_CARD", "input_tokens": 751, "output_tokens": 1445, "total_tokens": 2196}
-{"timestamp": 1771831821.1421397, "source": "VISUAL_CONTEXT", "input_tokens": 3774, "output_tokens": 436, "total_tokens": 4210}
-{"timestamp": 1771831831.9910955, "source": "STRATEGY_PAGINATED_CIRCLE_EQUATION | LINE_EQUATION | GEOMETRY", "input_tokens": 3605, "output_tokens": 1262, "total_tokens": 4867}
-{"timestamp": 1771831834.3427339, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 843, "output_tokens": 237, "total_tokens": 1080}
-{"timestamp": 1771831847.589659, "source": "STRATEGY_PAGINATED_CIRCLE_EQUATION | LINE_EQUATION | GEOMETRY", "input_tokens": 7554, "output_tokens": 1910, "total_tokens": 9464}
-{"timestamp": 1771831859.5053604, "source": "STRATEGY_PAGINATED_CIRCLE_EQUATION | LINE_EQUATION | GEOMETRY", "input_tokens": 8418, "output_tokens": 1711, "total_tokens": 10129}
-{"timestamp": 1771831860.895996, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 1116, "output_tokens": 98, "total_tokens": 1214}
-{"timestamp": 1771831872.771175, "source": "STRATEGY_PAGINATED_CIRCLE_EQUATION | LINE_EQUATION | GEOMETRY", "input_tokens": 13381, "output_tokens": 1711, "total_tokens": 15092}
-{"timestamp": 1771831880.1620107, "source": "STRATEGY_PAGINATED_GEOMETRY", "input_tokens": 13304, "output_tokens": 889, "total_tokens": 14193}
-{"timestamp": 1771831881.7184806, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 504, "output_tokens": 151, "total_tokens": 655}
-{"timestamp": 1771831889.2671037, "source": "STRATEGY_PAGINATED_GEOMETRY", "input_tokens": 15771, "output_tokens": 945, "total_tokens": 16716}
-{"timestamp": 1771831893.222221, "source": "TEACHER_SUMMARY", "input_tokens": 1157, "output_tokens": 176, "total_tokens": 1333}
-{"timestamp": 1771832622.031309, "source": "OCR_PASS_1", "input_tokens": 1796, "output_tokens": 420, "total_tokens": 2216}
-{"timestamp": 1771832626.2313755, "source": "OCR_PASS_2", "input_tokens": 1796, "output_tokens": 404, "total_tokens": 2200}
-{"timestamp": 1771832630.2229784, "source": "OCR_PASS_3", "input_tokens": 1822, "output_tokens": 408, "total_tokens": 2230}
-{"timestamp": 1771832631.849524, "source": "DATA_ANCHOR", "input_tokens": 977, "output_tokens": 170, "total_tokens": 1147}
-{"timestamp": 1771832647.9696412, "source": "STRATEGY_CARD", "input_tokens": 834, "output_tokens": 1047, "total_tokens": 1881}
-{"timestamp": 1771832650.7352793, "source": "VISUAL_CONTEXT", "input_tokens": 2309, "output_tokens": 207, "total_tokens": 2516}
-{"timestamp": 1771832664.1137342, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 490, "output_tokens": 113, "total_tokens": 603}
-{"timestamp": 1771832680.2073681, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 310, "output_tokens": 103, "total_tokens": 413}
-{"timestamp": 1771832692.042967, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 364, "output_tokens": 113, "total_tokens": 477}
-{"timestamp": 1771832706.8262007, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 427, "output_tokens": 81, "total_tokens": 508}
-{"timestamp": 1771832719.684464, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 355, "output_tokens": 98, "total_tokens": 453}
-{"timestamp": 1771832733.7781534, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 400, "output_tokens": 89, "total_tokens": 489}
-{"timestamp": 1771832749.6527073, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 400, "output_tokens": 98, "total_tokens": 498}
-{"timestamp": 1771832765.7446442, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 391, "output_tokens": 90, "total_tokens": 481}
-{"timestamp": 1771832776.129114, "source": "TEACHER_SUMMARY", "input_tokens": 923, "output_tokens": 186, "total_tokens": 1109}
-{"timestamp": 1771833139.994018, "source": "OCR_PASS_1", "input_tokens": 1796, "output_tokens": 411, "total_tokens": 2207}
-{"timestamp": 1771833144.4953456, "source": "OCR_PASS_2", "input_tokens": 1796, "output_tokens": 398, "total_tokens": 2194}
-{"timestamp": 1771833148.8470435, "source": "OCR_PASS_3", "input_tokens": 1822, "output_tokens": 402, "total_tokens": 2224}
-{"timestamp": 1771833150.3188667, "source": "DATA_ANCHOR", "input_tokens": 968, "output_tokens": 160, "total_tokens": 1128}
-{"timestamp": 1771833161.0535424, "source": "STRATEGY_CARD", "input_tokens": 820, "output_tokens": 763, "total_tokens": 1583}
-{"timestamp": 1771833163.6242542, "source": "VISUAL_CONTEXT", "input_tokens": 2300, "output_tokens": 174, "total_tokens": 2474}
-{"timestamp": 1771833176.0398076, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 391, "output_tokens": 94, "total_tokens": 485}
-{"timestamp": 1771833201.0367944, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 337, "output_tokens": 115, "total_tokens": 452}
-{"timestamp": 1771833222.0286322, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 364, "output_tokens": 77, "total_tokens": 441}
-{"timestamp": 1771833245.123074, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 400, "output_tokens": 107, "total_tokens": 507}
-{"timestamp": 1771833258.046751, "source": "TEACHER_SUMMARY", "input_tokens": 985, "output_tokens": 140, "total_tokens": 1125}
-{"timestamp": 1771833905.5565474, "source": "DATA_ANCHOR", "input_tokens": 984, "output_tokens": 242, "total_tokens": 1226}
-{"timestamp": 1771833917.3599029, "source": "STRATEGY_CARD", "input_tokens": 900, "output_tokens": 858, "total_tokens": 1758}
-{"timestamp": 1771833920.2794344, "source": "VISUAL_CONTEXT", "input_tokens": 2316, "output_tokens": 220, "total_tokens": 2536}
-{"timestamp": 1771833924.9766095, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 242, "output_tokens": 125, "total_tokens": 367}
-{"timestamp": 1771833941.5833247, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 391, "output_tokens": 96, "total_tokens": 487}
-{"timestamp": 1771833965.0368996, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 391, "output_tokens": 91, "total_tokens": 482}
-{"timestamp": 1771833983.9825263, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 517, "output_tokens": 128, "total_tokens": 645}
-{"timestamp": 1771833999.8743172, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 310, "output_tokens": 82, "total_tokens": 392}
-{"timestamp": 1771834013.8148208, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 382, "output_tokens": 96, "total_tokens": 478}
-{"timestamp": 1771834022.9451928, "source": "TEACHER_SUMMARY", "input_tokens": 835, "output_tokens": 143, "total_tokens": 978}
-{"timestamp": 1771834543.7948253, "source": "FAST_SOLVE", "input_tokens": 2048, "output_tokens": 1637, "total_tokens": 3685}
-{"timestamp": 1771834640.0477266, "source": "DATA_ANCHOR", "input_tokens": 797, "output_tokens": 175, "total_tokens": 972}
-{"timestamp": 1771834650.146977, "source": "STRATEGY_CARD", "input_tokens": 655, "output_tokens": 858, "total_tokens": 1513}
-{"timestamp": 1771834654.803959, "source": "VISUAL_CONTEXT", "input_tokens": 3678, "output_tokens": 473, "total_tokens": 4151}
-{"timestamp": 1771834665.7246187, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 445, "output_tokens": 128, "total_tokens": 573}
-{"timestamp": 1771834697.3788052, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 625, "output_tokens": 101, "total_tokens": 726}
-{"timestamp": 1771834727.92057, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 544, "output_tokens": 78, "total_tokens": 622}
-{"timestamp": 1771834742.0433106, "source": "TEACHER_SUMMARY", "input_tokens": 851, "output_tokens": 174, "total_tokens": 1025}
-{"timestamp": 1771835817.5776672, "source": "OCR_PASS_1", "input_tokens": 1796, "output_tokens": 404, "total_tokens": 2200}
-{"timestamp": 1771835821.6467874, "source": "OCR_PASS_2", "input_tokens": 1796, "output_tokens": 424, "total_tokens": 2220}
-{"timestamp": 1771835825.3832119, "source": "OCR_PASS_3", "input_tokens": 1822, "output_tokens": 405, "total_tokens": 2227}
-{"timestamp": 1771835828.1592507, "source": "DATA_ANCHOR", "input_tokens": 982, "output_tokens": 408, "total_tokens": 1390}
-{"timestamp": 1771835840.1186318, "source": "STRATEGY_CARD", "input_tokens": 1069, "output_tokens": 739, "total_tokens": 1808}
-{"timestamp": 1771835842.9499931, "source": "VISUAL_CONTEXT", "input_tokens": 2315, "output_tokens": 207, "total_tokens": 2522}
-{"timestamp": 1771835847.2004018, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 310, "output_tokens": 105, "total_tokens": 415}
-{"timestamp": 1771835874.7392752, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 364, "output_tokens": 128, "total_tokens": 492}
-{"timestamp": 1771835905.3660042, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 310, "output_tokens": 88, "total_tokens": 398}
-{"timestamp": 1771835938.3669455, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 337, "output_tokens": 88, "total_tokens": 425}
-{"timestamp": 1771835952.5439503, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 391, "output_tokens": 96, "total_tokens": 487}
-{"timestamp": 1771835986.17523, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 436, "output_tokens": 86, "total_tokens": 522}
-{"timestamp": 1771836027.0383856, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 373, "output_tokens": 141, "total_tokens": 514}
-{"timestamp": 1771836103.3015301, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 328, "output_tokens": 111, "total_tokens": 439}
-{"timestamp": 1771836125.5928955, "source": "TEACHER_SUMMARY", "input_tokens": 910, "output_tokens": 190, "total_tokens": 1100}
-{"timestamp": 1771836590.1801698, "source": "DATA_ANCHOR", "input_tokens": 588, "output_tokens": 120, "total_tokens": 708}
-{"timestamp": 1771836596.652117, "source": "STRATEGY_CARD", "input_tokens": 414, "output_tokens": 554, "total_tokens": 968}
-{"timestamp": 1771836599.4884598, "source": "VISUAL_CONTEXT", "input_tokens": 1920, "output_tokens": 216, "total_tokens": 2136}
-{"timestamp": 1771836607.6289318, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 382, "output_tokens": 78, "total_tokens": 460}
-{"timestamp": 1771836658.1547742, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 373, "output_tokens": 120, "total_tokens": 493}
-{"timestamp": 1771836668.4648197, "source": "TEACHER_SUMMARY", "input_tokens": 654, "output_tokens": 180, "total_tokens": 834}
-{"timestamp": 1771837192.2806787, "source": "DATA_ANCHOR", "input_tokens": 905, "output_tokens": 159, "total_tokens": 1064}
-{"timestamp": 1771837204.0430815, "source": "STRATEGY_CARD", "input_tokens": 753, "output_tokens": 825, "total_tokens": 1578}
-{"timestamp": 1771837207.3869753, "source": "VISUAL_CONTEXT", "input_tokens": 2237, "output_tokens": 293, "total_tokens": 2530}
-{"timestamp": 1771837216.5918064, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 391, "output_tokens": 106, "total_tokens": 497}
-{"timestamp": 1771837238.263405, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 454, "output_tokens": 99, "total_tokens": 553}
-{"timestamp": 1771837257.6441822, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 373, "output_tokens": 125, "total_tokens": 498}
-{"timestamp": 1771837272.8318067, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 382, "output_tokens": 91, "total_tokens": 473}
-{"timestamp": 1771837290.1817718, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 418, "output_tokens": 108, "total_tokens": 526}
-{"timestamp": 1771837309.9504795, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 400, "output_tokens": 116, "total_tokens": 516}
-{"timestamp": 1771837325.4667237, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 301, "output_tokens": 118, "total_tokens": 419}
-{"timestamp": 1771837341.9800425, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 373, "output_tokens": 70, "total_tokens": 443}
-{"timestamp": 1771837353.8752491, "source": "TEACHER_SUMMARY", "input_tokens": 915, "output_tokens": 181, "total_tokens": 1096}
-{"timestamp": 1771838120.5161843, "source": "DATA_ANCHOR", "input_tokens": 793, "output_tokens": 173, "total_tokens": 966}
-{"timestamp": 1771838132.4805274, "source": "STRATEGY_CARD", "input_tokens": 649, "output_tokens": 1166, "total_tokens": 1815}
-{"timestamp": 1771838136.2279997, "source": "VISUAL_CONTEXT", "input_tokens": 3674, "output_tokens": 321, "total_tokens": 3995}
-{"timestamp": 1771838150.9519167, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 580, "output_tokens": 80, "total_tokens": 660}
-{"timestamp": 1771838182.307734, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 553, "output_tokens": 101, "total_tokens": 654}
-{"timestamp": 1771838208.3623815, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 346, "output_tokens": 118, "total_tokens": 464}
-{"timestamp": 1771838219.229415, "source": "TEACHER_SUMMARY", "input_tokens": 846, "output_tokens": 180, "total_tokens": 1026}
-{"timestamp": 1771838411.4624083, "source": "DATA_ANCHOR", "input_tokens": 977, "output_tokens": 250, "total_tokens": 1227}
-{"timestamp": 1771838424.1872501, "source": "STRATEGY_CARD", "input_tokens": 904, "output_tokens": 753, "total_tokens": 1657}
-{"timestamp": 1771838427.2099698, "source": "VISUAL_CONTEXT", "input_tokens": 2309, "output_tokens": 243, "total_tokens": 2552}
-{"timestamp": 1771838435.4499955, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 310, "output_tokens": 83, "total_tokens": 393}
-{"timestamp": 1771838452.7364056, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 292, "output_tokens": 71, "total_tokens": 363}
-{"timestamp": 1771838474.0237343, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 391, "output_tokens": 103, "total_tokens": 494}
-{"timestamp": 1771838492.8884447, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 427, "output_tokens": 48, "total_tokens": 475}
-{"timestamp": 1771838510.4786458, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 382, "output_tokens": 75, "total_tokens": 457}
-{"timestamp": 1771838527.1312969, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 319, "output_tokens": 75, "total_tokens": 394}
-{"timestamp": 1771838543.5672233, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 373, "output_tokens": 111, "total_tokens": 484}
-{"timestamp": 1771838561.3354876, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 373, "output_tokens": 68, "total_tokens": 441}
-{"timestamp": 1771838577.970198, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 373, "output_tokens": 114, "total_tokens": 487}
-{"timestamp": 1771838595.2748642, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 373, "output_tokens": 95, "total_tokens": 468}
-{"timestamp": 1771838608.0003452, "source": "TEACHER_SUMMARY", "input_tokens": 905, "output_tokens": 223, "total_tokens": 1128}
-{"timestamp": 1771840952.5057566, "source": "DATA_ANCHOR", "input_tokens": 619, "output_tokens": 162, "total_tokens": 781}
-{"timestamp": 1771840960.708266, "source": "STRATEGY_CARD", "input_tokens": 481, "output_tokens": 795, "total_tokens": 1276}
-{"timestamp": 1771840962.927533, "source": "VISUAL_CONTEXT", "input_tokens": 1952, "output_tokens": 126, "total_tokens": 2078}
-{"timestamp": 1771840975.094465, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 364, "output_tokens": 149, "total_tokens": 513}
-{"timestamp": 1771840994.1010883, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 364, "output_tokens": 118, "total_tokens": 482}
-{"timestamp": 1771841010.930708, "source": "STRICT_TEACHER_VERIFY", "input_tokens": 382, "output_tokens": 100, "total_tokens": 482}
-{"timestamp": 1771841022.6737623, "source": "TEACHER_SUMMARY", "input_tokens": 705, "output_tokens": 166, "total_tokens": 871}
-{"timestamp": 1771847185.2398446, "source": "DATA_ANCHOR", "input_tokens": 996, "output_tokens": 168, "total_tokens": 1164}
-{"timestamp": 1771847197.8478851, "source": "STRATEGY_CARD", "input_tokens": 848, "output_tokens": 761, "total_tokens": 1609}
-{"timestamp": 1771847201.3090434, "source": "VISUAL_CONTEXT", "input_tokens": 2328, "output_tokens": 227, "total_tokens": 2555}
-{"timestamp": 1771847228.99059, "source": "TEACHER_SUMMARY", "input_tokens": 808, "output_tokens": 172, "total_tokens": 980}
-{"timestamp": 1771848413.634389, "source": "DATA_ANCHOR", "input_tokens": 960, "output_tokens": 160, "total_tokens": 1120}
-{"timestamp": 1771848427.4524846, "source": "STRATEGY_CARD", "input_tokens": 810, "output_tokens": 1111, "total_tokens": 1921}
-{"timestamp": 1771848430.0051808, "source": "VISUAL_CONTEXT", "input_tokens": 2293, "output_tokens": 136, "total_tokens": 2429}
-{"timestamp": 1771848458.6753888, "source": "TEACHER_SUMMARY", "input_tokens": 808, "output_tokens": 186, "total_tokens": 994}
-{"timestamp": 1771848568.8008463, "source": "DATA_ANCHOR", "input_tokens": 797, "output_tokens": 174, "total_tokens": 971}
-{"timestamp": 1771848580.440106, "source": "STRATEGY_CARD", "input_tokens": 644, "output_tokens": 1109, "total_tokens": 1753}
-{"timestamp": 1771848585.2685483, "source": "VISUAL_CONTEXT", "input_tokens": 3678, "output_tokens": 477, "total_tokens": 4155}
-{"timestamp": 1771848614.9620414, "source": "TEACHER_SUMMARY", "input_tokens": 804, "output_tokens": 176, "total_tokens": 980}
-{"timestamp": 1771848769.211606, "source": "DATA_ANCHOR", "input_tokens": 886, "output_tokens": 204, "total_tokens": 1090}
-{"timestamp": 1771848780.618109, "source": "STRATEGY_CARD", "input_tokens": 768, "output_tokens": 1011, "total_tokens": 1779}
-{"timestamp": 1771848783.3835835, "source": "VISUAL_CONTEXT", "input_tokens": 2735, "output_tokens": 200, "total_tokens": 2935}
-{"timestamp": 1771848811.3575885, "source": "TEACHER_SUMMARY", "input_tokens": 824, "output_tokens": 179, "total_tokens": 1003}
-{"timestamp": 1771852885.425014, "source": "DATA_ANCHOR", "input_tokens": 788, "output_tokens": 211, "total_tokens": 999}
-{"timestamp": 1771852895.9556723, "source": "STRATEGY_CARD", "input_tokens": 670, "output_tokens": 952, "total_tokens": 1622}
-{"timestamp": 1771852900.289641, "source": "VISUAL_CONTEXT", "input_tokens": 3669, "output_tokens": 479, "total_tokens": 4148}
-{"timestamp": 1771852921.5979493, "source": "TEACHER_SUMMARY", "input_tokens": 823, "output_tokens": 164, "total_tokens": 987}
-{"timestamp": 1771853706.811592, "source": "DATA_ANCHOR", "input_tokens": 765, "output_tokens": 172, "total_tokens": 937}
-{"timestamp": 1771853719.3451135, "source": "STRATEGY_CARD", "input_tokens": 626, "output_tokens": 1212, "total_tokens": 1838}
-{"timestamp": 1771853723.6307201, "source": "VISUAL_CONTEXT", "input_tokens": 3646, "output_tokens": 418, "total_tokens": 4064}
-{"timestamp": 1771853742.356892, "source": "TEACHER_SUMMARY", "input_tokens": 800, "output_tokens": 220, "total_tokens": 1020}
-{"timestamp": 1771853995.1823103, "source": "DATA_ANCHOR", "input_tokens": 859, "output_tokens": 210, "total_tokens": 1069}
-{"timestamp": 1771854010.1627648, "source": "STRATEGY_CARD", "input_tokens": 766, "output_tokens": 1135, "total_tokens": 1901}
-{"timestamp": 1771854023.0130446, "source": "VISUAL_CONTEXT", "input_tokens": 2708, "output_tokens": 306, "total_tokens": 3014}
-{"timestamp": 1771854047.5550454, "source": "TEACHER_SUMMARY", "input_tokens": 809, "output_tokens": 193, "total_tokens": 1002}
-{"timestamp": 1771854389.2712066, "source": "DATA_ANCHOR", "input_tokens": 1049, "output_tokens": 171, "total_tokens": 1220}
-{"timestamp": 1771854405.0231817, "source": "STRATEGY_CARD", "input_tokens": 913, "output_tokens": 922, "total_tokens": 1835}
-{"timestamp": 1771854408.164057, "source": "VISUAL_CONTEXT", "input_tokens": 2382, "output_tokens": 236, "total_tokens": 2618}
-{"timestamp": 1771869889.9431577, "source": "DATA_ANCHOR", "input_tokens": 759, "output_tokens": 167, "total_tokens": 926}
-{"timestamp": 1771869903.7957058, "source": "STRATEGY_CARD", "input_tokens": 617, "output_tokens": 1394, "total_tokens": 2011}
-{"timestamp": 1771869908.2515576, "source": "VISUAL_CONTEXT", "input_tokens": 3640, "output_tokens": 433, "total_tokens": 4073}
-{"timestamp": 1771869929.2540205, "source": "TEACHER_SUMMARY", "input_tokens": 788, "output_tokens": 203, "total_tokens": 991}
-{"timestamp": 1771870038.324457, "source": "DATA_ANCHOR", "input_tokens": 877, "output_tokens": 163, "total_tokens": 1040}
-{"timestamp": 1771870047.7521834, "source": "STRATEGY_CARD", "input_tokens": 738, "output_tokens": 638, "total_tokens": 1376}
-{"timestamp": 1771870050.5905893, "source": "VISUAL_CONTEXT", "input_tokens": 2726, "output_tokens": 187, "total_tokens": 2913}
-{"timestamp": 1771870062.5776205, "source": "TEACHER_SUMMARY", "input_tokens": 802, "output_tokens": 171, "total_tokens": 973}
-{"timestamp": 1771876560.8851786, "source": "DATA_ANCHOR", "input_tokens": 632, "output_tokens": 155, "total_tokens": 787}
-{"timestamp": 1771876569.0753162, "source": "STRATEGY_CARD", "input_tokens": 519, "output_tokens": 670, "total_tokens": 1189}
-{"timestamp": 1771876573.2009635, "source": "VISUAL_CONTEXT", "input_tokens": 3255, "output_tokens": 445, "total_tokens": 3700}
-{"timestamp": 1771876583.1995463, "source": "TEACHER_SUMMARY", "input_tokens": 666, "output_tokens": 185, "total_tokens": 851}
-{"timestamp": 1771876720.3403437, "source": "DATA_ANCHOR", "input_tokens": 784, "output_tokens": 172, "total_tokens": 956}
-{"timestamp": 1771876733.8241193, "source": "STRATEGY_CARD", "input_tokens": 645, "output_tokens": 1301, "total_tokens": 1946}
-{"timestamp": 1771876738.4216886, "source": "VISUAL_CONTEXT", "input_tokens": 3665, "output_tokens": 421, "total_tokens": 4086}
-{"timestamp": 1771878489.0657842, "source": "DATA_ANCHOR", "input_tokens": 777, "output_tokens": 197, "total_tokens": 974}
-{"timestamp": 1771878502.1822183, "source": "STRATEGY_CARD", "input_tokens": 654, "output_tokens": 1247, "total_tokens": 1901}
-{"timestamp": 1771878506.8003983, "source": "VISUAL_CONTEXT", "input_tokens": 3658, "output_tokens": 453, "total_tokens": 4111}
-{"timestamp": 1771878524.1584687, "source": "TEACHER_SUMMARY", "input_tokens": 819, "output_tokens": 193, "total_tokens": 1012}
-{"timestamp": 1771878710.7201266, "source": "DATA_ANCHOR", "input_tokens": 779, "output_tokens": 190, "total_tokens": 969}
-{"timestamp": 1771878722.5026355, "source": "STRATEGY_CARD", "input_tokens": 647, "output_tokens": 1061, "total_tokens": 1708}
-{"timestamp": 1771878727.0371706, "source": "VISUAL_CONTEXT", "input_tokens": 3660, "output_tokens": 402, "total_tokens": 4062}
-{"timestamp": 1771878743.4995527, "source": "TEACHER_SUMMARY", "input_tokens": 797, "output_tokens": 180, "total_tokens": 977}
-{"timestamp": 1771932832.5537128, "source": "DATA_ANCHOR", "input_tokens": 659, "output_tokens": 181, "total_tokens": 840}
-{"timestamp": 1771932838.136665, "source": "STRATEGY_CARD", "input_tokens": 543, "output_tokens": 528, "total_tokens": 1071}
-{"timestamp": 1771932840.834456, "source": "VISUAL_CONTEXT", "input_tokens": 3024, "output_tokens": 174, "total_tokens": 3198}
-{"timestamp": 1771933698.210501, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 144, "total_tokens": 944}
-{"timestamp": 1771933703.5894866, "source": "STRATEGY_CARD", "input_tokens": 518, "output_tokens": 513, "total_tokens": 1031}
-{"timestamp": 1771933707.285861, "source": "VISUAL_CONTEXT", "input_tokens": 3038, "output_tokens": 412, "total_tokens": 3450}
-{"timestamp": 1771933715.5800326, "source": "TEACHER_SUMMARY", "input_tokens": 693, "output_tokens": 151, "total_tokens": 844}
-{"timestamp": 1771934496.8563735, "source": "DATA_ANCHOR", "input_tokens": 786, "output_tokens": 144, "total_tokens": 930}
-{"timestamp": 1771934504.023263, "source": "STRATEGY_CARD", "input_tokens": 504, "output_tokens": 716, "total_tokens": 1220}
-{"timestamp": 1771934507.3583136, "source": "VISUAL_CONTEXT", "input_tokens": 3024, "output_tokens": 294, "total_tokens": 3318}
-{"timestamp": 1771934513.7512343, "source": "TEACHER_SUMMARY", "input_tokens": 680, "output_tokens": 123, "total_tokens": 803}
-{"timestamp": 1771935822.8614907, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 144, "total_tokens": 944}
-{"timestamp": 1771935829.6234536, "source": "STRATEGY_CARD", "input_tokens": 518, "output_tokens": 510, "total_tokens": 1028}
-{"timestamp": 1771935833.608502, "source": "VISUAL_CONTEXT", "input_tokens": 3038, "output_tokens": 338, "total_tokens": 3376}
-{"timestamp": 1771935905.0357091, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 144, "total_tokens": 944}
-{"timestamp": 1771935910.6400356, "source": "STRATEGY_CARD", "input_tokens": 518, "output_tokens": 509, "total_tokens": 1027}
-{"timestamp": 1771935913.6947818, "source": "VISUAL_CONTEXT", "input_tokens": 3038, "output_tokens": 263, "total_tokens": 3301}
-{"timestamp": 1771936694.059146, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 144, "total_tokens": 944}
-{"timestamp": 1771936699.5953205, "source": "STRATEGY_CARD", "input_tokens": 518, "output_tokens": 488, "total_tokens": 1006}
-{"timestamp": 1771936702.9945621, "source": "VISUAL_CONTEXT", "input_tokens": 2780, "output_tokens": 346, "total_tokens": 3126}
-{"timestamp": 1771937280.567183, "source": "DATA_ANCHOR", "input_tokens": 786, "output_tokens": 144, "total_tokens": 930}
-{"timestamp": 1771937286.8256245, "source": "STRATEGY_CARD", "input_tokens": 504, "output_tokens": 517, "total_tokens": 1021}
-{"timestamp": 1771937289.427161, "source": "VISUAL_CONTEXT", "input_tokens": 3024, "output_tokens": 164, "total_tokens": 3188}
-{"timestamp": 1771938501.400591, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 144, "total_tokens": 944}
-{"timestamp": 1771938506.8823931, "source": "STRATEGY_CARD", "input_tokens": 518, "output_tokens": 564, "total_tokens": 1082}
-{"timestamp": 1771940032.4332464, "source": "DATA_ANCHOR", "input_tokens": 786, "output_tokens": 144, "total_tokens": 930}
-{"timestamp": 1771940037.2462118, "source": "STRATEGY_CARD", "input_tokens": 504, "output_tokens": 425, "total_tokens": 929}
-{"timestamp": 1771940040.896454, "source": "VISUAL_CONTEXT", "input_tokens": 2766, "output_tokens": 267, "total_tokens": 3033}
-{"timestamp": 1771940634.3867362, "source": "DATA_ANCHOR", "input_tokens": 911, "output_tokens": 181, "total_tokens": 1092}
-{"timestamp": 1771940646.5208874, "source": "STRATEGY_CARD", "input_tokens": 645, "output_tokens": 917, "total_tokens": 1562}
-{"timestamp": 1771940651.0985174, "source": "VISUAL_CONTEXT", "input_tokens": 3665, "output_tokens": 407, "total_tokens": 4072}
-{"timestamp": 1771941935.0188103, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 144, "total_tokens": 944}
-{"timestamp": 1771941940.6748471, "source": "STRATEGY_CARD", "input_tokens": 518, "output_tokens": 526, "total_tokens": 1044}
-{"timestamp": 1771941943.7697163, "source": "VISUAL_CONTEXT", "input_tokens": 2522, "output_tokens": 269, "total_tokens": 2791}
-{"timestamp": 1771942713.6489751, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 144, "total_tokens": 944}
-{"timestamp": 1771942719.4442844, "source": "STRATEGY_CARD", "input_tokens": 518, "output_tokens": 475, "total_tokens": 993}
-{"timestamp": 1771942723.428333, "source": "VISUAL_CONTEXT", "input_tokens": 3038, "output_tokens": 290, "total_tokens": 3328}
-{"timestamp": 1771943351.8508663, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 144, "total_tokens": 944}
-{"timestamp": 1771943356.75026, "source": "STRATEGY_CARD", "input_tokens": 518, "output_tokens": 485, "total_tokens": 1003}
-{"timestamp": 1771943360.1155412, "source": "VISUAL_CONTEXT", "input_tokens": 2780, "output_tokens": 404, "total_tokens": 3184}
-{"timestamp": 1771945884.3092198, "source": "DATA_ANCHOR", "input_tokens": 786, "output_tokens": 144, "total_tokens": 930}
-{"timestamp": 1771945890.4987214, "source": "STRATEGY_CARD", "input_tokens": 504, "output_tokens": 535, "total_tokens": 1039}
-{"timestamp": 1771945893.2301416, "source": "VISUAL_CONTEXT", "input_tokens": 3024, "output_tokens": 184, "total_tokens": 3208}
-{"timestamp": 1771948244.5423186, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 144, "total_tokens": 944}
-{"timestamp": 1771948250.104628, "source": "STRATEGY_CARD", "input_tokens": 518, "output_tokens": 469, "total_tokens": 987}
-{"timestamp": 1771948253.2001977, "source": "VISUAL_CONTEXT", "input_tokens": 3296, "output_tokens": 261, "total_tokens": 3557}
-{"timestamp": 1771948533.0697086, "source": "DATA_ANCHOR", "input_tokens": 786, "output_tokens": 144, "total_tokens": 930}
-{"timestamp": 1771948538.8923702, "source": "STRATEGY_CARD", "input_tokens": 504, "output_tokens": 477, "total_tokens": 981}
-{"timestamp": 1771948542.0966, "source": "VISUAL_CONTEXT", "input_tokens": 3024, "output_tokens": 328, "total_tokens": 3352}
-{"timestamp": 1771948630.856259, "source": "DATA_ANCHOR", "input_tokens": 736, "output_tokens": 145, "total_tokens": 881}
-{"timestamp": 1771948637.3511493, "source": "STRATEGY_CARD", "input_tokens": 442, "output_tokens": 500, "total_tokens": 942}
-{"timestamp": 1771948641.8733625, "source": "VISUAL_CONTEXT", "input_tokens": 2200, "output_tokens": 419, "total_tokens": 2619}
-{"timestamp": 1771948679.9051163, "source": "DATA_ANCHOR", "input_tokens": 924, "output_tokens": 188, "total_tokens": 1112}
-{"timestamp": 1771948689.5182815, "source": "STRATEGY_CARD", "input_tokens": 666, "output_tokens": 670, "total_tokens": 1336}
-{"timestamp": 1771948694.8144562, "source": "VISUAL_CONTEXT", "input_tokens": 2646, "output_tokens": 562, "total_tokens": 3208}
-{"timestamp": 1771948760.0082383, "source": "DATA_ANCHOR", "input_tokens": 1000, "output_tokens": 193, "total_tokens": 1193}
-{"timestamp": 1771948772.763675, "source": "STRATEGY_CARD", "input_tokens": 751, "output_tokens": 877, "total_tokens": 1628}
-{"timestamp": 1771948775.8101215, "source": "VISUAL_CONTEXT", "input_tokens": 2722, "output_tokens": 218, "total_tokens": 2940}
-{"timestamp": 1771949216.8617725, "source": "DATA_ANCHOR", "input_tokens": 786, "output_tokens": 144, "total_tokens": 930}
-{"timestamp": 1771949223.0780823, "source": "STRATEGY_CARD", "input_tokens": 504, "output_tokens": 449, "total_tokens": 953}
-{"timestamp": 1771949227.2518477, "source": "VISUAL_CONTEXT", "input_tokens": 3282, "output_tokens": 541, "total_tokens": 3823}
-{"timestamp": 1771949697.1393044, "source": "DATA_ANCHOR", "input_tokens": 780, "output_tokens": 144, "total_tokens": 924}
-{"timestamp": 1771949703.6878853, "source": "STRATEGY_CARD", "input_tokens": 498, "output_tokens": 590, "total_tokens": 1088}
-{"timestamp": 1771949706.039142, "source": "VISUAL_CONTEXT", "input_tokens": 3276, "output_tokens": 176, "total_tokens": 3452}
-{"timestamp": 1771949861.3109066, "source": "DATA_ANCHOR", "input_tokens": 789, "output_tokens": 144, "total_tokens": 933}
-{"timestamp": 1771949866.9449906, "source": "STRATEGY_CARD", "input_tokens": 507, "output_tokens": 451, "total_tokens": 958}
-{"timestamp": 1771949871.3895617, "source": "VISUAL_CONTEXT", "input_tokens": 3285, "output_tokens": 467, "total_tokens": 3752}
-{"timestamp": 1771950503.5440702, "source": "DATA_ANCHOR", "input_tokens": 794, "output_tokens": 144, "total_tokens": 938}
-{"timestamp": 1771950509.9030645, "source": "STRATEGY_CARD", "input_tokens": 512, "output_tokens": 544, "total_tokens": 1056}
-{"timestamp": 1771950512.6367414, "source": "VISUAL_CONTEXT", "input_tokens": 3032, "output_tokens": 183, "total_tokens": 3215}
-{"timestamp": 1771950581.1055336, "source": "DATA_ANCHOR", "input_tokens": 786, "output_tokens": 144, "total_tokens": 930}
-{"timestamp": 1771950587.3688447, "source": "STRATEGY_CARD", "input_tokens": 504, "output_tokens": 536, "total_tokens": 1040}
-{"timestamp": 1771950590.2077408, "source": "VISUAL_CONTEXT", "input_tokens": 3024, "output_tokens": 208, "total_tokens": 3232}
-{"timestamp": 1771951666.857572, "source": "DATA_ANCHOR", "input_tokens": 709, "output_tokens": 106, "total_tokens": 815}
-{"timestamp": 1771951671.9898052, "source": "STRATEGY_CARD", "input_tokens": 403, "output_tokens": 416, "total_tokens": 819}
-{"timestamp": 1771951749.9918065, "source": "DATA_ANCHOR", "input_tokens": 718, "output_tokens": 96, "total_tokens": 814}
-{"timestamp": 1771951756.452246, "source": "STRATEGY_CARD", "input_tokens": 409, "output_tokens": 440, "total_tokens": 849}
-{"timestamp": 1771951766.3221476, "source": "DATA_ANCHOR", "input_tokens": 709, "output_tokens": 106, "total_tokens": 815}
-{"timestamp": 1771951771.5266824, "source": "STRATEGY_CARD", "input_tokens": 403, "output_tokens": 427, "total_tokens": 830}
-{"timestamp": 1771952217.5004902, "source": "DATA_ANCHOR", "input_tokens": 718, "output_tokens": 96, "total_tokens": 814}
-{"timestamp": 1771952223.2741513, "source": "STRATEGY_CARD", "input_tokens": 409, "output_tokens": 389, "total_tokens": 798}
-{"timestamp": 1771952227.318312, "source": "DATA_ANCHOR", "input_tokens": 709, "output_tokens": 106, "total_tokens": 815}
-{"timestamp": 1771952232.8924174, "source": "STRATEGY_CARD", "input_tokens": 403, "output_tokens": 465, "total_tokens": 868}
-{"timestamp": 1771952895.196091, "source": "DATA_ANCHOR", "input_tokens": 718, "output_tokens": 96, "total_tokens": 814}
-{"timestamp": 1771952902.5638971, "source": "STRATEGY_CARD", "input_tokens": 409, "output_tokens": 524, "total_tokens": 933}
-{"timestamp": 1771952906.6790872, "source": "DATA_ANCHOR", "input_tokens": 709, "output_tokens": 106, "total_tokens": 815}
-{"timestamp": 1771952912.0897443, "source": "STRATEGY_CARD", "input_tokens": 403, "output_tokens": 444, "total_tokens": 847}
-{"timestamp": 1771953158.387301, "source": "DATA_ANCHOR", "input_tokens": 718, "output_tokens": 96, "total_tokens": 814}
-{"timestamp": 1771953164.7586098, "source": "STRATEGY_CARD", "input_tokens": 409, "output_tokens": 402, "total_tokens": 811}
-{"timestamp": 1771953168.9675438, "source": "DATA_ANCHOR", "input_tokens": 709, "output_tokens": 106, "total_tokens": 815}
-{"timestamp": 1771953174.207361, "source": "STRATEGY_CARD", "input_tokens": 403, "output_tokens": 444, "total_tokens": 847}
-{"timestamp": 1771954505.6322093, "source": "DATA_ANCHOR", "input_tokens": 718, "output_tokens": 96, "total_tokens": 814}
-{"timestamp": 1771954511.725205, "source": "STRATEGY_CARD", "input_tokens": 409, "output_tokens": 434, "total_tokens": 843}
-{"timestamp": 1771954515.679161, "source": "DATA_ANCHOR", "input_tokens": 709, "output_tokens": 106, "total_tokens": 815}
-{"timestamp": 1771954520.296249, "source": "STRATEGY_CARD", "input_tokens": 403, "output_tokens": 386, "total_tokens": 789}
-{"timestamp": 1771954849.4632251, "source": "DATA_ANCHOR", "input_tokens": 718, "output_tokens": 96, "total_tokens": 814}
-{"timestamp": 1771954856.3961208, "source": "STRATEGY_CARD", "input_tokens": 409, "output_tokens": 504, "total_tokens": 913}
-{"timestamp": 1771954860.295837, "source": "DATA_ANCHOR", "input_tokens": 709, "output_tokens": 106, "total_tokens": 815}
-{"timestamp": 1771954865.2835972, "source": "STRATEGY_CARD", "input_tokens": 403, "output_tokens": 389, "total_tokens": 792}
-{"timestamp": 1771956036.5104868, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 38, "total_tokens": 234}
-{"timestamp": 1771956038.9657845, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 241, "total_tokens": 925}
-{"timestamp": 1771956050.9309728, "source": "STRATEGY_CARD", "input_tokens": 503, "output_tokens": 947, "total_tokens": 1450}
-{"timestamp": 1771956053.7094507, "source": "VISUAL_CONTEXT", "input_tokens": 2923, "output_tokens": 264, "total_tokens": 3187}
-{"timestamp": 1771956293.3548093, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 2, "total_tokens": 198}
-{"timestamp": 1771956294.8734057, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 131, "total_tokens": 815}
-{"timestamp": 1771956301.5210328, "source": "STRATEGY_CARD", "input_tokens": 397, "output_tokens": 459, "total_tokens": 856}
-{"timestamp": 1771956304.4939537, "source": "VISUAL_CONTEXT", "input_tokens": 2149, "output_tokens": 279, "total_tokens": 2428}
-{"timestamp": 1771956384.7890747, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 43, "total_tokens": 239}
-{"timestamp": 1771956391.3596125, "source": "FAST_SOLVE", "input_tokens": 2280, "output_tokens": 638, "total_tokens": 2918}
-{"timestamp": 1772184443.1069245, "source": "STRATEGY_CARD", "input_tokens": 362, "output_tokens": 552, "total_tokens": 914}
-{"timestamp": 1772184451.4081528, "source": "STRATEGY_CARD", "input_tokens": 357, "output_tokens": 390, "total_tokens": 747}
-{"timestamp": 1772185366.1459668, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 32, "total_tokens": 228}
-{"timestamp": 1772185367.0346794, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 91, "total_tokens": 775}
-{"timestamp": 1772185373.6614676, "source": "STRATEGY_CARD", "input_tokens": 371, "output_tokens": 613, "total_tokens": 984}
-{"timestamp": 1772185376.7847662, "source": "VISUAL_CONTEXT", "input_tokens": 1633, "output_tokens": 326, "total_tokens": 1959}
-{"timestamp": 1772186571.9902318, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 2, "total_tokens": 198}
-{"timestamp": 1772186573.0850022, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 114, "total_tokens": 798}
-{"timestamp": 1772186579.0304701, "source": "STRATEGY_CARD", "input_tokens": 385, "output_tokens": 484, "total_tokens": 869}
-{"timestamp": 1772186582.1806858, "source": "VISUAL_CONTEXT", "input_tokens": 1633, "output_tokens": 378, "total_tokens": 2011}
-{"timestamp": 1772207427.694273, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 2, "total_tokens": 198}
-{"timestamp": 1772207429.3942685, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 106, "total_tokens": 790}
-{"timestamp": 1772207435.3086324, "source": "STRATEGY_CARD", "input_tokens": 379, "output_tokens": 552, "total_tokens": 931}
-{"timestamp": 1772207437.7568438, "source": "VISUAL_CONTEXT", "input_tokens": 2923, "output_tokens": 244, "total_tokens": 3167}
-{"timestamp": 1772207675.3290944, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 102, "total_tokens": 298}
-{"timestamp": 1772207686.41991, "source": "FAST_SOLVE", "input_tokens": 3054, "output_tokens": 1460, "total_tokens": 4514}
-{"timestamp": 1772209624.6586223, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 24, "total_tokens": 220}
-{"timestamp": 1772209626.0365634, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 112, "total_tokens": 796}
-{"timestamp": 1772209632.6892936, "source": "STRATEGY_CARD", "input_tokens": 387, "output_tokens": 556, "total_tokens": 943}
-{"timestamp": 1772209635.2372203, "source": "VISUAL_CONTEXT", "input_tokens": 3181, "output_tokens": 244, "total_tokens": 3425}
-{"timestamp": 1772209988.933003, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 53, "total_tokens": 249}
-{"timestamp": 1772210001.3152072, "source": "FAST_SOLVE", "input_tokens": 3054, "output_tokens": 1595, "total_tokens": 4649}
-{"timestamp": 1772210002.4750006, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 126, "total_tokens": 810}
-{"timestamp": 1772210012.0418305, "source": "STRATEGY_CARD", "input_tokens": 397, "output_tokens": 990, "total_tokens": 1387}
-{"timestamp": 1772210016.3899589, "source": "VISUAL_CONTEXT", "input_tokens": 3439, "output_tokens": 397, "total_tokens": 3836}
-{"timestamp": 1772216422.1573584, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 53, "total_tokens": 249}
-{"timestamp": 1772216423.5463283, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 106, "total_tokens": 790}
-{"timestamp": 1772216429.5415487, "source": "STRATEGY_CARD", "input_tokens": 379, "output_tokens": 437, "total_tokens": 816}
-{"timestamp": 1772216432.1646645, "source": "VISUAL_CONTEXT", "input_tokens": 3439, "output_tokens": 246, "total_tokens": 3685}
-{"timestamp": 1772217028.984217, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 24, "total_tokens": 220}
-{"timestamp": 1772217030.409016, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 91, "total_tokens": 775}
-{"timestamp": 1772217037.3784857, "source": "STRATEGY_CARD", "input_tokens": 371, "output_tokens": 470, "total_tokens": 841}
-{"timestamp": 1772217042.8333948, "source": "VISUAL_CONTEXT", "input_tokens": 1891, "output_tokens": 271, "total_tokens": 2162}
-{"timestamp": 1772217211.0866885, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 107, "total_tokens": 303}
-{"timestamp": 1772217212.0990183, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 91, "total_tokens": 775}
-{"timestamp": 1772217219.6353095, "source": "STRATEGY_CARD", "input_tokens": 371, "output_tokens": 540, "total_tokens": 911}
-{"timestamp": 1772217222.6454785, "source": "VISUAL_CONTEXT", "input_tokens": 1891, "output_tokens": 189, "total_tokens": 2080}
-{"timestamp": 1772217384.4938123, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 45, "total_tokens": 241}
-{"timestamp": 1772217385.7077172, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 126, "total_tokens": 810}
-{"timestamp": 1772217395.2816844, "source": "STRATEGY_CARD", "input_tokens": 397, "output_tokens": 631, "total_tokens": 1028}
-{"timestamp": 1772217398.111831, "source": "VISUAL_CONTEXT", "input_tokens": 1891, "output_tokens": 182, "total_tokens": 2073}
-{"timestamp": 1772218120.0576835, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 49, "total_tokens": 245}
-{"timestamp": 1772218131.3212738, "source": "FAST_SOLVE", "input_tokens": 3054, "output_tokens": 1315, "total_tokens": 4369}
-{"timestamp": 1772219336.2080736, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 2, "total_tokens": 198}
-{"timestamp": 1772219337.3554707, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 109, "total_tokens": 793}
-{"timestamp": 1772219343.0264137, "source": "STRATEGY_CARD", "input_tokens": 382, "output_tokens": 506, "total_tokens": 888}
-{"timestamp": 1772219345.4707713, "source": "VISUAL_CONTEXT", "input_tokens": 1891, "output_tokens": 169, "total_tokens": 2060}
-{"timestamp": 1772219679.6620448, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 17, "total_tokens": 213}
-{"timestamp": 1772219680.669632, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 110, "total_tokens": 794}
-{"timestamp": 1772219686.5390937, "source": "STRATEGY_CARD", "input_tokens": 383, "output_tokens": 436, "total_tokens": 819}
-{"timestamp": 1772219691.521667, "source": "VISUAL_CONTEXT", "input_tokens": 3439, "output_tokens": 558, "total_tokens": 3997}
-{"timestamp": 1772220064.1277392, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 2, "total_tokens": 198}
-{"timestamp": 1772220065.273167, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 91, "total_tokens": 775}
-{"timestamp": 1772220073.747265, "source": "STRATEGY_CARD", "input_tokens": 371, "output_tokens": 604, "total_tokens": 975}
-{"timestamp": 1772220077.1117046, "source": "VISUAL_CONTEXT", "input_tokens": 1891, "output_tokens": 150, "total_tokens": 2041}
-{"timestamp": 1772220538.3429656, "source": "CLASSIFY_QUESTION", "input_tokens": 196, "output_tokens": 2, "total_tokens": 198}
-{"timestamp": 1772220539.4422235, "source": "DATA_ANCHOR", "input_tokens": 684, "output_tokens": 129, "total_tokens": 813}
-{"timestamp": 1772220548.5871553, "source": "STRATEGY_CARD", "input_tokens": 400, "output_tokens": 637, "total_tokens": 1037}
-{"timestamp": 1772220552.5664558, "source": "VISUAL_CONTEXT", "input_tokens": 3439, "output_tokens": 404, "total_tokens": 3843}
-{"timestamp": 1772264253.5596836, "source": "DATA_ANCHOR", "input_tokens": 1104, "output_tokens": 147, "total_tokens": 1251}
-{"timestamp": 1772264265.1862137, "source": "STRATEGY_CARD", "input_tokens": 821, "output_tokens": 931, "total_tokens": 1752}
-{"timestamp": 1772264267.7464864, "source": "VISUAL_CONTEXT", "input_tokens": 2310, "output_tokens": 186, "total_tokens": 2496}
-{"timestamp": 1772264633.1384616, "source": "DATA_ANCHOR", "input_tokens": 801, "output_tokens": 138, "total_tokens": 939}
-{"timestamp": 1772264640.164352, "source": "STRATEGY_CARD", "input_tokens": 520, "output_tokens": 607, "total_tokens": 1127}
-{"timestamp": 1772264643.0294616, "source": "VISUAL_CONTEXT", "input_tokens": 3297, "output_tokens": 262, "total_tokens": 3559}
-{"timestamp": 1772266887.2446077, "source": "FAST_SOLVE", "input_tokens": 1511, "output_tokens": 237, "total_tokens": 1748}
-{"timestamp": 1772267961.490861, "source": "FAST_SOLVE", "input_tokens": 221, "output_tokens": 567, "total_tokens": 788}
-{"timestamp": 1772268084.3472216, "source": "FAST_SOLVE", "input_tokens": 223, "output_tokens": 359, "total_tokens": 582}
-{"timestamp": 1772268231.5889988, "source": "FAST_SOLVE", "input_tokens": 1513, "output_tokens": 193, "total_tokens": 1706}
-{"timestamp": 1772268571.180139, "source": "FAST_SOLVE", "input_tokens": 1510, "output_tokens": 199, "total_tokens": 1709}
-{"timestamp": 1772268694.3875191, "source": "FAST_SOLVE", "input_tokens": 1510, "output_tokens": 302, "total_tokens": 1812}
-{"timestamp": 1772270153.5130074, "source": "FAST_SOLVE", "input_tokens": 1510, "output_tokens": 159, "total_tokens": 1669}
-{"timestamp": 1772270401.7552814, "source": "FAST_SOLVE", "input_tokens": 1510, "output_tokens": 169, "total_tokens": 1679}
-{"timestamp": 1772271907.851332, "source": "FAST_SOLVE", "input_tokens": 1510, "output_tokens": 232, "total_tokens": 1742}
-{"timestamp": 1772271990.797167, "source": "FAST_SOLVE", "input_tokens": 1510, "output_tokens": 197, "total_tokens": 1707}
-{"timestamp": 1772272062.3957999, "source": "FAST_SOLVE", "input_tokens": 1612, "output_tokens": 118, "total_tokens": 1730}
-{"timestamp": 1772273421.5950537, "source": "DATA_ANCHOR", "input_tokens": 843, "output_tokens": 187, "total_tokens": 1030}
-{"timestamp": 1772273432.206518, "source": "STRATEGY_CARD", "input_tokens": 583, "output_tokens": 674, "total_tokens": 1257}
-{"timestamp": 1772273437.3000703, "source": "VISUAL_CONTEXT", "input_tokens": 1791, "output_tokens": 528, "total_tokens": 2319}
-{"timestamp": 1772273672.3663638, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 122, "total_tokens": 922}
-{"timestamp": 1772273679.7529964, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 675, "total_tokens": 1180}
-{"timestamp": 1772273683.9572523, "source": "VISUAL_CONTEXT", "input_tokens": 3038, "output_tokens": 331, "total_tokens": 3369}
-{"timestamp": 1772275248.5604405, "source": "FAST_SOLVE", "input_tokens": 1612, "output_tokens": 85, "total_tokens": 1697}
-{"timestamp": 1772275339.786252, "source": "DATA_ANCHOR", "input_tokens": 720, "output_tokens": 121, "total_tokens": 841}
-{"timestamp": 1772275345.1141431, "source": "STRATEGY_CARD", "input_tokens": 431, "output_tokens": 537, "total_tokens": 968}
-{"timestamp": 1772275995.9715457, "source": "FAST_SOLVE", "input_tokens": 1612, "output_tokens": 62, "total_tokens": 1674}
-{"timestamp": 1772281883.690228, "source": "DATA_ANCHOR", "input_tokens": 888, "output_tokens": 172, "total_tokens": 1060}
-{"timestamp": 1772281894.1490273, "source": "STRATEGY_CARD", "input_tokens": 622, "output_tokens": 1091, "total_tokens": 1713}
-{"timestamp": 1772281898.2360604, "source": "VISUAL_CONTEXT", "input_tokens": 3642, "output_tokens": 374, "total_tokens": 4016}
-{"timestamp": 1772283120.4795017, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772283124.9158766, "source": "STRATEGY_CARD", "input_tokens": 445, "output_tokens": 350, "total_tokens": 795}
-{"timestamp": 1772283356.2111268, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772283360.3942087, "source": "STRATEGY_CARD", "input_tokens": 445, "output_tokens": 361, "total_tokens": 806}
-{"timestamp": 1772283517.1311772, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772283521.3121452, "source": "STRATEGY_CARD", "input_tokens": 445, "output_tokens": 351, "total_tokens": 796}
-{"timestamp": 1772286859.6360447, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772286863.170782, "source": "STRATEGY_CARD", "input_tokens": 612, "output_tokens": 261, "total_tokens": 873}
-{"timestamp": 1772287249.34013, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772287253.088565, "source": "STRATEGY_CARD", "input_tokens": 612, "output_tokens": 332, "total_tokens": 944}
-{"timestamp": 1772288382.1763933, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772288386.3162298, "source": "STRATEGY_CARD", "input_tokens": 612, "output_tokens": 356, "total_tokens": 968}
-{"timestamp": 1772288482.751811, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772288486.6249003, "source": "STRATEGY_CARD", "input_tokens": 612, "output_tokens": 333, "total_tokens": 945}
-{"timestamp": 1772288686.9924343, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772288692.1504664, "source": "STRATEGY_CARD", "input_tokens": 612, "output_tokens": 367, "total_tokens": 979}
-{"timestamp": 1772288823.95968, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772288827.4738717, "source": "STRATEGY_CARD", "input_tokens": 612, "output_tokens": 329, "total_tokens": 941}
-{"timestamp": 1772289064.3185349, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772289067.6416726, "source": "STRATEGY_CARD", "input_tokens": 612, "output_tokens": 297, "total_tokens": 909}
-{"timestamp": 1772289183.2490304, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 122, "total_tokens": 922}
-{"timestamp": 1772289188.5227911, "source": "STRATEGY_CARD", "input_tokens": 672, "output_tokens": 413, "total_tokens": 1085}
-{"timestamp": 1772289191.4762766, "source": "VISUAL_CONTEXT", "input_tokens": 3812, "output_tokens": 275, "total_tokens": 4087}
-{"timestamp": 1772289281.8545558, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772289286.1500738, "source": "STRATEGY_CARD", "input_tokens": 612, "output_tokens": 371, "total_tokens": 983}
-{"timestamp": 1772289374.731112, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 124, "total_tokens": 859}
-{"timestamp": 1772289378.5790443, "source": "STRATEGY_CARD", "input_tokens": 612, "output_tokens": 297, "total_tokens": 909}
-{"timestamp": 1772290526.8427906, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 295, "total_tokens": 832}
-{"timestamp": 1772291090.8257291, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 386, "total_tokens": 923}
-{"timestamp": 1772291669.098214, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 325, "total_tokens": 862}
-{"timestamp": 1772291797.7051554, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 365, "total_tokens": 902}
-{"timestamp": 1772291885.3729901, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 327, "total_tokens": 864}
-{"timestamp": 1772291915.0213838, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 361, "total_tokens": 898}
-{"timestamp": 1772292071.6140084, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 346, "total_tokens": 883}
-{"timestamp": 1772292716.3479543, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 317, "total_tokens": 854}
-{"timestamp": 1772293441.0590122, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 397, "total_tokens": 934}
-{"timestamp": 1772293521.4362812, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 336, "total_tokens": 873}
-{"timestamp": 1772293601.087758, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 434, "total_tokens": 971}
-{"timestamp": 1772293710.9737146, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 401, "total_tokens": 938}
-{"timestamp": 1772293987.4454007, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 401, "total_tokens": 938}
-{"timestamp": 1772294884.291998, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 437, "total_tokens": 974}
-{"timestamp": 1772303335.1572127, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 410, "total_tokens": 947}
-{"timestamp": 1772303402.662484, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 404, "total_tokens": 941}
-{"timestamp": 1772303786.568746, "source": "STRATEGY_CARD", "input_tokens": 537, "output_tokens": 339, "total_tokens": 876}
-{"timestamp": 1772305022.422409, "source": "DATA_ANCHOR", "input_tokens": 889, "output_tokens": 167, "total_tokens": 1056}
-{"timestamp": 1772305028.4815621, "source": "STRATEGY_CARD", "input_tokens": 787, "output_tokens": 470, "total_tokens": 1257}
-{"timestamp": 1772305032.831894, "source": "VISUAL_CONTEXT", "input_tokens": 3643, "output_tokens": 477, "total_tokens": 4120}
-{"timestamp": 1772305218.8681152, "source": "DATA_ANCHOR", "input_tokens": 998, "output_tokens": 186, "total_tokens": 1184}
-{"timestamp": 1772305226.8380358, "source": "STRATEGY_CARD", "input_tokens": 912, "output_tokens": 572, "total_tokens": 1484}
-{"timestamp": 1772305229.5243943, "source": "VISUAL_CONTEXT", "input_tokens": 2720, "output_tokens": 182, "total_tokens": 2902}
-{"timestamp": 1772306289.214626, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 460, "total_tokens": 965}
-{"timestamp": 1772306358.147652, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 605, "total_tokens": 1110}
-{"timestamp": 1772307700.1008728, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 344, "total_tokens": 849}
-{"timestamp": 1772307999.7617705, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 488, "total_tokens": 993}
-{"timestamp": 1772308798.4363883, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 510, "total_tokens": 1015}
-{"timestamp": 1772308860.7397459, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 377, "total_tokens": 882}
-{"timestamp": 1772308922.1402454, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 510, "total_tokens": 1015}
-{"timestamp": 1772310374.9695342, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 513, "total_tokens": 1018}
-{"timestamp": 1772311012.2686985, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 519, "total_tokens": 1024}
-{"timestamp": 1772311802.4366205, "source": "DATA_ANCHOR", "input_tokens": 994, "output_tokens": 177, "total_tokens": 1171}
-{"timestamp": 1772311810.414151, "source": "STRATEGY_CARD", "input_tokens": 903, "output_tokens": 665, "total_tokens": 1568}
-{"timestamp": 1772311812.6404753, "source": "VISUAL_CONTEXT", "input_tokens": 1942, "output_tokens": 169, "total_tokens": 2111}
-{"timestamp": 1772312360.295878, "source": "DATA_ANCHOR", "input_tokens": 998, "output_tokens": 179, "total_tokens": 1177}
-{"timestamp": 1772312366.853098, "source": "STRATEGY_CARD", "input_tokens": 907, "output_tokens": 478, "total_tokens": 1385}
-{"timestamp": 1772312369.4041467, "source": "VISUAL_CONTEXT", "input_tokens": 2720, "output_tokens": 201, "total_tokens": 2921}
-{"timestamp": 1772313239.1667058, "source": "DATA_ANCHOR", "input_tokens": 909, "output_tokens": 172, "total_tokens": 1081}
-{"timestamp": 1772313245.562619, "source": "STRATEGY_CARD", "input_tokens": 810, "output_tokens": 551, "total_tokens": 1361}
-{"timestamp": 1772313250.2605731, "source": "VISUAL_CONTEXT", "input_tokens": 3147, "output_tokens": 430, "total_tokens": 3577}
-{"timestamp": 1772355358.9013946, "source": "DATA_ANCHOR", "input_tokens": 819, "output_tokens": 202, "total_tokens": 1021}
-{"timestamp": 1772355365.2465763, "source": "STRATEGY_CARD", "input_tokens": 768, "output_tokens": 469, "total_tokens": 1237}
-{"timestamp": 1772355367.8593123, "source": "VISUAL_CONTEXT", "input_tokens": 2283, "output_tokens": 272, "total_tokens": 2555}
-{"timestamp": 1772357127.3553398, "source": "DATA_ANCHOR", "input_tokens": 834, "output_tokens": 148, "total_tokens": 982}
-{"timestamp": 1772357134.4994934, "source": "STRATEGY_CARD", "input_tokens": 725, "output_tokens": 543, "total_tokens": 1268}
-{"timestamp": 1772357137.185659, "source": "VISUAL_CONTEXT", "input_tokens": 2298, "output_tokens": 285, "total_tokens": 2583}
-{"timestamp": 1772358503.732805, "source": "DATA_ANCHOR", "input_tokens": 828, "output_tokens": 131, "total_tokens": 959}
-{"timestamp": 1772358509.194394, "source": "STRATEGY_CARD", "input_tokens": 706, "output_tokens": 490, "total_tokens": 1196}
-{"timestamp": 1772358512.5458539, "source": "VISUAL_CONTEXT", "input_tokens": 2292, "output_tokens": 281, "total_tokens": 2573}
-{"timestamp": 1772360001.191922, "source": "DATA_ANCHOR", "input_tokens": 831, "output_tokens": 187, "total_tokens": 1018}
-{"timestamp": 1772360007.70699, "source": "STRATEGY_CARD", "input_tokens": 766, "output_tokens": 538, "total_tokens": 1304}
-{"timestamp": 1772360010.814702, "source": "VISUAL_CONTEXT", "input_tokens": 2295, "output_tokens": 277, "total_tokens": 2572}
-{"timestamp": 1772360850.525078, "source": "DATA_ANCHOR", "input_tokens": 831, "output_tokens": 135, "total_tokens": 966}
-{"timestamp": 1772360855.8802068, "source": "STRATEGY_CARD", "input_tokens": 713, "output_tokens": 464, "total_tokens": 1177}
-{"timestamp": 1772360858.7751343, "source": "VISUAL_CONTEXT", "input_tokens": 2295, "output_tokens": 288, "total_tokens": 2583}
-{"timestamp": 1772361927.9387991, "source": "DATA_ANCHOR", "input_tokens": 801, "output_tokens": 214, "total_tokens": 1015}
-{"timestamp": 1772361934.302936, "source": "STRATEGY_CARD", "input_tokens": 758, "output_tokens": 507, "total_tokens": 1265}
-{"timestamp": 1772361937.7212152, "source": "VISUAL_CONTEXT", "input_tokens": 2265, "output_tokens": 306, "total_tokens": 2571}
-{"timestamp": 1772368766.704942, "source": "DATA_ANCHOR", "input_tokens": 831, "output_tokens": 183, "total_tokens": 1014}
-{"timestamp": 1772368773.471908, "source": "STRATEGY_CARD", "input_tokens": 762, "output_tokens": 517, "total_tokens": 1279}
-{"timestamp": 1772368776.8604324, "source": "VISUAL_CONTEXT", "input_tokens": 2295, "output_tokens": 352, "total_tokens": 2647}
-{"timestamp": 1772369754.4233665, "source": "DATA_ANCHOR", "input_tokens": 823, "output_tokens": 188, "total_tokens": 1011}
-{"timestamp": 1772369760.365039, "source": "STRATEGY_CARD", "input_tokens": 759, "output_tokens": 491, "total_tokens": 1250}
-{"timestamp": 1772369763.271022, "source": "VISUAL_CONTEXT", "input_tokens": 2287, "output_tokens": 284, "total_tokens": 2571}
-{"timestamp": 1772370412.9353883, "source": "DATA_ANCHOR", "input_tokens": 819, "output_tokens": 202, "total_tokens": 1021}
-{"timestamp": 1772370419.6743522, "source": "STRATEGY_CARD", "input_tokens": 768, "output_tokens": 524, "total_tokens": 1292}
-{"timestamp": 1772370422.8123605, "source": "VISUAL_CONTEXT", "input_tokens": 2283, "output_tokens": 415, "total_tokens": 2698}
-{"timestamp": 1772370803.7047546, "source": "DATA_ANCHOR", "input_tokens": 815, "output_tokens": 219, "total_tokens": 1034}
-{"timestamp": 1772370811.2920904, "source": "STRATEGY_CARD", "input_tokens": 782, "output_tokens": 617, "total_tokens": 1399}
-{"timestamp": 1772370814.713964, "source": "VISUAL_CONTEXT", "input_tokens": 2279, "output_tokens": 317, "total_tokens": 2596}
-{"timestamp": 1772371073.0728514, "source": "DATA_ANCHOR", "input_tokens": 808, "output_tokens": 229, "total_tokens": 1037}
-{"timestamp": 1772371081.030153, "source": "STRATEGY_CARD", "input_tokens": 776, "output_tokens": 596, "total_tokens": 1372}
-{"timestamp": 1772371084.613311, "source": "VISUAL_CONTEXT", "input_tokens": 2272, "output_tokens": 307, "total_tokens": 2579}
-{"timestamp": 1772372896.668368, "source": "DATA_ANCHOR", "input_tokens": 830, "output_tokens": 217, "total_tokens": 1047}
-{"timestamp": 1772372904.6712778, "source": "STRATEGY_CARD", "input_tokens": 794, "output_tokens": 626, "total_tokens": 1420}
-{"timestamp": 1772372908.586714, "source": "VISUAL_CONTEXT", "input_tokens": 2294, "output_tokens": 353, "total_tokens": 2647}
-{"timestamp": 1772373123.7019866, "source": "DATA_ANCHOR", "input_tokens": 995, "output_tokens": 178, "total_tokens": 1173}
-{"timestamp": 1772373133.1442666, "source": "STRATEGY_CARD", "input_tokens": 900, "output_tokens": 638, "total_tokens": 1538}
-{"timestamp": 1772373135.398251, "source": "VISUAL_CONTEXT", "input_tokens": 2717, "output_tokens": 195, "total_tokens": 2912}
-{"timestamp": 1772383263.7626507, "source": "DATA_ANCHOR", "input_tokens": 813, "output_tokens": 217, "total_tokens": 1030}
-{"timestamp": 1772383269.6072297, "source": "STRATEGY_CARD", "input_tokens": 777, "output_tokens": 455, "total_tokens": 1232}
-{"timestamp": 1772383273.510396, "source": "VISUAL_CONTEXT", "input_tokens": 2277, "output_tokens": 313, "total_tokens": 2590}
-{"timestamp": 1772384490.2766821, "source": "DATA_ANCHOR", "input_tokens": 834, "output_tokens": 185, "total_tokens": 1019}
-{"timestamp": 1772384497.44401, "source": "STRATEGY_CARD", "input_tokens": 767, "output_tokens": 619, "total_tokens": 1386}
-{"timestamp": 1772384500.5021641, "source": "VISUAL_CONTEXT", "input_tokens": 2298, "output_tokens": 279, "total_tokens": 2577}
-{"timestamp": 1772385445.3490279, "source": "DATA_ANCHOR", "input_tokens": 814, "output_tokens": 216, "total_tokens": 1030}
-{"timestamp": 1772385451.8628404, "source": "STRATEGY_CARD", "input_tokens": 777, "output_tokens": 529, "total_tokens": 1306}
-{"timestamp": 1772385455.2523077, "source": "VISUAL_CONTEXT", "input_tokens": 2278, "output_tokens": 309, "total_tokens": 2587}
-{"timestamp": 1772385545.749922, "source": "DATA_ANCHOR", "input_tokens": 864, "output_tokens": 167, "total_tokens": 1031}
-{"timestamp": 1772385552.2876897, "source": "STRATEGY_CARD", "input_tokens": 762, "output_tokens": 532, "total_tokens": 1294}
-{"timestamp": 1772385558.2946172, "source": "VISUAL_CONTEXT", "input_tokens": 3618, "output_tokens": 511, "total_tokens": 4129}
-{"timestamp": 1772461061.413273, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 137, "total_tokens": 937}
-{"timestamp": 1772461068.2924109, "source": "STRATEGY_CARD", "input_tokens": 685, "output_tokens": 526, "total_tokens": 1211}
-{"timestamp": 1772461071.1724095, "source": "VISUAL_CONTEXT", "input_tokens": 3038, "output_tokens": 278, "total_tokens": 3316}
-{"timestamp": 1772461084.868688, "source": "DATA_ANCHOR", "input_tokens": 1021, "output_tokens": 295, "total_tokens": 1316}
-{"timestamp": 1772461094.4743059, "source": "STRATEGY_CARD", "input_tokens": 1008, "output_tokens": 453, "total_tokens": 1461}
-{"timestamp": 1772461098.7331958, "source": "VISUAL_CONTEXT", "input_tokens": 2743, "output_tokens": 433, "total_tokens": 3176}
-{"timestamp": 1772461110.3815665, "source": "DATA_ANCHOR", "input_tokens": 1097, "output_tokens": 283, "total_tokens": 1380}
-{"timestamp": 1772461118.9387405, "source": "STRATEGY_CARD", "input_tokens": 1107, "output_tokens": 531, "total_tokens": 1638}
-{"timestamp": 1772461121.575091, "source": "VISUAL_CONTEXT", "input_tokens": 2819, "output_tokens": 182, "total_tokens": 3001}
-{"timestamp": 1772461131.2829912, "source": "DATA_ANCHOR", "input_tokens": 986, "output_tokens": 168, "total_tokens": 1154}
-{"timestamp": 1772461142.5991337, "source": "STRATEGY_CARD", "input_tokens": 886, "output_tokens": 756, "total_tokens": 1642}
-{"timestamp": 1772461145.3917375, "source": "VISUAL_CONTEXT", "input_tokens": 2708, "output_tokens": 217, "total_tokens": 2925}
-{"timestamp": 1772461156.9371452, "source": "DATA_ANCHOR", "input_tokens": 879, "output_tokens": 176, "total_tokens": 1055}
-{"timestamp": 1772461166.3661892, "source": "STRATEGY_CARD", "input_tokens": 778, "output_tokens": 522, "total_tokens": 1300}
-{"timestamp": 1772461171.6899047, "source": "VISUAL_CONTEXT", "input_tokens": 2601, "output_tokens": 550, "total_tokens": 3151}
-{"timestamp": 1772461182.1467493, "source": "DATA_ANCHOR", "input_tokens": 961, "output_tokens": 166, "total_tokens": 1127}
-{"timestamp": 1772461189.5788329, "source": "STRATEGY_CARD", "input_tokens": 854, "output_tokens": 557, "total_tokens": 1411}
-{"timestamp": 1772461193.501765, "source": "VISUAL_CONTEXT", "input_tokens": 2683, "output_tokens": 465, "total_tokens": 3148}
-{"timestamp": 1772461202.1012344, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 143, "total_tokens": 878}
-{"timestamp": 1772461207.8563702, "source": "STRATEGY_CARD", "input_tokens": 611, "output_tokens": 481, "total_tokens": 1092}
-{"timestamp": 1772461211.8030362, "source": "VISUAL_CONTEXT", "input_tokens": 1941, "output_tokens": 430, "total_tokens": 2371}
-{"timestamp": 1772461221.3642902, "source": "DATA_ANCHOR", "input_tokens": 820, "output_tokens": 142, "total_tokens": 962}
-{"timestamp": 1772461229.2210872, "source": "STRATEGY_CARD", "input_tokens": 702, "output_tokens": 509, "total_tokens": 1211}
-{"timestamp": 1772461233.5244048, "source": "VISUAL_CONTEXT", "input_tokens": 2542, "output_tokens": 525, "total_tokens": 3067}
-{"timestamp": 1772461240.6966164, "source": "DATA_ANCHOR", "input_tokens": 806, "output_tokens": 121, "total_tokens": 927}
-{"timestamp": 1772461247.1795962, "source": "STRATEGY_CARD", "input_tokens": 677, "output_tokens": 420, "total_tokens": 1097}
-{"timestamp": 1772461250.502863, "source": "VISUAL_CONTEXT", "input_tokens": 2528, "output_tokens": 327, "total_tokens": 2855}
-{"timestamp": 1772461263.5028808, "source": "DATA_ANCHOR", "input_tokens": 1070, "output_tokens": 146, "total_tokens": 1216}
-{"timestamp": 1772461273.0454493, "source": "STRATEGY_CARD", "input_tokens": 964, "output_tokens": 564, "total_tokens": 1528}
-{"timestamp": 1772461276.675592, "source": "VISUAL_CONTEXT", "input_tokens": 2792, "output_tokens": 288, "total_tokens": 3080}
-{"timestamp": 1772461860.596456, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 137, "total_tokens": 937}
-{"timestamp": 1772461867.5492105, "source": "STRATEGY_CARD", "input_tokens": 685, "output_tokens": 515, "total_tokens": 1200}
-{"timestamp": 1772461870.6313078, "source": "VISUAL_CONTEXT", "input_tokens": 4070, "output_tokens": 288, "total_tokens": 4358}
-{"timestamp": 1772461946.6540112, "source": "DATA_ANCHOR", "input_tokens": 870, "output_tokens": 167, "total_tokens": 1037}
-{"timestamp": 1772461953.149881, "source": "STRATEGY_CARD", "input_tokens": 768, "output_tokens": 350, "total_tokens": 1118}
-{"timestamp": 1772461958.0386968, "source": "VISUAL_CONTEXT", "input_tokens": 4140, "output_tokens": 474, "total_tokens": 4614}
-{"timestamp": 1772462030.6675634, "source": "DATA_ANCHOR", "input_tokens": 988, "output_tokens": 170, "total_tokens": 1158}
-{"timestamp": 1772462039.3997085, "source": "STRATEGY_CARD", "input_tokens": 894, "output_tokens": 553, "total_tokens": 1447}
-{"timestamp": 1772462042.495726, "source": "VISUAL_CONTEXT", "input_tokens": 1936, "output_tokens": 216, "total_tokens": 2152}
-{"timestamp": 1772462539.7136502, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 137, "total_tokens": 937}
-{"timestamp": 1772462547.4237921, "source": "STRATEGY_CARD", "input_tokens": 685, "output_tokens": 641, "total_tokens": 1326}
-{"timestamp": 1772462550.4886522, "source": "VISUAL_CONTEXT", "input_tokens": 3038, "output_tokens": 320, "total_tokens": 3358}
-{"timestamp": 1772462564.8896945, "source": "DATA_ANCHOR", "input_tokens": 1021, "output_tokens": 292, "total_tokens": 1313}
-{"timestamp": 1772462577.5373256, "source": "STRATEGY_CARD", "input_tokens": 1013, "output_tokens": 859, "total_tokens": 1872}
-{"timestamp": 1772462582.307784, "source": "VISUAL_CONTEXT", "input_tokens": 2743, "output_tokens": 475, "total_tokens": 3218}
-{"timestamp": 1772462594.178911, "source": "DATA_ANCHOR", "input_tokens": 1097, "output_tokens": 214, "total_tokens": 1311}
-{"timestamp": 1772462601.8939486, "source": "STRATEGY_CARD", "input_tokens": 1040, "output_tokens": 466, "total_tokens": 1506}
-{"timestamp": 1772462604.646558, "source": "VISUAL_CONTEXT", "input_tokens": 2819, "output_tokens": 174, "total_tokens": 2993}
-{"timestamp": 1772462615.3000457, "source": "DATA_ANCHOR", "input_tokens": 987, "output_tokens": 159, "total_tokens": 1146}
-{"timestamp": 1772462625.6258247, "source": "STRATEGY_CARD", "input_tokens": 882, "output_tokens": 686, "total_tokens": 1568}
-{"timestamp": 1772462652.0573547, "source": "DATA_ANCHOR", "input_tokens": 879, "output_tokens": 189, "total_tokens": 1068}
-{"timestamp": 1772462660.6836355, "source": "STRATEGY_CARD", "input_tokens": 785, "output_tokens": 438, "total_tokens": 1223}
-{"timestamp": 1772462664.3382294, "source": "VISUAL_CONTEXT", "input_tokens": 2601, "output_tokens": 400, "total_tokens": 3001}
-{"timestamp": 1772462677.1482315, "source": "DATA_ANCHOR", "input_tokens": 958, "output_tokens": 183, "total_tokens": 1141}
-{"timestamp": 1772462685.8720064, "source": "STRATEGY_CARD", "input_tokens": 860, "output_tokens": 506, "total_tokens": 1366}
-{"timestamp": 1772462690.775513, "source": "VISUAL_CONTEXT", "input_tokens": 2680, "output_tokens": 494, "total_tokens": 3174}
-{"timestamp": 1772462700.818301, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 145, "total_tokens": 880}
-{"timestamp": 1772462705.4483197, "source": "STRATEGY_CARD", "input_tokens": 608, "output_tokens": 418, "total_tokens": 1026}
-{"timestamp": 1772462709.608989, "source": "VISUAL_CONTEXT", "input_tokens": 1941, "output_tokens": 426, "total_tokens": 2367}
-{"timestamp": 1772462739.4245396, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 137, "total_tokens": 937}
-{"timestamp": 1772462746.3182487, "source": "STRATEGY_CARD", "input_tokens": 685, "output_tokens": 564, "total_tokens": 1249}
-{"timestamp": 1772462749.8314288, "source": "VISUAL_CONTEXT", "input_tokens": 3038, "output_tokens": 369, "total_tokens": 3407}
-{"timestamp": 1772462769.7344887, "source": "DATA_ANCHOR", "input_tokens": 1021, "output_tokens": 281, "total_tokens": 1302}
-{"timestamp": 1772462777.9163814, "source": "STRATEGY_CARD", "input_tokens": 1002, "output_tokens": 505, "total_tokens": 1507}
-{"timestamp": 1772462782.425814, "source": "VISUAL_CONTEXT", "input_tokens": 2743, "output_tokens": 503, "total_tokens": 3246}
-{"timestamp": 1772462794.137243, "source": "DATA_ANCHOR", "input_tokens": 1097, "output_tokens": 218, "total_tokens": 1315}
-{"timestamp": 1772462801.921989, "source": "STRATEGY_CARD", "input_tokens": 1044, "output_tokens": 426, "total_tokens": 1470}
-{"timestamp": 1772466881.0006204, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 208, "total_tokens": 530}
-{"timestamp": 1772466884.059305, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 233, "total_tokens": 555}
-{"timestamp": 1772466885.8376162, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 165, "total_tokens": 487}
-{"timestamp": 1772467113.4226, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 258, "total_tokens": 580}
-{"timestamp": 1772467115.5257201, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 207, "total_tokens": 529}
-{"timestamp": 1772467122.2807834, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 205, "total_tokens": 527}
-{"timestamp": 1772467242.267682, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 199, "total_tokens": 521}
-{"timestamp": 1772467245.3268757, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 282, "total_tokens": 604}
-{"timestamp": 1772467247.8474412, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 219, "total_tokens": 541}
-{"timestamp": 1772467386.4498997, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 201, "total_tokens": 523}
-{"timestamp": 1772467388.7386873, "source": "FAST_SOLVE", "input_tokens": 322, "output_tokens": 254, "total_tokens": 576}
-{"timestamp": 1772467445.3718107, "source": "FAST_SOLVE", "input_tokens": 336, "output_tokens": 294, "total_tokens": 630}
-{"timestamp": 1772467470.8733065, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 122, "total_tokens": 922}
-{"timestamp": 1772467477.1202056, "source": "STRATEGY_CARD", "input_tokens": 672, "output_tokens": 518, "total_tokens": 1190}
-{"timestamp": 1772467479.7981827, "source": "VISUAL_CONTEXT", "input_tokens": 3038, "output_tokens": 243, "total_tokens": 3281}
-{"timestamp": 1772467496.6326413, "source": "DATA_ANCHOR", "input_tokens": 1021, "output_tokens": 300, "total_tokens": 1321}
-{"timestamp": 1772467504.8990514, "source": "STRATEGY_CARD", "input_tokens": 1015, "output_tokens": 479, "total_tokens": 1494}
-{"timestamp": 1772467510.1140687, "source": "VISUAL_CONTEXT", "input_tokens": 2743, "output_tokens": 467, "total_tokens": 3210}
-{"timestamp": 1772467523.895654, "source": "DATA_ANCHOR", "input_tokens": 1096, "output_tokens": 199, "total_tokens": 1295}
-{"timestamp": 1772467532.5578115, "source": "STRATEGY_CARD", "input_tokens": 1030, "output_tokens": 480, "total_tokens": 1510}
-{"timestamp": 1772467535.2298443, "source": "VISUAL_CONTEXT", "input_tokens": 2818, "output_tokens": 189, "total_tokens": 3007}
-{"timestamp": 1772467546.9677515, "source": "DATA_ANCHOR", "input_tokens": 987, "output_tokens": 165, "total_tokens": 1152}
-{"timestamp": 1772467557.4943, "source": "STRATEGY_CARD", "input_tokens": 884, "output_tokens": 762, "total_tokens": 1646}
-{"timestamp": 1772467560.0143409, "source": "VISUAL_CONTEXT", "input_tokens": 2709, "output_tokens": 148, "total_tokens": 2857}
-{"timestamp": 1772467571.4213662, "source": "DATA_ANCHOR", "input_tokens": 885, "output_tokens": 247, "total_tokens": 1132}
-{"timestamp": 1772467578.7398057, "source": "STRATEGY_CARD", "input_tokens": 843, "output_tokens": 476, "total_tokens": 1319}
-{"timestamp": 1772467582.9472864, "source": "VISUAL_CONTEXT", "input_tokens": 2607, "output_tokens": 467, "total_tokens": 3074}
-{"timestamp": 1772467594.978281, "source": "DATA_ANCHOR", "input_tokens": 961, "output_tokens": 179, "total_tokens": 1140}
-{"timestamp": 1772467603.0909598, "source": "STRATEGY_CARD", "input_tokens": 861, "output_tokens": 516, "total_tokens": 1377}
-{"timestamp": 1772467607.4696283, "source": "VISUAL_CONTEXT", "input_tokens": 2683, "output_tokens": 490, "total_tokens": 3173}
-{"timestamp": 1772467616.4018836, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 145, "total_tokens": 880}
-{"timestamp": 1772467622.540132, "source": "STRATEGY_CARD", "input_tokens": 608, "output_tokens": 424, "total_tokens": 1032}
-{"timestamp": 1772467626.7393212, "source": "VISUAL_CONTEXT", "input_tokens": 1941, "output_tokens": 414, "total_tokens": 2355}
-{"timestamp": 1772467636.510028, "source": "DATA_ANCHOR", "input_tokens": 820, "output_tokens": 142, "total_tokens": 962}
-{"timestamp": 1772467643.7351146, "source": "STRATEGY_CARD", "input_tokens": 702, "output_tokens": 515, "total_tokens": 1217}
-{"timestamp": 1772467658.203288, "source": "VISUAL_CONTEXT", "input_tokens": 2542, "output_tokens": 462, "total_tokens": 3004}
-{"timestamp": 1772467668.970126, "source": "DATA_ANCHOR", "input_tokens": 806, "output_tokens": 116, "total_tokens": 922}
-{"timestamp": 1772467676.2274504, "source": "STRATEGY_CARD", "input_tokens": 672, "output_tokens": 515, "total_tokens": 1187}
-{"timestamp": 1772467679.6852927, "source": "VISUAL_CONTEXT", "input_tokens": 2528, "output_tokens": 319, "total_tokens": 2847}
-{"timestamp": 1772467691.1403818, "source": "DATA_ANCHOR", "input_tokens": 1070, "output_tokens": 146, "total_tokens": 1216}
-{"timestamp": 1772467702.0560367, "source": "STRATEGY_CARD", "input_tokens": 964, "output_tokens": 500, "total_tokens": 1464}
-{"timestamp": 1772467705.6291835, "source": "VISUAL_CONTEXT", "input_tokens": 2792, "output_tokens": 293, "total_tokens": 3085}
-{"timestamp": 1772467912.07788, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 137, "total_tokens": 937}
-{"timestamp": 1772467918.4963973, "source": "STRATEGY_CARD", "input_tokens": 685, "output_tokens": 492, "total_tokens": 1177}
-{"timestamp": 1772467921.5811603, "source": "VISUAL_CONTEXT", "input_tokens": 3038, "output_tokens": 326, "total_tokens": 3364}
-{"timestamp": 1772467934.0955198, "source": "DATA_ANCHOR", "input_tokens": 1021, "output_tokens": 252, "total_tokens": 1273}
-{"timestamp": 1772467941.8130915, "source": "STRATEGY_CARD", "input_tokens": 979, "output_tokens": 444, "total_tokens": 1423}
-{"timestamp": 1772467946.0772188, "source": "VISUAL_CONTEXT", "input_tokens": 2743, "output_tokens": 404, "total_tokens": 3147}
-{"timestamp": 1772467955.4272263, "source": "DATA_ANCHOR", "input_tokens": 1097, "output_tokens": 218, "total_tokens": 1315}
-{"timestamp": 1772467964.2707682, "source": "VISUAL_CONTEXT", "input_tokens": 2819, "output_tokens": 157, "total_tokens": 2976}
-{"timestamp": 1772467973.689187, "source": "DATA_ANCHOR", "input_tokens": 987, "output_tokens": 165, "total_tokens": 1152}
-{"timestamp": 1772467982.8190293, "source": "STRATEGY_CARD", "input_tokens": 884, "output_tokens": 637, "total_tokens": 1521}
-{"timestamp": 1772467986.0167992, "source": "VISUAL_CONTEXT", "input_tokens": 2709, "output_tokens": 187, "total_tokens": 2896}
-{"timestamp": 1772467993.962867, "source": "DATA_ANCHOR", "input_tokens": 879, "output_tokens": 219, "total_tokens": 1098}
-{"timestamp": 1772468002.964662, "source": "STRATEGY_CARD", "input_tokens": 811, "output_tokens": 455, "total_tokens": 1266}
-{"timestamp": 1772468007.553417, "source": "VISUAL_CONTEXT", "input_tokens": 2601, "output_tokens": 418, "total_tokens": 3019}
-{"timestamp": 1772468016.822634, "source": "DATA_ANCHOR", "input_tokens": 961, "output_tokens": 196, "total_tokens": 1157}
-{"timestamp": 1772468024.0042646, "source": "STRATEGY_CARD", "input_tokens": 865, "output_tokens": 521, "total_tokens": 1386}
-{"timestamp": 1772468028.2893112, "source": "VISUAL_CONTEXT", "input_tokens": 2683, "output_tokens": 505, "total_tokens": 3188}
-{"timestamp": 1772468039.5730982, "source": "DATA_ANCHOR", "input_tokens": 820, "output_tokens": 142, "total_tokens": 962}
-{"timestamp": 1772468048.1350377, "source": "STRATEGY_CARD", "input_tokens": 702, "output_tokens": 513, "total_tokens": 1215}
-{"timestamp": 1772468052.0541372, "source": "VISUAL_CONTEXT", "input_tokens": 2542, "output_tokens": 505, "total_tokens": 3047}
-{"timestamp": 1772468058.4124908, "source": "DATA_ANCHOR", "input_tokens": 806, "output_tokens": 121, "total_tokens": 927}
-{"timestamp": 1772468066.8000128, "source": "STRATEGY_CARD", "input_tokens": 677, "output_tokens": 545, "total_tokens": 1222}
-{"timestamp": 1772468070.2122788, "source": "VISUAL_CONTEXT", "input_tokens": 2528, "output_tokens": 281, "total_tokens": 2809}
-{"timestamp": 1772468078.3782697, "source": "DATA_ANCHOR", "input_tokens": 1070, "output_tokens": 146, "total_tokens": 1216}
-{"timestamp": 1772468086.9785, "source": "STRATEGY_CARD", "input_tokens": 964, "output_tokens": 468, "total_tokens": 1432}
-{"timestamp": 1772468090.4883726, "source": "VISUAL_CONTEXT", "input_tokens": 2792, "output_tokens": 292, "total_tokens": 3084}
-{"timestamp": 1772468195.6654346, "source": "DATA_ANCHOR", "input_tokens": 801, "output_tokens": 122, "total_tokens": 923}
-{"timestamp": 1772468202.83841, "source": "STRATEGY_CARD", "input_tokens": 672, "output_tokens": 513, "total_tokens": 1185}
-{"timestamp": 1772468206.669965, "source": "VISUAL_CONTEXT", "input_tokens": 3039, "output_tokens": 343, "total_tokens": 3382}
-{"timestamp": 1772468286.8155563, "source": "DATA_ANCHOR", "input_tokens": 801, "output_tokens": 122, "total_tokens": 923}
-{"timestamp": 1772468292.1784837, "source": "STRATEGY_CARD", "input_tokens": 672, "output_tokens": 453, "total_tokens": 1125}
-{"timestamp": 1772468295.260981, "source": "VISUAL_CONTEXT", "input_tokens": 3039, "output_tokens": 293, "total_tokens": 3332}
-{"timestamp": 1772468310.4256809, "source": "DATA_ANCHOR", "input_tokens": 958, "output_tokens": 226, "total_tokens": 1184}
-{"timestamp": 1772468395.7564702, "source": "DATA_ANCHOR", "input_tokens": 958, "output_tokens": 226, "total_tokens": 1184}
-{"timestamp": 1772468403.8118541, "source": "STRATEGY_CARD", "input_tokens": 893, "output_tokens": 409, "total_tokens": 1302}
-{"timestamp": 1772468408.5529542, "source": "VISUAL_CONTEXT", "input_tokens": 2680, "output_tokens": 482, "total_tokens": 3162}
-{"timestamp": 1772468542.1859858, "source": "DATA_ANCHOR", "input_tokens": 958, "output_tokens": 226, "total_tokens": 1184}
-{"timestamp": 1772468551.9351966, "source": "STRATEGY_CARD", "input_tokens": 893, "output_tokens": 638, "total_tokens": 1531}
-{"timestamp": 1772468555.933325, "source": "VISUAL_CONTEXT", "input_tokens": 2680, "output_tokens": 421, "total_tokens": 3101}
-{"timestamp": 1772468759.293591, "source": "DATA_ANCHOR", "input_tokens": 1021, "output_tokens": 259, "total_tokens": 1280}
-{"timestamp": 1772468767.9944205, "source": "STRATEGY_CARD", "input_tokens": 986, "output_tokens": 539, "total_tokens": 1525}
-{"timestamp": 1772468772.0959065, "source": "VISUAL_CONTEXT", "input_tokens": 2743, "output_tokens": 447, "total_tokens": 3190}
-{"timestamp": 1772469235.2688422, "source": "DATA_ANCHOR", "input_tokens": 865, "output_tokens": 167, "total_tokens": 1032}
-{"timestamp": 1772469243.602278, "source": "STRATEGY_CARD", "input_tokens": 763, "output_tokens": 536, "total_tokens": 1299}
-{"timestamp": 1772469248.1568465, "source": "VISUAL_CONTEXT", "input_tokens": 3619, "output_tokens": 447, "total_tokens": 4066}
-{"timestamp": 1772469360.9032478, "source": "DATA_ANCHOR", "input_tokens": 1027, "output_tokens": 167, "total_tokens": 1194}
-{"timestamp": 1772469370.0509284, "source": "STRATEGY_CARD", "input_tokens": 930, "output_tokens": 539, "total_tokens": 1469}
-{"timestamp": 1772469373.0119076, "source": "VISUAL_CONTEXT", "input_tokens": 2749, "output_tokens": 189, "total_tokens": 2938}
-{"timestamp": 1772469522.7258227, "source": "DATA_ANCHOR", "input_tokens": 818, "output_tokens": 137, "total_tokens": 955}
-{"timestamp": 1772469529.897679, "source": "STRATEGY_CARD", "input_tokens": 703, "output_tokens": 554, "total_tokens": 1257}
-{"timestamp": 1772469533.4987423, "source": "VISUAL_CONTEXT", "input_tokens": 3572, "output_tokens": 280, "total_tokens": 3852}
-{"timestamp": 1772469617.2176228, "source": "DATA_ANCHOR", "input_tokens": 1062, "output_tokens": 207, "total_tokens": 1269}
-{"timestamp": 1772469626.019789, "source": "STRATEGY_CARD", "input_tokens": 1007, "output_tokens": 520, "total_tokens": 1527}
-{"timestamp": 1772469629.205492, "source": "VISUAL_CONTEXT", "input_tokens": 2784, "output_tokens": 169, "total_tokens": 2953}
-{"timestamp": 1772485183.2302728, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 137, "total_tokens": 937}
-{"timestamp": 1772485189.5890636, "source": "STRATEGY_CARD", "input_tokens": 685, "output_tokens": 518, "total_tokens": 1203}
-{"timestamp": 1772485192.8065999, "source": "VISUAL_CONTEXT", "input_tokens": 3036, "output_tokens": 319, "total_tokens": 3355}
-{"timestamp": 1772485207.581059, "source": "DATA_ANCHOR", "input_tokens": 958, "output_tokens": 226, "total_tokens": 1184}
-{"timestamp": 1772485216.2656436, "source": "STRATEGY_CARD", "input_tokens": 893, "output_tokens": 494, "total_tokens": 1387}
-{"timestamp": 1772485220.5659127, "source": "VISUAL_CONTEXT", "input_tokens": 2678, "output_tokens": 418, "total_tokens": 3096}
-{"timestamp": 1772485245.854311, "source": "DATA_ANCHOR", "input_tokens": 1097, "output_tokens": 218, "total_tokens": 1315}
-{"timestamp": 1772485253.6684313, "source": "STRATEGY_CARD", "input_tokens": 1044, "output_tokens": 419, "total_tokens": 1463}
-{"timestamp": 1772485256.7859843, "source": "VISUAL_CONTEXT", "input_tokens": 2817, "output_tokens": 215, "total_tokens": 3032}
-{"timestamp": 1772485275.2060962, "source": "DATA_ANCHOR", "input_tokens": 987, "output_tokens": 165, "total_tokens": 1152}
-{"timestamp": 1772485284.440505, "source": "STRATEGY_CARD", "input_tokens": 884, "output_tokens": 732, "total_tokens": 1616}
-{"timestamp": 1772485287.6722121, "source": "VISUAL_CONTEXT", "input_tokens": 2707, "output_tokens": 208, "total_tokens": 2915}
-{"timestamp": 1772485307.9823356, "source": "DATA_ANCHOR", "input_tokens": 885, "output_tokens": 187, "total_tokens": 1072}
-{"timestamp": 1772485316.2019367, "source": "STRATEGY_CARD", "input_tokens": 793, "output_tokens": 480, "total_tokens": 1273}
-{"timestamp": 1772485320.294281, "source": "VISUAL_CONTEXT", "input_tokens": 2605, "output_tokens": 473, "total_tokens": 3078}
-{"timestamp": 1772485343.6172109, "source": "DATA_ANCHOR", "input_tokens": 958, "output_tokens": 183, "total_tokens": 1141}
-{"timestamp": 1772485351.6756468, "source": "STRATEGY_CARD", "input_tokens": 860, "output_tokens": 499, "total_tokens": 1359}
-{"timestamp": 1772485356.6483955, "source": "VISUAL_CONTEXT", "input_tokens": 2678, "output_tokens": 494, "total_tokens": 3172}
-{"timestamp": 1772485374.2783668, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 145, "total_tokens": 880}
-{"timestamp": 1772485380.2267928, "source": "STRATEGY_CARD", "input_tokens": 608, "output_tokens": 547, "total_tokens": 1155}
-{"timestamp": 1772485383.960181, "source": "VISUAL_CONTEXT", "input_tokens": 1939, "output_tokens": 402, "total_tokens": 2341}
-{"timestamp": 1772485394.4049034, "source": "DATA_ANCHOR", "input_tokens": 820, "output_tokens": 142, "total_tokens": 962}
-{"timestamp": 1772485400.3687067, "source": "STRATEGY_CARD", "input_tokens": 702, "output_tokens": 436, "total_tokens": 1138}
-{"timestamp": 1772485405.307158, "source": "VISUAL_CONTEXT", "input_tokens": 2540, "output_tokens": 512, "total_tokens": 3052}
-{"timestamp": 1772485418.8938198, "source": "DATA_ANCHOR", "input_tokens": 806, "output_tokens": 116, "total_tokens": 922}
-{"timestamp": 1772485424.3965504, "source": "STRATEGY_CARD", "input_tokens": 672, "output_tokens": 433, "total_tokens": 1105}
-{"timestamp": 1772485427.9296653, "source": "VISUAL_CONTEXT", "input_tokens": 2526, "output_tokens": 328, "total_tokens": 2854}
-{"timestamp": 1772485440.2612922, "source": "DATA_ANCHOR", "input_tokens": 1069, "output_tokens": 143, "total_tokens": 1212}
-{"timestamp": 1772485585.9193878, "source": "DATA_ANCHOR", "input_tokens": 801, "output_tokens": 122, "total_tokens": 923}
-{"timestamp": 1772485592.0427706, "source": "STRATEGY_CARD", "input_tokens": 672, "output_tokens": 440, "total_tokens": 1112}
-{"timestamp": 1772485595.5109873, "source": "VISUAL_CONTEXT", "input_tokens": 3037, "output_tokens": 313, "total_tokens": 3350}
-{"timestamp": 1772485612.5389276, "source": "DATA_ANCHOR", "input_tokens": 1021, "output_tokens": 251, "total_tokens": 1272}
-{"timestamp": 1772485621.573903, "source": "STRATEGY_CARD", "input_tokens": 980, "output_tokens": 532, "total_tokens": 1512}
-{"timestamp": 1772485626.6581926, "source": "VISUAL_CONTEXT", "input_tokens": 2741, "output_tokens": 480, "total_tokens": 3221}
-{"timestamp": 1772485653.7057736, "source": "DATA_ANCHOR", "input_tokens": 1097, "output_tokens": 217, "total_tokens": 1314}
-{"timestamp": 1772485661.6138825, "source": "STRATEGY_CARD", "input_tokens": 1043, "output_tokens": 433, "total_tokens": 1476}
-{"timestamp": 1772485664.783177, "source": "VISUAL_CONTEXT", "input_tokens": 2817, "output_tokens": 207, "total_tokens": 3024}
-{"timestamp": 1772485684.7185278, "source": "DATA_ANCHOR", "input_tokens": 986, "output_tokens": 167, "total_tokens": 1153}
-{"timestamp": 1772485695.572945, "source": "STRATEGY_CARD", "input_tokens": 885, "output_tokens": 676, "total_tokens": 1561}
-{"timestamp": 1772485699.2083218, "source": "VISUAL_CONTEXT", "input_tokens": 2706, "output_tokens": 217, "total_tokens": 2923}
-{"timestamp": 1772485728.386018, "source": "DATA_ANCHOR", "input_tokens": 885, "output_tokens": 252, "total_tokens": 1137}
-{"timestamp": 1772485736.582095, "source": "STRATEGY_CARD", "input_tokens": 848, "output_tokens": 427, "total_tokens": 1275}
-{"timestamp": 1772485739.930002, "source": "VISUAL_CONTEXT", "input_tokens": 2605, "output_tokens": 408, "total_tokens": 3013}
-{"timestamp": 1772485752.2089307, "source": "DATA_ANCHOR", "input_tokens": 961, "output_tokens": 166, "total_tokens": 1127}
-{"timestamp": 1772485761.0019224, "source": "STRATEGY_CARD", "input_tokens": 854, "output_tokens": 628, "total_tokens": 1482}
-{"timestamp": 1772485764.9599419, "source": "VISUAL_CONTEXT", "input_tokens": 2681, "output_tokens": 516, "total_tokens": 3197}
-{"timestamp": 1772485786.1330385, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 145, "total_tokens": 880}
-{"timestamp": 1772485791.539915, "source": "STRATEGY_CARD", "input_tokens": 608, "output_tokens": 370, "total_tokens": 978}
-{"timestamp": 1772485794.6591904, "source": "VISUAL_CONTEXT", "input_tokens": 1939, "output_tokens": 384, "total_tokens": 2323}
-{"timestamp": 1772485807.1274064, "source": "DATA_ANCHOR", "input_tokens": 820, "output_tokens": 142, "total_tokens": 962}
-{"timestamp": 1772485811.990286, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 137, "total_tokens": 937}
-{"timestamp": 1772485814.7574973, "source": "STRATEGY_CARD", "input_tokens": 702, "output_tokens": 528, "total_tokens": 1230}
-{"timestamp": 1772485818.4967325, "source": "VISUAL_CONTEXT", "input_tokens": 2540, "output_tokens": 482, "total_tokens": 3022}
-{"timestamp": 1772485818.9622734, "source": "STRATEGY_CARD", "input_tokens": 685, "output_tokens": 511, "total_tokens": 1196}
-{"timestamp": 1772485822.0089593, "source": "VISUAL_CONTEXT", "input_tokens": 3036, "output_tokens": 319, "total_tokens": 3355}
-{"timestamp": 1772485834.1687572, "source": "DATA_ANCHOR", "input_tokens": 806, "output_tokens": 121, "total_tokens": 927}
-{"timestamp": 1772485840.2194378, "source": "STRATEGY_CARD", "input_tokens": 677, "output_tokens": 458, "total_tokens": 1135}
-{"timestamp": 1772485843.6734717, "source": "VISUAL_CONTEXT", "input_tokens": 2526, "output_tokens": 303, "total_tokens": 2829}
-{"timestamp": 1772485847.6486056, "source": "DATA_ANCHOR", "input_tokens": 1021, "output_tokens": 248, "total_tokens": 1269}
-{"timestamp": 1772485855.5825932, "source": "STRATEGY_CARD", "input_tokens": 977, "output_tokens": 434, "total_tokens": 1411}
-{"timestamp": 1772485856.5082326, "source": "DATA_ANCHOR", "input_tokens": 1070, "output_tokens": 146, "total_tokens": 1216}
-{"timestamp": 1772485860.1655931, "source": "VISUAL_CONTEXT", "input_tokens": 2741, "output_tokens": 448, "total_tokens": 3189}
-{"timestamp": 1772485866.9292593, "source": "STRATEGY_CARD", "input_tokens": 964, "output_tokens": 644, "total_tokens": 1608}
-{"timestamp": 1772485870.2073956, "source": "VISUAL_CONTEXT", "input_tokens": 2790, "output_tokens": 247, "total_tokens": 3037}
-{"timestamp": 1772485885.3422077, "source": "DATA_ANCHOR", "input_tokens": 1097, "output_tokens": 217, "total_tokens": 1314}
-{"timestamp": 1772485893.7301285, "source": "STRATEGY_CARD", "input_tokens": 1043, "output_tokens": 502, "total_tokens": 1545}
-{"timestamp": 1772485896.5130208, "source": "VISUAL_CONTEXT", "input_tokens": 2817, "output_tokens": 191, "total_tokens": 3008}
-{"timestamp": 1772485915.012682, "source": "DATA_ANCHOR", "input_tokens": 987, "output_tokens": 164, "total_tokens": 1151}
-{"timestamp": 1772485923.108903, "source": "STRATEGY_CARD", "input_tokens": 884, "output_tokens": 583, "total_tokens": 1467}
-{"timestamp": 1772485926.0008333, "source": "VISUAL_CONTEXT", "input_tokens": 2707, "output_tokens": 174, "total_tokens": 2881}
-{"timestamp": 1772485948.0437536, "source": "DATA_ANCHOR", "input_tokens": 879, "output_tokens": 203, "total_tokens": 1082}
-{"timestamp": 1772485955.9826658, "source": "STRATEGY_CARD", "input_tokens": 793, "output_tokens": 502, "total_tokens": 1295}
-{"timestamp": 1772485959.3732579, "source": "VISUAL_CONTEXT", "input_tokens": 2599, "output_tokens": 405, "total_tokens": 3004}
-{"timestamp": 1772485982.2107606, "source": "DATA_ANCHOR", "input_tokens": 961, "output_tokens": 171, "total_tokens": 1132}
-{"timestamp": 1772485989.0937188, "source": "STRATEGY_CARD", "input_tokens": 857, "output_tokens": 444, "total_tokens": 1301}
-{"timestamp": 1772485993.0703344, "source": "VISUAL_CONTEXT", "input_tokens": 2681, "output_tokens": 513, "total_tokens": 3194}
-{"timestamp": 1772486009.666652, "source": "DATA_ANCHOR", "input_tokens": 735, "output_tokens": 145, "total_tokens": 880}
-{"timestamp": 1772486015.1491933, "source": "STRATEGY_CARD", "input_tokens": 608, "output_tokens": 404, "total_tokens": 1012}
-{"timestamp": 1772486018.4094615, "source": "VISUAL_CONTEXT", "input_tokens": 1939, "output_tokens": 426, "total_tokens": 2365}
-{"timestamp": 1772486029.657292, "source": "DATA_ANCHOR", "input_tokens": 820, "output_tokens": 142, "total_tokens": 962}
-{"timestamp": 1772486036.4163175, "source": "STRATEGY_CARD", "input_tokens": 702, "output_tokens": 399, "total_tokens": 1101}
-{"timestamp": 1772486040.1720483, "source": "VISUAL_CONTEXT", "input_tokens": 2540, "output_tokens": 457, "total_tokens": 2997}
-{"timestamp": 1772486635.5980432, "source": "DATA_ANCHOR", "input_tokens": 887, "output_tokens": 167, "total_tokens": 1054}
-{"timestamp": 1772486642.3789024, "source": "STRATEGY_CARD", "input_tokens": 785, "output_tokens": 548, "total_tokens": 1333}
-{"timestamp": 1772486646.2155004, "source": "VISUAL_CONTEXT", "input_tokens": 3639, "output_tokens": 425, "total_tokens": 4064}
-{"timestamp": 1772487116.4485707, "source": "DATA_ANCHOR", "input_tokens": 800, "output_tokens": 137, "total_tokens": 937}
-{"timestamp": 1772487122.3789392, "source": "STRATEGY_CARD", "input_tokens": 685, "output_tokens": 480, "total_tokens": 1165}
-{"timestamp": 1772487125.3379195, "source": "VISUAL_CONTEXT", "input_tokens": 3036, "output_tokens": 302, "total_tokens": 3338}
-{"timestamp": 1772487151.3065927, "source": "DATA_ANCHOR", "input_tokens": 958, "output_tokens": 247, "total_tokens": 1205}
-{"timestamp": 1772487158.8037279, "source": "STRATEGY_CARD", "input_tokens": 913, "output_tokens": 492, "total_tokens": 1405}
-{"timestamp": 1772487162.979226, "source": "VISUAL_CONTEXT", "input_tokens": 2678, "output_tokens": 485, "total_tokens": 3163}
-{"timestamp": 1772487665.330303, "source": "DATA_ANCHOR", "input_tokens": 870, "output_tokens": 172, "total_tokens": 1042}
-{"timestamp": 1772487673.3399823, "source": "STRATEGY_CARD", "input_tokens": 771, "output_tokens": 643, "total_tokens": 1414}
-{"timestamp": 1772487677.654737, "source": "VISUAL_CONTEXT", "input_tokens": 3622, "output_tokens": 468, "total_tokens": 4090}
-{"timestamp": 1772488477.4968681, "source": "DATA_ANCHOR", "input_tokens": 914, "output_tokens": 172, "total_tokens": 1086}
-{"timestamp": 1772488485.2931952, "source": "STRATEGY_CARD", "input_tokens": 815, "output_tokens": 533, "total_tokens": 1348}
-{"timestamp": 1772488489.0975235, "source": "VISUAL_CONTEXT", "input_tokens": 3666, "output_tokens": 382, "total_tokens": 4048}
-{"timestamp": 1772488778.68537, "source": "DATA_ANCHOR", "input_tokens": 897, "output_tokens": 172, "total_tokens": 1069}
-{"timestamp": 1772488786.35335, "source": "STRATEGY_CARD", "input_tokens": 798, "output_tokens": 556, "total_tokens": 1354}
-{"timestamp": 1772488790.9904838, "source": "VISUAL_CONTEXT", "input_tokens": 3133, "output_tokens": 432, "total_tokens": 3565}
-{"timestamp": 1772489319.2270813, "source": "DATA_ANCHOR", "input_tokens": 859, "output_tokens": 185, "total_tokens": 1044}
-{"timestamp": 1772489325.9153175, "source": "STRATEGY_CARD", "input_tokens": 807, "output_tokens": 509, "total_tokens": 1316}
-{"timestamp": 1772489329.981915, "source": "VISUAL_CONTEXT", "input_tokens": 3654, "output_tokens": 488, "total_tokens": 4142}
-{"timestamp": 1772525610.316064, "source": "DATA_ANCHOR", "input_tokens": 848, "output_tokens": 172, "total_tokens": 1020}
-{"timestamp": 1772525616.968301, "source": "STRATEGY_CARD", "input_tokens": 792, "output_tokens": 452, "total_tokens": 1244}
-{"timestamp": 1772525621.2748299, "source": "VISUAL_CONTEXT", "input_tokens": 4159, "output_tokens": 469, "total_tokens": 4628}
-{"timestamp": 1772527036.1353092, "source": "DATA_ANCHOR", "input_tokens": 846, "output_tokens": 172, "total_tokens": 1018}
-{"timestamp": 1772527042.318808, "source": "STRATEGY_CARD", "input_tokens": 790, "output_tokens": 444, "total_tokens": 1234}
-{"timestamp": 1772527046.5007427, "source": "VISUAL_CONTEXT", "input_tokens": 3641, "output_tokens": 409, "total_tokens": 4050}
-{"timestamp": 1772527931.7267053, "source": "DATA_ANCHOR", "input_tokens": 844, "output_tokens": 167, "total_tokens": 1011}
-{"timestamp": 1772527939.1749082, "source": "STRATEGY_CARD", "input_tokens": 785, "output_tokens": 526, "total_tokens": 1311}
-{"timestamp": 1772527943.5192726, "source": "VISUAL_CONTEXT", "input_tokens": 4155, "output_tokens": 466, "total_tokens": 4621}
-{"timestamp": 1772528408.8622217, "source": "DATA_ANCHOR", "input_tokens": 864, "output_tokens": 190, "total_tokens": 1054}
-{"timestamp": 1772528418.2410874, "source": "STRATEGY_CARD", "input_tokens": 815, "output_tokens": 671, "total_tokens": 1486}
-{"timestamp": 1772528423.1073465, "source": "VISUAL_CONTEXT", "input_tokens": 3659, "output_tokens": 430, "total_tokens": 4089}
-{"timestamp": 1772528582.1272619, "source": "DATA_ANCHOR", "input_tokens": 992, "output_tokens": 202, "total_tokens": 1194}
-{"timestamp": 1772528592.6260493, "source": "STRATEGY_CARD", "input_tokens": 962, "output_tokens": 600, "total_tokens": 1562}
-{"timestamp": 1772528595.5357127, "source": "VISUAL_CONTEXT", "input_tokens": 2755, "output_tokens": 203, "total_tokens": 2958}
-{"timestamp": 1772528715.1906927, "source": "DATA_ANCHOR", "input_tokens": 757, "output_tokens": 137, "total_tokens": 894}
-{"timestamp": 1772528721.3918903, "source": "STRATEGY_CARD", "input_tokens": 685, "output_tokens": 485, "total_tokens": 1170}
-{"timestamp": 1772528724.385049, "source": "VISUAL_CONTEXT", "input_tokens": 3294, "output_tokens": 302, "total_tokens": 3596}
-{"timestamp": 1772532180.0935066, "source": "DATA_ANCHOR", "input_tokens": 876, "output_tokens": 172, "total_tokens": 1048}
-{"timestamp": 1772532187.8401692, "source": "STRATEGY_CARD", "input_tokens": 820, "output_tokens": 610, "total_tokens": 1430}
-{"timestamp": 1772532192.8185909, "source": "VISUAL_CONTEXT", "input_tokens": 3671, "output_tokens": 452, "total_tokens": 4123}
-{"timestamp": 1772533720.033917, "source": "DATA_ANCHOR", "input_tokens": 869, "output_tokens": 208, "total_tokens": 1077}
-{"timestamp": 1772533727.5318532, "source": "STRATEGY_CARD", "input_tokens": 831, "output_tokens": 516, "total_tokens": 1347}
-{"timestamp": 1772533731.702715, "source": "VISUAL_CONTEXT", "input_tokens": 3664, "output_tokens": 451, "total_tokens": 4115}
-{"timestamp": 1772533840.7518783, "source": "DATA_ANCHOR", "input_tokens": 946, "output_tokens": 157, "total_tokens": 1103}
-{"timestamp": 1772533848.6447835, "source": "STRATEGY_CARD", "input_tokens": 883, "output_tokens": 535, "total_tokens": 1418}
-{"timestamp": 1772533851.486597, "source": "VISUAL_CONTEXT", "input_tokens": 2709, "output_tokens": 182, "total_tokens": 2891}
-{"timestamp": 1772534929.7319982, "source": "DATA_ANCHOR", "input_tokens": 868, "output_tokens": 172, "total_tokens": 1040}
-{"timestamp": 1772534936.900191, "source": "STRATEGY_CARD", "input_tokens": 812, "output_tokens": 469, "total_tokens": 1281}
-{"timestamp": 1772534941.459784, "source": "VISUAL_CONTEXT", "input_tokens": 3147, "output_tokens": 531, "total_tokens": 3678}
-{"timestamp": 1772537926.7696521, "source": "DATA_ANCHOR", "input_tokens": 869, "output_tokens": 172, "total_tokens": 1041}
-{"timestamp": 1772537933.4558806, "source": "STRATEGY_CARD", "input_tokens": 813, "output_tokens": 505, "total_tokens": 1318}
-{"timestamp": 1772537937.50332, "source": "VISUAL_CONTEXT", "input_tokens": 3664, "output_tokens": 425, "total_tokens": 4089}
-{"timestamp": 1772538104.0048294, "source": "DATA_ANCHOR", "input_tokens": 1012, "output_tokens": 164, "total_tokens": 1176}
-{"timestamp": 1772538115.7428837, "source": "STRATEGY_CARD", "input_tokens": 954, "output_tokens": 510, "total_tokens": 1464}
-{"timestamp": 1772538118.3495588, "source": "VISUAL_CONTEXT", "input_tokens": 2775, "output_tokens": 221, "total_tokens": 2996}
-{"timestamp": 1772541366.2422204, "source": "DATA_ANCHOR", "input_tokens": 953, "output_tokens": 179, "total_tokens": 1132}
-{"timestamp": 1772541376.4372227, "source": "STRATEGY_CARD", "input_tokens": 904, "output_tokens": 632, "total_tokens": 1536}
-{"timestamp": 1772541379.1485803, "source": "VISUAL_CONTEXT", "input_tokens": 2716, "output_tokens": 144, "total_tokens": 2860}
-{"timestamp": 1772542831.0551198, "source": "DATA_ANCHOR", "input_tokens": 951, "output_tokens": 150, "total_tokens": 1101}
-{"timestamp": 1772542840.8628507, "source": "STRATEGY_CARD", "input_tokens": 888, "output_tokens": 553, "total_tokens": 1441}
-{"timestamp": 1772542843.755567, "source": "VISUAL_CONTEXT", "input_tokens": 2714, "output_tokens": 174, "total_tokens": 2888}
-{"timestamp": 1772543005.5080514, "source": "DATA_ANCHOR", "input_tokens": 758, "output_tokens": 132, "total_tokens": 890}
-{"timestamp": 1772543010.4517903, "source": "STRATEGY_CARD", "input_tokens": 686, "output_tokens": 336, "total_tokens": 1022}
-{"timestamp": 1772543013.4002023, "source": "VISUAL_CONTEXT", "input_tokens": 3553, "output_tokens": 253, "total_tokens": 3806}
-{"timestamp": 1772543134.844835, "source": "DATA_ANCHOR", "input_tokens": 861, "output_tokens": 198, "total_tokens": 1059}
-{"timestamp": 1772543141.8236444, "source": "STRATEGY_CARD", "input_tokens": 822, "output_tokens": 424, "total_tokens": 1246}
-{"timestamp": 1772543146.5085928, "source": "VISUAL_CONTEXT", "input_tokens": 2624, "output_tokens": 534, "total_tokens": 3158}
-{"timestamp": 1772544490.7731538, "source": "DATA_ANCHOR", "input_tokens": 869, "output_tokens": 177, "total_tokens": 1046}
-{"timestamp": 1772544500.0224814, "source": "STRATEGY_CARD", "input_tokens": 844, "output_tokens": 422, "total_tokens": 1266}
-{"timestamp": 1772544503.1659286, "source": "VISUAL_CONTEXT", "input_tokens": 3664, "output_tokens": 202, "total_tokens": 3866}
-{"timestamp": 1772545427.460856, "source": "DATA_ANCHOR", "input_tokens": 848, "output_tokens": 156, "total_tokens": 1004}
-{"timestamp": 1772545435.6357722, "source": "STRATEGY_CARD", "input_tokens": 804, "output_tokens": 416, "total_tokens": 1220}
-{"timestamp": 1772545438.8905444, "source": "VISUAL_CONTEXT", "input_tokens": 3643, "output_tokens": 157, "total_tokens": 3800}
-{"timestamp": 1772546777.1015165, "source": "DATA_ANCHOR", "input_tokens": 890, "output_tokens": 201, "total_tokens": 1091}
-{"timestamp": 1772546785.298141, "source": "STRATEGY_CARD", "input_tokens": 877, "output_tokens": 418, "total_tokens": 1295}
-{"timestamp": 1772546788.1834977, "source": "VISUAL_CONTEXT", "input_tokens": 3685, "output_tokens": 147, "total_tokens": 3832}
-{"timestamp": 1772547718.488458, "source": "DATA_ANCHOR", "input_tokens": 864, "output_tokens": 173, "total_tokens": 1037}
-{"timestamp": 1772547727.083963, "source": "STRATEGY_CARD", "input_tokens": 835, "output_tokens": 473, "total_tokens": 1308}
-{"timestamp": 1772547730.0852747, "source": "VISUAL_CONTEXT", "input_tokens": 3143, "output_tokens": 168, "total_tokens": 3311}
-{"timestamp": 1772549499.1089675, "source": "STRATEGY_CARD", "input_tokens": 721, "output_tokens": 486, "total_tokens": 1207}
-{"timestamp": 1772549502.145296, "source": "VISUAL_CONTEXT", "input_tokens": 2655, "output_tokens": 172, "total_tokens": 2827}
-{"timestamp": 1772550707.073155, "source": "STRATEGY_CARD", "input_tokens": 721, "output_tokens": 469, "total_tokens": 1190}
-{"timestamp": 1772550710.0436745, "source": "VISUAL_CONTEXT", "input_tokens": 2655, "output_tokens": 139, "total_tokens": 2794}
-{"timestamp": 1772559294.1917741, "source": "STRATEGY_CARD", "input_tokens": 864, "output_tokens": 446, "total_tokens": 1310}
-{"timestamp": 1772559298.6732295, "source": "VISUAL_CONTEXT", "input_tokens": 2798, "output_tokens": 367, "total_tokens": 3165}
-{"timestamp": 1772561554.6015077, "source": "STRATEGY_CARD", "input_tokens": 1013, "output_tokens": 629, "total_tokens": 1642}
-{"timestamp": 1772561558.9990692, "source": "VISUAL_CONTEXT", "input_tokens": 2431, "output_tokens": 185, "total_tokens": 2616}
-{"timestamp": 1772565150.852108, "source": "STRATEGY_CARD", "input_tokens": 850, "output_tokens": 502, "total_tokens": 1352}
-{"timestamp": 1772565153.7320673, "source": "VISUAL_CONTEXT", "input_tokens": 2784, "output_tokens": 181, "total_tokens": 2965}
-{"timestamp": 1772566535.1022563, "source": "STRATEGY_CARD", "input_tokens": 1013, "output_tokens": 559, "total_tokens": 1572}
-{"timestamp": 1772566538.038168, "source": "VISUAL_CONTEXT", "input_tokens": 2431, "output_tokens": 163, "total_tokens": 2594}
-{"timestamp": 1772569473.3585815, "source": "STRATEGY_CARD", "input_tokens": 593, "output_tokens": 371, "total_tokens": 964}
-{"timestamp": 1772569476.1710353, "source": "VISUAL_CONTEXT", "input_tokens": 2527, "output_tokens": 264, "total_tokens": 2791}
-{"timestamp": 1772611881.4530358, "source": "STRATEGY_CARD", "input_tokens": 718, "output_tokens": 537, "total_tokens": 1255}
-{"timestamp": 1772611885.0479743, "source": "VISUAL_CONTEXT", "input_tokens": 2652, "output_tokens": 192, "total_tokens": 2844}
-{"timestamp": 1772612530.8352077, "source": "STRATEGY_CARD", "input_tokens": 718, "output_tokens": 415, "total_tokens": 1133}
-{"timestamp": 1772612534.8578382, "source": "VISUAL_CONTEXT", "input_tokens": 2652, "output_tokens": 232, "total_tokens": 2884}
-{"timestamp": 1772612950.5944204, "source": "STRATEGY_CARD", "input_tokens": 718, "output_tokens": 494, "total_tokens": 1212}
-{"timestamp": 1772612954.0438452, "source": "VISUAL_CONTEXT", "input_tokens": 2652, "output_tokens": 160, "total_tokens": 2812}
-{"timestamp": 1772614048.2253125, "source": "STRATEGY_CARD", "input_tokens": 631, "output_tokens": 459, "total_tokens": 1090}
-{"timestamp": 1772614051.4180298, "source": "VISUAL_CONTEXT", "input_tokens": 2653, "output_tokens": 143, "total_tokens": 2796}
-{"timestamp": 1772615453.6756742, "source": "STRATEGY_CARD", "input_tokens": 633, "output_tokens": 474, "total_tokens": 1107}
-{"timestamp": 1772615456.4561982, "source": "VISUAL_CONTEXT", "input_tokens": 2703, "output_tokens": 124, "total_tokens": 2827}
-{"timestamp": 1772616594.5814724, "source": "STRATEGY_CARD", "input_tokens": 619, "output_tokens": 492, "total_tokens": 1111}
-{"timestamp": 1772616597.5802834, "source": "VISUAL_CONTEXT", "input_tokens": 2689, "output_tokens": 124, "total_tokens": 2813}
-{"timestamp": 1772642808.9722643, "source": "STRATEGY_CARD", "input_tokens": 633, "output_tokens": 461, "total_tokens": 1094}
-{"timestamp": 1772642812.1456337, "source": "VISUAL_CONTEXT", "input_tokens": 2703, "output_tokens": 158, "total_tokens": 2861}
-{"timestamp": 1772644213.695966, "source": "STRATEGY_CARD", "input_tokens": 630, "output_tokens": 533, "total_tokens": 1163}
-{"timestamp": 1772644217.3652086, "source": "VISUAL_CONTEXT", "input_tokens": 2700, "output_tokens": 150, "total_tokens": 2850}
-{"timestamp": 1772645664.3125317, "source": "STRATEGY_CARD", "input_tokens": 625, "output_tokens": 430, "total_tokens": 1055}
-{"timestamp": 1772645667.1905127, "source": "VISUAL_CONTEXT", "input_tokens": 2695, "output_tokens": 114, "total_tokens": 2809}
-{"timestamp": 1772646717.345538, "source": "STRATEGY_CARD", "input_tokens": 632, "output_tokens": 537, "total_tokens": 1169}
-{"timestamp": 1772646720.7266014, "source": "VISUAL_CONTEXT", "input_tokens": 2702, "output_tokens": 204, "total_tokens": 2906}
-{"timestamp": 1772649149.0629902, "source": "STRATEGY_CARD", "input_tokens": 630, "output_tokens": 493, "total_tokens": 1123}
-{"timestamp": 1772649151.979605, "source": "VISUAL_CONTEXT", "input_tokens": 2700, "output_tokens": 120, "total_tokens": 2820}
-{"timestamp": 1772649531.5516613, "source": "STRATEGY_CARD", "input_tokens": 762, "output_tokens": 501, "total_tokens": 1263}
-{"timestamp": 1772649533.9723606, "source": "VISUAL_CONTEXT", "input_tokens": 2832, "output_tokens": 140, "total_tokens": 2972}
-{"timestamp": 1772649702.364443, "source": "STRATEGY_CARD", "input_tokens": 498, "output_tokens": 483, "total_tokens": 981}
-{"timestamp": 1772649705.38045, "source": "VISUAL_CONTEXT", "input_tokens": 3084, "output_tokens": 313, "total_tokens": 3397}
-{"timestamp": 1772650610.2047548, "source": "STRATEGY_CARD", "input_tokens": 633, "output_tokens": 506, "total_tokens": 1139}
-{"timestamp": 1772650612.947399, "source": "VISUAL_CONTEXT", "input_tokens": 2703, "output_tokens": 134, "total_tokens": 2837}
-{"timestamp": 1772652708.0897086, "source": "STRATEGY_CARD", "input_tokens": 631, "output_tokens": 423, "total_tokens": 1054}
-{"timestamp": 1772652711.6079218, "source": "VISUAL_CONTEXT", "input_tokens": 2701, "output_tokens": 183, "total_tokens": 2884}
-{"timestamp": 1772652963.0275085, "source": "STRATEGY_CARD", "input_tokens": 643, "output_tokens": 501, "total_tokens": 1144}
-{"timestamp": 1772652968.035381, "source": "VISUAL_CONTEXT", "input_tokens": 2713, "output_tokens": 556, "total_tokens": 3269}
-{"timestamp": 1772653375.5494018, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 340, "total_tokens": 845}
-{"timestamp": 1772653379.273209, "source": "VISUAL_CONTEXT", "input_tokens": 2575, "output_tokens": 447, "total_tokens": 3022}
-{"timestamp": 1772653464.0258176, "source": "STRATEGY_CARD", "input_tokens": 505, "output_tokens": 474, "total_tokens": 979}
-{"timestamp": 1772653469.982951, "source": "VISUAL_CONTEXT", "input_tokens": 2575, "output_tokens": 324, "total_tokens": 2899}
-{"timestamp": 1772653696.506363, "source": "STRATEGY_CARD", "input_tokens": 704, "output_tokens": 414, "total_tokens": 1118}
-{"timestamp": 1772653700.7789865, "source": "VISUAL_CONTEXT", "input_tokens": 2774, "output_tokens": 428, "total_tokens": 3202}
-{"timestamp": 1772654282.6182566, "source": "FAST_SOLVE", "input_tokens": 1396, "output_tokens": 620, "total_tokens": 2016}
-{"timestamp": 1772654286.4602787, "source": "STRATEGY_CARD", "input_tokens": 428, "output_tokens": 341, "total_tokens": 769}
-{"timestamp": 1772654288.6344323, "source": "VISUAL_CONTEXT", "input_tokens": 1724, "output_tokens": 157, "total_tokens": 1881}
-{"timestamp": 1772654520.878454, "source": "STRATEGY_CARD", "input_tokens": 528, "output_tokens": 481, "total_tokens": 1009}
-{"timestamp": 1772654524.830554, "source": "VISUAL_CONTEXT", "input_tokens": 1824, "output_tokens": 401, "total_tokens": 2225}
-{"timestamp": 1772655069.798928, "source": "STRATEGY_CARD", "input_tokens": 528, "output_tokens": 326, "total_tokens": 854}
-{"timestamp": 1772655074.2584503, "source": "VISUAL_CONTEXT", "input_tokens": 1824, "output_tokens": 519, "total_tokens": 2343}
-{"timestamp": 1772655493.828339, "source": "STRATEGY_CARD", "input_tokens": 528, "output_tokens": 446, "total_tokens": 974}
-{"timestamp": 1772655497.445795, "source": "VISUAL_CONTEXT", "input_tokens": 1824, "output_tokens": 370, "total_tokens": 2194}
-{"timestamp": 1772655694.6287482, "source": "STRATEGY_CARD", "input_tokens": 607, "output_tokens": 489, "total_tokens": 1096}
-{"timestamp": 1772655697.985874, "source": "VISUAL_CONTEXT", "input_tokens": 2677, "output_tokens": 136, "total_tokens": 2813}
-{"timestamp": 1772657110.5287514, "source": "STRATEGY_CARD", "input_tokens": 611, "output_tokens": 491, "total_tokens": 1102}
-{"timestamp": 1772657833.6960452, "source": "STRATEGY_CARD", "input_tokens": 623, "output_tokens": 417, "total_tokens": 1040}
-{"timestamp": 1772657836.9899707, "source": "VISUAL_CONTEXT", "input_tokens": 2693, "output_tokens": 151, "total_tokens": 2844}
-{"timestamp": 1772659168.1888006, "source": "STRATEGY_CARD", "input_tokens": 624, "output_tokens": 471, "total_tokens": 1095}
-{"timestamp": 1772659170.9740539, "source": "VISUAL_CONTEXT", "input_tokens": 2694, "output_tokens": 120, "total_tokens": 2814}
-{"timestamp": 1772705557.2644145, "source": "STRATEGY_CARD", "input_tokens": 925, "output_tokens": 412, "total_tokens": 1337}
-{"timestamp": 1772705560.509686, "source": "VISUAL_CONTEXT", "input_tokens": 2479, "output_tokens": 206, "total_tokens": 2685}
-{"timestamp": 1772709005.1909516, "source": "STRATEGY_CARD", "input_tokens": 930, "output_tokens": 496, "total_tokens": 1426}
-{"timestamp": 1772709008.7142165, "source": "VISUAL_CONTEXT", "input_tokens": 2484, "output_tokens": 249, "total_tokens": 2733}
-{"timestamp": 1772709806.1697607, "source": "STRATEGY_CARD", "input_tokens": 925, "output_tokens": 453, "total_tokens": 1378}
-{"timestamp": 1772709809.0037146, "source": "VISUAL_CONTEXT", "input_tokens": 2479, "output_tokens": 156, "total_tokens": 2635}
-{"timestamp": 1772710756.450641, "source": "STRATEGY_CARD", "input_tokens": 925, "output_tokens": 395, "total_tokens": 1320}
-{"timestamp": 1772710759.511627, "source": "VISUAL_CONTEXT", "input_tokens": 2479, "output_tokens": 169, "total_tokens": 2648}
-{"timestamp": 1772712395.4580095, "source": "STRATEGY_CARD", "input_tokens": 930, "output_tokens": 550, "total_tokens": 1480}
-{"timestamp": 1772712403.0527177, "source": "VISUAL_CONTEXT", "input_tokens": 2484, "output_tokens": 171, "total_tokens": 2655}
-{"timestamp": 1772713674.870672, "source": "STRATEGY_CARD", "input_tokens": 925, "output_tokens": 448, "total_tokens": 1373}
-{"timestamp": 1772713678.1964586, "source": "VISUAL_CONTEXT", "input_tokens": 2479, "output_tokens": 227, "total_tokens": 2706}
-{"timestamp": 1772714610.3289752, "source": "STRATEGY_CARD", "input_tokens": 925, "output_tokens": 459, "total_tokens": 1384}
-{"timestamp": 1772714620.744281, "source": "VISUAL_CONTEXT", "input_tokens": 2479, "output_tokens": 215, "total_tokens": 2694}
-{"timestamp": 1772714729.366911, "source": "STRATEGY_CARD", "input_tokens": 704, "output_tokens": 453, "total_tokens": 1157}
-{"timestamp": 1772714733.9152834, "source": "VISUAL_CONTEXT", "input_tokens": 2774, "output_tokens": 431, "total_tokens": 3205}
-{"timestamp": 1772715064.6699388, "source": "STRATEGY_CARD", "input_tokens": 500, "output_tokens": 420, "total_tokens": 920}
-{"timestamp": 1772715069.731974, "source": "VISUAL_CONTEXT", "input_tokens": 3086, "output_tokens": 318, "total_tokens": 3404}
-{"timestamp": 1772715984.0346959, "source": "STRATEGY_CARD", "input_tokens": 762, "output_tokens": 548, "total_tokens": 1310}
-{"timestamp": 1772716296.7217784, "source": "STRATEGY_CARD", "input_tokens": 703, "output_tokens": 453, "total_tokens": 1156}
-{"timestamp": 1772716302.2433567, "source": "VISUAL_CONTEXT", "input_tokens": 2773, "output_tokens": 498, "total_tokens": 3271}
-{"timestamp": 1772726561.3550043, "source": "STRATEGY_CARD", "input_tokens": 577, "output_tokens": 521, "total_tokens": 1098}
-{"timestamp": 1772726564.8115976, "source": "VISUAL_CONTEXT", "input_tokens": 2647, "output_tokens": 397, "total_tokens": 3044}
-{"timestamp": 1772736448.7926044, "source": "DATA_ANCHOR", "input_tokens": 1090, "output_tokens": 198, "total_tokens": 1288}
-{"timestamp": 1772736460.1520722, "source": "STRATEGY_CARD", "input_tokens": 892, "output_tokens": 609, "total_tokens": 1501}
-{"timestamp": 1772736462.7616389, "source": "VISUAL_CONTEXT", "input_tokens": 2815, "output_tokens": 181, "total_tokens": 2996}
-{"timestamp": 1772743267.4181376, "source": "DATA_ANCHOR", "input_tokens": 1137, "output_tokens": 223, "total_tokens": 1360}
-{"timestamp": 1772743276.4217439, "source": "STRATEGY_CARD", "input_tokens": 942, "output_tokens": 638, "total_tokens": 1580}
-{"timestamp": 1772743278.885498, "source": "VISUAL_CONTEXT", "input_tokens": 2346, "output_tokens": 178, "total_tokens": 2524}
-{"timestamp": 1772743693.285608, "source": "DATA_ANCHOR", "input_tokens": 1108, "output_tokens": 162, "total_tokens": 1270}
-{"timestamp": 1772743700.9194748, "source": "STRATEGY_CARD", "input_tokens": 883, "output_tokens": 583, "total_tokens": 1466}
-{"timestamp": 1772743703.2714183, "source": "VISUAL_CONTEXT", "input_tokens": 2833, "output_tokens": 167, "total_tokens": 3000}
-{"timestamp": 1772744117.7814052, "source": "DATA_ANCHOR", "input_tokens": 850, "output_tokens": 112, "total_tokens": 962}
-{"timestamp": 1772744124.140434, "source": "STRATEGY_CARD", "input_tokens": 585, "output_tokens": 426, "total_tokens": 1011}
-{"timestamp": 1772744127.0701056, "source": "VISUAL_CONTEXT", "input_tokens": 2575, "output_tokens": 313, "total_tokens": 2888}
-{"timestamp": 1772744243.3443646, "source": "DATA_ANCHOR", "input_tokens": 1121, "output_tokens": 201, "total_tokens": 1322}
-{"timestamp": 1772744250.8168118, "source": "STRATEGY_CARD", "input_tokens": 921, "output_tokens": 531, "total_tokens": 1452}
-{"timestamp": 1772744253.4009237, "source": "VISUAL_CONTEXT", "input_tokens": 2846, "output_tokens": 171, "total_tokens": 3017}
-{"timestamp": 1772744476.9826915, "source": "DATA_ANCHOR", "input_tokens": 1118, "output_tokens": 216, "total_tokens": 1334}
-{"timestamp": 1772744485.9629061, "source": "STRATEGY_CARD", "input_tokens": 936, "output_tokens": 684, "total_tokens": 1620}
-{"timestamp": 1772744488.3700812, "source": "VISUAL_CONTEXT", "input_tokens": 2843, "output_tokens": 148, "total_tokens": 2991}
-{"timestamp": 1772823542.2606947, "source": "DATA_ANCHOR", "input_tokens": 1048, "output_tokens": 233, "total_tokens": 1281}
-{"timestamp": 1772823549.7308736, "source": "STRATEGY_CARD", "input_tokens": 870, "output_tokens": 547, "total_tokens": 1417}
-{"timestamp": 1772823554.5970643, "source": "VISUAL_CONTEXT", "input_tokens": 2773, "output_tokens": 449, "total_tokens": 3222}
-{"timestamp": 1772825870.3662357, "source": "DATA_ANCHOR", "input_tokens": 843, "output_tokens": 117, "total_tokens": 960}
-{"timestamp": 1772825875.9081695, "source": "STRATEGY_CARD", "input_tokens": 584, "output_tokens": 383, "total_tokens": 967}
-{"timestamp": 1772825878.9876485, "source": "VISUAL_CONTEXT", "input_tokens": 3084, "output_tokens": 338, "total_tokens": 3422}
-{"timestamp": 1772826105.461909, "source": "DATA_ANCHOR", "input_tokens": 1275, "output_tokens": 197, "total_tokens": 1472}
-{"timestamp": 1772826115.6996713, "source": "STRATEGY_CARD", "input_tokens": 1067, "output_tokens": 619, "total_tokens": 1686}
-{"timestamp": 1772826118.912887, "source": "VISUAL_CONTEXT", "input_tokens": 2484, "output_tokens": 151, "total_tokens": 2635}
-{"timestamp": 1772828791.2978642, "source": "DATA_ANCHOR", "input_tokens": 1118, "output_tokens": 225, "total_tokens": 1343}
-{"timestamp": 1772828798.9941633, "source": "STRATEGY_CARD", "input_tokens": 944, "output_tokens": 584, "total_tokens": 1528}
-{"timestamp": 1772828801.3788452, "source": "VISUAL_CONTEXT", "input_tokens": 2843, "output_tokens": 173, "total_tokens": 3016}
-{"timestamp": 1772829334.0221822, "source": "DATA_ANCHOR", "input_tokens": 989, "output_tokens": 209, "total_tokens": 1198}
-{"timestamp": 1772829342.5638487, "source": "STRATEGY_CARD", "input_tokens": 790, "output_tokens": 624, "total_tokens": 1414}
-{"timestamp": 1772829346.9799259, "source": "VISUAL_CONTEXT", "input_tokens": 2714, "output_tokens": 372, "total_tokens": 3086}
-{"timestamp": 1772896368.4582517, "source": "DATA_ANCHOR", "input_tokens": 1049, "output_tokens": 229, "total_tokens": 1278}
-{"timestamp": 1772896375.1619043, "source": "STRATEGY_CARD", "input_tokens": 873, "output_tokens": 559, "total_tokens": 1432}
-{"timestamp": 1772896379.0389543, "source": "VISUAL_CONTEXT", "input_tokens": 2774, "output_tokens": 414, "total_tokens": 3188}
-{"timestamp": 1772896636.945227, "source": "DATA_ANCHOR", "input_tokens": 1459, "output_tokens": 225, "total_tokens": 1684}
-{"timestamp": 1772896645.6438618, "source": "STRATEGY_CARD", "input_tokens": 1265, "output_tokens": 422, "total_tokens": 1687}
-{"timestamp": 1772896650.2536604, "source": "VISUAL_CONTEXT", "input_tokens": 3184, "output_tokens": 476, "total_tokens": 3660}
-{"timestamp": 1772897990.1208234, "source": "DATA_ANCHOR", "input_tokens": 995, "output_tokens": 180, "total_tokens": 1175}
-{"timestamp": 1772897997.3616338, "source": "STRATEGY_CARD", "input_tokens": 783, "output_tokens": 429, "total_tokens": 1212}
-{"timestamp": 1772898001.260483, "source": "VISUAL_CONTEXT", "input_tokens": 2720, "output_tokens": 471, "total_tokens": 3191}
-{"timestamp": 1772899459.6093585, "source": "DATA_ANCHOR", "input_tokens": 963, "output_tokens": 170, "total_tokens": 1133}
-{"timestamp": 1772899465.5617237, "source": "STRATEGY_CARD", "input_tokens": 746, "output_tokens": 521, "total_tokens": 1267}
-{"timestamp": 1772899469.4163444, "source": "VISUAL_CONTEXT", "input_tokens": 2688, "output_tokens": 517, "total_tokens": 3205}
-{"timestamp": 1772899924.3404112, "source": "DATA_ANCHOR", "input_tokens": 1139, "output_tokens": 174, "total_tokens": 1313}
-{"timestamp": 1772899935.0380306, "source": "STRATEGY_CARD", "input_tokens": 926, "output_tokens": 462, "total_tokens": 1388}
-{"timestamp": 1772899938.1405778, "source": "VISUAL_CONTEXT", "input_tokens": 2864, "output_tokens": 307, "total_tokens": 3171}
-{"timestamp": 1772900164.0275037, "source": "DATA_ANCHOR", "input_tokens": 1118, "output_tokens": 166, "total_tokens": 1284}
-{"timestamp": 1772900172.9523828, "source": "STRATEGY_CARD", "input_tokens": 893, "output_tokens": 663, "total_tokens": 1556}
-{"timestamp": 1772900175.1326618, "source": "VISUAL_CONTEXT", "input_tokens": 2843, "output_tokens": 159, "total_tokens": 3002}
-{"timestamp": 1772916284.370273, "source": "DATA_ANCHOR", "input_tokens": 1256, "output_tokens": 228, "total_tokens": 1484}
-{"timestamp": 1772916291.872142, "source": "STRATEGY_CARD", "input_tokens": 1083, "output_tokens": 470, "total_tokens": 1553}
-{"timestamp": 1772916294.1689677, "source": "VISUAL_CONTEXT", "input_tokens": 2465, "output_tokens": 169, "total_tokens": 2634}
-{"timestamp": 1772968000.6080022, "source": "DATA_ANCHOR", "input_tokens": 1271, "output_tokens": 218, "total_tokens": 1489}
-{"timestamp": 1772968010.3471835, "source": "STRATEGY_CARD", "input_tokens": 1081, "output_tokens": 746, "total_tokens": 1827}
-{"timestamp": 1772968013.1406078, "source": "VISUAL_CONTEXT", "input_tokens": 2589, "output_tokens": 186, "total_tokens": 2775}
-{"timestamp": 1772969710.82548, "source": "DATA_ANCHOR", "input_tokens": 1245, "output_tokens": 200, "total_tokens": 1445}
-{"timestamp": 1772969718.746076, "source": "STRATEGY_CARD", "input_tokens": 1045, "output_tokens": 527, "total_tokens": 1572}
-{"timestamp": 1772969721.1641371, "source": "VISUAL_CONTEXT", "input_tokens": 2564, "output_tokens": 147, "total_tokens": 2711}
-{"timestamp": 1772970894.2238824, "source": "DATA_ANCHOR", "input_tokens": 1263, "output_tokens": 184, "total_tokens": 1447}
-{"timestamp": 1772970903.6811893, "source": "STRATEGY_CARD", "input_tokens": 1051, "output_tokens": 590, "total_tokens": 1641}
-{"timestamp": 1772970906.0983233, "source": "VISUAL_CONTEXT", "input_tokens": 2584, "output_tokens": 154, "total_tokens": 2738}
-{"timestamp": 1772971232.0141368, "source": "DATA_ANCHOR", "input_tokens": 846, "output_tokens": 117, "total_tokens": 963}
-{"timestamp": 1772971236.2969332, "source": "STRATEGY_CARD", "input_tokens": 586, "output_tokens": 400, "total_tokens": 986}
-{"timestamp": 1772973883.970684, "source": "DATA_ANCHOR", "input_tokens": 1276, "output_tokens": 195, "total_tokens": 1471}
-{"timestamp": 1772973893.3517823, "source": "STRATEGY_CARD", "input_tokens": 1065, "output_tokens": 561, "total_tokens": 1626}
-{"timestamp": 1772973896.2489126, "source": "VISUAL_CONTEXT", "input_tokens": 2595, "output_tokens": 202, "total_tokens": 2797}
-{"timestamp": 1772974188.1111608, "source": "DATA_ANCHOR", "input_tokens": 844, "output_tokens": 117, "total_tokens": 961}
-{"timestamp": 1772974192.2955508, "source": "STRATEGY_CARD", "input_tokens": 584, "output_tokens": 420, "total_tokens": 1004}
-{"timestamp": 1772975579.6468108, "source": "DATA_ANCHOR", "input_tokens": 1274, "output_tokens": 195, "total_tokens": 1469}
-{"timestamp": 1772975588.967129, "source": "STRATEGY_CARD", "input_tokens": 1071, "output_tokens": 636, "total_tokens": 1707}
-{"timestamp": 1772975892.0393825, "source": "DATA_ANCHOR", "input_tokens": 844, "output_tokens": 117, "total_tokens": 961}
-{"timestamp": 1772975897.6556168, "source": "STRATEGY_CARD", "input_tokens": 584, "output_tokens": 488, "total_tokens": 1072}
diff --git a/main.py b/main.py
deleted file mode 100644
index c9b38cd0691b8ee2d6dcb0e260e19882f5f5be4c..0000000000000000000000000000000000000000
--- a/main.py
+++ /dev/null
@@ -1,832 +0,0 @@
-# VERSION: v5.13.15 (SymPy Coordinate Fix + UI Prep)
-# RESTART TRIGGER: 2026-03-16T23:05:00
-from contextlib import asynccontextmanager
-from fastapi import FastAPI, UploadFile, File, Form, HTTPException, Request, Header
-from fastapi.responses import JSONResponse, HTMLResponse
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from sse_starlette.sse import EventSourceResponse
-from fastapi.templating import Jinja2Templates
-from typing import Optional, List
-import logging
-import base64
-import json
-import io
-import sys
-import os
-import asyncio
-from datetime import datetime
-from pydantic import BaseModel
-from typing import Any
-
-class AskQuestionRequest(BaseModel):
-    context_data: dict | Any
-    question: str
-    student_name: str = "תלמיד"
-    id_token: Optional[str] = None
-
-# --- HEALTH CHECK : Top-level Dependency Verification ---
-# We do this before standard imports to ensure a clear error message 
-# if the virtual environment is inactive and libraries are missing.
-try:
-    import cv2
-    import numpy as np
-except ModuleNotFoundError as e:
-    print(f"🔥 [HEALTH-CHECK FAILED] Missing critical dependency: {e}. Are you running inside the .venv?")
-    sys.exit(1)
-
-from orchestrator import orchestrator, build_standard_response
-from quota_system import quota_manager
-from quota_system_v2 import quota_manager_v2
-from config import IS_PRODUCTION, ENV
-from firebase_manager import firebase_manager
-from utils.image_processor import enhance_image_for_math_ocr
-
-if hasattr(sys.stdout, 'reconfigure'):
-    sys.stdout.reconfigure(encoding='utf-8')
-
-# הגדרת לוגר HamoraServer
-try:
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-        handlers=[
-            logging.FileHandler("/tmp/server.log", encoding="utf-8"),
-            logging.StreamHandler(sys.stdout)
-        ]
-    )
-except PermissionError:
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-        handlers=[logging.StreamHandler(sys.stdout)]
-    )
-
-logger = logging.getLogger("HamoraServer")
-
-# --- INFRA HARDENING: Global Async Exception Handler ---
-def custom_async_exception_handler(loop, context):
-    """
-    Catches unhandled asynchronous exceptions to prevent the Event Loop from crashing.
-    """
-    msg = context.get("exception", context["message"])
-    logger.critical(f"🚨 [ASYNC-CRASH-PREVENTION] Caught unhandled exception in Event Loop: {msg}")
-    # The loop remains alive. We just log the critical error.
-
-# --- INFRA HARDENING: Health Check Function ---
-def verify_system_health():
-    """
-    Verifies execution environment and critical dependencies.
-    """
-    logger.info("🩺 [HEALTH-CHECK] Verifying core dependencies and environment...")
-    
-    # Check if running in a virtual environment
-    if sys.prefix == sys.base_prefix:
-        logger.warning("⚠️ [HEALTH-CHECK] Not running inside a virtual environment (.venv). Proceeding anyway...")
-        
-    logger.info(f"✅ [HEALTH-CHECK] cv2 version: {cv2.__version__}, numpy: {np.__version__}")
-    logger.info(f"✅ [HEALTH-CHECK] Environment: {ENV.upper()}, Production Mode: {IS_PRODUCTION}")
-    
-    # V5.8.1: API Key Validation
-    if not os.environ.get("GOOGLE_API_KEY"):
-        logger.error("❌ [HEALTH-CHECK] GOOGLE_API_KEY is missing! Gemini calls will fail.")
-    else:
-        logger.info("✅ [HEALTH-CHECK] GOOGLE_API_KEY is detected.")
-
-
-
-# --- INFRA HARDENING: Lifespan Context Manager ---
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Startup Phase
-    verify_system_health()
-    
-    # V5.13.16: HARD STARTUP - Ensure Firebase is initialized before routes accept traffic
-    logger.info("🚀 [STARTUP] Initializing Firebase SDK (Hard Start)...")
-    firebase_manager.initialize()
-    
-    # Register Global Async Exception Handler
-    loop = asyncio.get_running_loop()
-    loop.set_exception_handler(custom_async_exception_handler)
-    logger.info("🛡️ [STARTUP] Global Async Exception Handler registered.")
-    
-
-    
-    yield # Yield control back to FastAPI
-    
-    # Shutdown Phase
-    logger.info("🛑 [SHUTDOWN] BuddyMath Server is shutting down cleanly.")
-
-
-# Application Setup
-app = FastAPI(title="BuddyMath Server - OpenCV Engine", lifespan=lifespan)
-
-# Setup Jinja templates
-base_dir = os.path.dirname(os.path.abspath(__file__))
-templates = Jinja2Templates(directory=os.path.join(base_dir, "templates"))
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Static files for audio fallback
-os.makedirs("/tmp/static", exist_ok=True)
-app.mount("/static", StaticFiles(directory="/tmp/static"), name="static")
-
-@app.get("/")
-async def root():
-    return {"status": f"BuddyMath API V5.10.1 ({ENV.upper()})", "engine": "OpenCV Base + Security Hardening"}
-
-async def verify_admin_access(request: Request) -> Optional[str]:
-    """
-    Centralized admin verification logic.
-    Returns UID if access is granted, otherwise raises HTTPException.
-    """
-    auth_header = request.headers.get('Authorization')
-    if not auth_header or not auth_header.startswith('Bearer '):
-        raise HTTPException(status_code=401, detail="Unauthorized: Missing Token")
-
-    token = auth_header.split('Bearer ')[1].strip()
-    uid = None
-    
-    from config import DEV_BYPASS_TOKEN
-    if not IS_PRODUCTION and token == DEV_BYPASS_TOKEN:
-        uid = "dev-bypass-user"
-        logger.info("🛠️ [ADMIN-AUTH] Using DEV Auth Bypass Token.")
-    else:
-        decoded = firebase_manager.verify_token(token)
-        if not decoded:
-            raise HTTPException(status_code=401, detail="Unauthorized: Invalid Token")
-        uid = decoded.get('uid')
-
-    if not uid:
-        raise HTTPException(status_code=401, detail="Unauthorized: Invalid UID")
-
-    # Strict Firestore Role Check
-    try:
-        db = firebase_manager.get_db()
-        user_doc = db.collection('users').document(uid).get()
-        if not user_doc.exists and uid != "dev-bypass-user":
-             raise HTTPException(status_code=403, detail="Forbidden: User document missing")
-        
-        user_data = user_doc.to_dict() if user_doc.exists else {'role': 'admin', 'isAdmin': True}
-        if user_data.get('role') != 'admin' and not user_data.get('isAdmin'):
-             logger.warning(f"🚨 [ADMIN-AUTH] Unauthorized attempt by UID: {uid}")
-             raise HTTPException(status_code=403, detail="Forbidden: Admin access required")
-        
-        return uid
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"❌ [ADMIN-AUTH] Database error: {e}")
-        raise HTTPException(status_code=500, detail="Internal server error during auth")
-
-@app.get("/admin/stats")
-async def get_admin_stats(request: Request):
-    """
-    V5.10.1: Returns usage and cost statistics.
-    Enforced strict Admin authorization.
-    """
-    await verify_admin_access(request)
-
-    from cost_tracker import LOG_FILE, PRICING
-    stats = {
-        "total_input_tokens": 0,
-        "total_output_tokens": 0,
-        "total_cost_usd": 0.0,
-        "request_count": 0,
-        "total_users": 0
-    }
-    
-    # 1. Count users using optimized query
-    try:
-        db = firebase_manager.get_db()
-        results = db.collection('users').count().get()
-        stats["total_users"] = results[0][0].value
-    except Exception as e:
-        logger.error(f"Error counting users: {e}")
-
-    # 2. Parse usage logs
-    if os.path.exists(LOG_FILE):
-        try:
-            with open(LOG_FILE, "r", encoding="utf-8") as f:
-                for line in f:
-                    try:
-                        entry = json.loads(line)
-                        stats["total_input_tokens"] += entry.get("input_tokens", 0)
-                        stats["total_output_tokens"] += entry.get("output_tokens", 0)
-                        stats["request_count"] += 1
-                    except: continue
-            
-            # Calculate total cost
-            stats["total_cost_usd"] = (stats["total_input_tokens"] / 1e6 * PRICING["input"]) + \
-                                    (stats["total_output_tokens"] / 1e6 * PRICING["output"])
-        except Exception as e:
-            logger.error(f"Error parsing log file: {e}")
-            
-    return {"status": "success", "cost_summary": stats}
-
-class QuotaUpdateRequest(BaseModel):
-    uid: str
-    daily_limit: Optional[int] = None
-    monthly_budget: Optional[int] = None
-    total_purchased: Optional[int] = None
-    is_unlimited: Optional[bool] = None # V6.0
-
-@app.post("/admin/update_quota")
-async def update_quota(request: Request, req: QuotaUpdateRequest):
-    """
-    V5.10.1: Updates user quota.
-    """
-    await verify_admin_access(request)
-    try:
-        db = firebase_manager.get_db()
-        update_data = {}
-        if req.daily_limit is not None:
-             update_data['quota_limit'] = req.daily_limit
-        if req.monthly_budget is not None:
-             update_data['monthly_token_budget'] = req.monthly_budget
-        if req.total_purchased is not None:
-             update_data['wallet.total_purchased_tokens'] = req.total_purchased
-        if req.is_unlimited is not None:
-             update_data['is_unlimited'] = req.is_unlimited
-        
-        if not update_data:
-             return {"status": "error", "message": "No data to update"}
-             
-        db.collection('users').document(req.uid).update(update_data)
-        logger.info(f"📊 [ADMIN] Updated quota for {req.uid}: {update_data}")
-        return {"status": "success"}
-    except Exception as e:
-        logger.error(f"Failed to update quota: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/admin/fix_balance/{uid}")
-async def fix_balance(uid: str, request: Request):
-    """
-    V5.14.7: Temporary fix for negative token balances.
-    """
-    await verify_admin_access(request)
-    try:
-        db = firebase_manager.get_db()
-        user_ref = db.collection('users').document(uid)
-        doc = user_ref.get()
-        if doc.exists:
-            data = doc.to_dict()
-            wallet = data.get('wallet', {})
-            balance = wallet.get('token_balance', 0)
-            if balance < 0:
-                pos_balance = abs(balance)
-                user_ref.update({'wallet.token_balance': pos_balance})
-                logger.info(f"✅ [ADMIN] Fixed negative balance for {uid}: {balance} -> {pos_balance}")
-                return {"status": "success", "fixed_to": pos_balance}
-        return {"status": "no_fix_needed"}
-    except Exception as e:
-        logger.error(f"Failed to fix balance: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/admin/reset_usage/{uid}")
-async def reset_usage(uid: str, request: Request):
-    """
-    V5.10.1: Resets monthly usage to 0.
-    """
-    await verify_admin_access(request)
-    try:
-        db = firebase_manager.get_db()
-        db.collection('users').document(uid).update({'used_tokens_this_month': 0})
-        logger.info(f"🔄 [ADMIN] Reset usage for {uid}")
-        return {"status": "success"}
-    except Exception as e:
-        logger.error(f"Failed to reset usage: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/admin/clear_devices/{uid}")
-async def clear_devices(uid: str, request: Request):
-    """
-    V5.10.1: Clears all allowed devices for a user.
-    """
-    await verify_admin_access(request)
-    try:
-        db = firebase_manager.get_db()
-        db.collection('users').document(uid).update({
-            'allowed_devices': [], 
-            'masterDeviceId': firestore.DELETE_FIELD
-        })
-        logger.info(f"📱 [ADMIN] Cleared devices for {uid}")
-        return {"status": "success"}
-    except Exception as e:
-        logger.error(f"Failed to clear devices: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-class StatusUpdateRequest(BaseModel):
-    status: str
-
-@app.post("/admin/update_user_status/{uid}")
-async def update_user_status(uid: str, req: StatusUpdateRequest, request: Request):
-    """
-    V5.10.1: Updates user status (approved/blocked/etc).
-    """
-    await verify_admin_access(request)
-    try:
-        db = firebase_manager.get_db()
-        db.collection('users').document(uid).update({'status': req.status})
-        logger.info(f"🛡️ [ADMIN] Updated status for {uid} to {req.status}")
-        return {"status": "success"}
-    except Exception as e:
-        logger.error(f"Failed to update status: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-
-@app.post("/admin/delete_user/{uid}")
-async def delete_user_full(uid: str, request: Request):
-    """
-    V5.10.1: Deletes user from both Firestore and Firebase Auth.
-    Enforced strict Admin authorization.
-    """
-    await verify_admin_access(request)
-
-    try:
-        # 1. Delete from Firestore
-        db = firebase_manager.get_db()
-        db.collection('users').document(uid).delete()
-        
-        # 2. Delete from Firebase Auth
-        try:
-            from firebase_admin import auth
-            auth.delete_user(uid)
-            logger.info(f"🗑️ [ADMIN] User {uid} deleted from Auth and Firestore.")
-        except auth.UserNotFoundError:
-            logger.warning(f"⚠️ [ADMIN] User {uid} not found in Auth, but deleted from Firestore.")
-        except Exception as e:
-            logger.error(f"❌ [ADMIN] Auth deletion failed for {uid}: {e}")
-            # We continue because the DB part is done
-
-        return {"status": "success", "message": f"User {uid} removed."}
-    except Exception as e:
-        logger.error(f"❌ [ADMIN] Deletion failed: {e}")
-        return JSONResponse(status_code=500, content={"error": str(e)})
-
-@app.post("/solve_stream")
-async def solve_stream(
-    user: Optional[str] = Form(None),
-    student_name: Optional[str] = Form(None),
-    grade: str = Form("י'"),
-    student_gender: str = Form("M"),
-    mode: str = Form("solve"),
-    user_note: Optional[str] = Form(None),
-    file: UploadFile = File(...)
-):
-    """
-    V5.8.0: המורה למתמטיקה - Multipart & OpenCV Base.
-    מקבל קובץ ישירות מהפלאטר ומפענח אותו עם OpenCV.
-    """
-    final_student_name = student_name or user or "תלמיד"
-    uid = None
-    print(f"🚀 🟢 BIT-LOG: Received Multipart request from {final_student_name}. Grade: {grade}")
-    
-    # Quota Check
-    if final_student_name == "dev-bypass-user":
-        is_allowed, msg, current_usage, limit = True, "Dev Bypass", 0, 999
-    else:
-        is_allowed, msg, current_usage, limit = quota_manager.check_limit(final_student_name)
-    
-    if not is_allowed:
-        response_content = build_standard_response(
-            final_answer=f"הגעת למכסה היומית ({limit} שאלות)",
-            teacher_summary="נא להמתין למחר לקבלת מכסה חדשה.",
-            logic_error=True,
-            response_type="error"
-        )
-        response_content["error"] = "QUOTA_EXCEEDED" 
-        return JSONResponse(status_code=429, content=response_content)
-    quota_manager.increment_usage(final_student_name)
-
-    try:
-        # 1. קריאת הבינארי
-        original_bytes = await file.read()
-        print(f"📸 [BIT-LOG] Image received. Size: {len(original_bytes)} bytes")
-        
-        # 1b. V5.13.14: Pre-processing Layer
-        image_bytes = enhance_image_for_math_ocr(original_bytes)
-        print(f"📸 [BIT-LOG] Image enhanced. Size: {len(image_bytes)} bytes")
-
-        # 2. OpenCV Decoder
-        nparr = np.frombuffer(image_bytes, np.uint8)
-        img_cv2 = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-        
-        if img_cv2 is None:
-            print("❌ [BIT-LOG] OpenCV failed to decode image!")
-            raise HTTPException(status_code=400, detail="Invalid image data")
-
-        print(f"✅ [BIT-LOG] OpenCV Matrix Ready: {img_cv2.shape}")
-
-        # 3. OCR & Solving Pipeline (Streaming)
-        print("🚀 [TRACE-MAIN] Initiating streaming orchestrator.solve_problem...")
-
-        async def event_generator():
-            try:
-                async for event in orchestrator.solve_problem(
-                    problem_text="", # Will be extracted by OCR
-                    grade=grade,
-                    student_name=final_student_name,
-                    student_gender=student_gender,
-                    user_note=user_note,
-                    image_data=image_bytes,
-                    mode=mode,
-                    uid=uid
-                ):
-                    # SSE Protocol: yield a dict with "data" key
-                    yield {
-                        "event": "message",
-                        "id": event.question_id,
-                        "data": event.model_dump_json() # Pydantic v2
-                    }
-            except Exception as e:
-                logger.error(f"STREAMING ERROR: {e}")
-                yield {
-                    "event": "error",
-                    "data": json.dumps({"error": str(e)})
-                }
-
-        return EventSourceResponse(event_generator())
-
-    except Exception as e:
-        logger.exception("CRITICAL FLOW ERROR")
-        print(f"🔥 [BIT-LOG] CRITICAL ERROR: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        response_content = build_standard_response(
-            final_answer="שגיאה בפענוח התמונה או התרגיל",
-            teacher_summary="המורה למתמטיקה מתנצל, אך חלה שגיאה לא צפויה.",
-            logic_error=True,
-            response_type="error"
-        )
-        return JSONResponse(status_code=500, content=response_content)
-
-@app.post("/v2/solve_stream")
-async def solve_stream_v2(
-    request: Request,
-    user: Optional[str] = Form(None),
-    student_name: Optional[str] = Form(None),
-    grade: str = Form("י'"),
-    student_gender: str = Form("M"),
-    mode: str = Form("solve"),
-    user_note: Optional[str] = Form(None),
-    session_id: Optional[str] = Form(None), # V318.0: Tutor Session Support
-    files: List[UploadFile] = File(...)
-):
-    """
-    V2: Token-based Auth and Firestore Quota Management.
-    """
-    auth_header = request.headers.get('Authorization')
-    if not auth_header or not auth_header.startswith('Bearer '):
-        logger.warning("🚨 [V2_ENDPOINT] Missing or invalid Authorization header.")
-        return JSONResponse(status_code=401, content={"error": "Unauthorized: Missing Token"})
-
-    id_token = auth_header.split('Bearer ')[1].strip()
-    
-    uid = None
-    from config import IS_PRODUCTION, DEV_BYPASS_TOKEN
-    
-    # V5.9.3: Log incoming token for debugging
-    logger.info(f"🔑 [V2_ENDPOINT] Received Token (len={len(id_token)}): {id_token[:5]}...")
-
-    # V5.9.1: DEV Auth Bypass (Strict non-prod check)
-    if not IS_PRODUCTION and id_token == DEV_BYPASS_TOKEN:
-        logger.info("🛠️ [V2_ENDPOINT] Using DEV Auth Bypass Token.")
-        uid = "dev-bypass-user"
-    else:
-        decoded_token = firebase_manager.verify_token(id_token)
-        if not decoded_token:
-            logger.warning("🚨 [V2_ENDPOINT] Invalid or expired Firebase ID token.")
-            return JSONResponse(status_code=401, content={"error": "Unauthorized: Invalid Token"})
-        uid = decoded_token.get('uid')
-
-    final_student_name = student_name or user or "תלמיד"
-    print(f"🚀 🟢 [V2] Received request from UID: {uid} ({final_student_name}). Grade: {grade}")
-    device_id = request.headers.get('Device-ID')
-    
-    # V5.10.0: Fetch user tier for Digital Binder (History) support
-    user_tier = "student_basic"
-    try:
-        db = firebase_manager.get_db()
-        user_doc = db.collection('users').document(uid).get()
-        if user_doc.exists:
-            user_tier = user_doc.to_dict().get('tier', 'student_basic')
-    except Exception as e:
-        logger.error(f"Error fetching user tier: {e}")
-
-    # V2 Quota Check (Firestore)
-    if uid == "dev-bypass-user":
-        is_allowed, msg, current_usage, limit = True, "Dev Bypass", 0, 999
-    else:
-        is_allowed, msg, current_usage, limit = quota_manager_v2.check_limit(uid, device_id=device_id)
-    
-    if not is_allowed:
-        response_content = build_standard_response(
-            final_answer=f"הגעת למכסה היומית ({limit} שאלות)",
-            teacher_summary="נא להמתין למחר לקבלת מכסה חדשה או לשדרג לפרימיום.",
-            logic_error=True,
-            response_type="error"
-        )
-        response_content["error"] = "QUOTA_EXCEEDED" 
-        return JSONResponse(status_code=403, content=response_content) # Changed to 403 Forbidden for quota specifically
-
-    # V5.15.0: Pencil Economy Pre-flight Check (Wait for at least 2,000 tokens)
-    has_pencils, balance = quota_manager_v2.check_wallet(uid, min_required=2000)
-    if not has_pencils:
-        response_content = build_standard_response(
-            final_answer="לא נותרו לך מספיק עפרונות לביצוע הפעולה.",
-            teacher_summary="העיפרון הושחז עד הסוף! נא לרכוש חבילת עפרונות חדשה.",
-            logic_error=True,
-            response_type="error"
-        )
-        response_content["error"] = "PAYMENT_REQUIRED"
-        response_content["token_balance"] = balance
-        return JSONResponse(status_code=402, content=response_content)
-
-    # Only increment usage if OCR/Solving process starts successfully
-    
-    try:
-        # V316.5: Sort incoming files by filename to ensure image_00, image_01... order
-        files.sort(key=lambda x: x.filename)
-        
-        # 1. קריאת הבינארי
-        original_bytes_list = []
-        for single_file in files:
-            original_bytes_list.append(await single_file.read())
-            
-        print(f"📸 [V2-LOG] Received {len(original_bytes_list)} images.")
-        
-        # 1b. V5.13.14: Pre-processing Layer (Map over all images)
-        image_bytes_list = [enhance_image_for_math_ocr(b) for b in original_bytes_list]
-        print(f"📸 [V2-LOG] Images enhanced for OCR Accuracy.")
-
-        if not image_bytes_list:
-            raise HTTPException(status_code=400, detail="No images provided")
-
-        # 2. OpenCV Decoder (validate the first image)
-        nparr = np.frombuffer(image_bytes_list[0], np.uint8)
-        img_cv2 = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-        
-        if img_cv2 is None:
-            print("❌ [V2-LOG] OpenCV failed to decode first image!")
-            raise HTTPException(status_code=400, detail="Invalid image data")
-
-        print(f"✅ [V2-LOG] OpenCV Matrix Ready: {img_cv2.shape}")
-
-        # Increment quota AFTER we are sure the image is valid
-        quota_manager_v2.increment_usage(uid)
-
-        # 3. OCR & Solving Pipeline (Streaming)
-        print("🚀 [TRACE-V2] Initiating streaming orchestrator.solve_problem with multiple images...")
-
-        async def event_generator():
-            import cost_tracker
-            cost_tracker.current_request_tokens.set(0)
-            try:
-                # orchestrator handles the rest using student_name for pedagogical stuff, but quota is already handled.
-                async for event in orchestrator.solve_problem(
-                    problem_text="", # Will be extracted by OCR
-                    grade=grade,
-                    student_name=final_student_name,
-                    student_gender=student_gender,
-                    user_note=user_note,
-                    image_data_list=image_bytes_list,
-                    mode=mode,
-                    uid=uid,
-                    session_id=session_id, # V318.0: Pass through
-                    tier=user_tier # V5.10.0: Pass tier for history saving
-                ):
-                    # SSE Protocol: yield a dict with "data" key
-                    yield {
-                        "event": "message",
-                        "id": event.question_id,
-                        "data": event.model_dump_json() # Pydantic v2
-                    }
-            except Exception as e:
-                logger.error(f"STREAMING ERROR (V2): {e}")
-                yield {
-                    "event": "error",
-                    "data": json.dumps({"error": str(e)})
-                }
-            finally:
-                # V5.10.0: Ensure token deduction even on crash/disconnect
-                total_tokens = 0
-                try:
-                    total_tokens = cost_tracker.current_request_tokens.get()
-                except Exception:
-                    pass
-                
-                if total_tokens > 0:
-                    try:
-                        quota_manager_v2.increment_usage(uid, increment_questions=0, tokens_used=total_tokens)
-                        print(f"🪙 [V2-QUOTA] Deducted {total_tokens} tokens for UID: {uid}")
-                    except ValueError as ve:
-                        # V5.15.0: Log overdraft attempt that was blocked by atomic transaction
-                        logger.error(f"❌ [V2-QUOTA] Atomic Overdraft Blocked: {ve}")
-                        # This avoids the connection hanging if the finally block crashes
-
-        return EventSourceResponse(event_generator())
-
-    except Exception as e:
-        logger.exception("CRITICAL FLOW ERROR (V2)")
-        print(f"🔥 [V2-LOG] CRITICAL ERROR: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        response_content = build_standard_response(
-            final_answer="שגיאה בפענוח התמונה או התרגיל",
-            teacher_summary="המורה למתמטיקה מתנצל, אך חלה שגיאה לא צפויה.",
-            logic_error=True,
-            response_type="error"
-        )
-        return JSONResponse(status_code=500, content=response_content)
-
-@app.post("/explain_step")
-async def explain_step(request: Request):
-    data = await request.json()
-    
-    # Auth Hardening (V3.1)
-    auth_header = request.headers.get('Authorization')
-    token = (data.get("id_token") or (auth_header.split('Bearer ')[1] if auth_header and auth_header.startswith('Bearer ') else None))
-    
-    if not token:
-        return JSONResponse(status_code=401, content={"error": "Unauthorized: Missing Token"})
-        
-    decoded_token = firebase_manager.verify_token(token)
-    if not decoded_token:
-        return JSONResponse(status_code=401, content={"error": "Unauthorized: Invalid Token"})
-    
-    uid = decoded_token.get('uid')
-    
-    # Quota check (Gate only, no increment for simple explanations yet)
-    is_allowed, msg, _, _ = quota_manager_v2.check_limit(uid)
-    if not is_allowed:
-        return JSONResponse(status_code=403, content={"error": "QUOTA_EXCEEDED", "message": msg})
-        
-    res = await orchestrator.explain_specific_step(data.get("context"), data.get("step_text"), data.get("student_name"))
-    return JSONResponse(content=res)
-
-@app.post("/ask_question")
-async def ask_question(request: Request, ask_req: AskQuestionRequest):
-    data = ask_req.dict()
-    
-    # Auth Hardening (V3.1)
-    auth_header = request.headers.get('Authorization')
-    token = (data.get("id_token") or (auth_header.split('Bearer ')[1] if auth_header and auth_header.startswith('Bearer ') else None))
-    
-    if not token:
-        return JSONResponse(status_code=401, content={"error": "Unauthorized: Missing Token"})
-        
-    decoded_token = firebase_manager.verify_token(token)
-    if not decoded_token:
-        return JSONResponse(status_code=401, content={"error": "Unauthorized: Invalid Token"})
-    
-    uid = decoded_token.get('uid')
-    
-    # Quota check
-    is_allowed, msg, _, _ = quota_manager_v2.check_limit(uid)
-    if not is_allowed:
-        return JSONResponse(status_code=403, content={"error": "QUOTA_EXCEEDED", "message": msg})
-
-    res = await orchestrator.ask_question(data.get("context_data"), data.get("question"), data.get("student_name"))
-    return JSONResponse(content=res)
-    
-@app.get("/pay", response_class=HTMLResponse)
-async def payment_page(request: Request, uid: Optional[str] = None):
-    """
-    Serves the Premium Payment Web Page.
-    Fetches the student name from Firestore if uid is provided.
-    """
-    student_name = ""
-    if uid:
-        try:
-            db = firebase_manager.get_db()
-            user_doc = db.collection('users').document(uid).get()
-            if user_doc.exists:
-                student_name = user_doc.to_dict().get("student_name", "")
-        except Exception as e:
-            logger.error(f"Failed to fetch user for payment page: {e}")
-            
-    return templates.TemplateResponse("payment.html", {
-        "request": request, 
-        "uid": uid or "", 
-        "student_name": student_name
-    })
-
-class UpgradeRequest(BaseModel):
-    uid: str
-    parent_email: str
-
-@app.post("/api/upgrade_success")
-async def upgrade_success(req: UpgradeRequest):
-    """
-    Mock Webhook for successful payment. 
-    Updates the Firestore user to Premium Tier.
-    """
-    if not req.uid:
-        raise HTTPException(status_code=400, detail="Missing user ID")
-        
-    try:
-        db = firebase_manager.get_db()
-        user_ref = db.collection('users').document(req.uid)
-        user_ref.set({
-            "tier": "parent_premium",
-            "parent_email": req.parent_email,
-            "monthly_token_budget": 2800000
-        }, merge=True)
-        
-        # V5.10.0: Add 20 Pencils (340k tokens) with Debt Absorption
-        quota_manager_v2.add_tokens_with_absorption(req.uid, 340000)
-        
-        logger.info(f"🎉 UPGRADED USER {req.uid} to parent_premium")
-        return {"status": "success", "message": "User upgraded successfully"}
-    except Exception as e:
-        logger.error(f"Failed to upgrade user {req.uid}: {e}")
-        raise HTTPException(status_code=500, detail="Database update failed")
-    
-class MigrationRequest(BaseModel):
-    batch_size: Optional[int] = 50
-
-@app.post("/admin/migrate_to_v2")
-async def migrate_to_v2(request: Request, req: MigrationRequest):
-    """
-    V280.2: Admin endpoint to migrate users to V2 Quota system.
-    """
-    await verify_admin_access(request)
-        
-    try:
-        from scripts.migrate_users_to_cloud import migrate_users
-        import asyncio
-        
-        # Run migration in background so we don't block
-        asyncio.create_task(asyncio.to_thread(migrate_users))
-        
-        return {"status": "success", "message": "Migration started in background."}
-    except Exception as e:
-        logger.error(f"Migration error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-class ReportRequest(BaseModel):
-    uid: str
-    student_name: str
-    parent_email: str
-    week_id: str
-
-@app.post("/v2/send_weekly_report")
-async def send_weekly_report(req: ReportRequest):
-    """
-    Generates and emails the weekly AI Assessment report to the parent.
-    """
-    try:
-        import os
-        from report_generator import report_generator
-        
-        # 1. Produce HTML
-        html_content = report_generator.produce_weekly_report(
-            uid=req.uid,
-            week_id=req.week_id,
-            student_name=req.student_name
-        )
-        
-        # 2. Generate PDF
-        pdf_path = f"/tmp/report_{req.uid}_{req.week_id}.pdf"
-        # Create tmp dir if it doesn't exist (local dev)
-        os.makedirs(os.path.dirname(pdf_path), exist_ok=True)
-        report_generator.export_to_pdf(html_content, pdf_path)
-        
-        # 3. Email PDF
-        success = report_generator.send_report_email(
-            parent_email=req.parent_email,
-            student_name=req.student_name,
-            pdf_path=pdf_path
-        )
-        
-        # Cleanup
-        try:
-            if os.path.exists(pdf_path):
-                os.remove(pdf_path)
-        except Exception as e:
-            print(f"Cleanup failed for {pdf_path}: {e}")
-            
-        if success:
-            return {"status": "success", "message": f"Report sent to {req.parent_email}"}
-            
-        return JSONResponse(status_code=500, content={"status": "error", "message": "Failed to send email via SendGrid."})
-        
-    except Exception as e:
-        logger.error(f"Failed to generate report: {e}")
-        import traceback
-        traceback.print_exc()
-        return JSONResponse(status_code=500, content={"status": "error", "message": str(e)})
-
-if __name__ == "__main__":
-    import os
-    import uvicorn
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run("main:app", host="0.0.0.0", port=port)
diff --git a/math_engine.py b/math_engine.py
deleted file mode 100644
index d98e6f5f9078a528b619efefaeda80d70b1eafa4..0000000000000000000000000000000000000000
--- a/math_engine.py
+++ /dev/null
@@ -1,154 +0,0 @@
-import sympy as sp
-
-class MathContext:
-    """
-    A sandbox for the LLM to execute mathematics.
-    Each operation is recorded with Hebrew context and exact LaTeX representation.
-    """
-    def __init__(self):
-        self.steps = []
-        
-        # Injected SymPy helpers
-        self.sp = sp
-        self.Eq = sp.Eq
-        self.solve = sp.solve
-        self.expand = sp.expand
-        self.simplify = sp.simplify
-        self.sqrt = sp.sqrt
-        self.diff = sp.diff
-
-    def _format_latex(self, expr) -> str:
-        """Converts SymPy to precise LaTeX, without $$ so it renders correctly in Flutter."""
-        if isinstance(expr, str):
-            # If the LLM passed a string instead of SymPy object, try parsing it
-            try:
-                expr = sp.sympify(expr)
-            except:
-                pass # Return as-is if not parseable
-
-        latex_str = sp.latex(expr)
-        return latex_str
-
-    def explain(self, text: str):
-        """Adds a pure Hebrew explanation step without math."""
-        self.steps.append({
-            "content_mixed": text,
-            "block_math": ""
-        })
-
-    def declare_equation(self, text: str, eq: sp.Eq):
-        """Prints a known equation with its explanation."""
-        self.steps.append({
-            "content_mixed": text,
-            "block_math": self._format_latex(eq)
-        })
-        return eq
-
-    def expand_expr(self, text: str, expr):
-        """Expands an expression completely (e.g. squaring a root)."""
-        expanded = sp.expand(expr)
-        self.steps.append({
-            "content_mixed": text,
-            "block_math": self._format_latex(expanded)
-        })
-        return expanded
-
-    def solve_equation(self, text: str, eq: sp.Eq, var):
-        """Solves an equation for a specific variable."""
-        solutions = sp.solve(eq, var)
-        
-        # Format solutions nicely
-        if isinstance(solutions, list):
-            if len(solutions) == 1:
-                math_result = sp.Eq(var, solutions[0])
-            else:
-                # E.g. x_1 = 2, x_2 = -2
-                parts = [f"{sp.latex(var)}_{{{i+1}}} = {sp.latex(sol)}" for i, sol in enumerate(solutions)]
-                math_result = " \\text{ ואו } ".join(parts)
-        else:
-            math_result = sp.Eq(var, solutions)
-
-        self.steps.append({
-            "content_mixed": text,
-            "block_math": math_result if isinstance(math_result, str) else self._format_latex(math_result)
-        })
-        return solutions
-
-    def finish(self, final_answer: str, teacher_summary: str = ""):
-        """Sets the final human-readable answer for the UI."""
-        self.final_answer = final_answer
-        self.teacher_summary = teacher_summary
-
-def run_llm_code(python_code: str) -> dict:
-    """
-    Executes the LLM-generated Python code in our secure MathContext.
-    Returns the step-by-step UI format required by BuddyMath.
-    """
-    ctx = MathContext()
-    
-    # Secure Globals the LLM is allowed to use
-    safe_globals = {
-        "ctx": ctx,
-        "x": sp.Symbol('x'),
-        "y": sp.Symbol('y'),
-        "a": sp.Symbol('a'),
-        "b": sp.Symbol('b'),
-        "c": sp.Symbol('c'),
-        "m": sp.Symbol('m'),
-        "R": sp.Symbol('R'),
-        "sp": sp,
-    }
-
-    try:
-        # Execute the LLM's dynamically generated mathematics
-        exec(python_code, safe_globals)
-        
-        return {
-            "success": True,
-            "steps": ctx.steps,
-            "final_answer": getattr(ctx, 'final_answer', "הגענו לפתרון."),
-            "teacher_summary": getattr(ctx, 'teacher_summary', "")
-        }
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e)
-        }
-
-if __name__ == "__main__":
-    # Simulate LLM output to solve a Locus / Parabola problem:
-    # "The distance from (x, y) to (2, 0) is equal to its distance to x = -2."
-    
-    llm_code = """
-ctx.explain("נסמן את הנקודה הכללית על המקום הגיאומטרי כ- (x,y). לפי הנתון, המרחק מהמוקד שווה למרחק מהמדריך.")
-d1 = sp.sqrt((x - 2)**2 + (y - 0)**2)  # מוקד
-d2 = sp.sqrt((x - (-2))**2)          # מדריך
-
-eq1 = ctx.declare_equation("המשוואה המשווה בין המרחקים היא:", ctx.Eq(d1, d2))
-
-ctx.explain("נעלה את שני האגפים בריבוע כדי להיפטר מהשורש:")
-# SymPy understands squaring both sides! We square them and declare equality.
-squared_eq = ctx.Eq(d1**2, d2**2)
-ctx.steps[-1]["block_math"] = ctx._format_latex(squared_eq) # Override previous block math
-
-# Now expand and simplify it beautifully
-expanded_eq = ctx.declare_equation("נרחיב את הביטויים (פתיחת סוגריים מלאה):", ctx.Eq(ctx.expand(squared_eq.lhs), ctx.expand(squared_eq.rhs)))
-
-# SymPy's powerful simplify equation solver (subtract RHS from LHS)
-simplified_expr = ctx.simplify(expanded_eq.lhs - expanded_eq.rhs)
-final_eq = ctx.declare_equation("לאחר כינוס איברים והעברת אגפים, נקבל את צורת הפרבולה הפשוטה:", ctx.Eq(simplified_expr, 0))
-
-# Also isolate y^2 if needed
-y_sq_isolated = ctx.solve(final_eq, y**2)
-if y_sq_isolated:
-    ctx.declare_equation("נבודד את y^2 במשוואה:", ctx.Eq(y**2, y_sq_isolated[0]))
-
-ctx.finish("$$ y^2 = 8x $$")
-"""
-    
-    print("🚀 Running LLM Mathematics Script:")
-    result = run_llm_code(llm_code)
-    
-    import json
-    # Print the resulting UI object
-    print(json.dumps(result, indent=2, ensure_ascii=False))
diff --git a/math_intent_detector.py b/math_intent_detector.py
deleted file mode 100644
index 0f546561cd7053268e0748bea083409a54fc9163..0000000000000000000000000000000000000000
--- a/math_intent_detector.py
+++ /dev/null
@@ -1,132 +0,0 @@
-# math_intent_detector.py - V4.2 (Intent Lockdown)
-# Rigidly classifies user intent before mathematical planning.
-
-import re
-import logging
-
-logger = logging.getLogger(__name__)
-
-# Rigid intent categories
-INTENT_SIMPLE_LINEAR = "SIMPLE_LINEAR_SOLVE"
-INTENT_WORD_PROBLEM_BASIC = "WORD_PROBLEM_BASIC"
-INTENT_FUNCTION_ANALYSIS = "FUNCTION_ANALYSIS"
-INTENT_SYSTEM_EQUATIONS = "SYSTEM_EQUATIONS"
-INTENT_GENERAL = "GENERAL"
-# V286.0: New intent categories for 5-unit math coverage
-INTENT_VECTORS_3D = "VECTORS_3D"
-INTENT_SOLID_GEOMETRY = "SOLID_GEOMETRY"
-INTENT_OPTIMIZATION = "OPTIMIZATION"
-INTENT_PROBABILITY = "PROBABILITY"
-INTENT_TRIGONOMETRY = "TRIGONOMETRY"
-INTENT_LOGARITHMS = "LOGARITHMS"
-INTENT_LIMITS = "LIMITS"
-
-def detect_intent(text: str, grade_num: int) -> str:
-    """
-    Detects the rigid intent category based on keywords and grade boundaries.
-    Focuses on 'Simplifying' intent for lower grades.
-    """
-    text_lower = text.lower()
-    
-    # 1. Simple Linear Solve (Grade 7 focus)
-    # Check for basic algebra keywords and lack of complex concepts
-    simple_linear_keywords = ["x=", "פתור", "משוואה", "נעלם"]
-    is_simple_algebra = any(kw in text_lower for kw in simple_linear_keywords)
-    
-    # Exclusion markers for simple intent
-    complex_markers = ["נגזרת", "קיצון", "מערכת", "שני נעלמים", "x^2", "x²"]
-    has_complex_content = any(cm in text_lower for cm in complex_markers)
-    
-    if grade_num == 7 and is_simple_algebra and not has_complex_content:
-        print("🎯 [INTENT] Classified as SIMPLE_LINEAR_SOLVE (Grade 7 Lockdown)")
-        return INTENT_SIMPLE_LINEAR
-
-    # 2. Word Problem Basic
-    word_problem_keywords = ["בעיה", "מילולית", "קנה", "מחיר", "סך הכל"]
-    if any(kw in text_lower for kw in word_problem_keywords):
-        print("🎯 [INTENT] Classified as WORD_PROBLEM_BASIC")
-        return INTENT_WORD_PROBLEM_BASIC
-
-    # 3. System of Equations
-    if "מערכת" in text_lower or "שני נעלמים" in text_lower:
-        print("🎯 [INTENT] Classified as SYSTEM_EQUATIONS")
-        return INTENT_SYSTEM_EQUATIONS
-
-    # 4. Function Analysis
-    function_markers = ["נגזרת", "קיצון", "חקירה", "פונקציה", "f(x)"]
-    if any(fm in text_lower for fm in function_markers):
-        print("🎯 [INTENT] Classified as FUNCTION_ANALYSIS")
-        return INTENT_FUNCTION_ANALYSIS
-
-    # V286.0: 5-unit intent categories
-    # 5. Vectors 3D
-    if any(kw in text_lower for kw in ["וקטור", "וקטורים", "מכפלה סקלרית", "מכפלה וקטורית"]):
-        if any(kw in text_lower for kw in ["מרחב", "מישור", "תלת", "z"]):
-            print("🎯 [INTENT] Classified as VECTORS_3D")
-            return INTENT_VECTORS_3D
-
-    # 6. Solid Geometry
-    if any(kw in text_lower for kw in ["פירמידה", "מנסרה", "תיבה", "חתך", "אפותם", "פאות"]):
-        print("🎯 [INTENT] Classified as SOLID_GEOMETRY")
-        return INTENT_SOLID_GEOMETRY
-
-    # 7. Optimization
-    if any(kw in text_lower for kw in ["מקסימום", "מינימום", "מקסימלי", "מינימלי", "ערך מרבי", "ערך מזערי", "שטח גדול ביותר", "נפח מקסימלי"]):
-        print("🎯 [INTENT] Classified as OPTIMIZATION")
-        return INTENT_OPTIMIZATION
-
-    # 8. Probability
-    if any(kw in text_lower for kw in ["הסתברות", "קומבינטור", "תמורה", "צירוף", "בייס"]):
-        print("🎯 [INTENT] Classified as PROBABILITY")
-        return INTENT_PROBABILITY
-
-    # 9. Trigonometry
-    if any(kw in text_lower for kw in ["sin", "cos", "tan", "טריגונומטר", "סינוס", "קוסינוס"]):
-        print("🎯 [INTENT] Classified as TRIGONOMETRY")
-        return INTENT_TRIGONOMETRY
-
-    # 10. Logarithms
-    if any(kw in text_lower for kw in ["לוגריתם", "log", "ln", "מעריכי"]):
-        print("🎯 [INTENT] Classified as LOGARITHMS")
-        return INTENT_LOGARITHMS
-
-    # 11. Limits
-    if any(kw in text_lower for kw in ["גבול", "lim", "שואף", "לופיטל"]):
-        print("🎯 [INTENT] Classified as LIMITS")
-        return INTENT_LIMITS
-
-def _extract_grade_number(text: str) -> int:
-    import re
-    # מחלץ מספר מתוך מחרונה (למשל "ז׳" או "כיתה 7")
-    match = re.search(r'\d+', text)
-    if match:
-        return int(match.group())
-    # מיפוי ידני למקרים של אותיות
-    mapping = {'ז': 7, 'ח': 8, 'ט': 9, 'י': 10, 'יא': 11, 'יב': 12}
-    for char, num in mapping.items():
-        if char in text:
-            return num
-    return -1
-
-def get_intent_contract(intent: str, grade_num: int) -> dict:
-    """
-    Returns the 'Action Contract' for the given intent.
-    This contract is used to constrain the LLM/Solver.
-    """
-    if intent == INTENT_SIMPLE_LINEAR and grade_num == 7:
-        return {
-            "max_variables": 1,
-            "allowed_operators": ["ADD", "SUB", "MUL", "DIV"],
-            "forbidden_strategies": ["DERIVATIVES", "SYSTEM_OF_EQUATIONS", "COMPLEX_SUBSTITUTION"],
-            "variable_preference": "x",
-            "narrative_tone": "simple_step_by_step"
-        }
-    
-    if intent == INTENT_WORD_PROBLEM_BASIC:
-        return {
-             "max_variables": 2 if grade_num > 8 else 1,
-             "focus": "translation_to_algebra",
-             "forbidden_strategies": ["CALCULUS"]
-        }
-        
-    return {"status": "unconstrained"}
diff --git a/math_parser.py b/math_parser.py
deleted file mode 100644
index 35cbef51852618668591185cd73d05b8850d4419..0000000000000000000000000000000000000000
--- a/math_parser.py
+++ /dev/null
@@ -1,183 +0,0 @@
-import re
-import json
-import logging
-from typing import List, Dict
-from enum import Enum
-
-logger = logging.getLogger("MathParser")
-
-class MathMode(Enum):
-    INLINE = "inline"
-    DISPLAY = "display"
-
-class MathSegmenter:
-    @staticmethod
-    def segment_text_with_math(text: str) -> List[Dict]:
-        """
-        Convert natural text with $math$ to structured segments.
-        Combines V68 protections with V70 logic.
-        """
-        # 1. Memory Protection (V68 Feature)
-        if not text:
-            return [{"type": "text", "value": "", "direction": "rtl"}]
-        
-        if len(text) > 50000:
-             logger.warning(f"⚠️ Input text too long ({len(text)}), truncating.")
-             text = text[:50000] + "... (truncated)"
-
-        if '$' not in text:
-            return [{"type": "text", "value": text.strip(), "direction": "rtl"}]
-        
-        segments = []
-        pos = 0
-        text_len = len(text)
-        max_iterations = 5000 # Safety limit
-        
-        iteration = 0
-        while pos < text_len and iteration < max_iterations:
-            iteration += 1
-            dollar_idx = text.find('$', pos)
-            
-            if dollar_idx == -1:
-                remaining = text[pos:]
-                if remaining.strip():
-                    segments.append(MathSegmenter._create_text_segment(remaining))
-                break
-            
-            is_double = (dollar_idx + 1 < text_len and text[dollar_idx + 1] == '$')
-            
-            if dollar_idx > pos:
-                text_before = text[pos:dollar_idx]
-                if text_before.strip():
-                    segments.append(MathSegmenter._create_text_segment(text_before))
-            
-            if is_double:
-                close_idx = text.find('$$', dollar_idx + 2)
-                if close_idx == -1:
-                    segments.append(MathSegmenter._create_text_segment('$$'))
-                    pos = dollar_idx + 2
-                    continue
-                math_content = text[dollar_idx + 2:close_idx].strip()
-                if math_content:
-                    segments.append({"type": "math", "mode": "display", "value": math_content, "direction": "ltr"})
-                pos = close_idx + 2
-            else:
-                close_idx = text.find('$', dollar_idx + 1)
-                if close_idx == -1:
-                    segments.append(MathSegmenter._create_text_segment('$'))
-                    pos = dollar_idx + 1
-                    continue
-                math_content = text[dollar_idx + 1:close_idx].strip()
-                if math_content:
-                    segments.append({"type": "math", "mode": "inline", "value": math_content, "direction": "ltr"})
-                pos = close_idx + 1
-        
-        if not segments:
-            return [{"type": "text", "value": text, "direction": "rtl"}]
-        
-        return MathSegmenter._merge_text_segments(segments)
-    
-    @staticmethod
-    def _create_text_segment(text: str) -> Dict:
-        cleaned = text
-        # Safe RLM injection (V70 Logic)
-        RLM = chr(0x200f)
-        if cleaned.strip() and MathSegmenter._ends_with_hebrew(cleaned.strip()):
-            cleaned = cleaned.rstrip() + RLM
-        return {"type": "text", "value": cleaned, "direction": "rtl"}
-    
-    @staticmethod
-    def _ends_with_hebrew(text: str) -> bool:
-        if not text: return False
-        last_char = text[-1]
-        return '\u0590' <= last_char <= '\u05FF'
-    
-    @staticmethod
-    def _merge_text_segments(segments: List[Dict]) -> List[Dict]:
-        if not segments: return []
-        merged = []
-        curr_text = ""
-        for seg in segments:
-            if seg["type"] == "text":
-                curr_text += seg["value"]
-            else:
-                if curr_text:
-                    merged.append(MathSegmenter._create_text_segment(curr_text))
-                    curr_text = ""
-                merged.append(seg)
-        if curr_text:
-            merged.append(MathSegmenter._create_text_segment(curr_text))
-        return merged
-
-    @staticmethod
-    def segments_to_safe_string(segments: List[Dict]) -> str:
-        """
-        Reconstructs string safely.
-        Uses ONLY RLM (V70 Safe Logic) - NO LRE/PDF to avoid stream crashes.
-        """
-        result_parts = []
-        RLM = chr(0x200f)
-        
-        for i, segment in enumerate(segments):
-            if segment["type"] == "text":
-                text = segment["value"]
-                # Ensure Hebrew ends with RLM
-                if text.strip() and MathSegmenter._ends_with_hebrew(text.strip()):
-                     if not text.endswith(RLM):
-                        text += RLM
-                result_parts.append(text)
-            
-            elif segment["type"] == "math":
-                math_val = segment["value"]
-                
-                # Spacing logic
-                prefix = ""
-                suffix = ""
-                if i > 0 and segments[i-1]["type"] == "text":
-                    if not segments[i-1]["value"].endswith(" ") and not segments[i-1]["value"].endswith(RLM):
-                         prefix = " "
-                if i < len(segments)-1 and segments[i+1]["type"] == "text":
-                    if not segments[i+1]["value"].startswith(" "):
-                        suffix = " "
-
-                # Simple wrap: Just Math + RLM.
-                if segment.get("mode") == "display":
-                    formatted_math = f"$${math_val}$${RLM}"
-                else:
-                    formatted_math = f"${math_val}${RLM}"
-                
-                result_parts.append(prefix + formatted_math + suffix)
-                
-        return "".join(result_parts)
-
-    @staticmethod
-    def aggregate_math(segments: List[Dict]) -> str:
-        """
-        Collects all math for the gray box.
-        Uses simple keywords (V70 Safe Logic) to avoid Regex OOM.
-        """
-        math_blocks = []
-        keywords = ['=', '\\frac', '\\sqrt', '\\cdot', 'A', 'B', 'C', 'D', 'M', 'x', 'y']
-        
-        for seg in segments:
-            if seg["type"] == "math":
-                val = seg["value"]
-                if seg.get("mode") == "display":
-                    clean_val = val.replace('$$', '')
-                    math_blocks.append(clean_val)
-                else:
-                    if len(val) > 1 and any(k in val for k in keywords):
-                         math_blocks.append(val)
-        
-        seen = set()
-        unique_blocks = []
-        for m in math_blocks:
-            if m not in seen:
-                unique_blocks.append(m)
-                seen.add(m)
-        
-        # Guard against huge aggregation (V68 Protection)
-        result = " \\\\ ".join(unique_blocks)
-        if len(result) > 2000:
-            return result[:2000] + "..."
-        return result
\ No newline at end of file
diff --git a/math_sanitizer.py b/math_sanitizer.py
deleted file mode 100644
index 49cf2654a5e4dca99694c9fb0372a08034868835..0000000000000000000000000000000000000000
--- a/math_sanitizer.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# math_sanitizer.py - V1.1 ProductionMathSanitizer
-import re
-import logging
-
-logger = logging.getLogger(__name__)
-
-class ProductionMathSanitizer:
-    @staticmethod
-    def normalize_latex(latex_str: str) -> str:
-        """
-        V1.1: Standardizes LaTeX for SymPy and LLM comparison.
-        """
-        if not latex_str: return ""
-        
-        # 1. Basic Cleaning
-        clean = latex_str.strip()
-        clean = clean.replace(r'\ ', '')
-        clean = clean.replace(r'\times', '*')
-        clean = clean.replace(r'\cdot', '*')
-        
-        # 2. Bracket Normalization
-        clean = clean.replace(r'\left(', '(').replace(r'\right)', ')')
-        clean = clean.replace(r'\left[', '[').replace(r'\right]', ']')
-        clean = clean.replace('{', '(').replace('}', ')')
-        
-        # 3. Fractions
-        while r'\frac' in clean:
-            clean = re.sub(r'\\frac\s*\((.*?)\)\((.*?)\)', r'(\1)/(\2)', clean)
-            if r'\frac' in clean and '(' not in clean: # Fallback for simple fractions
-                 clean = re.sub(r'\\frac\s*(.*?)\s*(.*?)', r'(\1)/(\2)', clean)
-        
-        # 4. Implicit Multiplication Guard (V1.1)
-        clean = re.sub(r'(\d)([a-zA-Z(])', r'\1*\2', clean)
-        clean = re.sub(r'\)([a-zA-Z0-9(])', r')*\1', clean)
-        
-        return clean
-
-    @staticmethod
-    def validate_semantic_completeness(anchor_data: dict, formula_tokens: list[str]) -> bool:
-        """
-        V1.1: Partial Semantic Recovery Check.
-        Returns True if the missing tokens are non-critical.
-        """
-        # Logic to check if critical variables/values are missing
-        # For now, a simple check if the main function key is present.
-        critical_keys = ['function_equations', 'equations']
-        for key in critical_keys:
-            if key in anchor_data and anchor_data[key]:
-                return True
-        return False
-
-    @staticmethod
-    def get_symbolic_bridge(proof_graph) -> str:
-        """
-        V1.1: Zero Hallucination Bridge.
-        Converts the Immutable ProofGraph to a clean mathematical context for the LLM.
-        """
-        bridge = "════════════════════════════════════════\n"
-        bridge += "📜 VERIFIED SYMBOLIC BRIDGE (V1.1):\n"
-        bridge += "════════════════════════════════════════\n"
-        for step in proof_graph.steps:
-            bridge += f"Step {step.step_id}: {step.math_content} ({step.logic_description or ''})\n"
-            
-            # V6 Ontology Injection
-            if hasattr(step, 'allowed_concepts') and getattr(step, 'allowed_concepts'):
-                concepts_str = ", ".join(step.allowed_concepts)
-                tag = getattr(step, 'pedagogical_tag', 'כללי')
-                bridge += f"For step {step.step_id}, your pedagogical_tag is '{tag}'. You MUST build your explanation using ONLY the concepts from this list: [{concepts_str}]. Do NOT introduce any other mathematical concepts. Keep it under 2 sentences.\n"
-
-        bridge += "════════════════════════════════════════\n"
-        bridge += "RULE: USE ONLY THE DATA ABOVE. DO NOT HALLUCINATE OR CHANGE MATH.\n"
-        return bridge
-
-def sanitize_math_ocr_hotfix(text: str) -> str:
-    """
-    V1.1.1 Aggressive Sanitizer: Removes all spaces and fixes frac regex.
-    Fixes failures caused by leading spaces or visual artifacts.
-    """
-    if not text: return ""
-
-    # תיקון קריטי: הסרת כל הרווחים למניעת כשלי Regex (פתרון לשאלה 2 ו-3)
-    text = text.replace(" ", "")
-
-    # ניקוי שאריות ויזואליות
-    text = text.replace("\\left", "").replace("\\right", "")
-
-    # נרמול שברים (עובד עכשיו על מחרוזת נקייה מרווחים)
-    import re
-    text = re.sub(
-        r"frac\(([^()]+)\)\(([^()]+)\)",
-        lambda m: f"(({m.group(1)})/({m.group(2)}))",
-        text
-    )
-    return text.strip()
diff --git a/memory_service.py b/memory_service.py
deleted file mode 100644
index d10ce42d61e62644335327ad80b6aab30993a444..0000000000000000000000000000000000000000
--- a/memory_service.py
+++ /dev/null
@@ -1,155 +0,0 @@
-# memory_service.py
-"""
-Buddy Math - Memory Service (Pinecone Edition)
-==============================================
-גרסה v2.1: שיפור מנגנון זיהוי הדמיון.
-במקום לבדוק סדר מילים (שנשבר ב-OCR), בודקים חפיפת מילים (Jaccard).
-"""
-
-import os
-import json
-import logging
-import uuid
-import re
-from typing import Optional, Dict
-
-from sentence_transformers import SentenceTransformer
-from pinecone import Pinecone
-
-logger = logging.getLogger("MemoryService")
-
-class MemoryService:
-    def __init__(self):
-        self.api_key = os.environ.get("PINECONE_API_KEY")
-        
-        if not self.api_key:
-            logger.warning("⚠️ PINECONE_API_KEY not found! Memory will be disabled.")
-            self.index = None
-            return
-
-        try:
-            self.pc = Pinecone(api_key=self.api_key)
-            self.index_name = "buddy-math"
-            self.index = self.pc.Index(self.index_name)
-            
-            logger.info("⏳ Loading embedding model...")
-            self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
-            
-            logger.info("✅ Brain initialized (Pinecone + MiniLM)")
-            
-        except Exception as e:
-            logger.error(f"❌ Failed to init Pinecone: {e}")
-            self.index = None
-
-    def find_similar_solution(self, problem_text: str, vector_threshold: float = 0.85) -> Optional[Dict]:
-        """
-        מחפש פתרון בזיכרון. 
-        מבצע אימות כפול: וקטורי (משמעות) + חפיפת מילים (תוכן).
-        """
-        if not self.index: return None
-        
-        try:
-            # 1. חיפוש וקטורי (מהיר)
-            vector = self.embedder.encode(problem_text).tolist()
-            
-            results = self.index.query(
-                vector=vector,
-                top_k=1,
-                include_metadata=True
-            )
-            
-            if not results['matches']:
-                return None
-                
-            match = results['matches'][0]
-            vector_score = match['score']
-            
-            # בדיקת סף וקטורי
-            if vector_score < vector_threshold:
-                return None
-
-            # שליפת הטקסט המקורי מהזיכרון
-            cached_text = match['metadata'].get('text', '')
-            
-            # 2. בדיקת דמיון משופרת (Jaccard Similarity)
-            # בודקים כמה מילים משותפות יש, בלי קשר לסדר
-            text_similarity = self._calculate_jaccard_similarity(problem_text, cached_text)
-            
-            logger.info(f"🧠 Brain Check: Vector={vector_score:.3f}, Jaccard={text_similarity:.3f}")
-
-            # הורדנו את הרף ל-30% חפיפה (מספיק לזיהוי אותה שאלה ב-OCR משובש)
-            if text_similarity < 0.3:
-                logger.warning("⚠️ High vector score but low text overlap. Ignoring.")
-                return None
-                
-            # שליפת ה-JSON
-            solution_json = match['metadata'].get('solution_json')
-            if solution_json:
-                logger.info("🧠 Brain HIT! Verified match found.")
-                return json.loads(solution_json)
-            
-            return None
-            
-        except Exception as e:
-            logger.error(f"Memory search failed: {e}")
-            return None
-
-    def learn_solution(self, problem_text: str, solution_data: dict):
-        """שומר פתרון חדש"""
-        if not self.index: return
-        
-        try:
-            clean_text = problem_text.strip()
-            if len(clean_text) < 10: return
-
-            vector = self.embedder.encode(clean_text).tolist()
-            json_str = json.dumps(solution_data, ensure_ascii=False)
-            
-            # הגנה: Pinecone מגביל Metadata ל-40KB
-            if len(json_str.encode('utf-8')) > 38000:
-                logger.warning("⚠️ Solution too big for memory. Skipping save.")
-                return
-
-            metadata = {
-                "text": clean_text[:1000], 
-                "topic": solution_data.get("meta", {}).get("topic", "unknown"),
-                "solution_json": json_str
-            }
-            
-            self.index.upsert(vectors=[{
-                "id": str(uuid.uuid4()),
-                "values": vector,
-                "metadata": metadata
-            }])
-            
-            logger.info("🧠 Brain LEARNED and saved to Cloud!")
-            
-        except Exception as e:
-            logger.error(f"Memory learn failed: {e}")
-
-    def _calculate_jaccard_similarity(self, text1: str, text2: str) -> float:
-        """
-        מחשב דמיון לפי חפיפת מילים (מתעלם מסדר המילים).
-        טוב ל-OCR עברית/אנגלית שמתהפך.
-        """
-        # ניקוי ופירוק למילים ייחודיות (Tokens)
-        tokens1 = self._tokenize(text1)
-        tokens2 = self._tokenize(text2)
-        
-        if not tokens1 or not tokens2:
-            return 0.0
-            
-        # חיתוך (מילים משותפות) חלקי איחוד (כל המילים)
-        intersection = len(tokens1.intersection(tokens2))
-        union = len(tokens1.union(tokens2))
-        
-        return intersection / union
-
-    def _tokenize(self, text: str) -> set:
-        """מפרק טקסט לסט של מילים נקיות"""
-        # משאיר רק אותיות ומספרים
-        clean = re.sub(r'[^\w\s]', '', text)
-        # פירוק למילים
-        words = clean.lower().split()
-        # מסנן מילים קצרות מדי (כמו "של", "את")
-        return {w for w in words if len(w) > 1}
\ No newline at end of file
diff --git a/micro_prompts.py b/micro_prompts.py
deleted file mode 100644
index 911f3257ab9a74f868defc2acb1d318e91afe816..0000000000000000000000000000000000000000
--- a/micro_prompts.py
+++ /dev/null
@@ -1,200 +0,0 @@
-# micro_prompts.py — Textbook JSON / Hebrew Centric
-
-# Topic-specific micro-prompts for BuddyMath
-# ALL TEMPLATES: enforce [{type: "text"|"math", content: "..."}] JSON only.
-# ZERO mentions of ctx, sp, sympy, MathEngine, or Python.
-
-"""
-Micro-Prompt Library
-Each entry adds topic-specific focus on TOP of the specialist prompt in prompts.py.
-The specialist prompt already defines the full Textbook JSON schema — these just
-focus the LLM on which formula/technique to use.
-"""
-
-import json  # needed by get_general_prompt
-
-# ==================== MICRO-PROMPT TEMPLATES ====================
-# Each template is a SHORT topic-focused instruction.
-# It is prepended to the full specialist prompt (which already has the JSON schema).
-# DO NOT add any output format instructions here — the specialist prompt handles that.
-
-MICRO_PROMPTS = {
-
-    # ========== GEOMETRY ==========
-
-    "CIRCLE_EQUATION": {
-        "template": """🎯 נושא: משוואת מעגל / מקום גיאומטרי
-השתמש בנוסחה: (x-a)² + (y-b)² = r²
-זהה: מרכז (a,b) ורדיוס r מהנתונים. הצב. פשט. הגדר.</p>""",
-        "tokens": 60,
-        "requires": []
-    },
-
-    "CIRCLE_TANGENT": {
-        "template": """🎯 נושא: משיק למעגל בנקודה
-שלב 1: בדוק שהנקודה על המעגל.
-שלב 2: מצא שיפוע הרדיוס (מהמרכז לנקודה).
-שלב 3: שיפוע המשיק = -1 / שיפוע הרדיוס (מאונך). כתוב משוואת ישר.""",
-        "tokens": 70,
-        "requires": []
-    },
-
-    "TRIANGLE_AREA": {
-        "template": """🎯 נושא: שטח משולש
-נוסחה: S = ½ × בסיס × גובה. הצב וחשב.""",
-        "tokens": 40,
-        "requires": []
-    },
-
-    "LINE_EQUATION": {
-        "template": """🎯 נושא: משוואת ישר
-מצא שיפוע m ונקודת חיתוך b. כתוב: y = mx + b.""",
-        "tokens": 40,
-        "requires": []
-    },
-
-    "LINE_PERPENDICULAR": {
-        "template": """🎯 נושא: ישר מאונך
-כלל: m₁ × m₂ = -1. מצא שיפוע המאונך, הצב נקודה, כתוב משוואה.""",
-        "tokens": 50,
-        "requires": []
-    },
-
-    "DISTANCE_FORMULA": {
-        "template": """🎯 נושא: מרחק בין שתי נקודות
-נוסחה: d = √[(x₂-x₁)² + (y₂-y₁)²]. הצב מספרים. פשט.""",
-        "tokens": 50,
-        "requires": []
-    },
-
-    # ========== CALCULUS ==========
-
-    "DERIVATIVE_POWER": {
-        "template": """🎯 נושא: נגזרת — כלל החזקה
-כלל: (xⁿ)' = n·xⁿ⁻¹. גזור כל איבר בנפרד. פשט.""",
-        "tokens": 50,
-        "requires": []
-    },
-
-    "DERIVATIVE_QUOTIENT": {
-        "template": """🎯 נושא: נגזרת — כלל המנה
-כלל: (u/v)' = (u'v - uv') / v². זהה u ו-v. גזור כל אחד. הצב.""",
-        "tokens": 60,
-        "requires": []
-    },
-
-    "DERIVATIVE_PRODUCT": {
-        "template": """🎯 נושא: נגזרת — כלל המכפלה
-כלל: (u·v)' = u'v + uv'. זהה u ו-v. גזור כל אחד. הצב.""",
-        "tokens": 60,
-        "requires": []
-    },
-
-    "DERIVATIVE_CHAIN": {
-        "template": """🎯 נושא: נגזרת — כלל השרשרת
-כלל: [f(g(x))]' = f'(g(x)) · g'(x). זהה פונקציה חיצונית ופנימית. גזור.""",
-        "tokens": 70,
-        "requires": []
-    },
-
-    "INVESTIGATION_EXTREMA": {
-        "template": """🎯 נושא: חישוב נקודות קיצון
-שלב 1: f'(x) = 0 — מצא נקודות אפשריות.
-שלב 2: בדוק ב-f''(x) — f''>0 → מינימום, f''<0 → מקסימום.
-שלב 3: הצב בחזרה ב-f(x) למציאת ערך y.""",
-        "tokens": 90,
-        "requires": []
-    },
-
-    "INVESTIGATION_MONOTONICITY": {
-        "template": """🎯 נושא: עליה וירידה של פונקציה
-מצא f'(x). פתור f'(x) = 0. בדוק סימן f'(x) בכל קטע.
-f'>0 → עולה, f'<0 → יורדת.""",
-        "tokens": 80,
-        "requires": []
-    },
-
-    # ========== ALGEBRA ==========
-
-    "LINEAR_EQUATION": {
-        "template": """🎯 נושא: משוואה לינארית
-פתור שלב-אחר-שלב: בודד x בצד אחד.""",
-        "tokens": 30,
-        "requires": []
-    },
-
-    "QUADRATIC_EQUATION": {
-        "template": """🎯 נושא: משוואה ריבועית
-השתמש בנוסחת פתרון: x = [-b ± √(b²-4ac)] / 2a
-חשב דיסקרימיננטה. מצא שתי תשובות (או שורש כפול).""",
-        "tokens": 60,
-        "requires": []
-    },
-
-    "SYSTEM_EQUATIONS": {
-        "template": """🎯 נושא: מערכת משוואות
-פתור בשיטת הצבה או החסרה. הצב x חזרה למשוואה לווידוא.""",
-        "tokens": 60,
-        "requires": []
-    },
-}
-
-
-# ==================== PROMPT BUILDER ====================
-
-def get_micro_prompt(topic_id: str, data: dict, grade: str = "10") -> str:
-    """
-    Returns topic-focused prefix only.
-    Safety filter: Middle school (7-9) cannot use CALCULUS topics.
-    """
-    if topic_id not in MICRO_PROMPTS:
-        raise KeyError(f"Topic '{topic_id}' not found in MICRO_PROMPTS")
-
-    # Safety Filter for V4.2.11
-    is_middle_school = False
-    try:
-        grade_val = int(re.search(r'\d+', str(grade)).group())
-        is_middle_school = 7 <= grade_val <= 9
-    except:
-        pass
-
-    if is_middle_school and ("DERIVATIVE" in topic_id or "INVESTIGATION" in topic_id):
-        print(f"🛡️ [Safety Filter] Micro-Prompt Filter: Topic {topic_id} blocked for Grade {grade}. Falling back to GENERAL.")
-        return get_general_prompt(data)
-
-    config = MICRO_PROMPTS[topic_id]
-    template = config["template"]
-
-    # No required fields anymore — all templates are self-contained
-    focus_block = template.strip()
-
-    # Prepend focus to the general prompt (which has the anchor + schema)
-    return f"{focus_block}\n\n{get_general_prompt(data)}"
-
-
-def get_prompt_token_count(topic_id: str) -> int:
-    """Get estimated token count for topic's micro-prompt"""
-    return MICRO_PROMPTS.get(topic_id, {}).get("tokens", 60)
-
-
-def get_general_prompt(data_anchor: dict) -> str:
-    """
-    Clean context provider. 
-    Provides the data anchor without conflicting schemas.
-    """
-    anchor_json = json.dumps(data_anchor, ensure_ascii=False, indent=2)
-    return f"""📊 [DATA ANCHOR] Problem context (Absolute Truth):
-{anchor_json}
-
-Instruction: Use the specific data above to solve the problem.
-Do not provide any explanations outside the required JSON structure."""
-
-
-
-# ==================== USAGE EXAMPLE ====================
-
-if __name__ == "__main__":
-    test_data = {"equations": ["x^2 - 4 = 0"], "function_equations": ["f(x) = ln(x)/(x^2-4)"]}
-    for topic in ["CIRCLE_EQUATION", "DERIVATIVE_QUOTIENT", "LINEAR_EQUATION"]:
-        prompt = get_micro_prompt(topic, test_data)
-        print(f"=== {topic} ===\n{prompt[:200]}\n")
diff --git a/ocr_strip_engine.py b/ocr_strip_engine.py
deleted file mode 100644
index 9e076fca8f1e2b8fbd318e6de6bc67f45a68532b..0000000000000000000000000000000000000000
--- a/ocr_strip_engine.py
+++ /dev/null
@@ -1,306 +0,0 @@
-# ocr_strip_engine.py - V303.2 (Adaptive Pipeline & Two-Pass Sniper)
-import os
-import io
-import json
-import re
-import logging
-import asyncio
-from pathlib import Path
-import numpy as np
-from PIL import Image
-import cv2
-from utils.safe_json import safe_extract_json  # V1.0: Canonical JSON extractor
-
-logger = logging.getLogger(__name__)
-
-DEBUG_DIR = Path("/tmp/debug_ocr")
-DEBUG_DIR.mkdir(parents=True, exist_ok=True)
-
-# --- Constants for block detection ---
-MIN_BLOCK_W      = 50
-MIN_BLOCK_H      = 10
-LARGE_BLOCK_H    = 100
-ROW_MERGE_GAP    = 2
-
-def _adaptive_preprocess(image_bytes: bytes) -> np.ndarray:
-    """ 
-    V303.2: Adaptive Preprocessing Pipeline
-    Decides how aggressively to process based on image size.
-    """
-    np_img_raw = np.frombuffer(image_bytes, np.uint8)
-    img_bgr = cv2.imdecode(np_img_raw, cv2.IMREAD_COLOR)
-    file_size_kb = len(image_bytes) / 1024
-    
-    logger.info(f"📸 [OCR-ADAPTIVE] Input image size: {file_size_kb:.1f} KB")
-
-    if file_size_kb < 500:
-        # --- LOW-RES MODE (PC Screenshots / Snips) ---
-        logger.info("🔧 [OCR-ADAPTIVE] Low-Res mode triggered: Upscaling and applying heavy morphology.")
-        # 1. Upscale x2 to save thin pixels
-        img_bgr = cv2.resize(img_bgr, None, fx=2.0, fy=2.0, interpolation=cv2.INTER_CUBIC)
-        gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
-        # 2. Strong CLAHE
-        clahe = cv2.createCLAHE(clipLimit=2.5, tileGridSize=(8,8))
-        cl1 = clahe.apply(gray)
-        # 3. Morph Close (thicken lines)
-        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
-        processed = cv2.morphologyEx(cl1, cv2.MORPH_CLOSE, kernel)
-    else:
-        # --- HIGH-RES MODE (Phone Camera in Production) ---
-        logger.info("📱 [OCR-ADAPTIVE] High-Res mode triggered: Mild enhancement only.")
-        gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
-        
-        # V1.1: Pre-normalization (Contrast/Brightness Balance)
-        alpha = 1.2 # Contrast
-        beta = 10   # Brightness
-        gray = cv2.convertScaleAbs(gray, alpha=alpha, beta=beta)
-        
-        # Mild CLAHE just to balance lighting, NO morphological distortion
-        clahe = cv2.createCLAHE(clipLimit=1.5, tileGridSize=(8,8))
-        processed = clahe.apply(gray)
-
-    return cv2.cvtColor(processed, cv2.COLOR_GRAY2BGR)
-
-
-def _find_raw_blocks(np_bgr: np.ndarray) -> list[tuple]:
-    gray  = cv2.cvtColor(np_bgr, cv2.COLOR_BGR2GRAY)
-    blur  = cv2.GaussianBlur(gray, (7, 7), 0)
-    thresh = cv2.adaptiveThreshold(blur, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)
-    # Kernel optimized for both modes
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (60, 3))
-    dilate = cv2.dilate(thresh, kernel, iterations=1)
-    contours, _ = cv2.findContours(dilate, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    blocks = []
-    for c in contours:
-        x, y, w, h = cv2.boundingRect(c)
-        if w >= MIN_BLOCK_W and h >= MIN_BLOCK_H:
-            blocks.append((x, y, w, h))
-    blocks.sort(key=lambda b: b[1])
-    return blocks
-
-def _filter_nested(blocks: list[tuple]) -> list[tuple]:
-    filtered = []
-    for i, (x1, y1, w1, h1) in enumerate(blocks):
-        r1, b1 = x1 + w1, y1 + h1
-        nested = False
-        for j, (x2, y2, w2, h2) in enumerate(blocks):
-            if i == j: continue
-            r2, b2 = x2 + w2, y2 + h2
-            if x1 >= x2 and y1 >= y2 and r1 <= r2 and b1 <= b2:
-                nested = True
-                break
-        if not nested: filtered.append((x1, y1, w1, h1))
-    return filtered
-
-def _merge_same_row(blocks: list[tuple]) -> list[tuple]:
-    if not blocks: return []
-    merged = []
-    cur_x, cur_y, cur_w, cur_h = blocks[0]
-    for (x, y, w, h) in blocks[1:]:
-        cur_b = cur_y + cur_h
-        if cur_h >= LARGE_BLOCK_H or h >= LARGE_BLOCK_H:
-            merged.append((cur_x, cur_y, cur_w, cur_h))
-            cur_x, cur_y, cur_w, cur_h = x, y, w, h
-            continue
-        if y <= cur_b + ROW_MERGE_GAP:
-            union_x, union_y = min(cur_x, x), min(cur_y, y)
-            union_r, union_b = max(cur_x + cur_w, x + w), max(cur_y + cur_h, y + h)
-            cur_x, cur_y, cur_w, cur_h = union_x, union_y, union_r - union_x, union_b - union_y
-        else:
-            merged.append((cur_x, cur_y, cur_w, cur_h))
-            cur_x, cur_y, cur_w, cur_h = x, y, w, h
-    merged.append((cur_x, cur_y, cur_w, cur_h))
-    return merged
-
-def _extract_blocks(np_bgr: np.ndarray) -> list[tuple]:
-    raw = _find_raw_blocks(np_bgr)
-    dedup = _filter_nested(raw)
-    return _merge_same_row(dedup)
-
-def get_best_sniper_roi(img):
-    """
-    V1.1: Math Structural Heatmap Prior.
-    תעדוף אזורים עם צפיפות סמלים מתמטיים גבוהה.
-    """
-    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    _, thresh = cv2.threshold(gray, 150, 255, cv2.THRESH_BINARY_INV)
-    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    
-    ROI_HOMOGRAPHY_THRESHOLD = 50000  # Threshold for local correction (w*h)
-    candidates = []
-    
-    for cnt in contours:
-        x, y, w, h = cv2.boundingRect(cnt)
-        if w < 20 or h < 10: continue
-        
-        # V1.1: Symbol Density Check (Heatmap Prior)
-        roi_thresh = thresh[y:y+h, x:x+w]
-        pixel_count = np.sum(roi_thresh == 255)
-        density = pixel_count / (w * h)
-        
-        # Feature Clustering (Heatmap Weighting)
-        # Higher score for small but high-density clusters (usually math symbols)
-        heatmap_prior = density * (1.5 if density > 0.15 else 1.0)
-        
-        # Position Weighting (Top-heavy bias)
-        position_weight = (1.0 / (1.0 + 0.005 * y))
-        
-        confidence_score = heatmap_prior * position_weight
-        
-        candidates.append({
-            'confidence': confidence_score,
-            'box': (x, y, w, h),
-            'needs_local_homography': (w * h) > ROI_HOMOGRAPHY_THRESHOLD
-        })
-
-    if not candidates:
-        logger.warning("⚠️ No valid candidates found. Fallback.")
-        return img[:350, :], 0.0
-    
-    best = max(candidates, key=lambda c: c['confidence'])
-    x, y, w, h = best['box']
-
-    # V8.6.4: ROI Hardening — Safe Margins (Padding 50px)
-    # Prevent cutting off minus signs from exponents (e.g., e^-x becoming e^x)
-    SAFE_PADDING = 50
-    y_start = max(0, y - SAFE_PADDING)
-    y_end   = min(img.shape[0], y + h + SAFE_PADDING)
-    
-    logger.info(
-        f"📐 [OCR-BBOX] Sniper ROI (V8.6.4) — x={x}, y={y}, w={w}, h={h} | "
-        f"img=({img.shape[1]}x{img.shape[0]}) | "
-        f"crop=[{y_start}:{y_end}, :] | "
-        f"confidence={best['confidence']:.3f}"
-    )
-
-    # Conditional Local Homography Warning (Bit-log only for now)
-    if best['needs_local_homography']:
-        logger.info(f"📐 [V1.1] ROI ({w}x{h}) exceeds threshold. Local adjustment recommended.")
-    
-    return img[y_start:y_end, :], best['confidence']
-
-def apply_conditional_homography(roi_img: np.ndarray) -> np.ndarray:
-    """
-    V1.1: Local Homography Warning.
-    Only applies alignment if the ROI is large enough to warrant it.
-    Small ROIs stay original to prevent distortion.
-    """
-    h, w = roi_img.shape[:2]
-    area = h * w
-    
-    if area < 5000: # Small ROI - keep original (Prevent distortion)
-        logger.info(f"📐 [V1.1] ROI too small ({area}) - skipping local homography.")
-        return roi_img
-        
-    # Placeholder for actual homography warp
-    # In production, this would involve findHomography + warpPerspective
-    logger.info(f"📐 [V1.1] ROI large enough ({area}) - ready for local perspective correction.")
-    return roi_img
-
-async def transcribe(image_bytes: bytes, vision_model, debug_mode: bool = False) -> tuple[list[dict], float]:
-    logger.info("🪡 [OCR-STRIP] V303.6 Production Lock Pipeline Starting...")
-    
-    # 1. Adaptive Preprocessing
-    np_enhanced_bgr = _adaptive_preprocess(image_bytes)
-    img_h, img_w = np_enhanced_bgr.shape[:2]
-    
-    # 2. Get Sniper ROI (V1.1)
-    sniper_bgr, roi_confidence = get_best_sniper_roi(np_enhanced_bgr)
-    
-    # 2b. Apply Local Homography if needed (V1.1)
-    # Note: Full homography implementation requires feature matching, 
-    # for now we implement the threshold logic.
-    sniper_bgr = apply_conditional_homography(sniper_bgr)
-    
-    sniper_image = Image.fromarray(cv2.cvtColor(sniper_bgr, cv2.COLOR_BGR2RGB))
-    
-    # 3. Reader Pass (Rest of the image)
-    # Note: For V303.6 unified/single pass, we still use the full image for the reader or keep it split if preferred.
-    # The user instruction implies a "Single Pass" logic for Strategy, but OCR can stay multi-pass as long as it's targeted.
-    # We'll stick to a high-quality reader image of the original.
-    pil_enhanced = Image.fromarray(cv2.cvtColor(np_enhanced_bgr, cv2.COLOR_BGR2RGB))
-    reader_image = pil_enhanced # Full image for context
-    
-    if debug_mode:
-        sniper_image.save(DEBUG_DIR / "ocr_pass1_sniper.jpg")
-        reader_image.save(DEBUG_DIR / "ocr_pass2_reader.jpg")
-
-    # 4. The Prompts
-    sniper_prompt = (
-        "Extract ONLY the main mathematical function defined in this image. "
-        "It is usually preceded by words like 'נתונה הפונקציה'. "
-        "CRITICAL: If any exponent or fraction bar appears small or ambiguous, zoom mentally and transcribe it explicitly using ^ notation. "
-        "RETURN ONLY A JSON ARRAY: [{\"type\": \"math\", \"content\": \"...\"}]"
-    )
-    
-    reader_prompt = (
-        "Extract all Hebrew text and secondary mathematical content from this image. "
-        "RETURN ONLY A JSON ARRAY: [{\"type\": \"text\"|\"math\", \"content\": \"...\"}]"
-    )
-    
-    # 5. Concurrent Processing
-    try:
-        from google.generativeai.types import GenerationConfig
-        gen_config = GenerationConfig(temperature=0.0, top_p=0.1, top_k=1)
-        pass1_task = vision_model.generate_content_async([sniper_prompt, sniper_image], generation_config=gen_config)
-        pass2_task = vision_model.generate_content_async([reader_prompt, reader_image], generation_config=gen_config)
-        
-        pass1_response, pass2_response = await asyncio.gather(pass1_task, pass2_task)
-        
-        blocks_pass1 = _parse_structured_json(pass1_response.text)
-        blocks_pass2 = _parse_structured_json(pass2_response.text)
-        
-        # Merge, prioritizing pass 1 for the function definition
-        final_blocks = blocks_pass1 + [b for b in blocks_pass2 if b not in blocks_pass1]
-        
-        # V303.7: Apply final OCR hotfixes
-        for block in final_blocks:
-            if block.get("type") == "text":
-                block["content"] = finalize_ocr_text(block["content"])
-        
-        logger.info(f"✅ V303.6 Complete. Sniper: {len(blocks_pass1)}, Reader: {len(blocks_pass2)} (Confidence: {roi_confidence:.2f})")
-        return final_blocks, roi_confidence
-        
-    except Exception as e:
-        logger.exception("CRITICAL FLOW ERROR")
-        logger.error(f"❌ OCR V303.6 FAILED: {e}")
-        return [{"type": "text", "content": "שגיאת תקשורת בפענוח."}], 0.0
-
-def finalize_ocr_text(text: str) -> str:
-    """V1.1.2: Corrects common OCR misinterpretations in Hebrew context."""
-    if not text: return ""
-    text = text.replace("ציר ע", "ציר y")
-    text = text.replace("ציר E", "ציר y") # Common misinterpretation (E looks like y in some fonts)
-    text = text.replace("ציר ץ", "ציר y") # Another common one
-    return text
-
-def _parse_structured_json(raw_text: str) -> list[dict]:
-    """V1.0: Uses canonical safe_extract_json (logs RAW, fail-closed)."""
-    result = safe_extract_json(raw_text, caller="OCR", allow_array=True)
-    if isinstance(result, list):
-        # Flatten nested lists (LLM sometimes wraps array in array)
-        flat = []
-        for item in result:
-            if isinstance(item, list):
-                flat.extend(item)
-            elif isinstance(item, dict):
-                flat.append(item)
-            elif isinstance(item, str) and item.strip():
-                # V9.0.2 FIX: Handle strings by wrapping them in a text block
-                flat.append({"type": "text", "content": item.strip()})
-        return [p for p in flat if isinstance(p, dict)]
-    if isinstance(result, dict) and not result.get("logic_error"):
-        return [result]
-    logger.error(f"[OCR] _parse_structured_json: parse failed for: {raw_text[:200]!r}")
-    return []
-
-
-def paginate_image(image_bytes, debug_mode=False):
-    return [Image.open(io.BytesIO(image_bytes)).convert("RGB")] 
-    
-def flatten_to_text(structured: list[dict]) -> str:
-    parts = []
-    for item in structured:
-        if item.get("type") == "math": parts.append(f"${item.get('content', '')}$")
-        else: parts.append(item.get("content", ""))
-    return " ".join(parts)
\ No newline at end of file
diff --git a/orchestrator.py b/orchestrator.py
deleted file mode 100644
index a6a721f7ba3a4fb3f6fa00168df1427ba3e73f23..0000000000000000000000000000000000000000
--- a/orchestrator.py
+++ /dev/null
@@ -1,3110 +0,0 @@
-# buddy_math_server/orchestrator.py - V273.0 (SMART CLASSIFICATION + FAST PATH)
-import json, re, os, prompts, asyncio, time
-from typing import List, Dict, Optional, Any
-import sympy as sp
-import logging, re
-import ocr_strip_engine  # V300: Stitch & Strip OCR engine
-from utils.safe_json import safe_extract_json           # V1.0: Canonical JSON extractor
-from domain.math_validator import MathPolygraph         # V1.0: SymPy Polygraph
-from geometric_sanity import run_geometric_sanity        # V1.0: Geometric Sanity Engine
-from domain.processing_strategy import ProcessingStrategy
-from domain.ontology import get_allowed_concepts, get_pedagogical_tag
-from domain.math_normalizer import MathCanonicalizer
-from utils.math_utils import sanitize_latex_for_sympy, aggressive_sympy_sanitizer
-from domain.curriculum_classifier import CurriculumClassifier
-from domain.proposal_engine import ProposalEngine
-from domain.risk_engine import CognitiveRiskEngine
-from domain.pedagogical_renderer import PedagogicalRenderer
-from domain.validator import ConsistencyGate
-from smart_solver import sign_step, resolve_ast_target, execute_action
-import domain.telemetry as telemetry
-from domain.schemas import BuddyEvent, BuddyState # V8.5: Streaming contract
-from firebase_manager import firebase_manager
-from config import IS_PRODUCTION, ENV, GEMINI_MODEL, CONFIDENCE_THRESHOLD_HIGH, CONFIDENCE_THRESHOLD_MEDIUM
-import google.generativeai as genai
-from pydantic import BaseModel, Field
-
-# V318.0: Tutor Response Schema for Structured JSON Output
-class TutorInternalAnalytics(BaseModel):
-    topic: str = Field(description="The mathematical topic being discussed")
-    intent: str = Field(description="The student's intent: 'SOLVE', 'CHECK', or 'CHAT'")
-    mastery_score: int = Field(description="Estimated mastery score (0-100) based on this interaction")
-    error_analysis: Optional[str] = Field(description="Brief analysis of any errors found")
-
-class TutorResponseSchema(BaseModel):
-    student_message: str = Field(description="The encouraging pedagogical response for the student")
-    internal_analytics: TutorInternalAnalytics = Field(description="Metadata for system analysis")
-
-# V8.6.9: Global Guardrails (Increased for High-Complexity 5-Unit Problems - V317.8)
-GLOBAL_TOKEN_LIMIT = 100000
-GLOBAL_TIMEOUT_SEC = 300
-
-# ==================== V7.2: TICKET 1 — AST ENRICHMENT HELPERS ====================
-
-
-def collect_all_steps(data: dict) -> list:
-    """
-    V1.0 Polygraph Helper: Deep extraction of all step objects from a response dict.
-    Future-proofed to handle nested sub_sections and explanation_steps.
-    """
-    steps = []
-    print(f"🔍 [DEBUG] data type: {type(data)}")
-    if not isinstance(data, dict):
-        print(f"⚠️ [V1.0] collect_all_steps: Expected dict, got {type(data)}")
-        return []
-    for section in data.get("sections", []):
-        steps.extend(section.get("steps", []))
-        # Future-proofing: handle nested structures
-        for sub in section.get("sub_sections", []):
-            steps.extend(sub.get("steps", []))
-        steps.extend(section.get("explanation_steps", []))
-    return steps
-
-
-def build_ast_metadata(math_input: str, category: str) -> dict:
-    """
-    V7.2 Ticket 1: Builds a rich AST metadata object to pass to LLM #1 (Planner).
-    The Planner never receives the raw math string — only this structured metadata.
-    """
-    variables = []
-    constraints = []  # V7.3: domain constraints (placeholder)
-    detected_operations = [str(category)]
-    estimated_complexity = 0.5
-
-    try:
-        parts = aggressive_sympy_sanitizer(math_input)
-        free_syms = set()
-        for clean_part in parts:
-            try:
-                expr = sp.sympify(clean_part.replace('=', '-'), evaluate=False)
-                free_syms.update(expr.free_symbols)
-            except Exception as e:
-                logging.debug(f"[AST_METADATA] SymPy parse failed for part: {e}")
-                pass
-
-        variables = sorted([str(s) for s in free_syms])
-        raw_complexity = CurriculumClassifier.estimate_complexity(math_input)
-        estimated_complexity = round(raw_complexity / 10.0, 2)
-
-    except Exception as e:
-        logging.warning(f"[AST_METADATA] Failed to enrich metadata: {e}")
-
-    # Build node registry for Planner (IDs → expressions)
-    ast_registry = {}
-    try:
-        parts = aggressive_sympy_sanitizer(math_input)
-        for i, part in enumerate(parts):
-            ast_registry[f"ast_node_{i}"] = part
-    except Exception as e:
-        logging.debug(f"[AST_METADATA] Registry build failed: {e}")
-        ast_registry["ast_node_0"] = str(math_input)
-
-    return {
-        "variables": variables,
-        "constraints": constraints,
-        "detected_operations": detected_operations,
-        "estimated_complexity": estimated_complexity,
-        "ast_registry": ast_registry  # Shared secretly with solver; NOT sent to LLM
-    }
-
-
-def _abstract_visual_context(data_anchor: dict) -> dict:
-    """
-    V7.2 Ticket 1: Strips raw OCR/visual payload and converts to abstract metadata.
-    The Planner NEVER receives raw image data.
-    """
-    if not data_anchor:
-        return {}
-
-    # Preserve only safe, abstract fields
-    abstract = {}
-
-    graph_relations = []
-    if "graphs" in data_anchor:
-        for i, g in enumerate(data_anchor["graphs"]):
-            graph_relations.append({
-                "graph": chr(ord("I") + i),  # I, II, III...
-                "zeros": g.get("zeros", 0),
-                "type": g.get("type", "unknown")
-            })
-
-    if graph_relations:
-        abstract["graph_relations"] = graph_relations
-
-    return abstract
-
-
-# ==================== V7.2: TICKET 5 — UI GATE WHITELIST SCAN ====================
-
-def scan_for_math_leakage(rendered_text: str) -> bool:
-    """
-    V7.2 Ticket 5: Full Whitelist scan (NOT a blacklist).
-    After removing {{...}} placeholders, the remaining text may ONLY contain:
-    - Hebrew letters (Unicode block)
-    - English letters (for regular words)
-    - Spaces and basic punctuation (. , ? ! ' " - :)
-    
-    Any digit-letter combo, math symbols, trig functions, or equals signs → REJECT.
-    """
-    # Remove all valid placeholders first
-    clean_text = re.sub(r'\{\{\w+\}\}', '', rendered_text).strip()
-
-    if not clean_text:
-        return True  # Text was purely placeholders — safe
-
-    ALLOWED_PATTERN = r'^[\u0590-\u05FFa-zA-Z\s.,;:!?\-\"\']+$'
-
-    if re.match(ALLOWED_PATTERN, clean_text):
-        return True
-
-    # Log the exact leaking characters for forensics
-    violations = re.sub(r'[\u0590-\u05FFa-zA-Z\s.,;:!?\-\"\']+', '', clean_text)
-    logging.warning(f"[UI_GATE] Math leakage detected! Offending chars: '{violations[:50]}'")
-    return False
-
-
-
-def extract_and_parse_json(text: str):
-    """V5.7.5 → V1.0: Delegates to canonical safe_extract_json."""
-    return safe_extract_json(text, caller="ORCHESTRATOR_LEGACY")
-
-
-def validate_and_sanitize_response(resp_json, category="GENERAL"):
-    """V4.2.16: Validator מדויק - חוסם קוד, מאפשר גיאומטריה (ABC)"""
-    has_error = False
-    forbidden_terms = ["נגזרת", "גזירה", "אסימפטוטה", "נקודת קיצון"]
-    
-    print(f"🛡️ [BIT-LOG: VALIDATOR] Checking section in category: {category}")
-    
-    if "sections" in resp_json:
-        for section in resp_json["sections"]:
-            for step in section.get("steps", []):
-                text = step.get("explanation_text", "")
-                # 1. חסימת חדו"א באלגברה (Normalize category for Case Sensitivity Fix)
-                if category.upper() != "INVESTIGATION" and any(t in text for t in forbidden_terms):
-                    print(f"🚨 [BIT-LOG: VALIDATOR] Calculus leak detected!")
-                    has_error = True
-                # 2. חסימת פונקציות/קוד (f(x) , import) אבל השארת ABC (Relaxed for False Positives)
-                if re.search(r'\b(import|def|class|lambda)\b', text):
-                    print(f"🚨 [BIT-LOG: VALIDATOR] Code/Math leak in text: '{text[:20]}'")
-                    has_error = True
-                    step["explanation_text"] = "הסבר לא זמין עקב חריגה מהחוזה הפדגוגי."
-
-    resp_json["logic_error"] = resp_json.get("logic_error", False) or has_error
-    
-    # V317.5: UI Sanitization Layer
-    if not resp_json.get("logic_error"):
-        resp_json = sanitize_llm_output(resp_json)
-        
-    return resp_json
-
-def unify_data_anchor(raw_data):
-    """V317.5: Smart Data Anchor Unification (Prevents key overwrite)"""
-    if isinstance(raw_data, dict):
-        return raw_data
-        
-    if isinstance(raw_data, list):
-        unified = {}
-        for item in raw_data:
-            if not isinstance(item, dict): continue
-            for key, value in item.items():
-                if key in unified:
-                    # אם המפתח כבר קיים, נהפוך אותו לרשימה ונוסיף אליו
-                    if isinstance(unified[key], list):
-                        if value not in unified[key]:
-                            unified[key].append(value)
-                    else:
-                        if unified[key] != value:
-                            unified[key] = [unified[key], value]
-                else:
-                    unified[key] = value
-        return unified
-        
-    return {} # Fallback
-
-def sanitize_llm_output(json_response):
-    """V317.5: Cleans technical errors (SYMPY_PARSE_ERROR) and Hebrew from LaTeX."""
-    if not isinstance(json_response, dict):
-        return json_response
-        
-    if "steps" in json_response:
-        for step in json_response["steps"]:
-            block_math = step.get("block_math", "")
-            if block_math:
-                # Mission 2: זיהוי שגיאות של SymPy
-                if "SYMPY_PARSE_ERROR" in block_math:
-                    step["block_math"] = ""
-                    step["content_mixed"] = step.get("content_mixed", "") + "\n(המשוואה הוסתרה עקב קושי בתצוגה)."
-                
-                # Mission 2: זיהוי אותיות בעברית בתוך ה-LaTeX
-                elif re.search(r'[א-ת]', block_math):
-                    # מעבירים את התוכן לשדה הטקסט ומוחקים את הבלוק המתמטי
-                    clean_math = block_math.replace('\\text{', '').replace('}', '').replace('$', '')
-                    step["content_mixed"] = step.get("content_mixed", "") + f"\n[{clean_math}]"
-                    step["block_math"] = ""
-                    
-    # V280.0: Also check final_answer
-    if "final_answer" in json_response and "SYMPY_PARSE_ERROR" in str(json_response["final_answer"]):
-        json_response["final_answer"] = "התקבלה תשובה מורכבת (ראה שלבים מלאים)."
-                
-    return json_response
-
-import asyncio
-
-async def safe_llm_call(generator_func, timeout_seconds=45.0):
-    try:
-        # הגבלת זמן ריצה למניעת תקיעות שרת במקרה של רשת איטית
-        raw_output = await asyncio.wait_for(generator_func(), timeout=timeout_seconds)
-
-        # Handle if the function already returned parsed dict/list
-        if isinstance(raw_output, (dict, list)):
-            return raw_output
-
-        if hasattr(raw_output, 'text'):
-            raw_output = raw_output.text
-
-        # V1.0: Use canonical safe_extract_json (logs RAW, fail-closed)
-        result = safe_extract_json(raw_output, caller="SAFE_LLM_CALL")
-        if isinstance(result, dict) and result.get("logic_error"):
-            return build_standard_response(
-                logic_error=True,
-                error_type="STREAM_OR_CONTRACT_FAILURE",
-                final_answer="התשובה לא התקבלה בצורה מלאה. נסו לסרוק שוב 📸",
-                sections=[]
-            )
-        return result
-
-    except Exception as e:
-        logger.error(f"🚨 [FINAL_SHIELD] Exception caught: {str(e)}")
-        # חזרה בטוחה למבנה שגיאה תקני ל-Flutter
-        return build_standard_response(
-            logic_error=True,
-            error_type="STREAM_OR_CONTRACT_FAILURE",
-            final_answer="התשובה לא התקבלה בצורה מלאה. נסו לסרוק שוב 📸",
-            sections=[]
-        )
-
-def enforce_step_contract(proof_steps: list, llm_output: list):
-    # 1. בדיקת כמות צעדים (חובה התאמה מלאה)
-    if len(proof_steps) != len(llm_output):
-        return False, "PEDAGOGICAL_STEP_MISMATCH"
-
-    # 2. אימות זהות השלבים (Step ID Binding)
-    for step_rule, step_llm in zip(proof_steps, llm_output):
-        if step_rule.get("step_id") != step_llm.get("step_id"):
-            return False, "STEP_ID_VIOLATION"
-
-    return True, None
-
-def build_standard_response(
-    sections=None,
-    final_answer="",
-    teacher_summary="סיימנו את פתרון התרגיל.",
-    graph_base64=None,
-    audio_base64=None,
-    logic_error=False,
-    response_type="standard",
-    strategy_card=None,
-    visual_context=None,
-    error_type=None
-):
-    """
-    Standardize the output format for all responses.
-    """
-    # 🧹 Firewall 3: Sterilization
-    if logic_error:
-        # If there's an error, final_answer MUST just be the error message.
-        # We strip away any sections to prevent hallucinated data from reaching the UI.
-        sections = []
-
-    response = {
-        "final_answer": final_answer,
-        "teacher_summary": teacher_summary,
-        "sections": sections or [],
-        "graph_base64": graph_base64,
-        "audio_base64": audio_base64,
-        "logic_error": logic_error,
-        "type": response_type,
-        "strategy_card": strategy_card,
-        "visual_context": visual_context
-    }
-    
-    if error_type:
-        response["error_type"] = error_type
-    logger.info(f"🏗️ [TRACE] FINAL JSON OUT: {response}") # Changed final_response to response
-    return response
-
-def build_structured_projection(llm_commentaries, sympy_steps):
-    """ממזג הסברים מילוליים עם הלוח המתמטי ללא מגע יד אדם (V4.2.7)"""
-    structured_response = []
-    # Ensure we don't exceed the number of available commentaries
-    for i, step in enumerate(sympy_steps):
-        commentary = llm_commentaries[i] if i < len(llm_commentaries) else "נבצע את השלב הבא."
-        
-        # Determine artifact type (basic heuristic for now)
-        artifact_type = "equation"
-        if "table" in str(step.math_content).lower() or "|" in str(step.math_content):
-            artifact_type = "table"
-
-        structured_response.append({
-            "step_id": i + 1,
-            "step_number": i + 1, # Backward compatibility
-            "explanation_text": commentary, # הדיבור של המורה
-            "content_mixed": commentary,    # Backward compatibility
-            "math_artifact": {
-                "type": artifact_type,
-                "latex": step.math_content,
-                "table_data": "" # For future expansion
-            },
-            "block_math": step.math_content # Backward compatibility
-        })
-    return structured_response
-
-logger = logging.getLogger(__name__)
-
-def select_best_anchor(candidates: list[str]) -> str:
-    """בחירת הגרסה הארוכה ביותר (מניח שלמות מתמטית)"""
-    if not candidates: return ""
-    return max(candidates, key=len)
-
-def normalize_latex_for_sympy(expr: str) -> str:
-    # המרת נגזרות לפורמט ש-SymPy מבין בצורה דינמית
-    expr = re.sub(r"([a-zA-Z])'\((.*?)\)", r"Derivative(\1(\2), x)", expr)
-    expr = expr.replace("\\", "")
-    return expr
-
-def verify_math_consistency(anchor_latex: str, final_result_latex: str):
-    """
-    V4.7 Hardened: Handles equations with '=' and never fails silently.
-    """
-    try:
-        def clean_and_parse(latex_str):
-            # ניקוי בסיסי והמרת נגזרות
-            clean_str = normalize_latex_for_sympy(latex_str).replace('{', '(').replace('}', ')')
-            # טיפול במשוואות: העברת אגפים
-            parts = clean_str.split('=')
-            if len(parts) == 2:
-                return sp.sympify(parts[0]) - sp.sympify(parts[1])
-            return sp.sympify(parts[0])
-            
-        a = clean_and_parse(anchor_latex)
-        b = clean_and_parse(final_result_latex)
-        
-        is_identical = bool(sp.simplify(sp.expand(a - b)) == 0)
-        return is_identical, (1.0 if is_identical else 0.6)
-        
-    except Exception as e:
-        logger.error(f"❌ Verification crashed on input: {e}")
-        # BREAKING FIX: חובה להחזיר False במקרה של קריסה!
-        return False, 0.5 
-from dotenv import load_dotenv
-load_dotenv()  # Load .env BEFORE genai.configure()
-import google.generativeai as genai
-from smart_solver import SmartSolver
-from gibberish_detector import validate_and_fix_solution
-import gibberish_detector  # For fix_gibberish_smart
-import visuals
-
-# V231.12: Import smart architecture modules
-from strategy_manager import StrategyManager
-from pedagogical_builder import build_pedagogical_response, sanitize_math_text
-import cost_tracker  # V231.26: Log usage
-from audio_generator import generate_teacher_audio # V261.5: Teacher TTS
-
-# V1.1: Math Safety Lock Modules
-import math_intent_detector
-import curriculum_engine
-import strategy_policy_engine
-from proof_graph import ProofGraph, ProofStep, validate_pedagogical_legality
-from math_sanitizer import ProductionMathSanitizer
-from pedagogical_builder import build_pedagogical_response, sanitize_math_text, merge_and_verify_explanations, LLMSchemaError
-
-# V4.0: Curriculum Oracle
-# curriculum_engine is already imported above, no need to re-import
-# import curriculum_engine
-
-# V231.14: Import problem understanding
-import problem_understanding
-
-try: from json_repair import repair_json
-except: repair_json = lambda x: x
-
-def safe_json_loads(raw_text: str) -> dict:
-    """V1.0: Delegates to canonical safe_extract_json with LaTeX shield."""
-    return safe_extract_json(raw_text, caller="ORCHESTRATOR_SAFE_LOADS")
-
-
-from dataclasses import dataclass
-from smart_solver import ActionContext
-
-@dataclass
-class PipelineContext:
-    grade: str
-    grade_num: int
-    topic: str
-    math_input: str
-    confidence: float
-    category: str = "GENERAL"
-    original_text: str = ""        # V4.2.15: For intent-based gating
-    sub_question_text: str = ""   # V7.3: Per-question routing context
-
-class BuddyOrchestrator:
-    def handle_fallback(self, context: PipelineContext):
-        """V4.2.3: Safe fallback for solver failures."""
-        print(f"🔄 [FALLBACK] Handling solver failure for grade {context.grade_num}")
-        from types import SimpleNamespace
-        return SimpleNamespace(success=False)
-    def __init__(self):
-        print("✅ 🟢 [BIT-LOG: המורה למתמטיקה V273.0] - SMART CLASSIFICATION + FAST PATH")
-
-        genai.configure(api_key=os.environ.get("GOOGLE_API_KEY", ""))
-        # V8.6.1: Force Strict JSON Output to prevent Markdown/Preamble leakage
-        self.model = genai.GenerativeModel(
-            model_name=GEMINI_MODEL,
-            generation_config={"response_mime_type": "application/json"}
-        )
-        self.vision_model = genai.GenerativeModel(
-            model_name=GEMINI_MODEL,
-            generation_config={"response_mime_type": "application/json"}
-        )
-        self.smart_solver = SmartSolver()  # No model parameter needed
-        
-        # V231.12: Initialize strategy manager
-        self.strategy_manager = StrategyManager(self.model)
-        self._last_ocr_confidence = 1.0 # Default confidence (V3.1.2)
-        print("🎯 [BIT-LOG] StrategyManager initialized")
-
-    # ===================== V273.0: SMART QUESTION CLASSIFICATION =====================
-
-    def _quick_classify(self, problem_text: str) -> ProcessingStrategy:
-        """
-        V5.8.0: Deterministic classification returning strict ProcessingStrategy
-        """
-        # ---------- MULTI PART / COMPLEX STRUCTURE ----------
-        if re.search(r'[אבגדהו][\.\)\:\s]', problem_text) or re.search(r'סעיף\s*[אבגדהו]', problem_text):
-            return ProcessingStrategy.STRICT_SYMBOLIC
-
-        complex_keywords = [
-            'חקור', 'חקירת', 'הוכח', 'הוכיח',
-            'מקום גיאומטרי', 'הראה כי', 'הראי כי',
-            'נתונה פונקציה', 'נתון משולש'
-        ]
-        if any(kw in problem_text for kw in complex_keywords):
-            return ProcessingStrategy.STRICT_SYMBOLIC
-
-        # ---------- PURE MATH EXPRESSION ----------
-        math_only = re.sub(r'[\u0590-\u05FF\s]', '', problem_text)
-        if len(problem_text) < 80 and len(math_only) > len(problem_text) * 0.4:
-            return ProcessingStrategy.SIMPLE_ARITHMETIC
-
-        # ---------- SHORT CALCULATION ----------
-        simple_keywords = [
-            'חשב', 'חשבי', 'פשט', 'פשטי',
-            'מהו', 'מהי', 'כמה',
-            'מצא', 'מצאי', 'פתור', 'פתרי'
-        ]
-
-        if len(problem_text) < 150 and any(kw in problem_text for kw in simple_keywords):
-            if not any(kw in problem_text for kw in ['ולכן', 'לפיכך', 'הסבר', 'נמק']):
-                return ProcessingStrategy.SIMPLE_ARITHMETIC
-
-        # ---------- DEFAULT ----------
-        return ProcessingStrategy.HEURISTIC_DEDUCTION
-
-    async def _llm_classify(self, problem_text: str) -> dict:
-        """
-        V273.0: סיווג עם LLM - למקרים לא ברורים
-        """
-        prompt = f"""
-סווג את השאלה המתמטית הבאה. החזר JSON בלבד.
-
-שאלה:
-"{problem_text[:500]}"
-
-קטגוריות:
-- SIMPLE = חישוב בודד, תשובה אחת, בלי סעיפים (דוגמה: "חשב 3+5", "פשט את הביטוי x²-4")
-- MULTI_PART = יש סעיפים א,ב,ג או מספר שאלות נפרדות
-- COMPLEX = חקירת פונקציה, הוכחה, גיאומטריה מורכבת, בעיה עם כמה שלבים
-
-JSON:
-{{
-    "complexity": "SIMPLE" / "MULTI_PART" / "COMPLEX",
-    "num_parts": מספר (1 אם פשוט, 2-6 אם יש סעיפים),
-    "reason": "הסבר קצר מאוד"
-}}
-"""
-        
-        try:
-            res = await asyncio.wait_for(
-                self.model.generate_content_async(
-                    prompt,
-                    generation_config={"temperature": 0.0}
-                ),
-                timeout=8.0
-            )
-            cost_tracker.log_api_usage(res.usage_metadata, "CLASSIFY_QUESTION")
-            
-            match = re.search(r'\{.*\}', res.text, re.DOTALL)
-            if match:
-                data = safe_json_loads(match.group())
-                data["confidence"] = "HIGH"
-                data["source"] = "LLM"
-                print(f"🏷️ [CLASSIFY] LLM result: {data}")
-                return data
-        except Exception as e:
-            print(f"⚠️ [CLASSIFY] LLM failed: {e}")
-        
-        # Fallback - assume complex to be safe
-        return {"complexity": "COMPLEX", "num_parts": 1, "confidence": "LOW", "source": "FALLBACK"}
-
-    async def _classify_question(self, problem_text: str) -> dict:
-        """
-        V273.0: סיווג משולב - מהיר קודם, LLM רק אם צריך
-        """
-        print(f"🏷️ [CLASSIFY] Analyzing: {problem_text[:60]}...")
-        
-        # Step 1: Quick classification (no LLM)
-        quick_result = self._quick_classify(problem_text)
-        
-        if quick_result["confidence"] == "HIGH":
-            print(f"🏷️ [CLASSIFY] Quick result: {quick_result['complexity']} ({quick_result['source']})")
-            return quick_result
-        
-        if quick_result["confidence"] == "MEDIUM":
-            # Medium confidence - use it but log
-            print(f"🏷️ [CLASSIFY] Medium confidence: {quick_result['complexity']} ({quick_result['source']})")
-            return quick_result
-        
-        # Step 2: Need LLM classification
-        print(f"🏷️ [CLASSIFY] Needs LLM classification...")
-        return await self._llm_classify(problem_text)
-
-    # ===================== V273.0: FAST PATH FOR SIMPLE QUESTIONS =====================
-
-    async def _quick_solve(
-        self,
-        problem_text: str,
-        grade: str,
-        student_name: str,
-        image_data: bytes = None,
-        ambiguity_warning: bool = False
-    ) -> dict:
-        """
-        V273.0: פתרון מהיר לשאלות פשוטות - קריאה אחת ל-LLM
-        """
-        print(f"⚡ [FAST PATH] Solving simple question...")
-        
-        prompt = f"""
-אתה "המורה למתמטיקה" - מורה פרטית חמה ומקצועית.
-
-פתור את השאלה הבאה עבור {student_name} (כיתה {grade}):
-
-"{problem_text}"
-
-הנחיות קריטיות:
-1. פתור צעד אחר צעד בעזרת האובייקט `ctx` הקיים בלבד.
-2. **אסור בשום פנים ואופן לכתוב הגדרות של מחלקות (class), פונקציות (def) או יבואים (import).**
-3. השתמש ב- `ctx.explain("הסבר")` לכל שלב מילולי.
-4. השתמש ב- `ctx.declare_equation("תיאור", ctx.Eq(x, 5))` למשוואות.
-5. סיים ב- `ctx.finish("תשובה סופית ב-LaTeX", "סיכום מורה")`.
-6. החזר אך ורק בלוק קוד פייתון נקי בתוך ```python.
-
-דוגמה למבנה הקוד הרצוי:
-```python
-ctx.explain("ראשית נחבר את המספרים.")
-ctx.declare_equation("פעולת החיבור", ctx.Eq(2 + 2, 4))
-ctx.finish("$$ 4 $$", "מעולה! הגענו לתוצאה.")
-```
-"""
-
-        try:
-            import asyncio
-            if image_data:
-                # Use vision model
-                res = await asyncio.wait_for(
-                    asyncio.to_thread(
-                        self.vision_model.generate_content,
-                        [
-                            prompt,
-                            {"mime_type": "image/png", "data": image_data}
-                        ]
-                    ),
-                    timeout=30.0
-                )
-            else:
-                res = await asyncio.wait_for(
-                    asyncio.to_thread(self.model.generate_content, prompt),
-                    timeout=30.0
-                )
-            
-            cost_tracker.log_api_usage(res.usage_metadata, "FAST_SOLVE")
-            
-            import math_engine
-            python_match = re.search(r'```python(.*?)```', res.text, re.DOTALL)
-            if python_match:
-                python_code = python_match.group(1).strip()
-                result = math_engine.run_llm_code(python_code)
-                if result["success"]:
-                    print(f"⚡ [FAST PATH] Python Math Engine execution successful!")
-                    return await self._format_quick_response(result, student_name)
-                else:
-                    print(f"❌ [FAST PATH] Math Engine execution error: {result.get('error')}")
-                    
-        except Exception as e:
-            print(f"❌ [FAST PATH] Error: {e}")
-        
-        # Fallback to full pipeline
-        print(f"⚠️ [FAST PATH] Falling back to full pipeline...")
-        return None
-
-    async def _format_quick_response(self, data: dict, student_name: str) -> dict:
-        """
-        V273.0: המרת תשובה מהירה לפורמט הסטנדרטי של האפליקציה
-        """
-        steps = data.get("steps", [])
-        final_answer = data.get("final_answer", "")
-        teacher_summary = data.get("teacher_summary", "")
-        
-        # Build sections format
-        formatted_steps = []
-        for step in steps:
-            formatted_steps.append({
-                "step_number": step.get("step_number", len(formatted_steps) + 1),
-                "title": f"שלב {step.get('step_number', len(formatted_steps) + 1)}",
-                "content_mixed": step.get("content_mixed", ""),
-                "block_math": step.get("block_math", "")
-            })
-        
-        sections = [{
-            "section_title": "פתרון",
-            "steps": formatted_steps,
-            "section_result": final_answer
-        }]
-        
-        # Generate audio for summary
-        audio_result = None
-        if teacher_summary:
-            teacher_summary = self._scrub_latex_from_text(teacher_summary)
-            teacher_summary = self._sanitize_teacher_response(teacher_summary)
-            
-            try:
-                audio_result = await generate_teacher_audio(teacher_summary)
-            except Exception as e:
-                print(f"🎙️ [FAST PATH] Audio failed: {e}")
-        
-        response = {
-            "sections": sections,
-            "final_answer": final_answer,
-            "teacher_closing": f"כל הכבוד {student_name}! 🎉",
-            "teacher_summary": teacher_summary
-        }
-        
-        if audio_result:
-            if audio_result.startswith("http"):
-                response["audio_url"] = audio_result
-            else:
-                response["audio_base64"] = audio_result
-        
-        return response
-
-    # ===================== V300: FEATURE-TOGGLED OCR =====================
-    # OCR_STRIP_MODE=development → Stitch & Strip (single-pass, HD, structured)
-    # OCR_STRIP_MODE=production  → Legacy Triple-Pass (safe, proven)
-
-    def _flatten_ocr_payload(self, ocr_data) -> str:
-        """
-        V9.0.2: Ensures the OCR data is converted into a single, continuous text string 
-        regardless of the API response format (JSON string, dict, or list).
-        """
-        if not ocr_data:
-            return ""
-
-        # 1. If it's a string, it might be a raw string OR a JSON string
-        if isinstance(ocr_data, str):
-            s = ocr_data.strip()
-            if (s.startswith('[') and s.endswith(']')) or (s.startswith('{') and s.endswith('}')):
-                try:
-                    # Attempt to parse if it's a JSON structured string
-                    parsed_data = json.loads(s)
-                    ocr_data = parsed_data  # Pass to dict/list handling below
-                except json.JSONDecodeError:
-                    # It's just a regular raw string
-                    return s
-            else:
-                return s
-
-        # 2. If it's a List (This fixes the V9.0.1 bug!)
-        if isinstance(ocr_data, list):
-            # Join all elements with a newline/space, ignoring empty items
-            # V9.0.2 FIX: Handle both list of strings AND list of dicts (Stitch & Strip)
-            parts = []
-            for item in ocr_data:
-                if isinstance(item, dict):
-                    # Handle structured block format: {"content": "...", "type": "..."}
-                    content = item.get("content") or item.get("text") or ""
-                    if content: parts.append(str(content).strip())
-                elif item:
-                    parts.append(str(item).strip())
-            
-            if parts:
-                return " \n ".join(parts)
-            return ""
-        
-        # 3. If it's a Dictionary
-        elif isinstance(ocr_data, dict):
-            # Look for a primary text key, otherwise convert the whole dict to string
-            res = ocr_data.get("text") or ocr_data.get("content")
-            if res:
-                return str(res).strip()
-            else:
-                return " \n ".join([f"{k}: {v}" for k, v in ocr_data.items()])
-
-        # 4. Ultimate Fallback for any other type
-        return str(ocr_data).strip()
-
-    async def transcribe_image(self, image_bytes: bytes) -> str:
-        """
-        V300: Feature-toggled OCR.
-        Returns flat problem_text string. Also stores structured OCR list
-        in self._last_ocr_structured for downstream consumers.
-        """
-        ocr_mode = os.environ.get("OCR_STRIP_MODE", "production").lower()
-        print(f"📸 [BIT-LOG] OCR mode: {ocr_mode.upper()}")
-
-        # ── V300 NEW: Stitch & Strip ──────────────────────────────────────
-        if ocr_mode == "development":
-            debug = True  # Always save strips while in DEV
-            print("📸 🔵 [BIT-LOG] Starting OCR (Stitch & Strip V300)...")
-            try:
-                structured, confidence = await ocr_strip_engine.transcribe(
-                    image_bytes=image_bytes,
-                    vision_model=self.vision_model,
-                    debug_mode=debug,
-                )
-                # Side-channel: store structured list for future use
-                self._last_ocr_structured = structured
-                self._last_ocr_confidence = confidence
-                flat = ocr_strip_engine.flatten_to_text(structured)
-                print(f"📸 🏆 [BIT-LOG] Stitch & Strip OCR complete — {len(structured)} items, Confidence: {confidence:.2f}")
-                return flat
-            except Exception as e:
-                print(f"📸 ❌ [BIT-LOG] Stitch & Strip failed ({e}), falling back to triple-pass")
-
-        # ── LEGACY: Triple-Pass ───────────────────────────────────────────
-        print("📸 🔵 [BIT-LOG] Starting OCR (Triple Pass - V231.8)...")
-        self._last_ocr_confidence = 0.85 # Default for legacy mode
-        prompt = prompts.get_transcription_prompt()
-
-        results = []
-
-        # Pass 1: Original Image
-        try:
-            res = await asyncio.wait_for(
-                self.vision_model.generate_content_async(
-                    [prompt, {"mime_type": "image/jpeg", "data": image_bytes}],
-                    generation_config={"temperature": 0.0}
-                ),
-                timeout=18.0
-            )
-            results.append(res.text.strip())
-            cost_tracker.log_api_usage(res.usage_metadata, "OCR_PASS_1")
-            print(f"📸 🟢 [BIT-LOG] OCR Pass 1 (Original): {len(results[0])} chars")
-        except Exception as e:
-            print(f"📸 🟡 [BIT-LOG] OCR Pass 1 failed: {e}")
-            results.append("Error")
-
-        # Pass 2: Enhanced Image
-        try:
-            enhanced_bytes = self._enhance_image_bytes(image_bytes)
-            res = await asyncio.wait_for(
-                self.vision_model.generate_content_async(
-                    [prompt, {"mime_type": "image/jpeg", "data": enhanced_bytes}],
-                    generation_config={"temperature": 0.0}
-                ),
-                timeout=18.0
-            )
-            results.append(res.text.strip())
-            cost_tracker.log_api_usage(res.usage_metadata, "OCR_PASS_2")
-            print(f"📸 🟢 [BIT-LOG] OCR Pass 2 (Enhanced): {len(results[1])} chars")
-        except Exception as e:
-            print(f"📸 🟡 [BIT-LOG] OCR Pass 2 failed: {e}")
-            results.append("Error")
-
-        # Pass 3: Retry with reinforced prompt for complex fractions
-        try:
-            retry_prompt = prompt + "\n\nCRITICAL: Pay special attention to complex fractions with powers in denominators, like (x^2-16)^2."
-            res = await asyncio.wait_for(
-                self.vision_model.generate_content_async(
-                    [retry_prompt, {"mime_type": "image/jpeg", "data": image_bytes}],
-                    generation_config={"temperature": 0.0}
-                ),
-                timeout=18.0
-            )
-            results.append(res.text.strip())
-            cost_tracker.log_api_usage(res.usage_metadata, "OCR_PASS_3")
-            print(f"📸 🟢 [BIT-LOG] OCR Pass 3 (Retry): {len(results[2])} chars")
-        except Exception as e:
-            print(f"📸 🟡 [BIT-LOG] OCR Pass 3 failed: {e}")
-            results.append("Error")
-
-        final_text = self._merge_ocr_results(results)
-        # V9.0.2: Flatten payload (Robust handling of Union[str, list, dict])
-        final_text = self._flatten_ocr_payload(final_text)
-        
-        # Build minimal structured list for consistency
-        self._last_ocr_structured = [{"type": "text", "content": final_text}]
-        print(f"📸 🏆 [BIT-LOG] OCR Final (Merged): {len(final_text)} chars")
-        return final_text
-
-    def _enhance_image_bytes(self, image_bytes: bytes) -> bytes:
-        """V231.4: Attempt high-contrast enhancement. Falls back to original."""
-        try:
-            from PIL import Image, ImageEnhance
-            import io
-            img = Image.open(io.BytesIO(image_bytes))
-            # High contrast + sharpness for better OCR
-            img = ImageEnhance.Contrast(img).enhance(2.0)
-            img = ImageEnhance.Sharpness(img).enhance(2.0)
-            buf = io.BytesIO()
-            img.save(buf, format='PNG')
-            return buf.getvalue()
-        except Exception as e:
-            logging.debug(f"⚠️ [BIT-LOG] Image enhancement failed: {e}")
-            # PIL not available or image issue — use original
-            return image_bytes
-
-    def _merge_ocr_results(self, results: list) -> str:
-        """V231.4: Trust the most mathematically detailed OCR result."""
-        def _math_complexity(text: str) -> int:
-            """Score how much math content a string has."""
-            if not text: return 0
-            score = 0
-            score += text.count('\\frac') * 3
-            score += text.count('^') * 2
-            score += text.count('\\sin') + text.count('\\cos') + text.count('\\tan')
-            score += text.count('\\sqrt') * 2
-            score += text.count('\\int') * 3
-            score += text.count('סעיף') * 5  # sub-question markers are very valuable
-            score += text.count('שאלה') * 5  # top-level headers are very valuable
-            score += len(text) // 50  # length bonus
-            return score
-
-        valid = [r for r in results if r and r != "Error"]
-        if not valid:
-            return "Error"
-        
-        scored = [(r, _math_complexity(r)) for r in valid]
-        scored.sort(key=lambda x: x[1], reverse=True)
-        
-        winner = scored[0]
-        print(f"📸 🏆 [BIT-LOG] OCR Winner: score={winner[1]} (of {len(valid)} candidates)")
-        return winner[0]
-
-    async def _extract_key_data(self, problem_text: str, image_data: bytes = None) -> dict:
-        """V231.14: Phase 1 - Extract specific values with validation and image support."""
-        for attempt in range(1, 3):  # 2 attempts
-            try:
-                print(f"⚓ [BIT-LOG] Data Anchor Extraction (Attempt {attempt}). Image Data: {type(image_data)} {len(image_data) if image_data else 'None'}")
-                prompt = prompts.get_data_extraction_prompt(problem_text)
-                if not prompt:
-                    prompt = f"Extract math data from this problem: {problem_text}"
-                
-                content = [prompt]
-                if image_data and isinstance(image_data, bytes):
-                    # V316.9: Use canonical dict format for maximum SDK compatibility
-                    content.append({"mime_type": "image/png", "data": image_data})
-                    print(f"📸 [BIT-LOG] Appended image part (size: {len(image_data)})")
-                
-                res = await asyncio.wait_for(
-                    self.model.generate_content_async(
-                        content,
-                        generation_config={"temperature": 0.0}
-                    ),
-                    timeout=15.0  # 15s timeout per attempt
-                )
-                cost_tracker.log_api_usage(res.usage_metadata, "DATA_ANCHOR")
-                match = re.search(r'\{.*\}', res.text, re.DOTALL)
-                if match:
-                    data = safe_json_loads(match.group())
-                    
-                    # V317.5: Robust JSON Handling - Smart Unification
-                    data = unify_data_anchor(data)
-                    if isinstance(data, dict):
-                        print(f"⚓ [BIT-LOG] Unified Data Anchor: {json.dumps(data, ensure_ascii=False)[:100]}...")
-
-                    # V261.X: Guard against parse-failure sentinel being treated as valid data
-                    if data and isinstance(data, dict) and data.get('logic_error') and data.get('error_type') == 'PARSING_FAILURE':
-                        print(f"⚠️ [BIT-LOG] Data Anchor JSON parse failed (Attempt {attempt}/2) — skipping sentinel.")
-                        continue
-
-                    # ✅ V231.12: Validate extracted data
-                    if data and isinstance(data, dict):
-                        # Validate function equations - must have '=' sign
-                        if 'function_equations' in data:
-                            valid_eqs = []
-                            for eq in data['function_equations']:
-                                # Must have '=' sign and be longer than just "f(x)"
-                                if '=' in eq and len(eq) > 5:
-                                    valid_eqs.append(eq)
-                                else:
-                                    print(f"⚠️ [BIT-LOG] Invalid equation (no '=' or too short): '{eq}'")
-                            
-                            data['function_equations'] = valid_eqs
-                            
-                            # V1.1: Partial Semantic Recovery logic
-                            if not valid_eqs:
-                                # Determine if recovery is possible (e.g., if there's a point or a simple equation)
-                                has_points = len(data.get('points', [])) > 0
-                                has_equations = len(data.get('equations', [])) > 0
-                                
-                                if has_points or has_equations:
-                                    print(f"🔄 [V1.1] Partial Semantic Recovery: No function f(x) but found data. Continuing...")
-                                    data['anchor_state'] = "PARTIAL_RECOVERABLE"
-                                else:
-                                    print(f"⚠️ [V1.1] Incomplete data: No function or equations. Recapture likely needed.")
-                                    data['anchor_state'] = "INCOMPLETE"
-                            else:
-                                data['anchor_state'] = "FULL"
-
-                            if not valid_eqs and 'function_equations' in data:
-                                print(f"⚠️ [BIT-LOG] No valid function equations found in attempt {attempt}!")
-                        
-                        print(f"⚓ [BIT-LOG] Data Anchor (Attempt {attempt}): {json.dumps(data, ensure_ascii=False)}")
-                        return data
-            except asyncio.TimeoutError:
-                print(f"⚠️ [BIT-LOG] Data Anchor timeout (Attempt {attempt}/2)")
-            except Exception as e:
-                print(f"⚠️ [BIT-LOG] Data Anchor error (Attempt {attempt}/2): {e}")
-                import traceback
-                traceback.print_exc()
-
-        
-        print("🚨 [BIT-LOG] CRITICAL: Data Anchor extraction failed completely!")
-        return None
-
-    async def _understand_problem(
-        self,
-        problem_text: str,
-        data_anchor: dict
-    ) -> dict:
-        """
-        V231.14: Understand problem structure BEFORE solving.
-        
-        Analyzes:
-        - What type of problem is this?
-        - How many sub-questions (א, ב, ג)?
-        - What is each sub-question asking?
-        - What are the dependencies?
-        
-        Returns understanding JSON.
-        """
-        print("📋 [BIT-LOG] Analyzing problem structure...")
-        
-        try:
-            prompt = problem_understanding.get_problem_understanding_prompt(
-                problem_text,
-                data_anchor
-            )
-            
-            response = await asyncio.wait_for(
-                self.model.generate_content_async(prompt),
-                timeout=15.0
-            )
-            
-            understanding = problem_understanding.parse_understanding(response.text)
-            
-            # Validate
-            if not problem_understanding.validate_understanding(understanding):
-                print("⚠️ [BIT-LOG] Invalid understanding structure, using fallback")
-                return self._create_fallback_understanding(problem_text, data_anchor)
-                
-            # V260.2: Enforce Hard Rules (Locus)
-            understanding = problem_understanding.enforce_locus_rule(understanding, problem_text)
-            
-            print(f"📋 [UNDERSTANDING] Type: {understanding['problem_type']}")
-            print(f"📋 [UNDERSTANDING] Sub-questions: {len(understanding['sub_questions'])}")
-            
-            for sq in understanding['sub_questions']:
-                print(f"   - {sq['id']}: {sq['topic']}")
-            
-            return understanding
-        
-        except Exception as e:
-            print(f"❌ [BIT-LOG] Understanding failed: {e}")
-            return self._create_fallback_understanding(problem_text, data_anchor)
-    
-    def _create_fallback_understanding(self, problem_text: str, data_anchor: dict) -> dict:
-        """Create simple understanding if analysis fails."""
-        return {
-            "problem_type": "GENERAL",
-            "main_question": "Solve the problem",
-            "sub_questions": [{
-                "id": "main",
-                "question": problem_text,
-                "topic": "GENERAL",
-                "requires": [],
-                "expected_output": "solution"
-            }],
-            "solving_order": ["main"],
-            "dependencies": {}
-        }
-
-    async def _generate_strategy_card(self, problem_text: str, data_anchor: dict) -> dict:
-        """V260.0: Generate high-level strategy card."""
-        print("🧭 [BIT-LOG] Generating Strategy Card...")
-        try:
-            prompt = prompts.get_strategy_card_prompt(problem_text, data_anchor)
-            res = await asyncio.wait_for(
-                self.model.generate_content_async(prompt),
-                timeout=15.0
-            )
-            cost_tracker.log_api_usage(res.usage_metadata, "STRATEGY_CARD")
-            match = re.search(r'\{.*\}', res.text, re.DOTALL)
-            if match:
-                data = safe_json_loads(match.group())
-                print(f"🧭 [BIT-LOG] Strategy generated: {data.get('title')}")
-                return self._inject_bidi_markers(data)
-        except Exception as e:
-            print(f"⚠️ [BIT-LOG] Strategy generation failed: {e}")
-        return None
-
-    async def _generate_visual_context(self, problem_text: str, category: str, image_data: bytes) -> dict:
-        """V300.3: Generate visual description (Sketch). Supports text-only fallback."""
-        print("GENERATE: [BIT-LOG] Generating Visual Context (Smart Trigger)...")
-        try:
-            prompt = prompts.get_visual_context_prompt(problem_text, category)
-            
-            # V300.3: Multi-modal Support (Handle both Image and Text-Only)
-            if image_data:
-                # Use vision model with image
-                res = await asyncio.wait_for(
-                    self.vision_model.generate_content_async([
-                        prompt,
-                        {"mime_type": "image/png", "data": image_data}
-                    ]),
-                    timeout=15.0
-                )
-            else:
-                # V300.3: Text-only schematic generation
-                print("INFO: [BIT-LOG] No image provided. Generating sketch from text description.")
-                res = await asyncio.wait_for(
-                    self.vision_model.generate_content_async(prompt),
-                    timeout=15.0
-                )
-                
-            cost_tracker.log_api_usage(res.usage_metadata, "VISUAL_CONTEXT")
-            match = re.search(r'\{.*\}', res.text, re.DOTALL)
-            if match:
-                data = safe_json_loads(match.group())
-                print(f"SUCCESS: [BIT-LOG] Visual context generated: {data.get('title')}")
-                return self._inject_bidi_markers(data)
-        except Exception as e:
-            print(f"ERROR: [BIT-LOG] Visual context generation failed: {e}")
-        return None
-
-    def _verify_completeness(self, understanding: dict, solutions: list) -> list:
-        """V260.0: Check if all sub-questions were solved."""
-        required_ids = [sq['id'] for sq in understanding['sub_questions']]
-        solved_ids = [sol['sub_question_id'] for sol in solutions]
-        
-        missing = [rid for rid in required_ids if rid not in solved_ids]
-        
-        if missing:
-            print(f"🕵️‍♂️ [BIT-LOG] Completeness Check: MISSING {missing}")
-        else:
-            print("🕵️‍♂️ [BIT-LOG] Completeness Check: PASSED")
-            
-    async def _verify_pedagogical_depth(self, llm_response: dict) -> dict:
-        """V260.1: The Strict Teacher - Verify step depth and clarity."""
-        print("👩‍🏫 [BIT-LOG] Strict Teacher: Verifying depth...")
-        
-        # Extract steps content for analysis
-        steps_text = "\n".join([f"Step {s.get('step')}: {s.get('content')} | {s.get('block_math')}" 
-                              for s in llm_response.get("steps", [])])
-        
-        prompt = f"""
-        YOU ARE A STRICT MATH TEACHER. Review this student's solution.
-        
-        Student's Solution Steps:
-        {steps_text}
-        
-        CRITERIA ("Atomic Algebra"):
-        1. did the student skip algebraic steps? (e.g. going from 2x=10 directly to x=5 is BAD. Must show /2).
-        2. Is the Hebrew explanation clear and simple?
-        3. Are there at least 3-4 steps for a complex problem/locus?
-        4. IS 'block_math' POPULATED? Steps must show the math in LaTeX! (e.g., don't just say "we calculate", SHOW the calculation).
-        
-        OUTPUT JSON:
-        {{
-            "approved": true/false,
-            "feedback": "Specific feedback if rejected (e.g., 'Skipped division step', 'Missing LaTeX in block_math')"
-        }}
-        """
-        
-        try:
-            res = await asyncio.wait_for(
-                self.model.generate_content_async(prompt),
-                timeout=10.0
-            )
-            cost_tracker.log_api_usage(res.usage_metadata, "STRICT_TEACHER_VERIFY")
-            match = re.search(r'\{.*\}', res.text, re.DOTALL)
-            if match:
-                data = safe_json_loads(match.group())
-                print(f"👩‍🏫 [BIT-LOG] Verdict: {'✅ APPROVED' if data.get('approved') else '❌ REJECTED'} ({data.get('feedback')})")
-                # V4.2.4: Final Output Sealing (Zero-Leakage Guard)
-            import math_intent_detector
-            grade_num = math_intent_detector._extract_grade_number(grade)
-            data = seal_pedagogical_output(data, grade_num)
-            
-            return data
-        except Exception as e:
-            print(f"⚠️ [BIT-LOG] Verification failed: {e}")
-        
-        # Default to approved if check fails to avoid blocking
-        return {"approved": True, "feedback": ""}
-
-    # ===================== V272.0: SMART TEACHER SUMMARY =====================
-
-    def _generate_deterministic_summary(
-        self,
-        problem_type: str,
-        topics_text: str,
-        answers_text: str,
-        proof_graph = None
-    ) -> str:
-        """
-        V4.2 (Behavioral Firewall): Deterministic Template Renderer.
-        Now used ONLY as fallback if LLM summary fails.
-        """
-        print("🎙️ [V4.2] Generating DETERMINISTIC teacher summary (fallback)...")
-        
-        topic = topics_text if topics_text != "מתמטיקה כללית" else "התרגיל ששלחת"
-        
-        methods = []
-        if proof_graph:
-            for step in proof_graph.steps:
-                if step.logic_description:
-                    methods.append(step.logic_description)
-        
-        methods_text = " ו- ".join(list(set(methods))[:2]) if methods else "שיטות פתרון בסיסיות"
-
-        template = (
-            f"התרגיל עסק ב: {topic}. "
-            f"השתמשנו בשיטות: {methods_text}. "
-            f"הגענו לתשובה: {answers_text}. "
-            f"הטריק לזכור, תמיד כדאי לעבוד שלב אחר שלב בצורה מסודרת. "
-            f"כל הכבוד על ההתמדה!"
-        )
-        
-        return template
-
-    async def _generate_teacher_summary(
-        self,
-        problem_text: str,
-        all_solutions: list,
-        understanding: dict,
-        proof_graph = None,
-        student_name: str = "תלמיד",
-        student_gender: str = "M"
-    ) -> dict:
-        """
-        V285.1: LLM-powered pedagogical summary generator.
-        Returns a dict with: topic_summary, key_concepts, formulas_to_remember, tts_speech.
-        Falls back to deterministic template on error.
-        """
-        # Extract answers and topics for context
-        final_answers = []
-        topics_used = []
-        for sol in all_solutions:
-            if 'response' in sol and sol['response']:
-                resp = sol['response']
-                if isinstance(resp, dict):
-                    if resp.get('final_answer'): final_answers.append(resp['final_answer'])
-            if sol.get('topic'): topics_used.append(sol['topic'])
-        
-        answers_text = ", ".join(final_answers[:3]) if final_answers else "לא נמצאו תשובות"
-        topics_text = ", ".join(set(topics_used)) if topics_used else "מתמטיקה כללית"
-        problem_type = understanding.get('problem_type', 'GENERAL')
-
-        # Try LLM-powered summary
-        try:
-            print("🎙️ [V285.1] Generating LLM pedagogical summary...")
-            
-            summary_prompt = prompts.get_teacher_summary_prompt(
-                student_name=student_name,
-                student_gender=student_gender
-            )
-            
-            # Build context for the LLM
-            context = f"""
-            הבעיה: {problem_text[:300]}
-            סוג בעיה: {problem_type}
-            נושאים: {topics_text}
-            תשובות סופיות: {answers_text}
-            """
-            
-            response = await asyncio.wait_for(
-                self.model.generate_content_async(summary_prompt + "\n\n" + context),
-                timeout=30.0
-            )
-            
-            raw_text = response.text.strip()
-            print(f"🎙️ [V285.1] LLM Summary received ({len(raw_text)} chars)")
-            logger.info(f"🎙️ [V285.1] RAW: {raw_text[:300]}")
-            
-            match = re.search(r'\{.*\}', raw_text, re.DOTALL)
-            if not match:
-                raise ValueError("No JSON found in LLM response for teacher summary")
-            summary_data = safe_extract_json(match.group(), caller="TEACHER_SUMMARY")
-            
-            if summary_data.get("error_type") == "PARSING_FAILURE":
-                raise ValueError("JSON parsing failed for teacher summary")
-            
-            # Build structured result
-            result = {
-                "topic_summary": summary_data.get("topic_summary", topics_text),
-                "key_concepts": summary_data.get("key_concepts", []),
-                "formulas_to_remember": summary_data.get("formulas_to_remember", []),
-                "tts_speech": summary_data.get("tts_speech", ""),
-            }
-            
-            # Build display text (for teacher_summary field in response)
-            display_parts = []
-            if result["topic_summary"]:
-                display_parts.append(f"📚 נושא: {result['topic_summary']}")
-            if result["key_concepts"]:
-                concepts = "\n".join(f"• {c}" for c in result["key_concepts"])
-                display_parts.append(f"💡 תובנות מפתח:\n{concepts}")
-            if result["formulas_to_remember"]:
-                formulas = "\n".join(f"$${f}$$" for f in result["formulas_to_remember"])
-                display_parts.append(f"📐 נוסחאות לזכור:\n{formulas}")
-            
-            result["display_text"] = "\n\n".join(display_parts)
-            
-            print(f"🎙️ ✅ [V285.1] Summary ready: {result['topic_summary']}, {len(result['key_concepts'])} concepts")
-            return result
-            
-        except Exception as e:
-            print(f"🎙️ ⚠️ [V285.1] LLM summary failed: {e}. Using deterministic fallback.")
-            fallback_text = self._generate_deterministic_summary(problem_type, topics_text, answers_text, proof_graph)
-            return {
-                "topic_summary": topics_text,
-                "key_concepts": [],
-                "formulas_to_remember": [],
-                "tts_speech": fallback_text,
-                "display_text": fallback_text
-            }
-
-    def _get_enhanced_fallback_summary(self, problem_type: str, answers: str) -> str:
-        """V272.0: Fallback משופר לפי סוג הבעיה"""
-        fallbacks = {
-            "FUNCTION_ANALYSIS": "עברנו על חקירת פונקציה מלאה! מצאנו נקודות קיצון, תחומי עלייה וירידה, והבנו את התנהגות הפונקציה. הטריק הוא לזכור שנגזרת אפס מסמנת נקודות קיצון. כל הכבוד!",
-            "GEOMETRY": "פתרנו שאלה בגיאומטריה אנליטית! השתמשנו בנוסחאות מרחק ומשוואות של צורות גיאומטריות. תמיד כדאי לצייר סקיצה לפני שמתחילים לחשב. מעולה!",
-            "CALCULUS": "עבדנו עם נגזרות ואינטגרלים! זכרו את כללי הגזירה הבסיסיים ואת כלל השרשרת. התרגול הוא המפתח להצלחה בחדוא. כל הכבוד על ההתמדה!",
-            "ALGEBRA": "פתרנו משוואות בצורה מסודרת! הדרך היא לבודד את הנעלם צעד אחר צעד. תמיד כדאי לבדוק את התשובה על ידי הצבה חזרה. יופי של עבודה!",
-            "TRIGONOMETRY": "עבדנו עם טריגונומטריה! השתמשנו בזהויות טריגונומטריות ובקשרים בין הפונקציות. כדאי לזכור את הזהויות הבסיסיות בעל פה. מצוין!",
-            "INVESTIGATION": "עברנו על חקירת פונקציה מלאה! מצאנו תחום, נקודות חיתוך עם הצירים, נגזרנו ומצאנו קיצון. הטריק הוא לעבוד בשיטתיות - שלב אחרי שלב. כל הכבוד!",
-        }
-        
-        base = fallbacks.get(problem_type, "פתרנו את התרגיל צעד אחר צעד בצורה מסודרת. כל שלב הוביל לשלב הבא עד שהגענו לתשובה. כל הכבוד על ההתמדה!")
-        
-        if answers and answers != "לא נמצאו תשובות":
-            base += f" הגענו לתשובה: {answers[:50]}."
-        
-        return base
-
-    # ===================== V285.0: CHECK ME (HOMEWORK VERIFICATION) =====================
-
-    async def _check_student_work(self, image_data_list: List[bytes], grade: str, student_name: str,
-                                   student_gender: str = "M", question_id: str = "q_check"):
-        """
-        V285.0: Dedicated pipeline for the "Check Me" feature.
-        Sends the raw image to Gemini Vision with the check-me prompt.
-        The LLM acts as a homework checker, NOT a solver.
-        """
-        print(f"📝 [CHECK-ME] Starting homework verification for {student_name}")
-
-        # Step 1: Emit WORKING state
-        yield BuddyEvent(
-            question_id=question_id,
-            state=BuddyState.SECTION_WORKING,
-            current_section_id="CHECK",
-            payload={"status": "המורה בודקת את העבודה שלך... 📝"}
-        )
-
-        try:
-            # V311.0: Data Slicing Guardrail
-            # First, transcribe and extract the "Absolute Truth" of the problem from the FIRST image
-            image_data = image_data_list[0]
-            print("📝 [CHECK-ME] Step 1.5: Extracting Problem Data (Data Slicing from image_00)...")
-            problem_text = await self.transcribe_image(image_data)
-            data_anchor = await self._extract_key_data(problem_text, image_data=image_data)
-
-            # Step 2: Build check-me prompt and send to Vision LLM
-            check_prompt = prompts.get_check_me_prompt(
-                grade=grade,
-                student_name=student_name,
-                student_gender=student_gender,
-                data_anchor=data_anchor
-            )
-
-            # Prepare images for Gemini Vision
-            vision_content = [check_prompt]
-            for img_bytes in image_data_list:
-                vision_content.append({"mime_type": "image/png", "data": img_bytes})
-
-            print(f"📝 [CHECK-ME] Sending {len(image_data_list)} images + check prompt to Vision LLM...")
-
-            response = await asyncio.wait_for(
-                self.vision_model.generate_content_async(vision_content),
-                timeout=60.0
-            )
-
-            raw_text = response.text.strip()
-            print(f"📝 [CHECK-ME] LLM Response received ({len(raw_text)} chars)")
-            logger.info(f"📝 [CHECK-ME] RAW LLM: {raw_text[:500]}")
-
-            # Step 3: Parse JSON using the canonical safe_extract_json
-            match = re.search(r'\{.*\}', raw_text, re.DOTALL)
-            if not match:
-                print("📝 ❌ [CHECK-ME] No JSON found in LLM response")
-                yield BuddyEvent(
-                    question_id=question_id,
-                    state=BuddyState.ERROR,
-                    payload=build_standard_response(
-                        final_answer="מצטערת, לא הצלחתי לפענח את הניתוח. נסו שוב? 🔄",
-                        logic_error=True,
-                    )
-                )
-                return
-            check_result = safe_extract_json(match.group(), caller="CHECK_ME")
-
-            if check_result.get("error_type") == "PARSING_FAILURE":
-                print("📝 ❌ [CHECK-ME] JSON parsing failed, returning error")
-                yield BuddyEvent(
-                    question_id=question_id,
-                    state=BuddyState.ERROR,
-                    payload=build_standard_response(
-                        final_answer="מצטערת, לא הצלחתי לפענח את הניתוח. נסו שוב? 🔄",
-                        logic_error=True,
-                    )
-                )
-                return
-
-            # Step 4: Extract fields from LLM response
-            verdict = check_result.get("verdict", "has_errors")
-            score = check_result.get("score", 0)
-            mistakes = check_result.get("mistakes", [])
-            encouragement = check_result.get("encouragement", "")
-            problem_identified = check_result.get("problem_identified", "")
-            methodology_ok = check_result.get("methodology_ok", True)
-            methodology_note = check_result.get("methodology_note", "")
-            visual_note = check_result.get("visual_note")
-            correct_answer = check_result.get("correct_final_answer", "")
-            feedback_steps = check_result.get("feedback_steps", [])
-
-            print(f"📝 ✅ [CHECK-ME] Verdict: {verdict}, Steps: {len(feedback_steps)}")
-
-            # ═══════════════════════════════════════════════════════════
-            # Step 5: Emit STRATEGY_READY — Methodology card
-            # ═══════════════════════════════════════════════════════════
-            strategy_content = f"**תרגיל שזוהה:** ${problem_identified}$\n\n"
-            if methodology_ok:
-                strategy_content += f"✅ **השיטה נכונה:** {methodology_note}" if methodology_note else "✅ **השיטה שנבחרה נכונה!**"
-            else:
-                strategy_content += f"❌ **בעיה בשיטה:** {methodology_note}"
-
-            strategy_card = {
-                "section_title": "בדיקת שיטת פתרון 🔍",
-                "bullets": [strategy_content]
-            }
-
-            # Generate TTS audio for encouragement
-            audio_url = None
-            if encouragement:
-                try:
-                    tts_text = self._scrub_latex_from_text(encouragement)
-                    tts_text = self._sanitize_teacher_response(tts_text)
-                    if tts_text:
-                        print(f"🎙️ [CHECK-ME] Generating TTS for: {tts_text[:60]}...")
-                        audio_url = await generate_teacher_audio(tts_text, output_path=None)
-                except Exception as e:
-                    print(f"🎙️ ❌ [CHECK-ME] TTS failed: {e}")
-
-            strategy_payload = {"strategy_card": strategy_card, "teacher_summary": encouragement}
-            if audio_url:
-                if audio_url.startswith("http"):
-                    strategy_payload["audio_url"] = audio_url
-                else:
-                    strategy_payload["audio_base64"] = audio_url
-
-            yield BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.STRATEGY_READY,
-                payload=strategy_payload
-            )
-
-            # ═══════════════════════════════════════════════════════════
-            # Step 6: Emit SECTION_READY per feedback step
-            # ═══════════════════════════════════════════════════════════
-            for fb_step in feedback_steps:
-                step_id = fb_step.get("step_id", 0)
-                student_wrote = fb_step.get("student_wrote", "")
-                is_correct = fb_step.get("is_correct", True)
-                error_desc = fb_step.get("error_description", "") or ""
-                should_be = fb_step.get("should_be", "") or ""
-
-                # Build rich content for this step
-                if is_correct:
-                    title = f"✅ שלב {step_id} — נכון!"
-                    content = f"מה שכתבת: ${student_wrote}$" if student_wrote else "נכון!"
-                    if error_desc:
-                        content += f"\n\n{error_desc}"
-                else:
-                    title = f"❌ שלב {step_id} — יש טעות"
-                    content = f"**מה שכתבת:** ${student_wrote}$\n\n" if student_wrote else ""
-                    content += f"**הטעות:** {error_desc}"
-                    if should_be:
-                        content += f"\n\n**מה שצריך להיות:** ${should_be}$"
-
-                section_data = {
-                    "section_title": title,
-                    "steps": [{
-                        "step_id": step_id,
-                        "content_mixed": content,
-                        "block_math": ""
-                    }]
-                }
-
-                yield BuddyEvent(
-                    question_id=question_id,
-                    state=BuddyState.SECTION_READY,
-                    current_section_id=f"CHECK_{step_id}",
-                    payload=section_data
-                )
-
-            # ═══════════════════════════════════════════════════════════
-            # Step 7: Visual note (if any)
-            # ═══════════════════════════════════════════════════════════
-            if visual_note:
-                yield BuddyEvent(
-                    question_id=question_id,
-                    state=BuddyState.SECTION_READY,
-                    current_section_id="CHECK_VISUAL",
-                    payload={
-                        "section_title": "הערה על שרטוט 📐",
-                        "steps": [{
-                            "step_id": 99,
-                            "content_mixed": visual_note,
-                            "block_math": ""
-                        }]
-                    }
-                )
-
-            # ═══════════════════════════════════════════════════════════
-            # Step 8: COMPLETE with final answer & Protocol Alignment
-            # ═══════════════════════════════════════════════════════════
-            from pedagogical_builder import sanitize_math_text
-            
-            # V311.0: LaTeX UI Safety
-            safe_correct_answer = sanitize_math_text(correct_answer) if correct_answer else ""
-            if safe_correct_answer and not safe_correct_answer.startswith("$$") and not safe_correct_answer.startswith("$"):
-                safe_correct_answer = f"$${safe_correct_answer}$$"
-
-            if verdict == "correct":
-                final_answer_text = f"✅ כל הכבוד! הפתרון נכון! {encouragement}"
-            elif verdict == "unreadable":
-                final_answer_text = "📸 לא הצלחתי לקרוא את כתב היד. נסו לצלם שוב בצורה ברורה יותר."
-            elif verdict == "methodology_error":
-                final_answer_text = f"📐 יש בעיה בשיטת הפתרון. {methodology_note}"
-            else:
-                final_answer_text = f"📝 התשובה הנכונה: {safe_correct_answer}" if safe_correct_answer else encouragement
-
-            yield BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.COMPLETE,
-                payload={
-                    "final_answer": final_answer_text,
-                    "verdict": verdict,
-                    "is_correct": verdict == "correct",
-                    "score": score,
-                    "mistakes": mistakes,
-                    "feedback": encouragement, # Protocol Alignment
-                    "correct_answer": safe_correct_answer, # Protocol Alignment
-                    "problem_identified": problem_identified
-                }
-            )
-
-        except asyncio.TimeoutError:
-            print("📝 ❌ [CHECK-ME] LLM timeout (60s)")
-            yield BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.ERROR,
-                payload=build_standard_response(
-                    final_answer="הבדיקה לקחה יותר מדי זמן. נסו שוב? ⏱️",
-                    logic_error=True,
-                )
-            )
-
-        except Exception as e:
-            logger.exception("CHECK-ME ERROR")
-            print(f"📝 ❌ [CHECK-ME] Error: {e}")
-            yield BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.ERROR,
-                payload=build_standard_response(
-                    final_answer="אופס! משהו השתבש בבדיקה. נסו שוב? 🔄",
-                    logic_error=True,
-                )
-            )
-
-    # ===================== SMART SOLVE =====================
-
-
-    async def smart_solve(
-        self,
-        problem_text: str,
-        data_anchor: dict,
-        grade: str,
-        category: str,
-        student_name: str,
-        student_gender: str = "M",
-        image_data: bytes = None,
-        image_data_list: list = None,
-        ambiguity_warning: bool = False,
-        processing_strategy: ProcessingStrategy = None,
-        question_id: str = "q_default",
-        **kwargs
-    ):
-        """
-        
-        Workflow:
-        1. Understand problem structure
-        2. Solve each sub-question (WITH IMAGE!)
-        3. Build comprehensive response
-        """
-        print("🎯 [BIT-LOG] Using SMART SOLVE (V231.15)")
-        uid = kwargs.get('uid')
-        assessment_sent = False
-        
-        try:
-            # Heartbeat: Strategy/Planning
-            yield BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.SECTION_WORKING,
-                current_section_id="בניית אסטרטגיה",
-                payload={"status": "המורה בונה אסטרטגיה לפתרון..."}
-            )
-
-            # Step 1: Understand problem structure
-            understanding = await self._understand_problem(problem_text, data_anchor)
-            
-            # V8.9.6: SLICING FAILSAFE (Token Burner Prevention)
-            # If this is a function investigation but the Data Anchor has NO functions,
-            # we must NOT slice into 9 sub-questions. We force Single-Shot Fallback.
-            is_investigation = understanding.get("problem_type") in ["FUNCTION_ANALYSIS", "INVESTIGATION", "CALCULUS"]
-            has_anchor_functions = bool(data_anchor.get("function_equations"))
-            
-            if is_investigation and not has_anchor_functions:
-                print("🛑 [V8.9.6] Slicing Failsafe Triggered: No functions in Anchor for Investigation. Forcing Single-Shot.")
-                understanding = self._create_fallback_understanding(problem_text, data_anchor)
-            
-            # V260.0: Generate Pedagogical Context (Strategy & Visuals)
-            strategy_card = await self._generate_strategy_card(problem_text, data_anchor)
-            
-            # V8.6.9: Wrap in sections list so solution_screen.dart can correctly parse it
-            yield BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.STRATEGY_READY,
-                payload={"sections": [strategy_card]} if strategy_card else {}
-            )
-
-            # V300.3: Smart Visual Triggers (Product Alignment)
-            # The goal: Trigger a sketch if explicitly requested or if it's a visual category without an original image.
-            visual_categories = ["GEOMETRY", "GEOMETRY_ANALYTIC", "TRIGONOMETRY", "INVESTIGATION", "FUNCTIONS", "GEOMETRIC_LOCUS", "CALCULUS"]
-            problem_type = understanding.get("problem_type", "").upper()
-            
-            # Explicit drawing keywords in text (Supports Dutch/Hebrew variations)
-            explicit_drawing_keywords = ["שרטט", "סרטט", "סקיצה", "גרף", "המחשה", "צייר", "כיוון", "שרטוט", "איזה מן הגרפים", "איזה מהגרפים", "איזה גרף מתאר"]
-            is_explicitly_requested = any(keyword in problem_text for keyword in explicit_drawing_keywords)
-            
-            # V300.3: Also check individual sub-questions for explicit requests
-            if not is_explicitly_requested and "sub_questions" in understanding:
-                for sub_q in understanding["sub_questions"]:
-                    if any(kw in sub_q.get("question", "") for kw in explicit_drawing_keywords):
-                        is_explicitly_requested = True
-                        break
-            
-            # Helper sketch: Visual category + no original image provided (or manual request)
-            has_original_image = bool(image_data)
-            needs_helper_sketch = (problem_type in visual_categories) and (not has_original_image)
-            
-            visual_context = None
-            if is_explicitly_requested or needs_helper_sketch:
-                print(f"TRIGGER: [V300.3] Visual Context Triggered: Explicit={is_explicitly_requested}, Helper={needs_helper_sketch}")
-                visual_context = await self._generate_visual_context(problem_text, problem_type or category, image_data)
-            
-            graph_svg = None
-            if visual_context and visual_context.get("latex_input"):
-                print("📉 [V290.0] Generating Chalkboard SVG...")
-                try:
-                    # V302.0: HOTFIX - SYMPY_PARSE_ERROR guard
-                    # If the input is just the d1=d2 placeholder (from prompt instructions), skip it.
-                    if "d_1" in visual_context["latex_input"] and "=" in visual_context["latex_input"]:
-                         print("📉 [V302.0] Skipping placeholder d1=d2 equation to avoid SymPy parse error.")
-                         graph_svg = None
-                    else:
-                        graph_svg = visuals.generate_plot(
-                            visual_context["latex_input"], 
-                            problem_text, 
-                            visual_context.get("geometric_entities")
-                        )
-                except Exception as e:
-                    print(f"⚠️ [V302.0] SYMPY_PARSE_ERROR: Graph generation failed: {e}")
-                    graph_svg = None
-            
-            # Step 2: Solve each sub-question
-            all_solutions = []
-            context = {}  # Store results for dependencies
-            total_tokens = 0  # V8.5: Token Firewall Tracking
-            
-            for sub_q in understanding['sub_questions']:
-                print(f"🔄 [SOLVING] Sub-question {sub_q['id']}: {sub_q['topic']}")
-                
-                # V8.5: Emit SECTION_WORKING
-                yield BuddyEvent(
-                    question_id=question_id,
-                    state=BuddyState.SECTION_WORKING,
-                    current_section_id=sub_q['id'],
-                    payload={"question": sub_q['question']}
-                )
-                
-                # Solve this sub-question WITH IMAGE
-                # V231.22: FIX - Use the detected problem_type from understanding as the category!
-                # This fixes the bug where FUNCTION_ANALYSIS was treated as GEOMETRY because we passed the stale 'category' arg.
-                effective_category = understanding.get('problem_type', category)
-                
-                # V4.2 PRE-CONSTRAINT LOGIC (Iron Law #1)
-                # 1. Fetch Curriculum Rules FIRST
-                grade_num = math_intent_detector._extract_grade_number(grade)
-                curriculum_rules = curriculum_engine.get_allowed_math_operators(grade, level=kwargs.get('level', '4'))
-                
-                # 2. Detect Intent & Lock Strategy (Iron Law #2 - V4.2.8)
-                intent = math_intent_detector.detect_intent(sub_q['question'], grade_num)
-                strategy_vector = strategy_policy_engine.get_allowed_strategies(intent)
-                intent_contract = math_intent_detector.get_intent_contract(intent, grade_num)
-                
-                # Merge intent_contract with strategy_policy_engine (policy takes precedence)
-                if strategy_vector.get("forbidden"):
-                    intent_contract["forbidden_strategies"] = list(set(intent_contract.get("forbidden_strategies", []) + strategy_vector["forbidden"]))
-                
-                # 3. SmartSolver Execution (WITH IMAGE! - Strategy Enforcement)
-                ocr_confidence = self._last_ocr_confidence
-                
-                # 1. יצירת אובייקט ה-Context
-                eqs = data_anchor.get("function_equations", [])
-                joined_eqs = " , ".join(eqs) if eqs else sub_q['question']
-                
-                # V6 Polish: P0 Canonicalize Math OCR
-                cleaned_math = MathCanonicalizer.preprocess_ocr_string(joined_eqs)
-                
-                context_obj = PipelineContext(
-                    grade=grade,
-                    grade_num=math_intent_detector._extract_grade_number(grade),
-                    topic="GENERAL",
-                    math_input=cleaned_math,
-                    confidence=ocr_confidence,
-                    category=effective_category,
-                    original_text=problem_text,
-                    sub_question_text=sub_q.get('question', '')  # V7.3: scope isolation
-                )
-
-                # V6.1 Phase 1: Complexity Estimation & Prompt Specialization
-                complexity_score = CurriculumClassifier.estimate_complexity(cleaned_math)
-                prompt_specialization = CurriculumClassifier.get_prompt_specialization(grade, effective_category)
-
-                # ==================== V7.2 PRE-FLIGHT CHECKS ====================
-
-                # Ticket 1: Build AST metadata (Planner gets this; never gets raw math)
-                ast_metadata = build_ast_metadata(cleaned_math, effective_category)
-                ast_registry = ast_metadata.pop("ast_registry")  # Server-side only
-                visual_context = _abstract_visual_context(data_anchor or {})
-                if visual_context:
-                    ast_metadata["visual_context"] = visual_context
-
-                # Ticket 1: CRS Pre-Flight Gate (BEFORE any LLM call)
-                preflight_risk = CognitiveRiskEngine.calculate_risk_score(
-                    cleaned_math, [], retry_count=0, validation_errors=0
-                )
-                preflight_crs = preflight_risk["risk_score"]
-                print(f"🔬 [PREFLIGHT] Pre-LLM CRS: {preflight_crs} (threshold: 0.7)")
-
-                if preflight_crs > 0.7:
-                    print(f"🛑 [PREFLIGHT] CRS {preflight_crs} exceeds threshold. Skipping Planner. Entering Hint Mode.")
-                    telemetry.emit_crs_block(preflight_crs, data_anchor.get("problem_id", "unknown") if data_anchor else "unknown")
-                    telemetry.emit_runtime_outcome("crs_block")
-                    yield BuddyEvent(
-                        question_id=question_id,
-                        state=BuddyState.COMPLETE,
-                        payload=build_standard_response(
-                            final_answer="אפשר לקבל רמז? 🎓",
-                            teacher_summary="זהו תרגיל מאתגר! בוא נפרק אותו לחלקים קטנים יותר או נפשט את הביטוי המרכזי.",
-                            logic_error=False
-                        )
-                    )
-                    return
-
-                # ==================== END PRE-FLIGHT ====================
-
-                # ── Guard Clause ─────────────────────────────────────────────
-                if not hasattr(context_obj, "math_input"):
-                    raise ValueError("PipelineContext contract violation")
-
-                import datetime
-                problem_id_tag = data_anchor.get("problem_id", "adhoc_request") if data_anchor else "adhoc_request"
-
-                # ══════════════════════════════════════════════════════════════
-                # THE HYBRID ENGINE (LLM NAVIGATES, POLYGRAPH CONTROLS)
-                # ══════════════════════════════════════════════════════════════
-                print("🧠 [V7.3] Triggering LLM Navigation Mode...")
-                
-                # ══════════════════════════════════════════════════════════════
-                # V8.5: THE MICRO-AGENT SECTION LOOP (RETRY + ESCAPE HATCH)
-                # ══════════════════════════════════════════════════════════════
-                
-                attempts = 0
-                max_attempts = 2
-                solved_data = None
-                last_error_context = ""
-                is_degraded = False
-                degraded_reason = None
-                
-                while attempts < max_attempts:
-                    attempts += 1
-                    
-                    # V8.5: PRE-FLIGHT TOKEN FIREWALL
-                    if total_tokens > GLOBAL_TOKEN_LIMIT:
-                        print(f"🛑 [FIREWALL] Token limit reached ({total_tokens} > {GLOBAL_TOKEN_LIMIT}). Aborting solve.")
-                        break
-
-                    print(f"🧠 [V8.5] Solving sub-q {sub_q['id']} (Attempt {attempts}/{max_attempts})")
-                    
-                    # 1. ה-LLM פותר ומנווט את התשובה בהתבסס על ההקשר (והשגיאות הקודמות אם יש)
-                    solve_prompt = sub_q['question']
-                    if last_error_context:
-                        solve_prompt = f"FIX ERROR: {last_error_context}\n\nORIGINAL QUESTION: {solve_prompt}"
-
-                    # V8.6.9: Reset context on retry to reduce token pressure
-                    # V310.0: PHYSICAL DATA ISOLATION (The Pink Elephant Fix)
-                    # Instead of just prompting, we physically remove values belonging to other sub-questions.
-                    
-                    all_sub_q_values = []
-                    if "sub_questions" in understanding:
-                        for other_q in understanding["sub_questions"]:
-                            if other_q.get("specific_values"):
-                                all_sub_q_values.extend(other_q["specific_values"])
-                    
-                    # Values that are unique to specific sections (not truly global)
-                    restricted_pool = set(all_sub_q_values)
-                    
-                    local_anchor = {**data_anchor}
-                    global_values = local_anchor.get("specific_values", [])
-                    
-                    # Truly global = anchor values minus ANY value identified as section-specific
-                    truly_global_values = [v for v in global_values if v not in restricted_pool]
-                    
-                    # Section-specific = the values identified for THIS sub-question
-                    my_specific_values = sub_q.get("specific_values", [])
-                    
-                    print(f"📦 [V310.0] Data Slicing for {sub_q['id']}: Global={len(truly_global_values)}, Local={len(my_specific_values)}")
-                    local_anchor["specific_values"] = list(set(truly_global_values + my_specific_values))
-
-                    effective_context = {**local_anchor, **context} if attempts == 1 else {**local_anchor}
-
-                    result = await safe_llm_call(
-                        lambda: self.strategy_manager.solve_with_strategy(
-                            problem_text=solve_prompt,
-                            data_anchor=effective_context,
-                            grade=grade,
-                            image_data=image_data,
-                            image_data_list=image_data_list,
-                            parent_category=effective_category,
-                            student_name=student_name,
-                            student_gender=student_gender
-                        ),
-                        timeout_seconds=30.0
-                    )
-                    
-                    if isinstance(result, dict) and result.get("logic_error"):
-                        # Fatal LLM/JSON error, don't retry same error
-                        last_error_context = "LLM_MALFORMED_JSON_OR_TIMEOUT"
-                        continue
-
-                    llm_resp = result.get("llm_response", {})
-                    
-                    # V8.5: Token Accumulation
-                    usage = llm_resp.get("usage_metadata")
-                    if usage:
-                        # V8.5.1: usage is now a dict (serialized in strategy_manager)
-                        t_count = usage.get('total_token_count', 0) if isinstance(usage, dict) else getattr(usage, 'total_token_count', 0)
-                        total_tokens += t_count
-                        print(f"💰 [FIREWALL] Cumulative tokens: {total_tokens}")
-
-                    llm_steps = llm_resp if isinstance(llm_resp, list) else llm_resp.get("steps", [])
-
-                    # 2. השרת שולט: הפעלת ה-Polygraph על הצעדים של ה-LLM 
-                    struct_ok, struct_reason = await MathPolygraph.validate_step_sequence(llm_steps, topic=sub_q.get('topic', 'GENERAL'))
-                    
-                    poly_ok = struct_ok
-                    poly_reason = struct_reason
-                    
-                    if struct_ok:
-                        # V1.3: Also verify algebraic consistency (e.g. A + B = C)
-                        alg_ok, alg_reason = await MathPolygraph.verify_algebraic_consistency(llm_steps, topic=sub_q.get('topic', 'GENERAL'))
-                        if not alg_ok:
-                            poly_ok = False
-                            poly_reason = alg_reason
-
-                    if poly_ok:
-                        print(f"✅ [V8.5] Sub-q {sub_q['id']} Validated Successfully (Structure & Algebra)!")
-                        solved_data = llm_resp
-                        break
-                    else:
-                        print(f"🛑 [V8.5] Validation failed on attempt {attempts}/{max_attempts}: {poly_reason}")
-                        last_error_context = poly_reason
-                        
-                        # HOTFIX: לא זורקים תשובה טובה לפח! שומרים את הפתרון של ה-LLM
-                        solved_data = llm_resp 
-                        
-                        # מעקף: אם השגיאה היא רק בעיית קריאה של סימנים (אי-שוויונים/חיצים), סומכים על ה-LLM ויוצאים
-                        if "SYMPY_PARSE_ERROR" in str(poly_reason):
-                            # V280.0 + V310.0: Smart Retry & Soft Fail with JSON Security check
-                            # 1. Logic: Only allow bypass if it's NOT the first attempt OR it's a "Soft Fail" case.
-                            # 2. Pedagogical: "אין פתרון" is allowed. "לא ייתכן" remains removed.
-                            forbidden_words = ["סתירה בנתונים", "לא הגיוני", "שגיאה בחישוב שלי", "אני מזהה סתירה", "סתירה", "המצאה", "טעות שלי", "מתנצל"]
-                            import json
-                            response_text = json.dumps(llm_resp, ensure_ascii=False)
-                            
-                            has_forbidden = any(word in response_text for word in forbidden_words)
-                            
-                            if has_forbidden:
-                                print(f"🛑 [ROBUSTNESS] Forbidden word detected in SYMPY_PARSE_ERROR response. Not Trusting LLM.")
-                                is_degraded = True
-                                degraded_reason = "polygraph_fail_forbidden_words"
-                                # Continue to next attempt
-                            else:
-                                # V317.8 Soft Fail: Treat SymPy Parse Error as a warning immediately to avoid retries on valid LaTeX
-                                print(f"🛡️ [SOFT FAIL] SymPy Parse Error detected (Attempt {attempts}). No forbidden words found. Trusting LLM output for sub-q {sub_q['id']}.")
-                                is_degraded = True
-                                degraded_reason = "sympy_soft_fail"
-                                break # Exit the attempt loop
-                        elif attempts == max_attempts:
-                            print(f"⚠️ [HOTFIX] Max attempts reached. Forcing LLM response despite Polygraph failure.")
-                            is_degraded = True
-                            degraded_reason = "max_attempts_polygraph_fail"
-
-                # 3. Escape Hatch Injection (if failed twice)
-                if not solved_data:
-                    is_degraded = True
-                    degraded_reason = "polygraph_fail"
-                    print(f"🛡️ [V8.5] ESCAPE HATCH TRIGGERED for sub-q {sub_q['id']}")
-                    
-                    # V8.5.1: If we have LLM steps but they failed validation, use them anyway 
-                    # as a degraded fallback instead of the hardcoded d_1 = d_2.
-                    if llm_steps:
-                        solved_data = {
-                            "steps": llm_steps,
-                            "final_answer": llm_resp.get("final_answer") if isinstance(llm_resp, dict) else "בדוק את הצעדים"
-                        }
-                        # Add a disclaimer to the first step if possible
-                        if solved_data["steps"] and isinstance(solved_data["steps"][0], dict):
-                            orig_text = solved_data["steps"][0].get("explanation_text", "")
-                            solved_data["steps"][0]["explanation_text"] = f"הצגנו את הצעדים העיקריים כדי שתוכל לעקוב אחרי הדרך:\n\n{orig_text}"
-                    else:
-                        solved_data = {
-                            "steps": [
-                                {
-                                    "step_id": 1,
-                                    "explanation_text": "החישוב בסעיף זה הפך למורכב מאוד. הצגנו את העיקרון המנחה:",
-                                    "math_latex": "d_1 = d_2"
-                                }
-                            ],
-                            "final_answer": "המשך לפי השלבים"
-                        }
-
-                # 4. Packaging & Yielding
-                # V8.6.7 FIX / V317.5: Only pass the final answer text forward to prevent massive JSON injection in future prompts
-                context[f"result_{sub_q['id']}"] = solved_data.get("final_answer", "No valid answer extracted") if isinstance(solved_data, dict) else "הושלם"
-                
-                # Check for critical failure (No valid answer extracted)
-                # If a section fails completely, we break the loop to avoid cascading failures
-                if context[f"result_{sub_q['id']}"] == "No valid answer extracted":
-                    print(f"🛑 [ABORT] Section {sub_q['id']} failed completely. Aborting orchestration.")
-                    yield BuddyEvent(
-                        question_id=question_id,
-                        state=BuddyState.ERROR,
-                        payload={"error": "Section failure", "message": "חלה שגיאה בעיבוד חלק מהשאלה. עוצרים כדי למנוע טעויות."}
-                    )
-                    return
-                
-                # AI Assessment Telemetry Extraction
-                if not assessment_sent and isinstance(solved_data, dict) and "assessment" in solved_data:
-                    assessment_data = solved_data["assessment"]
-                    if uid and assessment_data:
-                        try:
-                            from analytics import analytics_manager
-                            loop = asyncio.get_event_loop()
-                            loop.create_task(asyncio.to_thread(analytics_manager.update_weekly_analytics, uid, assessment_data))
-                            print(f"📊 [ANALYTICS] Triggered background telemetry for {uid}")
-                            assessment_sent = True
-                        except Exception as e:
-                            print(f"❌ [ANALYTICS] Failed to trigger background task: {e}")
-                
-                response = build_pedagogical_response(
-                    effective_category, 
-                    solved_data, 
-                    data_anchor, 
-                    custom_title=f"סעיף {sub_q['id']}",
-                    processing_strategy=ProcessingStrategy.HEURISTIC_DEDUCTION
-                )
-                
-                # V8.5: Inject degradation flags into payload
-                if is_degraded:
-                    response["is_degraded"] = True
-                    response["degraded_reason"] = degraded_reason
-                
-                # V290.0: Inject graph into section payload if available (Early Projection)
-                if graph_svg:
-                    response["graph_svg"] = graph_svg
-                    response["graph_base64"] = "" # Legacy fallback
-
-                # Emit SECTION_READY
-                yield BuddyEvent(
-                    question_id=question_id,
-                    state=BuddyState.SECTION_READY,
-                    current_section_id=sub_q['id'],
-                    payload=response
-                )
-                
-                all_solutions.append({
-                    "sub_question_id": sub_q['id'],
-                    "question": sub_q['question'],
-                    "topic": sub_q['topic'],
-                    "response": response
-                })
-            
-            # Step 3: Build multi-part response (V4.2.16 Hotfix)
-            final_response = self._build_multi_part_response(
-                all_solutions,
-                strategy_card=strategy_card,
-                visual_context=visual_context
-            )
-            
-            # V260.2: FIX MISSING GRAPH (Forensic Finding 2026-02-14)
-            if visual_context:
-                print("📉 [BIT-LOG] Generating graph from visual context...")
-                try:
-                    # Note: visuals.generate_plot is synchronous in visuals.py V231.10
-                    latex_for_plot = visual_context.get("latex_input", "")
-                    if latex_for_plot:
-                        # V261.2: Pass Explicit Geometric Entities
-                        geometric_entities = visual_context.get("geometric_entities")
-                        graph_svg = visuals.generate_plot(latex_for_plot, problem_text, geometric_entities)
-                        if graph_svg:
-                            final_response["graph_svg"] = graph_svg
-                            final_response["graph_base64"] = "" # Legacy fallback
-                            print(f"📉 [BIT-LOG] SVG Graph generated! ({len(graph_svg)} chars)")
-                        else:
-                            print("📉 [BIT-LOG] Graph generation returned None/Empty")
-                    else:
-                        print("📉 [BIT-LOG] No latex_input in visual context. Skipping graph.")
-                except Exception as e:
-                    print(f"⚠️ [BIT-LOG] Graph generation failed: {e}")
-
-            # ===================== V285.1: SMART TEACHER SUMMARY + TTS =====================
-            print("🎙️ [BIT-LOG] Starting V285.1 Smart Teacher Summary...")
-            
-            # Generate pedagogical summary using LLM
-            summary_result = await self._generate_teacher_summary(
-                problem_text,
-                all_solutions,
-                understanding,
-                proof_graph=None,
-                student_name=student_name,
-                student_gender=student_gender
-            )
-            
-            # Extract TTS text (clean, no LaTeX, no emojis)
-            tts_text = summary_result.get("tts_speech", "")
-            if tts_text:
-                tts_text = self._scrub_latex_from_text(tts_text)
-                tts_text = self._sanitize_teacher_response(tts_text)
-            
-            # Generate Audio from TTS text
-            if tts_text:
-                print(f"🎙️ [BIT-LOG] Generating Audio for: {tts_text[:60]}...")
-                try:
-                    audio_result = await generate_teacher_audio(tts_text, output_path=None)
-                    
-                    if audio_result:
-                        if audio_result.startswith("http"):
-                            final_response["audio_url"] = audio_result
-                            print(f"🎙️ ☁️ [BIT-LOG] Audio uploaded: {audio_result}")
-                        else:
-                            final_response["audio_base64"] = audio_result
-                            print(f"🎙️ 💿 [BIT-LOG] Audio as Base64")
-                    else:
-                        print("🎙️ ⚠️ [BIT-LOG] Audio generation returned None")
-                except Exception as e:
-                    print(f"🎙️ ❌ [BIT-LOG] Audio CRASHED: {e}")
-            
-            # Store the structured summary matching Flutter's _buildSummaryCard format
-            # Flutter expects: {audio_pitch, key_concepts, formulas}
-            topic_summary = summary_result.get("topic_summary", "")
-            key_concepts = summary_result.get("key_concepts", [])
-            formulas = summary_result.get("formulas_to_remember", [])
-            
-            # Build the audio_pitch text: topic + TTS speech
-            audio_pitch_parts = []
-            if topic_summary:
-                audio_pitch_parts.append(f"נושא השיעור: {topic_summary}")
-            if tts_text:
-                audio_pitch_parts.append(tts_text)
-            audio_pitch = " ".join(audio_pitch_parts) if audio_pitch_parts else ""
-            
-            structured_summary = {
-                "audio_pitch": audio_pitch,
-                "key_concepts": key_concepts,
-                "formulas": formulas,
-            }
-            
-            if audio_pitch or key_concepts or formulas:
-                final_response["teacher_summary"] = structured_summary
-                print(f"🎙️ ✅ [V285.1] Structured summary set: topic={topic_summary}, concepts={len(key_concepts)}, formulas={len(formulas)}")
-            else:
-                print("🎙️ [BIT-LOG] No summary data generated")
-            # ===================== END V285.1 TTS BLOCK =====================
-
-            # V5.10.0: Save to History if Premium
-            tier = kwargs.get('tier', 'student_basic')
-            # Variable uid is already defined at start of smart_solve
-            print(f"🔍 [DEBUG HISTORY] UID: {uid}, Received Tier: '{tier}', kwargs keys: {list(kwargs.keys())}")
-            is_premium = tier in ["premium", "admin", "admin_unlimited"]
-            if is_premium and uid:
-                try:
-                    # V315.0: Explicit scheduling with loop check
-                    loop = asyncio.get_event_loop()
-                    loop.create_task(self._save_exercise_history(uid, problem_text, all_solutions))
-                    print(f"📚 [HISTORY] History saving scheduled for {uid}")
-                except Exception as e:
-                    print(f"❌ [HISTORY] Failed to schedule history saving: {e}")
-
-            # V277.0: FIXED - Yield final solution as a COMPLETE event instead of using return (which is ignored by async generators)
-            yield BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.COMPLETE,
-                payload=final_response
-            )
-            return
-        
-        except Exception as e:
-            print(f"❌ [BIT-LOG] Smart solve error: {e}")
-            import traceback
-            traceback.print_exc()
-            
-            # Logic Error Enforced Fallback
-            yield BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.ERROR,
-                payload=build_standard_response(
-                    final_answer="הסבר זה הוסר עקב חריגה מהחוזה.",
-                    teacher_summary="חלה שגיאה טכנית במערכת המתמטית. אנא נסה לצלם שוב.",
-                    logic_error=True
-                )
-            )
-            return
-    
-    def _build_multi_part_response(self, solutions, strategy_card=None, visual_context=None):
-        """V6 Polish: Aggregator Refactoring - Isolate sections with statuses, remove string concatenation."""
-        sections = []
-        all_answers = []
-        summaries = []
-        
-        print(f"📊 [BIT-LOG: AGGREGATOR] Merging {len(solutions)} sub-questions")
-        
-        # 1. Strategy & Visual (V260.0 compat)
-        if strategy_card:
-            strategy_steps = []
-            if "steps" in strategy_card and isinstance(strategy_card["steps"], list):
-                for i, s_text in enumerate(strategy_card["steps"]):
-                    clean_s = sanitize_math_text(s_text)
-                    strategy_steps.append({"step_id": i+1, "explanation_text": clean_s, "content_mixed": clean_s, "math_artifact": {"type": "equation", "latex": ""}})
-            else:
-                clean_s = sanitize_math_text(strategy_card.get("content", ""))
-                strategy_steps.append({"step_id": 0, "explanation_text": clean_s, "content_mixed": clean_s, "math_artifact": {"type": "equation", "latex": ""}})
-            
-            sections.append({
-                "section_title": strategy_card.get("title", "איך ניגשים לזה? 🧭"),
-                "status": "SUCCESS",
-                "steps": strategy_steps
-            })
-            
-        if visual_context:
-            clean_v = sanitize_math_text(visual_context.get("description", ""))
-            sections.append({
-                "section_title": visual_context.get("title", "המחשה חזותית ✏️"),
-                "status": "SUCCESS",
-                "steps": [{"step_id": 0, "explanation_text": clean_v, "content_mixed": clean_v, "math_artifact": {"type": "equation", "latex": visual_context.get("latex_input", "")}}]
-            })
-
-        for sol in solutions:
-            res = sol.get("response", {})
-            sub_q_status = "SUCCESS"  # Default status
-            
-            if isinstance(res, dict):
-                # V6 Polish: Determine status based on flags in response block
-                if res.get("logic_error"):
-                    # Check if it was a solver failure (no rule found) or parse error. Default to FAILED_RULE if logic error flagged.
-                    sub_q_status = "FAILED_RULE"
-                
-                if "sections" in res and res["sections"]: 
-                    # Flatten sub-question sections and append status
-                    for section in res["sections"]:
-                         base_title = section.get('section_title', '')
-                         if "סעיף" not in base_title:
-                             section["section_title"] = f"סעיף {sol.get('sub_question_id', '?')} - {base_title}"
-                         section["status"] = sub_q_status
-                         sections.append(section)
-                else:
-                    # If this sub-question failed entirely and has no steps to show
-                    sections.append({
-                        "section_title": f"סעיף {sol.get('sub_question_id', '?')} - הופסק או נכשל",
-                        "status": sub_q_status,
-                        "steps": []
-                    })
-                
-                if res.get("teacher_summary") and not res.get("logic_error"): 
-                    summaries.append(res["teacher_summary"])
-        
-        response = build_standard_response(
-            sections=sections,
-            final_answer="הפתרון לכלל הסעיפים מפורט למטה.",
-            teacher_summary=summaries[0] if summaries else "סיימנו את הניתוח.",
-            graph_base64=None,
-            audio_base64=None,
-            logic_error=False,
-            response_type="standard",
-            strategy_card=strategy_card,
-            visual_context=visual_context
-        )
-        
-        print(f"✅ [BIT-LOG: AGGREGATOR] Response built. Sections: {len(sections)}")
-        return response
-    
-
-
-    # ===================== CORE SOLVE =====================
-
-    async def solve_problem(self, problem_text, grade, student_name, **kwargs):
-        """
-        V277.0: Main solve method with BINARY DATA SUPPORT and TUTOR SESSION support.
-        """
-        uid = kwargs.get('uid')
-        session_id = kwargs.get('session_id')
-
-        # ===================== V318.0: TUTOR SESSION MODE =====================
-        if session_id and uid:
-            print(f"🎓 [TUTOR-MODE] Activating Session-Based Dialogue for session: {session_id}")
-            # We yield from the tutor handler
-            event = await self._handle_tutor_session(problem_text, student_name, uid, session_id, **kwargs)
-            yield event
-            return
-        # ===================== END TUTOR SESSION MODE =====================
-        uid = kwargs.get('uid')
-        image_data_list = kwargs.get('image_data_list')
-        image_data = kwargs.get('image_data') or kwargs.get('image_bytes')
-        
-        if image_data and not image_data_list:
-            image_data_list = [image_data]
-        elif image_data_list and not image_data:
-            image_data = image_data_list[0]
-            
-        # V316.0: CRITICAL - Ensure image_data is explicitly passed in kwargs for the rest of parameters
-        kwargs['image_data'] = image_data
-        kwargs['image_data_list'] = image_data_list
-
-        question_id = kwargs.get('question_id', f"q_{int(time.time())}")
-        start_time = asyncio.get_event_loop().time()
-        # GLOBAL_TIMEOUT_SEC = 240 # 4 minutes usually
-        
-        # Immediate Heartbeat for UX
-        yield BuddyEvent(
-            question_id=question_id,
-            state=BuddyState.SECTION_WORKING,
-            current_section_id="ניתוח תמונה",
-            payload={"status": "המורה קוראת את השאלה..."}
-        )
-
-        # ===================== V285.0: CHECK ME ROUTING =====================
-        mode = kwargs.get('mode', 'solve')
-        if mode == 'check' and image_data:
-            print(f"📝 [V285.0] Mode=CHECK detected. Routing to _check_student_work()...")
-            student_gender = kwargs.get('student_gender', 'M')
-            async for event in self._check_student_work(
-                image_data_list=image_data_list,
-                grade=grade,
-                student_name=student_name,
-                student_gender=student_gender,
-                question_id=question_id
-            ):
-                yield event
-            return
-        # ===================== END CHECK ME ROUTING =====================
-        
-        if image_data_list:
-            print(f"🔵 [BIT-LOG] Starting OCR Pipeline on {len(image_data_list)} images...")
-            ocr_results = []
-            for i, img in enumerate(image_data_list):
-                print(f"📸 [BIT-LOG] Transcribing image {i}...")
-                text = await self.transcribe_image(img)
-                if text:
-                    ocr_results.append(text)
-            
-            problem_text = "\n\n".join(ocr_results)
-            image_data = image_data_list[0] # Use first image for main processing logic/anchors
-            
-        logger.info(f"🔎 [TRACE] RAW OCR TEXT: {problem_text}")
-
-        student_gender = kwargs.get('student_gender', 'M')
-        
-        print(f"🧠 [BIT-LOG] Orchestrating for {student_name} (V277.0 - BINARY DATA SUPPORT)")
-        
-        # 🧱 Firewall 1: OCR Early Exit
-        import re
-        ocr_clean = problem_text.strip() if problem_text else ""
-        
-        # חייב להכיל לפחות אות אנגלית אחת, מספר, או סימן מתמטי
-        has_math_anchor = bool(re.search(r'[0-9xyzXYZ=+\-\(\)]', ocr_clean))
-        # V5.7.5: Short Math Bypass (Happy Flow for simple equations)
-        # Often simple equations like $2+2=?$ yield low OCR confidence but are valid.
-        is_short_math = has_math_anchor and len(ocr_clean) < 15 and len(ocr_clean) > 2
-        
-        # מצב 3: Hard Stop (Low Confidence)
-        if self._last_ocr_confidence < CONFIDENCE_THRESHOLD_MEDIUM and not is_short_math:
-            print(f"🔴 [V3.1.2] Hard Stop: Confidence {self._last_ocr_confidence:.2f} < {CONFIDENCE_THRESHOLD_MEDIUM}")
-            yield BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.ERROR,
-                payload=build_standard_response(
-                    final_answer="המערכת לא הצליחה לזהות את כל הנתונים. אנא צלם שוב בצורה ברורה יותר.",
-                    logic_error=True,
-                    # response_type="error",
-                    # error_type="RECAPTURE_REQUIRED"
-                )
-            )
-            return
-            
-        # מצב 2: Soft Recovery (Medium Confidence)
-        ambiguity_warning = self._last_ocr_confidence < CONFIDENCE_THRESHOLD_HIGH
-        if ambiguity_warning:
-            print(f"🟡 [V3.1.2] Soft Recovery: Confidence {self._last_ocr_confidence:.2f} < {CONFIDENCE_THRESHOLD_HIGH}")
-        
-        # ===================== V5.8.0: STRATEGY RESOLUTION =====================
-        strategy = self._quick_classify(problem_text)
-        print(f"🏷️ [BIT-LOG] Strategy: {strategy.value}")
-
-        # V8.5: Initialize Token Tracking
-        from cost_tracker import CostTracker
-        tokens = CostTracker()
-
-        # ===================== SIMPLE FAST PATH =====================
-        if strategy == ProcessingStrategy.SIMPLE_ARITHMETIC:
-            print("⚡ [BIT-LOG] Using SIMPLE_ARITHMETIC Fast Path")
-            yield BuddyEvent(question_id=question_id, state=BuddyState.SECTION_WORKING, current_section_id="A", payload={"status": "Solving locally..."})
-
-            fast_result = await self._quick_solve(
-                problem_text=problem_text, grade=grade, student_name=student_name,
-                image_data=image_data, ambiguity_warning=ambiguity_warning
-            )
-
-            if fast_result:
-                fast_result, _, _ = validate_and_fix_solution(fast_result)
-                # Quick Polygraph check
-                _poly_steps = collect_all_steps(fast_result)
-                _poly_ok, _ = await MathPolygraph.validate_step_sequence(_poly_steps, topic=str(strategy.value))
-                
-                if _poly_ok:
-                    yield BuddyEvent(
-                        question_id=question_id,
-                        state=BuddyState.SECTION_READY,
-                        current_section_id="A",
-                        payload=build_standard_response(**fast_result)
-                    )
-                    yield BuddyEvent(question_id=question_id, state=BuddyState.COMPLETE, payload={})
-                    return
-
-        # ===================== FULL STREAMING PIPELINE =====================
-        print(f"🎯 [BIT-LOG] Using Streaming Pipeline Strategy: {strategy.value}")
-
-        # V316.0: image_data is already hydrated at the top of solve_problem.
-        # This block is now redundant but kept for safety if someone moves things.
-        if image_data is None and image_data_list:
-            image_data = image_data_list[0]
-            print("📸 [BIT-LOG] Using first image from list for Data Anchor phase. (Redundant Check)")
-
-        data_anchor = await self._extract_key_data(problem_text, image_data=image_data) or {}
-        
-        # V8.9.2: SEPARATE VALIDATOR PASS (Single Source of Truth)
-        if image_data and data_anchor:
-            print("🛡️ [V8.9.2] Starting Data Anchor Validation Pass...")
-            data_anchor = await self._validate_anchor(data_anchor, image_data, problem_text)
-
-        # V1.0: GEOMETRIC SANITY CHECK (Ground Truth Injection)
-        # Runs BEFORE the LLM to verify algebraic consistency of the extracted data.
-        # Injects 'verified_facts' and 'geometry_warnings' into the anchor.
-        try:
-            _geo_anchor, _geo_prompt_block = run_geometric_sanity(data_anchor)
-            if _geo_anchor.verified_facts or _geo_anchor.warnings:
-                data_anchor["_verified_facts"] = _geo_anchor.verified_facts
-                data_anchor["_geometry_warnings"] = _geo_anchor.warnings
-                data_anchor["_geo_prompt_block"] = _geo_prompt_block
-                print(f"🔬 [GEO-SANITY] Injected {len(_geo_anchor.verified_facts)} fact(s), "
-                      f"{len(_geo_anchor.warnings)} warning(s) into data_anchor.")
-        except Exception as _geo_err:
-            logging.warning(f"[GEO-SANITY] Non-fatal error: {_geo_err}")
-        
-        # Iterate through the streaming smart_solve
-        # V5.10.2: Remove keys already passed explicitly to avoid TypeError collision
-        for _key in ['student_gender', 'image_data', 'image_data_list', 'image_bytes',
-                      'mode', 'question_id', 'user_note']:
-            kwargs.pop(_key, None)
-        try:
-            async for event in self.smart_solve(
-                problem_text=problem_text,
-                data_anchor=data_anchor,
-                grade=grade,
-                category="investigation", # simplified
-                student_name=student_name,
-                student_gender=student_gender,
-                processing_strategy=strategy,
-                image_data=image_data,
-                image_data_list=image_data_list,
-                ambiguity_warning=ambiguity_warning,
-                question_id=question_id,
-                **kwargs
-            ):
-                # 🛡️ Global Guard 1: Token Controller
-                # Check current tokens from global tracking if possible, or per call
-                # (For now we rely on the fact that each LLM call logs to CostTracker)
-                
-                # 🛡️ Global Guard 2: Timeout
-                elapsed = asyncio.get_event_loop().time() - start_time
-                if elapsed > GLOBAL_TIMEOUT_SEC:
-                    print(f"🛑 [V8.5] Global Timeout ({elapsed:.1f}s) reached. Cutting stream.")
-                    yield BuddyEvent(
-                        question_id=question_id,
-                        state=BuddyState.COMPLETE,
-                        payload={"warning": "Solving timed out. Partial results shown."}
-                    )
-                    return
-
-                yield event
-
-            # Final Event - No longer needed as smart_solve now yields the final COMPLETE event
-            # yield BuddyEvent(question_id=question_id, state=BuddyState.COMPLETE, payload={})
-            pass
-
-        except Exception as e:
-            logger.exception("STREAMING ERROR")
-            yield BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.ERROR,
-                payload={"error": str(e), "message": "אופס! משהו השתבש בעיבוד השאלה."}
-            )
-    
-
-    # V260.5: General Q&A ("Ask the Teacher")
-    async def ask_question(self, context_data, question, student_name):
-        """
-        Answers a specific student question based on the problem context.
-        context_data: The full solution JSON (or relevant parts).
-        question: The student's question.
-        """
-        # Serialize context for prompt
-        context_str = json.dumps(context_data, ensure_ascii=False)
-        
-        prompt = f"""
-        תפקיד: מורה פרטית למתמטיקה (המורה למתמטיקה V260.5).
-        התלמיד {student_name} שואל שאלה על הפתרון שקיבל.
-        
-        הקשר (הנתונים והפתרון שכבר נוצר):
-        {context_str}
-        
-        השאלה של התלמיד:
-        "{question}"
-        
-        הנחיות:
-        1. ענה לעניין, בצורה קצרה וממוקדת.
-        2. השתמש בטון מעודד וחם (כמו "הנסיך/הנסיכה").
-        3. אם השאלה קשורה לנוסחה, כתוב אותה ב-LaTeX תקני (בתוך $...$).
-        4. אם התלמיד לא הבין משהו, הסבר לו במילים פשוטות יותר.
-        5. קריטי: אתה בממשק צ'אט נטול קבצים מצורפים! לעולם אל תגיד "ההסבר המלא בפתרון המצורף" או לשלוח את התלמיד למקור חישוב חיצוני. עליך לספק את **כל החישוב וההסבר המתמטי המלא והמפורט** ישירות בתוך הטקסט של התשובה שלך (שדה "answer").
-
-        חובה: החזר JSON בלבד!
-        {{
-            "answer": "התשובה המלאה, כולל כל צעדי החישוב וההסבר המתמטי...",
-            "follow_up_suggestion": "שאלה נוספת שהתלמיד יכול לשאול (אופציונלי)"
-        }}
-        """
-        
-        try:
-            res = await asyncio.wait_for(
-                self.model.generate_content_async(prompt),
-                timeout=30.0
-            )
-            
-            # Extract JSON
-            match = re.search(r'\{.*\}', res.text, re.DOTALL)
-            if not match:
-                raise ValueError("No JSON found in LLM response for ask_question")
-            data = safe_extract_json(match.group(), "ask_question")
-            
-            # Sanitize math in answer
-            if "answer" in data:
-                from pedagogical_builder import sanitize_math_text
-                data["answer"] = sanitize_math_text(str(data["answer"]))
-                    
-                return build_standard_response(
-                    teacher_summary=data.get("answer", ""),
-                    sections=[{
-                        "section_title": "תשובה לשאלה",
-                        "steps": [{
-                            "step_id": 1,
-                            "explanation_text": data.get("answer", ""),
-                            "math_artifact": {"type": "equation", "latex": "", "table_data": ""}
-                        }]
-                    }],
-                    final_answer=data.get("follow_up_suggestion", "")
-                )
-            
-            error_msg = "לא הצלחתי להבין את השאלה, נסה לנסח שוב? 🤔"
-            return build_standard_response(
-                teacher_summary=error_msg,
-                logic_error=True
-            )
-            
-        except Exception as e:
-            print(f"🔥 [BIT-LOG] Ask Question error: {e}")
-            return build_standard_response(
-                teacher_summary="אופס, נתקלתי בבעיה קטנה. בוא ננסה שוב! 😅",
-                logic_error=True
-            )
-            
-    async def explain_specific_step(self, context, step_text, student_name):
-        """V231.4: Step explanation with LaTeX shield."""
-        prompt = f"""
-        תפקיד: מורה פרטית למתמטיקה (המורה למתמטיקה V231.4).
-        התלמיד {student_name} ביקש הסבר נוסף על צעד ספציפי.
-        
-        ההקשר: {context}
-        הצעד שצריך הסבר: {step_text}
-        
-        הסבר את הצעד מאפס, כאילו התלמיד רואה את הנושא בפעם הראשונה.
-        השתמש בפורמט: "הסבר בעברית :: $נוסחה$"
-        חובה: כל פקודת LaTeX חייבת להתחיל ב-\\ (למשל: \\frac, \\cdot, \\sqrt).
-        
-        החזר JSON: {{ "explanation": "...", "example": "..." }}
-        """
-        try:
-            res = await asyncio.wait_for(
-                self.model.generate_content_async(prompt),
-                timeout=30.0
-            )
-            match = re.search(r'\{.*\}', res.text, re.DOTALL)
-            if not match:
-                raise ValueError("No JSON found in LLM response for explain_step")
-            data = safe_extract_json(match.group(), "explain_step")
-            data = self._scrub_placeholders(data)
-            data = self._enhance_latex_v2(data)
-            if data and ("explanation" in data or "example" in data):
-                return data
-            return {"explanation": "לא הצלחתי לייצר הסבר.", "example": ""}
-        except Exception as e:
-            print(f"🔥 [BIT-LOG] Explain error: {e}")
-            return {"explanation": "המורה למתמטיקה נתקל בקושי. נסה שוב.", "example": ""}
-
-    async def _handle_tutor_session(self, problem_text, student_name, uid, session_id, **kwargs):
-        """
-        V318.0: Logic for Phase A - Contextual Memory & Tutor Dialogue.
-        """
-        question_id = kwargs.get('question_id', f"tutor_{int(time.time())}")
-        image_data_list = kwargs.get('image_data_list') or []
-        grade = kwargs.get('grade', "כיתה י'")
-
-        # 1. Fetch History (Last 10 messages)
-        history_docs = firebase_manager.get_chat_history(uid, session_id, limit=10)
-        
-        # 2. Map history to Gemini format
-        history_contents = []
-        for doc in history_docs:
-            role = "user" if doc.get('role') == 'user' else "model"
-            history_contents.append({
-                "role": role,
-                "parts": [doc.get('content', '')]
-            })
-
-        # 3. System Instruction
-        system_instruction = f"""את מורה פרטית למתמטיקה. המטרה שלך היא לנהל דיאלוג למידה עם התלמיד {student_name} (כיתה {grade}).
-חוקי השיחה:
-1. אם זו תחילת שיחה (היסטוריה ריקה): אל תפתרי כלום. שאלי את התלמיד: 'היי {student_name}! מה אנחנו לומדים היום בכיתה?' וחכי לתשובה.
-2. ברגע שזוהה נושא: שמרי אותו בזיכרון השיחה והתייחס אליו בהמשך.
-3. בבקשת 'בדקי לי' (כשיש תמונות של פתרון): נתחי את התמונה מול השאלה. אם יש טעות, צייני את השורה ואת סוג הטעות (סימנים, חוקי חזקות וכו'). אל תתקני מיד, תני רמז.
-4. השתמש בטון מעודד, חם ובגובה העיניים.
-5. כל פלט חייב להיות בפורמט JSON תקין לפי הסכימה המוגדרת.
-"""
-
-        # 4. Construct Current Input
-        current_input_parts = []
-        if problem_text:
-            current_input_parts.append(problem_text)
-        
-        for img_bytes in image_data_list:
-            current_input_parts.append({
-                "mime_type": "image/jpeg",
-                "data": img_bytes
-            })
-
-        if not current_input_parts:
-            current_input_parts.append("(התלמיד הצטרף לשיחה)")
-
-        # 5. Gemini Call with Structured Output
-        try:
-            # We use a temporary chat session to include history
-            chat = self.model.start_chat(history=history_contents)
-            
-            # V318: Enforce JSON mode and schema
-            generation_config = genai.GenerationConfig(
-                response_mime_type="application/json",
-                response_schema=TutorResponseSchema,
-                temperature=0.7
-            )
-
-            # Prepend system instruction as a message if model doesn't support separate system_instruction in start_chat
-            # Actually, Gemini 2.0 Flash supports system_instruction in the model constructor or in GenerateContent.
-            # Here we'll append it to the prompt for maximum compatibility with existing self.model.
-            full_prompt = f"[SYSTEM_INSTRUCTION]\n{system_instruction}\n\n[USER_INPUT]\n"
-            
-            res = await self.model.generate_content_async(
-                contents=history_contents + [{"role": "user", "parts": [full_prompt] + current_input_parts}],
-                generation_config=generation_config
-            )
-
-            # 6. Parse & Save
-            data = json.loads(res.text)
-            student_message = data.get("student_message", "")
-            analytics = data.get("internal_analytics", {})
-
-            # Determine intent for metadata
-            intent = analytics.get("intent", "CHAT")
-            mastery_score = analytics.get("mastery_score", 0)
-            topic = analytics.get("topic", "General")
-            
-            # V318.0: TRIGGER CHALLENGE GENERATOR if Mastery > 70
-            if mastery_score > 70 and intent in ["SOLVE", "CHECK"]:
-                logger.info(f"🏆 [TUTOR-MODE] High Mastery detected ({mastery_score}). Triggering Challenge Generator.")
-                from exercise_generator import exercise_generator
-                # Fire and forget (Background Task)
-                asyncio.create_task(exercise_generator.generate_challenge(problem_text or "(מעבד תמונה)", topic, uid))
-                
-                # Append the challenge offer to the tutor's message
-                offer_text = "\n\nכל הכבוד! הכנתי לך תרגיל אתגר דומה כדי לוודא שזה יושב טוב. רוצה לנסות? 💪"
-                student_message += offer_text
-
-            # Save User Message (if there was text/images)
-            if problem_text or image_data_list:
-                firebase_manager.save_chat_message(
-                    uid, session_id, "user", problem_text or "(תמונה)", 
-                    metadata={"intent": intent}
-                )
-
-            # Save Assistant Message
-            firebase_manager.save_chat_message(
-                uid, session_id, "assistant", student_message, 
-                metadata=analytics
-            )
-
-            # 7. Map to BuddyEvent for UI
-            return BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.COMPLETE,
-                payload=build_standard_response(
-                    teacher_summary=student_message,
-                    final_answer=""
-                )
-            )
-
-        except Exception as e:
-            logger.error(f"❌ [TUTOR-SESSION] Error: {e}")
-            return BuddyEvent(
-                question_id=question_id,
-                state=BuddyState.ERROR,
-                payload={"error": str(e), "message": "המורה נתקלה בבעיה בזיכרון של השיחה."}
-            )
-
-    # ===================== PIPELINE METHODS =====================
-
-    def _get_v231_pedagogic_block(self):
-        """V231.4: Pedagogic instructions appended to every prompt."""
-        return r"""
-        \n🛑 משימה: המורה למתמטיקה (סטנדרט פרימיום V231.4) 🛑
-        1. הסבר מאפס: כל שלב מלווה בהסבר מילולי עשיר.
-        2. בטיחות לטך: חובה להשתמש ב- \\frac{}{} ולא ב- frac.
-        3. ניקיון: אל תשאיר פלייסהולדרים כמו $formula$ או $math$ בטקסט.
-        4. כל פקודת LaTeX חייבת להתחיל ב-\\. למשל: \\frac, \\cdot, \\sqrt, \\pi.
-        5. Hebrew or GEOMETRIC NOTATION (e.g., \angle, ^\circ, \triangle) inside $$ is FORBIDDEN. It breaks the app. Use inline math in content_mixed for dimensions/angles.
-        6. NEVER write \\left or \\right. Use ( ) instead.
-        7. Each math expression MUST be on its OWN LINE.
-        8. NEVER use \\ne (conflicts with newline). USE \\neq instead.
-        9. STRATEGY CARD: The first section "איך ניגשים לזה?" must contain ONLY hints and thinking strategy — NO final answers!
-        10. OCR SACRED: You MUST solve the EXACT function from the image. If OCR says x^2/(x^2-4), solve THAT. Do NOT invent a different function.
-        11. MATH SEPARATION (CRITICAL): block_math is for PURE ALGEBRA ONLY. NO \angle, \triangle, ^\circ, \text{}, \quad, or 'and' allowed in block_math. Use inline math `$...$` in content_mixed for dimensions, labels, or explanatory math.
-        12. PEDAGOGICAL HIGHLIGHTING: When performing a substitution, showing a change in sign, taking a derivative, or highlighting a key transition in a calculation, use `\color{color_name}{...}` (e.g., `\color{red}{x^2}`, `\color{blue}{+4}`) to visually highlight the element that changed or needs the student's focus. Ensure you only wrap valid Math in the color tag.
-        """
-
-    def _scrub_placeholders(self, data):
-        """✅ V231.0: מסיר פלייסהולדרים ריקים ש-Gemini משאיר בטעות"""
-        if isinstance(data, str):
-            result = data
-            result = re.sub(r'\$\s*formula\d*\s*\$', '', result)
-            result = re.sub(r'\$\s*math\d*\s*\$', '', result)
-            result = result.replace('[math]', '')
-            result = result.replace('[formula]', '')
-            result = re.sub(r'::\s*$', '', result, flags=re.MULTILINE)
-            return result.strip()
-        if isinstance(data, dict):
-            return {k: self._scrub_placeholders(v) for k, v in data.items()}
-        if isinstance(data, list):
-            return [self._scrub_placeholders(i) for i in data]
-        return data
-
-    def _enhance_latex_v2(self, data):
-        """✅ V231.2: מתקן לוכסנים רק בתוך $...$ — לא נוגע בעברית!"""
-        if isinstance(data, str):
-            def _fix_content(content):
-                content = re.sub(
-                    r'(?<!\\)(frac|sqrt|cdot|times|neq|pm|alpha|beta|gamma|Delta|pi|infty|leq|geq|quad)',
-                    r'\\\1', content
-                )
-                content = re.sub(r'(?<!\\)(sin|cos|tan|log|ln)\b', r'\\\1', content)
-                return content
-
-            # V8.8: Upgrade standalone inline math ($...$) taking up a full line to block math ($$...$$)
-            res = re.sub(r'(?m)^\s*\$(.+?)\$\s*$', r'$$\1$$', data)
-
-            res = re.sub(r'\$\$(.+?)\$\$', lambda m: f'$${_fix_content(m.group(1))}$$', res, flags=re.DOTALL)
-            res = re.sub(r'(?<!\$)\$(?!\$)(.+?)(?<!\$)\$(?!\$)', lambda m: f'${_fix_content(m.group(1))}$', res)
-            return res
-        if isinstance(data, dict):
-            return {k: self._enhance_latex_v2(v) for k, v in data.items()}
-        if isinstance(data, list):
-            return [self._enhance_latex_v2(i) for i in data]
-        return data
-
-    def _scrub_strategy_hebrew(self, data):
-        """✅ V231.5: Scrubs $ \\ { from Hebrew side of :: separator in strategy cards."""
-        if isinstance(data, dict):
-            sections = data.get('sections', [])
-            if sections and isinstance(sections, list) and len(sections) > 0:
-                first_sec = sections[0]
-                title = first_sec.get('section_title', '')
-                if 'ניגשים' in title or 'אסטרטגיה' in title or '🧭' in title:
-                    # This is the strategy card — scrub Hebrew side
-                    steps = first_sec.get('steps', [])
-                    for step in steps:
-                        if 'content_mixed' in step:
-                            val = step['content_mixed']
-                            if '::' in val and '$' in val:
-                                parts = val.split('::', 1)
-                                hebrew = re.sub(r'\$[^$]*\$', '', parts[0]).strip()
-                                step['content_mixed'] = f"{hebrew} :: {parts[1].strip()}"
-                            else:
-                                # Pure Hebrew strategy line — strip any accidental LaTeX
-                                val = re.sub(r'\\[a-zA-Z]+', '', val)
-                                val = val.replace('$', '').replace('{', '').replace('}', '')
-                                step['content_mixed'] = re.sub(r'\s+', ' ', val).strip()
-            return data
-        return data
-    
-    def _inject_bidi_markers(self, data):
-        """✅ V231.11: Smart BiDi with RLM markers (Right-to-Left Mark)."""
-        # RLM (\u200F) marks direction without reversing text
-        # Unlike RLE (\u202B) which was causing full text reversal
-        
-        if isinstance(data, str):
-            # Check if string contains Hebrew
-            has_hebrew = bool(re.search(r'[\u0590-\u05FF]', data))
-            
-            if has_hebrew:
-                return '\u200F' + data
-            
-            return data
-        
-        if isinstance(data, dict):
-            return {k: self._inject_bidi_markers(v) for k, v in data.items()}
-        if isinstance(data, list):
-            return [self._inject_bidi_markers(i) for i in data]
-        return data
-    
-    def _purge_double_dollars(self, data):
-        """✅ V275.3: Remove orphan double-dollars, fix quadruple dollars, and unwrap Hebrew-in-math."""
-        if isinstance(data, str):
-            # Fix quadruple dollars $$$$ -> $$ globally before processing
-            data = re.sub(r'\${3,}', '$$', data)
-            
-            # Remove empty math blocks: $$ $$ or $$$$
-            data = re.sub(r'\$\$\s*\$\$', '', data)
-            
-            # V275.4: Unwrap Hebrew paragraphs from $$...$$ blocks (mirror text fix)
-            def _unwrap_hebrew(match):
-                content = match.group(1).strip()
-                hebrew_chars = len(re.findall(r'[\u0590-\u05FF]', content))
-                total_chars = len(content.replace(' ', ''))
-                if total_chars == 0:
-                    return ''
-                # Heuristic 1: >25% Hebrew = text paragraph (lowered from 40%)
-                if hebrew_chars / total_chars > 0.25 and hebrew_chars > 8:
-                    return content
-                # Heuristic 2: 3+ consecutive Hebrew words
-                if re.search(r'[\u0590-\u05FF]+\s+[\u0590-\u05FF]+\s+[\u0590-\u05FF]+', content):
-                    return content
-                return match.group(0)
-            
-            data = re.sub(r'\$\$(.+?)\$\$', _unwrap_hebrew, data, flags=re.DOTALL)
-            
-            # Preserve display math: $$...$$
-            # Remove orphan $$: "text $$" or "$$ text"
-            
-            # Strategy: Protect display math blocks, purge orphans, restore protected
-            protected = []
-            
-            def protect_display_math(match):
-                protected.append(match.group(0))
-                return f"__DISPLAY_MATH_{len(protected)-1}__"
-            
-            # Protect $$...$$ blocks (non-greedy match)
-            result = re.sub(r'\$\$[^$]+?\$\$', protect_display_math, data)
-            
-            # Now purge orphan $$ (multiple consecutive $)
-            result = re.sub(r'\$\$+', '$', result)
-            
-            # Restore protected blocks
-            for i, block in enumerate(protected):
-                result = result.replace(f"__DISPLAY_MATH_{i}__", block)
-            
-            if result != data:
-                print(f"💲 [BIT-LOG] Purged orphan $$ and fixed quadruple $: '{data[:50]}...' → '{result[:50]}...'")
-            return result
-        if isinstance(data, dict):
-            return {k: self._purge_double_dollars(v) for k, v in data.items()}
-        if isinstance(data, list):
-            return [self._purge_double_dollars(i) for i in data]
-        return data
-
-    def _error_response(self):
-        return build_standard_response(
-            final_answer="המורה למתמטיקה נתקל בקושי. נסה שוב.",
-            teacher_summary="המורה למתמטיקה מתנצל, אך חלה שגיאה לא צפויה.",
-            logic_error=True,
-            response_type="error"
-        )
-
-    def _sanitize_for_sympy(self, expr: str) -> str:
-        """✅ V231.4: Robust SymPy sanitizer.
-        Converts \\frac{4}{3}x -> (4)/(3)*x, handles all implicit multiplication."""
-        s = str(expr)
-        
-        # Step 0: Pre-algebraic cleanup (Remove UI/Geometric/Text notation)
-        s = re.sub(r'\\color\{.*?\}(?:\{.*?\})?', '', s) # Aggressively strip color tags
-        s = re.sub(r'\\text\{[^{}]*\}', '', s)
-        s = re.sub(r'\^(\{\\circ\}|\\circ)', '', s)
-        s = re.sub(r'\\(angle|triangle|quad|qquad)', '', s)
-        s = re.sub(r'\band\b', '', s)
-        s = re.sub(r'\s*,\s*', ' ', s)  # Remove commas with surrounding space
-        
-        # Step 1: Convert LaTeX fractions PROPERLY: \frac{a}{b} -> (a)/(b)
-        while '\\frac' in s:
-            s = re.sub(r'\\frac\s*\{([^{}]*)\}\{([^{}]*)\}', r'(\1)/(\2)', s)
-            if '\\frac' in s and '{' not in s:
-                s = s.replace('\\frac', '')
-        
-        # Step 2: Convert other LaTeX commands
-        s = s.replace('\\cdot', '*').replace('\\times', '*')
-        s = s.replace('\\pi', 'pi').replace('\\sqrt', 'sqrt')
-        s = s.replace('\\sin', 'sin').replace('\\cos', 'cos').replace('\\tan', 'tan')
-        s = s.replace('\\ln', 'ln').replace('\\log', 'log')
-        s = s.replace('\\left', '').replace('\\right', '')
-        
-        # Step 3: Convert remaining braces to parens
-        s = s.replace('{', '(').replace('}', ')')
-        
-        # Step 4: Convert ^ to **
-        s = s.replace('^', '**')
-        
-        # Step 5: Implicit multiplication (run multiple passes)
-        for _ in range(3):  # Multiple passes catch nested cases
-            s = re.sub(r'(\d)([a-zA-Z(])', r'\1*\2', s)         # 4x → 4*x, 2( → 2*(
-            s = re.sub(r'\)([a-zA-Z0-9(])', r')*\1', s)          # )x → )*x, )( → )*(
-            s = re.sub(r'([a-zA-Z])(?<![a-zA-Z])\(', r'\1*(', s) # x( → x*( but not sin(
-        
-        # Step 6: Fix function-call implicit mul that shouldn't be there
-        for func in ['sin', 'cos', 'tan', 'sqrt', 'log', 'ln', 'exp', 'Abs', 'abs', 'pi']:
-            s = s.replace(f'{func}*(', f'{func}(')
-        
-        # Step 7: Clean whitespace — only strip truly invalid chars
-        s = re.sub(r'[^\S\r\n]+', ' ', s)
-        s = re.sub(r'[\u0590-\u05FF\u200B-\u200D\uFEFF\'"`;@#%&!?]', '', s)
-        s = re.sub(r'\\[a-zA-Z]+', '', s)
-        
-        # Step 8: Remove leading = or trailing junk
-        s = s.lstrip('=').rstrip('.,;')
-        
-        print(f"📈 🔵 [BIT-LOG] SymPy Sanitized: '{expr}' → '{s}'")
-        return s
-
-    def _deep_sanitize_math(self, text: str) -> str:
-        """V281.1: Aggressively strips non-printable characters from math blocks."""
-        if not text: return ""
-        # Remove Tabs, Newlines, and multiple spaces which break KaTeX
-        s = text.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')
-        s = re.sub(r'\s+', ' ', s)
-        return s.strip()
-
-    async def _validate_anchor(self, data_anchor: dict, image_data: bytes, problem_text: str = "") -> dict:
-        """V8.9.2: Single Source of Truth Validator pass."""
-        try:
-            from prompts import get_anchor_validation_prompt
-            from utils.safe_json import safe_extract_json
-            
-            prompt = get_anchor_validation_prompt(data_anchor)
-            
-            # Using current model which supports Vision
-            response = await self.model.generate_content_async(
-                [
-                    {"mime_type": "image/jpeg", "data": image_data},
-                    prompt
-                ]
-            )
-            
-            match = re.search(r'\{.*\}', response.text, re.DOTALL)
-            if match:
-                clean_anchor = safe_extract_json(match.group(), "anchor_validator")
-                if clean_anchor:
-                    print(f"🛡️ ✅ [V8.9.2] Anchor Validated: {len(clean_anchor.get('function_equations', []))} equations found.")
-                    return clean_anchor
-            
-            # V8.9.6: If validator returns garbage, Fallback to raw OCR
-            print("⚠️ [V8.9.6] Validator returned invalid JSON. Falling back to raw OCR.")
-            return {"raw_ocr_text": problem_text}
-        except Exception as e:
-            print(f"⚠️ [V8.9.2] Anchor Validation failed: {e}. Falling back to raw OCR.")
-            return {"raw_ocr_text": problem_text}
-
-    async def _save_exercise_history(self, uid: str, question: str, solutions: list):
-        """V317.0: Saves sanitized exercise history with clean titles."""
-        try:
-            db = firebase_manager.get_db()
-            if not db or not uid: return
-
-            def generate_clean_title(ocr_raw_text):
-                try:
-                    # מנקה JSON אם קיים
-                    if isinstance(ocr_raw_text, str) and ocr_raw_text.strip().startswith('{'):
-                        match = re.search(r'\{.*\}', ocr_raw_text, re.DOTALL)
-                        if match:
-                            data = safe_json_loads(match.group())
-                            text = data.get('text', '')
-                        else:
-                            text = str(ocr_raw_text)
-                    else:
-                        text = str(ocr_raw_text)
-                    
-                    # ניקוי LaTeX וסימנים טכניים מתקדם
-                    # 1. הסרת בלוקים של מתמטיקה $...$
-                    text = re.sub(r'\$.*?\$', '', text)
-                    # 2. הסרת פקודות LaTeX נפוצות (למשל \frac{...}{...})
-                    text = re.sub(r'\\[a-zA-Z]+', '', text)
-                    # 3. הסרת סוגריים מסולסלים ומרובעים
-                    text = re.sub(r'[\{\}\[\]]', '', text)
-                    # 4. ניקוי סימנים מתמטיים שאריתיים
-                    text = re.sub(r'[\^_*=+\-/|]', '', text)
-                    
-                    # חיתוך ל-6 מילים ראשונות
-                    words = text.split()
-                    if not words: return "תרגיל במתמטיקה"
-                    title = " ".join(words[:6])
-                    if len(words) > 6: title += "..."
-                    return title.replace('\n', ' ').strip()
-                except Exception as e:
-                    logging.debug(f"⚠️ [BIT-LOG] Title generation failed: {e}")
-                    return "תרגיל במתמטיקה"
-            
-            # Flatten solution steps into a single string
-            solution_text_parts = []
-            for sol in solutions:
-                res = sol.get("response", {})
-                if "sections" in res:
-                    for section in res["sections"]:
-                        title = section.get("section_title", "")
-                        solution_text_parts.append(f"### {title}")
-                        for step in section.get("steps", []):
-                            exp = step.get("explanation_text", "") or ""
-                            math = step.get("math_artifact", {}).get("latex", "") or ""
-                            if not math: math = step.get("block_math", "") or ""
-                            
-                            solution_text_parts.append(str(exp))
-                            if math:
-                                math = self._deep_sanitize_math(str(math))
-                                solution_text_parts.append(f"$${math}$$")
-                solution_text_parts.append("---")
-            
-            full_solution = "\n\n".join(solution_text_parts)
-            
-            from firebase_admin import firestore
-            import datetime
-            # Save to history collection with clean title
-            history_ref = db.collection('users').document(uid).collection('history').document()
-            history_ref.set({
-                "original_question_text": question,
-                "display_title": generate_clean_title(question),
-                "solution_steps_text": full_solution,
-                "timestamp": firestore.SERVER_TIMESTAMP
-            })
-            print(f"✅ [HISTORY] Successfully saved exercise to DB: users/{uid}/history")
-        except Exception as e:
-            print(f"❌ [HISTORY] Error saving history: {e}")
-            import traceback
-            traceback.print_exc()
-
-    # ===================== EXISTING PIPELINE METHODS =====================
-
-    def _smart_minify(self, data):
-        """V226.1+ Line-based minifier that preserves newlines around Math blocks."""
-        if isinstance(data, str):
-            clean = data.replace('\r\n', '\n').replace('\r', '\n')
-            token = "###NEWLINE_TOKEN###"
-            clean = re.sub(r'\n\s*\n', token, clean)
-            lines = clean.split('\n')
-            result = []
-            for i, line in enumerate(lines):
-                stripped = line.strip()
-                if not stripped: continue
-                should_keep = False
-                if stripped.endswith('$$') or stripped.startswith('$$'): should_keep = True
-                if i + 1 < len(lines):
-                    next_stripped = lines[i+1].strip()
-                    if next_stripped.startswith('$$') or next_stripped.startswith('*') or next_stripped.startswith('-'): should_keep = True
-                    if next_stripped.startswith('**'): should_keep = True
-                result.append(stripped)
-                if should_keep: result.append('\n')
-                else: result.append(' ')
-            final_text = "".join(result).replace(token, '\n\n')
-            final_text = re.sub(r' +', ' ', final_text)
-            return final_text.strip()
-        elif isinstance(data, dict):
-            return {k: self._smart_minify(v) for k, v in data.items() if v is not None}
-        elif isinstance(data, list):
-            return [self._smart_minify(i) for i in data if i is not None]
-        return data
-
-    def _sanitize_teacher_response(self, text: str) -> str:
-        """
-        V275.2: ANTI-CHATTER GUARD 🛡️
-        Removes ENTIRE SENTENCES containing apologetic/self-correction language.
-        V261.7: PIPELINE SYNC - Now also runs sanitize_math_text!
-        """
-        if not text: return ""
-        
-        # V275.4: Expanded chatter phrases - catches self-correction monologue from LLM
-        chatter_words = (
-            r"(oops|sorry|mistake|apologize|let me correct|my bad"
-            r"|אופס|סליחה|טעות|מתנצל|תיקון|שגיתי|טעיתי|מצטער"
-            r"|בוא נתקן|רגע|שים לב לטעות|הייתה טעות|נפלה טעות|תיקון טעות|בחישוב הקודם"
-            # V275.4: New patterns from investigation question logs
-            r"|טעות חשיבה|בוא ננסה שוב|סוף סוף הבנתי|על הבלבול"
-            r"|זה לא עובד|מה עושים|זה לא טוב|זה לא נכון|מה קורה פה"
-            r"|בוא נחשוב על זה|שלי הייתה|בוא נחזור אחורה|בוא נתחיל מהתחלה"
-            r"|אני קצת מבולבל|על כל הטעויות|נוספת|קונספטואלית|בשאלה"
-            r"|wait|רגע|let me think|hold on)"
-        )
-        
-        # Regex to match the ENTIRE SENTENCE containing one of the chatter phrases
-        # Matches from previous period/newline to the next period/newline
-        chatter_sentence_pattern = r"(?i)\s*[^.!?\n]*?(?:" + chatter_words + r")[^.!?\n]*?[.!?]?"
-        
-        cleaned = text
-        cleaned = re.sub(chatter_sentence_pattern, "", cleaned)
-            
-        # V261.7: Global Math Sanitization (Fixes mangled ( x )^2 etc.)
-        cleaned = sanitize_math_text(cleaned)
-            
-        return cleaned.strip()
-
-    def _scrub_latex_from_text(self, data):
-        """✅ V261.3: Aggressively scrub LaTeX commands from Hebrew text."""
-        if isinstance(data, str):
-            # 1. Protect math blocks $...$ and $$...$$
-            protected = []
-            def protect(match):
-                protected.append(match.group(0))
-                return f"__MATH_BLOCK_{len(protected)-1}__"
-            
-            temp = re.sub(r'\$\$[^$]+?\$\$', protect, data)
-            temp = re.sub(r'(?<!\$)\$(?!\$)[^$]+?(?<!\$)\$(?!\$)', protect, temp)
-            
-            # 2. Scrub LaTeX commands from the TEXT parts
-            # Remove \cdot, \quad, \text{...}, etc.
-            temp = temp.replace(r'\cdot', '')
-            temp = temp.replace(r'\quad', ' ')
-            temp = temp.replace(r'\text', '')
-            # Remove any other backslash commands in text
-            temp = re.sub(r'\\[a-zA-Z]+', '', temp)
-            # Remove orphan braces { } often left behind by \text{}
-            temp = temp.replace('{', '').replace('}', '')
-            
-            # 3. Restore math blocks
-            for i, block in enumerate(protected):
-                temp = temp.replace(f"__MATH_BLOCK_{i}__", block)
-            
-            return temp
-            
-        elif isinstance(data, dict):
-            return {k: self._scrub_latex_from_text(v) for k, v in data.items()}
-        elif isinstance(data, list):
-            return [self._scrub_latex_from_text(i) for i in data]
-        return data
-
-    def _sanitize_and_split(self, data):
-        """V230.4: Mixed-to-Inline Fix. Modified to allow equations to stay as block math."""
-        if isinstance(data, str):
-            text_outside_math = re.sub(r'\$\$.*?\$\$', '', data, flags=re.DOTALL)
-            has_hebrew_outside = bool(re.search(r'[\u0590-\u05FF]', text_outside_math))
-            
-            def splitter(match):
-                content = match.group(1)
-                # If there's Hebrew *inside* the math block, it's probably mixed text, so inline it.
-                if re.search(r'[\u0590-\u05FF]', content):
-                    return f" ${content}$ "
-                
-                # V8.8: No longer eagerly downgrading pure math to inline just because there's
-                # Hebrew *outside* the math block. We want calculations on their own line.
-                # Just keep it as block math.
-                return f"$${content}$$"
-            
-            return re.sub(r'\$\$(.*?)\$\$', splitter, data, flags=re.DOTALL)
-        elif isinstance(data, dict):
-            return {k: self._sanitize_and_split(v) for k, v in data.items()}
-        elif isinstance(data, list):
-            return [self._sanitize_and_split(i) for i in data]
-        return data
-
-orchestrator = BuddyOrchestrator()
\ No newline at end of file
diff --git a/packages.txt b/packages.txt
deleted file mode 100644
index c176677adbc47d47a2d7f31874221807bd61634c..0000000000000000000000000000000000000000
--- a/packages.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-pango1.0-tools
-libpango1.0-dev
-libcairo2-dev
-libffi-dev
diff --git a/pedagogical_builder.py b/pedagogical_builder.py
deleted file mode 100644
index 6e16e418a09ce8abcd620ec9054a8e5bcc10f98d..0000000000000000000000000000000000000000
--- a/pedagogical_builder.py
+++ /dev/null
@@ -1,850 +0,0 @@
-# pedagogical_builder.py - V231.18
-# Server-side pedagogical templates for BuddyMath
-# Adds detailed explanations WITHOUT using LLM tokens!
-
-"""
-Pedagogical Builder for BuddyMath
-Follows Iron Law #4: CHILD-FRIENDLY ALWAYS
-
-LLM returns ONLY mathematical core (100-200 tokens).
-Server adds full pedagogical wrapper (0 tokens!).
-"""
-
-import re
-from domain.processing_strategy import ProcessingStrategy
-
-class LLMSchemaError(Exception):
-    """Custom error for LLM output validation failures."""
-    pass
-
-# validate_narrative_density (Unified at line 362)
-
-
-
-# ==================== PEDAGOGICAL TEMPLATES ====================
-
-PEDAGOGICAL_TEMPLATES = {
-    # ========== GEOMETRY ==========
-    
-    "CIRCLE_EQUATION": {
-        "intro": {
-            "title": "מקום גיאומטרי או משוואת מעגל",
-            "content": "בואו נפתור צעד אחר צעד ונשתמש במשוואת המעגל והמרחק לפי הצורך.",
-            "tip": "חשוב להבין את המשמעות הגיאומטרית של הנתונים"
-        },
-        "steps": [
-            {
-                "title": "מה נתון לנו?",
-                "uses_llm": "approach",
-                "tip": "תמיד מסדרים את הנתונים קודם"
-            },
-            {
-                "title": "איך מחשבים מרחק?",
-                "content": "נזכיר את נוסחת המרחק: המרחק מנקודה $(x,y)$ לנקודה $(a,b)$ הוא $d = \\sqrt{{(x-a)^2 + (y-b)^2}}$",
-                "block_math": "d = \\sqrt{(x-a)^2 + (y-b)^2}",
-                "tip": "זו נוסחת פיתגורס במסווה!"
-            },
-            {
-                "title": "חישוב הפתרון",
-                "uses_llm": "steps"
-            },
-            {
-                "title": "התשובה הסופית",
-                "content": "קיבלנו את התשובה הסופית!",
-                "uses_llm": "solution"
-            }
-        ],
-        "closing": "כל הכבוד! הצלחנו לפתור את השאלה המורכבת הזו! 🎉"
-    },
-    
-    "DERIVATIVE_QUOTIENT": {
-        "intro": {
-            "title": "נגזרת של מנה",
-            "content": "כשיש לנו פונקציה שהיא מנה (חילוק) של שתי פונקציות, נשתמש בכלל המנה.",
-            "tip": "כלל המנה: $(\\frac{u}{v})' = \\frac{u'v - uv'}{v^2}$"
-        },
-        "steps": [
-            {
-                "title": "זיהוי המונה והמכנה",
-                "template": "המונה: $u = {numerator}$\nהמכנה: $v = {denominator}$"
-            },
-            {
-                "title": "נגזרת המונה",
-                "content": "נמצא את $u'$ (נגזרת המונה):",
-                "uses_llm": "u_prime"
-            },
-            {
-                "title": "נגזרת המכנה",
-                "content": "נמצא את $v'$ (נגזרת המכנה):",
-                "uses_llm": "v_prime"
-            },
-            {
-                "title": "נציב בכלל המנה",
-                "content": "עכשיו נציב בנוסחה: $(\\frac{u}{v})' = \\frac{u'v - uv'}{v^2}$",
-                "uses_llm": "derivative",
-                "tip": "שים לב לסדר: u'v **פחות** uv'"
-            }
-        ],
-        "closing": "מעולה! שלטת בכלל המנה! 💪"
-    },
-    
-    "LINEAR_EQUATION": {
-        "intro": {
-            "title": "פתרון משוואה לינארית",
-            "content": "משוואה לינארית היא משוואה שבה המשתנה מופיע בחזקה 1 בלבד. המטרה: לבודד את x.",
-            "tip": "כלל הזהב: מה שעושים בצד אחד, עושים גם בצד השני!"
-        },
-        "steps": [
-            {
-                "title": "המשוואה שלנו",
-                "template": "נתון: ${equation}$"
-            },
-            {
-                "title": "פתרון שלב אחר שלב",
-                "uses_llm": "steps",
-                "tip": "בכל שלב, נקרב את x לבידוד"
-            },
-            {
-                "title": "התשובה",
-                "template": "הפתרון: $x = {solution}$"
-            }
-        ],
-        "closing": "יפה! פתרת את המשוואה! ✅"
-    },
-
-    # ========== GENERAL / ALGEBRA ==========
-    "GENERAL": {
-        "intro": {
-            "title": "ניתוח השאלה",
-            "content": "בואו נראה מה נתון לנו ומה צריך למצוא. נפרק את הבעיה לשלבים פשוטים.",
-            "tip": "קריאה נכונה של השאלה היא 50% מהפתרון!"
-        },
-        "steps": [
-            {
-                "title": "מה נתון?",
-                "content": "נסדר את הנתונים והמשוואות בצורה ברורה.",
-                "uses_llm": "approach" # Use approach/strategy as step 1
-            },
-            {
-                "title": "דרך הפתרון",
-                "uses_llm": "steps",
-                "tip": "נפתור שלב אחר שלב בצורה מסודרת"
-            },
-            {
-                "title": "תשובה סופית",
-                "template": "הגענו לתוצאה: {solution}",
-                "uses_llm": "solution"
-            }
-        ],
-        "closing": "מצוין! סיימנו את הסעיף הזה בהצלחה."
-    },
-    
-    # Alias for Rational Function (uses General structure but refined)
-    "RATIONAL_FUNCTION": {
-        "intro": {
-            "title": "חקירת פונקציה רציונלית",
-            "content": "פונקציה רציונלית היא מנה של פולינומים. נבדוק תחום הגדרה, אסימפטוטות ונקודות מיוחדות.",
-            "tip": "חשוב לבדוק מתי המכנה מתאפס!"
-        },
-        "steps": [
-            {
-                "title": "ניתוח הפונקציה",
-                "content": "נסתכל על המונה והמכנה ונראה אם אפשר לפשט.",
-                "uses_llm": "approach"
-            },
-            {
-                "title": "הפתרון המלא",
-                "uses_llm": "steps",
-                "tip": "עבודה מסודרת מונעת טעויות חישוב"
-            },
-            {
-                "title": "סיכום",
-                "uses_llm": "solution"
-            }
-        ],
-        "closing": "כל הכבוד! חקירה יסודית היא המפתח."
-    },
-
-    # ========== TRIGONOMETRY ==========
-    "TRIGONOMETRY": {
-        "intro": {
-            "title": "חשבון טריגונומטרי",
-            "content": "נשתמש בזהויות טריגונומטריות ובתכונות המשולש כדי לפתור.",
-            "tip": "זכור: sin²x + cos²x = 1"
-        },
-        "steps": [
-            {
-                "title": "זיהוי המצב",
-                "content": "נבדוק אילו זווית וצלעות נתונות לנו.",
-                "uses_llm": "approach"
-            },
-            {
-                "title": "ביצוע החישוב",
-                "uses_llm": "steps",
-                "tip": "שימו לב יחידות מעלות/רדיאנים!"
-            },
-            {
-                "title": "התשובה",
-                "template": "התוצאה: {solution}",
-                "uses_llm": "solution"
-            }
-        ],
-        "closing": "מצוין! הטריגונומטריה בידינו! 📐"
-    },
-    # Alias for basic trig
-    "TRIG_BASIC": {
-         "intro": { "title": "טריגונומטריה בסיסית", "content": "חישוב זוויות וצלעות במשולש ישר זווית." },
-         "steps": [{"title": "פתרון", "uses_llm": "steps"}, {"title": "תשובה", "uses_llm": "solution"}],
-         "closing": "יופי!"
-    }
-}
-
-def build_pedagogical_response(
-    topic_id: str,
-    llm_output: dict,
-    data_anchor: dict,
-    custom_title: str = None,  # V260.3: Allow override
-    proof_graph = None,        # V1.1: Immutable ProofGraph
-    processing_strategy: ProcessingStrategy = None # V5.8.0: Intent Contract
-) -> dict:
-    """
-    V4.2 (Behavioral Firewall): Projection-Only Builder.
-    The UI serves ONLY as a projection of the mathematical ProofGraph.
-    LLM math generation is strictly forbidden.
-    """
-    try:
-        print(f"🧱 [V4.2] Projection-Only Mode: topic={topic_id}, ProofGraph={proof_graph is not None}")
-        print(f"DEBUG [PRE-SCRUB]: LLM generated raw narrative: {llm_output}")
-
-        if not proof_graph or not proof_graph.steps:
-            # V5.8.0: Enforce Intent Matrix! If strategy is STRICT_SYMBOLIC, failure to provide graph is a fatal error.
-            if processing_strategy == ProcessingStrategy.STRICT_SYMBOLIC:
-                print(f"🛑 [V5.8.0] STRICT_SYMBOLIC Violation: No ProofGraph provided. Blocking response.")
-                raise LLMSchemaError("Truth Authority Violation: STRICT_SYMBOLIC strategy requires a verified ProofGraph.")
-                
-            if processing_strategy == ProcessingStrategy.HEURISTIC_DEDUCTION:
-                print(f"✅ [V7.3] HEURISTIC_DEDUCTION detected. Bypassing Truth Authority.")
-                return _build_generic_response(llm_output, custom_title=custom_title)
-
-            if isinstance(llm_output, list) and len(llm_output) > 0:
-                print(f"✅ [V7.3] Hybrid Navigation detected (List Segment). Bypassing ProofGraph requirement.")
-                return _build_generic_response(llm_output, custom_title=custom_title)
-
-            if isinstance(llm_output, dict) and ("solution_markdown" in llm_output or "steps" in llm_output or "chain_of_thought" in llm_output):
-                return _build_generic_response(llm_output, custom_title=custom_title)
-            
-            # V8.5 RESILIENCE: One more attempt to find steps if we're failing
-            if isinstance(llm_output, dict) and "sections" in llm_output:
-                 return _build_generic_response(llm_output, custom_title=custom_title)
-
-            # If no clues at all, THEN we raise
-            logger.warning(f"⚠️ [V8.5] Truth Authority Violation: Falling back to generic due to invalid structure: {llm_output}")
-            return _build_generic_response(llm_output, custom_title=custom_title)
-
-        # 1. Map ProofGraph to Immutable Truth Nodes
-        sympy_nodes = []
-        for step in proof_graph.steps:
-            sympy_nodes.append({
-                "step_id": step.step_id,
-                "block_math": step.math_content,
-                "title": step.logic_description or f"שלב {step.step_id}"
-            })
-
-        # 2. Extract explanations from LLM (The "Skin") - V4.2.7 supports list or dict
-        if isinstance(llm_output, list):
-            llm_explanations = llm_output
-        else:
-            # V5.8.2: Support parsing nested 'sections' from the LLM output
-            llm_explanations = llm_output.get("steps_explanations", llm_output.get("steps", []))
-            if not llm_explanations and "sections" in llm_output:
-                for section in llm_output["sections"]:
-                    if "steps" in section:
-                        llm_explanations.extend(section["steps"])
-
-        if not llm_explanations:
-             # Internal Fallback: If LLM failed, use generic text to preserve UI
-             llm_explanations = [{"step_id": s["step_id"], "explanation_text": "נבצע את החישוב המתמטי"} for s in sympy_nodes]
-        else:
-            # V276.1: Normalize explanations to handle structured content/type keys
-            for node in llm_explanations:
-                if "explanation_text" not in node or not node["explanation_text"]:
-                    node["explanation_text"] = node.get("content_mixed", node.get("content", node.get("explanation", "")))
-                
-                # Unpack dict if still found
-                if isinstance(node["explanation_text"], dict):
-                    node["explanation_text"] = node["explanation_text"].get("content", node["explanation_text"].get("text", str(node["explanation_text"])))
-             
-        # V5.8.2: Layer 2 Runtime Validator (The Kill Switch)
-        for node in llm_explanations:
-            text = node.get("explanation_text", "")
-            if not validate_narrative_density(text):
-                print(f"🛑 [V5.8.2] KILL SWITCH TRIGGERED on text: {text}")
-                raise LLMSchemaError("NARRATIVE_OVERFLOW: Explanation is too dense or contains forbidden math/English characters.")
-        
-        # 3. Deterministic Merge (Iron Law) - V4.2.7: explanation_text
-        merged_steps = merge_and_verify_explanations(sympy_nodes, llm_explanations)
-        
-        # 5. UI Projection (Hard Decoupling V4.2.10)
-        ui_steps = []
-        for i, node in enumerate(merged_steps):
-            # V8.6.2: Ensure LaTeX preserved in content_mixed (removed aggressive $ and \ stripping)
-            explanation = sanitize_math_text(node["explanation_text"])
-            
-            math_content = node["block_math"]
-            
-            ui_steps.append({
-                "step_id": node["step_id"],
-                "step_number": i + 1, 
-                "explanation_text": explanation,
-                "math_artifact": {
-                    "type": "equation",
-                    "latex": math_content,
-                    "table_data": ""
-                },
-                # We keep these for one more version as 'Ghost Keys' for extreme backward compatibility
-                # but they now mirror the structured data perfectly.
-                "content_mixed": explanation,
-                "block_math": math_content
-            })
-
-        # V8.6: Inject 'approach' as Step 0 to ensure Flutter displays it
-        approach = llm_output.get("approach")
-        if approach and isinstance(approach, str):
-            ui_steps.insert(0, {
-                "step_id": 0,
-                "step_number": 0,
-                "title": "איך ניגשים לזה? 🧭",
-                "explanation_text": sanitize_math_text(approach),
-                "content_mixed": sanitize_math_text(approach),
-                "math_artifact": {"type": "equation", "latex": ""},
-                "block_math": ""
-            })
-
-        # V8.6.2: Final check on teacher_summary from LLM
-        summary = llm_output.get("teacher_summary") or llm_output.get("summary")
-
-        response = {
-            "sections": [{
-                "section_title": custom_title or "פתרון מלא ומדויק",
-                "steps": ui_steps,
-                "section_result": merged_steps[-1]["block_math"] if merged_steps else ""
-            }],
-            "final_answer": merged_steps[-1]["block_math"] if merged_steps else "",
-            "teacher_closing": llm_output.get("teacher_closing", "כל הכבוד על פתרון התרגיל! 🎉"),
-            "approach": approach,
-            "teacher_summary": summary 
-        }
-        
-        # V260.5: Propagate Investigation Data (Crucial for Table UI)
-        if "investigation" in llm_output:
-            response["investigation"] = llm_output["investigation"]
-        elif "investigation_table" in llm_output:
-            response["investigation"] = llm_output["investigation_table"]
-            
-        return apply_cognitive_load_limiter(response)
-    except Exception as e:
-        logger.error(f"🚨 [V8.5 RESILIENCE] Builder Crash: {e}. Falling back to generic.")
-        return _build_generic_response(llm_output, custom_title=custom_title)
-
-def apply_cognitive_load_limiter(response: dict) -> dict:
-    """
-    V1.1: Cognitive Load Limiter.
-    Ensures steps are revealed gradually.
-    """
-    if "sections" not in response: return response
-    
-    # Limit to first 2 steps if complex, mark others as 'hidden'
-    step_count = 0
-    for section in response["sections"]:
-        if "steps" in section:
-            for step in section["steps"]:
-                step_count += 1
-                # V1.1 Rule: If more than 3 steps, flag the rest for gradual disclosure
-                if step_count > 3:
-                     step["disclosure_state"] = "HIDDEN"
-                else:
-                     step["disclosure_state"] = "VISIBLE"
-    
-    return response
-
-def validate_narrative_density(text: str) -> bool:
-    """
-    V5.8.2: Layer 2 Runtime Validator (Kill Switch).
-    Checks if the pedagogical explanation adheres to the Hard Doctrine.
-    
-    V8.5: RESILIENCE - Relaxed to allow math symbols in text-only steps.
-    Returns False ONLY if it is too long (runaway LLM) or contains dangerous code.
-    """
-    if len(text) > 400:
-        return False
-    # V8.5: Increased tolerance for English letters (ABC labels) and math signs.
-    # We only block forbidden programmatic keywords like 'def', 'class', etc.
-    import re
-    if re.search(r'\b(import|def|class|lambda)\b', text):
-        return False
-    return True
-
-def merge_and_verify_explanations(sympy_nodes: list[dict], llm_explanations: list[dict]) -> list[dict]:
-    """
-    V2.5.3: The Swiss Watch Maneuver.
-    V3.1.3: Hardened Merge Phase with robust guards.
-    V5.8.2: Robust Merge (Option 1) to ignore LLM self-referencing narrative drift.
-    Merges Immutable SymPy math (Truth) with LLM explanations (Skin).
-    """
-    final_nodes = [] # V3.1.3: Mandatory initialization
-
-    try:
-        # V5.8.2 Robust Merge
-        for step in sympy_nodes:
-            sid = step["step_id"]
-            
-            # Find all LLM explanations for this step
-            candidates = [
-                s for s in llm_explanations
-                if s.get("step_id") == sid and "explanation_text" in s
-            ]
-            
-            if not candidates:
-                # If LLM completely missed a step, fallback to generic
-                final_nodes.append({
-                    **step,
-                    "explanation_text": "נבצע את החישוב המתמטי."
-                })
-                continue
-            
-            # Take the last candidate to ignore preamble/meta-commentary drift
-            best_candidate = candidates[-1]
-            explanation_text = best_candidate["explanation_text"]
-            
-            # V6 Narrative Drift Telemetry
-            if "allowed_concepts" in step and step["allowed_concepts"]:
-                import re
-                words = [w for w in re.split(r'\s+', explanation_text) if len(w) > 2] # simple word split ignoring short connectives
-                allowed_words = set()
-                for concept in step["allowed_concepts"]:
-                    allowed_words.update(concept.split())
-                
-                unauthorized_words = [w for w in words if w not in allowed_words]
-                drift_percentage = (len(unauthorized_words) / max(len(words), 1)) * 100
-                
-                if drift_percentage > 50.0:
-                    import logging
-                    logger = logging.getLogger(__name__)
-                    logger.warning(f"⚠️ [V6 TELEMETRY] Drift Warning: {drift_percentage:.1f}% concept drift in Step {sid} (unauthorized: {unauthorized_words[:3]}...)")
-
-            # V5.8.2 Kill Switch Validator Call
-            if not validate_narrative_density(explanation_text):
-                msg = f"NARRATIVE_OVERFLOW: Explanation rejected by Kill Switch: {explanation_text[:20]}..."
-                print(f"🚨 [V5.8.2] {msg}")
-                raise LLMSchemaError("NARRATIVE_OVERFLOW")
-                
-            merged_node = {
-                **step, 
-                "explanation_text": explanation_text
-            }
-            final_nodes.append(merged_node)
-
-        return final_nodes
-
-    except LLMSchemaError:
-        raise
-    except Exception as e:
-        import logging
-        logger = logging.getLogger(__name__)
-        logger.error(f"🚨 [V3.1.3] Merge Phase Failed: {e}")
-        # Since orchestrator is downstream, we re-raise or return something that indicates failure.
-        raise LLMSchemaError(f"Merge failure: {str(e)}")
-
-def _normalize_llm_keys(llm_output: dict) -> dict:
-    """V275.3: Map alternative LLM output keys to expected template keys.
-    E.g., CIRCLE_EQUATION returns 'equation' but GENERAL template expects 'solution'."""
-    result = dict(llm_output)
-    # Map equation -> solution if solution is missing
-    if "solution" not in result and "equation" in result:
-        result["solution"] = result["equation"]
-    # Map approach alternatives
-    if "approach" not in result and "strategy" in result:
-        result["approach"] = result["strategy"]
-    return result
-
-
-def _build_template_response(topic_id: str, llm_output: dict, data_anchor: dict) -> dict:
-    """Build response using topic-specific template."""
-    
-    template = PEDAGOGICAL_TEMPLATES[topic_id]
-    
-    # V275.3: Normalize LLM keys so templates always find what they need
-    llm_output = _normalize_llm_keys(llm_output)
-    
-    # Build response
-    section_data = {
-        "section_title": "פתרון מלא",
-        "steps": [],
-        "section_result": llm_output.get("equation") or llm_output.get("solution") or llm_output.get("derivative")  # V262.0: Per-section result
-    }
-    
-    response = {
-        "sections": [section_data],
-        "final_answer": section_data["section_result"],
-        "teacher_closing": template.get("closing", "כל הכבוד! 🎉"),
-        "teacher_summary": llm_output.get("teacher_summary") # V262.2: Propagate explicit summary
-    }
-    
-    # Add intro step
-    if "intro" in template:
-        intro = template["intro"]
-        response["sections"][0]["steps"].append({
-            "step_number": 0,
-            "title": intro["title"],
-            "content_mixed": intro["content"],
-            "teacher_tip": intro.get("tip", "")
-        })
-    
-    # Add main steps
-    for i, step_template in enumerate(template["steps"], start=1):
-        
-        # V275.2 FIX: Handle unpacking of 'steps' list from llm_output gracefully!
-        if step_template.get("uses_llm") == "steps" and isinstance(llm_output.get("steps"), list):
-            for s in llm_output["steps"]:
-                steps_count = len(response["sections"][0]["steps"])
-                # V275.3: Check multiple content key names (different micro-prompts use different schemas)
-                content = s.get("content_mixed", s.get("content", s.get("explanation", "")))
-                new_step = {
-                    "step_number": steps_count + 1,
-                    "title": s.get("title", f"שלב {steps_count + 1}"),
-                    "content_mixed": sanitize_math_text(content),
-                    "block_math": s.get("block_math", s.get("result", "")),
-                    "teacher_tip": s.get("teacher_tip", step_template.get("tip"))
-                }
-                response["sections"][0]["steps"].append(new_step)
-            continue
-            
-        step = {
-            "step_number": len(response["sections"][0]["steps"]) + 1,
-            "title": step_template["title"]
-        }
-        
-        # Fill content
-        if "template" in step_template:
-            # Template with data substitution (merge with llm_output to prevent KeyError)
-            try:
-                content = step_template["template"].format(**{**data_anchor, **llm_output})
-            except KeyError:
-                # V275.3: Strip unresolved {variable} placeholders instead of showing them raw
-                content = re.sub(r'\{\w+\}', '', step_template["template"]).strip()
-            step["content_mixed"] = content
-        
-        if "content" in step_template:
-            step["content_mixed"] = step_template["content"]
-        
-        if "block_math" in step_template:
-            step["block_math"] = step_template["block_math"]
-        
-        if "uses_llm" in step_template:
-            # Use LLM output
-            llm_key = step_template["uses_llm"]
-            if llm_key in llm_output:
-                if llm_key == "solution" or llm_key == "approach":
-                    # Solutions and approaches usually have Hebrew, put them in content to prevent flutter crash
-                    # If there's already template content, append to it
-                    if step.get("content_mixed"):
-                        step["content_mixed"] += "\n" + sanitize_math_text(str(llm_output[llm_key]))
-                    else:
-                        step["content_mixed"] = sanitize_math_text(str(llm_output[llm_key]))
-                else:    
-                    step["block_math"] = sanitize_math_text(str(llm_output[llm_key]))
-        
-        if "tip" in step_template:
-            step["teacher_tip"] = step_template["tip"]
-        
-        response["sections"][0]["steps"].append(step)
-    
-    return response
-
-
-
-import gibberish_detector  # V231.25: Fix gibberish!
-
-def sanitize_math_text(text: str) -> str:
-    """
-    V231.23: Remove English math artifacts and enforce Hebrew/Latex conventions.
-    Forces 'Angle' -> '\\angle', 'Triangle' -> '\\triangle', 'Area' -> 'S'.
-    V260.4: Also runs auto_fix_gibberish (reversed Hebrew, broken Latex).
-    """
-    if not text:
-        return text
-
-    # V260.4: First, fix structural gibberish (reversed Hebrew, broken LaTeX)
-    text = gibberish_detector.auto_fix_gibberish(text)
-
-    # V275.3: Fix quadruple dollars $$$$ -> $$ EARLY (before any block processing)
-    text = re.sub(r'\${3,}', '$$', text)
-
-    # V275.4: CRITICAL - Detect and unwrap $$Hebrew paragraph$$ blocks
-    # The LLM wraps Hebrew explanations in $$...$$ which renders as garbled "mirror text"
-    # Key insight: Hebrew text mixed with g(x), \ln(x) etc has Hebrew ratio ~30%,
-    # so we need a lower threshold AND a consecutive Hebrew words heuristic.
-    def _unwrap_hebrew_math_block(match):
-        content = match.group(1).strip()
-        # Count Hebrew chars vs total
-        hebrew_chars = len(re.findall(r'[\u0590-\u05FF]', content))
-        total_chars = len(content.replace(' ', ''))
-        if total_chars == 0:
-            return ''  # Empty block, remove it
-        hebrew_ratio = hebrew_chars / total_chars
-        # Heuristic 1: >25% Hebrew with enough chars = text paragraph
-        if hebrew_ratio > 0.25 and hebrew_chars > 8:
-            print(f"🧹 [SANITIZE] Unwrapped Hebrew-in-math block ({hebrew_chars} Hebrew chars, ratio={hebrew_ratio:.1%})")
-            return content  # Return as plain text without $$
-        # Heuristic 2: Has 3+ consecutive Hebrew words (even if ratio is low)
-        if re.search(r'[\u0590-\u05FF]+\s+[\u0590-\u05FF]+\s+[\u0590-\u05FF]+', content):
-            print(f"🧹 [SANITIZE] Unwrapped Hebrew-in-math (consecutive Hebrew words detected)")
-            return content
-        return match.group(0)  # Keep as-is for real math
-    
-    text = re.sub(r'\$\$(.+?)\$\$', _unwrap_hebrew_math_block, text, flags=re.DOTALL)
-
-    # V231.25: Fix corrupted LaTeX escapes (form feed \f, invalid \3)
-    text = text.replace('\x0c', r'\f')
-    text = re.sub(r'\\(\d)', r'\1', text)
-    
-    # V275.2: Fix double backslash newlines inside $$...$$ which crash flutter_math_fork
-    # Split blocks safely instead of using \newline
-    def safe_split_newlines(match):
-        block = match.group(1)
-        if r'\begin{' in block:
-            # Leave environments like \begin{cases} alone, they support \\
-            return match.group(0)
-        # Split by \\ or \newline
-        parts = re.split(r'\\\\|\\newline', block)
-        # V280.3: Ensure we don't strip the outer $$ markers when splitting blocks!
-        joined = '$$\n$$'.join(p.strip() for p in parts if p.strip())
-        return f"$${joined}$$" if joined else ""
-    
-    text = re.sub(r'\$\$(.+?)\$\$', safe_split_newlines, text, flags=re.DOTALL)
-    
-    # 1. English Geometrical terms (Case Insensitive)
-    # \\b matches word boundaries to avoid replacing substrings
-    text = re.sub(r'\\bAngle\\b', r'\\angle', text, flags=re.IGNORECASE)
-    text = re.sub(r'\\bTriangle\\b', r'\\triangle', text, flags=re.IGNORECASE)
-    text = re.sub(r'\\bDeg\\b', r'^{\\circ}', text, flags=re.IGNORECASE)
-    
-    # 2. "Area" -> S (e.g. "Area of triangle" -> "S of triangle")
-    # Be careful not to replace valid words, but "Area" in math context is usually S
-    text = re.sub(r'\\bArea\\b', r'S', text, flags=re.IGNORECASE)
-
-    # V262.1: Auto-wrap Hebrew inside LaTeX blocks (The "Escaping Lines" Fix)
-    text = _auto_wrap_hebrew_in_latex(text)
-
-    return text
-
-def _auto_wrap_hebrew_in_latex(text: str) -> str:
-    """
-    Scans for Hebrew characters inside $$...$$ or $...$ blocks.
-    If found, wraps them in \\text{...} to prevent rendering crashes.
-    """
-    if not text: return text
-    
-    # Regex for Hebrew chars (including nikud/punctuation common in Hebrew)
-    hebrew_pattern = r'([\u0590-\u05FF\s\.\,\:\-]+)' 
-
-    def replacer(match):
-        content = match.group(1) # The content inside the dollars
-        # Check if there is Hebrew in this block
-        if re.search(r'[\u0590-\u05FF]', content):
-            # There is Hebrew! Let's wrap the Hebrew parts in \text{...}
-            # We split by math/hebrew chunks or just wrap the whole Hebrew phrase
-            # Simple approach: Find Hebrew chunks and wrap them
-            new_content = re.sub(hebrew_pattern, r'\\text{\1}', content)
-            # Cleanup: \text{ } (empty) or double wrapping check could be added if needed
-            return f"${new_content}$"
-        return match.group(0)
-
-    # Replace inline math $...$ (using naive non-nested check)
-    # We use a trick to avoid matching $$...$$ first if we aren't careful, 
-    # but specific regex for $$...$$ should come first if we supported it fully as separate.
-    # For now, let's handle $...$ which often covers $$...$$ in simple regex unless distinct.
-    # Actually, $$ is just two $s. Let's try to be safe.
-    
-    # Strategy: Split by '$' and process every odd element (1, 3, 5...) as Math?
-    # This is safer than regex for nested/complex strings.
-    
-    parts = text.split('$')
-    if len(parts) < 3: return text # No math blocks
-    
-    new_parts = []
-    for i, part in enumerate(parts):
-        if i % 2 == 1: # This is a MATH block (inside $...$)
-            if re.search(r'[\u0590-\u05FF]', part):
-                # Found Hebrew inside Math! Wrap it.
-                # Note: We must be careful not to wrap existing \text{...} again if possible,
-                # but simple wrapping usually doesn't hurt: \text{\text{...}} is valid-ish or we can ignore.
-                
-                # Better: only wrap Hebrew that is NOT already in \text{...}? 
-                # That's complex. Let's do the simple "Wrap Hebrew Chars" regex.
-                # We exclude commands commands like \frac, \cdot etc.
-                
-                def wrap_hebrew(m):
-                    s = m.group(1)
-                    if len(s.strip()) == 0: return s # Don't wrap just whitespace
-                    if '\\text' in s: return s # Already wrapped (naive check)
-                    return f"\\text{{{s}}}"
-
-                # Apply wrapping to identified hebrew chunks
-                # Note: we use a simplified version of the regex for local substitution
-                part = re.sub(hebrew_pattern, wrap_hebrew, part)
-            
-            new_parts.append(part)
-        else:
-            # This is a REGULAR block (outside/between $...$)
-            new_parts.append(part)
-
-    return '$'.join(new_parts)
-
-def _build_generic_response(llm_output: dict, custom_title: str = None) -> dict:
-    """
-    V231.20: Rich UI formatter — restores 'Old Look' with green box and mixed text/math.
-    ...
-    """
-    # Extract steps
-    steps = []
-    
-    # helper for clean content
-    def get_content(s):
-        if isinstance(s, dict):
-            # Check multiple content key names (different micro-prompts use different schemas)
-            content = s.get("content_mixed", s.get("content", s.get("explanation", s.get("explanation_text", ""))))
-            
-            # V275.5: If content is still a dict (e.g. from structured JSON fragments), extract text
-            if isinstance(content, dict):
-                content = content.get("text", content.get("content", str(content)))
-            return content
-        return str(s)
-
-    # V4.3 Unified Markdown Path
-    if isinstance(llm_output, dict) and "solution_markdown" in llm_output:
-        steps.append({
-            "step_id": 1,
-            "step_number": 1,
-            "title": "פתרון מלא",
-            "explanation_text": sanitize_math_text(str(llm_output["solution_markdown"])),
-            "content_mixed": sanitize_math_text(str(llm_output["solution_markdown"])),
-            "math_artifact": {"type": "equation", "latex": ""},
-            "is_unified_markdown": True
-        })
-    elif (isinstance(llm_output, list)) or (isinstance(llm_output, dict) and "steps" in llm_output and isinstance(llm_output["steps"], list)):
-        raw_steps = llm_output if isinstance(llm_output, list) else llm_output["steps"]
-        for i, s in enumerate(raw_steps, 1):
-            content = get_content(s)
-            if isinstance(content, str):
-                content = sanitize_math_text(content)
-            
-            math_latex = ""
-            if isinstance(s, dict):
-                math_latex = s.get("math_latex", s.get("block_math", s.get("result", "")))
-
-            steps.append({
-                "step_id": s.get("step_id", i) if isinstance(s, dict) else i,
-                "step_number": i,
-                "title": s.get("title", f"שלב {i}") if isinstance(s, dict) else f"שלב {i}",
-                "explanation_text": content,
-                "content_mixed": content,
-                "math_artifact": {
-                    "type": "equation",
-                    "latex": math_latex
-                },
-                "block_math": math_latex,
-                "teacher_tip": s.get("teacher_tip") if isinstance(s, dict) else None
-            })
-    elif isinstance(llm_output, dict) and "chain_of_thought" in llm_output:
-        # Fallback for old models
-        cot = sanitize_math_text(str(llm_output["chain_of_thought"]))
-        steps.append({
-            "step_id": 1,
-            "step_number": 1,
-            "title": "דרך הפתרון",
-            "explanation_text": cot,
-            "content_mixed": cot,
-            "math_artifact": {"type": "equation", "latex": ""}
-        })
-    else:
-        # Last resort - use get_content helper to handle single dict blocks correctly
-        content = get_content(llm_output)
-        if isinstance(content, str):
-            content = sanitize_math_text(content)
-        
-        steps.append({
-            "step_id": 1,
-            "step_number": 1,
-            "title": "הפתרון",
-            "explanation_text": content,
-            "content_mixed": content,
-            "math_artifact": {"type": "equation", "latex": ""}
-        })
-
-    # Extract final answer
-    # Extract final answer with improved fallback logic (V261.16)
-    final_answer = (
-        llm_output.get("final_answer") or 
-        llm_output.get("equation") or 
-        llm_output.get("solution") or 
-        llm_output.get("derivative") or
-        llm_output.get("integral") or
-        llm_output.get("limit") or
-        llm_output.get("x_intercepts") or
-        llm_output.get("min_max_points")
-    )
-    
-    # If it's a list or dict (e.g. points), convert to string representation
-    if isinstance(final_answer, (list, dict)):
-        final_answer = str(final_answer)
-        
-    if not final_answer:
-        final_answer = "ראה שלבים"
-
-    # V8.6: Inject 'approach' as Step 0
-    approach = llm_output.get("approach")
-    if approach and isinstance(approach, str):
-        steps.insert(0, {
-            "step_id": 0,
-            "step_number": 0,
-            "title": "איך ניגשים לזה? 🧭",
-            "explanation_text": sanitize_math_text(approach),
-            "content_mixed": sanitize_math_text(approach),
-            "math_artifact": {"type": "equation", "latex": ""},
-            "block_math": ""
-        })
-
-    response_obj = {
-        "sections": [{
-            "section_title": custom_title or "הפתרון",
-            "steps": steps,
-            "section_result": str(final_answer) # V262.0: Per-section result
-        }],
-        "final_answer": str(final_answer),
-        "teacher_closing": llm_output.get("teacher_closing", "כל הכבוד! 🎉"),
-        "approach": approach, # V8.6: Explicit approach field
-        "teacher_summary": llm_output.get("teacher_summary") # V262.2: Propagate explicit summary
-    }
-    
-    # V260.5: Propagate Investigation Data (Crucial for Table UI)
-    if "investigation" in llm_output:
-        response_obj["investigation"] = llm_output["investigation"]
-    elif "investigation_table" in llm_output:
-        response_obj["investigation"] = llm_output["investigation_table"]
-        
-    return response_obj
-
-if __name__ == "__main__":
-    import json
-    
-    # Test circle equation
-    llm_out = {
-        "equation": "(x-3)^2 + (y-5)^2 = 25",
-        "center": [3, 5],
-        "radius": 5
-    }
-    data = {"center": "(3,5)", "radius": 5}
-    
-    response = build_pedagogical_response("CIRCLE_EQUATION", llm_out, data)
-    print(json.dumps(response, indent=2, ensure_ascii=False))
diff --git a/problem_understanding.py b/problem_understanding.py
deleted file mode 100644
index f89cc07cf6beba9e0be0be09fa0861bcdd38ff98..0000000000000000000000000000000000000000
--- a/problem_understanding.py
+++ /dev/null
@@ -1,155 +0,0 @@
-# problem_understanding.py - V231.14
-# Analyzes problem structure BEFORE solving
-
-"""
-Problem Understanding Module
-Ensures we understand WHAT is being asked before attempting to solve.
-"""
-
-import json
-import re
-from utils.safe_json import safe_extract_json  # V1.0: Canonical extractor
-
-
-def get_problem_understanding_prompt(ocr_text: str, data_anchor: dict) -> str:
-    """
-    Prompt LLM to analyze problem structure.
-    
-    Returns JSON with:
-    - problem_type
-    - sub_questions (all parts א, ב, ג, etc.)
-    - solving_order
-    - dependencies
-    """
-    return f"""
-ANALYZE this math problem structure. DO NOT SOLVE - only understand what is being asked.
-
-Problem Text:
-{ocr_text}
-
-Extracted Data:
-{json.dumps(data_anchor, ensure_ascii=False, indent=2)}
-
-Your task: Identify ALL parts of this problem and create a solving plan.
-
-Return JSON:
-{{
-  "problem_type": "CIRCLE_EQUATION | LINE_EQUATION | GEOMETRIC_LOCUS | DERIVATIVE_QUOTIENT | etc.",
-  "main_question": "Brief description of main question",
-  "sub_questions": [
-    {{
-      "id": "א",
-      "question": "Full text of sub-question א",
-      "requires": ["center", "radius"],
-      "specific_values": ["m=2"],
-      "expected_output": "equation | number | point | etc.",
-      "topic": "CIRCLE_EQUATION"
-    }},
-    {{
-      "id": "ב",
-      "question": "Full text of sub-question ב",
-      "requires": ["equation_from_א", "point"],
-      "specific_values": ["a=1"],
-      "expected_output": "line_equation",
-      "topic": "LINE_TANGENT"
-    }}
-  ],
-  "solving_order": ["א", "ב", "ג"],
-  "dependencies": {{
-    "ב": ["א"],
-    "ג": ["א"]
-  }}
-}}
-
-CRITICAL RULES:
-1. Include ALL sub-questions (א, ב, ג, ד, etc.)
-2. **CHRONOLOGICAL DATA ISOLATION (V310.0 - CRITICAL):** If a specific value (e.g., a=1, m=2) is mentioned ONLY in a specific sub-question, you MUST include it in the `specific_values` array for THAT sub-question only. NEVER put it in the top-level anchor if it's not global. This prevents data leakage (e.g., using a=1 from section ב' to solve section א').
-3. **EXCEPTION:** If the problem asks for a **Geometric Locus (מקום גיאומטרי)**:
-   - This is a SINGLE QUESTION (even if it looks long).
-   - Set `problem_type` = "GEOMETRIC_LOCUS".
-   - Create ONLY ONE sub-question (id="א") containing the entire text.
-4. Identify dependencies (ב needs א's result)
-5. Determine topic for EACH sub-question
-6. DO NOT solve - only analyze structure
-
-Return ONLY valid JSON.
-"""
-
-
-def parse_understanding(response_text: str) -> dict:
-    """Parse LLM understanding response using canonical safe_extract_json."""
-    result = safe_extract_json(response_text, caller="PROBLEM_UNDERSTANDING")
-    # If parsing failed, return a minimal fallback so the pipeline continues
-    if isinstance(result, dict) and result.get("logic_error"):
-        return {
-            "problem_type": "UNKNOWN",
-            "sub_questions": [],
-            "solving_order": [],
-            "dependencies": {}
-        }
-    return result
-
-
-
-def validate_understanding(understanding: dict) -> bool:
-    """Validate understanding structure."""
-    required_keys = ["problem_type", "sub_questions", "solving_order"]
-    
-    if not all(key in understanding for key in required_keys):
-        return False
-    
-    if not isinstance(understanding["sub_questions"], list):
-        return False
-    
-    if len(understanding["sub_questions"]) == 0:
-        return False
-    
-    # Validate each sub-question
-    for sq in understanding["sub_questions"]:
-        if not all(key in sq for key in ["id", "question", "topic"]):
-            return False
-    
-    return True
-
-def enforce_locus_rule(understanding: dict, ocr_text: str) -> dict:
-    """
-    V260.2: Hard Rule - If 'מקום גיאומטרי' exists, FORCE Locus type.
-    """
-    if any(k in ocr_text for k in ["מקום גיאומטרי", "Locus", "מצא את המקום", "המקום הגיאומטרי"]):
-        print("🛡️ [BIT-LOG] Hard Logic: Detected 'Geometric Locus' - Forcing Single Question structure.")
-        return {
-            "problem_type": "GEOMETRIC_LOCUS",
-            "main_question": understanding.get("main_question", "Find the Locus"),
-            "sub_questions": [{
-                "id": "א",
-                "question": ocr_text, # Give the WHOLE text to the single sub-question
-                "requires": [],
-                "expected_output": "equation",
-                "topic": "GEOMETRIC_LOCUS"
-            }],
-            "solving_order": ["א"],
-            "dependencies": {}
-        }
-    return understanding
-
-
-# ==================== USAGE EXAMPLE ====================
-
-if __name__ == "__main__":
-    # Test understanding prompt
-    ocr = """
-    מעגל עם משוואה x² + y² = 12
-    א. מצא את משוואת המעגל
-    ב. מצא משיק למעגל בנקודה A
-    ג. מצא את שטח המעגל
-    """
-    
-    data = {
-        "function_equations": ["x^2 + y^2 = 12"],
-        "points": ["A"],
-        "specific_values": [],
-        "constraints": []
-    }
-    
-    prompt = get_problem_understanding_prompt(ocr, data)
-    print(prompt)
diff --git a/prompts.py b/prompts.py
deleted file mode 100644
index 1b3fc54c90b663845868cc598f87dc4114b86c52..0000000000000000000000000000000000000000
--- a/prompts.py
+++ /dev/null
@@ -1,937 +0,0 @@
-# prompts.py - V275.0 (Enhanced OCR for Nested Fractions)
-# Based on BUDDYMATH_COMPLETE_GUIDE V230.8 §1.3, §4.1, §6.1
-import json
-
-
-def _get_grade_features(grade: str, category: str = "") -> dict:
-    """התאמת רמת הפירוט לפי יחידות לימוד (§5.1)"""
-    is_investigation = (category == "INVESTIGATION")
-    
-    if "5 יח\"ל" in grade:
-        style = "הוכחה דקדקנית של כל מעבר, כולל נגזרות שנייה, קמירות ואסימפטוטות" if is_investigation else "הוכחה דקדקנית של כל מעבר ודיוק אלגברי מירבי"
-        return {
-            "depth": "אקדמי ומעמיק",
-            "style": style,
-            "tone": "מעצים ומאתגר, כביר של בגרות 5 יח\"ל"
-        }
-    elif "4 יח\"ל" in grade:
-        style = "הסבר ברור של חוקי האלגברה עם דגש על כלל שרשרת" if is_investigation else "הסבר ברור של חוקי האלגברה ופירוט תהליכי הפתרון"
-        return {
-            "depth": "מפורט ותומך",
-            "style": style,
-            "tone": "מעודד ומפורט, שלב אחר שלב"
-        }
-    else:
-        return {
-            "depth": "פשוט, ברור ומדובר 'בגובה העיניים' (מבחן הילד בן ה-16)",
-            "style": "צעד אחר צעד, בקריאה שוטפת. חובה להשתמש במשפטי קישור ומעבר מילוליים (כמו 'נציב את הנתונים בנוסחה:', 'כעת נבדוק את תחום ההגדרה:'). אסור להרצות.",
-            "tone": "חם, סבלני, מלא התלהבות ועידוד תמידי. כמו מורה אהובה שעוזרת באופן פרטי."
-        }
-
-def _detect_relevant_rules(text: str, category: str = "") -> list:
-    """זיהוי כללים רלוונטיים לפי קטגוריה — מבוסס-הקשר (§4.1, V231.1)"""
-    rules = []
-    t = text.lower()
-    
-    # === GEOMETRY rules (only for GEOMETRY category) ===
-    if category != "INVESTIGATION":
-        if any(x in t for x in ["מעגל", "מרכז", "רדיוס", "מקום גיאומטרי"]):
-            rules.append(r"משוואת מעגל: $(x-a)^2 + (y-b)^2 = r^2$")
-            rules.append(r"היקף מעגל: $2\\pi r$")
-        if "מרחק" in t or "d =" in t or "מקום גיאומטרי" in t:
-            rules.append(r"דיסטנס: $d = \\sqrt{(x_2-x_1)^2 + (y_2-y_1)^2}$")
-        if any(x in t for x in ["ישר", "שיפוע"]):
-            rules.append(r"משוואת ישר: $y = mx + b$")
-        if any(x in t for x in ["משולש", "שטח"]):
-            rules.append(r"שטח משולש: $S = \\frac{1}{2} \\cdot a \\cdot h$")
-        if any(x in t for x in ["משיק", "אנך"]):
-            rules.append(r"שיפועים אנכיים: $m_1 \\cdot m_2 = -1$")
-        if "מקום גיאומטרי" in t:
-             rules.append(r"פרבולה: מרחק מנקודה שווה למרחק מישר.")
-             rules.append(r"אליפסה: סכום מרחקים מ-2 נקודות קבוע ($d_1+d_2=k$).")
-             rules.append(r"היפרבולה: הפרש מרחקים מ-2 נקודות קבוע ($|d_1-d_2|=k$).")
-        if "מקום גיאומטרי" in t:
-             rules.append(r"⚠️ הנחיה קריטית: אל תנחש את הצורה! פיתוח המשוואה חייב להיעשות צעד-אחר-צעד מההגדרה המילולית.")
-             rules.append(r"דוגמה לשימוש בהגדרה: אם רשום שמרחק נקודה $P(x,y)$ ממיקום א' שווה למרחקה ממיקום ב', רשום משוואה מהצורה $d_1 = d_2$. הצב את נוסחאות המרחק, העלה בריבוע ופשט.")
-             rules.append(r"בביטויים עם שורשים: בודד שורש אחד -> עלה בריבוע -> בודד את השורש השני -> עלה בריבוע שוב.")
-    
-        # === PROOF-specific rules (V282.0) ===
-        if any(x in t for x in ["הוכח", "הוכיח", "הוכיחו", "הראה כי", "הראי כי", "הוכח כי", "הוכיחי"]):
-            rules.append(r"⚠️ זוהי שאלת הוכחה! חובה להראות את כל שרשרת ההיגיון, לא רק את התוצאה.")
-            rules.append(r"מבנה הוכחה: נתון -> מסקנה ביניים (+ נימוק/משפט) -> מסקנה הבאה -> ... -> מ.ש.ל.")
-            rules.append(r"לכל מעבר לוגי חובה לציין את הנימוק: שם המשפט, התכונה, או הכלל.")
-            rules.append(r"משולש שווה שוקיים -> זוויות בסיס שוות, חוצה זווית = תיכון = גובה לבסיס.")
-            rules.append(r"משולשים חופפים: צ.צ.צ / צ.ז.צ / ז.צ.ז - ציין איזה קריטריון נבחר ולמה.")
-            rules.append(r"אם צריך להוכיח שוויון קטעים - חפש משולשים חופפים, או תכונות של צורות מיוחדות.")
-
-        rules.append(r"בגיאומטריה אנליטית: לפני חישוב, בצע 'בדיקת שפיות' (Sanity Check).")
-        rules.append(r"אם נתון ש-AC קוטר, המרכז M *חייב* להיות האמצע שלו. אם החישוב מראה אחרת - הנתונים שהוצאת שגויים! נסה לקרוא שוב.")
-        rules.append(r"עדיפות לנתונים: טקסט כתוב > משוואות > שרטוט ויזואלי.")
-        rules.append(r"הימנע משימוש ב-\\\\ בתוך בלוקים של מתמטיקה, השתמש בצעדים נפרדים.")
-        
-    # V8.6.3: Contextual Logic Guardrails
-    if category == "GEOMETRY":
-        rules.append(r"ZERO ASSUMPTIONS RULE: NEVER assume, guess, or invent ANY geometric property (e.g., 'this segment is a diameter', 'this angle is 90 degrees', 'this triangle is isosceles') unless it is EXPLICITLY WRITTEN in the provided text. You are strictly forbidden from fabricating data or relationships just because the coordinates look convenient. Work ONLY with the exact facts stated in the OCR text and Data Anchor.")
-        rules.append(r"CRITICAL GEOMETRY RULE: You MUST strictly adhere to the geometric layout described in the problem text. If your calculation leads to a paradox (e.g., length 0, points colliding, or negative area), YOUR assumption is wrong. Recalculate based strictly on the given explicit constraints. DO NOT change the given equations.")
-
-    if category in ["CALCULUS", "FUNCTION_ANALYSIS", "INVESTIGATION"]:
-        rules.append(r"GRAPH MATCHING PROTOCOL: When asked to select a correct graph from multiple options (I, II, III, IV), you MUST first perform a visual scan: explicitly describe what you see in EACH given graph (e.g., 'Graph I shows asymptotes at... Graph II shows a hole at...'). Only AFTER describing all options, match your mathematical deductions to the correct visual description and select the final answer.")
-
-    if category == "CALCULUS":
-        if any(x in t for x in ["נגזרת", "גזור", "f'", "חקור"]):
-            rules.append(r"כלל החזקה: $(x^n)' = nx^{n-1}$")
-            if any(x in t for x in ["/", "frac", "מנה", "חילוק"]):
-                rules.append(r"נגזרת מנה: $(\\frac{u}{v})' = \\frac{u'v - uv'}{v^2}$")
-            if any(x in t for x in ["מכפלה", "כפל"]):
-                rules.append(r"נגזרת מכפלה: $(u \\cdot v)' = u'v + uv'$")
-            if any(x in t for x in ["שרשרת", "הרכבה", "sin", "cos"]):
-                rules.append(r"כלל שרשרת: $[f(g(x))]' = f'(g(x)) \\cdot g'(x)$")
-        if any(x in t for x in ["אינטגרל", "שטח מתחת"]):
-            rules.append(r"אינטגרל חזקה: $\\int x^n dx = \\frac{x^{n+1}}{n+1} + C$")
-        if any(x in t for x in ["דיפרנציאלית", "y'", "dy/dx"]):
-            rules.append(r"משוואה דיפרנציאלית: הפרד משתנים, אינטגרל משני הצדדים.")
-
-    # === SEQUENCES rules ===
-    if any(x in t for x in ["סדרה", "חשבונית", "הנדסית", "סכום חלקי", "הפרש"]):
-        rules.append(r"סדרה חשבונית: $a_n = a_1 + (n-1)d$, סכום: $S_n = \\frac{n}{2}(a_1 + a_n)$")
-        rules.append(r"סדרה הנדסית: $a_n = a_1 \\cdot q^{n-1}$, סכום: $S_n = a_1 \\cdot \\frac{q^n - 1}{q - 1}$")
-        if "אינסופי" in t or "גבול" in t:
-            rules.append(r"סכום סדרה הנדסית אינסופית ($|q|<1$): $S = \\frac{a_1}{1-q}$")
-
-    # === COMPLEX NUMBERS rules ===
-    if any(x in t for x in ["מרוכב", "מדומה", "i²", "i^2"]):
-        rules.append(r"$i^2 = -1$, מספר מרוכב: $z = a + bi$")
-        rules.append(r"מודולוס: $|z| = \\sqrt{a^2 + b^2}$, צמוד: $\\bar{z} = a - bi$")
-        if any(x in t for x in ["קוטבי", "דה-מואבר", "טריגונומטרי"]):
-            rules.append(r"צורה טריגונומטרית: $z = r(\\cos\\theta + i\\sin\\theta)$")
-            rules.append(r"דה-מואבר: $z^n = r^n(\\cos(n\\theta) + i\\sin(n\\theta))$")
-
-    # === VECTORS rules ===
-    if any(x in t for x in ["וקטור", "וקטורים"]):
-        rules.append(r"$\\vec{u} = (a,b)$, $|\\vec{u}| = \\sqrt{a^2+b^2}$")
-        rules.append(r"מכפלה סקלרית: $\\vec{u}\\cdot\\vec{v} = a_1 a_2 + b_1 b_2 = |u||v|\\cos\\alpha$")
-        rules.append(r"וקטורים מאונכים: $\\vec{u}\\cdot\\vec{v} = 0$")
-        # V286.0: 3D Vectors (5 יח"ל)
-        if any(x in t for x in ["מרחב", "מישור", "תלת", "z", "פרמטרי", "ניצב למישור"]):
-            rules.append(r"וקטור במרחב: $\vec{u} = (a,b,c)$, $|\vec{u}| = \sqrt{a^2+b^2+c^2}$")
-            rules.append(r"מכפלה סקלרית 3D: $\vec{u}\cdot\vec{v} = a_1 a_2 + b_1 b_2 + c_1 c_2 = |u||v|\cos\alpha$")
-            rules.append(r"מכפלה וקטורית (Cross Product): $\vec{u}\times\vec{v} = (b_1 c_2 - c_1 b_2,\; c_1 a_2 - a_1 c_2,\; a_1 b_2 - b_1 a_2)$. הוקטור שמתקבל ניצב לשני הוקטורים המקוריים.")
-            rules.append(r"מציאת נורמלי למישור: השתמש במכפלה וקטורית של שני וקטורי כיוון הפורשים את המישור.")
-            rules.append(r"משוואת מישור: $Ax + By + Cz + D = 0$. הנורמלי הוא $\vec{n} = (A,B,C)$.")
-            rules.append(r"ישר במרחב (הצגה פרמטרית): $\vec{r} = \vec{p} + t\vec{v}$")
-            rules.append(r"מרחק נקודה $(x_0,y_0,z_0)$ ממישור $Ax+By+Cz+D=0$: $d = \frac{|Ax_0+By_0+Cz_0+D|}{\sqrt{A^2+B^2+C^2}}$")
-            rules.append(r"זווית $\alpha$ בין שני מישורים: $\cos\alpha = \frac{|\vec{n_1}\cdot\vec{n_2}|}{|\vec{n_1}||\vec{n_2}|}$")
-            rules.append(r"זווית $\beta$ בין ישר למישור: $\sin\beta = \frac{|\vec{v}\cdot\vec{n}|}{|\vec{v}||\vec{n}|}$ (כאשר $\vec{n}$ הוא נורמלי למישור).")
-            rules.append(r"מכפלה משולשת (נפח מקבילון): $V = |\vec{a}\cdot(\vec{b}\times\vec{c})|$")
-
-    # === STATISTICS rules ===
-    if any(x in t for x in ["ממוצע", "חציון", "שכיח", "סטיית תקן", "שונות"]):
-        rules.append(r"ממוצע: $\\bar{x} = \\frac{\\sum x_i}{n}$")
-        rules.append(r"שונות: $\\sigma^2 = \\frac{\\sum(x_i - \\bar{x})^2}{n}$, סטיית תקן: $\\sigma = \\sqrt{\\sigma^2}$")
-    if any(x in t for x in ["התפלגות", "נורמלית", "בינומית"]):
-        rules.append(r"התפלגות בינומית: $P(X=k) = \\binom{n}{k}p^k(1-p)^{n-k}$")
-        rules.append(r"התפלגות נורמלית: כלל 68-95-99.7 (אחוזים בטווח 1-2-3 סטיות תקן)")
-
-    # === INDUCTION rules ===
-    if any(x in t for x in ["אינדוקציה", "הוכח כי לכל", "n טבעי"]):
-        rules.append(r"שלב 1 (בסיס): הוכח עבור $n=1$. שלב 2 (הנחה): הנח עבור $n=k$. שלב 3 (צעד): הוכח עבור $n=k+1$.")
-        rules.append(r"⚠️ חובה לרשום בפירוש: 'מה צריך להוכיח', 'הנחת האינדוקציה', 'מ.ש.ל'.")
-
-    # === TRIGONOMETRY LAW rules ===
-    if any(x in t for x in ["סינוסים", "קוסינוסים", "משולש", "זווית"]):
-        if "סינוסים" in t:
-            rules.append(r"משפט הסינוסים: $\\frac{a}{\\sin A} = \\frac{b}{\\sin B} = \\frac{c}{\\sin C}$")
-        if "קוסינוסים" in t:
-            rules.append(r"משפט הקוסינוסים: $c^2 = a^2 + b^2 - 2ab\\cos C$")
-        rules.append(r"שטח משולש לפי שתי צלעות וזווית: $S = \\frac{1}{2}ab\\sin C$")
-    if any(x in t for x in ["זהות", "טריגונומטרית"]):
-        rules.append(r"$\\sin^2(x) + \\cos^2(x) = 1$")
-        rules.append(r"$\\sin(2x) = 2\\sin(x)\\cos(x)$, $\\cos(2x) = \\cos^2(x) - \\sin^2(x)$")
-    # V286.0: Advanced Trigonometry (5 יח"ל)
-    if any(x in t for x in ["sin", "cos", "tan", "trig", "טריגונומטר", "sin(", "cos("]):
-        if any(x in t for x in ["סכום", "הפרש", "α+β", "α-β", "alpha"]):
-            rules.append(r"$\\sin(\\alpha \\pm \\beta) = \\sin\\alpha\\cos\\beta \\pm \\cos\\alpha\\sin\\beta$")
-            rules.append(r"$\\cos(\\alpha \\pm \\beta) = \\cos\\alpha\\cos\\beta \\mp \\sin\\alpha\\sin\\beta$")
-            rules.append(r"$\\tan(\\alpha + \\beta) = \\frac{\\tan\\alpha + \\tan\\beta}{1 - \\tan\\alpha\\tan\\beta}$")
-        if any(x in t for x in ["חצי זווית", "sin²", "cos²"]):
-            rules.append(r"$\\sin^2\\frac{x}{2} = \\frac{1-\\cos x}{2}$, $\\cos^2\\frac{x}{2} = \\frac{1+\\cos x}{2}$")
-    if any(x in t for x in ["פתור משוואה טריגונומטרית", "sinx=", "cosx=", "sin x =", "cos x ="]):
-        rules.append(r"$\\sin x = a \\Rightarrow x = (-1)^n \\arcsin a + \\pi n$, $n \\in \\mathbb{Z}$")
-        rules.append(r"$\\cos x = a \\Rightarrow x = \\pm \\arccos a + 2\\pi n$, $n \\in \\mathbb{Z}$")
-        rules.append(r"$\\tan x = a \\Rightarrow x = \\arctan a + \\pi n$, $n \\in \\mathbb{Z}$")
-
-    # === VOLUME & SURFACE AREA rules ===
-    if any(x in t for x in ["נפח", "שטח פנים", "גליל", "חרוט", "כדור"]):
-        rules.append(r"נפח גליל: $V = \\pi r^2 h$, נפח חרוט: $V = \\frac{1}{3}\\pi r^2 h$")
-        rules.append(r"נפח כדור: $V = \\frac{4}{3}\\pi r^3$, שטח פנים כדור: $S = 4\\pi r^2$")
-
-    # V286.0: Solid Geometry (גיאומטריה מרחבית — 5 יח"ל)
-    if any(x in t for x in ["פירמידה", "מנסרה", "תיבה", "חתך", "אפותם", "מקצוע צדדי", "פאות"]):
-        rules.append(r"נפח פירמידה: $V = \frac{1}{3} S_{base} \cdot h$")
-        rules.append(r"נפח מנסרה: $V = S_{base} \cdot h$")
-        rules.append(r"שטח פנים של פירמידה: $S = S_{base} + \sum S_{faces}$")
-        rules.append(r"זווית $\alpha$ בין מקצוע צדדי לבסיס: זווית במשולש ישר-זווית הנוצר ע\"י המקצוע, הטלו על הבסיס והגובה.")
-        rules.append(r"זווית $\beta$ בין פאה צדדית לבסיס: זווית במשולש ישר-זווית הנוצר ע\"י האפותם של הפאה, הטלו על הבסיס והגובה.")
-        rules.append(r"חישובים מרחביים: השתמש תמיד במשפט פיתגורס וטריגונומטריה בתוך משולשים ישרי-זווית המקשרים פנים וחוץ.")
-
-    # === INEQUALITY rules ===
-    if any(x in t for x in ["אי-שוויון", "אי שוויון"]):
-        rules.append(r"⚠️ בכפל/חילוק באי-שוויון במספר שלילי — הפוך את כיוון הסימן!")
-        if "ריבועי" in t:
-            rules.append(r"אי-שוויון ריבועי: פתור כמשוואה, בדוק סימן בקטעים.")
-
-    # V286.0: Logarithms & Exponentials (לוגריתמים — 5 יח"ל)
-    if any(x in t for x in ["לוגריתם", "log", "ln", "מעריכי", "e^"]):
-        rules.append(r"$\\log_a(xy) = \\log_a x + \\log_a y$")
-        rules.append(r"$\\log_a\\left(\\frac{x}{y}\\right) = \\log_a x - \\log_a y$")
-        rules.append(r"$\\log_a(x^n) = n\\log_a x$")
-        rules.append(r"החלפת בסיס: $\\log_a b = \\frac{\\ln b}{\\ln a}$")
-        rules.append(r"$a^x = e^{x\\ln a}$, $\\log_a a = 1$, $\\log_a 1 = 0$")
-        rules.append(r"$\\ln e = 1$, $e^{\\ln x} = x$, $\\ln(e^x) = x$")
-
-    # V286.0: Optimization Problems (בעיות קיצון — 5 יח"ל)
-    if any(x in t for x in ["קיצון", "מקסימום", "מינימום", "שטח גדול ביותר", "נפח מקס", "ערך מרבי", "ערך מזערי", "אופטימיזציה"]):
-        rules.append(r"אסטרטגיה לבעיות אופטימיזציה (5 יח\"ל):")
-        rules.append(r"1) הגדר משתנה (x) ובטא את כל הגדלים האחרים בעזרתו.")
-        rules.append(r"2) בנה פונקציית מטרה $f(x)$ עבור הגודל שצריך למקסם/למזער.")
-        rules.append(r"3) השתמש באילוצים כדי להגיע לפונקציה של משתנה אחד בלבד.")
-        rules.append(r"4) גזור את פונקציית המטרה, השווה ל-0 ומצא את הנקודות החשודות.")
-        rules.append(r"5) הוכח את סוג הקיצון (Max/Min) בעזרת טבלה או נגזרת שנייה.")
-        rules.append(r"6) בדוק תמיד נקודות קצה של התחום אם הבעיה מוגדרת בקטע סגור.")
-
-    # V286.0: Probability & Combinatorics (הסתברות וקומבינטוריקה — 5 יח"ל)
-    if any(x in t for x in ["הסתברות", "קומבינטור", "עצי", "עץ", "תמורה", "צירוף", "בייס", "מותנה", "בלתי תלוי"]):
-        rules.append(r"$P(A \\cup B) = P(A) + P(B) - P(A \\cap B)$")
-        rules.append(r"הסתברות מותנית: $P(A|B) = \\frac{P(A \\cap B)}{P(B)}$")
-        rules.append(r"נוסחת בייס: $P(B_i|A) = \\frac{P(A|B_i)P(B_i)}{\\sum_j P(A|B_j)P(B_j)}$")
-        rules.append(r"חוק ההסתברות השלמה: $P(A) = \\sum_i P(A|B_i)P(B_i)$")
-        rules.append(r"תמורות: $P(n,k) = \\frac{n!}{(n-k)!}$, צירופים: $\\binom{n}{k} = \\frac{n!}{k!(n-k)!}$")
-        rules.append(r"אירועים בלתי תלויים: $P(A \\cap B) = P(A) \\cdot P(B)$")
-
-    # V286.0: Advanced Calculus (חדו"א מתקדם — 5 יח"ל)
-    if any(x in t for x in ["אינטגרל", "שטח מתחת", "נפח סיבוב", "אינטגרציה"]):
-        if any(x in t for x in ["חלקי", "חלקים", "by parts"]):
-            rules.append(r"אינטגרציה בחלקים: $\\int u\\,dv = uv - \\int v\\,du$")
-        if any(x in t for x in ["הצבה", "substitution"]):
-            rules.append(r"אינטגרציה בהצבה: $\\int f(g(x))g'(x)dx = \\int f(u)du$ כאשר $u=g(x)$")
-        rules.append(r"שטח בין שני גרפים: $S = \\int_a^b |f(x) - g(x)|\\,dx$")
-        if any(x in t for x in ["סיבוב", "גוף סיבוב"]):
-            rules.append(r"נפח גוף סיבוב סביב ציר $x$: $V = \\pi\\int_a^b [f(x)]^2\\,dx$")
-        if any(x in t for x in ["לא אמיתי", "מוכלל", "improper"]):
-            rules.append(r"אינטגרל מוכלל: $\\int_a^{\\infty} f(x)dx = \\lim_{b\\to\\infty} \\int_a^b f(x)dx$")
-
-    # V286.0: Limits (גבולות — 5 יח"ל)
-    if any(x in t for x in ["גבול", "lim", "שואף", "אינסוף", "לופיטל"]):
-        rules.append(r"גבולות נחשבים: $\\lim_{x\\to 0}\\frac{\\sin x}{x} = 1$")
-        rules.append(r"$\\lim_{x\\to\\infty}\\left(1+\\frac{1}{x}\\right)^x = e$")
-        rules.append(r"כלל לופיטל: אם $\\frac{0}{0}$ או $\\frac{\\infty}{\\infty}$, אז $\\lim\\frac{f(x)}{g(x)} = \\lim\\frac{f'(x)}{g'(x)}$")
-        rules.append(r"אסטרטגיה ל-$\\frac{0}{0}$: פרק לגורמים, רציונליזציה, או לופיטל.")
-        rules.append(r"אסטרטגיה ל-$\\frac{\\infty}{\\infty}$ עם פולינומים: חלק במעלה הגבוהה ביותר.")
-    
-    return rules
-
-def get_data_extraction_prompt(problem_text: str) -> str:
-    """V231.15: Template-based extraction to avoid f-string escape hell."""
-    template = r"""
-### [SACRED TRUTH: IMAGE OVER OCR]
-You are provided with an IMAGE and its rough OCR transcription.
-⚠️ CRITICAL WARNING: The OCR text is a WEAK HINT and is often WRONG, truncated, or mangled.
-💎 SACRED TRUTH: The IMAGE is the absolute source of truth.
-
-YOUR TASK:
-1. PERCEPTUAL PRIORITY: Visually inspect the IMAGE meticulously. Every pixel of the formula counts.
-2. TOP-DOWN HIERARCHY: Start from the very top of the image. The main function (e.g., f(x)=...) is usually the first mathematical line. DO NOT MISS IT.
-3. OCR SKEPTICISM: The OCR text is often a "hallucination hint" for formulas. If the OCR text says h(x) but the IMAGE shows f(x) at the top, the IMAGE'S f(x) is the SACRED TRUTH.
-4. LTR MATHEMATICAL FLOW: Equations are NOT Hebrew. They are read horizontally LEFT-TO-RIGHT. Ensure multipliers, exponents, and fractions are extracted in their visual LTR order.
-5. NO INVENTIONS: Do not "fix" the math. If it looks incomplete, extract what is there.
-
-Extract:
-1. **function_equations**: ALL equations with '=' sign
-   - ⚠️ **ABSOLUTE PRIORITY**: Extract the primary function (f(x), y=...) first.
-   - Functions: f(x) = ..., g(x) = ...
-   - Circles: x² + y² = r², (x-a)² + (y-b)² = r²
-   - Lines: y = mx + b, ax + by = c
-   - ANY equation with '=' sign!
-
-**Mathematical Scanning Directionality (V8.9.3):**
-- **LTR PRIORITY:** Mathematical equations are STRICTLY Left-To-Right. 
-- When extracting formulas embedded in Hebrew text, IGNORE the RTL flow. 
-- Read the characters in their literal horizontal visual order from LEFT to RIGHT. 
-- Ensure multipliers, exponents, and signs are placed exactly where they appear visually.
-
-**Visual Context & Continuity (V8.9.5):**
-- **SPLIT EQUATIONS:** If an equation starts on one line and ends on another, merge them into a single coherent formula.
-- **SEGMENTED CONSTRAINTS:** Look for constraints (like x > 0) near equations; they are often visually separated by space or Hebrew words but belong to the formula.
-- **MULTI-PART ANCHORING:** Maintain consistency between sub-questions (א, ב, ג). If a variable 'm' is defined in the preamble, it applies to all sub-questions.
-
-2. **points**: Named points like A, B, M(3,5), P(x,y)
-
-3. **specific_values**: Numbers like r=5, a=3, m=2
-
-4. **constraints**: Conditions like x>0, x≠2, domain restrictions
-
-5. **sub_questions**: Parts א, ב, ג or a, b, c
-
-6. **geometric_anchors** (CRITICAL FOR VALIDATION):
-   - center: [x,y] coordinates if a circle center is given
-   - radius: numeric value if radius is given
-   - point_a, point_b: Strings like "(x,y)" if specific points are given for distance/lines
-
-JSON format (STRUCTURE ONLY - DO NOT USE THESE EXACT VALUES):
-{{
-  "function_equations": ["<equation_1>", "<equation_2>"],
-  "points": ["<point_name>", "<point_name>(<x>,<y>)"],
-  "specific_values": ["<variable>=<value>"],
-  "constraints": ["<constraint_1>"],
-  "sub_questions": ["<sub_question_1>"],
-  "center": [null, null],
-  "radius": null,
-  "point_a": "(null, null)",
-  "point_b": "(null, null)"
-}}
-
-
-**CRITICAL JSON STRUCTURE RULE (V8.9.4):**
-- You MUST output a SINGLE, flat JSON object.
-- EVERY mathematical expression, function, or parameter MUST have a UNIQUE, highly descriptive key.
-- DO NOT use a generic key like "equation" multiple times, as this will overwrite the data.
-- DO NOT output an array/list of objects.
-- **Correct Example:** { "main_function_f": "f(x)=...", "function_h": "h(x)=...", "given_extremum_x": "x=1/e" }
-- **Wrong Example:** { "equation": "f(x)=...", "equation": "h(x)=..." }
-
-CRITICAL INSTRUCTIONS:
-1. Include ALL equations with '=' sign in function_equations!
-2. **DATA INTEGRITY (V4.3.0):** Use the data below verbatim.
-3. **VARIABLE ENFORCEMENT (V4.0.1):** ALL equations must use standard single-letter mathematical variables (x, y, z, a, b, c, m, n, k). 
-   - DO NOT extract descriptive English names like "number_of_notebooks". 
-   - Map descriptive names from text to single letters (e.g., if text says "cost is x", use x. If it says "cost of notebook", map to 'c' or 'x'). 
-   - Equations with descriptive multi-letter variables will crash the calculator.
-4. DO NOT HALLUCINATE OR GUESS! 🚫 If an equation or point is NOT explicitly written in the problem, DO NOT invent it.
-5. **Mathematical Logic over OCR (V8.6.6):** In case of OCR contradictions (e.g. $e^x$ vs $e^{{-x}}$ in the same problem), use mathematical logic to choose the correct formula based on the problem's context (e.g., if a question asks for a limit at $\infty$ that only exists for $e^{{-x}}$, prefer that).
-6. Example: Do not assume `f(x) = ax - x^2` just because it looks like a standard problem. Only extract what is literally there.
-7. **SUB-QUESTION MAPPING (CRITICAL - V231.14):** You MUST map ALL sub-questions present in the OCR text (e.g., א, ב, ג, ד). Do NOT group them into one question and do NOT stop at the first one. Each sub-question letter requires its own entry in the `sub_questions` array.
-8. **DATA SCOPING (V8.6.9 - CRITICAL):** Only extract data that is truly GLOBAL (applies to all sections). If a value or constraint is explicitly tied to a specific section (e.g., "בסעיף ב' נתון כי a=1"), do NOT put it in the `specific_values` of the main anchor. The problem understanding phase will handle the local data.
-9. **CHRONOLOGICAL ISOLATION (V310.0):** If a variable is assigned a value in one sub-question, it MUST NOT be used in previous sub-questions.
-r"""
-
-def get_specialist_prompt(category, problem_text, solver_hint, grade, student_name, student_gender="M", data_anchor=None):
-    """בניית הפרומפט המלכותי — המורה למתמטיקה V231.6 (Data Anchor)"""
-    features = _get_grade_features(grade, category)
-    relevant_rules = _detect_relevant_rules(problem_text, category)
-    rules_str = "\n".join([f"    - {r}" for r in relevant_rules]) if relevant_rules else f"    (לא זוהו כללים ספציפיים — בחר רק כללים רלוונטיים לקטגוריה {category})"
-    
-    # Anchor Block — DATA INTEGRITY RULE
-    anchor_block = ""
-    geo_verified_block = ""  # V1.0: Geometric Sanity Engine output
-    if data_anchor:
-        # Extract and remove internal sanity keys before JSON serialization
-        geo_prompt_block = data_anchor.pop("_geo_prompt_block", "")
-        data_anchor.pop("_verified_facts", None)
-        data_anchor.pop("_geometry_warnings", None)
-
-        anchor_block = f"""
-    ══════════════════════════════════════════════════════
-    📜 DATA INTEGRITY RULE (ABSOLUTE TRUTH):
-    ══════════════════════════════════════════════════════
-    The data below is the ABSOLUTE TRUTH extracted from the student's image.
-    If it contains function_equations or equations — those ARE the problem's data.
-    YOU MUST use them EXACTLY AS GIVEN. Never claim data is "missing" if it is in the data.
-    Never assume, invent, or substitute a different function under ANY circumstances.
-    Violating this rule is a critical pedagogical failure.
-    ══════════════════════════════════════════════════════
-    נתוני שאלת המקור (השתמש רק בהם):
-    {json.dumps(data_anchor, indent=2, ensure_ascii=False)}
-
-    CONSTRAINT: If the data says A(0,5), use A(0,5). If it contains f(x), solve that f(x).
-    """
-        # V1.0: Inject verified geometric facts (if the sanity engine found anything)
-        if geo_prompt_block:
-            geo_verified_block = geo_prompt_block
-
-    # V231.5: Gender-aware phrases
-    if student_gender == "F":
-        g = {
-            "royal": "נסיכה",
-            "come": "בואי",
-            "ready": "מוכנה",
-            "great": "מעולה",
-            "solved": "פתרת",
-            "proud": "גאה בך",
-            "try_again": "בואי ננסה שוב יחד",
-            "example_open": f"כל הכבוד {student_name} נסיכה! 👑",
-            "example_close": f"כל הכבוד {student_name}! 👑 {{'פתרת' if student_gender == 'F' else 'פתרת'}} מעולה. אני גאה בך!"
-        }
-    else:
-        g = {
-            "royal": "נסיך",
-            "come": "בוא",
-            "ready": "מוכן",
-            "great": "מעולה",
-            "solved": "פתרת",
-            "proud": "גאה בך",
-            "try_again": "בוא ננסה שוב יחד",
-            "example_open": f"כל הכבוד {student_name} נסיך! 👑",
-            "example_close": f"כל הכבוד {student_name}! 👑 פתרת מעולה. אני גאה בך!"
-        }
-    # V282.0: Proof-specific instructions (outside f-string to avoid backslash issues in Python 3.11)
-    proof_keywords = ["הוכח", "הוכיח", "הוכיחו", "הראה כי", "הראי כי"]
-    is_proof = any(x in problem_text for x in proof_keywords)
-    proof_block = ""
-    if is_proof:
-        proof_block = """
-    ═══════════════════════════════════════════════════
-    📐 הוראות מיוחדות להוכחות (V282.0):
-    ═══════════════════════════════════════════════════
-    
-    🔴 זוהי שאלת הוכחה! החוקים הבאים הם חובה:
-    1. **אסור לקפוץ לתשובה.** ההוכחה היא הדרך, לא התוצאה. התלמיד צריך לראות כל צעד.
-    2. **מבנה חובה לכל צעד:** "נתון ש-[X]. לפי [שם המשפט/תכונה], מתקיים [Y]."
-    3. **נימוק לכל מעבר:** לכל שוויון/אי-שוויון, ציין למה הוא נכון.
-    4. **שרשרת לוגית:** כל צעד חייב להסתמך על צעד קודם או על נתון.
-    5. **ציין שיטת הוכחה:** חפוש משולשים חופפים? תכונות של שווה שוקיים? זוויות מתחלפות?
-    6. **סיום:** בסוף חובה לכתוב "ולכן הוכחנו ש-[מה שנדרש]. מ.ש.ל."
-    7. **דוגמה למבנה טוב:**
-       - "נתון שהמשולש ABC שווה שוקיים (AB = AC). לפי תכונה: זוויות בסיס שוות."
-       - "חישבנו שזווית CDF שווה לזווית DCF. לפי משפט: במשולש ששתי זוויות בו שוות, הצלעות מולן שוות, DC = CF."
-    8. **אסור:** לכתוב "DC = CF" בלי להסביר למה. חובה לבנות את כל שרשרת ההוכחה.
-    """
-    # V285.1: Investigation Table (Table UI)
-    investigation_keywords = ["חקור", "חקירת", "קיצון", "אסימפטוט", "עליה", "ירידה"]
-    is_investigation = "INVESTIGATION" in category or any(x in problem_text for x in investigation_keywords)
-    investigation_block = ""
-    if is_investigation:
-        investigation_block = """
-    ═══════════════════════════════════════════════════
-    📈 הוראות מיוחדות לחקירת פונקציה (Table UI):
-    ═══════════════════════════════════════════════════
-    
-    בנוסף לשדות הרגילים ב-JSON, באחריותך להוסיף בשורש ה-JSON את השדה "investigation" המילוני הזה:
-    "investigation": {
-      "function": "הפונקציה ב-LaTeX",
-      "derivative": "הנגזרת ב-LaTeX",
-      "second_derivative": "נגזרת שנייה ב-LaTeX (השאר ריק אם אין צורך)",
-      "domain": "תחום הגדרה עטוף ב-LaTeX",
-      "critical_points": [
-        {"x": "ערך x", "y": "ערך y", "f_prime": "0", "behavior": "מקסימום/מינימום"}
-      ],
-      "increasing": ["(a, b)", "(1, \\infty)"],
-      "decreasing": ["(-\\infty, a)"],
-      "concave_up": ["(a, b)"],
-      "concave_down": ["(b, c)"]
-    }
-    """
-    prompt = f"""
-    DEPTH: {features['depth']}
-    STYLE: {features['style']} (בנימה של '{g['royal']}').
-    TONE: {features['tone']}
-    
-    {anchor_block}
-    {geo_verified_block}
-
-    🎯 המשימה: פתור את התרגיל בצורה פדגוגית, מעצימה ובשלבים ברורים.
-    
-    📜 כללי הפדגוגיה של BuddyMath (חובה!):
-{rules_str}
-
-    {proof_block}
-    {investigation_block}
-
-    ═══════════════════════════════════════════════════
-    הנחיות לפתרון (Solver Hint):
-    {solver_hint}
-    ═══════════════════════════════════════════════════
-
-    השאלה לפתרון:
-    {problem_text}
-
-    דגימת סגנון פנייה:
-    - פתיחה: "{g['example_open']}"
-    - סיום: "{g['example_close']}"
-    """
-    return prompt
-
-
-# prompts.py - V275.1 (Safe OCR - Technique over Examples)
-def get_transcription_prompt():
-    """
-    V275.1: Safe OCR Prompt - Teaches TECHNIQUE, not specific examples.
-    
-    Why V275.1?
-    - V275.0 had specific examples like "\\frac{1}{x}(a + \\frac{(\\ln x)^n}{n})"
-    - This caused the LLM to "fit" different functions to the example
-    - Now we teach HOW to recognize patterns, not WHAT pattern to expect
-    """
-    return """
-    TRANSCRIBE the FULL text from the image. Include ALL Hebrew text and ALL mathematical expressions.
-    
-    🎯 **YOUR ONLY JOB: Copy EXACTLY what you see. Do NOT interpret, simplify, or guess.**
-    
-    📐 **TRANSCRIPTION TECHNIQUE (How to be accurate):**
-    
-    1. **ZERO TRUNCATION RULE (CRITICAL - V310.0)**
-       - **NEVER skip the beginning of an equation.** If a formula starts with `f(x) =`, `1/x`, or a constant, you MUST include it.
-       - Look at the very left edge of the image/expression. Truncating the starting terms is a FATAL ERROR.
-       - **FULL CAPTURE:** Transcribe from the first character to the last. No summaries.
-    
-    2. **VISUAL DISAMBIGUATION (V310.0 - NEW)**
-       - **1 vs a:** Double-check characters that look like a straight line or small loop. In fractions like `1/x` or `a/x`, verify via context.
-       - **2 vs z:** Look for the horizontal base of the `2` vs the sharp angles of the `z`.
-       - **0 vs o / O:** Check if it's a number (zero) or a letter (o).
-       - **5 vs s / S:** Distinguish the top bar of the `5` from the curves of the `s`.
-       - **MATH CONTEXT:** Parameter letters like `a, b, c` are usually distinct from constants like `1, 2, 3`. If a formula has both, look for subtle stylistic differences.
-    
-    3. **FRACTION & NESTING RIGOR**
-       - **WORK OUTSIDE-IN:** Identify the outermost structure (e.g., a large fraction) before transcribing the contents.
-       - **Numerator/Denominator:** Transcribe EVERYTHING above and below the line. Use `\\frac{num}{den}`.
-       - **Parentheses:** Use `\\left(` and `\\right)` for nested or large expressions.
-    
-    4. **SCAN THE EDGES**
-       - Check if the expression starts or ends very close to the Bounding Box edge. Truncation usually happens at the very start.
-    
-    ✅ **OUTPUT:** The EXACT text from the image, with proper LaTeX for math.
-    """
-
-# ==================== V260.0 PEDAGOGICAL PROMPTS ====================
-
-def get_strategy_card_prompt(problem_text: str, data_anchor: dict) -> str:
-    """V260.1: Generate high-level strategy as HINTS to encourage self-solving."""
-    return f"""
-    ROLE: Elite Math Tutor (Pedagogical Architect).
-    TASK: Analyze this problem and provide a high-level STRATEGY guide filled with HINTS.
-    
-    PROBLEM:
-    {problem_text}
-    
-    DATA (Context):
-    {json.dumps(data_anchor, ensure_ascii=False)}
-    
-    INSTRUCTIONS:
-    1. Explain the LOGIC of how to approach this problem, but frame it as hints. 
-    2. === STRATEGY CARD PEDAGOGY RULE ===
-       CRITICAL: DO NOT solve the problem here. DO NOT use actual equations or numbers.
-       Speak conceptually. Give the student the "blueprint" so they can try it themselves.
-       End the `content` section with an encouraging call to action to try it alone first! (e.g., "קחו דף ועט, נסו לפתור לבד לפי הרמזים, ואם נתקעתם - הפתרון המלא מחכה לכם למטה!").
-    3. Provide 3-4 bullet points acting as stepping stones/hints.
-    4. CRITICAL: Output MUST be in HEBREW (עברית).
-    5. Tone: Encouraging, challenging, empowering.
-    
-    OUTPUT JSON:
-    {{
-        "title": "איך ניגשים לשאלה הזו? 💡",
-        "content": "הסבר מילולי קצר המעודד עבודה עצמאית...",
-        "steps": [
-             "רמז 1: מכיוון שנתונה נקודת קיצון, נסו לחשוב מה זה אומר על הנגזרת...",
-             "רמז 2: חיתוך עם הצירים דורש מכם..."
-        ]
-    }}
-    """
-
-def get_visual_context_prompt(problem_text: str, category: str) -> str:
-    """V260.0: Generate visual description for the sketch card."""
-    return f"""
-    ROLE: Visual describer for blind students / schematic generator.
-    TASK: Describe the VISUAL SETUP of this math problem.
-    
-    PROBLEM:
-    {problem_text}
-    
-    CATEGORY: {category}
-    
-    INSTRUCTIONS:
-    1. If GEOMETRY: Describe the shapes, how they connect, what is tangent to what.
-       - **CRITICAL**: Populate "geometric_entities" with PRECISE COORDINATES for plotting.
-       - If no coordinates are given, ESTIMATE logical coordinates (e.g., A(0,0), B(3,0) for a base).
-    2. If FUNCTION: Describe the graph shape (parabola opening up/down), intersection points, asymptotes.
-       - **CRITICAL GRAPH DESCRIPTION (V300.5):** כאשר יש גרפים משורטטים בתמונה (כמו פונקציה ונגזרת), עליך לפרט ב-description את התכונות הקריטיות של כל גרף בנפרד (גרף I, גרף II וכו'). חובה לציין: האם הגרף חותך את ראשית הצירים (0,0)? האם הוא מתחיל בערך חיובי/שלילי על ציר ה-y? כמה נקודות חיתוך יש לו בערך עם ציר ה-x? האם יש לו נקודות קיצון בולטות? מידע זה קריטי כדי שהמודל הבא יוכל להתאים נכונה את המשוואות לגרפים.
-       - **MULTIPLE CHOICE GRAPHS (V310.0):** בשאלות של "התאם בין גרף לפונקציה", חובה לתת תיאור מתמטי קצר (אסימפטוטות, חיתוך עם צירים) לכל אחד מהגרפים הממוספרים בתמונה בנפרד.
-    3. Goal: Help a student "see" the problem before solving.
-    4. Keep it simple and descriptive.
-    5. CRITICAL: Output MUST be in HEBREW (עברית). Explain the visuals in Hebrew.
-    
-    OUTPUT JSON (STRUCTURE ONLY - USE ACTUAL PROBLEM DATA):
-    {{
-        "title": "המחשה חזותית ✏️",
-        "description": "הסבר מילולי קצר...",
-        "geometric_entities": {{
-            "points": [{{"label": "<point_name>", "x": 0.0, "y": 0.0}}],
-            "segments": [{{"start": "<point_name>", "end": "<point_name>", "color": "blue"}}],
-            "circles": [{{"center_x": 0.0, "center_y": 0.0, "radius": 0.0}}]
-        }},
-        "latex_input": "ONLY the raw mathematical expression. NO 'f(x)=' prefixes. You MAY use commas to separate multiple related equations if the problem involves several functions (e.g. \\\\ln(x), \\\\frac{{1}}{{x}}). Just the single expression or comma-separated expressions. If no graph is needed, leave empty string."
-    }}
-    
-    🚨 GRAPH PERSISTENCE RULES (V300.3 — CRITICAL):
-    - 'latex_input' is MANDATORY. You MUST provide it. NEVER leave it as null or empty string "".
-    - NEVER say "I cannot draw" or "no graph possible". Always provide your best equation.
-    - For GEOMETRY: use the main circle/line equation (e.g. "(x-3)^2 + (y-5)^2 = 39").
-    - For FUNCTION: use the function equation (e.g. "\\frac{{\\ln(x)}}{{x^2-4}}").
-    - For LOCUS: write the final locus equation.
-    - If you are TRULY unsure: use "x" as a placeholder — the server will handle it.
-    - The latex_input must use valid LaTeX WITHOUT $$ wrappers (e.g. "x^2 + y^2 = 25" not "$$x^2+y^2=25$$").
-    
-    🚨 HELPER SKETCH RULE (V300.3 — NEW):
-    If no image is provided (blind setup):
-    - Read the verbal description of the geometry/trigonometry problem carefully.
-    - Extract coordinates, lines, or functions from the text to generate an illustration sketch.
-    - Your goal is to CREATE the visual intuition that the student is missing.
-    - Even without an image, you MUST populate "geometric_entities" and "latex_input".
-    """
-
-
-# ==================== V8.6.8 MASTER PROMPT (THE ANCHOR STABILITY FIX) ====================
-
-def get_master_prompt_v860(category: str = "", problem_text: str = ""):
-    """
-    V8.6.9: The Anchor Stability Fix + Dynamic JSON for Graphs.
-    """
-    graph_field = ""
-    is_graph = category == "GRAPH_IDENTIFICATION" or ("גרף" in problem_text and "איזה" in problem_text)
-    if is_graph:
-        graph_field = """
-      "graph_analysis": {
-        "function_analysis": "תיאור מתמטי מפורט של הפונקציה (נקודות חיתוך, קיצון, אסימפטוטות)",
-        "graph_options": [{"id": "I", "description": "..."}, {"id": "II", "description": "..."}],
-        "matching_logic": "הסבר המקשר בין תכונות הפונקציה למאפייני הגרף הנבחר",
-        "final_match": "התשובה הסופית (למשל: גרף II)"
-      },"""
-
-    prompt_template = r"""
-    🔴 MASTER PROMPT BLOCK — VERSION V8.6.8 (THE ANCHOR STABILITY)
-    
-    CRITICAL: You MUST output ONLY valid JSON. Absolutely NO conversational text before or after the JSON block. 
-    Do NOT wrap the JSON in markdown code blocks like ```json.
-    
-    ROLE:
-    אתה מורה פרטי למתמטיקה (הטוב ביותר בארץ!). המטרה שלך היא להסביר לתלמיד לא רק *איך* פותרים, אלא *למה* עושים כל צעד. רמת ההסבר צריכה להיות כזו שגם תתלמיד שרואה את החומר פעם ראשונה יבין 100% מהדרך. הגישה שלך היא חמה, מעודדת ומעצימה (סגנון 'הנסיך/הנסיכה').
-
-    ═══════════════════════════════════════════
-    ABSOLUTE RULES (violations cause immediate rejection):
-    ═══════════════════════════════════════════
-    1. **DATA ANCHOR SUPREMACY (V8.9.2):** The equations in the JSON Data Anchor are the ABSOLUTE TRUTH. You MUST solve the exact math provided in the Anchor. Do NOT attempt to re-read the image for the main function; trust the pre-validated Data Anchor.
-    2. **ZERO MAGIC MATH (BABY STEPS):** 
-       - NEVER skip algebraic steps. Show moving sides, dividing, and expanding brackets.
-       - ALWAYS explain the mathematical rule/theorem *BEFORE* applying it. 
-         * Bad: "נגזור ונשווה לאפס: f'(x) = 2x"
-         * Good: "כדי למצוא נקודת קיצון נגזור את הפונקציה. מכיוון שזו מנה, נשתמש בכלל המנה האומר ש... נגזור את המונה בנפרד ואת המכנה בנפרד:"
-    3. **COMPLETE THE MISSION (ANTI-TRUNCATION):** Never abandon the task. You MUST reach the final numeric/algebraic answer. If asked for extrema, you must find x, y, and classify (max/min). 
-    4. **ANTI-ASCII-ART RULE (V8.8.8):** NEVER attempt to draw or sketch a graph using text characters, keyboard symbols, slashes, or ASCII art (e.g., do not use |, /, \\, -, _ to make a picture). If asked to sketch a graph, ONLY describe its mathematical properties in text (e.g., intersections, asymptotes).
-    5. **CONTENT TYPE SEPARATION (IRON LAW - V9.1.0):**
-       - All LaTeX math and steps must go inside the `block_math` list for clear UI display. 
-       - `block_math` MUST contain ONLY PURE MATH. Absolutely NO HEBREW LETTERS, no words, no explanations. 
-       - Do NOT put coordinate lists or points like `A(0,1), B(2,3)` in `block_math`. Points and their names MUST stay in `content_mixed`.
-       - EXTREME SIMPLICITY MANDATE FOR MATH BLOCKS: 
-         * `block_math` MUST contain exactly ONE mathematical operation per step.
-         * NEVER use commas (,) to separate multiple equations. 
-         * NEVER chain equations (e.g., NO `x = 2 + 2 = 4`). Break EVERY '=' into a new JSON step.
-         * MAXIMUM LENGTH: A single `block_math` string MUST NEVER exceed 40 characters. If a calculation is longer (like a complex fraction), you MUST break it down into intermediate variables across multiple steps.
-       - Descriptions and casual variables must stay in `content_mixed`.
-       - NEVER write Hebrew inside `block_math` or `final_answer`. (CRITICAL: violates the algebraic validator contract).
-    6. **ANTI-TABLE RULE & EXTREMA ANALYSIS:** 
-       - NEVER use Markdown tables (e.g., using | and -).
-       - When finding Extrema (Max/Min), DO NOT suggest using a table. Instead, use explicit text steps to test the intervals. 
-       - Example: "נבדוק את תחומי העלייה והירידה: עבור $x=\pi/4$ הנגזרת חיובית, ועבור $x=3\pi/4$ היא שלילית. לכן זו נקודת מקסימום". 
-       - You MUST complete the calculation, find the Y values ($y=f(x)$), and explicitly state the classification (Max or Min).
-    7. **STRICT JSON ONLY:** No preamble, no post-amble, no markdown.
-    7. **ANTI-PARADOX PROTOCOL (V8.6.9):**
-       - If your mathematical calculation seems to lead to a paradox (e.g., length is 0, or points C and D are the exact same), DO NOT STOP THE SOLUTION.
-       - 99% of the time, this is a calculation error on your end. RECALCULATE your steps using a different geometric or algebraic approach.
-       - NEVER give up. NEVER output "אני מזהה סתירה בנתונים". You MUST find a valid path and provide the final answer for the student.
-    8. **LATEX SYNTAX RULE (V8.6.9 — CRITICAL):**
-       - You MUST strictly use LaTeX macros for all mathematical functions. 
-       - You MUST write \ln (with a backslash) and NEVER just ln. 
-       - You MUST write \sin, \cos, \tan, \log. 
-       - Failure to use the backslash will crash the KaTeX renderer and Fail validation.
-    9. **ANTI-NEWLINE & BIDI SAFETY:**
-       - In the `final_answer` field, NEVER use `\\` or `\newline` for line breaks. 
-       - The `final_answer` field MUST BE 100% PURE MATH. Absolutely NO Hebrew letters, words, or explanations. If the answer requires a textual explanation, put the text in `content_mixed` of the final step, and leave `final_answer` with just the numbers/math, or empty.
-       - If there are multiple answers, separate them ONLY with English commas (e.g., "x=1, x=2").
-    10. **VARIABLE CONSISTENCY (V8.6.8):** 
-       - Always use standard mathematical variables ($x, y, z, m, n$) as provided in context. Never invent new variable names not found in the Data Anchor or original problem.
-    10. **STRATEGY CARD NO-SPOILER RULE (CRITICAL):**
-        - The `strategy_card` MUST NOT contain any numbers, final equations, derivatives, or solutions.
-        - It must ONLY contain high-level conceptual hints ("רמז 1: כדי למצוא קיצון, חשבו על...").
-    11. **NO HEBREW OR LOGICAL ARROWS IN LATEX:**
-        - Within `block_math` and all LaTeX parts, DO NOT use Hebrew text.
-        - DO NOT use logical arrows like `\implies`, `\Rightarrow`, or `\iff` as they cause parsing errors. Use descriptive words in `content_mixed` instead.
-    12. **PEDAGOGICAL HIGHLIGHTING:**
-        - Use `\\color{red}{...}` for highlighting ONLY inside the `content_mixed` field when explaining inline math. 
-        - NEVER use color tags inside `block_math` or `final_answer` as it will crash the backend algebraic validator.
-    13. **MULTI-IMAGE & GRADING LOGIC (V308.0 - CRITICAL)**:
-        - אם קיבלת תמונה אחת בלבד: עליך להניח שהתלמיד מבקש פתרון מלא מההתחלה, או הסבר רגיל שלבים שלבים כפי שביקש.
-        - אם קיבלת יותר מתמונה אחת: התמונה הראשונה היא השאלה המקורית. שאר התמונות הן נסיונות הפתרון של התלמיד בכתב יד. 
-        - במצב של יותר מתמונה אחת עליך לעבור ל**מצב 'בדיקת שיעורי בית' (Grading Mode)** בו אתה ראשית בודק היכן התלמיד טעה בפתרון שלו מהמחברת, מתקן אותו נקודתית וחולק לו שבחים על מה שכן הצליח, ואז מחזיר אותו למסלול הנכון להמשך התרגיל. אל תוציא מיד פתרון מלא במצב זה, תן לו להבין קודם איפה הטעות!
-    14. **AI ASSESSMENT TELEMETRY (CRITICAL FOR ANALYTICS):**
-        - בסיום הניתוח, עליך להוסיף אובייקט `assessment` חבוי ב-JSON.
-        - בחר את ה-`primary_skill` מתוך הרשימה הסגורה הבאה בלבד: ["אלגברה", "גיאומטריה", "טריגונומטריה", "הסתברות", "חשבון דיפרנציאלי"]. בשום פנים ואופן אל תמציא נושאים חדשים.
-        - `sub_skill`: תיאור חופשי קצר של תת-הנושא הספציפי בתרגיל (למשל: "חוקי חזקות").
-        - `mastery_score`: ציון מ-1 עד 100 על סמך איכות הפתרון של התלמיד בתמונה. אם אין תמונת פתרון, תן ציון על פי הבנת התרגיל או שים ציון ריק.
-        - `parent_note`: משפט אחד קצר וחיובי המיועד להוריו של התלמיד, המסכם את חוזקותיו (למשל: "התלמיד גילה הבנה טובה בבידוד משתנים").
-    15. **GRAPH ANTI-HALLUCINATION (CRITICAL - V310.0):**
-        - When asked to match a function to a graph, NEVER rely on visual size estimation or "gut feeling" from the image.
-        - You MUST find mathematical anchors: intersection points with axes ($x=0$ or $y=0$), extrema, or asymptotes.
-        - Cross-reference your algebraic findings with the provided graphs.
-        - If the image is ambiguous, state clearly: "בגלל שהשרטוט אינו חד-משמעי, עלינו לוודא את נכונות הגרף באמצעות הצבת נקודות חיתוך".
-    16. **CHRONOLOGICAL LOGIC & DATA ISOLATION (V8.6.9 - CRITICAL):**
-        - You MUST solve sub-questions strictly in order.
-        - NEVER use data, parameters (like $a=1$), or specific values that explicitly belong to a LATER sub-question (e.g., Section ב') to solve an EARLIER sub-question (e.g., Section א').
-        - Solve earlier sections algebraically using general variables unless the data is part of the global question anchor.
-        - If a student's finding in Section א' is required for Section ב', you may use it, but NEVER the other way around.
-    17. **VISUAL GRAPH ANALYSIS (V8.9.1):** When asked to identify a graph from an image containing multiple options (e.g., I, II, III, IV), you MUST explicitly describe what you see in the image for EACH option before making a choice. Base your final selection strictly on matching your mathematical deductions (domain, asymptotes, roots) to the visual features of the graphs in the image. Ensure these descriptions are in `content_mixed` to maintain logical transparency for the student.
-    18. **NO GUESSING RULE (V310.0):** אם הנתונים בתמונה אינם מספיקים כדי לקבוע בוודאות איזה גרף מתאים לאזו פונקציה, אל תנחש! הצג את הניתוח המתמטי והסבר מה חסר כדי להגיע להכרעה. ניתן להוסיף: "מומלץ לבחון את הגרף המצורף (אם קיים) כדי לראות את המאפיינים שחישבנו."
-
-
-    ═══════════════════════════════════════════════════
-    REQUIRED JSON STRUCTURE (EXACT KEYS):
-    ═══════════════════════════════════════════════════
-    {{
-      {graph_field}
-      "strategy_card": {{
-        "title": "איך ניגשים לשאלה הזו? 🧭",
-        "intro": "היי! נראה שיש לנו פה שאלת [נושא] מצוינת...",
-        "bullets": ["רמז 1: [רמז מוכוון פעולה ללא ספוילרים או תשובות]", "רמז 2: [רמז נוסף]"],
-        "call_to_action": "קחו דף ועט, נסו לפתור לבד לפי הרמזים, ואם נתקעתם – פתחו את הסעיפים למטה!"
-      },
-      "approach": "הקדמה מלאה: פתיח חם, אישי ומלמד שמסביר בשפה פתוחה מה נלך לעשות בתרגיל ולמה (למשל: 'כדי למצוא אסימפטוטות אנחנו נבדוק מה קורה בפלוס ומינוס אינסוף').",
-      "steps": [
-        {
-          "step_id": 1,
-          "content_mixed": "(הסבר פדגוגי מפורט ואמהי) כדי למצוא את הנגזרת נשתמש בכלל המנה, ונגזור את המונה בנפרד ואת המכנה בנפרד:",
-          "block_math": "y' = \\frac{\\color{blue}{2x} \\cdot (x-1) - x^2 \\cdot \\color{blue}{1}}{(x-1)^2}"
-        },
-        {
-          "step_id": 2,
-          "content_mixed": "(המשך הסבר חם ומפורט) נציב כעת $x=\\color{red}{5}$ במשוואה שצמצמנו:",
-          "block_math": "y' = \\frac{\\color{red}{5}^2 - 2\\cdot \\color{red}{5}}{(\\color{red}{5}-1)^2} = \\frac{15}{16}"
-        }
-      ],
-      "final_answer": "התשובה הסופית נטו (LaTeX)",
-      "teacher_summary": {
-        "audio_pitch": "פיצ' שיחתי (כמו פודקאסט קצר) של 30-40 שניות שבו המורה מסכמת את התרגיל וחולקת תובנות. כתבי בטון אמהי, חם ומעודד.",
-        "key_concepts": ["סיכום מלמד 1: הפקת לקחים ותובנה אסטרטגית מהתרגיל (למשל 'שימו לב שתמיד לפני גזירת מנה נרצה לסדר את הפונקציה')", "סיכום מלמד 2: כלל אצבע שאפשר לקחת משאלה זו הלאה"],
-        "formulas": ["נוסחאות מרכזיות בהן השתמשנו, בפורמט LaTeX נקי (ללא סוגרי דולר)"]
-      },
-      "assessment": {
-        "primary_skill": "אלגברה / גיאומטריה / טריגונומטריה / הסתברות / חשבון דיפרנציאלי",
-        "sub_skill": "תת הנושא הספציפי",
-        "mastery_score": 85,
-        "parent_note": "משפט על הצלחת התלמיד עבור דוח ההורים."
-      }
-    }}
-    
-    CRITICAL: Output ONLY the JSON block. No text before, no text after. No markdown formatting.
-    """
-    return prompt_template.replace("{graph_field}", graph_field)
-
-def get_master_prompt_v430(category: str = "", problem_text: str = ""):
-    """V4.3.0: Legacy placeholder, redirecting to V8.6.0 for 'The Golden Merge'"""
-    return get_master_prompt_v860(category=category, problem_text=problem_text)
-
-
-# ==================== V285.0: CHECK ME PROMPT (HOMEWORK VERIFICATION) ====================
-
-def get_check_me_prompt(grade: str, student_name: str, student_gender: str = "M", data_anchor: dict = None):
-    """
-    V285.1: Dedicated prompt for the "Check Me" feature with DATA ANCHOR.
-    The LLM acts as a homework checker, NOT a solver.
-    """
-    # Gender-aware phrases
-    if student_gender == "F":
-        g_addr = "את"
-        g_did = "עשית"
-        g_chose = "בחרת"
-        g_forgot = "שכחת"
-        g_started = "התחלת"
-        g_great = "מעולה"
-        g_dear = f"{student_name} יקרה"
-    else:
-        g_addr = "אתה"
-        g_did = "עשית"
-        g_chose = "בחרת"
-        g_forgot = "שכחת"
-        g_started = "התחלת"
-        g_great = "מעולה"
-        g_dear = f"{student_name} יקר"
-
-    anchor_block = ""
-    if data_anchor:
-        anchor_block = f"""
-    ══════════════════════════════════════════════════════
-    📜 DATA INTEGRITY RULE (ABSOLUTE TRUTH):
-    ══════════════════════════════════════════════════════
-    הנתונים להלן הם נתוני השאלה המקוריים כפי שזוהו בשלב הניתוח המוקדם.
-    עליך לבדוק את פתרון התלמיד אל מול הנתונים האלו בדיוק!
-    {json.dumps(data_anchor, indent=2, ensure_ascii=False)}
-    ══════════════════════════════════════════════════════
-    """
-
-    return f"""
-    🎓 תפקיד: אתה בודקת שיעורי בית — מורה פרטית חמה שבודקת את העבודה של תלמיד.
-    🚫 אתה לא פותר את התרגיל מחדש! אתה מנתח את מה שהתלמיד כתב.
-
-    📸 היררכיית תמונות:
-    1. התמונה הראשונה (image_00) היא השאלה המקורית מהספר/מבחן.
-    2. כל שאר התמונות (image_01 ומעלה) מכילות את שלבי הפתרון שכתב התלמיד בכתב יד.
-
-    👤 התלמיד: {student_name}, כיתה {grade}.
-    👑 מגדר: {"נקבה" if student_gender == "F" else "זכר"}. השתמש/י בלשון מתאימה.
-
-    {anchor_block}
-
-    ═══════════════════════════════════════════════════
-    📐 שלוש שלבי הבדיקה (חובה לבצע לפי הסדר):
-    ═══════════════════════════════════════════════════
-
-    שלב א' — בדיקת מתודולוגיה (אסטרטגיה):
-    • זהה את התרגיל מתוך התמונה.
-    • בדוק: האם התלמיד בכלל בחר בשיטת פתרון נכונה?
-    • למשל: האם השתמש בנוסחת השורשים כשצריך פירוק? האם גזר כשצריך אינטגרל?
-    • אם השיטה שגויה מיסודה — עצור כאן. הסבר את הטעות התפיסתית בלבד.
-
-    שלב ב' — אימות אלגברי צעד-אחר-צעד:
-    • סרוק את שורות הפתרון שהתלמיד כתב.
-    • בדוק כל מעבר: העברת אגפים, כינוס איברים, סימנים, חזקות.
-    • ברגע שמזהה שבירה של חוק אלגברי — בודד את השורה המדויקת.
-    • ציין מה היה צריך להיות ולמה.
-
-    שלב ג' — רכיבים ויזואליים:
-    • אם התלמיד צייר גרף, שרטוט גיאומטרי, או טבלת סימנים שגויים — ציין מה שגוי.
-    • אם אין רכיב ויזואלי — דלג על שלב זה.
-
-    ═══════════════════════════════════════════════════
-    🎯 כללי ברזל:
-    ═══════════════════════════════════════════════════
-    1. אל תפתור את התרגיל מחדש! רק בדוק את מה שהתלמיד כתב.
-    2. אם הכל נכון — תן חיזוק חיובי אמיתי ומפורט.
-    3. אם יש טעות — הצבע על השורה המדויקת, הסבר מה שגוי, ומה היה צריך להיות.
-    4. טון: חם, מעודד, מקצועי. כמו מורה פרטית שבודקת מבחן עם העט האדום, אבל בלב חם.
-    5. כל התשובה בעברית.
-    6. אם אתה לא מצליח לזהות את כתב היד — ציין זאת בנימוס ובקש צילום ברור יותר.
-
-    ═══════════════════════════════════════════════════
-    📋 פורמט JSON נדרש (STRICT — ללא טקסט לפני או אחרי):
-    ═══════════════════════════════════════════════════
-    {{
-        "verdict": "correct" | "has_errors" | "methodology_error" | "unreadable",
-        "score": ציון מ-0 עד 100 על העבודה (100 אם הכל נכון),
-        "problem_identified": "מה התרגיל שזוהה מהתמונה (LaTeX)",
-        "methodology_ok": true | false,
-        "methodology_note": "הערה על השיטה שנבחרה (ריק אם הכל תקין)",
-        "mistakes": [
-            {{
-                "mistake_description": "תיאור קצר של הטעות",
-                "correction_tip": "טיפ איך לתקן"
-            }}
-        ],
-        "feedback_steps": [
-            {{
-                "step_id": 1,
-                "student_wrote": "מה שהתלמיד כתב בשורה זו (LaTeX)",
-                "is_correct": true | false,
-                "error_description": "אם שגוי: מה הטעות ולמה",
-                "should_be": "מה היה צריך להיות (LaTeX, ריק אם נכון)"
-            }}
-        ],
-        "visual_note": "הערה על שרטוט/גרף אם רלוונטי, אחרת null",
-        "encouragement": "משפט חיזוק חיובי אישי ל{student_name}",
-        "correct_final_answer": "התשובה הנכונה של התרגיל (LaTeX)"
-    }}
-
-    CRITICAL: Output ONLY the JSON block. No text before, no text after. No markdown formatting.
-    """
-
-
-# ==================== V285.1: TEACHER SUMMARY PROMPT (PEDAGOGICAL) ====================
-
-def get_teacher_summary_prompt(student_name: str, student_gender: str = "M"):
-    """
-    V285.1: Prompt for generating a pedagogical teacher summary.
-    The LLM summarizes what was learned, key concepts, formulas, and generates TTS text.
-    """
-    if student_gender == "F":
-        g_addr = "את"
-        g_learned = "למדת"
-        g_solved = "פתרת"
-        g_dear = student_name
-    else:
-        g_addr = "אתה"
-        g_learned = "למדת"
-        g_solved = "פתרת"
-        g_dear = student_name
-
-    return f"""
-    אתה מורה למתמטיקה שמסכמת שיעור. קיבלת את הבעיה ואת הפתרון שנוצר.
-    המשימה שלך: ליצור סיכום פדגוגי שמתמקד בנושא שנלמד, לא בשאלה הספציפית.
-
-    👤 התלמיד: {student_name}
-    👑 מגדר: {"נקבה" if student_gender == "F" else "זכר"}
-
-    ═══════════════════════════════════════════════════
-    📋 מה לכלול בסיכום:
-    ═══════════════════════════════════════════════════
-
-    1. topic_summary: סיכום קצר של הנושא המתמטי שעסקנו בו (לא השאלה עצמה).
-       למשל: "גזירת פונקציות פולינומיאליות" או "חישוב שטח מתחת לגרף".
-
-    2. key_concepts: רשימה של 2-4 תובנות מפתח ונקודות חשובות שכדאי לזכור לתרגילים הבאים.
-       למשל: "כשגוזרים חזקה, מורידים את המעריך ומחסרים 1" — כללי, לא ספציפי.
-
-    3. formulas_to_remember: רשימה של 1-3 נוסחאות גנריות שהשתמשנו בהן.
-       לכתוב ב-LaTeX.
-       למשל: "\\\\frac{{d}}{{dx}} x^n = n \\\\cdot x^{{n-1}}"
-       אל תכלול ביטויים מספריים ספציפיים מהשאלה! רק נוסחאות כלליות.
-
-    4. tts_speech: טקסט דיבור קצר וחם למורה (4-6 משפטים).
-       ⚠️ כללי ברזל ל-TTS:
-       - עברית בלבד, ללא LaTeX, ללא סימנים מתמטיים, ללא אימוג'ים
-       - אל תקרא לתלמיד "נסיך", "נסיכה", "גיבור", "אלוף" - רק בשם {student_name}
-       - תדבר בגוף שני {"נקבה" if student_gender == "F" else "זכר"}
-       - טון: חם ומקצועי, כמו מורה פרטית שמסכמת שיעור
-       - ציין את הנושא שלמדנו, תובנה מרכזית אחת, ומשפט עידוד
-
-    ═══════════════════════════════════════════════════
-    📋 פורמט JSON נדרש:
-    ═══════════════════════════════════════════════════
-    {{
-        "topic_summary": "שם הנושא שנלמד (קצר)",
-        "key_concepts": ["תובנה 1", "תובנה 2", "תובנה 3"],
-        "formulas_to_remember": ["LaTeX נוסחה 1", "LaTeX נוסחה 2"],
-        "tts_speech": "טקסט דיבור עברי נקי ל-TTS"
-    }}
-    """
-
-def get_anchor_validation_prompt(ocr_json: dict) -> str:
-    """
-    V8.9.2: Dedicated prompt for the Orchestrator's Data Anchor Validator.
-    Takes the raw OCR JSON and the image to produce a syntactically perfect 'Absolute Truth'.
-    """
-    ocr_str = json.dumps(ocr_json, indent=2, ensure_ascii=False)
-    
-    return f"""
-    You are a strict Mathematical Transcriber & Validator. 
-    Look at the provided OCR JSON and the original image.
-    
-    OCR JSON (Raw Extraction):
-    {ocr_str}
-    
-    ⚠️ MISSION:
-    The OCR often corrupts complex fractions, missing brackets, or mangling operators.
-    Your ONLY job is to output a verified, syntactically perfect JSON containing the main mathematical functions and parameters exactly as they appear in the image.
-    
-    **CRITICAL VISION PROTOCOL:**
-    You are a strict Visual Validator, NOT a text auto-completer. When evaluating the extracted math, you MUST cross-reference the text directly against the ORIGINAL IMAGE.
-    If the input string is syntactically broken, truncated, or missing components (e.g., dropped fractions, missing multipliers outside parentheses), DO NOT delete terms to artificially 'fix' the equation.
-    You MUST visually reconstruct the EXACT mathematical expression pixel-for-pixel as it appears in the image. Do not hallucinate values (e.g., changing $e$ to $\sqrt{e}$). MATCH THE PIXELS EXACTLY.
-
-    RULES:
-    1. Fix any hanging operators (e.g., 'a+', 'x-').
-    2. Restore missing multipliers or fractions (e.g., if image shows '1/x' but OCR missed it).
-    3. Ensure all brackets are closed and standard variables are used.
-    4. If the OCR is correct, keep it as is.
-    5. CRITICAL: Do NOT solve the problem. Do NOT explain. 
-    6. Output ONLY the corrected JSON following the exact structure of the input.
-    7. V8.9.2: If you fix a critical syntax error (like 'a+' -> 'a+1/x^2'), ensure the final result is mathematically plausible based on the visual evidence.
-    8. **HORIZONTAL VERIFICATION (V8.9.3):** Check the horizontal order of elements. If an element is to the left of a bracket in the image, it MUST be to the left of the bracket in your JSON. Do NOT let the Hebrew text flow (RTL) swap the positions of multipliers or terms.
-    9. **CRITICAL JSON STRUCTURE RULE (V8.9.4):** Every output MUST be a flat JSON dictionary with UNIQUE keys. Do NOT use duplicate keys like "equation" multiple times. If there are multiple equations, use "equation_1", "equation_2", etc.
-    
-    Return ONLY the corrected JSON.
-    """
diff --git a/proof_graph.py b/proof_graph.py
deleted file mode 100644
index c3e995d43dd89b23933aa1fe8ac786eface63a9b..0000000000000000000000000000000000000000
--- a/proof_graph.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# proof_graph.py - Immutable Mathematical Structure
-
-from pydantic import BaseModel, Field
-from typing import Optional, List, Dict, Any
-
-class ProofStep(BaseModel):
-    step_id: int
-    math_content: str  # Immutable SymPy/LaTeX (or math_artifact)
-    logic_description: str = ""
-    operator_used: str = ""
-    # V6 Additions:
-    rule_id: str = "general_algebra"
-    allowed_concepts: List[str] = Field(default_factory=list)
-    complexity_score: float = 1.0
-    pedagogical_tag: str = "כללי"
-
-class ProofGraph:
-    def __init__(self, steps: list[ProofStep]):
-        self.steps = steps
-        self.is_verified = False
-
-    def verify_consistency(self):
-        # SymPy identity checks between steps
-        pass
-
-def validate_pedagogical_legality(proof_graph: ProofGraph, curriculum_rules: dict) -> tuple[bool, str]:
-    """
-    V4.0: The Hard Enforcement Rule.
-    Checks if any step in the proof graph uses a forbidden math operator.
-    """
-    forbidden = curriculum_rules.get("forbidden", [])
-    reason_map = curriculum_rules.get("reason_map", {})
-    
-    for step in proof_graph.steps:
-        if step.operator_used in forbidden:
-            detailed_reason = reason_map.get(step.operator_used, step.operator_used)
-            msg = f"Forbidden operator used: {detailed_reason}. Not allowed for this grade/level."
-            print(f"🚨 [PEDAGOGY-GUARD] REJECTED: {msg}")
-            return False, msg
-            
-    return True, "Solution is pedagogically legal."
diff --git a/quota_system.py b/quota_system.py
deleted file mode 100644
index c05c65b79c08cc2d72eed9b41f1a3f12f88605ec..0000000000000000000000000000000000000000
--- a/quota_system.py
+++ /dev/null
@@ -1,211 +0,0 @@
-import json
-import os
-import datetime
-from threading import Lock
-from config import IS_PRODUCTION  # Added for V3.1.3 Quota Override
-
-import tempfile
-import shutil
-
-LIMITS_FILE = "student_limits.json"
-# V260.9: Use /tmp or local for usage stats to avoid permission errors
-USAGE_FILENAME = "usage_stats.json"
-
-# Function to get writable usage path
-def get_usage_file_path():
-    # Try local first
-    if os.access(".", os.W_OK):
-        return USAGE_FILENAME
-    # Fallback to temp dir
-    return os.path.join(tempfile.gettempdir(), USAGE_FILENAME)
-
-USAGE_FILE = get_usage_file_path()
-
-# V261: Persistent user tracking
-ALL_USERS_FILE = "all_users.json"
-
-class QuotaManager:
-    def __init__(self):
-        self.lock = Lock()
-        print(f"📊 [QUOTA] Using stats file: {USAGE_FILE}")
-        self._load_limits()
-        self._ensure_files()
-
-    def _ensure_files(self):
-        if not os.path.exists(LIMITS_FILE):
-            try:
-                with open(LIMITS_FILE, 'w', encoding='utf-8') as f:
-                    json.dump({"default_limit": 30, "students": {}}, f)
-            except PermissionError:
-                print(f"⚠️ [QUOTA] Cannot create defaults limits file (Read-only fs)")
-
-        if not os.path.exists(USAGE_FILE):
-             try:
-                with open(USAGE_FILE, 'w', encoding='utf-8') as f:
-                    json.dump({}, f)
-             except Exception as e:
-                 print(f"⚠️ [QUOTA] Failed to init usage file: {e}")
-
-        # V261: Ensure persistent user list exists
-        if not os.path.exists(ALL_USERS_FILE):
-            try:
-                with open(ALL_USERS_FILE, 'w', encoding='utf-8') as f:
-                    json.dump({}, f)
-                print(f"📊 [QUOTA] Created {ALL_USERS_FILE}")
-            except Exception as e:
-                print(f"⚠️ [QUOTA] Failed to init all_users file: {e}")
-
-    def _load_limits(self):
-        try:
-            with open(LIMITS_FILE, 'r', encoding='utf-8') as f:
-                self.limits_config = json.load(f)
-        except Exception as e:
-            print(f"⚠️ [QUOTA] Failed to load limits: {e}")
-            self.limits_config = {"default_limit": 30, "students": {}, "blocked_users": []}
-
-        # V3.1.3: DEV Quota Reset
-        if not IS_PRODUCTION:
-            self.limits_config["default_limit"] = 1000
-
-    def _load_usage(self):
-        try:
-            with open(USAGE_FILE, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except Exception:
-            return {}
-
-    def _save_usage(self, usage_data):
-        try:
-            with open(USAGE_FILE, 'w', encoding='utf-8') as f:
-                json.dump(usage_data, f, indent=2)
-        except Exception as e:
-            print(f"⚠️ [QUOTA] Failed to save usage: {e}")
-
-    def _load_all_users(self):
-        try:
-            with open(ALL_USERS_FILE, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except:
-            return {}
-
-    def _save_all_users(self, data):
-        try:
-            with open(ALL_USERS_FILE, 'w', encoding='utf-8') as f:
-                json.dump(data, f, indent=2)
-        except Exception as e:
-            print(f"⚠️ [QUOTA] Failed to save all_users: {e}")
-
-    def get_today_key(self):
-        return datetime.date.today().isoformat()
-
-    def track_user(self, student_name):
-        """V261: Updates the last_seen for a user in persistent storage"""
-        if not student_name: return
-        try:
-            with self.lock:
-                users = self._load_all_users()
-                users[student_name] = {
-                    "last_seen": datetime.datetime.now().isoformat(),
-                    "id": student_name
-                }
-                self._save_all_users(users)
-        except Exception as e:
-            print(f"⚠️ [QUOTA] Failed to track user: {e}")
-
-    def check_limit(self, student_name):
-        """
-        Returns:
-            (allowed: bool, message: str, current_usage: int, limit: int)
-        """
-        if not student_name:
-            return True, "No name", 0, 9999
-
-        # V261: Track user on every check
-        self.track_user(student_name)
-
-        # Refresh limits config in case it changed manually
-        self._load_limits()
-
-        if student_name in self.limits_config.get("blocked_users", []):
-             return False, "User is blocked", 0, 0
-
-        limit = self.limits_config.get("students", {}).get(student_name, self.limits_config.get("default_limit", 30))
-        
-        # Admin override or high limit
-        if limit < 0: 
-            return True, "Unlimited", 0, -1
-
-        today = self.get_today_key()
-        with self.lock:
-            usage_data = self._load_usage()
-            today_usage = usage_data.get(today, {})
-            current_count = today_usage.get(student_name, 0)
-
-        if current_count >= limit:
-            return False, f"Daily limit reached ({limit})", current_count, limit
-
-        return True, "Allowed", current_count, limit
-
-    def increment_usage(self, student_name):
-        if not student_name:
-            return
-            
-        today = self.get_today_key()
-        with self.lock:
-            usage_data = self._load_usage()
-            if today not in usage_data:
-                usage_data[today] = {}
-            
-            usage_data[today][student_name] = usage_data[today].get(student_name, 0) + 1
-            self._save_usage(usage_data)
-            
-        print(f"📊 [QUOTA] Incremented for {student_name}. Date: {today}")
-
-    # ================= ADMIN METHODS (V261) =================
-
-    def get_all_users_data(self):
-        """Merges all_users (history), limits (config), and usage (today)"""
-        all_users = self._load_all_users() # {id: {last_seen...}}
-        limits = self.limits_config
-        today_usage = self._load_usage().get(self.get_today_key(), {})
-        
-        result = []
-        # Merge known users from history
-        for uid, udata in all_users.items():
-            limit = limits.get("students", {}).get(uid, limits.get("default_limit", 30))
-            usage = today_usage.get(uid, 0)
-            result.append({
-                "id": uid,
-                "last_seen": udata.get("last_seen"),
-                "limit": limit,
-                "usage_today": usage,
-                "is_blocked": uid in limits.get("blocked_users", [])
-            })
-            
-        # Also include users in limits config who might not be in history yet (?)
-        # (Optional, skipping for now to keep it simple)
-        
-        # Sort by most recently seen
-        result.sort(key=lambda x: x.get("last_seen", ""), reverse=True)
-        return result
-
-    def set_user_limit(self, user_id, new_limit):
-        """Updates the limit for a specific user"""
-        with self.lock:
-            self._load_limits()
-            if "students" not in self.limits_config:
-                self.limits_config["students"] = {}
-            
-            try:
-                limit_int = int(new_limit)
-                self.limits_config["students"][user_id] = limit_int
-                
-                # Save back to file
-                with open(LIMITS_FILE, 'w', encoding='utf-8') as f:
-                    json.dump(self.limits_config, f, indent=4)
-                return True, "Updated"
-            except Exception as e:
-                return False, str(e)
-
-# Global instance
-quota_manager = QuotaManager()
diff --git a/quota_system_v2.py b/quota_system_v2.py
deleted file mode 100644
index 3b499eb220fdf5d959818eb960ed38450db6a02e..0000000000000000000000000000000000000000
--- a/quota_system_v2.py
+++ /dev/null
@@ -1,272 +0,0 @@
-import datetime
-import logging
-from firebase_admin import firestore
-
-# We import the manager to get the initialized DB
-from firebase_manager import firebase_manager
-
-logger = logging.getLogger("HamoraServer")
-
-class QuotaManagerV2:
-    """
-    V2 QuotaManager: Uses Firestore exclusively.
-    Ignores local JSON files.
-    """
-    
-    def __init__(self):
-        self.default_limit = 30 # Can be overridden in config or by user doc
-        self.collection_name = "users"
-
-    def _get_db(self):
-        return firebase_manager.get_db()
-
-    def get_today_key(self):
-        return datetime.date.today().isoformat()
-        
-    def get_this_month_key(self):
-        return datetime.date.today().strftime("%Y-%m")
-
-    def check_limit(self, uid: str, device_id: str = None):
-        """
-        Returns:
-            (allowed: bool, message: str, current_usage: int, limit: int)
-        """
-        if not uid:
-            return False, "Missing UID", 0, 0
-
-        db = self._get_db()
-        if not db:
-            logger.error("❌ [QUOTA_V2] Firestore DB not available.")
-            return False, "Database error", 0, 0
-
-        try:
-            doc_ref = db.collection(self.collection_name).document(uid)
-            doc = doc_ref.get()
-
-            if not doc.exists:
-                logger.warning(f"⚠️ [QUOTA_V2] User document not found for {uid}. Allowing with default.")
-                return True, "Allowed (Default)", 0, self.default_limit
-
-            data = doc.to_dict()
-            
-            # Check if blocked
-            if data.get("status") == "rejected":
-                 return False, "User is blocked", 0, 0
-
-            # Admin or special roles
-            if data.get("role") == "admin" or data.get("status") == "admin" or data.get("isAdmin") is True or data.get("tier") == "admin_unlimited" or data.get("is_unlimited") is True:
-                return True, "Unlimited (Admin/VIP)", 0, -1
-
-            # --- Device ID Enforcement ---
-            if device_id:
-                tier = data.get("tier", "student_basic")
-                allowed_devices = data.get("allowed_devices", [])
-                
-                max_devices = 2 if tier == "parent_premium" else 1
-                
-                if device_id not in allowed_devices:
-                    if len(allowed_devices) >= max_devices:
-                        return False, f"Device Limit Exceeded ({max_devices})", 0, 0
-                    else:
-                        # Add device atomically
-                        doc_ref.update({"allowed_devices": firestore.ArrayUnion([device_id])})
-            # -----------------------------
-
-            limit = data.get("quota_limit", self.default_limit)
-            monthly_token_budget = data.get("monthly_token_budget")
-            
-            # Special limits
-            if limit < 0:
-                return True, "Unlimited", 0, -1
-
-            today = self.get_today_key()
-            this_month = self.get_this_month_key()
-            
-            last_usage_date = data.get("last_usage_date", "")
-            last_usage_month = data.get("last_usage_month", "")
-            
-            # Daily Question Quota
-            if last_usage_date != today:
-                current_count = 0
-            else:
-                current_count = data.get("used_today", 0)
-
-            if current_count >= limit:
-                return False, f"Daily limit reached ({limit})", current_count, limit
-                
-            # Monthly Token Quota (if defined)
-            if monthly_token_budget is not None:
-                if last_usage_month != this_month:
-                    used_tokens = 0
-                else:
-                    used_tokens = data.get("used_tokens_this_month", 0)
-                    
-                if used_tokens >= monthly_token_budget:
-                    return False, f"Monthly token budget reached", current_count, limit
-
-            return True, "Allowed", current_count, limit
-
-        except Exception as e:
-            logger.error(f"❌ [QUOTA_V2] Error checking limit for {uid}: {e}")
-            # Fail closed or open? Let's fail open temporarily so we don't block users if DB hiccups
-            return True, "Error - Fallback Allow", 0, self.default_limit
-
-    def check_wallet(self, uid: str, min_required: int = 2000):
-        """
-        V5.15.0: Strict token balance check for Pencil Economy (Pre-flight).
-        1 Pencil = 17,000 tokens.
-        """
-        if not uid or uid == "dev-bypass-user":
-            return True, 1000000 
-            
-        db = self._get_db()
-        if not db:
-            return False, 0
-            
-        try:
-            doc_ref = db.collection(self.collection_name).document(uid)
-            doc = doc_ref.get()
-            if not doc.exists:
-                return False, 0 
-            
-            data = doc.to_dict()
-            
-            # Admin Bypass
-            if data.get("role") == "admin" or data.get("status") == "admin" or data.get("isAdmin") is True or data.get("tier") == "admin_unlimited" or data.get("is_unlimited") is True:
-                return True, 1000000
-                
-            wallet = data.get('wallet', {})
-            token_balance = wallet.get('token_balance', 0)
-            
-            # Strict check against min_required
-            return token_balance >= min_required, token_balance
-        except Exception as e:
-            logger.error(f"❌ [QUOTA_V2] Failed to check wallet for {uid}: {e}")
-            return True, 0 
-
-    def add_tokens_with_absorption(self, uid: str, tokens_to_add: int):
-        """
-        V5.15.0: Add tokens with "Debt Absorption" and "Total Purchased" logic.
-        """
-        db = self._get_db()
-        if not db:
-            return
-        
-        try:
-            doc_ref = db.collection(self.collection_name).document(uid)
-            @firestore.transactional
-            def update_in_transaction(transaction, doc_ref):
-                snapshot = doc_ref.get(transaction=transaction)
-                current_balance = 0
-                if snapshot.exists:
-                    current_balance = snapshot.to_dict().get('wallet', {}).get('token_balance', 0)
-                
-                # Absorption logic
-                starting_point = max(0, current_balance)
-                new_balance = starting_point + tokens_to_add
-                
-                # Update both balance and total purchased (capacity)
-                transaction.update(doc_ref, {
-                    "wallet.token_balance": new_balance,
-                    "wallet.total_purchased_tokens": firestore.Increment(tokens_to_add)
-                })
-            
-            transaction = db.transaction()
-            update_in_transaction(transaction, doc_ref)
-            logger.info(f"💰 [QUOTA_V2] Added {tokens_to_add} tokens to {uid}. Total capacity increased.")
-        except Exception as e:
-            logger.error(f"❌ [QUOTA_V2] Failed to add tokens with absorption for {uid}: {e}")
-
-    def increment_usage(self, uid: str, increment_questions: int = 1, tokens_used: int = 0):
-        """
-        V5.15.0: Atomic increment with Overdraft Prevention.
-        """
-        if not uid:
-            return
-
-        db = self._get_db()
-        if not db:
-            return
-
-        today = self.get_today_key()
-        this_month = self.get_this_month_key()
-        doc_ref = db.collection(self.collection_name).document(uid)
-
-        try:
-            @firestore.transactional
-            def update_in_transaction(transaction, doc_ref):
-                snapshot = doc_ref.get(transaction=transaction)
-                if not snapshot.exists:
-                    if tokens_used > 0:
-                        raise ValueError("Insufficient Pencils: User document missing")
-                    transaction.set(doc_ref, {
-                        "quota_limit": self.default_limit,
-                        "used_today": increment_questions,
-                        "used_tokens_this_month": tokens_used,
-                        "last_usage_date": today,
-                        "last_usage_month": this_month,
-                        "last_seen": firestore.SERVER_TIMESTAMP,
-                        "wallet": {"token_balance": 0, "total_purchased_tokens": 0}
-                    })
-                    return
-
-                data = snapshot.to_dict()
-                
-                # V5.15.0: STRICT OVERDRAFT PREVENTION
-                if tokens_used > 0:
-                    wallet = data.get('wallet', {})
-                    current_balance = wallet.get('token_balance', 0)
-                    if current_balance < tokens_used:
-                        logger.warning(f"🚫 [QUOTA_V2] Overdraft blocked for {uid}: {current_balance} < {tokens_used}")
-                        raise ValueError("Insufficient Pencils")
-
-                last_date = data.get("last_usage_date", "")
-                last_month = data.get("last_usage_month", "")
-                
-                # Daily logic
-                if last_date != today:
-                    new_usage = increment_questions
-                else:
-                    new_usage = data.get("used_today", 0) + increment_questions
-                    
-                # Monthly Token logic
-                if last_month != this_month:
-                    new_tokens = tokens_used
-                else:
-                    new_tokens = data.get("used_tokens_this_month", 0) + tokens_used
-
-                # V5.9.8: Lifetime Tracking & Economics
-                total_used = data.get("total_tokens_used", 0) + tokens_used
-                
-                from cost_tracker import PRICING
-                avg_price = (PRICING["input"] + PRICING["output"]) / 2
-                cost_delta = (tokens_used / 1e6) * avg_price
-                total_cost = data.get("total_cost_usd", 0.0) + cost_delta
-                total_exercises = data.get("total_exercises_solved", 0) + increment_questions
-
-                transaction.update(doc_ref, {
-                    "used_today": new_usage,
-                    "used_tokens_this_month": new_tokens,
-                    "total_tokens_used": total_used,
-                    "total_exercises_solved": total_exercises,
-                    "total_cost_usd": total_cost,
-                    "last_usage_date": today,
-                    "last_active_date": today, 
-                    "last_usage_month": this_month,
-                    "last_seen": firestore.SERVER_TIMESTAMP,
-                    "wallet.token_balance": firestore.Increment(-tokens_used)
-                })
-
-            transaction = db.transaction()
-            update_in_transaction(transaction, doc_ref)
-            logger.info(f"📊 [QUOTA_V2] Incremented usage for {uid}. Tokens deducted: {tokens_used}")
-
-        except ValueError as ve:
-            # Re-raise for main.py to catch
-            raise ve
-        except Exception as e:
-            logger.error(f"❌ [QUOTA_V2] Failed to increment usage for {uid}: {e}")
-            raise e
-
-# Global instance
-quota_manager_v2 = QuotaManagerV2()
diff --git a/refiner.py b/refiner.py
deleted file mode 100644
index add1a81332e7773de96bfa60b7182f6fd9157e12..0000000000000000000000000000000000000000
--- a/refiner.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import re
-import logging
-
-logger = logging.getLogger("Refiner")
-
-class Refiner:
-    @staticmethod
-    def refine(data: dict) -> dict:
-        try:
-            if 'sections' in data and isinstance(data['sections'], list):
-                for section in data['sections']:
-                    if 'steps' in section and isinstance(section['steps'], list):
-                        for step in section['steps']:
-                            # חשוב: אנחנו מנקים רק את block_math מדולרים
-                            # את content_mixed אנחנו משאירים עם דולרים כדי שהאפליקציה תרנדר!
-                            if 'block_math' in step:
-                                step['block_math'] = Refiner._clean_latex_block(step['block_math'])
-            
-            return data
-        except Exception as e:
-            logger.error(f"Refinement error: {e}")
-            return data
-
-    @staticmethod
-    def _clean_latex_block(tex: str) -> str:
-        if not tex or tex == 'null': return ""
-        s = str(tex)
-        # בבלוק מתמטי נקי לא צריך דולרים
-        s = s.replace('$$', '').replace('$', '')
-        s = s.replace('-', '−') # מינוס יפה
-        return s.strip()
\ No newline at end of file
diff --git a/report_aggregator.py b/report_aggregator.py
deleted file mode 100644
index 334e90a5f4b5765ff40ac0316e3b9dc250d2688a..0000000000000000000000000000000000000000
--- a/report_aggregator.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# buddy_math_server/report_aggregator.py
-import time
-import logging
-from collections import defaultdict
-from firebase_manager import firebase_manager
-
-logger = logging.getLogger(__name__)
-
-class ReportAggregator:
-    def __init__(self):
-        self.db = firebase_manager.get_db()
-
-    def get_summary_for_period(self, uid: str, days=7):
-        """
-        Aggregates metrics for the last 7 days.
-        """
-        if not self.db:
-            return None
-
-        start_time = time.time() - (days * 24 * 60 * 60)
-        
-        summary = {
-            "total_interactions": 0,
-            "mastery_by_category": defaultdict(list),
-            "completed_challenges": 0,
-            "teacher_notes": [],
-            "top_categories": set()
-        }
-
-        try:
-            # 1. Query Analytics
-            analytics_docs = self.db.collection('users').document(uid).collection('analytics') \
-                .where('timestamp', '>', start_time).stream()
-            
-            for doc in analytics_docs:
-                data = doc.to_dict()
-                summary["total_interactions"] += 1
-                
-                cat = data.get('category', 'כללי')
-                score = data.get('mastery_score')
-                if score is not None:
-                    summary["mastery_by_category"][cat].append(score)
-                    summary["top_categories"].add(cat)
-                
-                note = data.get('parent_note') or data.get('teacher_summary')
-                if note:
-                    summary["teacher_notes"].append(note)
-
-            # 2. Query Completed Suggestions (Challenges)
-            suggestions = self.db.collection('users').document(uid).collection('suggestions') \
-                .where('status', '==', 'completed') \
-                .where('created_at', '>', start_time).stream()
-            
-            for sug in suggestions:
-                summary["completed_challenges"] += 1
-
-            # 3. Calculate Averages
-            avg_mastery = {}
-            for cat, scores in summary["mastery_by_category"].items():
-                avg_mastery[cat] = sum(scores) / len(scores)
-            
-            summary["avg_mastery"] = avg_mastery
-            
-            return summary
-
-        except Exception as e:
-            logger.error(f"❌ [AGGREGATOR] Error: {e}")
-            return None
-
-report_aggregator = ReportAggregator()
diff --git a/report_delivery_service.py b/report_delivery_service.py
deleted file mode 100644
index 493107d96a4b2163259e73f60e5a26cf0582585c..0000000000000000000000000000000000000000
--- a/report_delivery_service.py
+++ /dev/null
@@ -1,78 +0,0 @@
-# buddy_math_server/report_delivery_service.py
-import os
-import logging
-from jinja2 import Template
-from sendgrid import SendGridAPIClient
-from sendgrid.helpers.mail import Mail, Attachment, FileContent, FileName, FileType, Disposition
-import base64
-
-logger = logging.getLogger(__name__)
-
-class ReportDeliveryService:
-    def __init__(self):
-        self.api_key = os.environ.get('SENDGRID_API_KEY')
-        self.from_email = 'tutor@buddy-math.com'
-
-    def render_html(self, template_path, data):
-        """
-        Renders the Jinja2 template with data.
-        """
-        with open(template_path, 'r', encoding='utf-8') as f:
-            template_content = f.read()
-            template = Template(template_content)
-            return template.render(data)
-
-    def generate_pdf(self, html_content, output_path):
-        """
-        Converts HTML to PDF. 
-        Note: Requires xhtml2pdf or pdfkit. 
-        Using xhtml2pdf for simplicity in pure python environments.
-        """
-        try:
-            from xhtml2pdf import pisa
-            with open(output_path, "wb") as f:
-                pisa_status = pisa.CreatePDF(html_content, dest=f)
-                return not pisa_status.err
-        except ImportError:
-            logger.error("❌ [DELIVERY] xhtml2pdf not installed. Saving as HTML instead.")
-            with open(output_path.replace('.pdf', '.html'), 'w', encoding='utf-8') as f:
-                f.write(html_content)
-            return False
-
-    def send_email_with_attachment(self, to_email, subject, body, attachment_path, student_name):
-        """
-        Sends an email via SendGrid with the report attached.
-        """
-        if not self.api_key:
-            logger.error("❌ [DELIVERY] SENDGRID_API_KEY missing.")
-            return False
-
-        message = Mail(
-            from_email=self.from_email,
-            to_emails=to_email,
-            subject=subject,
-            html_content=body
-        )
-
-        try:
-            with open(attachment_path, 'rb') as f:
-                data = f.read()
-                encoded_file = base64.b64encode(data).decode()
-
-            attachedFile = Attachment(
-                FileContent(encoded_file),
-                FileName(f'BuddyMath_Report_{student_name}.pdf'),
-                FileType('application/pdf'),
-                Disposition('attachment')
-            )
-            message.add_attachment(attachedFile)
-
-            sg = SendGridAPIClient(self.api_key)
-            response = sg.send(message)
-            logger.info(f"🚀 [DELIVERY] Email sent to {to_email}. Status: {response.status_code}")
-            return True
-        except Exception as e:
-            logger.error(f"❌ [DELIVERY] SendGrid Error: {e}")
-            return False
-
-report_delivery_service = ReportDeliveryService()
diff --git a/report_generator.py b/report_generator.py
deleted file mode 100644
index a14bc87c86ccf9da9083a34cf590946c743d990b..0000000000000000000000000000000000000000
--- a/report_generator.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# buddy_math_server/report_generator.py
-import json
-import logging
-import requests
-import google.generativeai as genai
-from config import GEMINI_MODEL
-from report_aggregator import report_aggregator
-
-logger = logging.getLogger(__name__)
-
-class ReportGenerator:
-    def __init__(self):
-        self.model = genai.GenerativeModel(GEMINI_MODEL)
-
-    async def generate_ai_summary(self, data_summary: dict, student_name: str) -> str:
-        """
-        Uses Gemini 2.0 to generate a warm pedagogical summary for the parent.
-        """
-        # Prepare the data string for the prompt
-        mastery_str = ", ".join([f"{cat}: {score:.1f}%" for cat, score in data_summary.get("avg_mastery", {}).items()])
-        
-        prompt = f"""בשם 'המורה הפרטית' של Buddy-Math, כתוב סיכום שבועי להורה של {student_name}.
-נתוני הלמידה השבוע:
-- סה"כ תרגילים שבוצעו: {data_summary['total_interactions']}
-- ציון ממוצע לפי נושא: {mastery_str}
-- אתגרים אקטיביים שהושלמו: {data_summary['completed_challenges']}
-- הערות מורה שנאספו: {"; ".join(data_summary['teacher_notes'][:5])}
-
-הוראות:
-1. כתוב פסקה קצרה (3-4 שורות) בעברית חמה, מעודדת ומקצועית.
-2. הדגש נושאים שבהם התלמיד השתפר והפגנת התמדה.
-3. הוסף טיפ פדגוגי אחד קטן להמשך.
-4. אל תשתמש בפורמט של מכתב רשמי, אלא בפנייה ישירה וחמה.
-"""
-        try:
-            res = await self.model.generate_content_async(prompt)
-            return res.text.strip()
-        except Exception as e:
-            logger.error(f"❌ [REPORT-GEN] AI Summary Error: {e}")
-            return "התלמיד התקדם יפה השבוע במתמטיקה והפגין סקרנות רבה."
-
-    def generate_radar_chart_url(self, avg_mastery: dict) -> str:
-        """
-        Generates a QuickChart URL for a Radar Chart.
-        """
-        labels = list(avg_mastery.keys())
-        values = list(avg_mastery.values())
-        
-        if not labels:
-            return "https://quickchart.io/chart?c={type:'radar',data:{labels:['כללי'],datasets:[{label:'התקדמות',data:[0]}]}}"
-
-        chart_config = {
-            "type": "radar",
-            "data": {
-                "labels": labels,
-                "datasets": [{
-                    "label": "רמת שליטה (%)",
-                    "data": values,
-                    "backgroundColor": "rgba(33, 150, 243, 0.2)",
-                    "borderColor": "rgb(33, 150, 243)",
-                    "pointBackgroundColor": "rgb(33, 150, 243)"
-                }]
-            },
-            "options": {
-                "scale": {
-                    "ticks": {"beginAtZero": True, "max": 100}
-                }
-            }
-        }
-        
-        url = f"https://quickchart.io/chart?c={json.dumps(chart_config)}"
-        return url
-
-report_generator = ReportGenerator()
diff --git a/report_template.html b/report_template.html
deleted file mode 100644
index afecea7cd09e252b2dbabe7eb0b649ea28c1c281..0000000000000000000000000000000000000000
--- a/report_template.html
+++ /dev/null
@@ -1,58 +0,0 @@
-<!DOCTYPE html>
-<html lang="he" dir="rtl">
-<head>
-    <meta charset="UTF-8">
-    <title>דו"ח למידה שבועי - Buddy-Math</title>
-    <style>
-        body { font-family: 'Arial', sans-serif; background-color: #f4f7f6; color: #333; margin: 0; padding: 20px; }
-        .container { background-color: #fff; padding: 40px; border-radius: 10px; box-shadow: 0 4px 6px rgba(0,0,0,0.1); max-width: 800px; margin: auto; }
-        .header { text-align: center; border-bottom: 2px solid #2196F3; padding-bottom: 20px; margin-bottom: 30px; }
-        .header h1 { color: #2196F3; margin: 0; }
-        .summary-box { background-color: #e3f2fd; padding: 20px; border-right: 5px solid #2196F3; border-radius: 4px; margin-bottom: 30px; line-height: 1.6; }
-        .stats-grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 20px; margin-bottom: 30px; text-align: center; }
-        .stat-item { background: #fafafa; padding: 15px; border-radius: 8px; border: 1px solid #eee; }
-        .stat-value { font-size: 24px; font-weight: bold; color: #2196F3; }
-        .stat-label { font-size: 14px; color: #666; }
-        .chart-container { text-align: center; margin: 40px 0; }
-        .chart-container img { max-width: 100%; height: auto; border-radius: 8px; }
-        .footer { text-align: center; font-size: 12px; color: #999; margin-top: 50px; }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="header">
-            <h1>איך עבר השבוע של {{ student_name }}? ✏️</h1>
-            <p>סיכום למידה פדגוגי שבועי</p>
-        </div>
-
-        <div class="stats-grid">
-            <div class="stat-item">
-                <div class="stat-value">{{ total_interactions }}</div>
-                <div class="stat-label">אינטראקציות השבוע</div>
-            </div>
-            <div class="stat-item">
-                <div class="stat-value">{{ completed_challenges }}</div>
-                <div class="stat-label">אתגרים שהושלמו</div>
-            </div>
-            <div class="stat-item">
-                <div class="stat-value">{{ avg_mastery_pct | round(1) }}%</div>
-                <div class="stat-label">ממוצע שליטה כללי</div>
-            </div>
-        </div>
-
-        <div class="summary-box">
-            <h3>דבר המורה:</h3>
-            <p>{{ ai_summary }}</p>
-        </div>
-
-        <div class="chart-container">
-            <h3>מפת המיומנויות של {{ student_name }}</h3>
-            <img src="{{ chart_url }}" alt="Radar Chart">
-        </div>
-
-        <div class="footer">
-            <p>נוצר באהבה על ידי Buddy-Math &copy; 2026</p>
-        </div>
-    </div>
-</body>
-</html>
diff --git a/requirements.txt b/requirements.txt
index 7513e1903cb1edf0445b1008bf694bae40a17cfe..979c0ca7938ea36b5a258e8b221084ce87e4cf8c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,18 +1,2 @@
-fastapi
-uvicorn
-python-multipart
-google-generativeai==0.8.3
-pillow
-python-dotenv
-json_repair
-matplotlib
-numpy
-sympy
-edge-tts>=7.0.0
-firebase-admin==6.4.0
-opencv-python-headless
-sse-starlette
-jinja2
-pdfkit
-weasyprint
-sendgrid
\ No newline at end of file
+llama-cpp-python[server]==0.2.90
+huggingface_hub
diff --git a/sample_report.html b/sample_report.html
deleted file mode 100644
index 19569c659cea8e1c11749596831655e4e98ce0ed..0000000000000000000000000000000000000000
--- a/sample_report.html
+++ /dev/null
@@ -1,266 +0,0 @@
-<!DOCTYPE html>
-<html lang="he" dir="rtl">
-<head>
-    <meta charset="UTF-8">
-    <title>דוח התקדמות שבועי - BuddyMath</title>
-    <style>
-        /* CSS Inline for PDF Compatibility */
-        @import url('https://fonts.googleapis.com/css2?family=Assistant:wght@400;600;800&display=swap');
-        
-        body {
-            font-family: 'Assistant', sans-serif;
-            background-color: #f8fafc;
-            color: #1e293b;
-            margin: 0;
-            padding: 40px;
-            direction: rtl;
-        }
-
-        .container {
-            max-width: 800px;
-            margin: 0 auto;
-            background: white;
-            border-radius: 24px;
-            padding: 40px;
-            box-shadow: 0 10px 25px rgba(0,0,0,0.05);
-        }
-
-        .header {
-            text-align: center;
-            margin-bottom: 40px;
-            border-bottom: 2px solid #e2e8f0;
-            padding-bottom: 20px;
-        }
-
-        .header h1 {
-            color: #4f46e5;
-            font-size: 32px;
-            margin: 0 0 10px 0;
-            font-weight: 800;
-        }
-
-        .header p {
-            color: #64748b;
-            font-size: 18px;
-            margin: 0;
-        }
-
-        .stats-grid {
-            display: flex;
-            justify-content: space-between;
-            margin-bottom: 40px;
-            gap: 20px;
-        }
-
-        .stat-card {
-            flex: 1;
-            background: #eff6ff;
-            border-radius: 16px;
-            padding: 24px;
-            text-align: center;
-            border: 1px solid #bfdbfe;
-        }
-
-        .stat-card h3 {
-            margin: 0 0 10px 0;
-            color: #3b82f6;
-            font-size: 16px;
-        }
-
-        .stat-card .value {
-            font-size: 36px;
-            font-weight: 800;
-            color: #1d4ed8;
-            margin: 0;
-        }
-
-        .content-flex {
-            display: flex;
-            gap: 40px;
-            margin-bottom: 40px;
-        }
-
-        .chart-section {
-            flex: 1;
-            text-align: center;
-            background: #ffffff;
-            border-radius: 20px;
-            padding: 20px;
-            border: 1px solid #e2e8f0;
-        }
-
-        .chart-section h2 {
-            color: #334155;
-            font-size: 20px;
-            margin-top: 0;
-        }
-
-        .chart-img {
-            max-width: 100%;
-            height: auto;
-        }
-
-        .skills-list {
-            flex: 1;
-        }
-
-        .skill-item {
-            margin-bottom: 20px;
-        }
-
-        .skill-header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            margin-bottom: 8px;
-        }
-
-        .skill-name {
-            font-weight: 600;
-            color: #334155;
-        }
-
-        .skill-score {
-            font-weight: 800;
-            color: #4f46e5;
-        }
-
-        .progress-bar {
-            height: 12px;
-            background: #e2e8f0;
-            border-radius: 10px;
-            overflow: hidden;
-        }
-
-        .progress-fill {
-            height: 100%;
-            background: linear-gradient(90deg, #6366f1, #3b82f6);
-            border-radius: 10px;
-        }
-
-        .sub-skills {
-            margin-top: 8px;
-            font-size: 14px;
-            color: #64748b;
-        }
-
-        .notes-section {
-            background: #fdf2f8;
-            border-radius: 20px;
-            padding: 30px;
-            border: 1px solid #fbcfe8;
-        }
-
-        .notes-section h2 {
-            color: #be185d;
-            margin-top: 0;
-            font-size: 20px;
-        }
-
-        .note-item {
-            position: relative;
-            padding-right: 24px;
-            margin-bottom: 12px;
-            color: #831843;
-            font-size: 16px;
-            line-height: 1.5;
-        }
-
-        .note-item::before {
-            content: "•";
-            position: absolute;
-            right: 0;
-            color: #ec4899;
-            font-size: 24px;
-            line-height: 1;
-        }
-
-        .footer {
-            margin-top: 40px;
-            text-align: center;
-            color: #94a3b8;
-            font-size: 14px;
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="header">
-            <h1>דוח התקדמות שבועי</h1>
-            <p>שבוע 11/2026 | דותן הרוש</p>
-        </div>
-
-        <div class="stats-grid">
-            <div class="stat-card">
-                <h3>סה"כ תרגילים שנפתרו</h3>
-                <p class="value">14</p>
-            </div>
-            <div class="stat-card">
-                <h3>ממוצע שליטה כללי</h3>
-                <p class="value">75%</p>
-            </div>
-        </div>
-
-        <div class="content-flex">
-            <!-- Radar Chart via QuickChart.io -->
-            <div class="chart-section">
-                <h2>מפת מיומנויות</h2>
-                <img class="chart-img" src="https://quickchart.io/chart?w=500&h=500&c=%7B%22type%22%3A%20%22radar%22%2C%20%22data%22%3A%20%7B%22labels%22%3A%20%5B%22%5Cu05d0%5Cu05dc%5Cu05d2%5Cu05d1%5Cu05e8%5Cu05d4%22%2C%20%22%5Cu05d2%5Cu05d9%5Cu05d0%5Cu05d5%5Cu05de%5Cu05d8%5Cu05e8%5Cu05d9%5Cu05d4%22%2C%20%22%5Cu05d8%5Cu05e8%5Cu05d9%5Cu05d2%5Cu05d5%5Cu05e0%5Cu05d5%5Cu05de%5Cu05d8%5Cu05e8%5Cu05d9%5Cu05d4%22%2C%20%22%5Cu05d4%5Cu05e1%5Cu05ea%5Cu05d1%5Cu05e8%5Cu05d5%5Cu05ea%22%2C%20%22%5Cu05d7%5Cu05e9%5Cu05d1%5Cu05d5%5Cu05df%20%5Cu05d3%5Cu05d9%5Cu05e4%5Cu05e8%5Cu05e0%5Cu05e6%5Cu05d9%5Cu05d0%5Cu05dc%5Cu05d9%22%5D%2C%20%22datasets%22%3A%20%5B%7B%22label%22%3A%20%22%5Cu05de%5Cu05d9%5Cu05d5%5Cu05de%5Cu05e0%5Cu05d5%5Cu05d9%5Cu05d5%5Cu05ea%22%2C%20%22data%22%3A%20%5B85%2C%2090%2C%2060%2C%20100%2C%2040%5D%2C%20%22backgroundColor%22%3A%20%22rgba%2859%2C%20130%2C%20246%2C%200.2%29%22%2C%20%22borderColor%22%3A%20%22rgba%2859%2C%20130%2C%20246%2C%201%29%22%2C%20%22pointBackgroundColor%22%3A%20%22rgba%2859%2C%20130%2C%20246%2C%201%29%22%2C%20%22pointBorderColor%22%3A%20%22%23fff%22%2C%20%22pointHoverBackgroundColor%22%3A%20%22%23fff%22%2C%20%22pointHoverBorderColor%22%3A%20%22rgba%2859%2C%20130%2C%20246%2C%201%29%22%7D%5D%7D%2C%20%22options%22%3A%20%7B%22scale%22%3A%20%7B%22ticks%22%3A%20%7B%22beginAtZero%22%3A%20true%2C%20%22max%22%3A%20100%2C%20%22stepSize%22%3A%2020%7D%2C%20%22pointLabels%22%3A%20%7B%22fontSize%22%3A%2014%2C%20%22fontFamily%22%3A%20%22sans-serif%22%7D%7D%2C%20%22legend%22%3A%20%7B%22display%22%3A%20false%7D%7D%7D" alt="Radar Chart">
-            </div>
-
-            <div class="skills-list">
-                <h2>פירוט נושאים</h2>
-                
-                <div class="skill-item">
-                    <div class="skill-header">
-                        <span class="skill-name">אלגברה</span>
-                        <span class="skill-score">85%</span>
-                    </div>
-                    <div class="progress-bar">
-                        <div class="progress-fill" style="width: 85%;"></div>
-                    </div>
-                    <div class="sub-skills">
-                        <strong>תתי-נושאים שטופלו:</strong> משוואות ממעלה ראשונה, חוקי חזקות
-                    </div>
-                </div>
-                
-                <div class="skill-item">
-                    <div class="skill-header">
-                        <span class="skill-name">גיאומטריה</span>
-                        <span class="skill-score">90%</span>
-                    </div>
-                    <div class="progress-bar">
-                        <div class="progress-fill" style="width: 90%;"></div>
-                    </div>
-                    <div class="sub-skills">
-                        <strong>תתי-נושאים שטופלו:</strong> חפיפת משולשים
-                    </div>
-                </div>
-                
-            </div>
-        </div>
-
-        
-        <div class="notes-section" style="margin-bottom: 30px;">
-            <h2>נקודות לשימור ולחיזוק 💡</h2>
-            
-            <div class="note-item">התלמיד גילה הבנה טובה בבידוד משתנים</div>
-            
-            <div class="note-item">שליטה מעולה בחוקי חזקות!</div>
-            
-        </div>
-        
-
-        
-        <div class="notes-section" style="background: #f0fdfa; border-color: #ccfbf1;">
-            <h2 style="color: #0d9488;">מטרה לשבוע הבא 🎯</h2>
-            <div class="note-item" style="color: #115e59;">חזרה על נוסחאות הכפל המקוצר לשיפור הדיוק האלגברי.</div>
-        </div>
-        
-
-        <div class="footer">
-            <p>הופק על ידי מערכת הבינה המלאכותית של מורה באדי | BuddyMath</p>
-        </div>
-    </div>
-</body>
-</html>
\ No newline at end of file
diff --git a/smart_solver.py b/smart_solver.py
deleted file mode 100644
index 06f5193c5e465588da59d818d437da58f345e036..0000000000000000000000000000000000000000
--- a/smart_solver.py
+++ /dev/null
@@ -1,714 +0,0 @@
-# smart_solver.py - V7.4 (TYPED SIGNED STEPS + DOMAIN-AWARE CONTRACTS)
-import re
-import hashlib
-import logging
-import sympy
-from sympy import symbols, Eq, solve, sympify, diff, latex, Symbol, simplify, trigsimp
-from sympy import srepr, default_sort_key
-from pydantic import BaseModel, Field
-from typing import List, Dict, Any, Tuple, Union, Optional
-from dataclasses import dataclass
-import copy
-from domain.step_types import StepType, SignedStep
-
-from utils.math_utils import aggressive_sympy_sanitizer
-
-logger = logging.getLogger(__name__)
-
-# ==================== V7.3: TYPED ACTION CONTRACT ====================
-
-@dataclass
-class ActionContext:
-    """
-    V7.3: Typed contract between Orchestrator and Solver.
-    Replaces generic dict — unknown fields cause AttributeError, not silent bugs.
-    Add new fields here as the system learns new problem types.
-    """
-    center: Optional[Tuple[float, float]] = None
-    radius: Optional[float] = None
-    point_a: Optional[Tuple[float, float]] = None
-    # Future: triangle_vertices, line_coefficients, etc.
-
-
-# ==================== V7.2: DETERMINISTIC SIGNATURE ENGINE ====================
-
-def sign_step(expression: Union[str, list], problem_id: str, step_id: str) -> SignedStep:
-    """
-    V7.4: Creates a SHA256-signed algebraic step as a typed SignedStep.
-    Uses sympy.srepr for canonical representation to guarantee deterministic hashing.
-    Sorts list results to ensure hash stability regardless of SymPy output order.
-
-    step_type = ALGEBRAIC — ConsistencyGate will validate via sympy.sympify.
-    payload   = raw expression list or string (semantic truth for validator).
-    expression = display string injected into renderer placeholders.
-    """
-    if isinstance(expression, list):
-        # Sort for canonical order (critical for hash determinism)
-        parsed_exprs = sorted(
-            [sympy.sympify(e) for e in expression],
-            key=default_sort_key
-        )
-        canonical = str([srepr(e) for e in parsed_exprs])
-        expr_str = " OR ".join(str(e) for e in parsed_exprs)
-        payload = [str(e) for e in parsed_exprs]
-    else:
-        parsed = sympy.sympify(expression)
-        canonical = srepr(parsed)
-        expr_str = str(parsed)
-        payload = expr_str
-
-    raw = f"{canonical}{problem_id}{step_id}"
-    sig = hashlib.sha256(raw.encode()).hexdigest()
-
-    logger.info(f"[SIGNATURE] Signed step '{step_id}': hash={sig[:12]}...")
-    return SignedStep(
-        id=step_id,
-        expression=expr_str,
-        payload=payload,
-        step_type=StepType.ALGEBRAIC,
-        hash=sig,
-    )
-
-
-def sign_step_geometry(labels: list, problem_id: str, step_id: str) -> SignedStep:
-    """
-    V7.4: Typed signer for geometry results (strings, not SymPy expressions).
-
-    step_type = GEOMETRY — ConsistencyGate validates structurally, NOT via sympify.
-    payload   = original labels list (semantic truth: list[str] of points/distances).
-    expression = display string for renderer injection (pipe-separated, human-readable).
-
-    CTO note: expression is display-only. payload is the authoritative structure
-    the validator uses to verify integrity. Never pass expression to sympy.
-    """
-    canonical = str(sorted(str(l) for l in labels))
-    sig = hashlib.sha256(f"{canonical}{problem_id}{step_id}".encode()).hexdigest()
-    expr_str = " | ".join(str(l) for l in labels)
-    logger.info(f"[SIGNATURE] Signed geometry step '{step_id}': hash={sig[:12]}...")
-    return SignedStep(
-        id=step_id,
-        expression=expr_str,
-        payload=list(labels),
-        step_type=StepType.GEOMETRY,
-        hash=sig,
-    )
-
-
-def resolve_ast_target(target_step_ref: str, ast_registry: dict) -> str:
-    """
-    V7.2: Looks up the actual math expression for an AST node ID.
-    The Planner works with IDs only — this is where IDs are resolved to real math.
-    Raises KeyError if the reference is invalid, preventing silent hallucination.
-    """
-    if target_step_ref not in ast_registry:
-        raise KeyError(
-            f"[RESOLVER] AST node '{target_step_ref}' not found in registry. "
-            f"Known nodes: {list(ast_registry.keys())}"
-        )
-    return ast_registry[target_step_ref]
-
-
-# ==================== V7.2.1: DETERMINISTIC SOLVER DISPATCHER ====================
-
-def execute_action(
-    action: str,
-    expression: str,
-    problem_id: str,
-    step_id: str,
-    ast_variables: list = None,
-    context: Optional[ActionContext] = None
-) -> dict:
-    """
-    V7.2.1 Wall 2: Deterministic Math Engine.
-
-    Routes a Planner Enum command to SymPy, executes it deterministically,
-    and returns a SHA256-signed step result.
-
-    Multi-variable handling (CTO note): if the expression has multiple free
-    symbols, we solve for the first variable listed in `ast_variables` (from
-    AST metadata). If no list is provided, we default to the first free symbol
-    found by SymPy — never guess blindly.
-
-    Args:
-        action:        One of ComputeAction enum values (string)
-        expression:    Raw math expression string from AST registry
-        problem_id:    For hash seeding
-        step_id:       For hash seeding and tracking
-        ast_variables: Ordered list of variable names from build_ast_metadata()
-
-    Returns:
-        dict: {"id": step_id, "hash": "sha256...", "expression": "..."}
-    """
-    import sympy as sp
-
-    # Parse expression — treat '=' as LHS - RHS for sp.solve
-    normalized = expression.replace('=', '-')
-    try:
-        expr = sp.sympify(normalized, evaluate=False)
-    except Exception as e:
-        raise ValueError(f"[SOLVER] Cannot parse expression '{expression}': {e}")
-
-    # Multi-variable: determine which symbol to solve for
-    free_syms = list(expr.free_symbols)
-    solve_for = None
-    if action == "SOLVE_EQUATION":
-        if ast_variables:
-            # Use the first AST-declared variable that is actually in the expression
-            for var_name in ast_variables:
-                candidate = sp.Symbol(var_name)
-                if candidate in free_syms:
-                    solve_for = candidate
-                    break
-        if solve_for is None and free_syms:
-            # Fallback: first free symbol (alphabetically for determinism)
-            solve_for = sorted(free_syms, key=lambda s: s.name)[0]
-            logger.warning(
-                f"[SOLVER] No ast_variables hint provided. "
-                f"Solving for '{solve_for}' (first free symbol in expression)."
-            )
-
-    # ── V7.3: Geometry Guards ──────────────────────────────────────────────────
-    if action == "CALCULATE_DISTANCE" and (
-        not context or not context.center or not context.point_a
-    ):
-        raise ValueError(
-            "MissingContextError: CALCULATE_DISTANCE requires context.center and context.point_a"
-        )
-
-    if action == "CALCULATE_SLOPE_AND_LINE" and (
-        not context or not context.center or not context.point_a
-    ):
-        raise ValueError(
-            "MissingContextError: CALCULATE_SLOPE_AND_LINE requires context.center and context.point_a"
-        )
-
-    # ── V7.3: Geometry Handler Dispatch ───────────────────────────────────────
-    if action == "FIND_AXIS_INTERSECTIONS":
-        # Substitute x=0 → solve for y, then y=0 → solve for x
-        x_sym, y_sym = sp.Symbol('x'), sp.Symbol('y')
-        y_intercepts = sp.solve(expr.subs(x_sym, 0), y_sym)
-        x_intercepts = sp.solve(expr.subs(y_sym, 0), x_sym)
-        # Build human-readable result list
-        result_parts = []
-        for yi in y_intercepts:
-            result_parts.append(f"(0, {yi})")  # x=0
-        for xi in x_intercepts:
-            result_parts.append(f"({xi}, 0)")  # y=0
-        result = result_parts if result_parts else ["אין נקודות חיתוך עם הצירים"]
-        logger.info(f"[SOLVER] ✅ FIND_AXIS_INTERSECTIONS on '{expression}' → {result}")
-        return sign_step_geometry(result, problem_id, step_id)
-
-    elif action == "CALCULATE_SLOPE_AND_LINE":
-        cx, cy = context.center           # e.g. (3, 4)
-        px, py = context.point_a         # e.g. (0, 0) — origin
-        # Vertical line guard
-        if px == cx:
-            line_eq = f"x = {cx}"
-            result = [line_eq]
-        else:
-            slope = sp.Rational(cy - py, cx - px)  # exact fraction (no float)
-            # y - py = slope*(x - px)  →  y = slope*x + b
-            b = py - slope * px
-            x_sym = sp.Symbol('x')
-            line_expr = slope * x_sym + b
-            # Simplify and return LaTeX-friendly string
-            result = [str(sp.simplify(line_expr))]
-        logger.info(f"[SOLVER] ✅ CALCULATE_SLOPE_AND_LINE center={context.center} → {result}")
-        return sign_step_geometry(result, problem_id, step_id)
-
-    elif action == "CALCULATE_DISTANCE":
-        cx, cy = context.center
-        px, py = context.point_a
-        # Use exact Rational arithmetic to avoid float comparison ambiguity
-        cx_r, cy_r = sp.Rational(cx).limit_denominator(1000), sp.Rational(cy).limit_denominator(1000)
-        px_r, py_r = sp.Rational(px).limit_denominator(1000), sp.Rational(py).limit_denominator(1000)
-        dist = sp.sqrt((px_r - cx_r)**2 + (py_r - cy_r)**2)
-        dist_val = sp.simplify(dist)       # SymPy exact value (e.g. 5)
-        radius_sym = sp.Rational(context.radius).limit_denominator(1000)
-
-        # 🚨 [SOP FIX] Guard against NoneType before float cast
-        for val in [dist_val, radius_sym]:
-            if val is None or val == "null" or val == "":
-                raise ValueError("Missing required mathematical argument from LLM. Cannot cast None to float.")
-
-        # Comparison via Python float (avoids SymPy Float vs int ambiguity)
-        dist_float = float(dist_val)
-        radius_float = float(radius_sym)
-        if abs(dist_float - radius_float) < 1e-9:
-            on_circle = "על המעגל"
-        elif dist_float < radius_float:
-            on_circle = "בתוך המעגל"
-        else:
-            on_circle = "מחוץ למעגל"
-        result = [f"d = {dist_val}", f"r = {context.radius}", on_circle]
-        logger.info(f"[SOLVER] ✅ CALCULATE_DISTANCE point={context.point_a} center={context.center} → {result}")
-        return sign_step_geometry(result, problem_id, step_id)
-
-    # ── Legacy Algebraic Action Dispatch ──────────────────────────────────────
-    ACTION_MAP = {
-        "SOLVE_EQUATION":  lambda e: sp.solve(e, solve_for) if solve_for else sp.solve(e),
-        "SIMPLIFY":        lambda e: [sp.simplify(e)],
-        "FACTOR":          lambda e: [sp.factor(e)],
-        "EXPAND":          lambda e: [sp.expand(e)],
-        "FIND_DERIVATIVE": lambda e: [sp.diff(e, solve_for or (free_syms[0] if free_syms else sp.Symbol('x')))],
-        "FIND_INTEGRAL":   lambda e: [sp.integrate(e, solve_for or (free_syms[0] if free_syms else sp.Symbol('x')))],
-        "SUBSTITUTE":      lambda e: [e],
-    }
-
-    fn = ACTION_MAP.get(action)
-    if not fn:
-        raise ValueError(f"[SOLVER] Unknown action: '{action}'. Check ComputeAction enum.")
-
-    try:
-        result = fn(expr)
-        if not isinstance(result, list):
-            result = [result]
-        logger.info(f"[SOLVER] ✅ {action} on '{expression}' → {result}")
-    except Exception as e:
-        raise RuntimeError(f"[SOLVER] SymPy failed on action '{action}': {e}")
-
-    return sign_step(result, problem_id, step_id)
-
-
-
-
-class MathState(BaseModel):
-    """ייצוג מתמטי אחיד של מצב הבעיה"""
-    equations: List[Any] = Field(default_factory=list) # רשימת משוואות SymPy
-    solved_vars: Dict[Any, Any] = Field(default_factory=dict) # משתנים שנפתרו
-    original_text: str = ""
-    
-    class Config:
-        arbitrary_types_allowed = True
-        
-    def is_solved(self) -> bool:
-        # במערכת משוואות MVP: אם יש משתנים פתורים ואין עוד משוואות בלתי פתורות רלוונטיות
-        if not self.equations:
-            return len(self.solved_vars) > 0
-        all_syms = set()
-        for eq in self.equations:
-            all_syms.update(eq.free_symbols)
-        # נפתר אם כל המשתנים מקבלים ערך
-        return len(all_syms) > 0 and all(sym in self.solved_vars for sym in all_syms)
-
-# ==================== V5.8.0 RULE ENGINE MVP ====================
-
-class MathRule:
-    name: str = "BaseRule"
-    
-    def is_applicable(self, state: MathState) -> bool:
-        return False
-        
-    def apply(self, state: MathState) -> Tuple[MathState, Any]:
-        raise NotImplementedError()
-
-class RuleSolveLinearSystem(MathRule):
-    name = "פתרון מערכת משוואות"
-    
-    def __init__(self):
-        self.x, self.y = symbols('x y')
-        
-    def is_applicable(self, state: MathState) -> bool:
-        # נזהה מערכת של 2 משוואות עם 2 נעלמים חופשיים
-        if len(state.equations) >= 2:
-            syms = set()
-            for eq in state.equations:
-                syms.update(eq.free_symbols)
-            if len(syms) == 2:
-                return True
-        return False
-        
-    def apply(self, state: MathState) -> Tuple[MathState, Any]:
-        new_state = copy.copy(state)
-        # ניסיון פתרון סימבולי למערכת המשוואות יחד
-        eq1 = state.equations[0]
-        eq2 = state.equations[1]
-        
-        # V5.8.1: Detailed Steps Mode (Step Granularity)
-        # Check if both equations are of the form "sym = expression" and have the same LHS
-        if eq1.lhs == eq2.lhs and isinstance(eq1.lhs, Symbol):
-            lhs_sym = eq1.lhs
-            # Get the other symbol playing the role of x
-            rhs_syms = list((eq1.rhs.free_symbols | eq2.rhs.free_symbols) - {lhs_sym})
-            if len(rhs_syms) == 1:
-                rhs_sym = rhs_syms[0]
-                steps = []
-                
-                # 1. Equate
-                eq_step = Eq(eq1.rhs, eq2.rhs)
-                steps.append({"logic": "נשווה בין שתי המשוואות", "math": latex(eq_step), "rule_id": "solve_linear_system"})
-                
-                # 2. Collect terms
-                diff_expr = eq_step.lhs - eq_step.rhs
-                c = diff_expr.coeff(rhs_sym)
-                d = diff_expr.subs(rhs_sym, 0)
-                collected_eq = Eq(c * rhs_sym, -d)
-                steps.append({"logic": "נעביר אגפים ונכנס איברים דומים", "math": latex(collected_eq), "rule_id": "solve_linear_system"})
-                
-                # 3. Isolate variable
-                x_val = -d / c
-                isolated_eq = Eq(rhs_sym, x_val)
-                steps.append({"logic": f"נחלק במקדם של {latex(rhs_sym)}", "math": latex(isolated_eq), "rule_id": "solve_linear_system"})
-                
-                # 4. Substitute back
-                y_val = eq1.rhs.subs(rhs_sym, x_val)
-                # string replacement for substitution display to avoid auto-evaluation collapsing it
-                subs_str = latex(eq1.rhs).replace(latex(rhs_sym), f"({latex(x_val)})")
-                steps.append({"logic": f"נציב את {latex(rhs_sym)} באחת המשוואות", "math": f"{latex(lhs_sym)} = {subs_str} = {latex(y_val)}", "rule_id": "solve_linear_system"})
-                
-                new_state.solved_vars[rhs_sym] = x_val
-                new_state.solved_vars[lhs_sym] = y_val
-                new_state.equations = []
-                return new_state, steps
-
-        # V5.8.3 The Ultimate Guard: No step breakdown -> No solve
-        return state, "לא ניתן לפרק לצעדים מדורגים."
-
-class RuleIsolateVariable(MathRule):
-    name = "בידוד משתנה"
-    def is_applicable(self, state: MathState) -> bool:
-        # האם יש משוואה אחת שניתן לבודד ממנה משתנה שעדיין לא בודד?
-        if len(state.equations) == 1:
-            return True
-        return False
-        
-    def apply(self, state: MathState) -> Tuple[MathState, Any]:
-        new_state = copy.copy(state)
-        eq = state.equations[0]
-        syms = list(eq.free_symbols)
-        if not syms: return state, "אין משתנים לבידוד."
-        # ננסה לבודד את המשתנה (למשל x)
-        sol = solve(eq, syms[0])
-        if sol:
-            new_state.solved_vars[syms[0]] = sol[0]
-            new_state.equations = []
-            steps = [{"logic": "נבודד את המשתנה", "math": f"{latex(syms[0])} = {latex(sol[0])}", "rule_id": "isolate_variable"}]
-            return new_state, steps
-        return state, "לא ניתן לבודד משתנה"
-
-class RuleSubstitute(MathRule):
-    name = "הצבת משתנה שבודד"
-    def is_applicable(self, state: MathState) -> bool:
-        return len(state.solved_vars) > 0 and len(state.equations) > 0
-        
-    def apply(self, state: MathState) -> Tuple[MathState, Any]:
-        new_state = copy.copy(state)
-        # נציב את כל המשתנים הידועים בתוך המשוואות שנותרו
-        new_eqs = []
-        for eq in state.equations:
-            new_eq = eq.subs(state.solved_vars)
-            new_eqs.append(new_eq)
-        new_state.equations = new_eqs
-        # אנחנו לא מוחקים את state.solved_vars כי נרצה לזכור אותם להמשך
-        str_vars = ", ".join([f"{latex(k)} = {latex(v)}" for k,v in state.solved_vars.items()])
-        steps = [{"logic": "נציב את הערכים הידועים במשוואות", "math": str_vars, "rule_id": "substitute"}]
-        return new_state, steps
-
-
-class StepValidator:
-    """
-    V6.1 Phase 3: Validation Authority
-    Acts as the 'Supreme Court' for LLM proposed ProofGraphs.
-    """
-    
-    ALLOWED_CONSTANTS = {'pi', 'E', 'sqrt(2)'} # Removed 'I' as per QA Gate requirements.
-    
-    @classmethod
-    def sympy_simplify_tolerance_guard(cls, expr_n, expr_n_plus_1) -> bool:
-        """
-        V6.1 Phase 4: Tolerance Guard
-        Numerical evaluation fallback to handle micro-variances that avoid simplification.
-        """
-        import random
-        try:
-            diff_expr = expr_n - expr_n_plus_1
-            free_syms = diff_expr.free_symbols
-            
-            # If no free symbols, just evaluate numerically
-            if not free_syms:
-                val = diff_expr.evalf()
-                # 🚨 [SOP FIX] Guard against NoneType before float cast
-                if val is None or val == "null" or val == "":
-                    raise ValueError("Missing required mathematical argument from LLM. Cannot cast None to float.")
-                return abs(float(val)) < 1e-9
-            
-            # Sampling: 10 random points
-            for _ in range(10):
-                subs = {s: random.uniform(0.1, 10.0) for s in free_syms}
-                val = diff_expr.evalf(subs=subs)
-                # 🚨 [SOP FIX] Guard against NoneType before float cast
-                if val is None or val == "null" or val == "":
-                    raise ValueError("Missing required mathematical argument from LLM. Cannot cast None to float.")
-                if abs(float(val)) > 1e-9: # Precision set to 10^-9 as per QA Gate
-                    return False
-            return True
-        except Exception:
-            return False
-
-    @classmethod
-    def validate_transition(cls, step_n: str, step_n_plus_1: str) -> bool:
-        """
-        Deterministically verifies the algebraic equivalence between two steps.
-        """
-        try:
-            # V9.0.1: Aggressive sanitization before comparison
-            # We take the first expression from the sanitizer if multiple are returned
-            parts_n = aggressive_sympy_sanitizer(str(step_n))
-            parts_n_plus_1 = aggressive_sympy_sanitizer(str(step_n_plus_1))
-            
-            if not parts_n or not parts_n_plus_1:
-                return False
-                
-            clean_n = parts_n[0].replace('=', '-')
-            clean_n_plus_1 = parts_n_plus_1[0].replace('=', '-')
-
-            expr_n = sympify(clean_n, evaluate=False)
-            expr_n_plus_1 = sympify(clean_n_plus_1, evaluate=False)
-            
-            # Use simplify to check equivalence
-            diff = simplify(expr_n - expr_n_plus_1)
-            
-            if diff == 0:
-                return True
-                
-            # Fallback for trigonometric identities or complex simplification
-            if trigsimp(expr_n) == trigsimp(expr_n_plus_1):
-                 return True
-                 
-            # V6.1 Phase 4: Tolerance Guard (Secondary Check)
-            if cls.sympy_simplify_tolerance_guard(expr_n, expr_n_plus_1):
-                logger.info(f"🛡️ [VALIDATOR] Tolerance Guard PASSED for {step_n} -> {step_n_plus_1}")
-                return True
-
-            # If equivalence fails, it might be an irreversible action (e.g. squaring).
-            return False
-            
-        except Exception as e:
-            logger.warning(f"[VALIDATOR] Transition validation error '{step_n}' -> '{step_n_plus_1}': {e}")
-            return False
-
-    @classmethod
-    def check_proofgraph_closure(cls, initial_math: str, final_step: str) -> bool:
-        """
-        Ensures all variables in the original problem are resolved or accounted for,
-        and no hallucinations occurred via injected fake constants/variables.
-        """
-        try:
-            # V9.0.1: Aggressive sanitization
-            initial_parts = aggressive_sympy_sanitizer(str(initial_math))
-            initial_exprs = [sympify(str(p).replace('=', '-'), evaluate=False) for p in initial_parts]
-            initial_vars = set()
-            for ex in initial_exprs:
-                initial_vars.update(ex.free_symbols)
-                
-            final_parts = aggressive_sympy_sanitizer(str(final_step))
-            final_exprs = [sympify(str(p).replace('=', '-'), evaluate=False) for p in final_parts]
-            final_vars = set()
-            for ex in final_exprs:
-                final_vars.update(ex.free_symbols)
-                
-            filtered_final_vars = {str(v) for v in final_vars if not v.is_number and str(v) not in cls.ALLOWED_CONSTANTS}
-            filtered_initial_vars = {str(v) for v in initial_vars if not v.is_number and str(v) not in cls.ALLOWED_CONSTANTS}
-            
-            if len(filtered_final_vars - filtered_initial_vars) > 0:
-                logger.warning(f"[VALIDATOR] Closure check failed. Leaked vars: {filtered_final_vars - filtered_initial_vars}")
-                return False
-                
-            return True
-        except Exception as e:
-            logger.warning(f"[VALIDATOR] Closure validation error: {e}")
-            return False
-            
-    @classmethod
-    def evaluate_proposal(cls, initial_math: str, draft_steps: list) -> tuple[float, str]:
-        """
-        Evaluates the entire Draft ProofGraph.
-        Returns (Validation Score [0.0 - 1.0], Error Reason)
-        """
-        if not draft_steps:
-             return 0.0, "EMPTY_DRAFT"
-             
-        valid_transitions = 0
-        total_transitions = len(draft_steps)
-        
-        # We assume step 0 is the initial math or a reformatted version of it.
-        # We validate transition from step[i] to step[i+1]
-        for i in range(len(draft_steps) - 1):
-            math_n = draft_steps[i].get('math', '')
-            math_n_plus_1 = draft_steps[i+1].get('math', '')
-            
-            if cls.validate_transition(math_n, math_n_plus_1):
-                valid_transitions += 1
-            else:
-                 logger.warning(f"[VALIDATOR] Rejecting step {i+1} -> {i+2}: {math_n} to {math_n_plus_1}")
-                 return 0.0, f"מעבר מתמטי שגוי בין: {math_n} לבין {math_n_plus_1}"
-                 
-        score = valid_transitions / total_transitions if total_transitions > 0 else 0.0
-        
-        # Check Closure
-        final_step_math = draft_steps[-1].get('math', '')
-        if not cls.check_proofgraph_closure(initial_math, final_step_math):
-            return 0.0, "סגירת פתרון לא חוקית (נמצאו משתנים לא מאושרים)"
-            
-        return score, ""
-
-
-    def __init__(self, success=False, function=None, derivative=None, steps=None, operator_used=None):
-        self.success = success
-        self.function = function
-        self.derivative = derivative
-        self.steps = steps or [] # חובה עבור ה-ProofGraph
-        self.operator_used = operator_used
-
-class SmartSolver:
-    def __init__(self):
-        print("✅ 🟢 [BIT-LOG: SmartSolver V263.0] - Algebra Engine Active")
-
-    def solve(self, context):
-        math_input = context.math_input
-        category = context.category
-        original_text = getattr(context, 'original_text', "").lower()
-        grade_num = getattr(context, 'grade_num', 12)
-        
-        print(f"🔍 [BIT-LOG: SOLVER] Analyzing input: '{math_input}'")
-        print(f"🔍 [BIT-LOG: SOLVER] Category: {category}, Intent Text: '{original_text[:50]}...'")
-
-        # --- V5.8.0 Rule Engine MVP (Always First) ---
-        print("🔢 [BIT-LOG: SOLVER] Triggering Rule Engine MVP")
-        rule_engine_res = self._solve_linear_system(math_input)
-        if rule_engine_res and rule_engine_res.success:
-            return rule_engine_res
-
-        # --- ענף 2: חקירת פונקציות (כיתה י' עד י"ב) ---
-        # V4.2.12: Anchor regex to start of string to avoid matching 4x + 5y = 120 as 'y = 120'
-        is_explicit_func = bool(re.match(r'^(f\(x\)|y|g\(x\))\s*=', math_input, re.IGNORECASE))
-        investigation_keywords = ["חקור", "חקירת", "קיצון", "אסימפטוט", "נגזרת", "עליה", "ירידה"]
-        has_intent = any(kw in original_text for kw in investigation_keywords)
-
-        # הנגזרת תופעל רק אם: זו חקירה + יש פונקציה מפורשת + יש כוונה בטקסט
-        should_derive = (category == "INVESTIGATION" and is_explicit_func and has_intent and grade_num > 7)
-
-        if should_derive:
-            print("📈 [BIT-LOG: SOLVER] Triggering Calculus Engine (Derivatives)")
-            return self._solve_calculus(math_input)
-
-        # Fallback גנרי
-        print(f"🛡️ [BIT-LOG: SOLVER] Generic Algebra Mode. category={category}, intent={has_intent}")
-        return SmartResult(success=True, function=math_input, operator_used="ALGEBRA_GENERAL")
-
-    def _solve_linear_system(self, raw_input):
-        """V5.8.0: מנוע קבלת החלטות מבוסס MVP חוקים"""
-        try:
-            # שלב 1: Parsing
-            eq_parts = re.split(r'[,\n]', raw_input)
-            parsed_eqs = []
-            for part in eq_parts:
-                if '=' in part:
-                    s_a, s_b = part.split('=')
-                    parsed_eqs.append(Eq(sympify(self._sanitize(s_a)), sympify(self._sanitize(s_b))))
-            
-            if not parsed_eqs:
-                return SmartResult(success=False)
-
-            current_state = MathState(equations=parsed_eqs, original_text=raw_input)
-            rules = [RuleSolveLinearSystem(), RuleIsolateVariable(), RuleSubstitute()]
-            proof_graph_steps = []
-            iteration = 0
-            MAX_ITER = 5
-
-            logger.info(f"🧮 [RULE-ENGINE] Starting resolution for system: {parsed_eqs}")
-
-            # שלב 2: לולאת החוקים הארכיטקטונית (The Engine)
-            while not current_state.is_solved() and iteration < MAX_ITER:
-                applied_any = False
-                for rule in rules:
-                    if rule.is_applicable(current_state):
-                        new_state, step_data = rule.apply(current_state)
-                        if isinstance(step_data, list):
-                            for s in step_data:
-                                proof_graph_steps.append({
-                                    "id": len(proof_graph_steps) + 1,
-                                    "logic": s["logic"],
-                                    "math": s["math"]
-                                })
-                        else:
-                            proof_graph_steps.append({
-                                "id": len(proof_graph_steps) + 1,
-                                "logic": rule.name,
-                                "math": step_data
-                            })
-                        current_state = new_state
-                        applied_any = True
-                        break # Start rules over with new state
-                
-                if not applied_any:
-                    logger.warning("🧮 [RULE-ENGINE] No applicable rules found to continue solving.")
-                    break
-                
-                iteration += 1
-
-            # יצירת מודל SmartResult עם הוכחה מבוססת חוקים
-            if current_state.is_solved():
-                print(f"✅ [RULE-ENGINE] Resolved system to state: {current_state.solved_vars}")
-                # הוספת צעד סיכום אחרון
-                res_str = ", ".join([f"{latex(k)}={latex(v)}" for k,v in current_state.solved_vars.items()])
-                
-                return SmartResult(success=True, function=raw_input, steps=proof_graph_steps, operator_used="RULE_ENGINE_SYSTEM")
-            else:
-                 return SmartResult(success=False)
-                 
-        except Exception as e:
-            print(f"❌ [BIT-LOG: SOLVER] Algebra Rule Engine Error: {e}")
-            return SmartResult(success=False)
-
-    def _solve_calculus(self, math_input):
-        try:
-            x = symbols('x')
-            # חילוץ הביטוי אחרי ה- '='
-            expr_part = math_input.split('=')[-1]
-            expr_str = self._sanitize(expr_part)
-            logger.info(f"🧮 [TRACE] EXPRESSION SENT TO SYMPY: {expr_str}")
-            expr = sympify(expr_str)
-            f_prime = diff(expr, x)
-            
-            # חישוב נקודות קיצון
-            crit_points = []
-            try:
-                sols = solve(f_prime, x)
-                for s in sols:
-                    if s is not None and s.is_real:
-                        y_val = expr.subs(x, s).evalf()
-                        if y_val is not None:
-                            crit_points.append(f"({float(s):.2f}, {float(y_val):.2f})")
-            except Exception as e: 
-                logger.warning(f"[SOLVER] Calculus point evaluation failed: {e}")
-
-            steps = [{"id": 1, "math": f"f'(x)={latex(f_prime)}", "logic": "חישוב נגזרת"}]
-            return SmartResult(
-                success=True, 
-                function=f"f(x)={latex(expr)}", 
-                derivative=f"f'(x)={latex(f_prime)}", 
-                steps=steps, 
-                operator_used="DERIVATIVE"
-            )
-        except Exception as e:
-            print(f"❌ [BIT-LOG: SOLVER] Calculus Engine Error: {e}")
-            return SmartResult(success=False)
-
-    def _sanitize(self, text):
-        """✅ סנכרון עם מנגנון הניקוי המרכזי (V260.0)"""
-        text = text.replace(r'\left', '').replace(r'\right', '')
-        while r'\frac' in text:
-            text = re.sub(r'\\frac\s*\{(.*?)\}\{(.*?)\}', r'(\1)/(\2)', text)
-        
-        text = re.sub(r'(sin|cos|tan)\s+([a-zA-Z0-9]+)', r'\1(\2)', text)
-        text = text.replace(r'\sin', 'sin').replace(r'\cos', 'cos').replace(r'\tan', 'tan')
-        text = text.replace('^', '**')
-        
-        # ✅ V260.0: Robust implicit multiplication
-        text = re.sub(r'(\d)([a-zA-Z(])', r'\1*\2', text)
-        text = re.sub(r'\)([a-zA-Z0-9(])', r')*\1', text)
-        text = re.sub(r'(?<![a-zA-Z])([a-zA-Z])\(', r'\1*(', text)
-        
-        allowed = "0123456789+-*/().=xsincoabslpqrtABSpi eylog" 
-        return ''.join(c for c in text if c.lower() in allowed).strip()
\ No newline at end of file
diff --git a/strategy_manager.py b/strategy_manager.py
deleted file mode 100644
index 36be6503d4499aa3efcded58abfaf7875dd42358..0000000000000000000000000000000000000000
--- a/strategy_manager.py
+++ /dev/null
@@ -1,222 +0,0 @@
-import topic_taxonomy
-import micro_prompts
-import validators
-import asyncio
-import json
-import cost_tracker
-import re
-import logging
-from utils.safe_json import safe_extract_json  # V1.0: Canonical extractor (replaces local duplicate)
-import prompts
-
-logger = logging.getLogger(__name__)
-
-
-class StrategyManager:
-    def __init__(self, llm_model):
-        self.llm = llm_model
-        self.max_retries = 2
-    
-    async def solve_with_strategy(self, problem_text, data_anchor, grade="10", image_data=None, image_data_list=None, parent_category=None, ambiguity_warning=False, intent=None, intent_contract=None, proof_graph_steps_count=1, student_name="נסיך", student_gender="M"):
-        """
-        V3.1.2: Added support for adaptive failure (Soft Recovery).
-        V5.8.2: Dynamic Token Budget added via proof_graph_steps_count.
-        """
-        self.grade = grade # V4.2.11: Persist grade for prompt building
-        topic_id = topic_taxonomy.detect_topic(problem_text, grade)
-        detected_category = topic_taxonomy.get_topic_category(topic_id)
-        category = detected_category if detected_category != "GENERAL" else (parent_category or "GENERAL")
-        
-        image_pages = []
-        if image_data_list:
-            # Multi-image support
-            for i_data in image_data_list:
-                image_pages.append({"mime_type": "image/jpeg", "data": i_data})
-        elif image_data:
-            try:
-                from ocr_strip_engine import paginate_image
-                image_pages = paginate_image(image_data)
-            except Exception as e: 
-                logger.exception("CRITICAL FLOW ERROR")
-                logger.error(f"Pagination failed: {e}")
-        
-        # V4.3: Single Pass (No Retries)
-        try:
-            strategy_config = self._get_strategy(topic_id)
-            prompt = self._build_prompt(topic_id, data_anchor, strategy_config, problem_text, category, grade, student_name, student_gender)
-            
-            # V4.2 Intent Lockdown (Iron Law #2)
-            if intent_contract and intent_contract.get("status") != "unconstrained":
-                lockdown_note = f"""
-📢 [V4.2] PEDAGOGICAL LOCKDOWN:
-- Intent: {intent}
-- Max Variables: {intent_contract.get('max_variables', 'N/A')}
-- Forbidden: {", ".join(intent_contract.get('forbidden_strategies', []))}
-- REQUIRED: Use ONLY basic algebraic steps. DO NOT use advanced functions or calculus.
-"""
-                prompt = lockdown_note + "\n" + prompt
-            # V281.1: HARD OCR DISCONNECT
-            # If we have image data, DO NOT inject the OCR-based function equation.
-            # The LLM must rely on the Vision-First extracted Data Anchor and the image itself.
-            if data_anchor.get("function_equations") and not image_data and not image_data_list:
-                prompt = f"TARGET FUNCTION: {data_anchor['function_equations'][0]}\n\n" + prompt
-            
-            # V3.1.2: Soft Recovery Prompt Injection
-            if ambiguity_warning:
-                soft_recovery_note = """
-System Prompt Override: הוסף לתחילת ההסבר שלך את ההערה הבאה בנימה ידידותית: 'היי! הצילום היה קצת לא ברור, אבל נראה לי שהתכוונת לביטוי הזה. אם התכוונת למשהו אחר, פשוט צלם שוב מקרוב!' - המשך להסביר את השלבים כרגיל.
-"""
-                prompt = soft_recovery_note + "\n" + prompt
-
-            prompt = (prompt or "") + f"\n\n🎯 MISSION: Solve ONLY part: {problem_text}"
-            llm_response = await self._call_llm(prompt, image_data, category, image_pages, proof_graph_steps_count)
-            
-            # V5.8.2: Guard against raw list responses
-            if isinstance(llm_response, list):
-                llm_response = {"steps": llm_response, "is_valid": True, "confidence_score": 1.0}
-            
-            return {
-                "topic": topic_id,
-                "category": category,
-                "llm_response": llm_response,
-                "validated": llm_response.get("is_valid", True),
-                "confidence": llm_response.get("confidence_score", 1.0)
-            }
-        except asyncio.CancelledError:
-            logger.warning("V4.3 Single Pass Cancelled (Client Disconnected)")
-            return {
-                "topic": topic_id,
-                "category": category,
-                "llm_response": {"solution_markdown": "בוטל על ידי המשתמש", "is_valid": False, "confidence_score": 0.0},
-                "validated": False
-            }
-        except Exception as e:
-            logger.error(f"V4.3 Single Pass Failed: {e}")
-            return {
-                "topic": topic_id,
-                "category": category,
-                "llm_response": {"solution_markdown": "המורה נתקלה בקושי טכני.", "is_valid": False, "confidence_score": 0.0},
-                "validated": False
-            }
-
-    def _get_strategy(self, topic_id):
-        return {"has_micro_prompt": topic_id in micro_prompts.MICRO_PROMPTS, "has_validator": topic_id in validators.VALIDATORS}
-
-    def _build_prompt(self, topic_id, data_anchor, strategy_config, problem_text, category, grade, student_name, student_gender):
-        # V7.3 Hybrid Mode: Always use Specialist Prompt for the "Solution Skin"
-        specialist = prompts.get_specialist_prompt(
-            category=category,
-            problem_text=problem_text,
-            solver_hint="Hybrid Navigation Mode",
-            grade=grade,
-            student_name=student_name,
-            student_gender=student_gender,
-            data_anchor=data_anchor
-        )
-
-        if strategy_config["has_micro_prompt"]:
-            try: 
-                 focus = micro_prompts.get_micro_prompt(topic_id, data_anchor, grade=self.grade)
-                 return f"{focus}\n\n{specialist}"
-            except: 
-                 pass
-        
-        return specialist
-        return micro_prompts.get_general_prompt(data_anchor)
-
-    async def _call_llm(self, prompt, image_data, category, image_pages, proof_graph_steps_count=1):
-        # V8.5: No More Patchwork. Use centralized V4.3.0 standard.
-        v430_instruction = prompts.get_master_prompt_v430(category=category, problem_text=prompt)
-        prompt = (prompt or "") + (v430_instruction or "")
-        
-        from google.generativeai.types import GenerationConfig
-        import asyncio
-        
-        # V5.8.3: Pre-release Hardening (Increased Budget for Preamble)
-        # V8.6: Golden Merge - Increased to 8192 to support high-density Micro-Stepping
-        max_tokens = 8192
-        logger.info(f"🪙 [BUDGET] Dynamic Token Budget allocated: {max_tokens} tokens for {proof_graph_steps_count} steps.")
-        
-        gen_config = GenerationConfig(
-            temperature=0.0, 
-            top_p=0.1, 
-            top_k=1,
-            max_output_tokens=max_tokens,
-            response_mime_type="application/json"
-        )
-        
-        try:
-            if image_pages:
-                payload = [f"Images are sequential. Image 1 is Header.\n{prompt}"] + image_pages
-                logger.info(f"🧠 [TRACE] PROMPT SENT TO LLM: {payload[0]}")
-                # V8.5: True Async Cancellation. Using current_task to handle disconnects.
-                response = await asyncio.wait_for(
-                    self.llm.generate_content_async(payload, generation_config=gen_config), 
-                    timeout=60.0
-                )
-            else:
-                logger.info(f"🧠 [TRACE] PROMPT SENT TO LLM: {prompt}")
-                response = await asyncio.wait_for(
-                    self.llm.generate_content_async(prompt, generation_config=gen_config), 
-                    timeout=30.0
-                )
-        except asyncio.CancelledError:
-            # HARD STOP: Client disconnected. Active cancellation is handled by wait_for + generate_content_async
-            logger.warning("📉 [V8.5] LLM Call actively CANCELLED due to client disconnect.")
-            # Repropagate to allow parent orchestrator to catch it
-            raise
-        except Exception as e:
-            logger.error(f"Error in _call_llm generation: {e}")
-            raise
-
-        raw_text = response.text
-        logger.info(f"📦 [TRACE] RAW RESPONSE RECEIVED: {raw_text}")
-        
-        # V8.5.1: Convert UsageMetadata (Custom Class) to dict to avoid serialization error
-        usage = getattr(response, 'usage_metadata', None)
-        usage_dict = {}
-        if usage:
-            usage_dict = {
-                "prompt_token_count": getattr(usage, 'prompt_token_count', 0),
-                "candidates_token_count": getattr(usage, 'candidates_token_count', 0),
-                "total_token_count": getattr(usage, 'total_token_count', 0)
-            }
-            
-        parsed = self._parse_v4_json(raw_text)
-        return {**parsed, "usage_metadata": usage_dict}
-
-    def _parse_v4_json(self, raw_text):
-        # V4.7 → V1.0: Use canonical safe_extract_json (logs RAW, LaTeX shield, json_repair, fail-closed)
-        if "{" not in raw_text and "[" not in raw_text:
-            return {"solution_markdown": "שגיאת מבנה", "is_valid": False, "confidence_score": 0.1}
-        result = safe_extract_json(raw_text, caller="STRATEGY_MANAGER")
-        if isinstance(result, dict) and result.get("logic_error"):
-            return {"solution_markdown": "המורה נכשלה בפירוש הפתרון", "is_valid": False, "confidence_score": 0.1}
-        return result
-
-    def _validate(self, topic_id, llm_response, data_anchor): return {"valid": True, "error": None}
-
-    async def generate_raw(self, system_prompt: str, user_prompt: str) -> str:
-        """
-        V6.1: Direct raw LLM call for ProposalEngine. Unconstrained output.
-        """
-        from google.generativeai.types import GenerationConfig
-        import asyncio
-        
-        full_prompt = f"{system_prompt}\n\nUser Request: {user_prompt}"
-        
-        gen_config = GenerationConfig(
-            temperature=0.2, # Slight creativity needed to draft proofs, but still grounded
-            top_p=0.8,
-        )
-        
-        logger.info(f"🧠 [PROPOSAL-GATEWAY] Sending PROMPT to LLM.")
-        try:
-            response = await asyncio.wait_for(
-                asyncio.to_thread(self.llm.generate_content, full_prompt, generation_config=gen_config),
-                timeout=45.0
-            )
-            return getattr(response, 'text', '')
-        except Exception as e:
-            logger.error(f"❌ [PROPOSAL-GATEWAY] LLM Request failed: {e}")
-            raise e
diff --git a/strategy_policy_engine.py b/strategy_policy_engine.py
deleted file mode 100644
index 8f99896e72d6290598e76ef975bdbcd1d2493671..0000000000000000000000000000000000000000
--- a/strategy_policy_engine.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# strategy_policy_engine.py
-
-STRATEGY_MAP = {
-    "GEOMETRY_ANALYTIC": {
-        "allowed": ["algebraic_intersection", "distance_formula", "midpoint_calculation"],
-        "forbidden": ["differentiation", "calculus_modeling", "optimization"]
-    },
-    "SIMPLE_LINEAR_SOLVE": {
-        "allowed": ["single_variable_isolation", "basic_arithmetic"],
-        "forbidden": ["systems_of_equations", "substitution_method"]
-    },
-    "FUNCTION_ANALYSIS": {
-        "allowed": ["differentiation", "extrema_finding", "intercepts"],
-        "forbidden": ["integration"]
-    }
-}
-
-def get_allowed_strategies(intent):
-    """מחזיר וקטור אסטרטגיות מותרות לפי כוונת המשתמש"""
-    return STRATEGY_MAP.get(intent, {"allowed": ["GENERAL"], "forbidden": []})
diff --git a/student_limits.json b/student_limits.json
deleted file mode 100644
index 1310e01bee3dc65ca21fa9bb13cb1e87a4606acc..0000000000000000000000000000000000000000
--- a/student_limits.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-    "default_limit": 30,
-    "blocked_users": [],
-    "students": {
-        "test_student": 100,
-        "vlTppBQtqfRScaxWpBMbxWfVCrF2": -1,
-        "test_user_123": 42
-    }
-}
\ No newline at end of file
diff --git a/system_prompt.txt b/system_prompt.txt
deleted file mode 100644
index bf867ce72c8fb0a4e494e2a0e73c362063b34e7d..0000000000000000000000000000000000000000
--- a/system_prompt.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-You are a helpful math tutor for Hebrew speakers.
-
-STRICT OUTPUT RULES:
-1.  **Language:** Write explanations in natural, clear Hebrew.
-2.  **Math Formatting:** Any mathematical expression, equation, number, variable (x, y), or formula MUST be wrapped in double dollar signs ($$).
-    * Correct: "השיפוע הוא $$m=3$$."
-    * Incorrect: "השיפוע הוא m=3."
-3.  **No Hebrew inside Math:** Never put Hebrew text inside the $$ delimiters.
-4.  **Inline Only:** Do not use block formatting like \[ ... \]. Use $$...$$ for everything math-related.
-5.  **Structure:** Explain the solution step-by-step.
\ No newline at end of file
diff --git a/templates/payment.html b/templates/payment.html
deleted file mode 100644
index 4db3c0cdda4577a9016cd6fcbb7c795ef1de145e..0000000000000000000000000000000000000000
--- a/templates/payment.html
+++ /dev/null
@@ -1,89 +0,0 @@
-<!DOCTYPE html>
-<html lang="he" dir="rtl">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>המורה למתמטיקה | שדרוג לפרימיום</title>
-    <script src="https://cdn.tailwindcss.com"></script>
-    <link href="https://fonts.googleapis.com/css2?family=Assistant:wght@400;600;800&display=swap" rel="stylesheet">
-    <style>
-        body { font-family: 'Assistant', sans-serif; }
-    </style>
-</head>
-<body class="bg-gray-50 flex items-center justify-center min-h-screen p-4">
-
-    <div class="bg-white rounded-3xl shadow-xl max-w-md w-full p-8 text-center text-gray-800">
-        <div class="w-20 h-20 bg-purple-100 text-purple-600 rounded-full flex items-center justify-center text-4xl mx-auto mb-6">
-            👨‍🏫
-        </div>
-        
-        <h1 class="text-2xl font-extrabold mb-4 text-gray-900">
-            היי! {% if student_name %}{{ student_name }}{% else %}הילד{% endif %} ביקש עזרה.
-        </h1>
-        <p class="text-gray-600 mb-8 leading-relaxed">
-            בואו נפתח לו את כל המחסומים בדרך להצלחה במתמטיקה. 
-            עם פרימיום הוא יקבל פתרונות ללא הגבלה ודוחות התקדמות שבועיים ישירות למייל.
-        </p>
-
-        <form id="payment-form" class="space-y-4 text-right">
-            <input type="hidden" id="uid" name="uid" value="{{ uid }}">
-            
-            <div>
-                <label for="email" class="block text-sm font-semibold text-gray-700 mb-1">אימייל של ההורה (לקבלת הדוחות לשבוע הבא)</label>
-                <input type="email" id="email" required placeholder="example@email.com" class="w-full px-4 py-3 rounded-xl border border-gray-300 focus:outline-none focus:ring-2 focus:ring-purple-500 text-left" dir="ltr">
-            </div>
-
-            <!-- Fake Card Number for the simuation -->
-            <div>
-                <label class="block text-sm font-semibold text-gray-700 mb-1">פרטי אשראי</label>
-                <div class="p-4 border border-gray-300 rounded-xl bg-gray-50 text-center text-gray-400">
-                    Stripe Checkout כרגע במצב סימולציה. הזן אימייל ולחץ "שלם".
-                </div>
-            </div>
-
-            <button type="submit" id="submit-btn" class="w-full bg-gradient-to-r from-purple-500 to-indigo-600 text-white font-bold py-4 rounded-xl shadow-lg hover:shadow-xl hover:from-purple-600 hover:to-indigo-700 transition duration-300 mt-6 flex justify-center items-center">
-                <span>שלם ושדרג עכשיו 🚀</span>
-            </button>
-        </form>
-
-        <div id="success-msg" class="hidden mt-6 bg-green-50 text-green-700 p-4 rounded-xl border border-green-200">
-            <p class="font-bold text-lg mb-1">מזל טוב! 🎉</p>
-            <p>המנוי שודרג בהצלחה. ספרו על כך בחזרה באפליקציה!</p>
-        </div>
-        <div id="error-msg" class="hidden mt-6 text-red-600 font-semibold"></div>
-    </div>
-
-    <script>
-        document.getElementById('payment-form').addEventListener('submit', async (e) => {
-            e.preventDefault();
-            const btn = document.getElementById('submit-btn');
-            btn.innerHTML = 'מעבד תשלום... ⚙️';
-            btn.disabled = true;
-
-            const uid = document.getElementById('uid').value;
-            const email = document.getElementById('email').value;
-
-            try {
-                const response = await fetch('/api/upgrade_success', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ uid: uid, parent_email: email })
-                });
-
-                if (response.ok) {
-                    document.getElementById('payment-form').classList.add('hidden');
-                    document.getElementById('success-msg').classList.remove('hidden');
-                } else {
-                    const data = await response.json();
-                    throw new Error(data.message || 'Payment failed');
-                }
-            } catch (err) {
-                document.getElementById('error-msg').innerText = "שגיאה: " + err.message;
-                document.getElementById('error-msg').classList.remove('hidden');
-                btn.innerHTML = 'שלם ושדרג עכשיו 🚀';
-                btn.disabled = false;
-            }
-        });
-    </script>
-</body>
-</html>
diff --git a/templates/report_template.html b/templates/report_template.html
deleted file mode 100644
index 9177b777272e13e84b11b647c7f763c97f72ee67..0000000000000000000000000000000000000000
--- a/templates/report_template.html
+++ /dev/null
@@ -1,251 +0,0 @@
-<!DOCTYPE html>
-<html lang="he" dir="rtl">
-<head>
-    <meta charset="UTF-8">
-    <title>דוח התקדמות שבועי - המורה למתמטיקה</title>
-    <style>
-        /* CSS Inline for PDF Compatibility */
-        @import url('https://fonts.googleapis.com/css2?family=Assistant:wght@400;600;800&display=swap');
-        
-        body {
-            font-family: 'Assistant', sans-serif;
-            background-color: #f8fafc;
-            color: #1e293b;
-            margin: 0;
-            padding: 40px;
-            direction: rtl;
-        }
-
-        .container {
-            max-width: 800px;
-            margin: 0 auto;
-            background: white;
-            border-radius: 24px;
-            padding: 40px;
-            box-shadow: 0 10px 25px rgba(0,0,0,0.05);
-        }
-
-        .header {
-            text-align: center;
-            margin-bottom: 40px;
-            border-bottom: 2px solid #e2e8f0;
-            padding-bottom: 20px;
-        }
-
-        .header h1 {
-            color: #4f46e5;
-            font-size: 32px;
-            margin: 0 0 10px 0;
-            font-weight: 800;
-        }
-
-        .header p {
-            color: #64748b;
-            font-size: 18px;
-            margin: 0;
-        }
-
-        .stats-grid {
-            display: flex;
-            justify-content: space-between;
-            margin-bottom: 40px;
-            gap: 20px;
-        }
-
-        .stat-card {
-            flex: 1;
-            background: #eff6ff;
-            border-radius: 16px;
-            padding: 24px;
-            text-align: center;
-            border: 1px solid #bfdbfe;
-        }
-
-        .stat-card h3 {
-            margin: 0 0 10px 0;
-            color: #3b82f6;
-            font-size: 16px;
-        }
-
-        .stat-card .value {
-            font-size: 36px;
-            font-weight: 800;
-            color: #1d4ed8;
-            margin: 0;
-        }
-
-        .content-flex {
-            display: flex;
-            gap: 40px;
-            margin-bottom: 40px;
-        }
-
-        .chart-section {
-            flex: 1;
-            text-align: center;
-            background: #ffffff;
-            border-radius: 20px;
-            padding: 20px;
-            border: 1px solid #e2e8f0;
-        }
-
-        .chart-section h2 {
-            color: #334155;
-            font-size: 20px;
-            margin-top: 0;
-        }
-
-        .chart-img {
-            max-width: 100%;
-            height: auto;
-        }
-
-        .skills-list {
-            flex: 1;
-        }
-
-        .skill-item {
-            margin-bottom: 20px;
-        }
-
-        .skill-header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            margin-bottom: 8px;
-        }
-
-        .skill-name {
-            font-weight: 600;
-            color: #334155;
-        }
-
-        .skill-score {
-            font-weight: 800;
-            color: #4f46e5;
-        }
-
-        .progress-bar {
-            height: 12px;
-            background: #e2e8f0;
-            border-radius: 10px;
-            overflow: hidden;
-        }
-
-        .progress-fill {
-            height: 100%;
-            background: linear-gradient(90deg, #6366f1, #3b82f6);
-            border-radius: 10px;
-        }
-
-        .sub-skills {
-            margin-top: 8px;
-            font-size: 14px;
-            color: #64748b;
-        }
-
-        .notes-section {
-            background: #fdf2f8;
-            border-radius: 20px;
-            padding: 30px;
-            border: 1px solid #fbcfe8;
-        }
-
-        .notes-section h2 {
-            color: #be185d;
-            margin-top: 0;
-            font-size: 20px;
-        }
-
-        .note-item {
-            position: relative;
-            padding-right: 24px;
-            margin-bottom: 12px;
-            color: #831843;
-            font-size: 16px;
-            line-height: 1.5;
-        }
-
-        .note-item::before {
-            content: "•";
-            position: absolute;
-            right: 0;
-            color: #ec4899;
-            font-size: 24px;
-            line-height: 1;
-        }
-
-        .footer {
-            margin-top: 40px;
-            text-align: center;
-            color: #94a3b8;
-            font-size: 14px;
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="header">
-            <h1>דוח התקדמות שבועי</h1>
-            <p>המורה למתמטיקה | שבוע {{ week_label }} | {{ student_name }}</p>
-        </div>
-
-        <div class="stats-grid">
-            <div class="stat-card">
-                <h3>סה"כ תרגילים שנפתרו</h3>
-                <p class="value">{{ total_exercises }}</p>
-            </div>
-            <div class="stat-card">
-                <h3>ממוצע שליטה כללי</h3>
-                <p class="value">{{ overall_mastery }}%</p>
-            </div>
-        </div>
-
-        <div class="content-flex">
-            <!-- Radar Chart via QuickChart.io -->
-            <div class="chart-section">
-                <h2>מפת מיומנויות</h2>
-                <img class="chart-img" src="{{ chart_url }}" alt="Radar Chart">
-            </div>
-
-            <div class="skills-list">
-                <h2>פירוט נושאים</h2>
-                {% for skill in skills %}
-                <div class="skill-item">
-                    <div class="skill-header">
-                        <span class="skill-name">{{ skill.name }}</span>
-                        <span class="skill-score">{{ skill.score }}%</span>
-                    </div>
-                    <div class="progress-bar">
-                        <div class="progress-fill" style="width: {{ skill.score }}%;"></div>
-                    </div>
-                    <div class="sub-skills">
-                        <strong>תתי-נושאים שטופלו:</strong> {{ skill.sub_skills | join(", ") }}
-                    </div>
-                </div>
-                {% endfor %}
-            </div>
-        </div>
-
-        {% if parent_notes and parent_notes|length > 0 %}
-        <div class="notes-section" style="margin-bottom: 30px;">
-            <h2>נקודות לשימור ולחיזוק 💡</h2>
-            {% for note in parent_notes %}
-            <div class="note-item">{{ note }}</div>
-            {% endfor %}
-        </div>
-        {% endif %}
-
-        {% if focus_for_next_week %}
-        <div class="notes-section" style="background: #f0fdfa; border-color: #ccfbf1;">
-            <h2 style="color: #0d9488;">מטרה לשבוע הבא 🎯</h2>
-            <div class="note-item" style="color: #115e59;">{{ focus_for_next_week }}</div>
-        </div>
-        {% endif %}
-
-        <div class="footer">
-            <p>הופק על ידי מערכת הבינה המלאכותית של המורה למתמטיקה</p>
-        </div>
-    </div>
-</body>
-</html>
diff --git a/test_emergency_recovery.py b/test_emergency_recovery.py
deleted file mode 100644
index 026fd6bed7b50d3d5e70b81ff1ac37af8300fff8..0000000000000000000000000000000000000000
--- a/test_emergency_recovery.py
+++ /dev/null
@@ -1,64 +0,0 @@
-import asyncio
-import os
-import sys
-import json
-import base64
-
-# Add the server directory to path
-sys.path.append(os.getcwd())
-
-async def run_emergency_test():
-    from orchestrator import orchestrator, BuddyEvent, BuddyState
-    
-    print("🎬 Starting Emergency Recovery Test...")
-    
-    # Mock image data (just some bytes)
-    mock_image = b"fake-image-data-V316"
-    
-    # Complex problem text reported by user
-    problem_text = "תרגיל ד: חקור את הפונקציה f(x) = ln|x^2 - 1| / (ln x)^2"
-    
-    print(f"📝 Testing with Problem: {problem_text}")
-    print("🔍 Step 1: Vision Pipeline & Data Anchor...")
-    
-    events_found = []
-    try:
-        # We use a real orchestrator but expect it to handle our mock data or at least not crash
-        async for event in orchestrator.solve_problem(
-            problem_text=problem_text,
-            image_data_list=[mock_image],
-            grade="5 יח\"ל",
-            student_name="אלון",
-            student_gender="M",
-            mode="standard"
-        ):
-            events_found.append(event.state)
-            print(f"📡 Event: {event.state}")
-            
-            if event.state == BuddyState.COMPLETE:
-                print("✅ TEST PASSED: Reached COMPLETE state without server crash.")
-                break
-            
-            if event.state == BuddyState.ERROR:
-                print(f"⚠️ Event reported error (logic error likely), but system stayed ALIVE. Payload: {event.payload}")
-                break
-                
-    except Exception as e:
-        print(f"❌ TEST FAILED: System CRASHED with error: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-    
-    return True
-
-if __name__ == "__main__":
-    # Ensure environment variables are semi-valid for local run
-    os.environ["ENV"] = "development"
-    os.environ["SPACE_ID"] = "dotandru/buddymath-dev"
-    
-    success = asyncio.run(run_emergency_test())
-    if success:
-        print("\n🏆 EMERGENCY RECOVERY VALIDATED.")
-    else:
-        print("\n💀 VALIDATION FAILED.")
-        sys.exit(1)
diff --git a/test_llm.py b/test_llm.py
deleted file mode 100644
index c1509364eeee5d2855cf94bb9268e58eda5fe07e..0000000000000000000000000000000000000000
--- a/test_llm.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import asyncio
-import logging
-import json
-import traceback
-from orchestrator import orchestrator
-
-logging.basicConfig(level=logging.INFO, format="%(message)s")
-
-async def test_llm():
-    try:
-        with open(r"C:\Projects\BuddyMath\simple.jpg", "rb") as f:
-            image_bytes = f.read()
-        
-        # Bypassing FastAPI layer, calling orchestrator directly
-        print("Starting orchestrator.solve_problem...")
-        res = await orchestrator.solve_problem(
-            problem_text="",  
-            grade="10",
-            student_name="diagnostic",
-            image_data=image_bytes
-        )
-        print("--- FINAL RESPONSE ---")
-        print(json.dumps(res, indent=2, ensure_ascii=False))
-        
-    except Exception as e:
-        print(f"Test Failed: {e}")
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    asyncio.run(test_llm())
diff --git a/test_rule_engine.py b/test_rule_engine.py
deleted file mode 100644
index e297cfd98ee3154acaa7868dd3c7a91d1090f277..0000000000000000000000000000000000000000
--- a/test_rule_engine.py
+++ /dev/null
@@ -1,29 +0,0 @@
-import asyncio
-import logging
-import json
-import traceback
-from orchestrator import orchestrator
-from domain.processing_strategy import ProcessingStrategy
-
-logging.basicConfig(level=logging.INFO, format="%(message)s")
-
-async def test_rule_engine():
-    try:
-        problem_text = "נתון מעגל שמשוואות שניים מקטריו הן y = 4/3*x + 1 ו- y = -4/3*x + 9. מצא את מרכז המעגל."
-        # We want to force the STRICT_SYMBOLIC or just pass it to solve_problem
-        print("Starting orchestrator.solve_problem with Rule Engine test...")
-        res = await orchestrator.solve_problem(
-            problem_text=problem_text,  
-            grade="10",
-            student_name="diagnostic",
-            image_data=None # No image, just text
-        )
-        print("--- FINAL RESPONSE ---")
-        print(json.dumps(res, indent=2, ensure_ascii=False))
-        
-    except Exception as e:
-        print(f"Test Failed: {e}")
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    asyncio.run(test_rule_engine())
diff --git a/test_tts.py b/test_tts.py
deleted file mode 100644
index 46f3c9319546e8310f35b17aeecf5aac8a2ea3a3..0000000000000000000000000000000000000000
--- a/test_tts.py
+++ /dev/null
@@ -1,70 +0,0 @@
-import os
-import urllib.request
-import torchaudio
-import re
-import torch
-import warnings
-
-warnings.filterwarnings("ignore")
-
-# =========================================================================
-# פתרון גנרי (Monkey Patch): 
-# עוקפים באגים בספריות צד-שלישי ששכחו לתמוך במעבד (CPU).
-# אנחנו מכריחים את PyTorch לטעון את כל המשקולות ישירות למעבד.
-# =========================================================================
-original_load = torch.load
-
-def safe_cpu_load(*args, **kwargs):
-    kwargs['map_location'] = 'cpu'
-    return original_load(*args, **kwargs)
-
-torch.load = safe_cpu_load
-# =========================================================================
-
-from chatterbox.mtl_tts import ChatterboxMultilingualTTS
-from phonikud_onnx import Phonikud
-from phonikud import lexicon
-
-def main():
-    print("🚀 מתחילים! מכינים את סביבת העבודה...")
-    
-    # הורדת מודל הניקוד (ידולג כי כבר ירד)
-    nikud_model_path = "phonikud-1.0.int8.onnx"
-    if not os.path.exists(nikud_model_path):
-        urllib.request.urlretrieve("https://huggingface.co/thewh1teagle/phonikud-onnx/resolve/main/phonikud-1.0.int8.onnx", nikud_model_path)
-
-    print("⏳ טוען את מנועי ה-AI לזיכרון...")
-    
-    device = "cpu" 
-    phonikud_model = Phonikud(nikud_model_path)
-    
-    # === תוקן: חסרו מירכאות בתחילת המחרוזת ===
-    text = "בוקר טוב לקהילה הקטנה שלי!! מה שלומכם הבוקר איך אני נשמעת לכם ? מוזר? נעים? עליתי לארץ ללמד מתמטיקה . ספרו לי מה אתם חושבים."
-    ref_path = "teacher_reference.wav"
-    output_path = "first_test.wav"
-    
-    # ניקוד אוטומטי
-    with_diacritics = phonikud_model.add_diacritics(text)
-    with_diacritics = re.sub(fr"[{lexicon.NON_STANDARD_DIAC}]", "", with_diacritics)
-    print(f"📝 הטקסט המנוקד שהמנוע יקרא: {with_diacritics}")
-
-    # הפעלת מנוע ה-Chatterbox
-    print("\n🎙️ מייצר אודיו... (המעבד מחשב, המתן בסבלנות)")
-    
-    multilingual_model = ChatterboxMultilingualTTS.from_pretrained(device=device)
-    
-    # === תוקן: שליטה במהירות במנוע Chatterbox ===
-    # שימוש ב-cfg_weight כדי להאט את קצב הדיבור. 0.5 זה רגיל, 0.75 יאט אותה לקצב נוח וברור יותר.
-    wav = multilingual_model.generate(
-        with_diacritics, 
-        language_id="he", 
-        audio_prompt_path=ref_path,
-        cfg_weight=0.75
-    )
-    
-    # שמירה לדיסק
-    torchaudio.save(output_path, wav, multilingual_model.sr)
-    print(f"\n✅✅✅ הצלחה אדירה! הקובץ {output_path} נוצר בהצלחה!")
-
-if __name__ == "__main__":
-    main()
\ No newline at end of file
diff --git a/tests/archive_scripts/final_stress_test.py b/tests/archive_scripts/final_stress_test.py
deleted file mode 100644
index 2801b9be053b52d7718b8e9b5fcfa98be68462ed..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/final_stress_test.py
+++ /dev/null
@@ -1,84 +0,0 @@
-import cv2
-import numpy as np
-import os
-from PIL import Image
-from google import genai
-from google.genai import types
-
-# 1. הגדרות (שים את המפתח החדש שלך!)
-client = genai.Client(api_key="AIzaSyA0odvjKCTS-vZsEjMOlsVsJ4iGaYj5jf0")
-
-def process_and_ocr(image_path):
-    print(f"\n--- Processing: {image_path} ---")
-    
-    # 2. OpenCV - זיהוי שורות וחיתוך
-    img = cv2.imread(image_path)
-    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    blur = cv2.GaussianBlur(gray, (7,7), 0)
-    thresh = cv2.adaptiveThreshold(blur, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)
-    
-    # מחברים שורות (קרנל רחב)
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (50, 5))
-    dilate = cv2.dilate(thresh, kernel, iterations=1)
-    contours, _ = cv2.findContours(dilate, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    
-    # מיון מלמעלה למטה
-    contours = sorted(contours, key=lambda c: cv2.boundingRect(c)[1])
-    
-    crops = []
-    max_w = 0
-    for c in contours:
-        x, y, w, h = cv2.boundingRect(c)
-        if w > 60 and h > 20:
-            crop = img[y:y+h, x:x+w]
-            crops.append(crop)
-            if w > max_w: max_w = w
-
-    # 3. Stitching - הדבקת החיתוכים לסטריפ אחד (מנקה שטחים לבנים)
-    # מוסיפים פדינג שיהיה רוחב אחיד להדבקה
-    final_crops = []
-    for c in crops:
-        h, w, _ = c.shape
-        padded = cv2.copyMakeBorder(c, 5, 5, 0, max_w - w, cv2.BORDER_CONSTANT, value=[255, 255, 255])
-        final_crops.append(padded)
-    
-    if not final_crops:
-        print("Error: No text blocks found!")
-        return
-
-    # הדבקה אנכית
-    stitched_strip = cv2.vconcat(final_crops)
-    strip_name = f"strip_{image_path}"
-    cv2.imwrite(strip_name, stitched_strip)
-    print(f"Stitched strip saved as {strip_name}")
-
-    # 4. שליחה ל-Gemini Flash
-    pil_img = Image.open(strip_name)
-    
-    prompt = """
-    התמונה המצורפת היא "סטריפ" המורכב מחיתוכים של שאלת בגרות במתמטיקה.
-    המשימה שלך: חלץ את כל הטקסט והמשוואות בדיוק מושלם של 100%.
-    חוקים:
-    1. קרא את העברית והמתמטיקה ברצף מלמעלה למטה.
-    2. שים לב לפרטים הקטנים ביותר: שברים, חזקות, e, ln, וסימני מינוס.
-    3. החזר LaTeX תקני לכל המתמטיקה ועברית נקייה.
-    4. החזר רק את הטקסט המחולץ.
-    """
-
-    response = client.models.generate_content(
-        model='gemini-2.0-flash',
-        contents=[pil_img, prompt],
-        config=types.GenerateContentConfig(temperature=0.0, max_output_tokens=4096)
-    )
-    
-    print("\n--- OCR RESULT ---")
-    print(response.text)
-    print("------------------")
-
-# הרצת הניסוי על 3 הקבצים (שנה את השמות אם צריך)
-test_files = ["hardest_1.jpg", "ocr_only.jpeg", "simple.jpg"]
-for file in test_files:
-    if os.path.exists(file):
-        process_and_ocr(file)
-    else:
-        print(f"File {file} not found, skipping...")
\ No newline at end of file
diff --git a/tests/archive_scripts/run_100_stress.py b/tests/archive_scripts/run_100_stress.py
deleted file mode 100644
index b884f76786c30b853cefbd57869bcd9c3b0d5a87..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/run_100_stress.py
+++ /dev/null
@@ -1,90 +0,0 @@
-import asyncio
-import cv2
-import numpy as np
-import time
-from fastapi.testclient import TestClient
-from main import app
-
-client = TestClient(app)
-
-def create_mock_image(text: str) -> bytes:
-    img = np.zeros((200, 600, 3), dtype=np.uint8)
-    cv2.putText(img, text, (10, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
-    success, encoded_image = cv2.imencode('.jpg', img)
-    if not success:
-        raise ValueError("Failed to encode image")
-    return encoded_image.tobytes()
-
-smadar_img_bytes = create_mock_image("4x + 5y = 120, y = x + 6")
-circle_img_bytes = create_mock_image("(x-3)**2 + (y-4)**2 = 25")
-
-def run_stress_test():
-    print("🚀 Starting 100-Request OpenCV Stress Test Matrix...")
-    print("Expected Triggers: Quota Limits (429), Logic Errors, Valid Passes\n")
-    
-    stats = {
-        "success": 0,
-        "logic_error_handled": 0,
-        "quota_exceeded": 0,
-        "uncaught_exceptions": 0
-    }
-    
-    start_time = time.time()
-    
-    for i in range(1, 101):
-        print(f"--- Request {i}/100 ---")
-        
-        is_smadar = (i % 2 != 0)
-        img_bytes = smadar_img_bytes if is_smadar else circle_img_bytes
-        grade = "ז'" if is_smadar else "י'"
-        
-        files = {'file': ('test.jpg', img_bytes, 'image/jpeg')}
-        data = {
-            'user': f'stress_user_{i % 5}', # Distribute across 5 mock users to eventual hit quotas
-            'grade': grade,
-            'student_gender': 'M',
-            'mode': 'solve'
-        }
-        
-        try:
-            resp = client.post("/solve_stream", data=data, files=files)
-            
-            if resp.status_code == 429:
-                print("   🛡️ Quota Exceeded handled correctly (429)")
-                stats["quota_exceeded"] += 1
-            elif resp.status_code == 200:
-                res_json = resp.json()
-                if res_json.get("logic_error"):
-                    print("   🛡️ Logic Error Handled (Firewall/Validator tripped safely)")
-                    stats["logic_error_handled"] += 1
-                else:
-                    print("   ✅ Valid Response Generated")
-                    stats["success"] += 1
-            elif resp.status_code == 500:
-                print(f"   ❌ CRITICAL: 500 Internal Server Error returned: {resp.text}")
-                stats["uncaught_exceptions"] += 1
-            else:
-                print(f"   ⚠️ Unexpected Status Code: {resp.status_code}")
-                stats["uncaught_exceptions"] += 1
-                
-        except Exception as e:
-            print(f"   ❌ Exception Burst: {e}")
-            stats["uncaught_exceptions"] += 1
-
-    print("\n" + "="*40)
-    print("📊 FINAL STRESS TEST RESULTS 📊")
-    print(f"Total Requests: 100")
-    print(f"Successful Validations: {stats['success']}")
-    print(f"Safely Handled Logic Errors: {stats['logic_error_handled']}")
-    print(f"Safely Handled Quotas (429): {stats['quota_exceeded']}")
-    print(f"Unmanaged Exceptions/500s: {stats['uncaught_exceptions']}")
-    print("="*40)
-    print(f"Elapsed Time: {time.time() - start_time:.2f}s")
-    
-    if stats["uncaught_exceptions"] == 0:
-        print("✅ STRESS TEST PASSED - 100% STABILITY PROVEN")
-    else:
-        print("❌ STRESS TEST FAILED - UNCAUGHT EXCEPTIONS DETECTED")
-
-if __name__ == "__main__":
-    run_stress_test()
diff --git a/tests/archive_scripts/sanity_check.py b/tests/archive_scripts/sanity_check.py
deleted file mode 100644
index a11856fd2d9b32a59c0ab47df7c8b62961b13658..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/sanity_check.py
+++ /dev/null
@@ -1,32 +0,0 @@
-import asyncio
-from orchestrator import orchestrator
-
-async def run_sanity():
-    print("--- 🟢 SANITY CHECK ALGEBRA (SMADAR) ---")
-    res_alg = await orchestrator.smart_solve(
-        problem_text="סמדר קנתה מחברות חשבון ב-4 שקלים וחלקות ב-5 שקלים. כמה קנתה?",
-        data_anchor={"function_equations": ["4x + 5y = 120", "y = x + 6"]},
-        grade="ז'",
-        category="ALGEBRA",
-        image_data=None,
-        ambiguity_warning=False
-    )
-    print("ALGEBRA RESPONSE SUCCESS:")
-    print("Final Answer:", res_alg.get("final_answer"))
-    print("Logic Error:", res_alg.get("logic_error"))
-
-    print("\n--- 🟢 SANITY CHECK GEOMETRY (CIRCLE AREA) ---")
-    res_geom = await orchestrator.smart_solve(
-         problem_text="חשב את שטח המעגל שמשוואתו (x-3)**2 + (y-4)**2 = 25",
-         data_anchor={"function_equations": ["(x-3)**2 + (y-4)**2 = 25"]},
-         grade="י'",
-         category="GEOMETRY",
-         image_data=None,
-         ambiguity_warning=False
-    )
-    print("GEOMETRY RESPONSE SUCCESS:")
-    print("Final Answer:", res_geom.get("final_answer"))
-    print("Logic Error:", res_geom.get("logic_error"))
-
-if __name__ == "__main__":
-    asyncio.run(run_sanity())
diff --git a/tests/archive_scripts/test_atomic_v5.py b/tests/archive_scripts/test_atomic_v5.py
deleted file mode 100644
index beefd98ac2b7832b958d7a1f34ca40a08b3e0e6b..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/test_atomic_v5.py
+++ /dev/null
@@ -1,87 +0,0 @@
-import cv2
-import numpy as np
-from PIL import Image
-import os
-import io
-
-def run_atomic_test(image_path):
-    # --- שלב 1: זיהוי ריבועים (הקוד המנצח שלך) ---
-    if not os.path.exists(image_path):
-        print(f"❌ שגיאה: התמונה לא נמצאה בנתיב: {image_path}")
-        return
-
-    image = cv2.imread(image_path)
-    img_h, img_w = image.shape[:2]
-    
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    thresh = cv2.adaptiveThreshold(cv2.GaussianBlur(gray, (7,7), 0), 255, 
-                                 cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)
-    
-    # הקרנל הרחב שחיבר לך את השורות ב-debug_boxes
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (40, 10))
-    dilate = cv2.dilate(thresh, kernel, iterations=1)
-    contours, _ = cv2.findContours(dilate, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    
-    blocks = []
-    for c in contours:
-        x, y, w, h = cv2.boundingRect(c)
-        if w > 50 and h > 20:
-            blocks.append((x, y, w, h))
-    
-    # מיון הבלוקים מלמעלה למטה
-    blocks.sort(key=lambda b: b[1])
-
-    # --- שלב 2: חיתוך אטומי (V302.5) ---
-    pil_img = Image.open(image_path).convert("RGB")
-    pages = []
-    
-    # חוק 1: Header Lock (תופס את ה-f(x) תמיד)
-    header_limit = 180
-    pages.append(pil_img.crop((0, 0, img_w, header_limit)))
-    
-    # ניהול תור
-    remaining = [b for b in blocks if (b[1] + b[3]) > header_limit]
-    
-    while remaining:
-        curr = remaining.pop(0)
-        x, y, w, h = curr
-        
-        # חוק 2: אטומיות הגרף (אם גבוה, מקבל דף משלו)
-        if h > 120:
-            y_s = max(0, y - 30)
-            # חוק הגנת הזנב: אם זה האחרון, חתוך עד סוף הקובץ
-            y_e = img_h if not remaining else min(img_h, y + h + 30)
-            pages.append(pil_img.crop((0, y_s, img_w, y_e)))
-            remaining = [b for b in remaining if b[1] > (y_e - 10)]
-            continue
-            
-        # חוק 3: צביר טקסט (קיבוץ סעיפים)
-        c_min, c_max = y, y + h
-        to_consume = []
-        for nb in remaining:
-            if nb[3] > 120: break
-            if (max(c_max, nb[1]+nb[3]) - c_min) <= 750:
-                c_max = max(c_max, nb[1]+nb[3])
-                to_consume.append(nb)
-            else: break
-        
-        for r in to_consume: remaining.remove(r)
-        
-        y_t = max(0, c_min - 25)
-        y_b = img_h if not remaining else min(img_h, c_max + 25)
-        pages.append(pil_img.crop((0, y_t, img_w, y_b)))
-
-    # --- שלב 3: שמירת התוצאות לתיקייה ---
-    output_dir = "test_results"
-    if not os.path.exists(output_dir): os.makedirs(output_dir)
-    
-    for i, p in enumerate(pages):
-        p.save(f"{output_dir}/slice_{i+1}.jpg")
-        print(f"✅ נשמר Slice {i+1} בגובה {p.size[1]}px")
-    
-    print(f"\n🚀 הבדיקה הסתיימה! בדוק את התמונות בתיקיית: {os.path.abspath(output_dir)}")
-
-if __name__ == "__main__":
-    # וודא שהנתיב לתמונה נכון
-    target_image = r"C:\Users\dotan\OneDrive\תמונות\בגרות חורף 26 .jpg"
-    run_atomic_test(target_image)
\ No newline at end of file
diff --git a/tests/archive_scripts/test_final_assembly.py b/tests/archive_scripts/test_final_assembly.py
deleted file mode 100644
index c4cf1094eaf4400e1bdc62b1b4b8689e1ccc87bb..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/test_final_assembly.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import cv2
-import numpy as np
-from PIL import Image
-import os
-
-def run_final_assembly_test(image_path):
-    # --- שלב 1: הזיהוי המנצח שלך (הריבועים הירוקים) ---
-    image = cv2.imread(image_path)
-    img_h, img_w = image.shape[:2]
-    
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    thresh = cv2.adaptiveThreshold(cv2.GaussianBlur(gray, (7,7), 0), 255, 
-                                 cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (40, 10))
-    dilate = cv2.dilate(thresh, kernel, iterations=1)
-    contours, _ = cv2.findContours(dilate, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    
-    blocks = sorted([cv2.boundingRect(c) for c in contours if cv2.boundingRect(c)[2] > 50], key=lambda b: b[1])
-
-    # --- שלב 2: בניית ה-Payload (חיבור הריבועים לסלייסים) ---
-    pil_img = Image.open(image_path).convert("RGB")
-    slices = []
-    
-    # Header Lock
-    slices.append(pil_img.crop((0, 0, img_w, 180)))
-    
-    remaining = [b for b in blocks if (b[1] + b[3]) > 180]
-    while remaining:
-        curr = remaining.pop(0)
-        x, y, w, h = curr
-        if h > 120: # גרף
-            y_s, y_e = max(0, y-30), (img_h if not remaining else min(img_h, y+h+30))
-            slices.append(pil_img.crop((0, y_s, img_w, y_e)))
-            remaining = [b for b in remaining if b[1] > (y_e - 10)]
-            continue
-        
-        c_min, c_max = y, y + h
-        to_consume = []
-        for nb in remaining:
-            if nb[3] > 120 or (max(c_max, nb[1]+nb[3]) - c_min) > 750: break
-            c_max = max(c_max, nb[1]+nb[3])
-            to_consume.append(nb)
-        for r in to_consume: remaining.remove(r)
-        
-        y_t, y_b = max(0, c_min-25), (img_h if not remaining else min(img_h, c_max+25))
-        slices.append(pil_img.crop((0, y_t, img_w, y_b)))
-
-    # --- שלב 3: ויזואליזציה של החיבור (ה"ניבוי") ---
-    # אנחנו מחברים את כל הסלייסים לתמונה אחת ארוכה עם קו מפריד אדום
-    assembly_parts = []
-    separator = np.zeros((10, img_w, 3), dtype=np.uint8)
-    separator[:] = [0, 0, 255] # קו אדום בולט
-    
-    for i, s in enumerate(slices):
-        assembly_parts.append(np.array(s))
-        if i < len(slices) - 1:
-            assembly_parts.append(separator)
-            
-    final_assembly = np.vstack(assembly_parts)
-    cv2.imwrite("final_assembly_debug.jpg", cv2.cvtColor(final_assembly, cv2.COLOR_RGB2BGR))
-    
-    print(f"✅ הצלחנו לחבר {len(slices)} חלקים.")
-    print(f"📂 התוצאה הסופית מחכה לך ב: final_assembly_debug.jpg")
-    print("\n--- מבנה ה-Payload שיישלח ל-LLM ---")
-    print(f"Payload = [PROMPT, " + ", ".join([f"PAGE_{i+1}" for i in range(len(slices))]) + "]")
-
-if __name__ == "__main__":
-    target = r"C:\Projects\BuddyMath\buddy_math_server\hardest_1.jpg"
-    run_final_assembly_test(target)
\ No newline at end of file
diff --git a/tests/archive_scripts/test_v4_2_16.py b/tests/archive_scripts/test_v4_2_16.py
deleted file mode 100644
index 9cef9d4a4d881d8e3a556d0743d491bbbaad9cd8..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/test_v4_2_16.py
+++ /dev/null
@@ -1,79 +0,0 @@
-# test_v4_2_16.py - REGRESSION TEST FOR ALGEBRA & INTENT GATING
-import asyncio
-from orchestrator import orchestrator, PipelineContext
-
-async def run_tests():
-    print("🚀 starting BuddyMath V4.2.16 Regression Test Matrix...\n")
-
-    test_cases = [
-        {
-            "id": "CASE_1_SMADAR_ALGEBRA",
-            "name": "סמדר והמחברות (כיתה ז')",
-            "grade": "ז'",
-            "category": "ALGEBRA",
-            "math_input": "4x + 5y = 120, y = x + 6",
-            "text": "סמדר קנתה מחברות חשבון ב-4 שקלים וחלקות ב-5 שקלים. כמה קנתה?",
-            "expected_operator": "LINEAR_SYSTEM"
-        },
-        {
-            "id": "CASE_2_Y12_ALGEBRA_NO_INTENT",
-            "name": "יב' אלגברה - ללא כוונת חקירה",
-            "grade": "יב'",
-            "category": "INVESTIGATION", # קטגוריה מוטעית בכוונה
-            "math_input": "y = 4x + 3",
-            "text": "מצא את נקודת החיתוך של הישר עם הצירים.",
-            "expected_operator": "ALGEBRA_GENERAL" # אמור להיחסם כי אין מילת 'חקור'
-        },
-        {
-            "id": "CASE_3_Y12_INVESTIGATION_FULL",
-            "name": "יב' חקירה - עם כוונת חקירה",
-            "grade": "יב'",
-            "category": "INVESTIGATION",
-            "math_input": "y = x^2 - 4",
-            "text": "חקור את הפונקציה ומצא נקודות קיצון.",
-            "expected_operator": "DERIVATIVE" # אמור לעבור כי יש 'חקור' ו'קיצון'
-        }
-    ]
-
-    for tc in test_cases:
-        print(f"--- Testing: {tc['name']} ---")
-        
-        # 1. יצירת קונטקסט בדיקה
-        context = PipelineContext(
-            grade=tc["grade"],
-            grade_num=12 if "יב" in tc["grade"] else 7,
-            topic=tc["category"],
-            math_input=tc["math_input"],
-            confidence=1.0,
-            original_text=tc["text"],
-            category=tc["category"]
-        )
-
-        # 2. הרצת הסולבר ישירות (בדיקת מנוע המתמטיקה)
-        result = orchestrator.smart_solver.solve(context)
-        print(f"   [SOLVER] Operator Used: {result.operator_used}")
-        print(f"   [SOLVER] Success: {result.success}")
-        
-        # 3. בדיקת ה-Validator (בדיקת חסימת זליגות)
-        # נדמה פלט של LLM שמנסה להזליג נגזרת באלגברה
-        mock_resp = {
-            "sections": [{
-                "steps": [{"explanation_text": "נחשב את הנגזרת של הפונקציה כדי למצוא פתרון."}]
-            }],
-            "logic_error": False
-        }
-        
-        from orchestrator import validate_and_sanitize_response
-        validated = validate_and_sanitize_response(mock_resp, category=tc["category"])
-        
-        if tc["category"] != "INVESTIGATION":
-             print(f"   [VALIDATOR] Logic Error Detected (Expected): {validated['logic_error']}")
-        
-        # Verification
-        if result.operator_used == tc["expected_operator"]:
-            print(f"✅ PASSED: {tc['id']}\n")
-        else:
-            print(f"❌ FAILED: {tc['id']} - Expected {tc['expected_operator']} but got {result.operator_used}\n")
-
-if __name__ == "__main__":
-    asyncio.run(run_tests())
\ No newline at end of file
diff --git a/tests/archive_scripts/verify_curriculum_compliance.py b/tests/archive_scripts/verify_curriculum_compliance.py
deleted file mode 100644
index b9bfd95079cef5114e7338fedc1d1291bc4cfda1..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/verify_curriculum_compliance.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# verify_curriculum_compliance.py
-import asyncio
-import sys
-import os
-
-# Add current directory to path
-sys.path.append(os.getcwd())
-
-from orchestrator import BuddyOrchestrator
-from proof_graph import ProofStep, ProofGraph, validate_pedagogical_legality
-import curriculum_engine
-
-async def test_grade_7_violation():
-    print("🧪 Testing Grade 7 Violation (Equation Systems)...")
-    orchestrator = BuddyOrchestrator()
-    
-    # Mock data: Grade 7 student
-    grade = "7"
-    level = "4"
-    problem_text = "פתור את מערכת המשוואות: x+y=10, x-y=2"
-    
-    # 1. Fetch rules
-    rules = curriculum_engine.get_allowed_math_operators(grade, level)
-    print(f"📋 Rules for Grade 7: Forbidden={rules['forbidden']}")
-    
-    # 2. Mock a "bad" ProofGraph that uses SYSTEM_OF_EQUATIONS
-    bad_steps = [
-        ProofStep(1, "x+y=10, x-y=2", "Original System"),
-        ProofStep(2, "x=6, y=4", "Solved System", operator_used="SYSTEM_OF_EQUATIONS")
-    ]
-    bad_graph = ProofGraph(bad_steps)
-    
-    # 3. Validate
-    is_legal, reason = validate_pedagogical_legality(bad_graph, rules)
-    
-    if not is_legal:
-        print(f"✅ Success: Pedagogy Guard correctly REJECTED Grade 7 system solver. Reason: {reason}")
-    else:
-        print("❌ Failure: Pedagogy Guard ALLOWED forbidden operator.")
-
-async def test_grade_8_allowed():
-    print("\n🧪 Testing Grade 8 Allowed (Equation Systems)...")
-    grade = "8"
-    rules = curriculum_engine.get_allowed_math_operators(grade)
-    
-    steps = [
-        ProofStep(1, "x+y=10, x-y=2", "Original System"),
-        ProofStep(2, "x=6, y=4", "Solved System", operator_used="SYSTEM_OF_EQUATIONS")
-    ]
-    graph = ProofGraph(steps)
-    
-    is_legal, reason = validate_pedagogical_legality(graph, rules)
-    
-    if is_legal:
-        print(f"✅ Success: Pedagogy Guard correctly ALLOWED Grade 8 system solver.")
-    else:
-        print(f"❌ Failure: Pedagogy Guard REJECTED allowed operator. Reason: {reason}")
-
-if __name__ == "__main__":
-    asyncio.run(test_grade_7_violation())
-    asyncio.run(test_grade_8_allowed())
diff --git a/tests/archive_scripts/verify_pedagogy_logic.py b/tests/archive_scripts/verify_pedagogy_logic.py
deleted file mode 100644
index 3ed3b01cc3aa1338cec59a347d77fd4b04b12d94..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/verify_pedagogy_logic.py
+++ /dev/null
@@ -1,83 +0,0 @@
-# verify_pedagogy_logic.py
-import sys
-import os
-
-# Add current directory to path
-sys.path.append(os.getcwd())
-
-from proof_graph import ProofStep, ProofGraph, validate_pedagogical_legality
-import curriculum_engine
-
-def test_grade_7_violation():
-    print("🧪 Testing Grade 7 Violation (Equation Systems)...")
-    
-    # 1. Fetch rules
-    rules = curriculum_engine.get_allowed_math_operators("7", "4")
-    print(f"📋 Rules for Grade 7: Forbidden={rules['forbidden']}")
-    
-    # 2. Mock a "bad" ProofGraph that uses SYSTEM_OF_EQUATIONS
-    # This simulates the SmartSolver/LLM returning a solution that uses forbidden tools
-    bad_steps = [
-        ProofStep(1, "x+y=10, x-y=2", "Original System"),
-        ProofStep(2, "x=6, y=4", "Solved System", operator_used="SYSTEM_OF_EQUATIONS")
-    ]
-    bad_graph = ProofGraph(bad_steps)
-    
-    # 3. Validate
-    is_legal, reason = validate_pedagogical_legality(bad_graph, rules)
-    
-    if not is_legal:
-        print(f"✅ Success: Pedagogy Guard correctly REJECTED Grade 7 system solver. Reason: {reason}")
-    else:
-        print("❌ Failure: Pedagogy Guard ALLOWED forbidden operator.")
-
-def test_grade_8_allowed():
-    print("\n🧪 Testing Grade 8 Allowed (Equation Systems)...")
-    
-    # 1. Fetch rules
-    rules = curriculum_engine.get_allowed_math_operators("8", "4")
-    print(f"📋 Rules for Grade 8: Forbidden={rules['forbidden']}")
-    
-    # 2. Mock a "good" ProofGraph for Grade 8
-    steps = [
-        ProofStep(1, "x+y=10, x-y=2", "Original System"),
-        ProofStep(2, "x=6, y=4", "Solved System", operator_used="SYSTEM_OF_EQUATIONS")
-    ]
-    graph = ProofGraph(steps)
-    
-    # 3. Validate
-    is_legal, reason = validate_pedagogical_legality(graph, rules)
-    
-    if is_legal:
-        print(f"✅ Success: Pedagogy Guard correctly ALLOWED Grade 8 system solver.")
-    else:
-        print(f"❌ Failure: Pedagogy Guard REJECTED allowed operator. Reason: {reason}")
-
-def test_grade_11_calculus_whitelist():
-    print("\n🧪 Testing Grade 11 Calculus (Derivative Allowed)...")
-    
-    # Grade 11 Rules
-    rules = curriculum_engine.get_allowed_math_operators("11", "5")
-    
-    steps = [
-        ProofStep(1, "f(x)=x^2", "Function"),
-        ProofStep(2, "f'(x)=2x", "Derivative", operator_used="DERIVATIVE")
-    ]
-    graph = ProofGraph(steps)
-    
-    is_legal, reason = validate_pedagogical_legality(graph, rules)
-    
-    if is_legal:
-        print("✅ Success: Grade 11 correctly allows DERIVATIVE.")
-    else:
-        print(f"❌ Failure: Grade 11 rejected allowed DERIVATIVE. {reason}")
-
-if __name__ == "__main__":
-    try:
-        test_grade_7_violation()
-        test_grade_8_allowed()
-        test_grade_11_calculus_whitelist()
-        print("\n✨ All isolated pedagogical tests PASSED!")
-    except Exception as e:
-        print(f"\n💥 Test Execution Failed: {e}")
-        sys.exit(1)
diff --git a/tests/archive_scripts/verify_v401_hotfix.py b/tests/archive_scripts/verify_v401_hotfix.py
deleted file mode 100644
index 41d15cbdfcc8d97d6714957781231cb02f4a521f..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/verify_v401_hotfix.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# verify_v401_hotfix.py
-import asyncio
-import sys
-import os
-import json
-
-# Add current directory to path
-sys.path.append(os.getcwd())
-
-from orchestrator import BuddyOrchestrator
-from prompts import get_data_extraction_prompt
-
-def test_single_letter_prompt_enforcement():
-    print("🧪 Testing Data Anchor Prompt (V4.0.1)...")
-    prompt = get_data_extraction_prompt("Solve: number_of_notebooks * 5 = 100")
-    if "SINGLE-LETTER VARIABLE ONLY" in prompt.upper() or "V4.0.1" in prompt:
-        print("✅ Success: Prompt contains V4.0.1 variable enforcement instructions.")
-    else:
-        print("❌ Failure: Prompt missing V4.0.1 instructions.")
-
-async def test_math_integrity_error_response():
-    print("\n🧪 Testing Orchestrator Error Standardization...")
-    orchestrator = BuddyOrchestrator()
-    
-    # We mock the case where smart_solver fails
-    class MockResult:
-        success = False
-    
-    # This is a bit tricky to test without full mock, but let's check the logic in smart_solve
-    # We'll just verify the code structure in orchestrator.py manually or via a targeted mock if possible.
-    # Since I just viewed the file and fixed the indentation, I'm confident in the code block.
-    
-    print("ℹ️ Visual verification of orchestrator.py:862-869 confirmed error object structure.")
-    print("✅ Logic: return {'status': 'RECAPTURE_REQUIRED', 'type': 'error', ...}")
-
-if __name__ == "__main__":
-    test_single_letter_prompt_enforcement()
-    # asyncio.run(test_math_integrity_error_response())
-    print("\n✨ V4.0.1 Basic Logic Verification PASSED!")
diff --git a/tests/archive_scripts/verify_v41_authority.py b/tests/archive_scripts/verify_v41_authority.py
deleted file mode 100644
index 61372e9b283e37b9b91000ef79bf781243ad6eef..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/verify_v41_authority.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# verify_v41_authority.py
-import sys
-import os
-import json
-
-# Add current directory to path
-sys.path.append(os.getcwd())
-
-from proof_graph import ProofGraph, ProofStep
-from pedagogical_builder import build_pedagogical_response
-import curriculum_engine
-
-def test_deterministic_merge():
-    print("🧪 Testing Deterministic Merge (V4.1)...")
-    
-    # 1. Create a ProofGraph (The Truth)
-    steps = [
-        ProofStep(1, "x + 2 = 5", "שיוויון בסיסי"),
-        ProofStep(2, "x = 3", "בידוד הנעלם")
-    ]
-    graph = ProofGraph(steps)
-    
-    # 2. Mock LLM output with different step counts or "distractions"
-    llm_output = {
-        "steps_explanations": [
-            {"step_id": 1, "pedagogical_explanation": "נתחיל מהמשוואה"},
-            {"step_id": 2, "pedagogical_explanation": "נחסר 2 משני האגפים"}
-        ],
-        "teacher_summary": "זה סיכום המורה"
-    }
-    
-    # 3. Build response
-    response = build_pedagogical_response("GENERAL", llm_output, {}, proof_graph=graph)
-    
-    # 4. Verify math is preserved from ProofGraph
-    ui_steps = response["sections"][0]["steps"]
-    if ui_steps[0]["block_math"] == "x + 2 = 5" and ui_steps[1]["block_math"] == "x = 3":
-        print("✅ Success: Math preserved exactly from ProofGraph.")
-    else:
-        print(f"❌ Failure: Math mismatch. Found {ui_steps[0]['block_math']} and {ui_steps[1]['block_math']}")
-
-def test_curriculum_ontology_enforcement():
-    print("\n🧪 Testing Curriculum Ontology Enforcement (V4.1)...")
-    
-    # Grade 7 rules
-    rules = curriculum_engine.get_allowed_math_operators("י׳", level="3") # Example: 3 units might have restrictions
-    grade7_rules = curriculum_engine.get_allowed_math_operators("ז׳", level="4")
-    
-    # Create an ILLEGAL ProofGraph for Grade 7 (System of Equations)
-    illegal_steps = [
-        ProofStep(1, "x + y = 10", "משוואה ראשונה"),
-        ProofStep(2, "x - y = 2", "משוואה שנייה"),
-        ProofStep(3, "2x = 12", "חיבור משוואות", operator_used="SYSTEM_OF_EQUATIONS")
-    ]
-    illegal_graph = ProofGraph(illegal_steps)
-    
-    from proof_graph import validate_pedagogical_legality
-    is_legal, reason = validate_pedagogical_legality(illegal_graph, grade7_rules)
-    
-    if not is_legal and "SYSTEM_OF_EQUATIONS" in reason or "מערכת משוואות" in reason:
-        print("✅ Success: Ontology-based guard REJECTED illegal operator for Grade 7.")
-    else:
-        print(f"❌ Failure: Guard allowed illegal operator or gave wrong reason: {reason}")
-
-if __name__ == "__main__":
-    test_deterministic_merge()
-    test_curriculum_ontology_enforcement()
-    print("\n✨ V4.1 Truth Authority Logic Verification PASSED!")
diff --git a/tests/archive_scripts/verify_v428_strategies.py b/tests/archive_scripts/verify_v428_strategies.py
deleted file mode 100644
index 152fefa25b6b95a5e161578a37b33ebd91a2c41c..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/verify_v428_strategies.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import unittest
-from unittest.mock import MagicMock
-import sys
-import os
-
-# Mock dependencies to avoid loading the whole project
-sys.modules['ocr_strip_engine'] = MagicMock()
-sys.modules['explanation_math_firewall'] = MagicMock()
-sys.modules['visuals'] = MagicMock()
-sys.modules['audio_generator'] = MagicMock()
-sys.modules['gibberish_detector'] = MagicMock()
-sys.modules['cv2'] = MagicMock()
-
-import strategy_policy_engine
-import math_intent_detector
-
-class TestV428StrategyConstraint(unittest.TestCase):
-    def test_policy_engine_geometry(self):
-        intent = "GEOMETRY_ANALYTIC"
-        vector = strategy_policy_engine.get_allowed_strategies(intent)
-        self.assertIn("algebraic_intersection", vector["allowed"])
-        self.assertIn("differentiation", vector["forbidden"])
-
-    def test_policy_engine_linear(self):
-        intent = "SIMPLE_LINEAR_SOLVE"
-        vector = strategy_policy_engine.get_allowed_strategies(intent)
-        self.assertIn("single_variable_isolation", vector["allowed"])
-        self.assertIn("substitution_method", vector["forbidden"])
-
-    def test_intent_merging_logic(self):
-        # Simulation of the logic I added to orchestrator.py
-        intent = "GEOMETRY_ANALYTIC"
-        strategy_vector = strategy_policy_engine.get_allowed_strategies(intent)
-        intent_contract = {"forbidden_strategies": ["guessing"]}
-        
-        if strategy_vector.get("forbidden"):
-            intent_contract["forbidden_strategies"] = list(set(intent_contract.get("forbidden_strategies", []) + strategy_vector["forbidden"]))
-            
-        self.assertIn("differentiation", intent_contract["forbidden_strategies"])
-        self.assertIn("guessing", intent_contract["forbidden_strategies"])
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/tests/archive_scripts/verify_v42_firewall.py b/tests/archive_scripts/verify_v42_firewall.py
deleted file mode 100644
index 4d0c86c41e65749299f8e4045e77358f623e4f2e..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/verify_v42_firewall.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# verify_v42_firewall.py
-import sys
-import os
-import json
-
-# Add current directory to path
-sys.path.append(os.getcwd())
-
-from proof_graph import ProofGraph, ProofStep
-from pedagogical_builder import build_pedagogical_response
-import explanation_math_firewall
-
-def test_firewall_block():
-    print("🧪 Testing Behavioral Firewall Block (V4.2)...")
-    
-    # 1. Create a simple ProofGraph (Algebra)
-    steps = [ProofStep(1, "x + 2 = 5", "שיוויון בסיסי")]
-    graph = ProofGraph(steps)
-    
-    # 2. Mock LLM output that injects a forbidden concept ("נגזרת")
-    llm_output = {
-        "steps_explanations": [
-            {"step_id": 1, "pedagogical_explanation": "נשתמש במושג הנגזרת כדי למצוא את המשתנה"} # VIOLATION!
-        ],
-        "teacher_summary": "זה סיכום המורה"
-    }
-    
-    # 3. Build response - should raise LLMSchemaError due to firewall
-    try:
-        build_pedagogical_response("GENERAL", llm_output, {}, proof_graph=graph)
-        print("❌ Failure: Firewall ALLOWED a forbidden concept!")
-    except Exception as e:
-        if "Behavioral Firewall Violation" in str(e) and "נגזרת" in str(e):
-             print(f"✅ Success: Firewall BLOCKED forbidden concept. Reason: {e}")
-        else:
-             print(f"❌ Failure: Got wrong error: {e}")
-
-def test_projection_only_lock():
-    print("\n🧪 Testing Projection-Only Lock (V4.2)...")
-    
-    # ProofGraph with 1 step
-    graph = ProofGraph([ProofStep(1, "x = 3", "תשובה סופית")])
-    
-    # LLM with NO steps
-    llm_output = {} 
-    
-    # Response should still have 1 step because it's a projection of the ProofGraph
-    response = build_pedagogical_response("GENERAL", llm_output, {}, proof_graph=graph)
-    
-    ui_steps = response["sections"][0]["steps"]
-    if len(ui_steps) == 1 and ui_steps[0]["block_math"] == "x = 3":
-        print("✅ Success: UI is a projection of the ProofGraph even without LLM input.")
-    else:
-        print(f"❌ Failure: Projection mismatch. Steps found: {len(ui_steps)}")
-
-def test_deterministic_summary():
-    print("\n🧪 Testing Deterministic Summary Renderer (V4.2)...")
-    # This test simulates the orchestrator's summary generation
-    from orchestrator import BuddyOrchestrator
-    
-    # We mock the parts needed for BuddyOrchestrator to run _generate_deterministic_summary
-    class MockOrchestrator(BuddyOrchestrator):
-        def __init__(self): pass # No need for real init
-        
-    orchestrator = MockOrchestrator()
-    
-    graph = ProofGraph([ProofStep(1, "x=3", "בידוד הנעלם", operator_used="BASIC_ALGEBRA")])
-    
-    summary = orchestrator._generate_deterministic_summary(
-        "GENERAL", 
-        "משוואות", 
-        "x=3", 
-        proof_graph=graph
-    )
-    
-    print(f"Generated Summary: {summary}")
-    
-    if "נבדק שהשתמשת בשיטות: בידוד הנעלם" in summary and "הגענו לתשובה: x=3" in summary:
-        print("✅ Success: Deterministic summary followed the template correctly.")
-    else:
-        print("❌ Failure: Summary did not follow the template or missing data.")
-
-if __name__ == "__main__":
-    test_firewall_block()
-    test_projection_only_lock()
-    test_deterministic_summary()
-    print("\n✨ V4.2 Behavioral Firewall Verification PASSED!")
diff --git a/tests/archive_scripts/verify_v42_lockdown.py b/tests/archive_scripts/verify_v42_lockdown.py
deleted file mode 100644
index 2476452c12cfb7d2589107d43532df19fa1df05b..0000000000000000000000000000000000000000
--- a/tests/archive_scripts/verify_v42_lockdown.py
+++ /dev/null
@@ -1,103 +0,0 @@
-# verify_v42_lockdown.py
-import sys
-import os
-import asyncio
-import re
-from unittest.mock import MagicMock
-
-# Add current directory to path
-sys.path.append(os.getcwd())
-
-# Mock problematic dependencies before importing orchestrator
-sys.modules['cv2'] = MagicMock()
-sys.modules['ocr_strip_engine'] = MagicMock()
-
-import math_intent_detector
-from smart_solver import SmartSolver
-from strategy_manager import StrategyManager
-from orchestrator import seal_pedagogical_output
-
-async def test_grade7_lockdown():
-    print("🧪 [V4.2] Testing Grade 7 Strategy Lockdown...")
-    
-    # 1. Intent Detection
-    problem = "f(x) = 3x + 5. פתור את המשוואה עבור f(x)=0"
-    grade_num = 7
-    intent = math_intent_detector.detect_intent(problem, grade_num)
-    contract = math_intent_detector.get_intent_contract(intent, grade_num)
-    
-    print(f"Detected Intent: {intent}")
-    
-    if intent != "SIMPLE_LINEAR_SOLVE":
-        print("❌ Failure: Grade 7 problem not classified as SIMPLE_LINEAR_SOLVE")
-        return
-
-    # 2. Output Sealer Test (V4.2.4)
-    print("\n🧪 [V4.2.4] Testing Global Output Sealer...")
-    leaky_response = {
-        "final_answer": "x = -1.66",
-        "teacher_summary": "מצאנו את הנגזרת f'(x) וגילינו שזה קו ישר.",
-        "sections": [{
-            "steps": [{"content_mixed": "נחשב את הנגזרת f(x) = 3x+5..."}]
-        }]
-    }
-    
-    sealed = seal_pedagogical_output(leaky_response, 7)
-    sealed_str = str(sealed)
-    
-    forbidden_terms = ["נגזרת", "f'(x)", "f(x)"]
-    success = True
-    for term in forbidden_terms:
-        if term in sealed_str:
-            print(f"❌ Failure: Forbidden term '{term}' still present in sealed output!")
-            success = False
-    
-    if success:
-        print("✅ Success: Global Sealer scrubbed all forbidden Grade 7 concepts.")
-
-    # 3. StrategyManager Lockdown (Prompt Injection)
-    print("\n🧪 [V4.2.4] Testing StrategyManager Narrative Contract...")
-    mock_llm = MagicMock()
-    captured_prompt = ""
-    
-    async def mock_generate(payload):
-        nonlocal captured_prompt
-        captured_prompt = payload[0] if isinstance(payload, list) else payload
-        mock_resp = MagicMock()
-        mock_resp.text = '{"steps": [{"step_id": 1, "pedagogical_explanation": "הסבר פשוט"}]}'
-        return mock_resp
-
-    mock_llm.generate_content_async = mock_generate
-    
-    manager = StrategyManager(mock_llm)
-    await manager.solve_with_strategy(
-        problem, 
-        {"function_equations": ["3*x + 5"]}, 
-        grade="7", 
-        intent=intent, 
-        intent_contract=contract
-    )
-    
-    if "### STRICT CONTRACT ###" in captured_prompt and "Narrative Projector" in captured_prompt:
-        print("✅ Success: StrategyManager injected STRICT CONTRACT into narrative prompt.")
-    else:
-        print("❌ Failure: STRICT CONTRACT missing from narrative prompt.")
-
-def verify_infrastructure():
-    print("\n🧪 [V4.2] Verifying Infrastructure Lockdown...")
-    import config
-    expected_bucket = "buddy-math-dev.firebasestorage.app"
-    # Try different config structures
-    bucket = getattr(config, 'STORAGE_BUCKET', None)
-    if not bucket and hasattr(config, 'DevelopmentConfig'):
-        bucket = getattr(config.DevelopmentConfig, 'STORAGE_BUCKET', None)
-        
-    if bucket == expected_bucket:
-        print(f"✅ Success: Firebase Storage bucket locked to: {expected_bucket}")
-    else:
-        print(f"❌ Failure: Bucket mismatch! Found: {bucket}")
-
-if __name__ == "__main__":
-    asyncio.run(test_grade7_lockdown())
-    verify_infrastructure()
-    print("\n✨ V4.2.4 Strategy Lockdown Verification COMPLETE!")
diff --git a/tests/inspector.py b/tests/inspector.py
deleted file mode 100644
index daaca8e43b18010a2b499bff85563e3e27a3b0ef..0000000000000000000000000000000000000000
--- a/tests/inspector.py
+++ /dev/null
@@ -1,57 +0,0 @@
-import requests
-import base64
-import json
-import time
-import os
-import sys
-
-# הגדרות
-API_URL = "http://127.0.0.1:8000/solve_stream"
-TEST_IMAGE_PATH = "test_image.png"
-
-def run_inspection_safe():
-    print("🛑 SAFETY CHECK: This script will trigger 1 LLM call.")
-    print("   Estimated cost: $0.0016")
-    confirm = input("   Type 'yes' to proceed: ")
-    
-    if confirm.lower() != 'yes':
-        print("❌ Aborted by user.")
-        return
-
-    # --- מכאן הקוד זהה לקודם, רץ פעם אחת בדיוק ---
-    print("\n🚀 Starting Single Run Inspection...")
-    
-    if not os.path.exists(TEST_IMAGE_PATH):
-        print(f"❌ Error: Image file '{TEST_IMAGE_PATH}' not found.")
-        return
-
-    files = {'file': ('test.png', open(TEST_IMAGE_PATH, 'rb'), 'image/png')}
-    data = {'grade': 'Test', 'mode': 'solve', 'student_name': 'Tester'}
-
-    try:
-        start_time = time.time()
-        # Timeout חובה! מונע המתנה אינסופית
-        response = requests.post(API_URL, files=files, data=data, timeout=60) 
-        
-        print(f"✅ Status Code: {response.status_code}")
-        print(f"⏱️ Time: {time.time() - start_time:.2f}s")
-        
-        if response.status_code == 200:
-            try:
-                data = response.json()
-                print("✅ JSON Valid")
-                print(f"🔑 Keys found: {list(data.keys())}")
-                if "sections" in data:
-                    print(f"📄 Sections count: {len(data['sections'])}")
-            except:
-                print("⚠️ Not a JSON response")
-                print(response.text[:200])
-        else:
-            print("❌ Server Error")
-            print(response.text)
-
-    except Exception as e:
-        print(f"❌ Connection Error: {e}")
-
-if __name__ == "__main__":
-    run_inspection_safe()
\ No newline at end of file
diff --git a/tests/run_golden_set.py b/tests/run_golden_set.py
deleted file mode 100644
index 486c19424ebc0e92b56f027060bd8cbc90c66b84..0000000000000000000000000000000000000000
--- a/tests/run_golden_set.py
+++ /dev/null
@@ -1,123 +0,0 @@
-# tests/run_golden_set.py — V1.0 (Integration Test Runner)
-import asyncio
-import os
-import sys
-import json
-import logging
-import time
-
-# Add parent dir to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-# Import core components
-try:
-    from orchestrator import BuddyOrchestrator
-except ImportError as e:
-    print(f"❌ Error importing orchestrator: {e}")
-    sys.exit(1)
-
-# Configure logging to be minimal for the runner
-logging.basicConfig(level=logging.ERROR)
-logger = logging.getLogger("GOLDEN_SET")
-
-GOLDEN_SET_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "qa_golden_set")
-
-async def run_single_test(orchestrator, filename):
-    filepath = os.path.join(GOLDEN_SET_DIR, filename)
-    print(f"🔬 Testing: {filename}...", end=" ", flush=True)
-    
-    with open(filepath, "rb") as f:
-        image_data = f.read()
-    
-    start_time = time.time()
-    try:
-        # V277.0: FIXED - solve_problem is now an async generator. 
-        # We must iterate over it and collect the final COMPLETE payload.
-        final_result = {}
-        async for event in orchestrator.solve_problem(
-            problem_text="[GOLDEN_SET_AUTO_OCR]",
-            grade="י'",
-            student_name="QA_BOT",
-            image_data=image_data
-        ):
-            # V8.5 logic: If the state is COMPLETE, the payload contains the full standard response
-            if event.state == "COMPLETE" and event.payload:
-                final_result = event.payload
-            elif event.state == "ERROR":
-                final_result = event.payload or {"logic_error": True, "status": "ERROR"}
-
-        result = final_result
-        duration = time.time() - start_time
-        
-        status = result.get("status", "SUCCESS")
-        logic_error = result.get("logic_error", False)
-        error_type = result.get("error_type", "NONE")
-        
-        icon = "✅"
-        if logic_error:
-            icon = f"❌ LOGIC_ERROR ({error_type})"
-        elif not result:
-            icon = "🛑 EMPTY_RESULT"
-            logic_error = True
-        elif status != "SUCCESS":
-            icon = f"⚠️ {status}"
-        else:
-            # 🚨 [SOP FIX] Ensure sections are not empty on Happy Path
-            sections = result.get("sections", [])
-            if not sections:
-                icon = "⚠️ EMPTY_SECTIONS"
-                # We don't necessarily fail the whole test if it's a simple answer only, 
-                # but for the Golden Set, we expect sections.
-            
-        print(f"{icon} ({duration:.1f}s)")
-        
-        return {
-            "file": filename,
-            "status": status,
-            "logic_error": logic_error,
-            "error_type": error_type,
-            "duration": round(duration, 1),
-            "final_answer": str(result.get("final_answer", ""))[:100] + "..."
-        }
-    except Exception as e:
-        print(f"💥 CRASH: {e}")
-        return {
-            "file": filename,
-            "status": "CRASH",
-            "logic_error": True,
-            "error_type": "CRASH",
-            "duration": 0,
-            "final_answer": str(e)
-        }
-
-async def main():
-    if not os.path.exists(GOLDEN_SET_DIR):
-        print(f"❌ Directory not found: {GOLDEN_SET_DIR}")
-        return
-
-    orchestrator = BuddyOrchestrator()
-    files = [f for f in os.listdir(GOLDEN_SET_DIR) if f.lower().endswith(('.jpg', '.jpeg', '.png'))]
-    files.sort()
-    
-    print(f"\n🚀 Starting QA Golden Set Validation (10 images)")
-    print("=" * 60)
-    
-    results = []
-    for f in files:
-        res = await run_single_test(orchestrator, f)
-        results.append(res)
-        # Sleep briefly between tests to avoid hitting quotas too hard
-        await asyncio.sleep(2)
-    
-    print("=" * 60)
-    print(f"🏁 Finished. Success: {len([r for r in results if not r['logic_error']])}/{len(results)}")
-    
-    # Save a JSON report
-    report_path = os.path.join(os.path.dirname(GOLDEN_SET_DIR), "temp", "golden_set_report.json")
-    os.makedirs(os.path.dirname(report_path), exist_ok=True)
-    with open(report_path, "w", encoding="utf-8") as rf:
-        json.dump(results, rf, indent=2, ensure_ascii=False)
-    print(f"📊 Report saved to: {report_path}\n")
-
-if __name__ == "__main__":
-    asyncio.run(main())
diff --git a/tests/test_adaptive_failure.py b/tests/test_adaptive_failure.py
deleted file mode 100644
index d9b3fdae0ac570e84d5bfa42c6e4060c506165ab..0000000000000000000000000000000000000000
--- a/tests/test_adaptive_failure.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import asyncio
-import unittest
-from unittest.mock import MagicMock, AsyncMock
-from orchestrator import BuddyOrchestrator
-from config import CONFIDENCE_THRESHOLD_HIGH, CONFIDENCE_THRESHOLD_MEDIUM
-
-class TestAdaptiveFailureMode(unittest.IsolatedAsyncioTestCase):
-    def setUp(self):
-        self.orchestrator = BuddyOrchestrator()
-        # Mock strategy manager
-        self.orchestrator.strategy_manager = MagicMock()
-        self.orchestrator.strategy_manager.solve_with_strategy = AsyncMock()
-        
-        # Mock internal methods to isolate orchestration logic
-        self.orchestrator._classify_question = AsyncMock(return_value={"complexity": "COMPLEX", "num_parts": 1})
-        self.orchestrator._extract_key_data = AsyncMock(return_value={})
-        self.orchestrator.smart_solve = AsyncMock(return_value={"sections": []})
-
-    async def test_high_confidence_flow(self):
-        print(f"\n🟢 Testing High Confidence (> {CONFIDENCE_THRESHOLD_HIGH}):")
-        self.orchestrator._last_ocr_confidence = CONFIDENCE_THRESHOLD_HIGH + 0.05
-        await self.orchestrator.solve_problem("x + 1 = 2 and we need to solve it step by step for the student", "י'", "TestStudent")
-        
-        # Verify smart_solve was called with ambiguity_warning=False
-        args, kwargs = self.orchestrator.smart_solve.call_args
-        self.assertFalse(kwargs['ambiguity_warning'])
-        print(f"  ✅ High Confidence {self.orchestrator._last_ocr_confidence} - Passed (No warning)")
-
-    async def test_medium_confidence_soft_recovery(self):
-        print(f"\n🟡 Testing Medium Confidence ({CONFIDENCE_THRESHOLD_MEDIUM} - {CONFIDENCE_THRESHOLD_HIGH}):")
-        # Ensure we are in the medium range
-        self.orchestrator._last_ocr_confidence = (CONFIDENCE_THRESHOLD_HIGH + CONFIDENCE_THRESHOLD_MEDIUM) / 2
-        
-        # Force escalation to smart_solve by mocking quick_solve failure
-        self.orchestrator._quick_solve = AsyncMock(return_value=None)
-        
-        await self.orchestrator.solve_problem("x + 1 = 2 and we need to solve it step by step for the student", "י'", "TestStudent")
-        
-        # Verify smart_solve was called with ambiguity_warning=True
-        args, kwargs = self.orchestrator.smart_solve.call_args
-        self.assertTrue(kwargs['ambiguity_warning'])
-        print(f"  ✅ Medium Confidence {self.orchestrator._last_ocr_confidence} - Passed (Soft Recovery triggered)")
-
-    async def test_low_confidence_hard_stop(self):
-        # We need to make sure we are BELOW CONFIDENCE_THRESHOLD_MEDIUM
-        # In DEV it is 0.01, so let's use 0.005
-        low_val = min(0.005, CONFIDENCE_THRESHOLD_MEDIUM - 0.001)
-        print(f"\n🔴 Testing Low Confidence (< {CONFIDENCE_THRESHOLD_MEDIUM}):")
-        self.orchestrator._last_ocr_confidence = low_val
-        result = await self.orchestrator.solve_problem("x + 1 = 2 and we need to solve it step by step for the student", "י'", "TestStudent")
-        
-        # V7.3: Check logic_error and error_type instead of 'status'
-        self.assertTrue(result.get("logic_error"))
-        self.assertEqual(result.get("error_type"), "RECAPTURE_REQUIRED")
-        self.orchestrator.smart_solve.assert_not_called()
-        print(f"  ✅ Low Confidence {self.orchestrator._last_ocr_confidence} - Passed (Hard Stop triggered)")
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/tests/test_ce_fixes.py b/tests/test_ce_fixes.py
deleted file mode 100644
index f1936e18b25142d47234cb5d242981a21970f123..0000000000000000000000000000000000000000
--- a/tests/test_ce_fixes.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# tests/test_ce_fixes.py
-import asyncio
-import os
-import sys
-import logging
-import time
-
-# Add parent dir to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from orchestrator import BuddyOrchestrator
-
-async def test_ce_fixes():
-    orchestrator = BuddyOrchestrator()
-    
-    # 03_ocr_only.jpeg is the target for geometry bypass and truth authority bypass check
-    filename = "03_ocr_only.jpeg"
-    filepath = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "qa_golden_set", filename)
-    
-    if not os.path.exists(filepath):
-        print(f"❌ File not found: {filepath}")
-        return
-
-    print(f"🔬 Testing CE Fixes with: {filename}...")
-    
-    with open(filepath, "rb") as f:
-        image_data = f.read()
-    
-    start_time = time.time()
-    try:
-        result = await orchestrator.solve_problem(
-            problem_text="[CE_FIXES_TEST]",
-            grade="י'",
-            student_name="QA_BOT",
-            image_data=image_data
-        )
-        duration = time.time() - start_time
-        
-        logic_error = result.get("logic_error", False)
-        error_type = result.get("error_type", "NONE")
-        
-        if logic_error:
-            print(f"❌ FAILED: logic_error=True, error_type={error_type}")
-            print(f"Final Answer: {result.get('final_answer')}")
-        else:
-            print(f"✅ SUCCESS! (Duration: {duration:.1f}s)")
-            print(f"Final Answer: {result.get('final_answer')[:100]}...")
-            sections = result.get("sections", [])
-            print(f"Sections found: {len(sections)}")
-            
-    except Exception as e:
-        print(f"💥 CRASH: {e}")
-
-if __name__ == "__main__":
-    asyncio.run(test_ce_fixes())
diff --git a/tests/test_polygraph_gate.py b/tests/test_polygraph_gate.py
deleted file mode 100644
index 1efbb552bfc03ecfc5ed07682cfaf62c9717c067..0000000000000000000000000000000000000000
--- a/tests/test_polygraph_gate.py
+++ /dev/null
@@ -1,146 +0,0 @@
-# tests/test_polygraph_gate.py — V1.0 (QA GATE for MathPolygraph)
-"""
-CTO Directive: Automated QA gate for MathPolygraph.validate_step_sequence.
-
-Definition of Done (must all pass before merge):
-  1. SymPy parse failure → Fail-Closed (False returned, never swallowed)
-  2. 3-second timeout fires on a heavy expression
-  3. Geometry pipe-separated result passes through (no false positive)
-  4. Hebrew-only field is skipped cleanly
-  5. *** Happy Path: a valid algebraic sequence is NOT blocked ***
-"""
-
-import concurrent.futures
-import sys
-import os
-import unittest
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from domain.math_validator import MathPolygraph
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Helpers
-# ─────────────────────────────────────────────────────────────────────────────
-
-def _step(step_id: int, math_latex: str) -> dict:
-    """Build a minimal step dict accepted by MathPolygraph."""
-    return {"step_id": step_id, "math_latex": math_latex}
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Test Cases
-# ─────────────────────────────────────────────────────────────────────────────
-
-class TestPolygraphGate(unittest.TestCase):
-
-    # ── 1. SymPy parse failure → Fail-Closed ──────────────────────────────────
-    def test_gibberish_math_is_fail_closed(self):
-        """An expression SymPy cannot parse must return (False, ...)."""
-        steps = [_step(1, "x**1000@#invalid!$%^")]
-        ok, reason = MathPolygraph.validate_step_sequence(steps)
-        self.assertFalse(ok, msg=f"Expected Fail-Closed but got ok=True. reason={reason}")
-        self.assertIn("SYMPY_PARSING_FAILED", reason, msg=f"Unexpected reason: {reason}")
-        print(f"✅ [1] Gibberish fail-closed: {reason}")
-
-    # ── 2. 3-second timeout fires on heavy expression ─────────────────────────
-    def test_timeout_fires(self):
-        """
-        A very heavy expression must be BLOCKED by the Polygraph gate,
-        guaranteeing it never hangs the server indefinitely.
-
-        CTO guarantee: fail-closed, never hang. The *specific* error code
-        (SYMPY_TIMEOUT vs SYMPY_UNEXPECTED_ERROR) depends on whether the
-        expression hits the 3-second ThreadPoolExecutor deadline or triggers
-        an earlier recursion/memory error in SymPy — both are valid fail-closed
-        outcomes.
-        """
-        heavy = "(" + "+".join(f"x**{i}" for i in range(500)) + ")"
-        steps = [_step(1, heavy)]
-        ok, reason = MathPolygraph.validate_step_sequence(steps)
-        if not ok:
-            # Gate blocked correctly — accept any failure reason
-            self.assertFalse(ok)
-            print(f"✅ [2] Heavy expression blocked (fail-closed): reason='{reason[:60]}'")
-        else:
-            # SymPy was fast enough on this machine — no hang, no block needed
-            print(f"ℹ️  [2] Heavy expression parsed within 3s on this machine. ok={ok}. Acceptable.")
-
-    def test_timeout_reason_via_mock(self):
-        """
-        Verifies the SYMPY_TIMEOUT code path in isolation using a mock,
-        without depending on machine speed.
-        """
-        from unittest.mock import patch
-        import concurrent.futures
-
-        # Force _sympify_with_timeout to raise TimeoutError
-        with patch.object(
-            MathPolygraph,
-            "_sympify_with_timeout",
-            side_effect=concurrent.futures.TimeoutError,
-        ):
-            ok, reason = MathPolygraph.validate_step_sequence([_step(1, "x+1")])
-        self.assertFalse(ok, msg="Expected Fail-Closed on TimeoutError")
-        self.assertIn("SYMPY_TIMEOUT", reason, msg=f"Unexpected reason: {reason}")
-        print(f"✅ [2b] Mocked timeout returned correct reason: {reason}")
-
-    # ── 3. Geometry pipe-separated result passes (no false positive) ──────────
-    def test_geometry_pipe_result_passes(self):
-        """Pipe-separated geometry labels must not be blocked."""
-        steps = [_step(1, "(0, 5) | (3, 0)")]
-        ok, reason = MathPolygraph.validate_step_sequence(steps)
-        self.assertTrue(ok, msg=f"Geometry pipe result was unexpectedly blocked. reason={reason}")
-        print(f"✅ [3] Geometry pipe-result passed: ok={ok}")
-
-    # ── 4. Hebrew-only field is skipped ───────────────────────────────────────
-    def test_hebrew_only_skips_sympy(self):
-        """Hebrew-only math fields must be accepted without calling SymPy."""
-        steps = [_step(1, "על המעגל")]
-        ok, reason = MathPolygraph.validate_step_sequence(steps)
-        self.assertTrue(ok, msg=f"Hebrew-only field was unexpectedly blocked. reason={reason}")
-        print(f"✅ [4] Hebrew-only field skipped SymPy: ok={ok}")
-
-    # ── 5. HAPPY PATH: valid algebraic sequence is NOT blocked ────────────────
-    def test_happy_path_valid_sequence_passes(self):
-        """
-        CTO requirement: A perfectly valid solution must never be blocked.
-
-        x**2 = 4  →  x = 2
-        These are not algebraically equivalent (by design — step B is a solution
-        of step A, not a simplification), so the equivalence check logs an info
-        but does NOT fail.  Both expressions must be SymPy-parseable, guaranteeing
-        a (True, "") return.
-        """
-        steps = [
-            _step(1, "x**2 - 4"),   # x² = 4  (normalized to x²-4=0)
-            _step(2, "x - 2"),       # x = 2   (normalized to x-2=0)
-        ]
-        ok, reason = MathPolygraph.validate_step_sequence(steps)
-        self.assertTrue(ok, msg=f"Happy Path was unexpectedly BLOCKED! This would break the system. reason={reason}")
-        print(f"✅ [5] Happy Path valid sequence passed: ok={ok}")
-
-    # ── 6. Empty steps list passes (no-op) ───────────────────────────────────
-    def test_empty_steps_passes(self):
-        """Empty list should always return (True, '') — no steps to check."""
-        ok, reason = MathPolygraph.validate_step_sequence([])
-        self.assertTrue(ok)
-        self.assertEqual(reason, "")
-        print(f"✅ [6] Empty steps list: ok={ok}")
-
-    # ── 7. Step with no math field is silently skipped ────────────────────────
-    def test_step_with_no_math_field_skips(self):
-        """Steps without any math field must not cause failures."""
-        steps = [{"step_id": 1, "explanation_text": "נבצע את החישוב"}]
-        ok, reason = MathPolygraph.validate_step_sequence(steps)
-        self.assertTrue(ok, msg=f"Step with no math field was unexpectedly blocked. reason={reason}")
-        print(f"✅ [7] Step with no math field skipped: ok={ok}")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Runner
-# ─────────────────────────────────────────────────────────────────────────────
-
-if __name__ == "__main__":
-    print("\n🔬 [POLYGRAPH QA GATE] Running all tests...\n")
-    unittest.main(verbosity=2)
diff --git a/tests/test_validation_robustness.py b/tests/test_validation_robustness.py
deleted file mode 100644
index e8344305559cbe0bfe7ecd6094a3ceb74dc99d3b..0000000000000000000000000000000000000000
--- a/tests/test_validation_robustness.py
+++ /dev/null
@@ -1,84 +0,0 @@
-import pytest
-import asyncio
-from domain.math_validator import MathPolygraph, _latex_to_sympy_str
-import sympy
-
-@pytest.mark.asyncio
-async def test_blind_stripping_and_regex():
-    # Test that mixed text is preserved and math is extracted
-    text = "נציב $x=5$ ונקבל $y=2$. התוצאה היא $$z=7$$."
-    # _validate_single should return True because all math segments are valid
-    ok, reason = await MathPolygraph._validate_single(text, 1)
-    assert ok, f"Failed mixed text: {reason}"
-
-@pytest.mark.asyncio
-async def test_multiline_display_math():
-    # Test re.DOTALL with multi-line display math
-    text = """הנה משוואה:
-    $$
-    x = 5 + 3
-    y = 10
-    $$
-    סוף."""
-    ok, reason = await MathPolygraph._validate_single(text, 1)
-    assert ok, f"Failed multiline display math: {reason}"
-
-@pytest.mark.asyncio
-async def test_multi_equal_guard():
-    # x=y=5 should not crash unpacking
-    text = "נתון $x = y = 5$."
-    ok, reason = await MathPolygraph._validate_single(text, 1)
-    assert ok, f"Failed multi-equal check: {reason}"
-
-@pytest.mark.asyncio
-async def test_empty_string_guard():
-    # $$$$ should be ignored
-    text = "ריק $$$$ וגם $ $."
-    ok, reason = await MathPolygraph._validate_single(text, 1)
-    assert ok, f"Failed empty string guard: {reason}"
-
-@pytest.mark.asyncio
-async def test_arithmetic_exception_handling():
-    # $1/0$ should not crash the server
-    text = "חלוקה באפס $1/0$."
-    ok, reason = await MathPolygraph._validate_single(text, 1)
-    assert not ok
-    assert "SYMPY_PARSE_ERROR" in reason
-
-@pytest.mark.asyncio
-async def test_variable_trap_in_equivalence():
-    # Algebraic equivalence should pass syntax check but skip numerical identity
-    # x=5 is validated segment by segment (LHS: x, RHS: 5)
-    # are_equivalent for x=5 and x=5 should return True
-    res = MathPolygraph.are_equivalent("x=5", "x=5")
-    assert res is True
-
-@pytest.mark.asyncio
-async def test_numerical_identity_check():
-    # Valid identity
-    assert MathPolygraph.are_equivalent("2+3", "5") is True
-    # Hallucination
-    assert MathPolygraph.are_equivalent("2+3", "6") is False
-
-@pytest.mark.asyncio
-async def test_inequality_guard():
-    # x > 0 should not crash simplify(LHS - RHS)
-    # It should skip identity check and return True because strings are same
-    assert MathPolygraph.are_equivalent("x > 0", "x > 0") is True
-
-@pytest.mark.asyncio
-async def test_rce_protection():
-    # Malicious string that would execute if sympify was used without evaluate=False
-    # However, parse_expr(evaluate=False) just builds the tree.
-    # We just want to ensure it doesn't crash or execute.
-    # Note: testing "exec" in a string is hard without side effects, 
-    # but we can verify it doesn't crash on standard malicious patterns.
-    text = "__import__('os').system('echo hello')"
-    # This should definitely fail parsing or at least not execute
-    ok, reason = await MathPolygraph._check_segment(text, 1)
-    assert not ok
-    assert "SYMPY_PARSE_ERROR" in reason
-
-if __name__ == "__main__":
-    import pytest
-    pytest.main([__file__])
diff --git a/tests/verify_core_v11.py b/tests/verify_core_v11.py
deleted file mode 100644
index 682adbf6a6ac367ffdf96607b5e33ceaa141f2a5..0000000000000000000000000000000000000000
--- a/tests/verify_core_v11.py
+++ /dev/null
@@ -1,89 +0,0 @@
-import json
-import asyncio
-import numpy as np
-from ocr_strip_engine import get_best_sniper_roi, apply_conditional_homography
-from proof_graph import ProofGraph, ProofStep
-from math_sanitizer import ProductionMathSanitizer
-from pedagogical_builder import build_pedagogical_response
-
-async def verify_core_v11():
-    print("🚀 Starting BuddyMath Core V1.1 Verification Suite")
-
-    # 1. Test Layer 1: Vision & Scene Intelligence
-    print("\n👁️ Testing Layer 1: Vision Architecture")
-    mock_img = np.zeros((1000, 1000, 3), dtype=np.uint8)
-    # Simulate a dense math block (white pixels)
-    mock_img[100:150, 200:400] = 255 
-    
-    roi, confidence = get_best_sniper_roi(mock_img)
-    print(f"  - ROI Confidence (Heatmap Prior): {confidence:.2f}")
-    assert confidence > 0.1, "Heatmap prior scoring failure"
-    
-    homography_result = apply_conditional_homography(roi)
-    print("  - Conditional Homography applied successfully.")
-    assert homography_result.shape[0] > 0, "Homography returned empty image"
-
-    # 2. Test Layer 2: Math Safety Lock
-    print("\n🔒 Testing Layer 2: Math Safety Lock")
-    proof_steps = [
-        ProofStep(1, "f(x) = x^2", "Initial Function"),
-        ProofStep(2, "f'(x) = 2x", "Derivative Step")
-    ]
-    pg = ProofGraph(proof_steps)
-    bridge = ProductionMathSanitizer.get_symbolic_bridge(pg)
-    print("  - Symbolic Bridge generated:")
-    print(f"    {bridge.splitlines()[3]}") # Show one line
-    assert "VERIFIED SYMBOLIC BRIDGE" in bridge
-    assert "f(x) = x^2" in bridge
-    
-    sanitized = ProductionMathSanitizer.normalize_latex(r"\frac{x}{2}")
-    print(f"  - Math Sanitizer (Fraction): {sanitized}")
-    assert sanitized == "(x)/(2)"
-
-    # 3. Test Layer 3: Pedagogical Engine (LOPA)
-    print("\n🎓 Testing Layer 3: Pedagogical Engine")
-    mock_llm_output = {
-        "solution_markdown": "Test solution with steps.",
-        "confidence_score": 0.9,
-        "sections": [
-            {
-                "title": "Steps",
-                "steps": [
-                    {"title": "Step 1"}, {"title": "Step 2"}, 
-                    {"title": "Step 3"}, {"title": "Step 4"}
-                ]
-            }
-        ]
-    }
-    
-    response = build_pedagogical_response("GENERAL", mock_llm_output, {})
-    steps = response['sections'][0]['steps']
-    print(f"  - Cognitive Load Limiter (Step Count): {len(steps)}")
-    
-    visible_count = sum(1 for s in steps if s.get("disclosure_state") == "VISIBLE")
-    hidden_count = sum(1 for s in steps if s.get("disclosure_state") == "HIDDEN")
-    print(f"  - Visible: {visible_count}, Hidden: {hidden_count}")
-    
-    # Priority bypass (from previous hotfix) might return 1 step, but let's check the logic
-    # Actually, build_pedagogical_response with template usually has more steps.
-    # But wait, if llm_output HAS solution_markdown, it returns 1 step.
-    # Let's test with a template-style output (no solution_markdown)
-    mock_template_output = {
-        "confidence_score": 0.9,
-        "sections": [
-            {
-                "title": "Steps",
-                "steps": [{"t":1}, {"t":2}, {"t":3}, {"t":4}, {"t":5}]
-            }
-        ]
-    }
-    response2 = build_pedagogical_response("LINEAR_EQUATION", mock_template_output, {})
-    steps2 = response2['sections'][0]['steps']
-    visible_count2 = sum(1 for s in steps2 if s.get("disclosure_state") == "VISIBLE")
-    print(f"  - Template disclosure: {visible_count2} visible")
-    assert visible_count2 <= 3, "Cognitive Load Limiter failed to hide steps"
-
-    print("\n🏆 BuddyMath Core V1.1 Verified!")
-
-if __name__ == "__main__":
-    asyncio.run(verify_core_v11())
diff --git a/tests/verify_imports.py b/tests/verify_imports.py
deleted file mode 100644
index 49687874029948ea4af03b876429cc497a546604..0000000000000000000000000000000000000000
--- a/tests/verify_imports.py
+++ /dev/null
@@ -1,201 +0,0 @@
-"""
-V231.17 - Lightweight verification script
-Tests imports, syntax, and function signatures WITHOUT needing Google API key.
-"""
-import sys, os
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-os.chdir(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-passed = 0
-failed = 0
-
-def check(name, condition, detail=""):
-    global passed, failed
-    if condition:
-        print(f"  ✅ {name}")
-        passed += 1
-    else:
-        print(f"  ❌ {name} - {detail}")
-        failed += 1
-
-print("=" * 60)
-print("🔬 BuddyMath V231.17 - Local Verification")
-print("=" * 60)
-
-# =========== 1. IMPORTS ===========
-print("\n📦 1. Import Tests:")
-
-try:
-    import json
-    check("json (stdlib)", True)
-except Exception as e:
-    check("json (stdlib)", False, str(e))
-
-try:
-    import json_repair
-    check("json_repair", True)
-except Exception as e:
-    check("json_repair", False, str(e))
-
-try:
-    import micro_prompts
-    check("micro_prompts imports", True)
-except Exception as e:
-    check("micro_prompts imports", False, str(e))
-
-try:
-    import problem_understanding
-    check("problem_understanding imports", True)
-except Exception as e:
-    check("problem_understanding imports", False, str(e))
-
-try:
-    import topic_taxonomy
-    check("topic_taxonomy imports", True)
-except Exception as e:
-    check("topic_taxonomy imports", False, str(e))
-
-try:
-    import validators
-    check("validators imports", True)
-except Exception as e:
-    check("validators imports", False, str(e))
-
-try:
-    import prompts
-    check("prompts imports", True)
-except Exception as e:
-    check("prompts imports", False, str(e))
-
-# =========== 2. MICRO_PROMPTS ===========
-print("\n📝 2. micro_prompts.py Tests:")
-
-try:
-    # Test that json is available inside micro_prompts
-    result = micro_prompts.get_general_prompt({"test": "data"})
-    check("get_general_prompt() works (json.dumps OK)", isinstance(result, str) and len(result) > 20)
-except NameError as e:
-    check("get_general_prompt() works", False, f"NameError: {e}")
-except Exception as e:
-    check("get_general_prompt() works", False, str(e))
-
-try:
-    # Test CIRCLE_EQUATION micro-prompt
-    result = micro_prompts.get_micro_prompt("CIRCLE_EQUATION", {"center": "(3,5)", "radius": "5"})
-    check("CIRCLE_EQUATION micro-prompt", isinstance(result, str) and "מעגל" in result)
-except Exception as e:
-    check("CIRCLE_EQUATION micro-prompt", False, str(e))
-
-try:
-    tokens = micro_prompts.get_prompt_token_count("CIRCLE_EQUATION")
-    check(f"Token count for CIRCLE_EQUATION = {tokens}", tokens > 0)
-except Exception as e:
-    check("Token count", False, str(e))
-
-# =========== 3. PROBLEM UNDERSTANDING ===========
-print("\n🧠 3. problem_understanding.py Tests:")
-
-try:
-    prompt = problem_understanding.get_problem_understanding_prompt(
-        "מצא משוואת מעגל", {"function_equations": [], "points": ["A"]}
-    )
-    check("Understanding prompt generation", isinstance(prompt, str) and len(prompt) > 50)
-except Exception as e:
-    check("Understanding prompt generation", False, str(e))
-
-try:
-    # Test JSON parsing with LaTeX - THE BUG WE FIXED
-    test_json_with_latex = '{"problem_type": "GEOMETRY", "sub_questions": [{"id": "א", "topic": "CIRCLE"}]}'
-    result = problem_understanding.parse_understanding(test_json_with_latex)
-    check("parse_understanding (clean JSON)", result["problem_type"] == "GEOMETRY")
-except Exception as e:
-    check("parse_understanding (clean JSON)", False, str(e))
-
-try:
-    # Test with escaped LaTeX that breaks standard json.loads
-    test_bad_json = '{"type": "GEOMETRY", "eq": "\\Delta MOA"}'
-    result = problem_understanding.parse_understanding(test_bad_json)
-    check("parse_understanding (LaTeX JSON - json_repair)", "type" in result)
-except Exception as e:
-    check("parse_understanding (LaTeX JSON)", False, str(e))
-
-try:
-    valid = problem_understanding.validate_understanding({
-        "problem_type": "CIRCLE",
-        "sub_questions": [{"id": "א", "question": "test", "topic": "CIRCLE"}],
-        "solving_order": ["א"]
-    })
-    check("validate_understanding", valid == True)
-except Exception as e:
-    check("validate_understanding", False, str(e))
-
-# =========== 4. STRATEGY MANAGER ===========
-print("\n🎯 4. strategy_manager.py Tests:")
-
-try:
-    from strategy_manager import StrategyManager
-    check("StrategyManager class imports", True)
-except Exception as e:
-    check("StrategyManager class imports", False, str(e))
-
-try:
-    import inspect
-    sig = inspect.signature(StrategyManager.solve_with_strategy)
-    params = list(sig.parameters.keys())
-    check(f"solve_with_strategy params: {params}", "image_data" in params)
-except Exception as e:
-    check("solve_with_strategy signature", False, str(e))
-
-try:
-    sig = inspect.signature(StrategyManager._call_llm)
-    params = list(sig.parameters.keys())
-    check(f"_call_llm params: {params}", "image_data" in params and "category" in params)
-except Exception as e:
-    check("_call_llm signature", False, str(e))
-
-# =========== 5. ORCHESTRATOR (without API key) ===========
-print("\n🏗️ 5. orchestrator.py Tests:")
-
-try:
-    # Read the file and check for the kwarg fix
-    with open("orchestrator.py", "r", encoding="utf-8") as f:
-        orch_code = f.read()
-    
-    check("orchestrator.py reads image_bytes from kwargs", 
-          "image_bytes" in orch_code and "kwargs.get('image_bytes'" in orch_code)
-except Exception as e:
-    check("orchestrator.py kwarg check", False, str(e))
-
-try:
-    check("orchestrator.py passes image_data to smart_solve",
-          "image_data=image_data" in orch_code)
-except Exception as e:
-    check("orchestrator image_data pass-through", False, str(e))
-
-try:
-    check("orchestrator.py has V273.0+ version",
-          "V273.0" in orch_code)
-except Exception as e:
-    check("orchestrator version", False, str(e))
-
-# =========== 6. MAIN.PY ===========
-print("\n🌐 6. main.py Tests:")
-
-try:
-    with open("main.py", "r", encoding="utf-8") as f:
-        main_code = f.read()
-    
-    check("main.py sends image_bytes to solve_problem",
-          "image_bytes=image_bytes" in main_code)
-except Exception as e:
-    check("main.py image_bytes check", False, str(e))
-
-# =========== SUMMARY ===========
-print("\n" + "=" * 60)
-total = passed + failed
-print(f"📊 Results: {passed}/{total} passed, {failed}/{total} failed")
-if failed == 0:
-    print("🎉 ALL TESTS PASSED! Ready for deploy.")
-else:
-    print(f"⚠️ {failed} test(s) FAILED - fix before deploy!")
-print("=" * 60)
diff --git a/tests/verify_pipeline.py b/tests/verify_pipeline.py
deleted file mode 100644
index 6487b132dee9e66311fe4bbc814cf580bd2c7cbe..0000000000000000000000000000000000000000
--- a/tests/verify_pipeline.py
+++ /dev/null
@@ -1,65 +0,0 @@
-import asyncio
-import os
-import sys
-import json
-from dotenv import load_dotenv
-
-# Add parent directory to path so we can import modules
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from buddy_math_server.orchestrator import BuddyOrchestrator
-
-# Mock image data (1x1 pixel transparent gif)
-MOCK_IMAGE = b'GIF89a\x01\x00\x01\x00\x80\x00\x00\x00\x00\x00\xff\xff\xff!\xf9\x04\x01\x00\x00\x00\x00,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x01D\x00;'
-
-async def test_pipeline():
-    print("🚀 Starting Backend Pipeline Verification...")
-    
-    # Load env
-    load_dotenv()
-    if not os.getenv("GOOGLE_API_KEY"):
-        print("❌ GOOGLE_API_KEY not found in environment!")
-        return
-
-    try:
-        # Initialize Orchestrator
-        print("🔹 Initializing BuddyOrchestrator...")
-        orchestrator = BuddyOrchestrator()
-        
-        # Test Case 1: Geometry Problem (Should trigger Image path)
-        print("\n🧪 Test Case 1: Geometry Problem with Image")
-        problem_text = """
-        במשולש ישר זווית ABC, היתר הוא 10 ס"מ.
-        א. מצא את אורך הניצב אם הניצב השני הוא 6.
-        ב. חשב את שטח המשולש.
-        """
-        
-        # Simulate the call from main.py -> solve_problem
-        # passing image_data as kwargs
-        print("🔹 Calling solve_problem...")
-        result = await orchestrator.solve_problem(
-            problem_text=problem_text,
-            grade="10",
-            student_name="TestUser",
-            student_gender="M",
-            image_data=MOCK_IMAGE
-        )
-        
-        print("\n✅ Pipeline Execution Successful!")
-        print("📄 Result Keys:", result.keys())
-        
-        if "sections" in result:
-             print(f"✅ Generated {len(result['sections'])} sections")
-             for s in result['sections']:
-                 print(f"   - {s.get('section_title')}")
-        else:
-             print("⚠️ No sections found in result (might be legacy fallback?)")
-             print("Result dump:", json.dumps(result, ensure_ascii=False)[:200] + "...")
-
-    except Exception as e:
-        print(f"\n❌ Pipeline Verified FAILED: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    asyncio.run(test_pipeline())
diff --git a/tests/verify_swiss_watch.py b/tests/verify_swiss_watch.py
deleted file mode 100644
index 5c6759a839969c4eaaeb79d3bf93d3638d69ed9e..0000000000000000000000000000000000000000
--- a/tests/verify_swiss_watch.py
+++ /dev/null
@@ -1,67 +0,0 @@
-import json
-from pedagogical_builder import merge_and_verify_explanations, LLMSchemaError
-
-def test_golden_merge():
-    print("🚀 Running The Golden Test: V2.5.3 Swiss Watch")
-
-    # 1. Mock SymPy Truth Nodes (Immutable)
-    sympy_nodes = [
-        {"step_id": 1, "math": "f(x) = x^2", "logic": "מבנה הפונקציה"},
-        {"step_id": 2, "math": "f'(x) = 2x", "logic": "גזירה"}
-    ]
-
-    # 2. Mock LLM Pedagogical Explanations (Skin)
-    llm_explanations = [
-        {"step_id": 1, "pedagogical_explanation": "נתונה לנו פונקציה ריבועית פשוטה."},
-        {"step_id": 2, "pedagogical_explanation": "נשתמש בכלל החזקה כדי למצוא את הנגזרת."}
-    ]
-
-    try:
-        # 3. Perform the Merge
-        final_nodes = merge_and_verify_explanations(sympy_nodes, llm_explanations)
-        
-        print("  ✅ Merge Success!")
-        assert len(final_nodes) == 2
-        assert final_nodes[1]["math"] == "f'(x) = 2x"
-        assert final_nodes[1]["pedagogical_explanation"] == "נשתמש בכלל החזקה כדי למצוא את הנגזרת."
-        
-    except LLMSchemaError as e:
-        print(f"  ❌ Merge Failed: {e}")
-        assert False, "Golden Merge should have succeeded"
-
-    # 4. Test Schema Violations
-    print("\n🛡️ Testing Schema Enforcement (Swiss Watch Locks):")
-    
-    # Violation A: Length Mismatch
-    try:
-        merge_and_verify_explanations(sympy_nodes, llm_explanations[:1])
-        assert False, "Should have failed on length mismatch"
-    except LLMSchemaError:
-        print("  ✅ Length Mismatch Guard - PASSED")
-
-    # Violation B: Unexpected Keys (No Math allowed from LLM)
-    llm_with_math = [
-        {"step_id": 1, "pedagogical_explanation": "...", "math": "hacked math"},
-        {"step_id": 2, "pedagogical_explanation": "..."}
-    ]
-    try:
-        merge_and_verify_explanations(sympy_nodes, llm_with_math)
-        assert False, "Should have failed on unexpected keys (math)"
-    except LLMSchemaError:
-        print("  ✅ Key Enforcement Guard - PASSED")
-
-    # Violation C: Step Order Modified
-    llm_shuffled = [
-        {"step_id": 2, "pedagogical_explanation": "Step 2"},
-        {"step_id": 1, "pedagogical_explanation": "Step 1"}
-    ]
-    try:
-        merge_and_verify_explanations(sympy_nodes, llm_shuffled)
-        assert False, "Should have failed on step order"
-    except LLMSchemaError:
-        print("  ✅ Step Order Guard - PASSED")
-
-    print("\n🏆 The Golden Test: V2.5.3 Swiss Watch - VERIFIED!")
-
-if __name__ == "__main__":
-    test_golden_merge()
diff --git a/tests/verify_v111_hotfix.py b/tests/verify_v111_hotfix.py
deleted file mode 100644
index f145695aee37b2231303eb019760214b30d4eee4..0000000000000000000000000000000000000000
--- a/tests/verify_v111_hotfix.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import json
-from math_sanitizer import sanitize_math_ocr_hotfix
-from orchestrator import select_best_anchor
-
-def verify_v111_hotfix():
-    print("🚀 Starting BuddyMath V1.1.1 Hotfix Verification")
-
-    # 1. Test Aggressive Sanitization (CTO Requirement)
-    print("\n🧼 Testing Aggressive Sanitization:")
-    test_cases = [
-        (" frac(x)(2)", "((x)/(2))"),
-        ("frac (x) ( 2 )", "((x)/(2))"),
-        ("\\left( x + 1 \\right)", "(x+1)")
-    ]
-    
-    for input_str, expected in test_cases:
-        result = sanitize_math_ocr_hotfix(input_str)
-        print(f"  - '{input_str}' -> '{result}'")
-        assert result == expected or result == expected.replace(" ", ""), f"Sanitization mismatch: {result} != {expected}"
-    print("  ✅ Aggressive Sanitization - PASSED")
-
-    # 2. Test Smart Anchor Selection
-    print("\n⚓ Testing Smart Anchor Selection:")
-    candidates = ["f(x)=x", "f(x)=x^2+1", "f(x)=x^2"]
-    best = select_best_anchor(candidates)
-    print(f"  - Best of {candidates} -> '{best}'")
-    assert best == "f(x)=x^2+1", "Smart anchor selection failed (longest policy)"
-    print("  ✅ Smart Anchor Selection - PASSED")
-
-    print("\n🏆 BuddyMath V1.1.1 Hotfix Verified!")
-
-if __name__ == "__main__":
-    verify_v111_hotfix()
diff --git a/tests/verify_v313_hotfix.py b/tests/verify_v313_hotfix.py
deleted file mode 100644
index 7d1e7011f0346f36bcdd3eabb681fc12a15a8a49..0000000000000000000000000000000000000000
--- a/tests/verify_v313_hotfix.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from quota_system import QuotaManager
-from config import IS_PRODUCTION
-
-def verify_v313_hotfix():
-    print(f"🔍 [VERIFY] IS_PRODUCTION: {IS_PRODUCTION}")
-    
-    qm = QuotaManager()
-    # Check default limit
-    limit = qm.limits_config.get("default_limit")
-    print(f"📊 [VERIFY] Default Quota: {limit}")
-    
-    if not IS_PRODUCTION:
-        if limit == 1000:
-            print("✅ [VERIFY] DEV Quota 1000 - PASSED")
-        else:
-            print(f"❌ [VERIFY] DEV Quota 1000 - FAILED (Got {limit})")
-    else:
-        print("ℹ️ [VERIFY] Production environment, skipping 1000-quota check.")
-
-    from config import CONFIDENCE_THRESHOLD_HIGH, CONFIDENCE_THRESHOLD_MEDIUM
-    print(f"⚖️ [VERIFY] High Threshold: {CONFIDENCE_THRESHOLD_HIGH}")
-    print(f"⚖️ [VERIFY] Medium Threshold: {CONFIDENCE_THRESHOLD_MEDIUM}")
-    
-    if CONFIDENCE_THRESHOLD_HIGH == 0.75 and CONFIDENCE_THRESHOLD_MEDIUM == 0.55:
-        print("✅ [VERIFY] Thresholds (0.75/0.55) - PASSED")
-    else:
-        print("❌ [VERIFY] Thresholds - FAILED")
-
-if __name__ == "__main__":
-    verify_v313_hotfix()
diff --git a/tests/verify_v47_rollback.py b/tests/verify_v47_rollback.py
deleted file mode 100644
index 788e923763da9d06f7bfb916b3c8d14a5bc6be77..0000000000000000000000000000000000000000
--- a/tests/verify_v47_rollback.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import json
-import re
-import logging
-import asyncio
-import sympy as sp
-from strategy_manager import StrategyManager
-from pedagogical_builder import build_pedagogical_response
-from orchestrator import verify_math_consistency
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-async def test_v47_rollback():
-    print("🚀 Starting V4.7 Rollback & SymPy Hardening Verification")
-    
-    # 1. Test SymPy Hardening (Risk: Equations crashing)
-    print("\n⚖️ Testing SymPy Hardening:")
-    
-    # Test 1: Equation vs Value (Should be False for identity, even if consistent)
-    anchor = "x^2 = 4"
-    result = "2"
-    is_id, scale = verify_math_consistency(anchor, result)
-    print(f"  - Equation 'x^2 = 4' vs '2': Identical={is_id}, Scale={scale}")
-    assert is_id == False, "Equation and value should not be identical"
-    assert scale == 0.6, "Scale should be 0.6 for non-identity"
-
-    # Test 1b: True Identity (Expression vs Expression)
-    is_id, scale = verify_math_consistency("x^2 + 1", "1 + x^2")
-    print(f"  - Identity 'x^2 + 1' vs '1 + x^2': Identical={is_id}, Scale={scale}")
-    assert is_id == True, "Symbolic identity failed"
-    assert scale == 1.0, "Scale should be 1.0 for identity"
-
-    # Test 2: Invalid syntax handling
-    is_id, scale = verify_math_consistency("!!!invalid!!!", "2")
-    print(f"  - Invalid syntax handling: Identical={is_id}, Scale={scale}")
-    assert is_id == False, "SymPy should return False on crash"
-
-    # Test 3: Derivative Normalization (Hotfix #1)
-    # Using explicit multiplication (*) as sympify is strict
-    is_id, scale = verify_math_consistency("f'(x) = 2*x", "Derivative(f(x), x) = 2*x")
-    print(f"  - Derivative 'f'(x)' normalization: Identical={is_id}, Scale={scale}")
-    assert is_id == True, "Derivative normalization identity failed"
-
-    # 2. Test Strategy Manager V4.7 Output
-    sm = StrategyManager(None)
-    raw_response = """
-    {
-      "confidence_score": 0.9,
-      "is_valid": true,
-      "latex_result": "x=2",
-      "solution_markdown": "התשובה היא $x=2$."
-    }
-    """
-    parsed = sm._parse_v4_json(raw_response)
-    print("\n✅ Strategy Manager V4.7 Parsing: Passed")
-
-    # 3. Test Pedagogical Builder Priority Bypass (Hotfix #2)
-    ped_response = build_pedagogical_response(
-        topic_id="GENERAL", # Template should be bypassed
-        llm_output=parsed,
-        data_anchor={}
-    )
-    steps = ped_response['sections'][0]['steps']
-    print(f"\n📊 Pedagogical steps count (Priority Bypass): {len(steps)}")
-    # Bypass logic returns precisely 1 step in 1 section
-    assert len(steps) == 1, f"Priority bypass failed, got {len(steps)} steps"
-    assert "התשובה היא" in steps[0]['content_mixed'], "Solution content mismatch"
-    print("✅ Pedagogical Priority Bypass - PASSED")
-
-    print("\n🏆 V4.7 Rollback & SymPy Hardening Verified!")
-
-if __name__ == "__main__":
-    asyncio.run(test_v47_rollback())
diff --git a/tests/verify_v5_pipeline.py b/tests/verify_v5_pipeline.py
deleted file mode 100644
index 3e15bade9c6ef8db778290d75aa3e99a313e666d..0000000000000000000000000000000000000000
--- a/tests/verify_v5_pipeline.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import json
-import re
-import logging
-import asyncio
-from strategy_manager import StrategyManager
-from pedagogical_builder import build_pedagogical_response
-from orchestrator import verify_math_consistency
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-async def test_v5_pipeline():
-    print("🚀 Starting V5.0 Pipeline Verification Test")
-    
-    # 1. Mock Raw LLM Output (with Prefix Leakage Risk #1)
-    raw_response = """
-    Here is the structured solution for you:
-    {
-      "confidence_score": 0.95,
-      "uncertainty_flag": false,
-      "is_valid": true,
-      "blocks": [
-        {"type": "text", "content": "בוא נפתור את המשוואה הנפלאה הזו!"},
-        {"type": "math", "content": "x^2 - 4 = 0"},
-        {"type": "text", "content": "נעביר אגף:"},
-        {"type": "math", "content": "x^2 = 4"},
-        {"type": "text", "content": "ונוציא שורש:"},
-        {"type": "math", "content": "x = \\\\pm 2"}
-      ]
-    }
-    """
-    
-    # 2. Test Strategy Manager Parsing & Hardening
-    sm = StrategyManager(None) # Model not needed for parsing test
-    parsed = sm._parse_v5_json(raw_response)
-    
-    print("✅ Step 1: Prefix Leakage Protection - PASSED")
-    print(f"📊 Parsed block count: {len(parsed.get('blocks', []))}")
-    
-    assert len(parsed['blocks']) == 6, "Block count mismatch"
-    assert sm._validate_v5_schema(parsed), "Schema validation failed"
-    print("✅ Step 2: Schema Validation - PASSED")
-
-    # 3. Test Pedagogical Builder Mapping
-    response = build_pedagogical_response(
-        topic_id="GENERAL",
-        llm_output=parsed,
-        data_anchor={}
-    )
-    
-    steps = response['sections'][0]['steps']
-    print(f"📊 Pedagogical steps count: {len(steps)}")
-    # Template 'GENERAL' adds: Intro step + 'Approach' step + 6 blocks + 'Solution' step = 9 steps
-    assert len(steps) == 9, f"Pedagogical mapping failed, expected 9 steps, got {len(steps)}"
-    print("✅ Step 3: Pedagogical Mapping - PASSED")
-
-    # 4. Test Orchestrator Anchor Protection (Risk #3)
-    # Simulate orchestrator extraction
-    blocks = parsed.get("blocks", [])
-    math_blocks = [b for b in blocks if b.get("type") == "math"]
-    llm_fn = math_blocks[-1]["content"] if math_blocks else "None"
-    
-    print(f"⚖️ Extracted final result for verification: {llm_fn}")
-    assert llm_fn == "x = \\pm 2", "Anchor protection extraction failed"
-    
-    anchor_fn = "x^2 = 4" # Simple anchor for test
-    is_identical, scale = verify_math_consistency(anchor_fn, "2")
-    print(f"⚖️ Symbolic verification (x^2=4 vs 2): {is_identical}, scale: {scale}")
-    
-    print("\n🏆 V5.0 End-to-End Pipeline Verified!")
-
-if __name__ == "__main__":
-    asyncio.run(test_v5_pipeline())
diff --git a/tests/verify_validation.py b/tests/verify_validation.py
deleted file mode 100644
index d186e10f7aecd1c219dadc89a2006fa2c6cfcec0..0000000000000000000000000000000000000000
--- a/tests/verify_validation.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import asyncio
-import json
-from sympy import symbols, Eq
-from strategy_manager import StrategyManager
-
-async def run_test():
-    sm = StrategyManager()
-    
-    print("--- TEST 1: General Prompt with Good Math ---")
-    topic_id = "CIRCLE_EQUATION"
-    data_anchor = {"center": [0,0], "radius": 5}
-    llm_resp = {"solution": "x^2 + y^2 = 25"}
-    
-    res = sm._validate(topic_id, llm_resp, data_anchor)
-    print(f"Validation Result: {res}")
-    
-    print("\n--- TEST 2: General Prompt with Bad Math ---")
-    llm_resp_bad = {"solution": "x^2 - (y^2 / 3) = 1"}
-    res2 = sm._validate(topic_id, llm_resp_bad, data_anchor)
-    print(f"Validation Result: {res2}")
-    
-    print("\n--- TEST 3: General Prompt on Unknown Topic ---")
-    res3 = sm._validate("WEIRD_TOPIC", {}, {})
-    print(f"Validation Result: {res3}")
-
-if __name__ == "__main__":
-    asyncio.run(run_test())
diff --git a/topic_taxonomy.py b/topic_taxonomy.py
deleted file mode 100644
index 9d5cb43db83ac28dd890b34c0a31fd486af2df12..0000000000000000000000000000000000000000
--- a/topic_taxonomy.py
+++ /dev/null
@@ -1,611 +0,0 @@
-# topic_taxonomy.py - V231.12
-# Topic detection and classification for BuddyMath
-# Based on Israeli curriculum grades 7-12
-
-"""
-Topic Taxonomy for BuddyMath - Comprehensive Coverage
-Follows BUDDYMATH_COMPLETE_GUIDE principles:
-- General patterns, not example-specific
-- Keyword-based detection
-- Grade-appropriate classification
-"""
-
-# ==================== TOPIC TAXONOMY ====================
-
-TOPIC_TAXONOMY = {
-    # ========== GEOMETRY (Grades 7-12) ==========
-    
-    # V275.3: GEOMETRIC_LOCUS must come BEFORE CIRCLE_EQUATION!
-    # Locus problems mention "מעגל" but are NOT circle-equation problems.
-    # Without a micro-prompt, this falls back to the flexible general prompt.
-    "GEOMETRIC_LOCUS": {
-        "keywords": ["גיאומטרי"],
-        "grade_range": (10, 12),
-        "category": "GEOMETRY",
-        "complexity": "high"
-    },
-    
-    "CIRCLE_EQUATION": {
-        "keywords": ["מעגל", "מרכז", "רדיוס"],
-        "exclude_if": ["גיאומטרי"],  # V275.3: Don't match locus problems
-        "grade_range": (9, 12),
-        "category": "GEOMETRY",
-        "complexity": "medium"
-    },
-    
-    "CIRCLE_TANGENT": {
-        "keywords": ["מעגל", "משיק", "נקודת משיק"],
-        "grade_range": (10, 12),
-        "category": "GEOMETRY",
-        "complexity": "high"
-    },
-    
-    "TRIANGLE_AREA": {
-        "keywords": ["משולש", "שטח"],
-        "grade_range": (7, 10),
-        "category": "GEOMETRY",
-        "complexity": "low"
-    },
-    
-    "TRIANGLE_PYTHAGOREAN": {
-        "keywords": ["משולש", "פיתגורס", "ישר זווית"],
-        "grade_range": (8, 10),
-        "category": "GEOMETRY",
-        "complexity": "medium"
-    },
-    
-    "LINE_EQUATION": {
-        "keywords": ["ישר", "משוואה", "שיפוע"],
-        "grade_range": (9, 12),
-        "category": "GEOMETRY",
-        "complexity": "low"
-    },
-    
-    "LINE_PERPENDICULAR": {
-        "keywords": ["ישר", "אנך", "ניצב"],
-        "grade_range": (9, 12),
-        "category": "GEOMETRY",
-        "complexity": "medium"
-    },
-    
-    "LINE_PARALLEL": {
-        "keywords": ["ישר", "מקביל"],
-        "grade_range": (9, 12),
-        "category": "GEOMETRY",
-        "complexity": "low"
-    },
-    
-    "DISTANCE_FORMULA": {
-        "keywords": ["מרחק", "נקודות"],
-        "grade_range": (9, 12),
-        "category": "GEOMETRY",
-        "complexity": "low"
-    },
-    
-    "PARABOLA": {
-        "keywords": ["פרבולה", "ריבועית"],
-        "grade_range": (10, 12),
-        "category": "GEOMETRY",
-        "complexity": "high"
-    },
-    
-    # ========== CALCULUS (Grades 11-12) ==========
-    
-    "DERIVATIVE_POWER": {
-        "keywords": ["נגזרת", "חזקה"],
-        "grade_range": (11, 12),
-        "category": "CALCULUS",
-        "complexity": "low"
-    },
-    
-    "DERIVATIVE_QUOTIENT": {
-        "keywords": ["נגזרת", "מנה", "חילוק"],
-        "grade_range": (11, 12),
-        "category": "CALCULUS",
-        "complexity": "high"
-    },
-    
-    "DERIVATIVE_PRODUCT": {
-        "keywords": ["נגזרת", "מכפלה"],
-        "grade_range": (11, 12),
-        "category": "CALCULUS",
-        "complexity": "medium"
-    },
-    
-    "DERIVATIVE_CHAIN": {
-        "keywords": ["נגזרת", "שרשרת", "הרכבה"],
-        "grade_range": (11, 12),
-        "category": "CALCULUS",
-        "complexity": "high"
-    },
-    
-    "DERIVATIVE_TRIG": {
-        "keywords": ["נגזרת", "sin", "cos", "tan"],
-        "grade_range": (11, 12),
-        "category": "CALCULUS",
-        "complexity": "medium"
-    },
-    
-    "INVESTIGATION_EXTREMA": {
-        "keywords": ["חקור", "קיצון", "מקסימום", "מינימום"],
-        "grade_range": (11, 12),
-        "category": "INVESTIGATION",
-        "complexity": "high"
-    },
-    
-    "INVESTIGATION_MONOTONICITY": {
-        "keywords": ["חקור", "עולה", "יורדת"],
-        "grade_range": (11, 12),
-        "category": "INVESTIGATION",
-        "complexity": "medium"
-    },
-    
-    "INVESTIGATION_CONCAVITY": {
-        "keywords": ["חקור", "קמירות", "קעירות"],
-        "grade_range": (12, 12),
-        "category": "INVESTIGATION",
-        "complexity": "high"
-    },
-    
-    "INVESTIGATION_ASYMPTOTES": {
-        "keywords": ["חקור", "אסימפטוטה"],
-        "grade_range": (11, 12),
-        "category": "INVESTIGATION",
-        "complexity": "high"
-    },
-    
-    "INTEGRAL_BASIC": {
-        "keywords": ["אינטגרל", "שטח"],
-        "grade_range": (12, 12),
-        "category": "CALCULUS",
-        "complexity": "medium"
-    },
-    
-    # ========== ALGEBRA (Grades 7-12) ==========
-    
-    "LINEAR_EQUATION": {
-        "keywords": ["משוואה", "x=", "פתור"],
-        "grade_range": (7, 9),
-        "category": "ALGEBRA",
-        "complexity": "low"
-    },
-    
-    "QUADRATIC_EQUATION": {
-        "keywords": ["משוואה", "ריבועית", "x²"],
-        "grade_range": (9, 12),
-        "category": "ALGEBRA",
-        "complexity": "medium"
-    },
-    
-    "SYSTEM_EQUATIONS": {
-        "keywords": ["מערכת", "משוואות"],
-        "grade_range": (8, 10),
-        "category": "ALGEBRA",
-        "complexity": "medium"
-    },
-    
-    "EXPONENTS": {
-        "keywords": ["חזקה", "מעריכי"],
-        "grade_range": (7, 10),
-        "category": "ALGEBRA",
-        "complexity": "low"
-    },
-    
-    "LOGARITHM": {
-        "keywords": ["לוגריתם", "log"],
-        "grade_range": (11, 12),
-        "category": "ALGEBRA",
-        "complexity": "high"
-    },
-    
-    # ========== TRIGONOMETRY (Grades 10-12) ==========
-    
-    "TRIG_BASIC": {
-        "keywords": ["sin", "cos", "tan", "סינוס", "קוסינוס"],
-        "grade_range": (10, 12),
-        "category": "TRIGONOMETRY",
-        "complexity": "medium"
-    },
-    
-    "TRIG_IDENTITIES": {
-        "keywords": ["זהות", "טריגונומטרית"],
-        "grade_range": (11, 12),
-        "category": "TRIGONOMETRY",
-        "complexity": "high"
-    },
-    
-    # ========== PROBABILITY (Grades 11-12) ==========
-    
-    "PROBABILITY_BASIC": {
-        "keywords": ["הסתברות", "סיכוי"],
-        "grade_range": (11, 12),
-        "category": "PROBABILITY",
-        "complexity": "medium"
-    },
-    
-    "COMBINATORICS": {
-        "keywords": ["קומבינטוריקה", "צירופים", "תמורות"],
-        "grade_range": (11, 12),
-        "category": "PROBABILITY",
-        "complexity": "high"
-    },
-
-    "PROBABILITY_CONDITIONAL": {
-        "keywords": ["הסתברות", "מותנית", "P(", "בהינתן"],
-        "grade_range": (11, 12),
-        "category": "PROBABILITY",
-        "complexity": "high"
-    },
-
-    "PROBABILITY_TREE": {
-        "keywords": ["הסתברות", "עץ", "שלבים", "מדגם"],
-        "grade_range": (9, 12),
-        "category": "PROBABILITY",
-        "complexity": "medium"
-    },
-
-    # ========== SEQUENCES (Grades 9-12) ==========
-
-    "SEQUENCE_ARITHMETIC": {
-        "keywords": ["סדרה", "חשבונית", "הפרש"],
-        "grade_range": (9, 12),
-        "category": "SEQUENCES",
-        "complexity": "medium"
-    },
-
-    "SEQUENCE_GEOMETRIC": {
-        "keywords": ["סדרה", "הנדסית", "מנה"],
-        "grade_range": (9, 12),
-        "category": "SEQUENCES",
-        "complexity": "medium"
-    },
-
-    "SEQUENCE_SUM": {
-        "keywords": ["סכום", "סדרה", "חלקי", "ראשונים"],
-        "grade_range": (10, 12),
-        "category": "SEQUENCES",
-        "complexity": "high"
-    },
-
-    "SEQUENCE_RECURSIVE": {
-        "keywords": ["סדרה", "נוסחת", "נסיגה", "רקורסיבית"],
-        "grade_range": (10, 12),
-        "category": "SEQUENCES",
-        "complexity": "high"
-    },
-
-    # ========== COMPLEX NUMBERS (Grades 11-12, 5 units) ==========
-
-    "COMPLEX_BASIC": {
-        "keywords": ["מרוכב", "מדומה", "i"],
-        "grade_range": (11, 12),
-        "category": "COMPLEX_NUMBERS",
-        "complexity": "medium"
-    },
-
-    "COMPLEX_POLAR": {
-        "keywords": ["מרוכב", "קוטבי", "טריגונומטרי", "מודולוס"],
-        "grade_range": (11, 12),
-        "category": "COMPLEX_NUMBERS",
-        "complexity": "high"
-    },
-
-    "COMPLEX_ROOTS": {
-        "keywords": ["מרוכב", "שורש", "דה-מואבר"],
-        "grade_range": (11, 12),
-        "category": "COMPLEX_NUMBERS",
-        "complexity": "high"
-    },
-
-    # ========== VECTORS (Grade 12, 5 units) ==========
-
-    "VECTORS_BASIC": {
-        "keywords": ["וקטור", "גודל", "כיוון"],
-        "grade_range": (12, 12),
-        "category": "VECTORS",
-        "complexity": "medium"
-    },
-
-    "VECTORS_OPERATIONS": {
-        "keywords": ["וקטור", "מכפלה", "סקלרית", "חיבור"],
-        "grade_range": (12, 12),
-        "category": "VECTORS",
-        "complexity": "high"
-    },
-
-    # ========== INDUCTION (Grades 11-12, 5 units) ==========
-
-    "INDUCTION": {
-        "keywords": ["אינדוקציה", "הוכח", "n=k", "n טבעי"],
-        "grade_range": (11, 12),
-        "category": "PROOFS",
-        "complexity": "high"
-    },
-
-    # ========== STATISTICS (Grades 7-12) ==========
-
-    "STATISTICS_DESCRIPTIVE": {
-        "keywords": ["ממוצע", "חציון", "שכיח", "סטיית", "תקן"],
-        "grade_range": (7, 12),
-        "category": "STATISTICS",
-        "complexity": "medium"
-    },
-
-    "STATISTICS_DISTRIBUTION": {
-        "keywords": ["התפלגות", "נורמלית", "בינומית"],
-        "grade_range": (11, 12),
-        "category": "STATISTICS",
-        "complexity": "high"
-    },
-
-    # ========== CALCULUS EXTENSIONS (Grades 11-12) ==========
-
-    "INTEGRAL_DEFINITE": {
-        "keywords": ["אינטגרל", "מסוים", "גבולות"],
-        "grade_range": (12, 12),
-        "category": "CALCULUS",
-        "complexity": "high"
-    },
-
-    "INTEGRAL_AREA": {
-        "keywords": ["שטח", "אינטגרל", "תחום", "בין"],
-        "grade_range": (12, 12),
-        "category": "CALCULUS",
-        "complexity": "high"
-    },
-
-    "DIFFERENTIAL_EQUATION": {
-        "keywords": ["דיפרנציאלית", "y'", "dy"],
-        "grade_range": (12, 12),
-        "category": "CALCULUS",
-        "complexity": "high"
-    },
-
-    "INVESTIGATION_FULL": {
-        "keywords": ["חקור", "פונקציה", "תחום", "הגדרה"],
-        "grade_range": (11, 12),
-        "category": "INVESTIGATION",
-        "complexity": "high"
-    },
-
-    # ========== TRIGONOMETRY EXTENSIONS (Grades 10-12) ==========
-
-    "TRIG_EQUATIONS": {
-        "keywords": ["משוואה", "טריגונומטרית", "sin", "cos"],
-        "grade_range": (10, 12),
-        "category": "TRIGONOMETRY",
-        "complexity": "high"
-    },
-
-    "TRIG_LAW_SINES": {
-        "keywords": ["סינוסים", "משפט"],
-        "grade_range": (10, 12),
-        "category": "TRIGONOMETRY",
-        "complexity": "medium"
-    },
-
-    "TRIG_LAW_COSINES": {
-        "keywords": ["קוסינוסים", "משפט"],
-        "grade_range": (10, 12),
-        "category": "TRIGONOMETRY",
-        "complexity": "medium"
-    },
-
-    # ========== GEOMETRY EXTENSIONS (Grades 7-10) ==========
-
-    "TRIANGLE_CONGRUENCE": {
-        "keywords": ["חפיפה", "משולש"],
-        "grade_range": (8, 10),
-        "category": "GEOMETRY",
-        "complexity": "medium"
-    },
-
-    "TRIANGLE_SIMILARITY": {
-        "keywords": ["דמיון", "משולש"],
-        "grade_range": (9, 12),
-        "category": "GEOMETRY",
-        "complexity": "medium"
-    },
-
-    "THALES_THEOREM": {
-        "keywords": ["תאלס", "משפט"],
-        "grade_range": (9, 12),
-        "category": "GEOMETRY",
-        "complexity": "medium"
-    },
-
-    "CIRCLE_GEOMETRY": {
-        "keywords": ["מעגל", "זווית", "היקפית", "מרכזית", "מיתר"],
-        "exclude_if": ["משוואה", "רדיוס"],
-        "grade_range": (9, 12),
-        "category": "GEOMETRY",
-        "complexity": "medium"
-    },
-
-    "VOLUME_SURFACE_AREA": {
-        "keywords": ["נפח", "שטח פנים", "גליל", "חרוט", "כדור", "תיבה", "פירמידה"],
-        "grade_range": (7, 10),
-        "category": "GEOMETRY",
-        "complexity": "medium"
-    },
-
-    "QUADRILATERALS": {
-        "keywords": ["מרובע", "מקבילית", "טרפז", "מעוין", "מלבן"],
-        "grade_range": (7, 10),
-        "category": "GEOMETRY",
-        "complexity": "low"
-    },
-
-    # ========== ALGEBRA EXTENSIONS (Grades 7-12) ==========
-
-    "INEQUALITY": {
-        "keywords": ["אי-שוויון", "אי שוויון", "גדול", "קטן"],
-        "grade_range": (7, 12),
-        "category": "ALGEBRA",
-        "complexity": "medium"
-    },
-
-    "ABSOLUTE_VALUE": {
-        "keywords": ["ערך מוחלט", "|x|"],
-        "grade_range": (9, 12),
-        "category": "ALGEBRA",
-        "complexity": "medium"
-    },
-
-    "PERCENTAGE": {
-        "keywords": ["אחוז", "אחוזים", "%"],
-        "grade_range": (7, 10),
-        "category": "ALGEBRA",
-        "complexity": "low"
-    },
-
-    "RATIO_PROPORTION": {
-        "keywords": ["יחס", "פרופורציה", "ישר", "הפוך"],
-        "grade_range": (7, 9),
-        "category": "ALGEBRA",
-        "complexity": "low"
-    },
-
-    "ALGEBRAIC_EXPRESSIONS": {
-        "keywords": ["ביטוי", "אלגברי", "פשט", "צמצם"],
-        "grade_range": (7, 10),
-        "category": "ALGEBRA",
-        "complexity": "low"
-    },
-
-    "WORD_PROBLEM": {
-        "keywords": ["בעיית", "מילולית", "תרגום", "משוואה"],
-        "grade_range": (7, 12),
-        "category": "ALGEBRA",
-        "complexity": "medium"
-    },
-
-    # ========== FUNCTIONS (Grades 9-12) ==========
-
-    "FUNCTION_SQRT": {
-        "keywords": ["פונקציית", "שורש", "√"],
-        "grade_range": (10, 12),
-        "category": "ALGEBRA",
-        "complexity": "medium"
-    },
-
-    "FUNCTION_EXPONENTIAL": {
-        "keywords": ["מעריכית", "e^", "אקספוננציאלית"],
-        "grade_range": (11, 12),
-        "category": "ALGEBRA",
-        "complexity": "medium"
-    },
-
-    "FUNCTION_DOMAIN": {
-        "keywords": ["תחום", "הגדרה", "פונקציה"],
-        "grade_range": (9, 12),
-        "category": "ALGEBRA",
-        "complexity": "medium"
-    },
-    
-    "GRAPH_IDENTIFICATION": {
-        "keywords": ["איזה מהגרפים", "מתאים לפונקציה", "התאם בין", "מתאמת לגרף"],
-        "grade_range": (9, 12),
-        "category": "GRAPH_IDENTIFICATION",
-        "complexity": "high"
-    },
-}
-
-# ==================== DETECTION FUNCTIONS ====================
-
-def detect_topic(text: str, grade: str = "10") -> str:
-    """
-    Detect specific mathematical topic from problem text.
-    
-    Args:
-        text: Problem text (OCR output)
-        grade: Student grade (e.g., "10", "י\"א 5 יח\"ל")
-    
-    Returns:
-        Topic ID (e.g., "CIRCLE_EQUATION") or "GENERAL"
-    
-    Strategy:
-        1. Extract grade number
-        2. Check each topic's keywords
-        3. Filter by grade range
-        4. Return most specific match
-    """
-    text_lower = text.lower()
-    
-    # Extract grade number
-    grade_num = _extract_grade_number(grade)
-    
-    # Find matching topics
-    matches = []
-    for topic_id, config in TOPIC_TAXONOMY.items():
-        # Check grade range
-        min_grade, max_grade = config["grade_range"]
-        if not (min_grade <= grade_num <= max_grade):
-            continue
-        
-        # V275.3: Check exclusion keywords
-        exclude_keywords = config.get("exclude_if", [])
-        if any(ek in text_lower for ek in exclude_keywords):
-            continue
-        
-        # Check keywords (need at least 2 matches for specificity)
-        keywords = config["keywords"]
-        matches_count = sum(1 for kw in keywords if kw in text_lower)
-        
-        if matches_count >= min(2, len(keywords)):
-            matches.append((topic_id, matches_count, config["complexity"]))
-    
-    if not matches:
-        return "GENERAL"
-    
-    # Sort by: 1) keyword matches, 2) complexity (prefer specific)
-    matches.sort(key=lambda x: (x[1], x[2] == "high"), reverse=True)
-    
-    return matches[0][0]
-
-
-def get_topic_category(topic_id: str) -> str:
-    """Get category for a topic (GEOMETRY, CALCULUS, etc.)"""
-    if topic_id == "GENERAL":
-        return "GENERAL"
-    return TOPIC_TAXONOMY.get(topic_id, {}).get("category", "GENERAL")
-
-
-def _extract_grade_number(grade: str) -> int:
-    """Extract numeric grade from string like 'י\"א 5 יח\"ל' or '10'"""
-    # Hebrew grades
-    hebrew_grades = {
-        'ז': 7, 'ח': 8, 'ט': 9,
-        'י': 10, 'יא': 11, 'יב': 12
-    }
-    
-    for heb, num in hebrew_grades.items():
-        if heb in grade:
-            return num
-    
-    # Numeric grades
-    import re
-    match = re.search(r'\d+', grade)
-    if match:
-        return int(match.group())
-    
-    return 10  # Default
-
-
-# ==================== USAGE EXAMPLE ====================
-
-if __name__ == "__main__":
-    # Test cases
-    test_cases = [
-        ("מעגל עם מרכז M(3,5) ורדיוס 5", "10"),
-        ("חקור את הפונקציה f(x) = x³ - 3x", "י\"א 5 יח\"ל"),
-        ("פתור את המשוואה x² + 5x + 6 = 0", "9"),
-        ("מצא את הנגזרת של f(x) = sin(x²)", "12"),
-    ]
-    
-    for text, grade in test_cases:
-        topic = detect_topic(text, grade)
-        category = get_topic_category(topic)
-        print(f"Text: {text[:40]}...")
-        print(f"Grade: {grade} → Topic: {topic} ({category})")
-        print()
diff --git a/tts_manager.py b/tts_manager.py
deleted file mode 100644
index 5c78178389796bdc8d4380fbb3d54c1c1806babf..0000000000000000000000000000000000000000
--- a/tts_manager.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import os
-import re
-import time
-import torch
-import torchaudio
-import warnings
-from pydub import AudioSegment
-from firebase_manager import firebase_manager
-
-warnings.filterwarnings("ignore")
-
-# פתרון גנרי לטעינה על CPU
-original_load = torch.load
-torch.load = lambda *args, **kwargs: original_load(*args, map_location='cpu', **kwargs)
-
-from chatterbox.mtl_tts import ChatterboxMultilingualTTS
-from phonikud_onnx import Phonikud
-from phonikud import lexicon
-
-class TTSManager:
-    def __init__(self, reference_audio_path="teacher_reference.wav"):
-        print("⚙️  טוען מנוע 'המורה למתמטיקה' (Production Mode)...")
-        self.device = "cpu"
-        self.ref_audio_path = reference_audio_path
-        self.phonikud_model = Phonikud("phonikud-1.0.int8.onnx")
-        self.tts_model = ChatterboxMultilingualTTS.from_pretrained(device=self.device)
-        print("✅ המנוע מוכן לייצור דינמי.")
-
-    def _split_to_sentences(self, text):
-        return [s.strip() for s in re.split(r'(?<=[.!?]) +', text) if s.strip()]
-
-    def generate_and_upload(self, text):
-        """
-        מייצר קול חדש, מעלה לענן ומחזיר URL.
-        משמש רק למשפטים דינמיים שאינם קבועים מראש.
-        """
-        timestamp = int(time.time())
-        local_temp = f"audio_{timestamp}.wav"
-        
-        sentences = self._split_to_sentences(text)
-        combined = AudioSegment.empty()
-        silence = AudioSegment.silent(duration=800) 
-
-        for i, sentence in enumerate(sentences):
-            temp_part = f"temp_{timestamp}_{i}.wav"
-            voweled = self.phonikud_model.add_diacritics(sentence)
-            voweled = re.sub(fr"[{lexicon.NON_STANDARD_DIAC}]", "", voweled)
-            
-            wav = self.tts_model.generate(
-                voweled, 
-                language_id="he", 
-                audio_prompt_path=self.ref_audio_path,
-                cfg_weight=0.90 
-            )
-            torchaudio.save(temp_part, wav, self.tts_model.sr)
-            combined += AudioSegment.from_wav(temp_part) + silence
-            os.remove(temp_part)
-
-        combined.export(local_temp, format="wav")
-        
-        # העלאה לפי הפורמט שביקשת
-        url = firebase_manager.upload_file(local_temp, f"audio/{local_temp}")
-        
-        # ניקוי מקומי
-        if os.path.exists(local_temp):
-            os.remove(local_temp)
-            
-        return url
-
-# בסיום הקוד לא מריצים כלום - הוא מחכה לייבוא (Import) מהשרת
-if __name__ == "__main__":
-    print("🚀 TTS Manager מוכן לשימוש. אין הרצות אוטומיות.")
\ No newline at end of file
diff --git a/tutor_reminder_engine.py b/tutor_reminder_engine.py
deleted file mode 100644
index 2ff889a1c11aa5115be5b251930fe8e37f91085c..0000000000000000000000000000000000000000
--- a/tutor_reminder_engine.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# buddy_math_server/tutor_reminder_engine.py
-import time
-import logging
-from firebase_manager import firebase_manager
-from firebase_admin import messaging
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-def send_push_notification(uid, name, category):
-    """
-    Sends a personalized FCM notification to the user.
-    """
-    try:
-        # 1. Fetch user FCM token (In a real app, this would be in the user doc)
-        db = firebase_manager.get_db()
-        user_doc = db.collection('users').document(uid).get()
-        if not user_doc.exists:
-            logger.warning(f"⚠️ [REMINDER] User {uid} not found.")
-            return False
-            
-        fcm_token = user_doc.to_dict().get('fcm_token')
-        if not fcm_token:
-            logger.warning(f"⚠️ [REMINDER] No FCM token for user {uid}.")
-            return False
-
-        # 2. Construct Message
-        message_body = f"היי {name}, המורה מחכה לראות איך פתרת את התרגיל ב-{category}! זה ייקח רק 2 דקות. בא לך לנסות? 💪"
-        
-        message = messaging.Message(
-            notification=messaging.Notification(
-                title="האתגר היומי של Buddy-Math ✏️",
-                body=message_body
-            ),
-            token=fcm_token
-        )
-
-        # 3. Send
-        response = messaging.send(message)
-        logger.info(f"🚀 [REMINDER] Push sent to {uid}: {response}")
-        return True
-    except Exception as e:
-        logger.error(f"❌ [REMINDER] FCM Error: {e}")
-        return False
-
-def run_reminder_check():
-    """
-    V318.0: The Nudge Logic.
-    Finds pending suggestions older than 2 hours and sends reminders.
-    """
-    try:
-        db = firebase_manager.get_db()
-        if not db: return
-
-        # Query all users (In production, use a more efficient index if possible)
-        # For this phase, we iterate through suggestions that match criteria
-        two_hours_ago = time.time() - (2 * 60 * 60)
-        
-        # We need to query across all users' suggestions. 
-        # Firestore collectionGroup is ideal here.
-        suggestions = db.collection_group('suggestions') \
-            .where('status', '==', 'pending') \
-            .where('reminder_sent', '==', False) \
-            .where('created_at', '<', two_hours_ago) \
-            .stream()
-
-        count = 0
-        for sug in suggestions:
-            data = sug.to_dict()
-            sug_path = sug.reference.path # users/{uid}/suggestions/{sid}
-            uid = sug_path.split('/')[1]
-            
-            # Get user name
-            user_doc = db.collection('users').document(uid).get()
-            name = user_doc.to_dict().get('name', 'חבר')
-            category = data.get('category', 'מתמטיקה')
-            
-            # Send Notification
-            success = send_push_notification(uid, name, category)
-            
-            if success:
-                # Update status
-                sug.reference.update({"reminder_sent": True})
-                count += 1
-        
-        logger.info(f"✅ [REMINDER] Processed {count} reminders.")
-        
-    except Exception as e:
-        logger.error(f"❌ [REMINDER] Engine Error: {e}")
-
-if __name__ == "__main__":
-    # Ensure Firebase is initialized
-    firebase_manager.initialize()
-    run_reminder_check()
diff --git a/upload_welcome.py b/upload_welcome.py
deleted file mode 100644
index 34dfa94042e7698fa95c90200541db1ec8710f5c..0000000000000000000000000000000000000000
--- a/upload_welcome.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from firebase_manager import firebase_manager
-import os
-
-# הקובץ שכבר יצרת וקיים בתיקייה
-LOCAL_FILE = "welcome_speech_fixed.wav"
-# הנתיב שבו נשמור אותו בענן (קבוע עבור קובץ הפתיחה)
-DESTINATION = "audio/welcome_teacher_v1.wav"
-
-if os.path.exists(LOCAL_FILE):
-    print(f"📡 מעלה את קובץ הפתיחה הקיים ל-Firebase...")
-    url = firebase_manager.upload_file(LOCAL_FILE, DESTINATION)
-    if url:
-        print(f"✅ הקובץ הועלה! הכתובת הקבועה שלו היא:\n{url}")
-else:
-    print(f"❌ לא מצאתי את הקובץ {LOCAL_FILE}. וודא שאתה מריץ את הסקריפט מאותה תיקייה.")
\ No newline at end of file
diff --git a/usage_stats.json b/usage_stats.json
deleted file mode 100644
index 80a4a3537cc2f518157d53f62ab2d5ee1c9f9164..0000000000000000000000000000000000000000
--- a/usage_stats.json
+++ /dev/null
@@ -1,53 +0,0 @@
-{
-  "2026-02-15": {
-    "limit_test_user": 2
-  },
-  "2026-02-21": {
-    "\u05d3\u05d5\u05ea\u05df": 2
-  },
-  "2026-02-22": {
-    "\u05d3\u05d5\u05ea\u05df": 26
-  },
-  "2026-02-23": {
-    "\u05d3\u05d5\u05ea\u05df": 35
-  },
-  "2026-02-24": {
-    "\u05d3\u05d5\u05ea\u05df": 45
-  },
-  "2026-02-27": {
-    "stress_user_1": 23,
-    "stress_user_2": 23,
-    "stress_user_3": 22,
-    "stress_user_4": 22,
-    "stress_user_0": 22,
-    "\u05d3\u05d5\u05ea\u05df": 13
-  },
-  "2026-02-28": {
-    "\u05d3\u05d5\u05ea\u05df": 11,
-    "diagnostic": 7
-  },
-  "2026-03-01": {
-    "\u05d3\u05d5\u05ea\u05df": 17
-  },
-  "2026-03-02": {
-    "\u05d3\u05d5\u05ea\u05df": 11
-  },
-  "2026-03-03": {
-    "\u05d3\u05d5\u05ea\u05df": 30
-  },
-  "2026-03-04": {
-    "\u05d3\u05d5\u05ea\u05df": 27
-  },
-  "2026-03-05": {
-    "\u05d3\u05d5\u05ea\u05df": 19
-  },
-  "2026-03-06": {
-    "\u05d3\u05d5\u05ea\u05df": 11
-  },
-  "2026-03-07": {
-    "\u05d3\u05d5\u05ea\u05df": 7
-  },
-  "2026-03-08": {
-    "\u05d3\u05d5\u05ea\u05df": 8
-  }
-}
\ No newline at end of file
diff --git a/utils/image_processor.py b/utils/image_processor.py
deleted file mode 100644
index 139ee2042b4e66e8832877d4b04742c88b0400e5..0000000000000000000000000000000000000000
--- a/utils/image_processor.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import cv2
-import numpy as np
-
-def enhance_image_for_math_ocr(image_bytes: bytes) -> bytes:
-    """
-    Upscales and binarizes an image to improve OCR accuracy for math equations.
-    V5.13.14: Added OpenCV Pre-processing layer as requested.
-    """
-    try:
-        # Decode the image bytes to OpenCV format
-        nparr = np.frombuffer(image_bytes, np.uint8)
-        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-
-        if img is None:
-            return image_bytes # Fallback if decode fails
-
-        # 1. Upscale 2x using Cubic Interpolation for smoother edges
-        img = cv2.resize(img, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)
-
-        # 2. Convert to Grayscale
-        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-
-        # 3. Apply slight Gaussian Blur to remove noise before thresholding
-        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
-
-        # 4. Adaptive Thresholding - turns paper to pure white and ink to pure black
-        binary = cv2.adaptiveThreshold(
-            blurred, 
-            255, 
-            cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
-            cv2.THRESH_BINARY, 
-            11, 2
-        )
-
-        # Encode back to JPEG bytes (using .jpg as requested)
-        success, encoded_image = cv2.imencode('.jpg', binary)
-        if success:
-            return encoded_image.tobytes()
-        return image_bytes
-
-    except Exception as e:
-        print(f"⚠️ [IMAGE ENHANCEMENT FAILED]: {e}. Using original image.")
-        return image_bytes
diff --git a/utils/math_utils.py b/utils/math_utils.py
deleted file mode 100644
index dd099289f0d2511d7872c34a75f1b33b149f7e4f..0000000000000000000000000000000000000000
--- a/utils/math_utils.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import re
-
-def sanitize_latex_for_sympy(latex_str: str) -> str:
-    """
-    מסיר פקודות עיצוב של LaTeX (כמו צבעים) כדי ש-SymPy יוכל לפענח את הביטוי.
-    לדוגמה: הופך את \color{red}{5} ל- 5.
-    """
-    if not latex_str:
-        return latex_str
-        
-    # שלב 1: מחלץ את התוכן מתוך פקודות \color{...}{content}
-    cleaned = re.sub(r'\\color\{.*?\}\{(.*?)\}', r'\1', latex_str)
-    
-    # שלב 2: מוחק פקודות \color{...} גלמודות שלא עוטפות כלום
-    cleaned = re.sub(r'\\color\{.*?\}', '', cleaned)
-    
-    # שלב 3: מחיקת פקודות \text{} (SymPy שונא טקסט חופשי)
-    cleaned = re.sub(r'\\text\{.*?\}', '', cleaned)
-    
-    # שלב 4: ניקוי סוגריים מסוג \left( \right)
-    cleaned = cleaned.replace(r'\left', '').replace(r'\right', '')
-    
-    return cleaned
-
-from typing import List
-
-def aggressive_sympy_sanitizer(latex_str: str) -> List[str]:
-    """
-    V9.0.1: Cleans dirty LaTeX generated by the LLM before feeding it to SymPy.
-    Splits comma-separated equations into a list of pure math strings.
-    """
-    if not latex_str:
-        return []
-    
-    s = latex_str
-    
-    # 1. Strip Hebrew Content including surrounding parentheses (e.g. (לכן C))
-    # This prevents leaving behind empty shells like "( C)" which crash SymPy.
-    s = re.sub(r'\([^)]*[\u0590-\u05FF]+[^)]*\)', '', s)
-    s = re.sub(r'[\u0590-\u05FF]+', '', s)
-    
-    # 2. Strip formatting tags (\text{} and \color{})
-    s = re.sub(r'\\text\{.*?\}', '', s)
-    s = re.sub(r'\\color\{.*?\}', '', s)
-    
-    # 3. Replace Logical Arrows with Equals (to maintain equation structure)
-    arrows = [r'\Rightarrow', r'\implies', r'\iff', r'\rightarrow']
-    for arrow in arrows:
-        s = s.replace(arrow, '=')
-
-    # --- 🚀 BEGIN HOTFIX V9.0.3: LATEX MULTIPLICATION ---
-    s = s.replace(r'\cdot', '*').replace(r'\times', '*')
-    # --- END HOTFIX ---
-        
-    # 4. Split multiple equations
-    # SymPy cannot parse "x=0, y=9" as a single AST node. 
-    # We must split by comma and return a list of clean equations.
-    # We also run the existing sanitize_latex_for_sympy on each part.
-    expressions = [sanitize_latex_for_sympy(expr.strip()) for expr in s.split(',')]
-    
-    # Filter out empty strings that might have resulted from the split/regex
-    return [e for e in expressions if e]
diff --git a/utils/safe_json.py b/utils/safe_json.py
deleted file mode 100644
index 5a08726fc325a023128484fd0e094e685448be19..0000000000000000000000000000000000000000
--- a/utils/safe_json.py
+++ /dev/null
@@ -1,156 +0,0 @@
-# utils/safe_json.py — V1.0 (CANONICAL JSON EXTRACTOR)
-"""
-CTO Directive: One canonical JSON extractor for the entire server.
-Replaces 3 ad-hoc implementations in orchestrator.py, strategy_manager.py,
-problem_understanding.py, and ocr_strip_engine.py.
-
-Rules:
-1. LOG the RAW LLM string BEFORE any processing (critical for debugging hallucinations).
-2. LaTeX backslash shield applied BEFORE extraction (prevents json.loads crashes).
-3. json_repair applied before json.loads (handles LLM-malformed JSON).
-4. Fail-CLOSED: any failure returns a safe error dict, never raises.
-5. Supports both {} (dict) and [] (array) top-level JSON blocks.
-"""
-
-import re
-import json
-import logging
-from typing import Union
-
-logger = logging.getLogger(__name__)
-
-try:
-    from json_repair import repair_json
-except ImportError:
-    logger.warning("[SAFE_JSON] json_repair not available. Using raw json.loads fallback.")
-    repair_json = lambda x: x  # noqa: E731
-
-# Sentinel returned on any unrecoverable failure
-_PARSE_FAILURE = {
-    "logic_error": True,
-    "error_type": "PARSING_FAILURE",
-    "final_answer": "מצטערת, התשובה שיצרתי התבלגנה קצת בדרך. נוכל לנסות שוב? 🔄"
-}
-
-
-def safe_extract_json(
-    llm_response_text: str,
-    caller: str = "UNKNOWN",
-    allow_array: bool = True
-) -> Union[dict, list]:
-    """
-    Generic, robust JSON extraction from any LLM response string.
-
-    Args:
-        llm_response_text: Raw text from LLM (may include markdown, prose, LaTeX).
-        caller: Identifier for the calling module (used in log tags).
-        allow_array: If True, accepts top-level JSON arrays [...] as well as objects {...}.
-
-    Returns:
-        Parsed dict or list on success.
-        _PARSE_FAILURE dict on any failure (never raises).
-    """
-    # ── Step 1: LOG RAW INPUT (CTO requirement) ────────────────────────────────
-    logger.info(
-        f"[SAFE_JSON:{caller}] RAW LLM STRING ({len(llm_response_text)} chars): "
-        f"{llm_response_text[:600]!r}"
-    )
-
-    if not llm_response_text or not llm_response_text.strip():
-        logger.error(f"[SAFE_JSON:{caller}] Empty LLM response.")
-        return dict(_PARSE_FAILURE)
-
-    # ── Step 2: Strip markdown fencing (```json ... ```) ──────────────────────
-    # This is the most common wrapper the LLM adds despite instructions
-    text = re.sub(r'```(?:json)?\s*', '', llm_response_text)
-    text = text.replace('```', '')
-
-    # ── Step 3: LaTeX Backslash Shield (CRITICAL FOR MATH) ─────────────────────
-    # LLMs frequently output raw backslashes for LaTeX (\frac, \ln) which are
-    # invalid in JSON strings. We escape them here unless already escaped.
-    # Note: We only escape backslashes that are NOT followed by a valid JSON escape char
-    # or another backslash.
-    shielded = re.sub(r'\\(?![\\"/bfnrtu])', r'\\\\', text)
-
-    # ── Step 4: Locate the outermost JSON block (REGEX MANDATE) ────────────────
-    # V286.2: We use a robust re.DOTALL search to find the outermost {} or [] block.
-    # This ignores any conversational preamble or postamble added by the LLM.
-    pattern = r'(\{.*\}|\[.*\])'
-    match = re.search(pattern, shielded, re.DOTALL)
-    
-    if not match:
-        logger.error(
-            f"[SAFE_JSON:{caller}] No JSON block found via Regex. "
-            f"First 200 chars: {llm_response_text[:200]!r}"
-        )
-        return dict(_PARSE_FAILURE)
-
-    extracted = match.group(0)
-
-    # ── Step 5: Try raw json.loads first ─────────────────────────────────────
-    try:
-        parsed = json.loads(extracted)
-        logger.info(f"[SAFE_JSON:{caller}] ✅ Parsed successfully (direct).")
-        return _sanitize_math_newlines(parsed)
-    except json.JSONDecodeError:
-        pass  # Fall through to json_repair
-
-    # ── Step 5b: json_repair + json.loads (for malformed LLM output) ─────────
-    try:
-        repaired = repair_json(extracted)
-        parsed = json.loads(repaired)
-        logger.info(f"[SAFE_JSON:{caller}] ✅ Parsed successfully (repair).")
-        return _sanitize_math_newlines(parsed)
-
-    except Exception as e:
-        logger.error(f"[SAFE_JSON:{caller}] json_repair fail: {type(e).__name__} - {e}. Extracted: {extracted[:200]!r}")
-
-    # ── Step 6: Last resort — try raw extraction without LaTeX shield ─────────
-    # We look for anything that looks like a JSON block
-    patterns = [
-        r'(\{.*\}|\[.*\])',  # Greedy match for outermost block
-        r'(\{[^{}]*\}|\[[^\[\]]*\])'  # Non-nested match as fallback
-    ]
-
-    try:
-        for pattern in patterns:
-            match = re.search(pattern, llm_response_text, re.DOTALL)
-            if match:
-                parsed = json.loads(repair_json(match.group(0)))
-                logger.warning(f"[SAFE_JSON:{caller}] ✅ Recovered via raw extraction (no LaTeX shield).")
-                return _sanitize_math_newlines(parsed)
-    except Exception:
-        pass
-
-    logger.error(f"[SAFE_JSON:{caller}] 🚨 All extraction strategies failed. Returning PARSE_FAILURE.")
-    return dict(_PARSE_FAILURE)
-
-
-def _sanitize_math_newlines(data: Union[dict, list, str]) -> Union[dict, list, str]:
-    """Recursively cleans up newline characters and restores swallowed LaTeX backslashes."""
-    if isinstance(data, list):
-        return [_sanitize_math_newlines(i) for i in data]
-    elif isinstance(data, dict):
-        new_dict = {}
-        for k, v in data.items():
-            if isinstance(v, str):
-                # V286.1: Fix swallowed backslashes! 
-                # When LLM outputs "\frac", JSON parses \f as form feed (\x0c). \beta as backspace (\x08).
-                v = v.replace('\x0c', r'\f')
-                v = v.replace('\x08', r'\b')
-                v = v.replace('\t', r'\t')
-                v = v.replace('\r', r'\r')
-                
-                # \n might be intended for \neq, \nu, \nabla, \normal, etc.
-                import re
-                v = re.sub(r'\n(eq|u|abla|ormal| left| right)', r'\\n\1', v)
-
-                # Special case for math-heavy keys: ensure no \n breaks rendering
-                if k in ['block_math', 'math_block', 'latex', 'equation', 'content'] or '$' in v:
-                    v = v.replace('\n', ' ')
-                
-                new_dict[k] = v
-            else:
-                new_dict[k] = _sanitize_math_newlines(v)
-        return new_dict
-    return data
diff --git a/validators.py b/validators.py
deleted file mode 100644
index d286c4445dd470ece0475c4825f00a28796d9ef2..0000000000000000000000000000000000000000
--- a/validators.py
+++ /dev/null
@@ -1,410 +0,0 @@
-# validators.py - V231.12
-# Python-based mathematical validation for BuddyMath
-# Uses SymPy to verify LLM outputs are mathematically correct
-
-"""
-Mathematical Validators for BuddyMath
-Follows Iron Law #2: MATHEMATICAL ACCURACY OVER SPEED
-
-Each validator uses SymPy to verify LLM output is correct.
-If validation fails, Strategy Manager triggers retry.
-"""
-
-import ast
-from sympy import symbols, expand, diff, sympify, sqrt, simplify, Eq
-from sympy.parsing.sympy_parser import parse_expr
-import re
-
-# ==================== GEOMETRY VALIDATORS ====================
-
-def validate_circle_equation(llm_output: dict, data_anchor: dict) -> dict:
-    """
-    Validate circle equation using SymPy.
-    
-    Args:
-        llm_output: {"equation": "(x-3)² + (y-5)² = 25"}
-        data_anchor: {"center": (3, 5), "radius": 5}
-    
-    Returns:
-        {"valid": bool, "error": str or None}
-    """
-    try:
-        x, y = symbols('x y')
-        
-        # Expected equation
-        center = data_anchor.get('center', (0, 0))
-        radius = data_anchor.get('radius', 0)
-        
-        if isinstance(center, str):
-            # V8.6.8: Use ast.literal_eval instead of eval() for safety against NameError: name 'x' is not defined
-            try:
-                center = ast.literal_eval(center)
-            except Exception as e:
-                # If literal_eval fails (e.g. Center="A(3,5)"), try regex fallback
-                match = re.search(r'\(([^,]+),([^)]+)\)', center)
-                if match:
-                    center = (float(match.group(1)), float(match.group(2)))
-                else:
-                    return {"valid": False, "error": f"Invalid center format: {center}"}
-        
-        expected = (x - center[0])**2 + (y - center[1])**2 - radius**2
-        
-        # LLM equation (might be under 'equation' or 'solution' if using general prompt)
-        eq_str = llm_output.get('equation') or llm_output.get('solution', '')
-        
-        # If still empty, validation fails
-        if not eq_str:
-            return {"valid": False, "error": "No equation or solution found in LLM output"}
-            
-        # Convert to SymPy
-        eq_str = eq_str.replace('²', '**2').replace('^', '**')
-        
-        # Parse both sides
-        if '=' in eq_str:
-            left, right = eq_str.split('=')
-            actual = sympify(left) - sympify(right)
-        else:
-            actual = sympify(eq_str)
-        
-        # Check if equivalent
-        diff_expr = expand(expected - actual)
-        
-        if diff_expr == 0:
-            return {"valid": True, "error": None}
-        else:
-            return {
-                "valid": False,
-                "error": f"Equation mismatch. Expected: {expected} = 0, Got: {actual} = 0"
-            }
-    
-    except Exception as e:
-        return {"valid": False, "error": f"Validation error: {str(e)}"}
-
-
-def validate_line_equation(llm_output: dict, data_anchor: dict) -> dict:
-    """
-    Validate line equation.
-    
-    Checks:
-    - If two points given, line passes through both
-    - If slope + point given, equation is correct
-    """
-    try:
-        x, y = symbols('x y')
-        
-        # Parse LLM equation (might be under 'equation' or 'solution' if using general prompt)
-        eq_str = llm_output.get('equation') or llm_output.get('solution', '')
-        
-        if not eq_str:
-            return {"valid": False, "error": "No equation or solution found in LLM output"}
-            
-        eq_str = eq_str.replace('^', '**')
-        
-        # Get y as function of x
-        if '=' in eq_str:
-            left, right = eq_str.split('=')
-            if 'y' in left:
-                y_expr = sympify(right)
-            else:
-                y_expr = sympify(left)
-        else:
-            return {"valid": False, "error": "No '=' in equation"}
-        
-        # Validate against data
-        points = data_anchor.get('points', [])
-        
-        for point_str in points:
-            # Parse "A(3,4)" to (3, 4)
-            match = re.search(r'\(([^,]+),([^)]+)\)', point_str)
-            if match:
-                px, py = float(match.group(1)), float(match.group(2))
-                
-                # Check if point satisfies equation
-                y_val = y_expr.subs(x, px)
-                
-                if abs(float(y_val) - py) > 0.01:
-                    return {
-                        "valid": False,
-                        "error": f"Point ({px},{py}) not on line"
-                    }
-        
-        return {"valid": True, "error": None}
-    
-    except Exception as e:
-        return {"valid": False, "error": f"Validation error: {str(e)}"}
-
-
-def validate_locus_equation(llm_output: dict, data_anchor: dict) -> dict:
-    """
-    Validate geometric locus equation.
-    
-    Since loci vary, this performs a basic sanity check:
-    1. Verifies the equation is well-formed (can be parsed by SymPy)
-    2. If points are provided in data_anchor, checks if they satisfy the equation.
-    3. Prevents algebraically impossible equations.
-    """
-    try:
-        x, y = symbols('x y')
-        
-        # Parse LLM equation (might be under 'equation' or 'solution' if using general prompt)
-        eq_str = llm_output.get('equation') or llm_output.get('solution', '')
-        
-        if not eq_str:
-            return {"valid": False, "error": "No equation or solution found in LLM locus output"}
-            
-        eq_str = eq_str.replace('²', '**2').replace('^', '**')
-        
-        if '=' not in eq_str:
-            return {"valid": False, "error": "No '=' in locus equation"}
-            
-        left, right = eq_str.split('=')
-        
-        # Ensure it parses as a valid mathematical expression
-        try:
-            actual_expr = sympify(left) - sympify(right)
-        except Exception as e:
-            return {"valid": False, "error": f"Malformed locus equation: {str(e)}"}
-        
-        # Basic check: locus must depend on x and/or y
-        free_symbols = actual_expr.free_symbols
-        if x not in free_symbols and y not in free_symbols:
-            return {"valid": False, "error": "Locus equation does not contain x or y"}
-            
-        # Validate against provided locus points if any
-        points = data_anchor.get('points', [])
-        for point_str in points:
-            match = re.search(r'\(([^,]+),([^)]+)\)', point_str)
-            if match:
-                px, py = float(match.group(1)), float(match.group(2))
-                
-                # Check if locus point satisfies equation
-                val = actual_expr.subs({x: px, y: py})
-                if abs(float(val)) > 0.01:
-                    return {
-                        "valid": False,
-                        "error": f"Given locus point ({px},{py}) does not satisfy equation"
-                    }
-        
-        return {"valid": True, "error": None}
-    
-    except Exception as e:
-        return {"valid": False, "error": f"Locus validation error: {str(e)}"}
-
-
-def validate_distance(llm_output: dict, data_anchor: dict) -> dict:
-    """Validate distance calculation between two points."""
-    try:
-        # Parse points
-        point_a = data_anchor.get('point_a')
-        point_b = data_anchor.get('point_b')
-        
-        if isinstance(point_a, str):
-            match = re.search(r'\(([^,]+),([^)]+)\)', point_a)
-            if match:
-                point_a = (float(match.group(1)), float(match.group(2)))
-        
-        if isinstance(point_b, str):
-            match = re.search(r'\(([^,]+),([^)]+)\)', point_b)
-            if match:
-                point_b = (float(match.group(1)), float(match.group(2)))
-        
-        # Calculate expected distance
-        dx = point_b[0] - point_a[0]
-        dy = point_b[1] - point_a[1]
-        expected = float(sqrt(dx**2 + dy**2))
-        
-        # LLM distance
-        actual = float(llm_output.get('distance', 0))
-        
-        if abs(expected - actual) < 0.01:
-            return {"valid": True, "error": None}
-        else:
-            return {
-                "valid": False,
-                "error": f"Distance mismatch. Expected: {expected:.2f}, Got: {actual:.2f}"
-            }
-    
-    except Exception as e:
-        return {"valid": False, "error": f"Validation error: {str(e)}"}
-
-
-# ==================== CALCULUS VALIDATORS ====================
-
-def validate_derivative(llm_output: dict, data_anchor: dict) -> dict:
-    """
-    Validate derivative using SymPy.
-    
-    Works for all derivative types (power, quotient, product, chain).
-    """
-    try:
-        x = symbols('x')
-        
-        # Get original function
-        func_str = data_anchor.get('function', '')
-        if not func_str:
-            # Try to reconstruct from numerator/denominator
-            num = data_anchor.get('numerator', '')
-            den = data_anchor.get('denominator', '')
-            if num and den:
-                func_str = f"({num})/({den})"
-        
-        # Parse function
-        func_str = func_str.replace('^', '**').replace('²', '**2')
-        f = sympify(func_str)
-        
-        # Calculate expected derivative
-        expected = diff(f, x)
-        
-        # Parse LLM derivative
-        deriv_str = llm_output.get('derivative', '')
-        deriv_str = deriv_str.replace('^', '**').replace('²', '**2')
-        actual = sympify(deriv_str)
-        
-        # Simplify and compare
-        diff_expr = simplify(expected - actual)
-        
-        if diff_expr == 0:
-            return {"valid": True, "error": None}
-        else:
-            return {
-                "valid": False,
-                "error": f"Derivative mismatch. Expected: {expected}, Got: {actual}"
-            }
-    
-    except Exception as e:
-        return {"valid": False, "error": f"Validation error: {str(e)}"}
-
-
-def validate_extrema(llm_output: dict, data_anchor: dict) -> dict:
-    """
-    Validate extrema (max/min points).
-    
-    Checks:
-    1. f'(x) = 0 at extrema points
-    2. f''(x) confirms type (max/min)
-    """
-    try:
-        x = symbols('x')
-        
-        # Parse function
-        func_str = data_anchor.get('function', '')
-        func_str = func_str.replace('^', '**').replace('²', '**2')
-        f = sympify(func_str)
-        
-        # Calculate derivatives
-        f_prime = diff(f, x)
-        f_double_prime = diff(f_prime, x)
-        
-        # Check each extremum
-        extrema = llm_output.get('extrema', [])
-        
-        for ext in extrema:
-            x_val = ext.get('x')
-            ext_type = ext.get('type')  # 'max' or 'min'
-            
-            # Check f'(x) = 0
-            f_prime_val = float(f_prime.subs(x, x_val))
-            if abs(f_prime_val) > 0.01:
-                return {
-                    "valid": False,
-                    "error": f"f'({x_val}) = {f_prime_val:.3f}, not 0"
-                }
-            
-            # Check f''(x) for type
-            f_double_prime_val = float(f_double_prime.subs(x, x_val))
-            
-            if ext_type == 'min' and f_double_prime_val <= 0:
-                return {
-                    "valid": False,
-                    "error": f"f''({x_val}) = {f_double_prime_val:.3f}, should be > 0 for min"
-                }
-            
-            if ext_type == 'max' and f_double_prime_val >= 0:
-                return {
-                    "valid": False,
-                    "error": f"f''({x_val}) = {f_double_prime_val:.3f}, should be < 0 for max"
-                }
-        
-        return {"valid": True, "error": None}
-    
-    except Exception as e:
-        return {"valid": False, "error": f"Validation error: {str(e)}"}
-
-
-# ==================== ALGEBRA VALIDATORS ====================
-
-def validate_equation_solution(llm_output: dict, data_anchor: dict) -> dict:
-    """Validate solution to equation (linear, quadratic, etc.)"""
-    try:
-        x = symbols('x')
-        
-        # Parse equation
-        eq_str = data_anchor.get('equation', '')
-        eq_str = eq_str.replace('^', '**').replace('²', '**2')
-        
-        if '=' in eq_str:
-            left, right = eq_str.split('=')
-            equation = sympify(left) - sympify(right)
-        else:
-            equation = sympify(eq_str)
-        
-        # Get LLM solution(s)
-        solution = llm_output.get('solution')
-        solutions = llm_output.get('solutions', [])
-        
-        if solution is not None:
-            solutions = [solution]
-        
-        # Check each solution
-        for sol in solutions:
-            result = float(equation.subs(x, sol))
-            if abs(result) > 0.01:
-                return {
-                    "valid": False,
-                    "error": f"x = {sol} does not satisfy equation (result: {result:.3f})"
-                }
-        
-        return {"valid": True, "error": None}
-    
-    except Exception as e:
-        return {"valid": False, "error": f"Validation error: {str(e)}"}
-
-
-# ==================== VALIDATOR REGISTRY ====================
-
-VALIDATORS = {
-    "CIRCLE_EQUATION": validate_circle_equation,
-    "LINE_EQUATION": validate_line_equation,
-    "DISTANCE_FORMULA": validate_distance,
-    "GEOMETRIC_LOCUS": validate_locus_equation,
-    "DERIVATIVE_POWER": validate_derivative,
-    "DERIVATIVE_QUOTIENT": validate_derivative,
-    "DERIVATIVE_PRODUCT": validate_derivative,
-    "DERIVATIVE_CHAIN": validate_derivative,
-    "INVESTIGATION_EXTREMA": validate_extrema,
-    "LINEAR_EQUATION": validate_equation_solution,
-    "QUADRATIC_EQUATION": validate_equation_solution,
-}
-
-
-def get_validator(topic_id: str):
-    """Get validator function for topic, or None if no validator"""
-    return VALIDATORS.get(topic_id)
-
-
-# ==================== USAGE EXAMPLE ====================
-
-if __name__ == "__main__":
-    # Test circle equation
-    llm_out = {"equation": "(x-3)^2 + (y-5)^2 = 25"}
-    data = {"center": (3, 5), "radius": 5}
-    
-    result = validate_circle_equation(llm_out, data)
-    print(f"Circle validation: {result}")
-    
-    # Test derivative
-    llm_out = {"derivative": "3*x**2"}
-    data = {"function": "x^3"}
-    
-    result = validate_derivative(llm_out, data)
-    print(f"Derivative validation: {result}")
diff --git a/visuals.py b/visuals.py
deleted file mode 100644
index f2b6dfb1b8385deac4f21791250d5a881e7a0a96..0000000000000000000000000000000000000000
--- a/visuals.py
+++ /dev/null
@@ -1,354 +0,0 @@
-# visuals.py - V277.0 (Finer Lines + Grid Optimization)
-import matplotlib.pyplot as plt
-import numpy as np
-import io, base64, re, threading
-from concurrent.futures import ThreadPoolExecutor, TimeoutError
-from sympy import sympify, symbols, lambdify, Abs, sin, cos, tan, sqrt, log, ln, exp, solve
-
-print("✅ 🟢 [BIT-LOG: Visuals V277.0] - Finer Lines + Grid Optimization")
-
-def clean_latex_for_sympy(latex_str):
-    """V318.0: Conerts |x| to Abs(x) and \ln to log for SymPy compatibility."""
-    cleaned = re.sub(r'\|(.*?)\|', r'Abs(\1)', latex_str)
-    cleaned = cleaned.replace(r'\ln', 'log')
-    return cleaned
-
-    # 1. Strip Hebrew Characters and parenthetical Hebrew explanations (V9.0.1)
-    expr_str = re.sub(r'\([^)]*[\u0590-\u05FF]+[^)]*\)', '', expr_str)
-    expr_str = re.sub(r'[\u0590-\u05FF]', '', expr_str)
-
-    # 1.1 Replace Logical Arrows with Equals (V9.0.1)
-    arrows = [r'\Rightarrow', r'\implies', r'\iff', r'\rightarrow']
-    for arrow in arrows:
-        expr_str = expr_str.replace(arrow, '=')
-    
-    # 2. Cut multiple equations
-    if r'\\' in expr_str:
-        parts = expr_str.split(r'\\')
-        expr_str = max(parts, key=len)
-
-    text = expr_str.replace(r'\left', '').replace(r'\right', '')
-    
-    # 3. Fraction fix (Safe version for nested braces with Kill-Switch)
-    loop_counter = 0
-    max_loops = 15
-    while r'\frac' in text and loop_counter < max_loops:
-        old_text = text
-        # Regex שמאפשר רמה אחת של סוגריים פנימיים (למשל עבור חזקות)
-        text = re.sub(r'\\frac\s*\{((?:[^{}]|\{[^{}]*\})*)\}\s*\{((?:[^{}]|\{[^{}]*\})*)\}', r'(\1)/(\2)', text)
-        if old_text == text:
-            # חילוץ חירום במקרה של שבירה
-            text = text.replace(r'\frac', '').replace('{', '(').replace('}', ')')
-            break
-        loop_counter += 1
-
-    # 4. BASIC NORMALIZATION (The Foundation)
-    text = text.replace(r'\sin', 'sin').replace(r'\cos', 'cos').replace(r'\tan', 'tan')
-    text = text.replace(r'\ln', 'ln').replace(r'\log', 'log').replace(r'\exp', 'exp')
-    text = text.replace(r'\sqrt', 'sqrt').replace(r'\pi', 'pi').replace(r'\theta', 'theta')
-    
-    # V281.0: CRITICAL FIX - Implicit multiplication before parentheses and functions
-    # 1. Add parentheses to functions missing them: ln x -> ln(x), ln Abs(x) -> ln(Abs(x))
-    # Match function + (identifier or Abs(...) or nested function)
-    text = re.sub(r'(sin|cos|tan|ln|log|exp|sqrt)\s*([a-zA-Z\d]+(?:\([^)]*\))?)', r'\1(\2)', text)
-    
-    # 2. V276.0 CRITICAL FIX: \cdot → * (BEFORE ^ conversion!)
-    text = text.replace(r'\cdot', '*').replace('cdot', '*')
-    
-    # 5. ABSOLUTE VALUE FIX (V309.5: Clean Paired Pipes |x| -> Abs(x))
-    # Using a more surgical regex to avoid fragments like "lnAbsg(x)*Abs"
-    loop_counter = 0
-    while '|' in text and text.count('|') >= 2 and loop_counter < 10:
-        # Match |...| only if it's not part of another command or broken
-        text = re.sub(r'\|([^|]+)\|', r'Abs(\1)', text)
-        loop_counter += 1
-    
-    # Final cleanup: Remove any stray single pipes that didn't form a pair
-    text = text.replace('|', '') 
-    
-    # Convert syntax
-    text = text.replace('^', '**').replace('{', '(').replace('}', ')')
-    text = text.replace('f(x)=', '').replace('y=', '')
-    
-    # 6. ADVANCED FIXES
-    text = text.replace('((x))', '(x)')
-
-    # V230.4 FIX: Trig Powers
-    text = re.sub(r'(sin|cos|tan)\*\*\(?(\d+)\)?\(([^)]*)\)', r'(\1(\3))**\2', text)
-
-    # 6. Cleanup & Whitelist
-    blocklist = ["calculate", "find", "solve", "graph", ":"]
-    for w in blocklist: text = re.sub(rf'\b{w}\b', '', text, flags=re.IGNORECASE)
-
-    # V281.0: REFINED IMPLICIT MULTIPLICATION (Fixes "Pow object is not callable")
-    # x(x+1) -> x*(x+1), 2(x) -> 2*(x), (x)(y) -> (x)*(y)
-    text = re.sub(r'(\d|[a-zA-Z]|\))(\()', r'\1*\2', text)
-    # 2x -> 2*x, )x -> )*x
-    text = re.sub(r'(\d|\))([a-zA-Z\(])', r'\1*\2', text)
-    # (x)y -> (x)*y
-    text = re.sub(r'(\))([a-zA-Z])', r'\1*\2', text) 
-
-    # Whitelist → replaced with targeted blocklist to protect all math-relevant chars
-    # (old whitelist was missing 'f', 'h', 'k', 't', 'r' — caused \frac remnants to corrupt)
-    text = re.sub(r'[\u0590-\u05FF\u200B-\u200D\uFEFF\'"`;@#%&!?]', '', text)  # Hebrew + noise
-    text = re.sub(r'\\[a-zA-Z]+', '', text)  # Any un-converted LaTeX commands
-    
-    return text
-
-# V290.0: Global Timeout Wrapper for SymPy
-def _run_with_timeout(func, args, timeout_duration=2.0, default_value=None):
-    with ThreadPoolExecutor(max_workers=1) as executor:
-        future = executor.submit(func, *args)
-        try:
-            return future.result(timeout=timeout_duration)
-        except Exception as e:
-            print(f"⚠️ [VISUALS TIMEOUT] Operation failed or timed out: {e}")
-            return default_value
-
-def generate_plot(latex_input: str, context_text: str = "", geometric_entities: dict = None) -> str:
-    try:
-        print(f"📈 [VISUALS] generate_plot called with: latex='{latex_input}', geo_entities={list(geometric_entities.keys()) if geometric_entities else None}")
-        # We still sanitize the full input, but we don't split it by comma unconditionally
-        # geometry check uses the first element to avoid implicit matches on secondary graphs
-        first_expr = latex_input.split(',')[0].strip()
-        safe_expr_first = sanitize_math_for_sympy(first_expr)
-        
-        # We sanitize the FULL input to pass to _plot_func
-        safe_expr_full = sanitize_math_for_sympy(latex_input)
-        
-        # בדיקה חכמה: האם באמת יש ישויות גיאומטריות מלאות?
-        has_real_geo = False
-        if geometric_entities:
-            has_real_geo = any(len(v) > 0 for v in geometric_entities.values() if isinstance(v, list))
-    
-        is_implicit = "=" in safe_expr_first or ("x" in safe_expr_first and "y" in safe_expr_first and "**2" in safe_expr_first) or has_real_geo
-        
-        if is_implicit: 
-            return _plot_geo(safe_expr_first, context_text, geometric_entities)
-        return _plot_func(safe_expr_full)
-    except Exception as e:
-        print(f"📈 🔴 [BIT-LOG] CRITICAL PLOT ERROR: {e}")
-        import traceback
-        traceback.print_exc()
-        return None
-
-def _plot_func(expr_str):
-    try:
-        x = symbols('x')
-        local_dict = {"sin": sin, "cos": cos, "tan": tan, "sqrt": sqrt, "Abs": Abs, "pi": np.pi, "ln": ln, "log": log, "exp": exp, "e": exp(1)}
-        
-        # 1. הגדלת שטח הקנבס כך שהקווים יהיו דקים וחדים יותר ביחס לתמונה (Scaling)
-        plt.figure(figsize=(8.0, 5.0), dpi=300) 
-        plt.style.use('dark_background')
-        
-        # 2. הוסר plt.xkcd() לחלוטין כדי למנוע מריחות ועובי גיר מוגזם
-        
-        ax = plt.gca()
-        ax.set_facecolor('#1A1A1B') # צבע פחם עמוק ללוח
-        
-        # 3. הסרת מסגרת הגרף למראה נקי ומרחף
-        ax.spines['top'].set_visible(False)
-        ax.spines['right'].set_visible(False)
-        ax.spines['bottom'].set_visible(False)
-        ax.spines['left'].set_visible(False)
-        
-        x_vals = np.linspace(-10, 10, 500)
-        expressions = [e.strip() for e in expr_str.split(',') if e.strip()]
-        
-        colors = ['#A8E6CF', '#FFD3B6', '#D4A5FF'] # פסטל
-        plotted_any = False
-
-        for idx, single_expr in enumerate(expressions):
-            try:
-                # V318.0: Robust sanitization within the loop
-                single_expr = sanitize_math_for_sympy(single_expr)
-                if not single_expr: continue
-
-                # V8.6.9: Explicit try-except for SYMPY_PARSE_ERROR prevention
-                try:
-                    expr = _run_with_timeout(sympify, (single_expr, None, local_dict), timeout_duration=2.0)
-                except Exception as e:
-                    print(f"⚠️ [VISUALS] SymPy Parse Error on '{single_expr}': {e}")
-                    expr = None
-                
-                if not expr: continue 
-                
-                # Ticket 1 Fix: Handle free symbols (parameters like a, b, k)
-                # We only want to plot with respect to 'x', so replace everything else with 1
-                expr_symbols = expr.free_symbols
-                params = [s for s in expr_symbols if s != x]
-                if params:
-                    print(f"🛠️ [VISUALS] Substituting parameters {params} with 1 for sketch.")
-                    expr = expr.subs({s: 1 for s in params})
-                
-                # Final check if the result is still symbolic
-                if not expr.is_finite: continue
-                
-                f_np = lambdify(x, expr, modules=['numpy'])
-                y_vals = f_np(x_vals)
-                
-                y_vals = np.array(y_vals, dtype=float)
-                y_vals[np.abs(y_vals) > 20] = np.nan
-                
-                # קו הפונקציה: בולט וברור אך לא מרוח
-                plt.plot(x_vals, y_vals, 
-                         color=colors[idx % len(colors)], 
-                         linestyle='-', 
-                         linewidth=2.0,
-                         zorder=5)
-                plotted_any = True
-            except Exception as inner_err:
-                continue
-        
-        if not plotted_any:
-            plt.close()
-            return None
-
-        # ציורים וצירים: עדינים וכמעט שקופים
-        plt.axhline(0, color='white', alpha=0.4, linestyle='-', linewidth=0.8, zorder=2)
-        plt.axvline(0, color='white', alpha=0.4, linestyle='-', linewidth=0.8, zorder=2)
-        plt.grid(color='white', linestyle='--', alpha=0.1, linewidth=0.5, zorder=1)
-        
-        plt.tight_layout(pad=0.5)
-        
-        return _plt_to_svg()
-    except Exception as e:
-        print(f"📈 🔴 [BIT-LOG] Func Plot Error: {e}")
-        return None
-
-def _plot_geo(solution_expr, context_text, geometric_entities=None):
-    """V276.0: Enhanced geometry plotting."""
-    try:
-        # 1. הגדלת שטח הקנבס והסרת xkcd למראה נקי
-        plt.figure(figsize=(8.0, 8.0), dpi=300)
-        plt.style.use('dark_background')
-        
-        ax = plt.gca()
-        ax.set_facecolor('#1A1A1B') # צבע פחם עמוק ללוח
-        
-        # 2. הסרת מסגרת הגרף
-        ax.spines['top'].set_visible(False)
-        ax.spines['right'].set_visible(False)
-        ax.spines['bottom'].set_visible(False)
-        ax.spines['left'].set_visible(False)
-        
-        if geometric_entities:
-            print(f"📈 🟢 [BIT-LOG] Using Explicit Geometric Entities: {geometric_entities.keys()}")
-            
-            for circ in geometric_entities.get('circles', []):
-                try:
-                    c = plt.Circle((circ['center_x'], circ['center_y']), circ['radius'], 
-                                   color='#00D9FF', fill=False, linewidth=1.5)
-                    ax.add_patch(c)
-                except: pass
-
-            point_map = {}
-            for pt in geometric_entities.get('points', []):
-                try:
-                    px, py = float(pt['x']), float(pt['y'])
-                    label = pt.get('label', '')
-                    point_map[label] = (px, py)
-                    plt.plot(px, py, 'o', color='#FF4B4B', markersize=6)
-                    if label:
-                        plt.text(px + 0.3, py + 0.3, label, color='white', fontsize=10, fontweight='bold')
-                except: pass
-            
-            for seg in geometric_entities.get('segments', []):
-                try:
-                    p1 = point_map.get(seg['start'])
-                    p2 = point_map.get(seg['end'])
-                    if p1 and p2:
-                        plt.plot([p1[0], p2[0]], [p1[1], p2[1]], '-', color=seg.get('color', '#FFD700'), linewidth=1.5)
-                except: pass
-
-        if not geometric_entities:
-            circle_match = re.search(r'\(x\s*-\s*(\d+)\)\s*\*\*\s*2\s*\+\s*\(y\s*-\s*(\d+)\)\s*\*\*\s*2\s*=\s*(\d+)', context_text)
-            if not circle_match:
-                circle_match = re.search(r'M\((\d+),(\d+)\).*?r.*?=.*?(\d+)', context_text)
-            
-            if circle_match:
-                try:
-                    center_x = float(circle_match.group(1))
-                    center_y = float(circle_match.group(2))
-                    radius = float(circle_match.group(3))
-                    if radius > 20:
-                        radius = np.sqrt(radius)
-                    circle = plt.Circle((center_x, center_y), radius, color='#00D9FF', fill=False, linewidth=1.5)
-                    ax.add_patch(circle)
-                except: pass
-            
-            points = re.findall(r'([A-Z])\((\d+),(\d+)\)', context_text)
-            for label, px, py in points:
-                px, py = float(px), float(py)
-                plt.plot(px, py, 'o', color='#FF4B4B', markersize=6)
-                plt.text(px + 0.3, py + 0.3, label, color='white', fontsize=10, fontweight='bold')
-            
-            lines = re.findall(r'y\s*=\s*([-+]?\d+/\d+)x\s*([-+]\s*\d+)', context_text)
-            for slope_str, intercept_str in lines:
-                try:
-                    if '/' in slope_str:
-                        num, den = slope_str.split('/')
-                        slope = float(num) / float(den)
-                    else:
-                        slope = float(slope_str)
-                    intercept = float(intercept_str.replace(' ', ''))
-                    x_vals = np.linspace(-2, 12, 100)
-                    y_vals = slope * x_vals + intercept
-                    plt.plot(x_vals, y_vals, '-', color='#FFD700', linewidth=1.5, alpha=0.8)
-                except: pass
-        
-        if "=" in solution_expr:
-            parts = solution_expr.split("=")
-            eq_str = f"({parts[0]}) - ({parts[1]})"
-        else:
-            eq_str = solution_expr
-
-        try:
-            x, y = symbols('x y')
-            # V290.0: Watchdog for Geo Sympify & Contour
-            # V8.6.9: Local try-except for crash prevention
-            try:
-                expr = _run_with_timeout(sympify, (eq_str, None, {"sin": sin, "cos": cos, "tan": tan, "sqrt": sqrt, "Abs": Abs, "pi": np.pi, "ln": ln, "log": log, "exp": exp, "e": exp(1)}), timeout_duration=1.5)
-            except Exception as e:
-                print(f"⚠️ [VISUALS] Geo SymPy Parse Error on '{eq_str}': {e}")
-                expr = None
-            
-            if expr:
-                f_np = _run_with_timeout(lambdify, ((x, y), expr, 'numpy'), timeout_duration=1.0)
-                if f_np:
-                    r = np.linspace(-2, 12, 400)
-                    X, Y = np.meshgrid(r, r)
-                    plt.contour(X, Y, f_np(X, Y), levels=[0], colors='#00FF00', linewidths=1.5)
-        except:
-            pass
-
-        # צירים וגריד עדינים (בדומה ל-_plot_func)
-        plt.axhline(0, color='white', alpha=0.3, linewidth=0.6, zorder=2)
-        plt.axvline(0, color='white', alpha=0.3, linewidth=0.6, zorder=2)
-        plt.grid(True, alpha=0.1, linewidth=0.4, linestyle='--')
-        
-        plt.gca().set_aspect('equal', adjustable='box')
-        plt.xlim(-2, 12)
-        plt.ylim(-2, 12)
-        return _plt_to_svg()
-    except Exception as e:
-        print(f"📈 🔴 [BIT-LOG] Geo Plot Error: {e}")
-        return None
-
-def _plt_to_svg():
-    buf = io.StringIO()
-    # bbox_inches='tight' מונע חיתוך של שולי הגרף במסכים קטנים
-    plt.savefig(buf, format='svg', transparent=True, bbox_inches='tight', pad_inches=0.1)
-    plt.close()
-    
-    svg_str = buf.getvalue()
-    
-    # 🧼 V290.1: ניקוי ה-SVG עבור flutter_svg
-    # הסרת תגיות metadata ו-style שגורמות לאזהרות ב-Flutter
-    import re
-    svg_str = re.sub(r'<metadata>.*?</metadata>', '', svg_str, flags=re.DOTALL)
-    # הערה: אנחנו משאירים את ה-style אם הוא חיוני, אבל flutter_svg לפעמים מתקשה איתו.
-    # במקרה של Matplotlib, ה-style בדרך כלל מכיל הגדרות פונטים שלא קיימות ב-mobile.
-    svg_str = re.sub(r'<style type="text/css">.*?</style>', '', svg_str, flags=re.DOTALL)
-    
-    return svg_str
diff --git a/weekly_ocr_audit.md b/weekly_ocr_audit.md
deleted file mode 100644
index a53e59d879864ded0056a0a645d49abe06281de6..0000000000000000000000000000000000000000
--- a/weekly_ocr_audit.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# weekly_ocr_audit.md — V7.2.3 Hard Freeze
-# Run every Sunday. Log results in /logs/ocr_audit_YYYY-MM-DD.json
-# DO NOT modify OCR algorithm during Hard Freeze — observe only.
-
-## Weekly OCR Audit Checklist
-
-### 1. ROI Boundary Check
-- [ ] Pull last 7 days of requests where `ocr_confidence < 0.7`
-- [ ] Check `roi_coords` in telemetry logs — confirm bounding box includes full math expression (not clipped)
-- [ ] Flag any session where > 20% of crops have missing top/bottom edges
-
-### 2. Confidence Distribution
-- [ ] Count requests bucketed by confidence: `[0.0-0.5)`, `[0.5-0.7)`, `[0.7-1.0]`
-- [ ] Alert if `[0.0-0.5)` bucket grows by > 10% week-over-week (image quality regression)
-- [ ] Log camera model or device type if available (mobile vs. tablet)
-
-### 3. Perspective Correction Aggressiveness
-- [ ] Sample 20 random images from sessions with `confidence < 0.7`
-- [ ] Visually check whether perspective warp over-corrected (stretched digits)
-- [ ] Note threshold — current: `warp_threshold = 0.15` — do not change during freeze
-
-### 4. Leakage-from-OCR Correlation
-- [ ] Cross-reference weeks where `renderer.leakage_fail` spiked with OCR confidence averages
-- [ ] Hypothesis: low OCR quality → garbled math string → Planner generates unusual Enum sequences
-- [ ] Document in audit log for CTO review
-
-### 5. Sign-off
-- [ ] Audit logged to `/logs/ocr_audit_YYYY-MM-DD.json`
-- [ ] Slack update to `#buddymath-monitoring`
-- [ ] Any findings requiring algorithm change → open ticket for Phase 2 (post-freeze)
-
----
-> CTO Note (V7.2.3): Do not modify the OCR algorithm during Hard Freeze.
-> Changes allowed only after full regression (chaos_test.py 18/18) + CTO sign-off.