Update app.py

app.py

@@ -1,21 +1,43 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 14.0 — REAL-WORLD DOMAIN SUITE
+PRACTICALITY SYSTEM 15.0 — CREATIVE SEQUENCE WISDOM
 ═══════════════════════════════════════════════════════════════════
-14 Problems across 11 domains:
-  Cryptography · Finance · Energy · Chemistry · Physics · Chaos
-  Game Theory · Astronomy · Engineering · Signal Processing · Mathematics
-
-New in 14.0:
-  · 10 real-world AXL problems (hardcoded, no LLM)
-  · AXLInvariant mode: "eq" | "geq" (fixes GEQ semantic)
-  · PROBLEM_META: domain / category tagging
-  · PROBLEM_STATS: per-problem live performance tracking
-  · Round-robin cycling: every problem gets tested evenly
-  · Multi-domain performance table in dashboard
+NEW IN 15.0:
+
+  · CreativeSeeder — four categories of creative ray generation:
+
+    1. TENSION RAYS: mediated contradictions. [A→B→C] where A and C
+       are in ADJACENT_CONTRADICTIONS but B mediates between them.
+       CO₂ molecules of the axiom space — stable structures from
+       reactive parts. The system now explicitly *seeks* these.
+
+    2. SCOUT RAYS: random valid sequences, length 3-8. No earning
+       required. Pure cartographers of unexplored territory.
+       Retroactively earn branching rights if CE is good.
+
+    3. RECOMBINATION RAYS: genetic crossover of two successful rays.
+       Front half of one proven sequence + tail of another.
+       Novel combinations from parts that independently worked.
+
+    4. INVERSION RAYS: a successful sequence reversed and re-fired.
+       Same axioms, opposite order of application. The problem
+       approached from the other end.
+
+  · Resonant Pair Discovery (in-run, zero cross-run bias):
+    When two consecutive axioms in a sequence both reduce CE
+    meaningfully, they are stored as a 'resonant pair' in the
+    StructuralModel (per-run only). Child branching prioritises
+    extensions that continue resonant pairs. The system senses what
+    axiomatic connections are potent for THIS problem in THIS run.
+
+  · Ray Type field on every ray and trace. Dashboard shows breakdown
+    by type — see which creative category drives the most solves.
+
+  · 14-problem real-world suite retained from 14.0.
+  · Verification layer and hypothesis constructors unchanged.
 """
 
-import time, random, math, threading, asyncio, warnings, itertools
+import time, random, math, threading, asyncio, warnings
 from functools import reduce
 from typing import Optional, Callable, List, Dict, Tuple, Any, Set
 from dataclasses import dataclass, field
@@ -34,7 +56,7 @@ import uvicorn
 warnings.filterwarnings("ignore")
 USE_GPU = torch.cuda.is_available()
 DEVICE  = torch.device("cuda" if USE_GPU else "cpu")
-print(f"[SYSTEM 14.0] Compute: {'GPU' if USE_GPU else 'CPU'}")
+print(f"[SYSTEM 15.0] Compute: {'GPU' if USE_GPU else 'CPU'}")
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 1: CONSTANTS
@@ -47,12 +69,12 @@ L9_CONTRIB_THRESHOLD = 1e-8
 HUB_RESIDUAL_MULT    = 2.0
 HUB_DEGREE_RATIO     = 0.6
 MAX_HYPS_PER_AXIOM   = 4
-BRANCH_DEPTH         = 3
 MANIFOLD_STEPS       = [0.05, 0.2, -0.05, -0.2, 0.5, -0.5]
 N_MPRT_EXPLORE       = 20000 if USE_GPU else 3000
 POLISH_STEPS         = 40
 ADAM_STEPS           = 30
 PROJECTION_CACHE: Dict = {}
+RESONANCE_THRESHOLD  = 0.95   # CE must drop to <95% of prior to count as resonant
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 2: INTERVAL ARITHMETIC
@@ -217,22 +239,21 @@ def expand_psl(prog:PSLProgram) -> ExpandedProblem:
         if name not in bounds: variables.append(name); bounds[name]=(lo,hi)
         if scope!="root" and name not in scope_vars[scope]: scope_vars[scope].append(name)
     def add_con(kind,expr,direction,scope="root",weight=1.0,branches=None):
-        idx=len(constraints)
         constraints.append(Constraint(kind,expr,direction,weight,scope,branches or []))
-        scope_groups[scope].append(idx)
+        scope_groups[scope].append(len(constraints)-1)
         try:
             syms={v:sp.Symbol(v) for v in variables}
-            if kind=="or_eq" and branches:
-                for b_str in branches:
-                    parsed=parse_expr(b_str,local_dict=syms)
-                    for v in variables:
-                        if sp.Symbol(v) in parsed.free_symbols and scope!="root" and v not in scope_vars[scope]:
-                            scope_vars[scope].append(v)
-            else:
-                parsed=parse_expr(expr,local_dict=syms)
+            parsed=parse_expr(expr,local_dict=syms) if kind!="or_eq" else None
+            if parsed:
                 for v in variables:
                     if sp.Symbol(v) in parsed.free_symbols and scope!="root" and v not in scope_vars[scope]:
                         scope_vars[scope].append(v)
+            elif kind=="or_eq" and branches:
+                for b_str in branches:
+                    p2=parse_expr(b_str,local_dict=syms)
+                    for v in variables:
+                        if sp.Symbol(v) in p2.free_symbols and scope!="root" and v not in scope_vars[scope]:
+                            scope_vars[scope].append(v)
         except: pass
     for v in prog.vars: add_var(v.name,v.lo,v.hi)
     for c in prog.constraints:
@@ -252,8 +273,7 @@ def expand_psl(prog:PSLProgram) -> ExpandedProblem:
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class AXLInvariant:
-    name:str; expr:str; tolerance:float=VERIFY_G2_TOLERANCE
-    mode:str="eq"   # "eq": |expr|<tol  |  "geq": expr>=-tol  |  "leq": expr<=tol
+    name:str; expr:str; tolerance:float=VERIFY_G2_TOLERANCE; mode:str="eq"
 
 @dataclass
 class AXLProblemDef:
@@ -398,7 +418,7 @@ class Problem:
                     val=float(mc.fast_pt(*[b.get(v,0.0) for v in mc.syms_used]))
                     if mc.kind=="equality":   total+=abs(val)*mc.weight
                     elif mc.direction=="geq": total+=max(0.0,-val)*mc.weight
-                    else:                     total+=max(0.0, val)*mc.weight
+                    else:                     total+=max(0.0,val)*mc.weight
                 except: total+=1.0
         for v,(lo,hi) in self.bounds.items():
             bv=b.get(v,0.0); total+=max(0.0,lo-bv)+max(0.0,bv-hi)
@@ -466,7 +486,7 @@ class Problem:
                     if not isinstance(val,np.ndarray): val=np.full(N,float(val),dtype=np.float32)
                     if mc.kind=="equality":   total+=np.abs(val)*mc.weight
                     elif mc.direction=="geq": total+=np.maximum(0.0,-val)*mc.weight
-                    else:                     total+=np.maximum(0.0, val)*mc.weight
+                    else:                     total+=np.maximum(0.0,val)*mc.weight
                 except: total+=1.0
         for i,v in enumerate(var_order):
             lo,hi=self.bounds[v]; col=b_matrix[:,i]
@@ -474,7 +494,7 @@ class Problem:
         return total
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 6: VERIFY LAYER  (mode-aware)
+# SECTION 6: VERIFY LAYER
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class VerifyResult:
@@ -484,7 +504,7 @@ class VerifyResult:
     failed_gates:List[str]=field(default_factory=list)
 
 class VerifyLayer:
-    def run(self,binding:Dict[str,float],base_problem:Problem,anchors:List[AXLInvariant]) -> VerifyResult:
+    def run(self,binding,base_problem,anchors):
         g1_ce=base_problem.constraint_energy(binding)
         g1_pass=g1_ce<VERIFY_G1_THRESHOLD
         g2={}
@@ -494,11 +514,10 @@ class VerifyLayer:
                 expr=parse_expr(inv.expr,local_dict=syms)
                 func=sp.lambdify(list(expr.free_symbols),expr,modules="math")
                 args=[binding.get(str(s),0.0) for s in expr.free_symbols]
-                val=float(func(*args))
-                err=abs(val)
+                val=float(func(*args)); err=abs(val)
                 if inv.mode=="eq":    passed=err<inv.tolerance
-                elif inv.mode=="geq": passed=val>=-inv.tolerance   # constraint satisfied
-                elif inv.mode=="leq": passed=val<=inv.tolerance     # constraint satisfied
+                elif inv.mode=="geq": passed=val>=-inv.tolerance
+                elif inv.mode=="leq": passed=val<=inv.tolerance
                 else:                 passed=err<inv.tolerance
                 g2[inv.name]=(round(val,6),passed)
             except: g2[inv.name]=(999.0,False)
@@ -542,7 +561,7 @@ AXIOM_ABBR={
     Axiom.IMPLICATION:"IMP",Axiom.NEGATION:"NEG",Axiom.COMPOSITE:"CMP",
     Axiom.HOLISM:"HOL",Axiom.PARSIMONY:"PAR",Axiom.DUALITY:"DUA",
 }
-ADJACENT_CONTRADICTIONS=[
+ADJACENT_CONTRADICTIONS: List[Tuple[str,str]] = [
     (Axiom.DISCRETE,Axiom.CONTINUOUS),(Axiom.INJECTIVE,Axiom.SURJECTIVE),
     (Axiom.ORDERED,Axiom.SYMMETRIC),(Axiom.ATOMIC,Axiom.COMPOSITE),
     (Axiom.CONSERVED,Axiom.MUTABLE),(Axiom.PARSIMONY,Axiom.ENTROPY),
@@ -551,7 +570,7 @@ ADJACENT_CONTRADICTIONS=[
 ]
 _CONTRA_SET={frozenset(p) for p in ADJACENT_CONTRADICTIONS}
 
-def sequence_valid(seq:List[str]) -> bool:
+def sequence_valid(seq: List[str]) -> bool:
     for i in range(len(seq)-1):
         if frozenset([seq[i],seq[i+1]]) in _CONTRA_SET: return False
     return True
@@ -559,6 +578,19 @@ def sequence_valid(seq:List[str]) -> bool:
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 8: SHARED DATACLASSES
 # ══════════════════════════════════════════════════════════════════════
+# Ray types — what kind of creative move generated this ray
+RAY_SEED      = "seed"       # 🌱 single axiom starter
+RAY_BRANCH    = "branch"     # 🌿 earned child of a tree ray
+RAY_TENSION   = "tension"    # ⚡ mediated contradiction sequence
+RAY_SCOUT     = "scout"      # 🔭 random valid sequence
+RAY_RECOMBINE = "recombine"  # 🧬 genetic crossover of two rays
+RAY_INVERT    = "invert"     # 🔄 reversed successful sequence
+
+RAY_ICONS = {
+    RAY_SEED:"🌱", RAY_BRANCH:"🌿", RAY_TENSION:"⚡",
+    RAY_SCOUT:"🔭", RAY_RECOMBINE:"🧬", RAY_INVERT:"🔄",
+}
+
 @dataclass
 class Hypothesis:
     hid:str; binding:Dict[str,float]; h_type:str; claim:str
@@ -567,36 +599,56 @@ class Hypothesis:
 
 @dataclass
 class Baton:
+    """Partial solution passed between rays. A ray never fails — it terminates."""
     binding:Dict[str,float]; ce:float
     ray_id:str=""; depth:int=0
     l7:Optional[Any]=None; l9:Optional[Any]=None
 
 @dataclass
 class AxiomRay:
-    sequence:List[str]; ray_id:str; depth:int=0
-    parent_id:Optional[str]=None; baton:Optional[Baton]=None
+    """
+    An ordered sequence of axioms. [A→B→C] ≠ [C→B→A].
+    Now carries ray_type so we can track which creative move generated it.
+    """
+    sequence:  List[str]
+    ray_id:    str
+    ray_type:  str       = RAY_SEED
+    depth:     int       = 0
+    parent_id: Optional[str] = None
+    baton:     Optional[Baton] = None
+
     @property
     def name(self) -> str:
         return "→".join(AXIOM_ABBR.get(a,a[:3]) for a in self.sequence)
-    def extend(self,axiom:str) -> Optional['AxiomRay']:
-        new_seq=self.sequence+[axiom]
+
+    def extend(self, axiom:str, rtype:str=RAY_BRANCH) -> Optional['AxiomRay']:
+        new_seq = self.sequence + [axiom]
         if sequence_valid(new_seq):
-            return AxiomRay(sequence=new_seq,ray_id=f"{self.ray_id}+{AXIOM_ABBR.get(axiom,'?')}",
-                            depth=self.depth+1,parent_id=self.ray_id)
+            return AxiomRay(
+                sequence  = new_seq,
+                ray_id    = f"{self.ray_id}+{AXIOM_ABBR.get(axiom,'?')}",
+                ray_type  = rtype,
+                depth     = self.depth + 1,
+                parent_id = self.ray_id,
+            )
         return None
 
 @dataclass
 class HypothesisTrace:
-    hid:str; round_idx:int; ray_name:str; action:str
+    hid:str; round_idx:int; ray_name:str; ray_type:str; action:str
     ce_before:float; ce_after:float
     verify:Optional[VerifyResult]; survived:bool; elapsed_ms:float
     depth:int=0; parent_id:str=""
 
 @dataclass
 class StructuralModel:
-    best_binding:Dict[str,float]; best_ce:float
-    failure_patterns:Set[str]=field(default_factory=set)
-    scope_witnesses:Dict[str,Dict[str,Tuple]]=field(default_factory=dict)
+    best_binding: Dict[str,float]
+    best_ce:      float
+    failure_patterns: Set[str] = field(default_factory=set)
+    scope_witnesses:  Dict[str,Dict[str,Tuple]] = field(default_factory=dict)
+    # Resonant pairs — discovered in-run, zero cross-run bias
+    # (axiom_a, axiom_b) means a→b produced meaningful CE reduction
+    resonant_pairs: List[Tuple[str,str]] = field(default_factory=list)
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 9: ORACLES
@@ -787,7 +839,7 @@ def _test_hypothesis(problem,hyp):
     return best_b,best_ce
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 11: HYPOTHESIS CONSTRUCTORS (27 axioms — same as v13.0)
+# SECTION 11: HYPOTHESIS CONSTRUCTORS (27 axioms, unchanged from 14.0)
 # ══════════════════════════════════════════════════════════════════════
 def _proj_val(mc,v,b):
     if v not in mc.projections: return None
@@ -867,8 +919,7 @@ def _hyp_quadratic(problem,baton,all_batons,model):
 def _hyp_bilinear(problem,baton,all_batons,model):
     hyps=[]; b=dict(baton.binding)
     for mc in problem.compiled_constraints:
-        if not mc.parsed: continue
-        if not mc.parsed.is_Add: continue
+        if not mc.parsed or not mc.parsed.is_Add: continue
         for term in mc.parsed.args:
             if not term.is_Mul: continue
             syms_in=[str(s) for s in term.free_symbols if str(s) in problem.variables]
@@ -887,8 +938,7 @@ def _hyp_bilinear(problem,baton,all_batons,model):
 def _hyp_metric(problem,baton,all_batons,model):
     hyps=[]; b=dict(baton.binding)
     for mc in problem.compiled_constraints:
-        if mc.kind!="equality" or not mc.parsed: continue
-        if not mc.parsed.is_Add: continue
+        if mc.kind!="equality" or not mc.parsed or not mc.parsed.is_Add: continue
         sq_terms=[t for t in mc.parsed.args if t.is_Pow and t.args[1]==2]
         if len(sq_terms)<2: continue
         vars_in=[str(s) for s in mc.parsed.free_symbols if str(s) in problem.variables]
@@ -924,9 +974,8 @@ def _hyp_ordered(problem,baton,all_batons,model):
     b=dict(baton.binding); nb=dict(b)
     ord_mcs=[mc for mc in problem.compiled_constraints if mc.kind=="inequality" and len(mc.syms_used)==2]
     for mc in ord_mcs:
-        if len(mc.syms_used)<2: continue
         vi,vj=mc.syms_used[0],mc.syms_used[1]
-        lo_i,hi_i=problem.bounds.get(vi,(-1e18,1e18)); lo_j,hi_j=problem.bounds.get(vj,(-1e18,1e18))
+        lo_i,_=problem.bounds.get(vi,(-1e18,1e18)); _,hi_j=problem.bounds.get(vj,(-1e18,1e18))
         if mc.direction=="geq" and nb.get(vi,0)<nb.get(vj,0):
             mid=(nb[vi]+nb[vj])/2; nb[vi]=max(lo_i,mid); nb[vj]=min(hi_j,mid)
     return [_make_hyp(f"ord_{hash(str(nb))%9999}",nb,"ordered","OrderBal",["ordered"],{},list(problem.variables),0.67)]
@@ -1083,7 +1132,7 @@ def _hyp_transitive(problem,baton,all_batons,model):
         changed=False; iters+=1
         for mc in problem.compiled_constraints:
             if mc.kind!="equality" or not mc.projections: continue
-            for v,projs in mc.projections.items():
+            for v in mc.projections:
                 val=_proj_val(mc,v,nb)
                 if val is None: continue
                 lo,hi=problem.bounds.get(v,(-1e18,1e18))
@@ -1205,56 +1254,219 @@ def _hyp_duality(problem,baton,all_batons,model):
     return hyps
 
 AXIOM_CONSTRUCTORS:Dict[str,Callable]={
-    Axiom.CONTINUOUS:_hyp_continuous,Axiom.DISCRETE:_hyp_discrete,
-    Axiom.QUADRATIC:_hyp_quadratic,Axiom.BILINEAR:_hyp_bilinear,
-    Axiom.METRIC:_hyp_metric,Axiom.SYMMETRIC:_hyp_symmetric,
-    Axiom.ORDERED:_hyp_ordered,Axiom.MONOTONE:_hyp_monotone,Axiom.CONVEX:_hyp_convex,
-    Axiom.CONSERVED:_hyp_conserved,Axiom.MUTABLE:_hyp_mutable,Axiom.NETWORK:_hyp_network,
+    Axiom.CONTINUOUS:_hyp_continuous, Axiom.DISCRETE:_hyp_discrete,
+    Axiom.QUADRATIC:_hyp_quadratic,   Axiom.BILINEAR:_hyp_bilinear,
+    Axiom.METRIC:_hyp_metric,         Axiom.SYMMETRIC:_hyp_symmetric,
+    Axiom.ORDERED:_hyp_ordered,       Axiom.MONOTONE:_hyp_monotone,
+    Axiom.CONVEX:_hyp_convex,         Axiom.CONSERVED:_hyp_conserved,
+    Axiom.MUTABLE:_hyp_mutable,       Axiom.NETWORK:_hyp_network,
     Axiom.EQUILIBRIUM:_hyp_equilibrium,Axiom.SUPERPOSITION:_hyp_superposition,
-    Axiom.LOCALITY:_hyp_locality,Axiom.EXTREMAL:_hyp_extremal,Axiom.ENTROPY:_hyp_entropy,
-    Axiom.INJECTIVE:_hyp_injective,Axiom.SURJECTIVE:_hyp_surjective,
-    Axiom.TRANSITIVE:_hyp_transitive,Axiom.ATOMIC:_hyp_atomic,
-    Axiom.IMPLICATION:_hyp_implication,Axiom.NEGATION:_hyp_negation,
-    Axiom.COMPOSITE:_hyp_composite,Axiom.HOLISM:_hyp_holism,
-    Axiom.PARSIMONY:_hyp_parsimony,Axiom.DUALITY:_hyp_duality,
+    Axiom.LOCALITY:_hyp_locality,     Axiom.EXTREMAL:_hyp_extremal,
+    Axiom.ENTROPY:_hyp_entropy,       Axiom.INJECTIVE:_hyp_injective,
+    Axiom.SURJECTIVE:_hyp_surjective, Axiom.TRANSITIVE:_hyp_transitive,
+    Axiom.ATOMIC:_hyp_atomic,         Axiom.IMPLICATION:_hyp_implication,
+    Axiom.NEGATION:_hyp_negation,     Axiom.COMPOSITE:_hyp_composite,
+    Axiom.HOLISM:_hyp_holism,         Axiom.PARSIMONY:_hyp_parsimony,
+    Axiom.DUALITY:_hyp_duality,
 }
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 12: SEQUENCE HYPOTHESIS GENERATOR + RAY TRACER
+# SECTION 12: SEQUENCE HYPOTHESIS GENERATOR
+# Now tracks resonant pairs — consecutive axioms that both produce
+# meaningful CE reduction are recorded for this run.
 # ══════════════════════════════════════════════════════════════════════
 class SequenceHypothesisGenerator:
-    def generate(self,sequence:List[str],problem:Problem,
-                 baton:Baton,all_batons:List[Baton],model:StructuralModel) -> Tuple[List[Hypothesis],Baton]:
+    def generate(self, sequence:List[str], problem:Problem,
+                 baton:Baton, all_batons:List[Baton],
+                 model:StructuralModel) -> Tuple[List[Hypothesis],Baton]:
         accumulated:List[Hypothesis]=[]; current=baton
+        prev_axiom:Optional[str]=None; prev_ce=baton.ce
+
         for i,axiom in enumerate(sequence):
             constructor=AXIOM_CONSTRUCTORS.get(axiom)
             if not constructor: continue
+
             if current.l7 is None:
                 active=[s for s in problem.scope_order if s!="root" and problem.scope_vars.get(s)]
                 current.l7=TOPOLOGY_ORACLE.evaluate(problem,active)
             if current.l9 is None:
                 hubs=current.l7.hub_vars if current.l7 else []
                 current.l9=RESIDUAL_ORACLE.evaluate(current.binding,problem,hubs)
+
             new_hyps=constructor(problem,current,all_batons,model)
             accumulated.extend(new_hyps)
+
             best_ce=current.ce; best_b=current.binding
             for hyp in sorted(new_hyps,key=lambda h:-h.confidence)[:MAX_HYPS_PER_AXIOM]:
                 if hyp.hid in model.failure_patterns: continue
                 tb,tce=_test_hypothesis(problem,hyp)
                 if tce<best_ce: best_ce=tce; best_b=tb
+
             if best_ce<current.ce:
-                current=Baton(binding=best_b,ce=best_ce,ray_id=current.ray_id,depth=i+1,l7=None,l9=None)
+                # Resonance detection: both this axiom AND the previous one reduced CE
+                if prev_axiom and best_ce < prev_ce * RESONANCE_THRESHOLD:
+                    pair=(prev_axiom, axiom)
+                    if pair not in model.resonant_pairs:
+                        model.resonant_pairs.append(pair)
+                prev_ce=current.ce
+                current=Baton(binding=best_b,ce=best_ce,
+                              ray_id=current.ray_id,depth=i+1,l7=None,l9=None)
+
+            prev_axiom=axiom
+
         return accumulated,current
 
-class SequenceRayTracer:
-    MAX_TOTAL_RAYS=80; BRANCH_WIDTH=4; MIN_DEPTH=1; CE_EARN_RATIO=0.90
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 13: CREATIVE SEEDER
+# Generates four categories of novel rays beyond the seed tree.
+# All creativity is structural — derived from axiom space topology
+# and in-run resonance discovery. Zero cross-run bias.
+# ══════════════════════════════════════════════════════════════════════
+class CreativeSeeder:
+    """
+    The four creative moves:
+
+    1. TENSION: mediated contradictions [A→B→C] where (A,C) are in
+       ADJACENT_CONTRADICTIONS but B mediates. CO₂ molecules.
+       Stable structures from reactive parts.
+
+    2. SCOUT: fully random valid sequences, length 3-8.
+       Pure cartographers. No earning required.
+
+    3. RECOMBINE: single-point crossover of two proven sequences.
+       Front of seq_a + compatible tail of seq_b.
+
+    4. INVERT: reversed sequence. Same axioms, opposite order.
+       The problem approached from the other end.
+    """
+
+    def tension_seeds(self, max_n:int=60) -> List[AxiomRay]:
+        """
+        For every contradiction pair (A,C), find all B that mediate.
+        [A→B→C]: A and C contradict directly but B makes both steps valid.
+        These are seeds — they get to run from the beginning, no earning.
+        """
+        results:List[AxiomRay]=[]
+        for (a,c) in ADJACENT_CONTRADICTIONS:
+            for b in ALL_AXIOMS:
+                if b in (a,c): continue
+                if (frozenset([a,b]) not in _CONTRA_SET and
+                    frozenset([b,c]) not in _CONTRA_SET):
+                    seq=[a,b,c]
+                    ab=AXIOM_ABBR; rid=f"T_{ab.get(a,a[:3])}_{ab.get(b,b[:3])}_{ab.get(c,c[:3])}"
+                    results.append(AxiomRay(sequence=seq,ray_id=rid,ray_type=RAY_TENSION,depth=0))
+                    # Extend to length 4: any D where C→D is valid
+                    for d in ALL_AXIOMS:
+                        if d not in seq and frozenset([c,d]) not in _CONTRA_SET:
+                            seq4=seq+[d]; rid4=f"{rid}_{ab.get(d,d[:3])}"
+                            results.append(AxiomRay(sequence=seq4,ray_id=rid4,ray_type=RAY_TENSION,depth=0))
+        random.shuffle(results)
+        return results[:max_n]
+
+    def random_scouts(self, n:int=25) -> List[AxiomRay]:
+        """
+        Fully random valid sequences, length 3-8.
+        Pure exploration — no earning required to spawn children.
+        """
+        scouts:List[AxiomRay]=[]; attempts=0
+        while len(scouts)<n and attempts<n*30:
+            attempts+=1
+            length=random.randint(3,min(8,len(ALL_AXIOMS)))
+            pool=list(ALL_AXIOMS); random.shuffle(pool)
+            seq=[pool[0]]
+            for ax in pool[1:]:
+                if len(seq)>=length: break
+                if frozenset([seq[-1],ax]) not in _CONTRA_SET:
+                    seq.append(ax)
+            if len(seq)>=3:
+                rid=f"SC_{''.join(AXIOM_ABBR.get(a,a[:2]) for a in seq)}"
+                scouts.append(AxiomRay(sequence=seq,ray_id=rid,ray_type=RAY_SCOUT,depth=0))
+        return scouts
+
+    def recombine(self, ray_a:AxiomRay, ray_b:AxiomRay, baton:Baton) -> List[AxiomRay]:
+        """
+        Single-point crossover. For each cut point, take the front of ray_a
+        and graft on the tail of ray_b (filtering axioms already present).
+        """
+        results:List[AxiomRay]=[]; ab=AXIOM_ABBR
+        seq_a,seq_b=ray_a.sequence,ray_b.sequence
+        for cut in range(1,min(len(seq_a),len(seq_b))):
+            head=seq_a[:cut]
+            tail=[x for x in seq_b[cut:] if x not in head]
+            candidate=head+tail
+            if len(candidate)>=2 and sequence_valid(candidate):
+                rid=f"RC_{ray_a.ray_id[:8]}x{ray_b.ray_id[:8]}_c{cut}"
+                child=AxiomRay(sequence=candidate,ray_id=rid,ray_type=RAY_RECOMBINE,
+                               depth=0,parent_id=f"{ray_a.ray_id}+{ray_b.ray_id}",
+                               baton=baton)
+                results.append(child)
+        return results
+
+    def invert(self, ray:AxiomRay, baton:Baton) -> Optional[AxiomRay]:
+        """
+        Reverse the sequence. Same mathematical worldviews, opposite encounter order.
+        """
+        inv=list(reversed(ray.sequence))
+        if sequence_valid(inv) and inv!=ray.sequence:
+            rid=f"INV_{ray.ray_id}"
+            return AxiomRay(sequence=inv,ray_id=rid,ray_type=RAY_INVERT,
+                            depth=0,parent_id=ray.ray_id,baton=baton)
+        return None
+
+    def resonance_extensions(self, ray:AxiomRay, baton:Baton,
+                             resonant_pairs:List[Tuple[str,str]]) -> List[AxiomRay]:
+        """
+        If the ray ends with axiom A, and (A,B) is a discovered resonant pair,
+        generate A→B as a priority branch. These are in-run discoveries — the
+        system follows its own sensed potency for THIS problem.
+        """
+        if not ray.sequence or not resonant_pairs: return []
+        last=ray.sequence[-1]; results:List[AxiomRay]=[]
+        resonant_nexts=[b for (a,b) in resonant_pairs if a==last and b not in ray.sequence]
+        for b in resonant_nexts:
+            child=ray.extend(b, RAY_BRANCH)
+            if child:
+                child.baton=baton
+                child.ray_id=f"RES_{child.ray_id}"
+                results.append(child)
+        return results
+
+CREATIVE_SEEDER=CreativeSeeder()
 
-    def trace(self,axl_def:AXLProblemDef,base_problem:Problem) -> Tuple[Dict,float,List[Dict]]:
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 14: SEQUENCE RAY TRACER (15.0 — Creative Architecture)
+# ══════════════════════════════════════════════════════════════════════
+class SequenceRayTracer:
+    MAX_TOTAL_RAYS = 100    # more budget for creative exploration
+    BRANCH_WIDTH   = 3      # branches per earned ray
+    MIN_DEPTH      = 1      # depth below which branching is always free
+    CE_EARN_RATIO  = 0.90   # 10% reduction earns a branch
+    # Scouts bypass earning — they always get to branch if CE < threshold
+    SCOUT_CE_THRESHOLD = 0.5
+
+    def trace(self, axl_def:AXLProblemDef, base_problem:Problem) -> Tuple[Dict,float,List[Dict]]:
         all_traces:List[HypothesisTrace]=[]; generator=SequenceHypothesisGenerator()
-        active=[AxiomRay(sequence=[a],ray_id=f"S{i}",depth=0) for i,a in enumerate(ALL_AXIOMS)]
-        random.shuffle(active)
-        all_batons:List[Baton]=[]; best_ce=float('inf'); best_binding:Dict={}; history:List[Dict]=[]
-        total_fired=0
+
+        # ── Initial queue: seeds + tension seeds + scouts (interleaved) ──
+        seed_rays=[AxiomRay(sequence=[a],ray_id=f"S{i}",ray_type=RAY_SEED,depth=0)
+                   for i,a in enumerate(ALL_AXIOMS)]
+        tension_rays=CREATIVE_SEEDER.tension_seeds(max_n=50)
+        scout_rays=CREATIVE_SEEDER.random_scouts(n=20)
+
+        # Interleave: seed, tension, scout, seed, tension, scout ...
+        # This ensures we don't exhaust the budget on one category
+        active:List[AxiomRay]=[]
+        buckets=[seed_rays, tension_rays, scout_rays]
+        random.shuffle(seed_rays); random.shuffle(tension_rays); random.shuffle(scout_rays)
+        max_len=max(len(b) for b in buckets)
+        for i in range(max_len):
+            for bucket in buckets:
+                if i<len(bucket): active.append(bucket[i])
+
+        all_batons:List[Baton]=[]; best_ce=float('inf'); best_binding:Dict={}
+        history:List[Dict]=[]; total_fired=0
+        # Track successful rays for recombination
+        successful_rays:List[AxiomRay]=[]
 
         init_b={v:(lo+hi)/2 for v,(lo,hi) in base_problem.bounds.items()}
         init_ce=base_problem.constraint_energy(init_b)
@@ -1264,49 +1476,124 @@ class SequenceRayTracer:
             {v:IV(*base_problem.bounds[v]) for v in base_problem.variables},N_MPRT_EXPLORE//5)
         if mprt_ce<init_ce: init_b=mprt_b; init_ce=mprt_ce
         seed_baton=Baton(binding=init_b,ce=init_ce,ray_id="SEED")
+
+        # Shared structural model (per-run, carries resonant_pairs)
+        shared_model=StructuralModel(best_binding=init_b,best_ce=init_ce)
         self._last_traces=all_traces
 
+        print(f"\n{'═'*65}\nCREATIVE RAY TRACE 15.0: {axl_def.name}\n{'═'*65}")
+
         while active and total_fired<self.MAX_TOTAL_RAYS:
             ray=active.pop(0); total_fired+=1
             parent_baton=ray.baton or seed_baton
-            model=StructuralModel(
-                best_binding=best_binding if best_binding else parent_baton.binding,
-                best_ce=best_ce if best_ce<float('inf') else init_ce)
+
+            # Update shared model
+            shared_model.best_binding=best_binding if best_binding else parent_baton.binding
+            shared_model.best_ce=best_ce if best_ce<float('inf') else init_ce
+
             t0=time.time()
-            hyps,output_baton=generator.generate(ray.sequence,base_problem,parent_baton,all_batons,model)
+            hyps,output_baton=generator.generate(
+                ray.sequence,base_problem,parent_baton,all_batons,shared_model)
             elapsed=round((time.time()-t0)*1000,1)
             output_baton.ray_id=ray.ray_id; all_batons.append(output_baton)
-            if output_baton.ce<best_ce: best_ce=output_baton.ce; best_binding=dict(output_baton.binding)
+
+            improved=output_baton.ce<best_ce
+            if improved:
+                best_ce=output_baton.ce; best_binding=dict(output_baton.binding)
+                successful_rays.append(ray)
+
             verify=VERIFY_LAYER.run(output_baton.binding,base_problem,axl_def.anchors)
             trace=HypothesisTrace(
-                hid=ray.ray_id,round_idx=total_fired,ray_name=ray.name,action="Ray",
+                hid=ray.ray_id,round_idx=total_fired,ray_name=ray.name,
+                ray_type=ray.ray_type,action="CreativeRay",
                 ce_before=parent_baton.ce if parent_baton.ce<float('inf') else 99.0,
                 ce_after=output_baton.ce,verify=verify,survived=verify.overall_pass,
                 elapsed_ms=elapsed,depth=ray.depth,parent_id=ray.parent_id or "")
             all_traces.append(trace)
-            history.append({"ray_id":ray.ray_id,"sequence":ray.name,"depth":ray.depth,
-                "parent":ray.parent_id,"ce_in":round(parent_baton.ce if parent_baton.ce<float('inf') else 99,5),
+
+            icon=RAY_ICONS.get(ray.ray_type,"·")
+            status="✓" if verify.overall_pass else ""
+            print(f"  [{total_fired:3d}]{icon} {ray.name:<38} "
+                  f"CE {parent_baton.ce:.4f}→{output_baton.ce:.4f} "
+                  f"G1={'✓' if verify.gate1_pass else '✗'} "
+                  f"G2={'✓' if verify.gate2_pass else '✗'} {status}")
+
+            history.append({
+                "ray_id":ray.ray_id,"sequence":ray.name,"ray_type":ray.ray_type,
+                "depth":ray.depth,"parent":ray.parent_id,
+                "ce_in":round(parent_baton.ce if parent_baton.ce<float('inf') else 99,5),
                 "ce_out":round(output_baton.ce,5),"survived":verify.overall_pass,"ms":elapsed})
-            if verify.overall_pass: break
-            parent_ce=parent_baton.ce if parent_baton.ce<float('inf') else init_ce
-            earned=(output_baton.ce<parent_ce*self.CE_EARN_RATIO or ray.depth<self.MIN_DEPTH)
-            if earned:
-                remaining=[a for a in ALL_AXIOMS if a not in ray.sequence]
-                random.shuffle(remaining); children=[]
-                for axiom in remaining:
-                    child=ray.extend(axiom)
-                    if child: child.baton=output_baton; children.append(child)
-                    if len(children)>=self.BRANCH_WIDTH*2: break
-                active=children+active
 
-        self._last_traces=all_traces
+            if verify.overall_pass:
+                print(f"\n✓ TRUE UNIVERSE FOUND: {icon} {ray.name}")
+                break
+
+            # ── Branching decisions ───────────────────────────────────
+            parent_ce=parent_baton.ce if parent_baton.ce<float('inf') else init_ce
+            earned=(output_baton.ce<parent_ce*self.CE_EARN_RATIO
+                    or ray.depth<self.MIN_DEPTH)
+            scout_earned=(ray.ray_type==RAY_SCOUT
+                          and output_baton.ce<self.SCOUT_CE_THRESHOLD)
+
+            new_children:List[AxiomRay]=[]
+
+            if earned or scout_earned:
+                # 1. Standard tree branches (resonance-guided)
+                new_children.extend(
+                    self._spawn_tree_children(ray,output_baton,shared_model.resonant_pairs))
+
+                # 2. Inversion of this ray
+                inv=CREATIVE_SEEDER.invert(ray,output_baton)
+                if inv: new_children.append(inv)
+
+                # 3. Recombination with a random successful ray
+                if len(successful_rays)>=2:
+                    partner=random.choice([r for r in successful_rays if r.ray_id!=ray.ray_id]
+                                          or successful_rays)
+                    new_children.extend(
+                        CREATIVE_SEEDER.recombine(ray,partner,output_baton)[:2])
+
+                # 4. Resonance-guided extensions
+                new_children.extend(
+                    CREATIVE_SEEDER.resonance_extensions(
+                        ray,output_baton,shared_model.resonant_pairs))
+
+            # Depth-first: branches at front; inversions/recombinations at back
+            branches=[c for c in new_children if c.ray_type==RAY_BRANCH]
+            creative=[c for c in new_children if c.ray_type!=RAY_BRANCH]
+            active=branches+active+creative
+
+        survived=[t for t in all_traces if t.survived]
+        best_t=min(survived,key=lambda t:t.ce_after,default=None)
+        print(f"\n{'─'*65}")
+        print(f"RESULT: CE={best_ce:.5f} | Fired={total_fired} | "
+              f"Survived={len(survived)} | Best={best_t.ray_name if best_t else '—'}")
+        print(f"Resonant pairs discovered: {shared_model.resonant_pairs}")
         return best_binding,best_ce,history
 
+    def _spawn_tree_children(self, ray:AxiomRay, baton:Baton,
+                              resonant_pairs:List[Tuple[str,str]]) -> List[AxiomRay]:
+        """
+        Standard branch children, but prioritised by resonant pairs.
+        If the ray ends with A and (A,B) is resonant, B goes first.
+        """
+        last=ray.sequence[-1] if ray.sequence else None
+        resonant_nexts=([b for (a,b) in resonant_pairs if a==last and b not in ray.sequence]
+                        if last else [])
+        remaining=[a for a in ALL_AXIOMS if a not in ray.sequence]
+        random.shuffle(remaining)
+        # Resonant candidates first, then random
+        priority=resonant_nexts+[a for a in remaining if a not in resonant_nexts]
+        children:List[AxiomRay]=[]; count=0
+        for axiom in priority:
+            if count>=self.BRANCH_WIDTH*2: break
+            child=ray.extend(axiom, RAY_BRANCH)
+            if child: child.baton=baton; children.append(child); count+=1
+        return children
+
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 13: REAL-WORLD AXL PROBLEMS (14 across 11 domains)
+# SECTION 15: AXL PROBLEMS (14 real-world domains from 14.0)
 # ══════════════════════════════════════════════════════════════════════
-
-# Domain metadata
 PROBLEM_META={
     "EllipticCurvePoint": {"domain":"Cryptography",  "icon":"🔐","difficulty":"Medium"},
     "MarkowitzPortfolio": {"domain":"Finance",        "icon":"📈","difficulty":"Hard"},
@@ -1325,247 +1612,185 @@ PROBLEM_META={
 }
 
 AXL_PROBLEMS=[
-
-# ── CRYPTOGRAPHY ──────────────────────────────────────────────────────
 AXLProblemDef(
     name="EllipticCurvePoint",
-    description="Find point on E: y²=x³-x+1 (Weierstrass). Observe x=0, find y=±1.",
+    description="Find point on E: y²=x³-x+1. Observe x=0, find y=±1.",
     axioms={Axiom.CONTINUOUS,Axiom.QUADRATIC,Axiom.METRIC,Axiom.SYMMETRIC},
     variables=[{"name":"ex","lo":-2.0,"hi":2.0},{"name":"ey","lo":-2.0,"hi":2.0}],
-    constraints=[
-        # y² - x³ + x - 1 = 0  →  ey**2 - ex**3 + ex - 1 = 0
-        {"kind":"EQ","expr":"ey**2 - ex**3 + ex - 1","weight":5.0},
-    ],
+    constraints=[{"kind":"EQ","expr":"ey**2 - ex**3 + ex - 1","weight":5.0}],
     scopes=[{"name":"curve","order":0,"vars":["ex","ey"],
              "constraints":[{"kind":"EQ","expr":"ey**2 - ex**3 + ex - 1","weight":8.0}]}],
     anchors=[AXLInvariant("on_curve","ey**2 - ex**3 + ex - 1",1e-3)],
-    observations={"ex":0.0},  # x=0 → y=±1
+    observations={"ex":0.0},
 ),
-
-# ── FINANCE ───────────────────────────────────────────────────────────
 AXLProblemDef(
     name="MarkowitzPortfolio",
-    description="4-asset portfolio: budget=1, return=11%, minimize variance. "
-                "μ=[10,12,8,15]%, σ²=[4,9,1,16]%.",
+    description="4-asset portfolio: budget=1, return=11%, min variance.",
     axioms={Axiom.CONSERVED,Axiom.ORDERED,Axiom.METRIC,Axiom.HOLISM},
-    variables=[
-        {"name":"w1","lo":0.0,"hi":1.0},{"name":"w2","lo":0.0,"hi":1.0},
-        {"name":"w3","lo":0.0,"hi":1.0},{"name":"w4","lo":0.0,"hi":1.0},
-    ],
+    variables=[{"name":"w1","lo":0.0,"hi":1.0},{"name":"w2","lo":0.0,"hi":1.0},
+               {"name":"w3","lo":0.0,"hi":1.0},{"name":"w4","lo":0.0,"hi":1.0}],
     constraints=[
-        {"kind":"CONSERVE","expr":"w1 + w2 + w3 + w4 - 1.0"},
-        {"kind":"EQ","expr":"0.10*w1 + 0.12*w2 + 0.08*w3 + 0.15*w4 - 0.11","weight":3.0},
+        {"kind":"CONSERVE","expr":"w1+w2+w3+w4-1.0"},
+        {"kind":"EQ","expr":"0.10*w1+0.12*w2+0.08*w3+0.15*w4-0.11","weight":3.0},
         {"kind":"GEQ","expr":"w1","weight":1.0},{"kind":"GEQ","expr":"w2","weight":1.0},
         {"kind":"GEQ","expr":"w3","weight":1.0},{"kind":"GEQ","expr":"w4","weight":1.0},
     ],
     scopes=[{"name":"portfolio","order":0,"vars":["w1","w2","w3","w4"],
              "constraints":[
-                 # Minimize variance (soft TEND toward low-variance asset 3)
-                 {"kind":"EQ","expr":"w1 + w2 + w3 + w4 - 1.0","weight":5.0},
-                 {"kind":"EQ","expr":"0.10*w1 + 0.12*w2 + 0.08*w3 + 0.15*w4 - 0.11","weight":3.0},
+                 {"kind":"EQ","expr":"w1+w2+w3+w4-1.0","weight":5.0},
+                 {"kind":"EQ","expr":"0.10*w1+0.12*w2+0.08*w3+0.15*w4-0.11","weight":3.0},
              ]}],
     anchors=[
         AXLInvariant("budget","w1+w2+w3+w4-1.0",1e-3),
         AXLInvariant("return_target","0.10*w1+0.12*w2+0.08*w3+0.15*w4-0.11",5e-3),
-        AXLInvariant("w1_positive","w1",1e-3,"geq"),
-        AXLInvariant("w2_positive","w2",1e-3,"geq"),
-        AXLInvariant("w3_positive","w3",1e-3,"geq"),
-        AXLInvariant("w4_positive","w4",1e-3,"geq"),
+        AXLInvariant("w1_pos","w1",1e-3,"geq"),AXLInvariant("w2_pos","w2",1e-3,"geq"),
+        AXLInvariant("w3_pos","w3",1e-3,"geq"),AXLInvariant("w4_pos","w4",1e-3,"geq"),
     ],
-    # Many valid solutions: e.g. w1=w2=w3≈0.267, w4≈0.200
 ),
-
-# ── ENERGY SYSTEMS ────────────────────────────────────────────────────
 AXLProblemDef(
     name="PowerFlowDC3Bus",
-    description="DC power flow: 3-bus network, B12=2, B13=3, B23=1. "
-                "θ1=0 (ref), Pg1=0.5. Find θ2≈-0.318, θ3≈0.046.",
+    description="DC power flow 3-bus. pt2≈-0.318, pt3≈0.046.",
     axioms={Axiom.CONSERVED,Axiom.NETWORK,Axiom.EQUILIBRIUM,Axiom.ORDERED},
-    variables=[
-        {"name":"pt2","lo":-1.0,"hi":0.5},
-        {"name":"pt3","lo":-0.5,"hi":0.5},
-    ],
+    variables=[{"name":"pt2","lo":-1.0,"hi":0.5},{"name":"pt3","lo":-0.5,"hi":0.5}],
     constraints=[
-        # Bus 1: -2*θ2 - 3*θ3 = 0.5 (Pg1=0.5)
-        {"kind":"EQ","expr":"-2*pt2 - 3*pt3 - 0.5","weight":5.0},
-        # Bus 2: 3*θ2 - θ3 = -1.0 (Pd2=1.0)
-        {"kind":"EQ","expr":"3*pt2 - pt3 + 1.0","weight":5.0},
+        {"kind":"EQ","expr":"-2*pt2-3*pt3-0.5","weight":5.0},
+        {"kind":"EQ","expr":"3*pt2-pt3+1.0","weight":5.0},
     ],
     scopes=[{"name":"power","order":0,"vars":["pt2","pt3"],
              "constraints":[
-                 {"kind":"EQ","expr":"-2*pt2 - 3*pt3 - 0.5","weight":5.0},
-                 {"kind":"EQ","expr":"3*pt2 - pt3 + 1.0","weight":5.0},
+                 {"kind":"EQ","expr":"-2*pt2-3*pt3-0.5","weight":5.0},
+                 {"kind":"EQ","expr":"3*pt2-pt3+1.0","weight":5.0},
              ]}],
     anchors=[
-        AXLInvariant("bus1_balance","-2*pt2 - 3*pt3 - 0.5",1e-3),
-        AXLInvariant("bus2_balance","3*pt2 - pt3 + 1.0",1e-3),
+        AXLInvariant("bus1","-2*pt2-3*pt3-0.5",1e-3),
+        AXLInvariant("bus2","3*pt2-pt3+1.0",1e-3),
     ],
-    # Known: pt2 = -7/22 ≈ -0.3182, pt3 = 1/22 ≈ 0.0455
 ),
-
-# ── CHEMISTRY ────────────────────────────────────────────────────────
 AXLProblemDef(
     name="ChemEquilibrium",
-    description="A+B↔C equilibrium, Kc=4. "
-                "Initial [A]=[B]=1, [C]=0. Solve: ca=cb≈0.390, cc≈0.610.",
+    description="A+B↔C, Kc=4. ca=cb≈0.390, cc≈0.610.",
     axioms={Axiom.CONSERVED,Axiom.BILINEAR,Axiom.CONTINUOUS,Axiom.MONOTONE},
-    variables=[
-        {"name":"ca","lo":0.0,"hi":1.0},
-        {"name":"cb","lo":0.0,"hi":1.0},
-        {"name":"cc","lo":0.0,"hi":1.0},
-    ],
+    variables=[{"name":"ca","lo":0.0,"hi":1.0},{"name":"cb","lo":0.0,"hi":1.0},
+               {"name":"cc","lo":0.0,"hi":1.0}],
     constraints=[
-        {"kind":"CONSERVE","expr":"ca + cc - 1.0"},    # A atom balance
-        {"kind":"CONSERVE","expr":"cb + cc - 1.0"},    # B atom balance
-        {"kind":"EQ","expr":"4*ca*cb - cc","weight":5.0},  # Kc=4: cc=Kc*ca*cb
+        {"kind":"CONSERVE","expr":"ca+cc-1.0"},
+        {"kind":"CONSERVE","expr":"cb+cc-1.0"},
+        {"kind":"EQ","expr":"4*ca*cb-cc","weight":5.0},
     ],
-    scopes=[{"name":"equilibrium","order":0,"vars":["ca","cb","cc"],
+    scopes=[{"name":"equil","order":0,"vars":["ca","cb","cc"],
              "constraints":[
-                 {"kind":"EQ","expr":"ca - cb","weight":3.0},   # stoichiometry: ca=cb
-                 {"kind":"EQ","expr":"4*ca*cb - cc","weight":5.0},
+                 {"kind":"EQ","expr":"ca-cb","weight":3.0},
+                 {"kind":"EQ","expr":"4*ca*cb-cc","weight":5.0},
              ]}],
     anchors=[
         AXLInvariant("balance_A","ca+cc-1.0",1e-3),
         AXLInvariant("balance_B","cb+cc-1.0",1e-3),
-        AXLInvariant("equilibrium","4*ca*cb - cc",1e-3),
+        AXLInvariant("equilibrium","4*ca*cb-cc",1e-3),
     ],
-    # Known: ca=cb=(-1+√17)/8≈0.3904, cc≈0.6096
 ),
-
-# ── CHAOS THEORY ─────────────────────────────────────────────────────
 AXLProblemDef(
     name="LorenzFixedPoint",
-    description="Lorenz σ=10,ρ=28,β=8/3. Non-origin fixed point: "
-                "x=y, z=27, x²=72. Solution: (±8.485, ±8.485, 27).",
+    description="Lorenz σ=10,ρ=28,β=8/3. Fixed point: x=y=±8.485, z=27.",
     axioms={Axiom.CONTINUOUS,Axiom.QUADRATIC,Axiom.SYMMETRIC,Axiom.CONSERVED},
-    variables=[
-        {"name":"lx","lo":-12.0,"hi":12.0},
-        {"name":"ly","lo":-12.0,"hi":12.0},
-        {"name":"lz","lo":20.0,"hi":35.0},
-    ],
+    variables=[{"name":"lx","lo":-12.0,"hi":12.0},{"name":"ly","lo":-12.0,"hi":12.0},
+               {"name":"lz","lo":20.0,"hi":35.0}],
     constraints=[
-        {"kind":"EQ","expr":"lx - ly","weight":5.0},       # x=y (from σ(y-x)=0)
-        {"kind":"EQ","expr":"lz - 27.0","weight":5.0},     # z=ρ-1=27
-        {"kind":"EQ","expr":"lx**2 - 72.0","weight":5.0},  # x²=β(ρ-1)=8/3*27=72
+        {"kind":"EQ","expr":"lx-ly","weight":5.0},
+        {"kind":"EQ","expr":"lz-27.0","weight":5.0},
+        {"kind":"EQ","expr":"lx**2-72.0","weight":5.0},
     ],
     scopes=[{"name":"lorenz","order":0,"vars":["lx","ly","lz"],
              "constraints":[
-                 {"kind":"EQ","expr":"lx - ly","weight":5.0},
-                 {"kind":"EQ","expr":"lz - 27.0","weight":5.0},
-                 {"kind":"EQ","expr":"lx**2 - 72.0","weight":5.0},
+                 {"kind":"EQ","expr":"lx-ly","weight":5.0},
+                 {"kind":"EQ","expr":"lz-27.0","weight":5.0},
+                 {"kind":"EQ","expr":"lx**2-72.0","weight":5.0},
              ]}],
     anchors=[
-        AXLInvariant("x_equals_y","lx-ly",1e-3),
-        AXLInvariant("z_is_27","lz-27.0",1e-3),
-        AXLInvariant("x_squared_72","lx**2-72.0",0.1),
+        AXLInvariant("x_eq_y","lx-ly",1e-3),
+        AXLInvariant("z_27","lz-27.0",1e-3),
+        AXLInvariant("x2_72","lx**2-72.0",0.1),
     ],
 ),
-
-# ── GAME THEORY ──────────────────────────────────────────────────────
 AXLProblemDef(
     name="NashBattleSexes",
-    description="Battle of Sexes 2x2 game. Mixed Nash: p=2/3 (P1 Opera), q=1/3 (P2 Opera).",
+    description="Battle of Sexes mixed Nash: p=2/3, q=1/3.",
     axioms={Axiom.CONTINUOUS,Axiom.SYMMETRIC,Axiom.CONSERVED,Axiom.ORDERED},
-    variables=[
-        {"name":"np","lo":0.0,"hi":1.0},   # P1 prob choosing Opera
-        {"name":"nq","lo":0.0,"hi":1.0},   # P2 prob choosing Opera
-    ],
+    variables=[{"name":"np","lo":0.0,"hi":1.0},{"name":"nq","lo":0.0,"hi":1.0}],
     constraints=[
-        {"kind":"EQ","expr":"3*nq - 1.0","weight":5.0},   # P1 indifference: q=1/3
-        {"kind":"EQ","expr":"3*np - 2.0","weight":5.0},   # P2 indifference: p=2/3
+        {"kind":"EQ","expr":"3*nq-1.0","weight":5.0},
+        {"kind":"EQ","expr":"3*np-2.0","weight":5.0},
     ],
     scopes=[{"name":"nash","order":0,"vars":["np","nq"],
              "constraints":[
-                 {"kind":"EQ","expr":"3*nq - 1.0","weight":5.0},
-                 {"kind":"EQ","expr":"3*np - 2.0","weight":5.0},
+                 {"kind":"EQ","expr":"3*nq-1.0","weight":5.0},
+                 {"kind":"EQ","expr":"3*np-2.0","weight":5.0},
              ]}],
     anchors=[
         AXLInvariant("p1_indiff","3*nq-1.0",1e-3),
         AXLInvariant("p2_indiff","3*np-2.0",1e-3),
     ],
-    # Known: np=2/3≈0.6667, nq=1/3≈0.3333
 ),
-
-# ── ASTRONOMY ─────────────────────────────────────────────────────────
 AXLProblemDef(
     name="KeplerPeriapsis",
-    description="Orbital mechanics at periapsis. GM=1 units. a=1, e=0.5 observed. "
-                "Find rp=0.5, vp=√3≈1.732, h≈0.866.",
+    description="Orbital mechanics at periapsis. a=1, e=0.5 → rp=0.5, vp=√3, h=√3/2.",
     axioms={Axiom.CONTINUOUS,Axiom.QUADRATIC,Axiom.CONSERVED,Axiom.METRIC},
     variables=[
-        {"name":"ka","lo":0.5,"hi":2.0},    # semi-major axis
-        {"name":"ke","lo":0.0,"hi":0.99},   # eccentricity
-        {"name":"krp","lo":0.1,"hi":2.0},   # periapsis radius
-        {"name":"kvp","lo":0.5,"hi":5.0},   # periapsis speed
-        {"name":"kh","lo":0.1,"hi":3.0},    # specific angular momentum
+        {"name":"ka","lo":0.5,"hi":2.0},{"name":"ke","lo":0.0,"hi":0.99},
+        {"name":"krp","lo":0.1,"hi":2.0},{"name":"kvp","lo":0.5,"hi":5.0},
+        {"name":"kh","lo":0.1,"hi":3.0},
     ],
     constraints=[
-        {"kind":"EQ","expr":"krp - ka*(1 - ke)","weight":5.0},          # rp = a(1-e)
-        {"kind":"EQ","expr":"kvp**2*krp - (1 + ke)","weight":5.0},      # vis-viva (GM=1)
-        {"kind":"EQ","expr":"kh - krp*kvp","weight":5.0},               # L = r×v
+        {"kind":"EQ","expr":"krp-ka*(1-ke)","weight":5.0},
+        {"kind":"EQ","expr":"kvp**2*krp-(1+ke)","weight":5.0},
+        {"kind":"EQ","expr":"kh-krp*kvp","weight":5.0},
     ],
     scopes=[{"name":"orbit","order":0,"vars":["ka","ke","krp","kvp","kh"],
              "constraints":[
-                 {"kind":"EQ","expr":"krp - ka*(1 - ke)","weight":5.0},
-                 {"kind":"EQ","expr":"kvp**2*krp - (1 + ke)","weight":5.0},
-                 {"kind":"EQ","expr":"kh - krp*kvp","weight":5.0},
+                 {"kind":"EQ","expr":"krp-ka*(1-ke)","weight":5.0},
+                 {"kind":"EQ","expr":"kvp**2*krp-(1+ke)","weight":5.0},
+                 {"kind":"EQ","expr":"kh-krp*kvp","weight":5.0},
              ]}],
     anchors=[
-        AXLInvariant("periapsis_radius","krp - ka*(1-ke)",1e-3),
-        AXLInvariant("vis_viva","kvp**2*krp - (1+ke)",1e-3),
-        AXLInvariant("ang_momentum","kh - krp*kvp",1e-3),
+        AXLInvariant("periapsis","krp-ka*(1-ke)",1e-3),
+        AXLInvariant("vis_viva","kvp**2*krp-(1+ke)",1e-3),
+        AXLInvariant("ang_mom","kh-krp*kvp",1e-3),
     ],
-    observations={"ka":1.0,"ke":0.5},  # fix a=1, e=0.5 → rp=0.5, vp=√3, h=√3/2
+    observations={"ka":1.0,"ke":0.5},
 ),
-
-# ── STRUCTURAL ENGINEERING ────────────────────────────────────────────
 AXLProblemDef(
     name="VibratingString3",
-    description="3-node string under uniform unit load, fixed endpoints. "
-                "FD equations. Known: s1=s3=1.5, s2=2.0.",
+    description="3-node string, unit load, fixed ends. s1=s3=1.5, s2=2.0.",
     axioms={Axiom.ORDERED,Axiom.SYMMETRIC,Axiom.CONSERVED,Axiom.METRIC},
-    variables=[
-        {"name":"s1","lo":0.0,"hi":5.0},
-        {"name":"s2","lo":0.0,"hi":5.0},
-        {"name":"s3","lo":0.0,"hi":5.0},
-    ],
+    variables=[{"name":"s1","lo":0.0,"hi":5.0},{"name":"s2","lo":0.0,"hi":5.0},
+               {"name":"s3","lo":0.0,"hi":5.0}],
     constraints=[
-        {"kind":"EQ","expr":"-2*s1 + s2 + 1.0","weight":5.0},          # -2s1+s2=-1
-        {"kind":"EQ","expr":"s1 - 2*s2 + s3 + 1.0","weight":5.0},      # s1-2s2+s3=-1
-        {"kind":"EQ","expr":"s2 - 2*s3 + 1.0","weight":5.0},           # s2-2s3=-1
+        {"kind":"EQ","expr":"-2*s1+s2+1.0","weight":5.0},
+        {"kind":"EQ","expr":"s1-2*s2+s3+1.0","weight":5.0},
+        {"kind":"EQ","expr":"s2-2*s3+1.0","weight":5.0},
     ],
     scopes=[{"name":"string","order":0,"vars":["s1","s2","s3"],
              "constraints":[
-                 {"kind":"EQ","expr":"-2*s1 + s2 + 1.0","weight":5.0},
-                 {"kind":"EQ","expr":"s1 - 2*s2 + s3 + 1.0","weight":5.0},
-                 {"kind":"EQ","expr":"s2 - 2*s3 + 1.0","weight":5.0},
+                 {"kind":"EQ","expr":"-2*s1+s2+1.0","weight":5.0},
+                 {"kind":"EQ","expr":"s1-2*s2+s3+1.0","weight":5.0},
+                 {"kind":"EQ","expr":"s2-2*s3+1.0","weight":5.0},
              ]}],
     anchors=[
         AXLInvariant("node1","-2*s1+s2+1.0",1e-3),
         AXLInvariant("node2","s1-2*s2+s3+1.0",1e-3),
         AXLInvariant("node3","s2-2*s3+1.0",1e-3),
-        AXLInvariant("symmetry","s1-s3",1e-3),    # s1=s3 by symmetry
+        AXLInvariant("symmetry","s1-s3",1e-3),
     ],
-    # Known: s1=s3=1.5, s2=2.0
 ),
-
-# ── SIGNAL PROCESSING ─────────────────────────────────────────────────
 AXLProblemDef(
     name="SignalRecovery4",
-    description="Compressed sensing: A*x=b, find sparse x. "
-                "A=[[1,1,0,0],[1,0,1,0],[0,1,0,1]], b=[3,1,4]. "
-                "Sparse solution: x=[1,2,0,2] (3-sparse, r3=0).",
+    description="Compressed sensing: Ax=b, sparse x=[1,2,0,2].",
     axioms={Axiom.CONSERVED,Axiom.PARSIMONY,Axiom.METRIC,Axiom.INJECTIVE},
-    variables=[
-        {"name":"r1","lo":0.0,"hi":5.0},
-        {"name":"r2","lo":0.0,"hi":5.0},
-        {"name":"r3","lo":0.0,"hi":5.0},
-        {"name":"r4","lo":0.0,"hi":5.0},
-    ],
+    variables=[{"name":"r1","lo":0.0,"hi":5.0},{"name":"r2","lo":0.0,"hi":5.0},
+               {"name":"r3","lo":0.0,"hi":5.0},{"name":"r4","lo":0.0,"hi":5.0}],
     constraints=[
-        {"kind":"EQ","expr":"r1 + r2 - 3.0","weight":5.0},
-        {"kind":"EQ","expr":"r1 + r3 - 1.0","weight":5.0},
-        {"kind":"EQ","expr":"r2 + r4 - 4.0","weight":5.0},
+        {"kind":"EQ","expr":"r1+r2-3.0","weight":5.0},
+        {"kind":"EQ","expr":"r1+r3-1.0","weight":5.0},
+        {"kind":"EQ","expr":"r2+r4-4.0","weight":5.0},
     ],
     scopes=[{"name":"signal","order":0,"vars":["r1","r2","r3","r4"],
              "constraints":[
@@ -1578,24 +1803,15 @@ AXLProblemDef(
         AXLInvariant("meas2","r1+r3-1.0",1e-3),
         AXLInvariant("meas3","r2+r4-4.0",1e-3),
     ],
-    # Known sparse: r1=1, r2=2, r3=0, r4=2
 ),
-
-# ── ROBOTICS ──────────────────────────────────────────────────��──────
 AXLProblemDef(
     name="RobotArm2D",
-    description="2-link planar arm, L1=L2=1, target=(1.2, 0.8). "
-                "Find angles: t1≈-0.177rad, t2≈1.531rad. (Trig constraints.)",
+    description="2-link arm L1=L2=1, target=(1.2, 0.8). Find joint angles.",
     axioms={Axiom.CONTINUOUS,Axiom.METRIC,Axiom.SYMMETRIC,Axiom.QUADRATIC},
-    variables=[
-        {"name":"t1","lo":-3.15,"hi":3.15},   # joint 1 angle
-        {"name":"t2","lo":-3.15,"hi":3.15},   # joint 2 angle
-    ],
+    variables=[{"name":"t1","lo":-3.15,"hi":3.15},{"name":"t2","lo":-3.15,"hi":3.15}],
     constraints=[
-        # End-effector x = cos(t1) + cos(t1+t2) = 1.2
-        {"kind":"EQ","expr":"cos(t1) + cos(t1+t2) - 1.2","weight":5.0},
-        # End-effector y = sin(t1) + sin(t1+t2) = 0.8
-        {"kind":"EQ","expr":"sin(t1) + sin(t1+t2) - 0.8","weight":5.0},
+        {"kind":"EQ","expr":"cos(t1)+cos(t1+t2)-1.2","weight":5.0},
+        {"kind":"EQ","expr":"sin(t1)+sin(t1+t2)-0.8","weight":5.0},
     ],
     scopes=[{"name":"kinematics","order":0,"vars":["t1","t2"],
              "constraints":[
@@ -1605,25 +1821,18 @@ AXLProblemDef(
     anchors=[
         AXLInvariant("reach_x","cos(t1)+cos(t1+t2)-1.2",1e-2),
         AXLInvariant("reach_y","sin(t1)+sin(t1+t2)-0.8",1e-2),
-        # Reachability: r²=1.44+0.64=2.08 ≤ (L1+L2)²=4 ✓ → cos(t2)≈0.04
-        AXLInvariant("elbow_check","cos(t2) - 0.04",0.05),
+        AXLInvariant("elbow_check","cos(t2)-0.04",0.05),
     ],
-    # Known: t2=arccos(0.04)≈1.531, t1≈-0.177 (elbow-up config)
 ),
-
-# ── MATHEMATICS (from v13.0) ─────────────────────────────────────────
 AXLProblemDef(
     name="NormManifold4D",
-    description="4 vars on unit sphere, zero sum, x1 observed at 0.5. "
-                "Multiple solutions exist on the great circle.",
+    description="4 vars on unit sphere, zero sum, x1 observed at 0.5.",
     axioms={Axiom.CONTINUOUS,Axiom.QUADRATIC,Axiom.CONSERVED,Axiom.METRIC,Axiom.SYMMETRIC},
-    variables=[
-        {"name":"x1","lo":-1.0,"hi":1.0},{"name":"x2","lo":-1.0,"hi":1.0},
-        {"name":"x3","lo":-1.0,"hi":1.0},{"name":"x4","lo":-1.0,"hi":1.0},
-    ],
+    variables=[{"name":"x1","lo":-1.0,"hi":1.0},{"name":"x2","lo":-1.0,"hi":1.0},
+               {"name":"x3","lo":-1.0,"hi":1.0},{"name":"x4","lo":-1.0,"hi":1.0}],
     constraints=[
-        {"kind":"CONSERVE","expr":"x1**2 + x2**2 + x3**2 + x4**2 - 1.0"},
-        {"kind":"EQ","expr":"x1 + x2 + x3 + x4","weight":2.0},
+        {"kind":"CONSERVE","expr":"x1**2+x2**2+x3**2+x4**2-1.0"},
+        {"kind":"EQ","expr":"x1+x2+x3+x4","weight":2.0},
     ],
     scopes=[{"name":"sphere","order":0,"vars":["x1","x2","x3","x4"],
              "constraints":[{"kind":"EQ","expr":"x1**2+x2**2+x3**2+x4**2-1.0","weight":5.0}]}],
@@ -1636,8 +1845,7 @@ AXLProblemDef(
 ),
 AXLProblemDef(
     name="BilinearChain6",
-    description="6-var ordered chain. t1*t2=0.5, t3*t4=2.0, t5*t6=4.5, sum=9. "
-                "Known: (0.5,1.0,1.0,2.0,1.5,3.0).",
+    description="6-var ordered chain. Products 0.5, 2.0, 4.5. Sum=9.",
     axioms={Axiom.DISCRETE,Axiom.ORDERED,Axiom.BILINEAR,Axiom.CONSERVED,Axiom.NETWORK},
     variables=[{"name":f"t{i}","lo":0.0,"hi":3.0} for i in range(1,7)],
     constraints=[
@@ -1662,21 +1870,17 @@ AXLProblemDef(
 ),
 AXLProblemDef(
     name="PhaseCollider",
-    description="2-particle symmetric collision: conservation + phase branch. "
-                "p1 at r=0.5 or r=1.0.",
+    description="2-particle collision: conservation + phase branch.",
     axioms={Axiom.DISCRETE,Axiom.MUTABLE,Axiom.SYMMETRIC,Axiom.NETWORK,Axiom.CONSERVED},
-    variables=[
-        {"name":"p1x","lo":-2.0,"hi":2.0},{"name":"p2x","lo":-2.0,"hi":2.0},
-        {"name":"p1y","lo":-2.0,"hi":2.0},{"name":"p2y","lo":-2.0,"hi":2.0},
-    ],
+    variables=[{"name":"p1x","lo":-2.0,"hi":2.0},{"name":"p2x","lo":-2.0,"hi":2.0},
+               {"name":"p1y","lo":-2.0,"hi":2.0},{"name":"p2y","lo":-2.0,"hi":2.0}],
     constraints=[
         {"kind":"CONSERVE","expr":"p1x+p2x"},{"kind":"CONSERVE","expr":"p1y+p2y"},
     ],
     scopes=[{"name":"phase","order":0,"vars":["p1x","p2x","p1y","p2y"],
              "constraints":[
                  {"kind":"BRANCH","name":"phase_select","options":[
-                     "p1x**2+p1y**2-0.25","p1x**2+p1y**2-1.0",
-                 ]},
+                     "p1x**2+p1y**2-0.25","p1x**2+p1y**2-1.0"]},
                  {"kind":"EQ","expr":"p1x+p2x","weight":3.0},
                  {"kind":"EQ","expr":"p1y+p2y","weight":3.0},
              ]}],
@@ -1688,14 +1892,10 @@ AXLProblemDef(
 ),
 AXLProblemDef(
     name="MetricPacking3D",
-    description="3 vars packed with min separation, centred at 0, norm²=6. "
-                "Known: a=-√3, b=0, c=√3.",
+    description="3 vars: centred, norm²=6, min separation. a=-√3, b=0, c=√3.",
     axioms={Axiom.CONTINUOUS,Axiom.METRIC,Axiom.INJECTIVE,Axiom.CONSERVED,Axiom.SYMMETRIC},
-    variables=[
-        {"name":"a","lo":-3.0,"hi":3.0},
-        {"name":"b","lo":-3.0,"hi":3.0},
-        {"name":"c","lo":-3.0,"hi":3.0},
-    ],
+    variables=[{"name":"a","lo":-3.0,"hi":3.0},{"name":"b","lo":-3.0,"hi":3.0},
+               {"name":"c","lo":-3.0,"hi":3.0}],
     constraints=[
         {"kind":"CONSERVE","expr":"a+b+c"},
         {"kind":"GEQ","expr":"(a-b)**2-1.0","weight":2.0},
@@ -1707,12 +1907,11 @@ AXLProblemDef(
     anchors=[
         AXLInvariant("centred","a+b+c",1e-3),
         AXLInvariant("norm_6","a**2+b**2+c**2-6.0",0.05),
-        AXLInvariant("sep_ab","(a-b)**2-1.0",0.0,"geq"),   # (a-b)²≥1
-        AXLInvariant("sep_bc","(b-c)**2-1.0",0.0,"geq"),   # (b-c)²≥1
+        AXLInvariant("sep_ab","(a-b)**2-1.0",0.0,"geq"),
+        AXLInvariant("sep_bc","(b-c)**2-1.0",0.0,"geq"),
     ],
 ),
-
-]  # end AXL_PROBLEMS
+]
 
 def build_base_problem(axl_def:AXLProblemDef) -> Problem:
     psl_text=AXL_COMPILER.compile(axl_def)
@@ -1723,16 +1922,18 @@ def build_base_problem(axl_def:AXLProblemDef) -> Problem:
                    scope_order=ep.scope_order,annotations=ep.annotations)
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 14: GLOBAL STATE + ROUND-ROBIN RUNNER
+# SECTION 16: GLOBAL STATE + ROUND-ROBIN RUNNER
 # ══════════════════════════════════════════════════════════════════════
 STATE_LOCK   = threading.Lock()
 RUN_LOG:     List[Dict] = []
 PROBLEM_STATS: Dict[str,Dict] = {p.name: {
     "runs":0,"solved":0,"total_ce":0.0,"total_rays":0,
-    "best_ce":float('inf'),"best_ray":"—","last_binding":{}
+    "best_ce":float('inf'),"best_ray":"—","best_ray_type":"—",
+    "type_stats": {t:{"tried":0,"survived":0} for t in
+                   [RAY_SEED,RAY_BRANCH,RAY_TENSION,RAY_SCOUT,RAY_RECOMBINE,RAY_INVERT]},
 } for p in AXL_PROBLEMS}
-POOL = ThreadPoolExecutor(max_workers=1)  # sequential: one tracer at a time
-_PROBLEM_IDX = 0
+POOL       = ThreadPoolExecutor(max_workers=1)
+_PROB_IDX  = 0
 
 def _run_problem(axl_def:AXLProblemDef):
     try:
@@ -1743,6 +1944,17 @@ def _run_problem(axl_def:AXLProblemDef):
         survived=[t for t in traces if t.survived]
         failed  =[t for t in traces if not t.survived]
         best_t  =min(survived,key=lambda t:t.ce_after,default=None)
+
+        # Per-type breakdown
+        type_counts:Dict[str,Dict]={t:{"tried":0,"survived":0}
+                                    for t in [RAY_SEED,RAY_BRANCH,RAY_TENSION,
+                                               RAY_SCOUT,RAY_RECOMBINE,RAY_INVERT]}
+        for t in traces:
+            rt=t.ray_type
+            if rt in type_counts:
+                type_counts[rt]["tried"]+=1
+                if t.survived: type_counts[rt]["survived"]+=1
+
         record={
             "problem":axl_def.name,
             "description":axl_def.description[:60],
@@ -1754,7 +1966,8 @@ def _run_problem(axl_def:AXLProblemDef):
             "binding":{k:round(v,5) for k,v in binding.items()},
             "observations":axl_def.observations,
             "traces":[{
-                "round":t.round_idx,"ray":t.ray_name,"depth":t.depth,"parent":t.parent_id,
+                "round":t.round_idx,"ray":t.ray_name,"ray_type":t.ray_type,
+                "depth":t.depth,"parent":t.parent_id,
                 "ce_before":round(t.ce_before,5),"ce":round(t.ce_after,5),
                 "g1_ce":round(t.verify.gate1_ce,5) if t.verify else None,
                 "g1":t.verify.gate1_pass if t.verify else False,
@@ -1762,9 +1975,11 @@ def _run_problem(axl_def:AXLProblemDef):
                 "g2_detail":{k:(round(v,6),ok) for k,(v,ok) in t.verify.gate2_results.items()} if t.verify else {},
                 "survived":t.survived,"ms":t.elapsed_ms,
             } for t in traces],
+            "type_counts":type_counts,
             "survived_count":len(survived),
             "failed_count":len(failed),
             "best_ray":best_t.ray_name if best_t else "—",
+            "best_ray_type":best_t.ray_type if best_t else "—",
             "total_fired":len(traces),
         }
         with STATE_LOCK:
@@ -1772,22 +1987,23 @@ def _run_problem(axl_def:AXLProblemDef):
             if len(RUN_LOG)>60: RUN_LOG.pop(0)
             ps=PROBLEM_STATS[axl_def.name]
             ps["runs"]+=1; ps["total_rays"]+=len(traces); ps["total_ce"]+=ce
-            if len(survived)>0 and ce<SOLVE_THRESHOLD:
-                ps["solved"]+=1
+            if len(survived)>0 and ce<SOLVE_THRESHOLD: ps["solved"]+=1
             if ce<ps["best_ce"]:
                 ps["best_ce"]=ce
                 ps["best_ray"]=best_t.ray_name if best_t else "—"
-                ps["last_binding"]={k:round(v,5) for k,v in binding.items()}
+                ps["best_ray_type"]=best_t.ray_type if best_t else "—"
+            for rt,counts in type_counts.items():
+                ps["type_stats"][rt]["tried"]+=counts["tried"]
+                ps["type_stats"][rt]["survived"]+=counts["survived"]
     except Exception as e:
         import traceback; traceback.print_exc()
         print(f"[RUN ERROR] {axl_def.name}: {e}")
 
 async def run_loop():
-    global _PROBLEM_IDX
+    global _PROB_IDX
     loop=asyncio.get_event_loop()
     while True:
-        prob=AXL_PROBLEMS[_PROBLEM_IDX % len(AXL_PROBLEMS)]
-        _PROBLEM_IDX+=1
+        prob=AXL_PROBLEMS[_PROB_IDX % len(AXL_PROBLEMS)]; _PROB_IDX+=1
         await loop.run_in_executor(POOL,_run_problem,prob)
         await asyncio.sleep(0.2)
 
@@ -1798,60 +2014,49 @@ async def lifespan(app):
     POOL.shutdown(wait=False)
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 15: FASTAPI + DASHBOARD
+# SECTION 17: FASTAPI + DASHBOARD
 # ══════════════════════════════════════════════════════════════════════
-app=FastAPI(title="Practicality 14.0",lifespan=lifespan)
+app=FastAPI(title="Practicality 15.0",lifespan=lifespan)
+
+def _type_badge(rt:str, count:int, survived:int) -> str:
+    icon=RAY_ICONS.get(rt,"·")
+    rate=f"{round(survived/count*100)}%" if count else "—"
+    c="#4CAF50" if survived>0 else "#333"
+    return (f"<span style='font-size:0.75em;margin-right:8px'>"
+            f"{icon}<span style='color:#555'>{rt[:3]}</span> "
+            f"<span style='color:{c}'>{rate}</span></span>")
 
 def _perf_table() -> str:
     rows=""
     for prob in AXL_PROBLEMS:
         ps=PROBLEM_STATS[prob.name]
         if ps["runs"]==0:
-            rows+=f"<tr><td style='color:#555'>{PROBLEM_META.get(prob.name,{}).get('icon','·')}</td><td style='color:#555'>{PROBLEM_META.get(prob.name,{}).get('domain','')}</td><td style='color:#444'>{prob.name}</td><td style='color:#333'>{PROBLEM_META.get(prob.name,{}).get('difficulty','')}</td><td colspan='6' style='color:#222'>warming up…</td></tr>"
+            rows+=f"<tr><td>{PROBLEM_META.get(prob.name,{}).get('icon','·')}</td><td style='color:#444'>{prob.name}</td><td colspan='8' style='color:#222'>—</td></tr>"
             continue
         runs=ps["runs"]; rate=round(ps["solved"]/runs*100)
         avg_ce=round(ps["total_ce"]/runs,5)
-        avg_rays=round(ps["total_rays"]/runs,1)
-        rate_col="#4CAF50" if rate>=50 else ("#FF9800" if rate>=20 else "#EF5350")
+        rc=ps["type_stats"]
+        type_cells="".join(
+            f"<td style='color:{'#4CAF50' if rc[t]['survived']>0 else '#333'};font-size:0.75em'>"
+            f"{RAY_ICONS.get(t,'·')}{round(rc[t]['survived']/rc[t]['tried']*100) if rc[t]['tried'] else 0}%</td>"
+            for t in [RAY_SEED,RAY_TENSION,RAY_SCOUT,RAY_RECOMBINE,RAY_INVERT,RAY_BRANCH])
         dom=PROBLEM_META.get(prob.name,{})
-        axiom_str=", ".join(sorted(AXIOM_ABBR.get(a,a[:3]) for a in prob.axioms)[:4])
-        best_ray=ps["best_ray"][:25] if ps["best_ray"]!="—" else "—"
-        best_ce_str=f"{ps['best_ce']:.5f}" if ps["best_ce"]<float('inf') else "—"
+        best_t_icon=RAY_ICONS.get(ps["best_ray_type"],"·")
+        rate_col="#4CAF50" if rate>=50 else ("#FF9800" if rate>=20 else "#EF5350")
         rows+=(f"<tr>"
                f"<td style='color:#aaa'>{dom.get('icon','·')}</td>"
-               f"<td style='color:#5C6BC0;font-size:0.8em'>{dom.get('domain','')}</td>"
                f"<td style='color:#FF9800'>{prob.name}</td>"
+               f"<td style='color:#5C6BC0;font-size:0.8em'>{dom.get('domain','')}</td>"
                f"<td style='color:#555;font-size:0.75em'>{dom.get('difficulty','')}</td>"
-               f"<td style='color:#888;font-size:0.75em'>{axiom_str}</td>"
                f"<td style='color:#aaa'>{runs}</td>"
                f"<td style='color:{rate_col};font-weight:700'>{rate}%</td>"
                f"<td style='color:#26C6DA'>{avg_ce}</td>"
-               f"<td style='color:#26C6DA;font-size:0.8em'>{best_ce_str}</td>"
-               f"<td style='color:#888'>{avg_rays:.0f}</td>"
-               f"<td style='color:#4CAF50;font-size:0.75em'>{best_ray}</td>"
+               f"<td style='color:#26C6DA;font-size:0.8em'>{ps['best_ce']:.5f}</td>"
+               f"{type_cells}"
+               f"<td style='color:#4CAF50;font-size:0.75em'>{best_t_icon} {ps['best_ray'][:22]}</td>"
                f"</tr>")
     return rows
 
-def _axiom_table(log) -> str:
-    axiom_stats=defaultdict(lambda:{"tried":0,"survived":0,"total_ce":0.0,"as_seed":0})
-    for r in log:
-        for t in r.get("traces",[]):
-            parts=t["ray"].split("→")
-            for pos,ax in enumerate(parts):
-                if not ax: continue
-                axiom_stats[ax]["tried"]+=1; axiom_stats[ax]["total_ce"]+=t["ce"]
-                if t["survived"]: axiom_stats[ax]["survived"]+=1
-                if pos==0: axiom_stats[ax]["as_seed"]+=1
-    return "".join(
-        f"<tr><td style='color:#FF9800'>{ax}</td>"
-        f"<td style='color:#aaa'>{s['tried']}</td>"
-        f"<td style='color:#26C6DA'>{s['as_seed']}</td>"
-        f"<td style='color:#4CAF50'>{s['survived']}</td>"
-        f"<td style='color:#26C6DA'>{round(s['total_ce']/s['tried'],5) if s['tried'] else 0}</td>"
-        f"<td style='color:{'#4CAF50' if s['survived']>0 else '#333'}'>{round(s['survived']/s['tried']*100):.0f}%</td></tr>"
-        for ax,s in sorted(axiom_stats.items(),key=lambda x:-x[1]["survived"])
-    ) or "<tr><td colspan='6' style='color:#222'>—</td></tr>"
-
 def _render_collapse(record:Dict) -> str:
     b=record["binding"]; traces=record["traces"]
     survived=[t for t in traces if t["survived"]]
@@ -1861,11 +2066,13 @@ def _render_collapse(record:Dict) -> str:
     ce=record["ce"]; solved=record["solved"]
     ce_color="#4CAF50" if solved else ("#FF9800" if ce<0.5 else "#EF5350")
     status="✓ SOLVED" if solved else ("~ PARTIAL" if ce<0.5 else "✗ UNSOLVED")
+
     binding_rows="".join(
         f"<tr><td style='color:#888'>{v}</td>"
         f"<td style='color:#26C6DA;font-weight:700'>{val:+.5f}</td>"
         f"<td style='color:#4CAF50;font-size:0.7em'>{'[OBS]' if v in obs_vars else ''}</td></tr>"
         for v,val in b.items())
+
     inv_rows=""
     if best and best.get("g2_detail"):
         for inv,(val,ok) in best["g2_detail"].items():
@@ -1873,32 +2080,41 @@ def _render_collapse(record:Dict) -> str:
             inv_rows+=(f"<tr><td style='color:{c}'>{'✓' if ok else '✗'}</td>"
                        f"<td style='color:#888;font-size:0.8em'>{inv}</td>"
                        f"<td style='color:{c};font-size:0.8em'>{val:.5f}</td></tr>")
+
+    # Type breakdown badges
+    tc=record.get("type_counts",{})
+    type_summary="".join(_type_badge(rt,tc.get(rt,{}).get("tried",0),tc.get(rt,{}).get("survived",0))
+                         for rt in [RAY_SEED,RAY_TENSION,RAY_SCOUT,RAY_RECOMBINE,RAY_INVERT,RAY_BRANCH])
+
     def span(t):
+        icon=RAY_ICONS.get(t.get("ray_type",RAY_SEED),"·")
         depth_indent="·"*min(t.get("depth",0),5)
         c="#4CAF50" if t["survived"] else ("#555" if t.get("depth",0)>0 else "#333")
         star=" ◀" if t["survived"] else ""
         delta=t["ce"]-t.get("ce_before",t["ce"])
-        return (f"<div style='color:{c};font-size:0.72em;margin-bottom:1px'>"
-                f"{depth_indent}[{t['round']}|d{t.get('depth',0)}] "
+        return (f"<div style='color:{c};font-size:0.71em;margin-bottom:1px'>"
+                f"{icon}{depth_indent}[{t['round']}|d{t.get('depth',0)}] "
                 f"<span style='color:#FF9800'>{t['ray']}</span> "
                 f"CE={t['ce']:.4f} <span style='color:#444'>{delta:+.4f}</span>"
                 f"<span style='color:#4CAF50;font-weight:700'>{star}</span></div>")
-    trail="".join(span(t) for t in traces[:25])
+
+    trail="".join(span(t) for t in traces[:28])
     return f"""
-<div style='border:1px solid #181818;border-radius:6px;margin-bottom:14px;overflow:hidden'>
-  <div style='background:#0d0d0d;padding:7px 12px;border-bottom:1px solid #1a1a1a;display:flex;align-items:center;gap:14px'>
+<div style='border:1px solid #181818;border-radius:6px;margin-bottom:12px;overflow:hidden'>
+  <div style='background:#0d0d0d;padding:7px 12px;border-bottom:1px solid #1a1a1a;display:flex;align-items:center;gap:14px;flex-wrap:wrap'>
     <span style='color:{ce_color};font-weight:700'>{status}</span>
     <span style='color:#555;font-size:0.8em'>{record.get("icon","·")} {record["problem"]}</span>
     <span style='color:#5C6BC0;font-size:0.75em'>{record.get("domain","")}</span>
     <span style='color:#333;font-size:0.75em'>CE={ce:.6f}</span>
     <span style='color:#26C6DA;font-size:0.72em'>{record["survived_count"]} survived / {record["total_fired"]} fired</span>
+    <span style='margin-left:auto'>{type_summary}</span>
   </div>
   <div style='display:flex'>
-    <div style='flex:0 0 160px;padding:8px 10px;border-right:1px solid #181818'>
+    <div style='flex:0 0 155px;padding:8px 10px;border-right:1px solid #181818'>
       <div style='color:#333;font-size:0.65em;margin-bottom:4px'>BINDING</div>
       <table style='border-collapse:collapse;width:100%'>{binding_rows}</table>
     </div>
-    <div style='flex:0 0 210px;padding:8px 10px;border-right:1px solid #181818'>
+    <div style='flex:0 0 205px;padding:8px 10px;border-right:1px solid #181818'>
       <div style='color:#333;font-size:0.65em;margin-bottom:4px'>GATE 2 INVARIANTS</div>
       <table style='border-collapse:collapse;width:100%'>
         {inv_rows or "<tr><td colspan='3' style='color:#222'>—</td></tr>"}
@@ -1906,7 +2122,7 @@ def _render_collapse(record:Dict) -> str:
     </div>
     <div style='flex:1;padding:8px 10px;overflow-y:auto;max-height:200px'>
       <div style='color:#333;font-size:0.65em;margin-bottom:4px'>
-        RAY TREE — best: <span style='color:#FF9800'>{record["best_ray"]}</span>
+        RAY TREE — best: <span style='color:#FF9800'>{RAY_ICONS.get(record["best_ray_type"],"·")} {record["best_ray"]}</span>
       </div>
       {trail}
     </div>
@@ -1917,21 +2133,43 @@ def _render_collapse(record:Dict) -> str:
 async def dashboard():
     with STATE_LOCK:
         log=list(reversed(RUN_LOG[-8:]))
-        stats_snapshot=dict(PROBLEM_STATS)
-    total_runs=sum(s["runs"] for s in stats_snapshot.values())
-    total_solved=sum(s["solved"] for s in stats_snapshot.values())
-    domains_active=len([p for p in AXL_PROBLEMS if stats_snapshot[p.name]["runs"]>0])
-    avg_ce=(sum(s["total_ce"] for s in stats_snapshot.values())/max(1,total_runs))
+        stats_snap=dict(PROBLEM_STATS)
+    total_runs=sum(s["runs"] for s in stats_snap.values())
+    total_solved=sum(s["solved"] for s in stats_snap.values())
+    avg_ce=(sum(s["total_ce"] for s in stats_snap.values())/max(1,total_runs))
+    domains_active=len([p for p in AXL_PROBLEMS if stats_snap[p.name]["runs"]>0])
+
+    # Global creative type efficacy
+    global_type_stats:Dict[str,Dict]={t:{"tried":0,"survived":0}
+                                       for t in [RAY_SEED,RAY_BRANCH,RAY_TENSION,
+                                                  RAY_SCOUT,RAY_RECOMBINE,RAY_INVERT]}
+    for ps in stats_snap.values():
+        for rt,counts in ps["type_stats"].items():
+            global_type_stats[rt]["tried"]+=counts["tried"]
+            global_type_stats[rt]["survived"]+=counts["survived"]
+
+    type_rows="".join(
+        f"<tr>"
+        f"<td>{RAY_ICONS.get(rt,'·')}</td>"
+        f"<td style='color:#FF9800'>{rt}</td>"
+        f"<td style='color:#aaa'>{s['tried']}</td>"
+        f"<td style='color:#4CAF50'>{s['survived']}</td>"
+        f"<td style='color:#EF5350'>{s['tried']-s['survived']}</td>"
+        f"<td style='color:{'#4CAF50' if s['survived']>0 else '#333'};font-weight:700'>"
+        f"{round(s['survived']/s['tried']*100) if s['tried'] else 0}%</td>"
+        f"<td style='color:#555;font-size:0.8em'>"
+        f"{'Greedy depth-first from single axiom' if rt==RAY_SEED else 'Earned child of tree ray' if rt==RAY_BRANCH else 'Mediated contradiction [A→B→C]' if rt==RAY_TENSION else 'Random length 3-8 cartographer' if rt==RAY_SCOUT else 'Genetic crossover of two sequences' if rt==RAY_RECOMBINE else 'Reversed successful sequence'}"
+        f"</td></tr>"
+        for rt,s in global_type_stats.items())
 
     perf_rows=_perf_table()
-    ax_rows=_axiom_table(log)
     collapses="".join(_render_collapse(r) for r in log) if log else \
         "<div style='color:#222;padding:16px'>Cycling through 14 problems…</div>"
 
-    return f"""<!DOCTYPE html><html><head><title>Practicality 14.0</title>
+    return f"""<!DOCTYPE html><html><head><title>Practicality 15.0</title>
 <meta http-equiv="refresh" content="5">
 <style>
-  body{{background:#090909;color:#e0e0e0;font-family:monospace;padding:18px;max-width:1600px}}
+  body{{background:#090909;color:#e0e0e0;font-family:monospace;padding:18px;max-width:1700px}}
   h1{{color:#26C6DA;border-bottom:1px solid #1a1a1a;padding-bottom:5px;font-size:1.1em;margin-bottom:4px}}
   h3{{color:#252525;margin-top:18px;font-size:0.82em;letter-spacing:2px;text-transform:uppercase}}
   table{{width:100%;border-collapse:collapse;margin-bottom:8px}}
@@ -1939,10 +2177,10 @@ async def dashboard():
   th{{color:#252525;font-size:0.70em}}
   .badge{{display:inline-block;padding:2px 9px;border-radius:3px;background:#0e0e0e;margin:2px;font-size:0.75em;border:1px solid #1a1a1a}}
 </style></head><body>
-<h1>⚗ Practicality 14.0 — 14 Domains · 27 Axioms · Sequence Rays</h1>
+<h1>⚗ Practicality 15.0 — Creative Sequence Wisdom</h1>
 <div style='color:#2a2a2a;font-size:0.72em;margin-bottom:10px'>
-  Real-world AXL problems → PSL base → Sequence rays (ordered axiom chains) →
-  Baton protocol → Earn extension by CE reduction → Contradiction at distance
+  🌱 Seeds + ⚡ Tension (mediated contradictions) + 🔭 Scouts (random) →
+  🧬 Recombine + 🔄 Invert → 🌿 Branch (resonance-guided) → Verify
 </div>
 <div style='margin-bottom:14px'>
   <span class='badge' style='color:#aaa'>Total Runs: {total_runs}</span>
@@ -1952,20 +2190,21 @@ async def dashboard():
   <span class='badge' style='color:#5C6BC0'>Axioms: {len(ALL_AXIOMS)}</span>
 </div>
 
-<h3>Multi-Domain Performance Table</h3>
+<h3>Creative Ray Type Efficacy</h3>
 <table>
-  <tr>
-    <th></th><th>Domain</th><th>Problem</th><th>Difficulty</th><th>Axiom Tags</th>
-    <th>Runs</th><th>Rate%</th><th>Avg CE</th><th>Best CE</th>
-    <th>Avg Rays</th><th>Best Sequence</th>
-  </tr>
-  {perf_rows}
+  <tr><th></th><th>Type</th><th>Tried</th><th>Survived</th><th>Failed</th><th>Rate</th><th>Mechanism</th></tr>
+  {type_rows}
 </table>
 
-<h3>Axiom Efficacy — Cross-Domain</h3>
+<h3>Multi-Domain Performance</h3>
 <table>
-  <tr><th>Axiom</th><th>In-Seq</th><th>As Seed</th><th>Survived</th><th>Avg CE</th><th>Rate</th></tr>
-  {ax_rows}
+  <tr>
+    <th></th><th>Problem</th><th>Domain</th><th>Diff</th><th>Runs</th><th>Rate%</th>
+    <th>Avg CE</th><th>Best CE</th>
+    <th>🌱</th><th>⚡</th><th>🔭</th><th>🧬</th><th>🔄</th><th>🌿</th>
+    <th>Best Sequence</th>
+  </tr>
+  {perf_rows}
 </table>
 
 <h3>Recent Runs</h3>