Deploy DictaLM 2.0 API server

.env.example

@@ -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

.gcloudignore

@@ -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/

.gitignore

@@ -1,9 +0,0 @@
-__pycache__/
-*.pyc
-*.pyo
-serviceAccountKey*.json
-*credentials.json
-.env
-output_locus.txt
-*.log
-.DS_Store

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"]
+# 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"]

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

all_users.json

@@ -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"
-  }
-}

analytics.py

@@ -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()

audio_generator.py

@@ -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())

backend/__init__.py

@@ -1,2 +0,0 @@
-# backend/__init__.py
-# BuddyMath V2.0 backend package

backend/extractor.py

@@ -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

backend/math_schema.py

@@ -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

backend/pipeline.py

@@ -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)

backend/tests/test_pipeline.py

@@ -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')}")

backend/universal_verifier.py

@@ -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)

backend/variable_pinner.py

@@ -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

config.py

@@ -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}")

constraint_checks.py

@@ -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}")

cost_tracker.py

@@ -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}")

create_mock_user.py

@@ -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()

curriculum_engine.py

@@ -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"))

curriculum_israel.py

@@ -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)

debug_llm_payload.py

@@ -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())

deploy_dev.ps1

@@ -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

deploy_dev.sh

@@ -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"

deploy_hf

@@ -1 +0,0 @@
-Subproject commit ebcf3058d7ba593763ac0ff97ea695b1d67955ec

docs/legacy_prompts_backup.txt

@@ -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.
-    """

domain/curriculum_classifier.py

@@ -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

domain/math_normalizer.py

@@ -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

domain/math_validator.py

@@ -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, ""

domain/ontology.py

@@ -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", "כללי")

domain/pedagogical_renderer.py

@@ -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

domain/processing_strategy.py

@@ -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"            # שיח חופשי

domain/proposal_engine.py

@@ -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"}

domain/risk_engine.py

@@ -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

domain/schemas.py

@@ -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

domain/semantic_bank.py

@@ -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

domain/step_types.py

@@ -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

domain/telemetry.py

@@ -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)

domain/validator.py

@@ -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, ""

exercise_generator.py

@@ -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()

explanation_math_firewall.py

@@ -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, ""

find_admin.py

@@ -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.

find_dotan.py

@@ -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()

firebase_manager.py

@@ -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()

fix_dotan_balance_script.py

@@ -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()

fix_now.py

@@ -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()

fix_welcome_audio.py

@@ -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())

gcs_lifecycle_rule.json

@@ -1,11 +0,0 @@
-{
-  "rule": [
-    {
-      "action": {"type": "Delete"},
-      "condition": {
-        "age": 1,
-        "matchesPrefix": ["tts/"]
-      }
-    }
-  ]
-}

generate_dotan_report.py

@@ -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"))

generate_new_welcome.py

@@ -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")