Critical QA Fixes: Bug 1-4 (Data Isolation, Hotfix Sanity, History Save, Visuals Stability)

orchestrator.py

@@ -16,6 +16,7 @@ from domain.validator import ConsistencyGate
 from smart_solver import sign_step, resolve_ast_target, execute_action
 import domain.telemetry as telemetry
 from domain.schemas import BuddyEvent, BuddyState # V8.5: Streaming contract
+from firebase_manager import firebase_manager
 
 # V8.6.9: Global Guardrails (Increased for High-Complexity 5-Unit Problems)
 GLOBAL_TOKEN_LIMIT = 50000
@@ -1597,7 +1598,13 @@ ctx.finish("$$ 4 $$", "מעולה! הגענו לתוצאה.")
                         solve_prompt = f"FIX ERROR: {last_error_context}\n\nORIGINAL QUESTION: {solve_prompt}"
 
                     # V8.5: Reset context on retry to reduce token pressure
-                    effective_context = {**data_anchor, **context} if attempts == 1 else {**data_anchor}
+                    # V8.6.9: Inject sub-question specific data to prevent leakage (Data Isolation)
+                    local_anchor = {**data_anchor}
+                    if sub_q.get("specific_values"):
+                        print(f"📦 [V8.6.9] Injecting local data for {sub_q['id']}: {sub_q['specific_values']}")
+                        local_anchor["specific_values"] = list(set(local_anchor.get("specific_values", []) + sub_q["specific_values"]))
+
+                    effective_context = {**local_anchor, **context} if attempts == 1 else {**local_anchor}
 
                     result = await safe_llm_call(
                         lambda: self.strategy_manager.solve_with_strategy(
@@ -1656,10 +1663,19 @@ ctx.finish("$$ 4 $$", "מעולה! הגענו לתוצאה.")
                         
                         # מעקף: אם השגיאה היא רק בעיית קריאה של סימנים (אי-שוויונים/חיצים), סומכים על ה-LLM ויוצאים
                         if "SYMPY_PARSE_ERROR" in str(poly_reason):
-                            print(f"🛡️ [HOTFIX] Bypassing SymPy Parse Error. Trusting LLM output for sub-q {sub_q['id']}.")
-                            is_degraded = True
-                            degraded_reason = "sympy_parse_bypass"
-                            break  # יוצאים מהלופ מיד! חוסך ניסיון שני ומונע בזבוז טוקנים
+                            # V8.6.9: Sanity Check for forbidden words in response to prevent blindly trusting "contradiction" answers
+                            forbidden_words = ["סתירה", "לא ייתכן", "שגיאה", "לא הגיוני", "אין פתרון"]
+                            response_text = str(llm_resp) # Search in full JSON representation
+                            if any(word in response_text for word in forbidden_words):
+                                print(f"🛑 [HOTFIX BLOCKED] Forbidden word detected in SYMPY_PARSE_ERROR response. Not Trusting LLM.")
+                                is_degraded = True
+                                degraded_reason = "polygraph_fail_forbidden_words"
+                                # Continue to second attempt instead of breaking
+                            else:
+                                print(f"🛡️ [HOTFIX] Bypassing SymPy Parse Error. Trusting LLM output for sub-q {sub_q['id']}.")
+                                is_degraded = True
+                                degraded_reason = "sympy_parse_bypass"
+                                break  # יוצאים מהלופ מיד! חוסך ניסיון שני ומונע בזבוז טוקנים
                         elif attempts == max_attempts:
                             print(f"⚠️ [HOTFIX] Max attempts reached. Forcing LLM response despite Polygraph failure.")
                             is_degraded = True

problem_understanding.py

@@ -41,6 +41,7 @@ Return JSON:
       "id": "א",
       "question": "Full text of sub-question א",
       "requires": ["center", "radius"],
+      "specific_values": ["m=2"],
       "expected_output": "equation | number | point | etc.",
       "topic": "CIRCLE_EQUATION"
     }},
