Update main.py

main.py

@@ -423,339 +423,117 @@ def deep_dive():
 
 
 # -----------------------------------------------------------------------------
-# ODYSSEUS TRIAL ENGINE: REASONING-BASED GAME GENERATOR (NO FALLBACK)
-# - Generates a Trial once per (epiphanyId, layerKey) and persists it forever
-# - Cache hit returns existing Trial (no re-charge)
-# - If Gemini output can't "compile" into schema: return 422 + store diagnostics
-# - Credits are deducted ONLY after schema validation passes
-# - Uses an RTDB lock (transaction) to avoid double-click / concurrent generation
+# ODYSSEUS ENGINE V2: SYSTEM DYNAMICS (SCIENTIFIC EQUILIBRIUM)
 # -----------------------------------------------------------------------------
 
-TRIAL_RENDERERS = {"thermal", "electrical", "mechanical", "chemical", "biological"}
-TRIAL_GRAMMARS = {"accumulate", "balance", "transform"}
-
-def _strip_json_fences(s: str) -> str:
-    s = (s or "").strip()
-    if "```" in s:
-        m = re.search(r"```(?:json)?\s*(.*?)\s*```", s, re.DOTALL)
-        if m:
-            return m.group(1).strip()
-    return s
-
-def _is_num(x):
-    return isinstance(x, (int, float)) and not isinstance(x, bool)
-
-def validate_trial_schema(t: dict) -> (bool, str):
-    """
-    Minimal v1 compiler checks (deterministic frontend assumptions):
-    - renderer must be in fixed set (so UI knows which canvas renderer to use)
-    - grammar must be one of three
-    - 1 variable + 1 slider control bound to that variable
-    - win zone + dwell
-    """
-    if not isinstance(t, dict):
-        return False, "trial is not an object"
-
-    engine = t.get("engine")
-    if not isinstance(engine, dict):
-        return False, "engine missing/invalid"
-
-    renderer = t.get("renderer")
-    grammar = t.get("grammar")
-    labels = t.get("labels")
-    logic = t.get("logic")
-
-    if renderer not in TRIAL_RENDERERS:
-        return False, f"renderer must be one of {sorted(TRIAL_RENDERERS)} (got {renderer})"
-    if grammar not in TRIAL_GRAMMARS:
-        return False, f"grammar must be one of {sorted(TRIAL_GRAMMARS)} (got {grammar})"
-
-    if not isinstance(labels, dict):
-        return False, "labels missing/invalid"
-    if not isinstance(labels.get("title"), str) or len(labels["title"].strip()) < 2:
-        return False, "labels.title missing/invalid"
-    if not isinstance(labels.get("goal"), str) or len(labels["goal"].strip()) < 3:
-        return False, "labels.goal missing/invalid"
-    if not isinstance(labels.get("controls"), list) or len(labels["controls"]) < 1:
-        return False, "labels.controls missing/invalid"
-
-    if not isinstance(logic, dict):
-        return False, "logic missing/invalid"
-
-    variables = logic.get("variables")
-    controls = logic.get("controls")
-    win = logic.get("win")
-    fail = logic.get("fail")
-
-    if not isinstance(variables, list) or len(variables) != 1:
-        return False, "logic.variables must be a list of exactly 1 variable for v1"
-    if not isinstance(controls, list) or len(controls) != 1:
-        return False, "logic.controls must be a list of exactly 1 control for v1"
-    if not isinstance(win, dict):
-        return False, "logic.win missing/invalid"
-    if not isinstance(fail, dict):
-        return False, "logic.fail missing/invalid"
-
-    v = variables[0]
-    if not isinstance(v, dict):
-        return False, "variable[0] invalid"
-    for k in ("id", "label", "min", "max", "start"):
-        if k not in v:
-            return False, f"variable[0].{k} missing"
-    if not isinstance(v["id"], str) or not v["id"].strip():
-        return False, "variable[0].id invalid"
-    if not isinstance(v["label"], str) or len(v["label"].strip()) < 2:
-        return False, "variable[0].label invalid"
-    if not _is_num(v["min"]) or not _is_num(v["max"]) or not _is_num(v["start"]):
-        return False, "variable[0] numeric fields invalid"
-    if v["min"] >= v["max"]:
-        return False, "variable[0] min>=max"
-    if not (v["min"] <= v["start"] <= v["max"]):
-        return False, "variable[0] start out of range"
-
-    c = controls[0]
-    if not isinstance(c, dict):
-        return False, "control[0] invalid"
-    for k in ("id", "label", "type", "min", "max", "step", "binds_to", "gain"):
-        if k not in c:
-            return False, f"control[0].{k} missing"
-    if c.get("type") != "slider":
-        return False, "control[0].type must be 'slider' for v1"
-    if not isinstance(c["label"], str) or len(c["label"].strip()) < 2:
-        return False, "control[0].label invalid"
-    if not _is_num(c["min"]) or not _is_num(c["max"]) or not _is_num(c["step"]) or not _is_num(c["gain"]):
-        return False, "control[0] numeric fields invalid"
-    if c["min"] >= c["max"]:
-        return False, "control[0] min>=max"
-    if c.get("binds_to") != v["id"]:
-        return False, "control[0].binds_to must match variable id"
-
-    if win.get("type") != "zone":
-        return False, "win.type must be 'zone' for v1"
-    if win.get("var") != v["id"]:
-        return False, "win.var must match variable id"
-    if not _is_num(win.get("min")) or not _is_num(win.get("max")):
-        return False, "win.min/win.max invalid"
-    if win["min"] >= win["max"]:
-        return False, "win min>=max"
-    dwell = win.get("dwell_ms", 0)
-    if not _is_num(dwell) or dwell < 0:
-        return False, "win.dwell_ms invalid"
-
-    if not isinstance(fail.get("reason"), str) or len(fail["reason"].strip()) < 3:
-        return False, "fail.reason missing/invalid"
-
-    return True, "ok"
-
+def validate_odysseus_v2(t: dict) -> (bool, str):
+    """Ensures the AI output is a valid mathematical simulation."""
+    try:
+        if t.get("engine", {}).get("version") != "v2": return False, "Version Mismatch"
+        render_types = {"biological_growth", "chemical_reactor", "mechanical_stress", "vector_flow"}
+        if t.get("simulation_type") not in render_types: return False, "Invalid visualizer"
+        
+        logic = t.get("logic", {})
+        if "equilibrium_window" not in logic or "entropy_factor" not in logic:
+            return False, "Missing physics constants"
+            
+        return True, "ok"
+    except: return False, "Schema corruption"
 
 @app.route('/api/trial/generate', methods=['POST'])
 def generate_trial():
-    logger.info(">>> ODYSSEUS TRIAL GENERATION INITIATED")
-
-    # 1) AUTH
+    """
+    Odysseus v2: Designs a System Dynamics simulation based on First Principles.
+    Analyzes the Epiphany layer to identify a 'Tension' (e.g. Gravity vs Lift).
+    """
+    logger.info(">>> ODYSSEUS V2 TRIAL GENERATION")
     uid = verify_token(request.headers.get('Authorization'))
-    if not uid:
-        return jsonify({"error": "Unauthorized"}), 401
-
-    payload = request.get_json(silent=True) or {}
-    epiphany_id = payload.get("epiphanyId")
-    layer_key = payload.get("layerKey")  # genesis | scientific_core | engineering_edge | cross_pollination
+    if not uid: return jsonify({"error": "Unauthorized"}), 401
+    
+    payload = request.get_json()
+    ep_id = payload.get("epiphanyId")
+    layer_key = payload.get("layerKey") # genesis | scientific_core | engineering_edge | cross_pollination
     subject = payload.get("subject")
 
-    if not all([epiphany_id, layer_key, subject]):
-        return jsonify({"error": "Missing context (epiphanyId, layerKey, subject)."}), 400
-
-    # 2) OWNERSHIP CHECK
-    ep_ref = db_ref.child(f"epiphanies/{epiphany_id}")
-    ep = ep_ref.get() or {}
-    if not ep or ep.get("uid") != uid:
-        return jsonify({"error": "Forbidden: epiphany not found or not owned by user."}), 403
-
-    # 3) CACHE FOREVER
-    trial_path = f"epiphanies/{epiphany_id}/trials/{layer_key}"
-    trial_ref = db_ref.child(trial_path)
-    existing = trial_ref.get()
-    if existing:
-        return jsonify(existing), 200
-
-    # 4) LOCK (atomic via transaction)
-    lock_id = str(uuid.uuid4())
-    lock_path = f"epiphanies/{epiphany_id}/trialLocks/{layer_key}"
-    lock_ref = db.reference(lock_path)
-
-    lock_payload = {"uid": uid, "lockId": lock_id, "at": datetime.utcnow().isoformat()}
-
-    def lock_txn(cur):
-        # If a lock already exists, keep it (do not overwrite)
-        if cur:
-            return cur
-        return lock_payload
-
-    lock_result = lock_ref.transaction(lock_txn)
-    # If someone else already holds the lock, return 409
-    if lock_result and lock_result.get("lockId") != lock_id:
-        return jsonify({
-            "status": "locked",
-            "error": "Trial is being generated. Please retry shortly.",
-            "cooldown_ms": 1200
-        }), 409
-
-    def cleanup_lock_best_effort():
-        try:
-            cur = lock_ref.get()
-            if cur and cur.get("lockId") == lock_id:
-                lock_ref.delete()
-        except Exception:
-            pass
-
-    # 5) GEMINI GENERATION (2 attempts), NO FALLBACK
-    model_name = ATHENA_FLASH
-    attempts = 0
-    raw_outputs = []
-    last_validation_error = None
-    last_exception = None
-
-    trial_prompt = f"""
-You are designing a short, playable scientific Trial for: {subject}
-Layer: {layer_key}
-
-Output JSON ONLY (no markdown).
-
-Rules:
-- Choose a FREE domain_label (any string) describing the concept (e.g., "orbital mechanics", "distillation").
-- Choose renderer from EXACTLY: thermal, mechanical, electrical, chemical, biological
-- Choose grammar from EXACTLY: accumulate, balance, transform
-- Must be solvable in <= 30 seconds.
-- v1 STRICT: 1 variable and 1 slider control.
-
-JSON SCHEMA:
-{{
-  "engine": {{"name":"odysseus","version":"v1"}},
-  "renderer":"thermal|mechanical|electrical|chemical|biological",
-  "domain_label":"free text",
-  "grammar":"accumulate|balance|transform",
-  "labels": {{
-    "title":"Short Title",
-    "goal":"One-line goal",
-    "controls":["Single control label"]
-  }},
-  "logic": {{
-    "variables":[{{"id":"x","label":"Label (include units)","min":number,"max":number,"start":number}}],
-    "controls":[{{"id":"c1","label":"Same as labels.controls[0]","type":"slider","min":number,"max":number,"step":number,"binds_to":"x","gain":number}}],
-    "win":{{"type":"zone","var":"x","min":number,"max":number,"dwell_ms":number}},
-    "fail":{{"type":"out_of_range","reason":"Scientific reason for instability"}},
-    "difficulty": number
-  }},
-  "narrative": {{
-    "on_win":"One sentence insight.",
-    "on_fail":"One sentence failure explanation."
-  }}
-}}
-"""
+    # 1. Persistent Cache Check
+    trial_path = f"epiphanies/{ep_id}/trials/{layer_key}"
+    existing = db_ref.child(trial_path).get()
+    if existing: return jsonify(existing), 200
+
+    # 2. Transactional Lock (Prevent double-spending/concurrency)
+    lock_ref = db_ref.child(f"epiphanies/{ep_id}/trialLocks/{layer_key}")
+    if lock_ref.get(): return jsonify({"error": "Simulation initializing..."}), 409
+    lock_ref.set({"uid": uid, "at": datetime.utcnow().isoformat()})
 
     try:
-        trial_json = None
-
-        for _ in range(2):
-            attempts += 1
-            try:
-                res = client.models.generate_content(
-                    model=model_name,
-                    contents=trial_prompt,
-                    config=types.GenerateContentConfig(response_mime_type="application/json")
-                )
-                raw = _strip_json_fences(res.text)
-                raw_outputs.append(raw[:2000])  # keep a preview for logging
-
-                candidate = json.loads(raw)
-                candidate["createdAt"] = datetime.utcnow().isoformat()
-
-                ok, why = validate_trial_schema(candidate)
-                if ok:
-                    trial_json = candidate
-                    break
-                last_validation_error = why
-
-            except Exception as e:
-                last_exception = str(e)
-
-        # 6) IF INVALID: LOG FAILURE + RETURN 422 (no charge)
-        if not trial_json:
-            failure_doc = {
-                "status": "failed",
-                "uid": uid,
-                "epiphanyId": epiphany_id,
-                "layerKey": layer_key,
-                "subject": subject,
-                "model": model_name,
-                "attempts": attempts,
-                "validation_error": last_validation_error,
-                "exception": last_exception,
-                "raw_output_preview": raw_outputs[-1] if raw_outputs else None,
-                "at": datetime.utcnow().isoformat()
-            }
-            db_ref.child(f"trial_failures/{uid}/{epiphany_id}/{layer_key}").push(failure_doc)
-
-            cleanup_lock_best_effort()
-            return jsonify({
-                "status": "failed",
-                "epiphanyId": epiphany_id,
-                "layerKey": layer_key,
-                "subject": subject,
-                "reason": "schema_invalid" if last_validation_error else "model_error",
-                "details": {
-                    "validation_error": last_validation_error,
-                    "exception": last_exception,
-                    "attempts": attempts,
-                    "raw_output_preview": raw_outputs[-1] if raw_outputs else None
-                },
-                "next": {"action": "regenerate", "cooldown_ms": 1200}
-            }), 422
-
-        # 7) CHARGE (atomic) ONLY AFTER VALID TRIAL EXISTS
-        credits_ref = db.reference(f"users/{uid}/credits")
-        did_deduct = {"ok": False}
-
-        def credits_txn(cur):
-            cur = cur or 0
-            if cur < 1:
-                return cur
-            did_deduct["ok"] = True
-            return cur - 1
-
-        credits_ref.transaction(credits_txn)
-
-        if not did_deduct["ok"]:
-            cleanup_lock_best_effort()
-            return jsonify({"error": "Insufficient Sparks. (Trial requires 1 spark)"}), 402
-
-        # 8) PERSIST TRIAL FOREVER
-        trial_ref.set(trial_json)
-
-        cleanup_lock_best_effort()
-        logger.info(f"Trial manifested & persisted: {trial_path}")
-        return jsonify(trial_json), 201
+        # 3. High-Intellect Physics Prompting
+        # We fetch the actual text of the layer for specific context
+        layer_data = db_ref.child(f"epiphanies/{ep_id}/layers/{layer_key}").get() or {}
+        context_text = layer_data.get('text', '')
+
+        trial_prompt = f"""
+        Act as a Scientific Simulation Designer. Create an Odysseus v2 Trial for: {subject}.
+        Layer Focus: {layer_key}. Context: {context_text}
+        
+        Task: Identify the core 'Scientific Tension' of this system (e.g. Photosynthesis balance, Structural load, Ionization equilibrium).
+        
+        MANDATORY JSON SCHEMA:
+        {{
+            "engine": {{"name": "odysseus", "version": "v2"}},
+            "simulation_type": "biological_growth | chemical_reactor | mechanical_stress | vector_flow",
+            "labels": {{
+                "title": "Feynman-style Title",
+                "goal": "Explain the goal simply.",
+                "slider_label": "The force the user controls (e.g. 'Photon Intensity', 'Structural Rigidity')"
+            }},
+            "logic": {{
+                "initial_value": 50,
+                "target_value": 75,
+                "equilibrium_window": 10,
+                "entropy_factor": 0.5,
+                "reaction_latency": 0.2,
+                "hold_time_ms": 3000
+            }},
+            "narrative": {{
+                "on_win": "A Feynman-style explanation of why they succeeded.",
+                "on_fail": "A Socratic explanation of why the system collapsed."
+            }}
+        }}
+        """
 
-    except Exception as e:
-        # Hard failure path (still no fallback)
-        failure_doc = {
-            "status": "failed",
-            "uid": uid,
-            "epiphanyId": epiphany_id,
-            "layerKey": layer_key,
-            "subject": subject,
-            "model": model_name,
-            "attempts": attempts,
-            "validation_error": last_validation_error,
-            "exception": str(e),
-            "raw_output_preview": raw_outputs[-1] if raw_outputs else None,
-            "at": datetime.utcnow().isoformat()
-        }
-        db_ref.child(f"trial_failures/{uid}/{epiphany_id}/{layer_key}").push(failure_doc)
+        res = client.models.generate_content(
+            model=ATHENA_FLASH,
+            contents=trial_prompt,
+            config=types.GenerateContentConfig(response_mime_type="application/json")
+        )
+        
+        trial_data = json.loads(_strip_json_fences(res.text))
+        
+        # 4. Validation & Spark Charge
+        ok, why = validate_odysseus_v2(trial_data)
+        if not ok:
+            lock_ref.delete()
+            return jsonify({"error": f"Logic failure: {why}"}), 422
 
-        cleanup_lock_best_effort()
-        logger.error(f"Trial Generation Failure: {e}")
-        return jsonify({"error": "Trial generation failed."}), 500
+        user_ref = db_ref.child(f'users/{uid}')
+        credits = user_ref.get().get('credits', 0)
+        if credits < 1:
+            lock_ref.delete()
+            return jsonify({"error": "Insufficient Sparks"}), 402
+        
+        # 5. Finalize & Persist
+        trial_data["createdAt"] = datetime.utcnow().isoformat()
+        db_ref.child(trial_path).set(trial_data)
+        user_ref.update({'credits': credits - 1})
+        
+        lock_ref.delete()
+        logger.info(f"Odysseus v2 Trial manifested for {subject}")
+        return jsonify(trial_data), 201
+
+    except Exception as e:
+        lock_ref.delete()
+        logger.error(f"Trial Gen Error: {e}")
+        return jsonify({"error": "Failed to compile physics logic"}), 500
 
 # -----------------------------------------------------------------------------
 # 5. THE CHIRON MENTOR & SYSTEM UTILS