Refine Laya instinct heuristic

laya_engine.py

@@ -111,24 +111,39 @@ class LayaDecisionOracle:
     @staticmethod
     def _heuristic_gut_feeling(equations: List[str], legal_actions: List[Dict[str, Any]]) -> Tuple[Dict[str, Any], float, str]:
         """Mathematical instinct priority heuristic."""
-        # 1. If factored product exists, zero_product_split is highest priority
+        import re
+
+        # 1. If all equations are already in isolated form, choose finish
+        all_isolated = True
+        for eq in equations:
+            m = re.match(r'^\s*[a-zA-Z]\s*=\s*[+-]?\d+(?:\.\d+)?(?:\/\d+)?\s*$', eq)
+            if not m:
+                all_isolated = False
+                break
+
+        if all_isolated:
+            for a in legal_actions:
+                if a["type"] == "finish":
+                    return a, 0.99, "⚡ Laya Instinct: All equation branches are isolated into canonical root forms; proving Q.E.D."
+
+        # 2. If factored product exists (e.g. (x-2)*(x-3)=0), zero_product_split is highest priority
         for a in legal_actions:
             if a["type"] == "zero_product_split":
-                return a, 0.95, "Intuition: Factored terms present; split into independent zero-product branches."
+                return a, 0.97, "⚡ Laya Instinct: Factored product (A)(B)=0 detected; zero-product split decomposes problem into independent linear branches."
 
-        # 2. If polynomial can be factored, factor it
+        # 3. If any equation can be factored, factor it
         for a in legal_actions:
             if a["type"] == "factor":
-                return a, 0.92, "Intuition: Quadratic/polynomial structure detected; factoring collapses search space."
+                return a, 0.94, "⚡ Laya Instinct: High-degree polynomial structure detected; factoring collapses nonlinear search space to linear components."
 
-        # 3. If linear and can isolate, isolate
+        # 4. If any un-isolated linear equation exists, isolate it
         for a in legal_actions:
             if a["type"] == "isolate":
-                return a, 0.90, "Intuition: Variable can be directly isolated to terminal solution."
+                return a, 0.92, f"⚡ Laya Instinct: Linear term detected in {a.get('description', '')}; isolating directly yields root."
 
-        # 4. If needs simplification
+        # 5. If needs simplification
         for a in legal_actions:
             if a["type"] == "simplify":
-                return a, 0.85, "Intuition: Simplify terms to reveal canonical algebraic form."
+                return a, 0.88, "⚡ Laya Instinct: Redundant algebraic terms detected; simplifying reduces complexity metric."
 
-        return legal_actions[0], 0.75, f"Intuition: Proposing {legal_actions[0]['type']} as next candidate step."
+        return legal_actions[0], 0.80, f"⚡ Laya Instinct: Proposing {legal_actions[0]['type']} as optimal geodesic move."