@@ -48,6 +49,7 @@ Return JSON:
       "id": "ב",
       "question": "Full text of sub-question ב",
       "requires": ["equation_from_א", "point"],
+      "specific_values": ["a=1"],
       "expected_output": "line_equation",
       "topic": "LINE_TANGENT"
     }}
@@ -61,13 +63,14 @@ Return JSON:
 
 CRITICAL RULES:
 1. Include ALL sub-questions (א, ב, ג, ד, etc.)
-2. **EXCEPTION:** If the problem asks for a **Geometric Locus (מקום גיאומטרי)**:
+2. **CHRONOLOGICAL DATA ISOLATION (V8.6.9):** If a specific value (e.g., a=1, m=2) is mentioned ONLY in a specific sub-question, you MUST include it in the `specific_values` array for THAT sub-question only. NEVER put it in the top-level anchor if it's not global.
+3. **EXCEPTION:** If the problem asks for a **Geometric Locus (מקום גיאומטרי)**:
    - This is a SINGLE QUESTION (even if it looks long).
    - Set `problem_type` = "GEOMETRIC_LOCUS".
    - Create ONLY ONE sub-question (id="א") containing the entire text.
-3. Identify dependencies (ב needs א's result)
-4. Determine topic for EACH sub-question
-5. DO NOT solve - only analyze structure
+4. Identify dependencies (ב needs א's result)
+5. Determine topic for EACH sub-question
+6. DO NOT solve - only analyze structure
 
 Return ONLY valid JSON.
 """

prompts.py

@@ -281,6 +281,7 @@ CRITICAL INSTRUCTIONS:
 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.
 r"""
 
 def get_specialist_prompt(category, problem_text, solver_hint, grade, student_name, student_gender="M", data_anchor=None):
@@ -623,6 +624,11 @@ def get_master_prompt_v860():
         - You MUST find certain 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.
 
 
     ═══════════════════════════════════════════

visuals.py

@@ -140,7 +140,13 @@ def _plot_func(expr_str):
 
         for idx, single_expr in enumerate(expressions):
             try:
-                expr = _run_with_timeout(sympify, (single_expr, None, local_dict), timeout_duration=2.0)
+                # V8.6.9: Explicit try-except for SYMPY_PARSE_ERROR prevention
+                try:
+                    expr = _run_with_timeout(sympify, (single_expr, None, local_dict), timeout_duration=2.0)
+                except Exception as e:
+                    print(f"⚠️ [VISUALS] SymPy Parse Error on '{single_expr}': {e}")
+                    expr = None
+                
                 if not expr: continue 
                 
                 # טיפול בפרמטרים חופשיים
@@ -270,7 +276,13 @@ def _plot_geo(solution_expr, context_text, geometric_entities=None):
         try:
             x, y = symbols('x y')
             # V290.0: Watchdog for Geo Sympify & Contour
-            expr = _run_with_timeout(sympify, (eq_str, None, {"sin": sin, "cos": cos, "tan": tan, "sqrt": sqrt, "Abs": Abs, "pi": np.pi, "ln": ln, "log": log, "exp": exp, "e": exp(1)}), timeout_duration=1.5)
+            # V8.6.9: Local try-except for crash prevention
+            try:
+                expr = _run_with_timeout(sympify, (eq_str, None, {"sin": sin, "cos": cos, "tan": tan, "sqrt": sqrt, "Abs": Abs, "pi": np.pi, "ln": ln, "log": log, "exp": exp, "e": exp(1)}), timeout_duration=1.5)
+            except Exception as e:
+                print(f"⚠️ [VISUALS] Geo SymPy Parse Error on '{eq_str}': {e}")
+                expr = None
+            
             if expr:
                 f_np = _run_with_timeout(lambdify, ((x, y), expr, 'numpy'), timeout_duration=1.0)
                 if f_np: