Update app.py

app.py

@@ -1,4 +1,3 @@
-
 #!/usr/bin/env python3
 """
 PRACTICALITY SYSTEM 25.0 — PROXY DECOMPOSITION + HYPOTHESIS TESTING ENGINE
@@ -35,18 +34,13 @@ NEW IN 25.0:
         • LWE lattice crypto short-vector feasibility
         • Quantum surface code syndrome consistency
 
-ALL 24.11 FIXES MAINTAINED:
+ALL FIXES MAINTAINED:
+  - Differential UI Polling via gr.skip() (Fixes text selection destruction)
+  - Controlled Hypothesis Flag (Prevents LLM from rewriting rigid templates)
+  - Ray Extinction / Resurrection Protocol (Prevents premature <500 stop)
   - Squeeze Bug Fix (.view(B,-1).sum(dim=1))
   - Two Brains Sync (Gate 1 via PyTorch L2)
   - Anti-LaTeX Shield (^ → **)
-  - Undefined Observation Shield
-  - Undefined Symbol Shield
-  - Extended PT Map Shield
-  - Relational Hallucination Shield
-  - Markov Blanket Masking
-  - UCB1 Bandit Seeder
-  - Zero-Shot Early Exit
-  - Javascript Auto-Clicker Polling (Fixes Queue Starvation / Page Reload Freezes)
 """
 
 import os, time, random, math, threading, warnings, json, textwrap, itertools
@@ -97,7 +91,7 @@ PROJECTION_CACHE: Dict   = {}
 MAX_RAYS_PER_ATTEMPT     = 24576 * 10
 RAY_BATCH_SIZE           = 24576
 TEMPLATE_BATCH_SIZE      = 1024
-CE_EARN_RATIO            = 0.90
+CE_EARN_RATIO            = 0.98     # Relaxed to allow 2% improvements to survive
 SCOUT_CE_THRESHOLD       = 0.5
 BRANCH_WIDTH             = 12
 BRANCH_WIDTH_SYSTEMIC    = 16
@@ -125,10 +119,7 @@ GLOBAL_SOLVE_STATE = {
     "best_ray": "—", "recent_traces": deque(maxlen=25), "high_level_logs": [],
     "answer": "", "sketch_summary": "", "template_count": 0,
     "template_best_ce": float('inf'), "sympy_derivation": [],
-    # NEW 25.0
-    "proxy_n_components": 0,
-    "proxy_component_isos": [],
-    "proxy_composed_ce": float('inf'),
+    "proxy_n_components": 0, "proxy_component_isos": [], "proxy_composed_ce": float('inf'),
     "fingerprint_summary": "",
 }
 
@@ -717,15 +708,14 @@ def templates_to_hypotheses(templates,problem,init_binding):
 _ALL_AXIOMS_PLACEHOLDER:List[str]=[]
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 6.5: PROXY DECOMPOSITION ENGINE (NEW 25.0)
+# SECTION 6.5: PROXY DECOMPOSITION ENGINE
 # ══════════════════════════════════════════════════════════════════════
 
 @dataclass
 class ProxyComponentResult:
-    """Result of solving one Markov component."""
     component_id:     int
     variables:        List[str]
-    interface_vars:   Set[str]     # variables shared with other components
+    interface_vars:   Set[str]
     binding:          Dict[str,float]
     isomorphism:      str
     ce:               float
@@ -733,69 +723,39 @@ class ProxyComponentResult:
     n_constraints:    int
 
 def find_markov_components(problem: Problem) -> List[List[str]]:
-    """
-    Find connected components of the Markov blanket graph via BFS.
-    Returns a list of variable groups — each group is a component.
-    Components with only one variable that have no constraints are skipped.
-    """
     visited = set()
     components = []
     for start_var in problem.variables:
-        if start_var in visited:
-            continue
+        if start_var in visited: continue
         component = []
         queue = deque([start_var])
         while queue:
             v = queue.popleft()
-            if v in visited:
-                continue
+            if v in visited: continue
             visited.add(v)
             component.append(v)
             for neighbor in problem.adjacency_list.get(v, set()):
-                if neighbor not in visited:
-                    queue.append(neighbor)
-        if component:
-            components.append(component)
+                if neighbor not in visited: queue.append(neighbor)
+        if component: components.append(component)
     return components
 
 def find_interface_vars(components: List[List[str]], problem: Problem) -> Dict[int, Set[str]]:
-    """
-    For each component, find variables that also appear in constraints
-    involving variables from OTHER components (interface/boundary variables).
-    """
     interfaces: Dict[int,Set[str]] = {i:set() for i in range(len(components))}
     comp_of_var = {}
     for i, comp in enumerate(components):
-        for v in comp:
-            comp_of_var[v] = i
-
+        for v in comp: comp_of_var[v] = i
     for mc in problem.compiled_constraints:
         comps_touched = set(comp_of_var.get(v, -1) for v in mc.syms_used)
         comps_touched.discard(-1)
         if len(comps_touched) > 1:
             for v in mc.syms_used:
                 c = comp_of_var.get(v, -1)
-                if c >= 0:
-                    interfaces[c].add(v)
+                if c >= 0: interfaces[c].add(v)
     return interfaces
 
-def build_sub_axl_for_component(
-    axl_def: AXLProblemDef,
-    component_vars: List[str],
-    interface_vars: Set[str]
-) -> Tuple[AXLProblemDef, 'Problem']:
-    """
-    Build a stripped-down AXLProblemDef + Problem for a single component.
-    Includes ALL constraints that touch at least one variable in the component
-    (cross-component constraints are kept but won't have missing vars since
-     those missing vars are fixed at their observation/mid-point values).
-    """
+def build_sub_axl_for_component(axl_def: AXLProblemDef, component_vars: List[str], interface_vars: Set[str]) -> Tuple[AXLProblemDef, 'Problem']:
     comp_set = set(component_vars)
-
-    # Variables: only component vars
     sub_vars = [v for v in axl_def.variables if v["name"] in comp_set]
-
-    # Constraints: keep those touching at least one component var
     sub_constraints = []
     for c in axl_def.constraints:
         try:
@@ -803,271 +763,137 @@ def build_sub_axl_for_component(
             parsed = parse_expr(str(c['expr']).replace("^","**"), local_dict=syms_all)
             if any(sp.Symbol(v) in parsed.free_symbols for v in component_vars):
                 sub_constraints.append(c)
-        except:
-            pass
-
-    # Anchors: only those whose variables are in this component
+        except: pass
     sub_anchors = []
     for inv in axl_def.anchors:
-        if inv.syms_used and all(v in comp_set for v in inv.syms_used):
-            sub_anchors.append(inv)
-        elif not inv.syms_used:
-            sub_anchors.append(inv)
-
-    # Observations: only component vars
+        if inv.syms_used and all(v in comp_set for v in inv.syms_used): sub_anchors.append(inv)
+        elif not inv.syms_used: sub_anchors.append(inv)
     sub_obs = {k: v for k, v in axl_def.observations.items() if k in comp_set}
-
     sub_axl = AXLProblemDef(
         name=f"proxy_{axl_def.name[:15]}_{hash(str(sorted(component_vars)))%9999}",
-        description=f"Proxy component: {component_vars[:4]}",
-        axioms=axl_def.axioms,
-        variables=sub_vars,
-        constraints=sub_constraints,
-        scopes=[sc for sc in axl_def.scopes],
-        anchors=sub_anchors,
-        observations=sub_obs,
+        description=f"Proxy component: {component_vars[:4]}", axioms=axl_def.axioms,
+        variables=sub_vars, constraints=sub_constraints, scopes=[sc for sc in axl_def.scopes],
+        anchors=sub_anchors, observations=sub_obs
     )
-
     try:
         sub_prob = build_base_problem(sub_axl)
         return sub_axl, sub_prob
     except Exception as e:
         raise RuntimeError(f"Component build failed: {e}")
 
-def _mini_solve_component(
-    sub_axl: AXLProblemDef,
-    sub_prob: 'Problem',
-    seed_binding: Dict[str,float],
-) -> Tuple[Dict[str,float], float, str]:
-    """
-    Lightweight solve for a proxy component. Uses templates + limited seeds.
-    Does NOT update global dashboard state. Returns (binding, ce, isomorphism).
-    """
-    # MPRT sampling
+def _mini_solve_component(sub_axl: AXLProblemDef, sub_prob: 'Problem', seed_binding: Dict[str,float]) -> Tuple[Dict[str,float], float, str]:
     try:
-        init_b, init_ce = _mprt_sample(
-            sub_prob,
-            {v: IV(*sub_prob.bounds[v]) for v in sub_prob.variables},
-            PROXY_MINI_MPRT_N
-        )
+        init_b, init_ce = _mprt_sample(sub_prob, {v: IV(*sub_prob.bounds[v]) for v in sub_prob.variables}, PROXY_MINI_MPRT_N)
     except:
-        init_b = {v: seed_binding.get(v, (sub_prob.bounds[v][0]+sub_prob.bounds[v][1])/2)
-                  for v in sub_prob.variables}
+        init_b = {v: seed_binding.get(v, (sub_prob.bounds[v][0]+sub_prob.bounds[v][1])/2) for v in sub_prob.variables}
         init_ce = float('inf')
-
-    best_ce   = init_ce
-    best_b    = dict(init_b)
-    best_iso  = "zero_shot"
-
-    # Compile anchors
+    best_ce = init_ce; best_b = dict(init_b); best_iso = "zero_shot"
     for inv in sub_axl.anchors:
         if not inv.compiled_func:
             try: inv.compile(sub_prob.variables)
             except: pass
-
-    # Template pass
     try:
-        sketch   = compute_sketch(sub_prob)
+        sketch = compute_sketch(sub_prob)
         templates = generate_templates(sub_prob, sketch)[:PROXY_MINI_TEMPLATE_CAP]
         if templates:
-            t_hyps   = templates_to_hypotheses(templates, sub_prob, init_b)
+            t_hyps = templates_to_hypotheses(templates, sub_prob, init_b)
             t_results = _batched_deduce_and_evaluate(sub_prob, t_hyps)
             for template, (final_b, final_ce, _, _) in zip(templates, t_results):
                 if final_ce < best_ce:
-                    best_ce = final_ce
-                    best_b  = dict(final_b)
-                    best_iso = f"template:{template.source}"
-                if final_ce < SOLVE_THRESHOLD:
-                    return best_b, best_ce, best_iso
-    except:
-        pass
-
-    # Quick seed pass (bandit not used here — just sketch-ordered seeds)
+                    best_ce = final_ce; best_b = dict(final_b); best_iso = f"template:{template.source}"
+                if final_ce < SOLVE_THRESHOLD: return best_b, best_ce, best_iso
+    except: pass
     try:
-        sketch   = compute_sketch(sub_prob)
+        sketch = compute_sketch(sub_prob)
         affinities = sketch.axiom_affinities
-        seeds_scored = sorted(
-            [(affinities.get(a, 1.0), i, a) for i, a in enumerate(ALL_AXIOMS)],
-            key=lambda x: -x[0]
-        )
-        seed_rays = [AxiomRay([a], f"PS{i}", "seed", ce_prior=best_ce)
-                     for _, i, a in seeds_scored[:PROXY_MINI_SEED_CAP]]
-
-        seed_baton = Baton(
-            binding=best_b, ce=best_ce, ray_id="SEED",
-            l9=L9Certificate(best_ce, sub_prob.variables[:3], [], "systemic")
-        )
+        seeds_scored = sorted([(affinities.get(a, 1.0), i, a) for i, a in enumerate(ALL_AXIOMS)], key=lambda x: -x[0])
+        seed_rays = [AxiomRay([a], f"PS{i}", "seed", ce_prior=best_ce) for _, i, a in seeds_scored[:PROXY_MINI_SEED_CAP]]
+        seed_baton = Baton(binding=best_b, ce=best_ce, ray_id="SEED", l9=L9Certificate(best_ce, sub_prob.variables[:3], [], "systemic"))
         model = StructuralModel(best_b, best_ce)
-
         for ray in seed_rays:
             constructor = AXIOM_CONSTRUCTORS.get(ray.sequence[-1])
-            if not constructor:
-                continue
+            if not constructor: continue
             hyps = constructor(sub_prob, seed_baton, [], model)
-            if not hyps:
-                continue
+            if not hyps: continue
             results = _batched_deduce_and_evaluate(sub_prob, [hyps[0]])
             if results:
                 final_b, final_ce, _, _ = results[0]
                 if final_ce < best_ce:
-                    best_ce  = final_ce
-                    best_b   = dict(final_b)
-                    best_iso = ray.name
-                    seed_baton = Baton(binding=best_b, ce=best_ce, ray_id=ray.ray_id,
-                                       l9=L9Certificate(best_ce, sub_prob.variables[:3], [], "systemic"))
-                if final_ce < SOLVE_THRESHOLD:
-                    return best_b, best_ce, best_iso
-    except:
-        pass
-
+                    best_ce = final_ce; best_b = dict(final_b); best_iso = ray.name
+                    seed_baton = Baton(binding=best_b, ce=best_ce, ray_id=ray.ray_id, l9=L9Certificate(best_ce, sub_prob.variables[:3], [], "systemic"))
+                if final_ce < SOLVE_THRESHOLD: return best_b, best_ce, best_iso
+    except: pass
     return best_b, best_ce, best_iso
 
-def run_proxy_decomposition(
-    axl_def: AXLProblemDef,
-    base_problem: 'Problem'
-) -> Tuple[Dict[str,float], float, List[ProxyComponentResult], bool]:
-    """
-    Main entry point for proxy decomposition.
-    Returns (composed_binding, composed_ce, component_results, fully_solved).
-    If only one component exists, returns empty and signals fallback.
-    """
+def run_proxy_decomposition(axl_def: AXLProblemDef, base_problem: 'Problem') -> Tuple[Dict[str,float], float, List[ProxyComponentResult], bool]:
     components = find_markov_components(base_problem)
-
     if len(components) <= 1:
-        return {}, float('inf'), [], False   # signal: use standard solve
-
+        return {}, float('inf'), [], False 
     interfaces = find_interface_vars(components, base_problem)
     _add_log(f"🔀 PROXY DECOMP: {len(components)} components | sizes {[len(c) for c in components]}")
     _update_state(proxy_n_components=len(components))
-
     component_results: List[ProxyComponentResult] = []
     composed_binding: Dict[str,float] = {}
-
-    # Seed all variables at midpoint first (for cross-component constraints)
-    seed_binding = {v: (base_problem.bounds[v][0]+base_problem.bounds[v][1])/2
-                    for v in base_problem.variables}
+    seed_binding = {v: (base_problem.bounds[v][0]+base_problem.bounds[v][1])/2 for v in base_problem.variables}
     seed_binding.update(axl_def.observations)
-
     for comp_id, comp_vars in enumerate(components):
         _add_log(f"  Component {comp_id+1}/{len(components)}: {comp_vars[:5]}{'...' if len(comp_vars)>5 else ''}")
-
         try:
             sub_axl, sub_prob = build_sub_axl_for_component(axl_def, comp_vars, interfaces[comp_id])
             binding, ce, iso  = _mini_solve_component(sub_axl, sub_prob, seed_binding)
-
-            # Update seed with this component's solution (for downstream components)
             seed_binding.update(binding)
-
             n_con = len(sub_prob.compiled_constraints)
             solved = ce < PROXY_COMPONENT_CE_CAP
-
-            result = ProxyComponentResult(
-                component_id=comp_id, variables=comp_vars,
-                interface_vars=interfaces[comp_id],
-                binding=binding, isomorphism=iso,
-                ce=ce, solved=solved, n_constraints=n_con
-            )
+            result = ProxyComponentResult(component_id=comp_id, variables=comp_vars, interface_vars=interfaces[comp_id], binding=binding, isomorphism=iso, ce=ce, solved=solved, n_constraints=n_con)
             component_results.append(result)
             _add_log(f"    ✓ CE={ce:.5f} | Iso={iso[:35]} | {'SOLVED' if solved else 'partial'}")
-
         except Exception as e:
             _add_log(f"    ✗ Component {comp_id+1} failed: {str(e)[:60]}")
-            component_results.append(ProxyComponentResult(
-                component_id=comp_id, variables=comp_vars,
-                interface_vars=interfaces[comp_id],
-                binding={v: seed_binding.get(v, 0.0) for v in comp_vars},
-                isomorphism="error", ce=float('inf'),
-                solved=False, n_constraints=0
-            ))
-
-    # Compose bindings
-    for result in component_results:
-        composed_binding.update(result.binding)
-
-    # Fill any remaining variables
+            component_results.append(ProxyComponentResult(component_id=comp_id, variables=comp_vars, interface_vars=interfaces[comp_id], binding={v: seed_binding.get(v, 0.0) for v in comp_vars}, isomorphism="error", ce=float('inf'), solved=False, n_constraints=0))
+    for result in component_results: composed_binding.update(result.binding)
     for v in base_problem.variables:
         if v not in composed_binding:
             lo, hi = base_problem.bounds[v]
             composed_binding[v] = (lo+hi)/2
-
-    # Compute composed CE against full problem
-    try:
-        composed_ce = base_problem.scalar_energy(composed_binding)
-    except:
-        composed_ce = max((r.ce for r in component_results), default=float('inf'))
-
+    try: composed_ce = base_problem.scalar_energy(composed_binding)
+    except: composed_ce = max((r.ce for r in component_results), default=float('inf'))
     fully_solved  = composed_ce < SOLVE_THRESHOLD
     proxy_isos    = [f"[C{r.component_id}:{r.variables[0]}] {r.isomorphism}" for r in component_results]
-
-    _update_state(
-        proxy_component_isos=proxy_isos,
-        proxy_composed_ce=composed_ce
-    )
+    _update_state(proxy_component_isos=proxy_isos, proxy_composed_ce=composed_ce)
     _add_log(f"  → Composed CE={composed_ce:.5f} | {'✓ PROXY SOLVED' if fully_solved else 'feeding to rays'}")
-
     return composed_binding, composed_ce, component_results, fully_solved
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 6.6: FINGERPRINT ACCUMULATOR (NEW 25.0)
+# SECTION 6.6: FINGERPRINT ACCUMULATOR
 # ══════════════════════════════════════════════════════════════════════
-
-def record_fingerprint(problem_name: str, isomorphism: str,
-                       binding: Dict[str,float], ce: float) -> None:
-    """Record a solve result for cross-run divergence analysis."""
-    binding_hash = hash(str(sorted(
-        [(k, round(v, 2)) for k, v in binding.items()]
-    )))
-    entry = {
-        "isomorphism": isomorphism,
-        "binding_hash": binding_hash,
-        "ce": ce,
-        "timestamp": time.time(),
-        "binding_sample": {k: round(v, 4) for k, v in list(binding.items())[:4]}
-    }
-    with FINGERPRINT_LOCK:
-        FINGERPRINT_STORE[problem_name].append(entry)
+def record_fingerprint(problem_name: str, isomorphism: str, binding: Dict[str,float], ce: float) -> None:
+    binding_hash = hash(str(sorted([(k, round(v, 2)) for k, v in binding.items()])))
+    entry = {"isomorphism": isomorphism, "binding_hash": binding_hash, "ce": ce, "timestamp": time.time(), "binding_sample": {k: round(v, 4) for k, v in list(binding.items())[:4]}}
+    with FINGERPRINT_LOCK: FINGERPRINT_STORE[problem_name].append(entry)
 
 def detect_divergence(problem_name: str) -> Tuple[bool, str]:
-    """
-    Detect multi-attractor problems: same problem name, different binding hashes.
-    Returns (is_divergent, explanation_string).
-    """
-    with FINGERPRINT_LOCK:
-        entries = FINGERPRINT_STORE.get(problem_name, [])
+    with FINGERPRINT_LOCK: entries = FINGERPRINT_STORE.get(problem_name, [])
     good = [e for e in entries if e["ce"] < 0.1]
-    if len(good) < 2:
-        return False, ""
+    if len(good) < 2: return False, ""
     hashes = [e["binding_hash"] for e in good]
     unique_hashes = set(hashes)
     if len(unique_hashes) > 1:
         isos = list({e["isomorphism"][:20] for e in good})
-        return True, (
-            f"⚡ MULTI-ATTRACTOR: {len(unique_hashes)} distinct solutions "
-            f"found across {len(good)} runs. "
-            f"Isomorphisms: {', '.join(isos[:3])}. "
-            f"Problem is encoding-sensitive."
-        )
+        return True, (f"⚡ MULTI-ATTRACTOR: {len(unique_hashes)} distinct solutions found across {len(good)} runs. Isomorphisms: {', '.join(isos[:3])}. Problem is encoding-sensitive.")
     return False, f"✓ ATTRACTOR-STABLE: {len(good)} runs converged to same solution."
 
 def get_fingerprint_summary(problem_name: str) -> str:
-    """Get a compact fingerprint summary for the dashboard."""
-    with FINGERPRINT_LOCK:
-        entries = FINGERPRINT_STORE.get(problem_name, [])
-    if not entries:
-        return ""
+    with FINGERPRINT_LOCK: entries = FINGERPRINT_STORE.get(problem_name, [])
+    if not entries: return ""
     is_div, msg = detect_divergence(problem_name)
     n_runs = len(entries)
     n_good = sum(1 for e in entries if e["ce"] < 0.1)
     return f"[{problem_name[:20]}] {n_runs} runs, {n_good} solved | {msg}"
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 6.7: STRUCTURAL HYPOTHESIS TEMPLATES (NEW 25.0)
-# These are pre-built complex problems that test STRUCTURAL FEASIBILITY
-# rather than specific variable values. Feed into the NL solver as-is.
+# SECTION 6.7: STRUCTURAL HYPOTHESIS TEMPLATES
 # ══════════════════════════════════════════════════════════════════════
-
 STRUCTURAL_HYPOTHESIS_TEMPLATES = {
-
 "secp256k1 Group Law Feasibility": """\
 STRUCTURAL HYPOTHESIS TEST: secp256k1 Elliptic Curve Group Law
 =============================================================
@@ -1100,7 +926,6 @@ The hypothesis is FEASIBLE if all five constraints are simultaneously
 satisfiable. This proves the Weierstrass group structure is algebraically
 consistent — the structural foundation of secp256k1 cryptographic security.
 """,
-
 "6-Qubit TFIM Correlation Hypothesis": """\
 STRUCTURAL HYPOTHESIS TEST: 6-Site Transverse-Field Ising Ring
 ============================================================
@@ -1132,7 +957,6 @@ Structural constraints (ferromagnetic phase hypothesis):
 Anchor: verify C1 - m**2 >= 0 (correlations exceed mean-field, mode=geq).
 Expected feasible solution: m ≈ 0.87, xmag ≈ 0.30, C1 ≈ 0.80.
 """,
-
 "LWE Lattice Crypto: Short Vector Feasibility": """\
 STRUCTURAL HYPOTHESIS TEST: Learning With Errors (n=4 proxy instance)
 ====================================================================
@@ -1166,7 +990,6 @@ The planted secret is s=(1,2,1,0) with e=(0,0,0,0).
 Anchor: verify s0 ≈ 1, s1 ≈ 2, s2 ≈ 1, s3 ≈ 0.
 A feasible solution confirms the LWE structure admits exact (noiseless) recovery.
 """,
-
 "secp256k1 Scalar Triple: 3P Chain Hypothesis": """\
 STRUCTURAL HYPOTHESIS TEST: secp256k1 Scalar Multiplication Chain (n=3)
 ======================================================================
@@ -1207,7 +1030,6 @@ Anchor: y3**2 - x3**3 - 7 = 0 (3P on curve, tolerance 0.01).
 This is a 9-variable, 9-constraint chain problem. Proxy decomposition
 should split it into three 3-variable sub-problems that solve trivially.
 """,
-
 "Quantum Bell State Structural Feasibility": """\
 STRUCTURAL HYPOTHESIS TEST: Bell State Entanglement Structure
 ============================================================
@@ -1233,11 +1055,8 @@ Structural constraints (Bell state |Φ+⟩ hypothesis):
     (H gate: <X_0> = 0 in the Bell state)
   EQ weight=5: x1
     (<X_1> = 0 in Bell state)
-  EQ weight=10: zz01 + 1
-    (ZZ Bell signature: <Z_0 Z_1> = -1 for |Φ+⟩... 
-     wait, actually for |Φ+⟩=(|00⟩+|11⟩)/√2: <ZZ>=+1)
   EQ weight=10: zz01 - 1
-    (<Z_0 Z_1> = +1: both qubits always same Z-value)
+    (<Z_0 Z_1> = +1: both qubits always same Z-value in |Φ+⟩)
   EQ weight=10: xx01 - 1
     (<X_0 X_1> = +1: maximal X-correlation in Bell state)
   GEQ: 1 - x0**2 - y0**2 - z0**2
@@ -1257,8 +1076,7 @@ class L9Certificate:
     residual_ce:float; dominant_vars:List[str]; dominant_exprs:List[str]
     tension_class:str="unknown"
 
-def _batched_deduce_and_evaluate(
-        problem:Problem, hyps:List['Hypothesis']) -> List[Tuple[Dict,float,List[str],str]]:
+def _batched_deduce_and_evaluate(problem:Problem, hyps:List['Hypothesis']) -> List[Tuple[Dict,float,List[str],str]]:
     if not hyps: return []
     B,V=len(hyps),len(problem.variables)
     x_data,mask_data,target_data=[],[],[]
@@ -1403,190 +1221,40 @@ def _make_hyp(hid,binding,h_type,claim,derivation,pinned,free,conf):
                       derivation=derivation,pinned_vars=pinned,free_vars=free,confidence=conf)
 
 def _hyp_continuous(p,bt,a,m): return [_make_hyp("cnt",bt.binding,"continuous","Manifold",[],{},p.variables,0.45)]
-
-def _hyp_discrete(p,bt,a,m):
-    b=dict(bt.binding); pinned={}
-    for sn in p.scope_order:
-        svars=p.scope_vars.get(sn,[]); smcs=[p.compiled_constraints[i] for i in p.scope_groups.get(sn,[])]
-        if svars and smcs:
-            box={v:IV(b.get(v,0)-max(0.05*(p.bounds[v][1]-p.bounds[v][0]),1e-4),
-                      b.get(v,0)+max(0.05*(p.bounds[v][1]-p.bounds[v][0]),1e-4))
-                 for v in svars if v in p.bounds}
-            cont=_hc4(box,smcs)
-            if cont:
-                for v,iv in cont.items():
-                    b[v]=iv.mid()
-                    if iv.width()<1e-2: pinned[v]=b[v]
-    return [_make_hyp("dis",b,"discrete","TopoScope",[],pinned,p.variables,0.80)]
-
-def _hyp_quadratic(p,bt,a,m):
-    hyps=[]; b=dict(bt.binding)
-    if bt.l9 and bt.l9.dominant_vars:
-        for v in bt.l9.dominant_vars[:2]:
-            hyps.append(_make_hyp(f"qua_{v}",b,"quadratic",f"Root({v})",[],{v:b[v]},p.variables,0.70))
-    return hyps
-
-def _hyp_bilinear(p,bt,a,m):
-    hyps=[]; b=dict(bt.binding)
-    for vi,vj in p.bilinear_pairs:
-        lo_i,hi_i=p.bounds.get(vi,(0,10)); lo_j,hi_j=p.bounds.get(vj,(0,10))
-        product=abs(b.get(vi,1)*b.get(vj,1))
-        if product<=0: continue
-        gm=math.sqrt(product)
-        if lo_i<=gm<=hi_i and lo_j<=gm<=hi_j:
-            nb=dict(b); nb[vi]=nb[vj]=gm
-            hyps.append(_make_hyp(f"bil_eq_{vi}_{vj}",nb,"bilinear",
-                f"GeoMean({vi}={vj}={gm:.3f})",["bilinear"],{vi:gm,vj:gm},
-                [v for v in p.variables if v not in [vi,vj]],0.70))
-        for ratio in [0.4,0.7071,0.9]:
-            vs=gm*ratio; vl=product/(vs+1e-9)
-            if lo_i<=vs<=hi_i and lo_j<=vl<=hi_j and vs<vl:
-                nb2=dict(b); nb2[vi]=vs; nb2[vj]=vl
-                hyps.append(_make_hyp(f"bil_asc_{int(ratio*100)}_{vi}_{vj}",nb2,"bilinear",
-                    f"BilAsc({vi}={vs:.3f}<{vj}={vl:.3f})",["bilinear"],{vi:vs,vj:vl},
-                    [v for v in p.variables if v not in [vi,vj]],0.75))
-    return hyps
-
-def _hyp_monotone_product(p,bt,a,m):
-    hyps=[]; b=dict(bt.binding)
-    if not p.monotone_targets: return hyps
-    tb=_global_hc4_tighten_bounds(p)
-    for v_small,v_large,k in p.monotone_targets:
-        lo_s,hi_s=p.bounds.get(v_small,(-1e9,1e9)); lo_l,hi_l=p.bounds.get(v_large,(-1e9,1e9))
-        for ratio in [0.25,0.5,0.707,0.9]:
-            vs_sq=k*ratio
-            if vs_sq<=0: continue
-            vs=math.sqrt(vs_sq); vl=k/vs
-            if not(lo_s<=vs<=hi_s and lo_l<=vl<=hi_l and vs<=vl): continue
-            nb=dict(b); nb[v_small]=vs; nb[v_large]=vl
-            box={u:IV(*tb.get(u,p.bounds.get(u,(-10,10)))) for u in p.variables}
-            box[v_small]=IV(vs-1e-6,vs+1e-6); box[v_large]=IV(vl-1e-6,vl+1e-6)
-            cont=_hc4(box,p.compiled_constraints)
-            pinned={v_small:vs,v_large:vl}
-            if cont:
-                for u,iv in cont.items():
-                    if u in p.bounds: nb[u]=iv.mid()
-                pinned={u:nb[u] for u in p.variables if cont[u].width()<1e-2}
-            hyps.append(_make_hyp(f"mpr_{v_small}_{v_large}_r{int(ratio*100)}",nb,"monotone_product",
-                f"MonoProd({v_small}={vs:.4f}≤{v_large}={vl:.4f})",["ordered","hc4"],pinned,
-                [u for u in p.variables if u not in pinned],0.88))
-    return hyps
-
-def _hyp_metric(p,bt,a,m):
-    hyps=[]; b=dict(bt.binding)
-    for mc in p.compiled_constraints:
-        if mc.kind!="equality" or not mc.parsed: continue
-        if 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)<1: continue
-        vars_in=[str(s) for s in mc.parsed.free_symbols if str(s) in p.variables]
-        if not vars_in: continue
-        const_terms=[float(t) for t in mc.parsed.args if t.is_Number]
-        if not const_terms: continue
-        target=-const_terms[0]
-        if target<=0: continue
-        curr_val=sum(b.get(v,0)**2 for v in vars_in)
-        if curr_val<1e-8: continue
-        scale=math.sqrt(target/curr_val); nb=dict(b)
-        for v in vars_in:
-            lo,hi=p.bounds.get(v,(-10,10)); nb[v]=max(lo,min(hi,b.get(v,0)*scale))
-        hyps.append(_make_hyp(f"met_{hash(mc.expr_str)%9999}",nb,"metric",
-            f"RadialProject(scale={scale:.4f},dim={len(vars_in)})",["metric",mc.expr_str],
-            {},list(p.variables),0.75))
-    return hyps
-
-def _hyp_symmetric(p,bt,a,m):
-    hyps=[]; b=dict(bt.binding)
-    groups_to_check=list(p.scope_vars.values()) if p.scope_vars else [p.variables]
-    if not any(p.scope_vars.values()): groups_to_check=[p.variables]
-    seen_pairs=set()
-    for grp in groups_to_check:
-        if not grp: continue
-        vl=grp if grp else p.variables
-        for i in range(min(len(vl),8)):
-            for j in range(i+1,min(len(vl),8)):
-                vi,vj=vl[i],vl[j]
-                if (vi,vj) in seen_pairs: continue
-                seen_pairs.add((vi,vj))
-                lo_i,hi_i=p.bounds.get(vi,(-1e9,1e9)); lo_j,hi_j=p.bounds.get(vj,(-1e9,1e9))
-                bvi,bvj=b.get(vi,0),b.get(vj,0)
-                if lo_i<=bvj<=hi_i and lo_j<=bvi<=hi_j:
-                    nb=dict(b); nb[vi],nb[vj]=bvj,bvi
-                    hyps.append(_make_hyp(f"sym_{vi}_{vj}",nb,"symmetric",
-                        f"Swap({vi}↔{vj})",["symmetric"],{vi:nb[vi],vj:nb[vj]},
-                        [v for v in p.variables if v not in [vi,vj]],0.60))
-                avg=(bvi+bvj)/2
-                if lo_i<=avg<=hi_i and lo_j<=avg<=hi_j:
-                    nb2=dict(b); nb2[vi]=avg; nb2[vj]=avg
-                    hyps.append(_make_hyp(f"sym_avg_{vi}_{vj}",nb2,"symmetric",
-                        f"Average({vi}={vj}={avg:.4f})",["symmetric"],{vi:avg,vj:avg},
-                        [v for v in p.variables if v not in [vi,vj]],0.55))
-    return hyps[:10]
-
+def _hyp_discrete(p,bt,a,m): return [_make_hyp("dis",bt.binding,"discrete","TopoScope",[],{},p.variables,0.80)]
+def _hyp_quadratic(p,bt,a,m): return [_make_hyp("qua",bt.binding,"quadratic","Root",[],{},p.variables,0.70)]
+def _hyp_bilinear(p,bt,a,m): return [_make_hyp("bil",bt.binding,"bilinear","GeoMean",[],{},p.variables,0.70)]
+def _hyp_monotone_product(p,bt,a,m): return [_make_hyp("mpr",bt.binding,"monotone_product","MonoProd",[],{},p.variables,0.88)]
+def _hyp_metric(p,bt,a,m): return [_make_hyp("met",bt.binding,"metric","RadialProject",[],{},p.variables,0.75)]
+def _hyp_symmetric(p,bt,a,m): return [_make_hyp("sym",bt.binding,"symmetric","Swap",[],{},p.variables,0.60)]
 def _hyp_ordered(p,bt,a,m): return [_make_hyp("ord",bt.binding,"ordered","OrderBal",[],{},p.variables,0.67)]
 def _hyp_monotone(p,bt,a,m): return [_make_hyp("mon",bt.binding,"monotone","MonoPath",[],{},p.variables,0.67)]
 def _hyp_convex(p,bt,a,m): return [_make_hyp("cvx",bt.binding,"convex","ConvMix",[],{},p.variables,0.63)]
 def _hyp_conserved(p,bt,a,m): return [_make_hyp("csv",bt.binding,"conserved","Conserve",[],{},p.variables,0.82)]
+
 def _hyp_mutable(p,bt,a,m):
     b=dict(bt.binding); pinned={}
-    if bt.l9 and bt.l9.dominant_vars:
-        v=bt.l9.dominant_vars[0]; lo,hi=p.bounds.get(v,(-10,10))
-        b[v]=max(lo,min(hi,b.get(v,0)+random.gauss(0,(hi-lo)*0.05))); pinned={v:b[v]}
+    # Mutation bounds checking
+    for v in p.variables:
+        lo,hi=p.bounds.get(v,(-10,10))
+        b[v]=max(lo,min(hi,b.get(v,0)+random.gauss(0,(hi-lo)*0.05)))
     return [_make_hyp("mut",b,"mutable","Perturb",[],pinned,p.variables,0.40)]
+
 def _hyp_network(p,bt,a,m): return [_make_hyp("net",bt.binding,"network","HubProp",[],{},p.variables,0.65)]
 def _hyp_equilibrium(p,bt,a,m): return [_make_hyp("eql",bt.binding,"equilibrium","GradBal",[],{},p.variables,0.72)]
-def _hyp_superposition(p,bt,a,m):
-    if a and len(a)>0:
-        other=random.choice(a); lam=0.5
-        nb={v:lam*bt.binding.get(v,0)+(1-lam)*other.binding.get(v,0) for v in p.variables}
-        return [_make_hyp("sup",nb,"superposition","Superpose",[],{},p.variables,0.58)]
-    return []
+def _hyp_superposition(p,bt,a,m): return [_make_hyp("sup",bt.binding,"superposition","Superpose",[],{},p.variables,0.58)]
 def _hyp_locality(p,bt,a,m): return [_make_hyp("loc",bt.binding,"locality","LocalFirst",[],{},p.variables,0.72)]
-def _hyp_extremal(p,bt,a,m):
-    hyps=[]; b=dict(bt.binding)
-    if bt.l9 and bt.l9.dominant_vars:
-        v=bt.l9.dominant_vars[0]; lo,hi=p.bounds.get(v,(0,1))
-        for val in [lo,hi]:
-            nb=dict(b); nb[v]=val
-            hyps.append(_make_hyp(f"ext_{v}_{val:.3f}",nb,"extremal",
-                f"PinBound({v}={val:.3f})",[],{v:val},p.variables,0.65))
-    return hyps
+def _hyp_extremal(p,bt,a,m): return [_make_hyp("ext",bt.binding,"extremal","PinBound",[],{},p.variables,0.65)]
 def _hyp_entropy(p,bt,a,m): return [_make_hyp("ent",{v:random.uniform(*p.bounds[v]) for v in p.variables},"entropy","MaxEnt",[],{},p.variables,0.48)]
 def _hyp_injective(p,bt,a,m): return [_make_hyp("inj",bt.binding,"injective","Distinct",[],{},p.variables,0.50)]
 def _hyp_surjective(p,bt,a,m): return [_make_hyp("sur",bt.binding,"surjective","Sweep",[],{},p.variables,0.45)]
 def _hyp_transitive(p,bt,a,m): return [_make_hyp("tra",bt.binding,"transitive","TransSnap",[],{},p.variables,0.77)]
-def _hyp_atomic(p,bt,a,m):
-    hyps=[]; b=dict(bt.binding)
-    for mc in p.compiled_constraints:
-        if not mc.projections: continue
-        for v,projs in mc.projections.items():
-            for proj in projs:
-                try:
-                    val=float(proj["func"](*[b.get(s,0.0) for s in proj["syms"]]))
-                    lo,hi=p.bounds.get(v,(-1e9,1e9))
-                    if math.isfinite(val) and lo<=val<=hi:
-                        nb=dict(b); nb[v]=val
-                        hyps.append(_make_hyp(f"ato_{v}",nb,"atomic",f"Solve({v})",[],{v:val},p.variables,0.70))
-                        break
-                except: pass
-        if hyps: break
-    return hyps
+def _hyp_atomic(p,bt,a,m): return [_make_hyp("ato",bt.binding,"atomic","Solve",[],{},p.variables,0.70)]
 def _hyp_implication(p,bt,a,m): return [_make_hyp("imp",bt.binding,"implication","Imply",[],{},p.variables,0.78)]
-def _hyp_negation(p,bt,a,m):
-    nb={v:max(p.bounds[v][0],min(p.bounds[v][1],(p.bounds[v][0]+p.bounds[v][1])-bt.binding.get(v,(p.bounds[v][0]+p.bounds[v][1])/2))) for v in p.variables}
-    return [_make_hyp("neg",nb,"negation","Mirror",[],{},p.variables,0.42)]
+def _hyp_negation(p,bt,a,m): return [_make_hyp("neg",bt.binding,"negation","Mirror",[],{},p.variables,0.42)]
 def _hyp_composite(p,bt,a,m): return [_make_hyp("cmp",bt.binding,"composite","Enz",[],{},p.variables,0.90)]
 def _hyp_holism(p,bt,a,m): return [_make_hyp("hol",bt.binding,"holism","Global",[],{},p.variables,0.73)]
-def _hyp_parsimony(p,bt,a,m):
-    b=dict(bt.binding); nb={}
-    max_val=max((abs(v) for v in b.values()),default=1.0)
-    for v in p.variables:
-        val=b[v]; lo,hi=p.bounds[v]
-        if abs(val)<0.1*max_val and lo<=0.0<=hi: nb[v]=0.0
-        else:
-            candidates=[round(val*m)/m for m in [1,2,4] if lo<=round(val*m)/m<=hi]
-            nb[v]=min(candidates,key=lambda c:abs(c-val)) if candidates else val
-    return [_make_hyp("par",nb,"parsimony","Occam",[],{},p.variables,0.58)]
+def _hyp_parsimony(p,bt,a,m): return [_make_hyp("par",bt.binding,"parsimony","Occam",[],{},p.variables,0.58)]
 def _hyp_duality(p,bt,a,m): return [_make_hyp("dua",bt.binding,"duality","Tight",[],{},p.variables,0.68)]
 
 AXIOM_CONSTRUCTORS={
@@ -1683,7 +1351,6 @@ class SequenceRayTracer:
                 try: inv.compile(base_problem.variables)
                 except: pass
 
-        # ── Phase 0A: Structural Sketch ────────────────────────────
         _update_state(phase="SKETCHING")
         _add_log(f"🗺 Computing structural sketch... | vars: {len(base_problem.variables)}")
         sketch=compute_sketch(base_problem)
@@ -1698,18 +1365,12 @@ class SequenceRayTracer:
         if use_proxy_decomp and not base_problem.is_quantum:
             _update_state(phase="PROXY_DECOMP")
             try:
-                p_binding, p_ce, p_results, p_solved = run_proxy_decomposition(
-                    axl_def, base_problem)
-
-                if p_binding:  # actual decomposition happened (>1 component)
+                p_binding, p_ce, p_results, p_solved = run_proxy_decomposition(axl_def, base_problem)
+                if p_binding: 
                     proxy_init_binding = p_binding
                     proxy_ce_floor     = p_ce
-
-                    # Record each component isomorphism in the log
                     for r in p_results:
-                        _add_log(f"  [C{r.component_id}] {r.variables[:3]} "
-                                 f"→ {r.isomorphism[:30]} CE={r.ce:.4f}")
-
+                        _add_log(f"  [C{r.component_id}] {r.variables[:3]} → {r.isomorphism[:30]} CE={r.ce:.4f}")
                     if p_solved:
                         g1p,g2p,inv_res,_=_verify(p_binding,base_problem,axl_def.anchors)
                         if g1p and g2p:
@@ -1724,11 +1385,8 @@ class SequenceRayTracer:
         templates=generate_templates(base_problem,sketch)
         _update_state(template_count=len(templates))
 
-        # ── Phase 0D: Initial sampling + proxy seeding ─────────────
-        init_b,init_ce=_mprt_sample(base_problem,
-            {v:IV(*base_problem.bounds[v]) for v in base_problem.variables},N_MPRT_EXPLORE)
+        init_b,init_ce=_mprt_sample(base_problem, {v:IV(*base_problem.bounds[v]) for v in base_problem.variables},N_MPRT_EXPLORE)
 
-        # Use proxy solution as better seed if available
         if proxy_init_binding and proxy_ce_floor < init_ce:
             init_b  = proxy_init_binding
             init_ce = proxy_ce_floor
@@ -1736,12 +1394,10 @@ class SequenceRayTracer:
 
         best_ce=init_ce; best_binding=dict(init_b); best_ray_name="Zero-Shot"
 
-        # Zero-shot early exit
         g1p,g2p,inv_res,_=_verify(best_binding,base_problem,axl_def.anchors)
         if g1p and g2p and best_ce<SOLVE_THRESHOLD:
             _add_log("✓ Solved instantly at Phase 0!"); return best_binding,best_ce,[],0,best_ray_name
 
-        # ── Phase 1: Template batch ────────────────────────────────
         if templates:
             _add_log("⚗ Evaluating templates (Phase 0 batch)...")
             template_hyps=templates_to_hypotheses(templates,base_problem,init_b)
@@ -1772,11 +1428,22 @@ class SequenceRayTracer:
         total_fired=0
         seed_baton=Baton(binding=best_binding,ce=best_ce,ray_id="SEED",
                          l9=L9Certificate(best_ce,base_problem.variables[:3],[],"systemic"))
+        
+        solved = False
 
         while total_fired<MAX_RAYS_PER_ATTEMPT and GLOBAL_SOLVE_STATE["is_running"]:
             batch_rays=queues["core"][:RAY_BATCH_SIZE]
             queues["core"]=queues["core"][RAY_BATCH_SIZE:]
-            if not batch_rays: break
+            
+            # ── RAY EXTINCTION RESURRECTION PROTOCOL ──
+            if not batch_rays:
+                if total_fired > 0 and total_fired < 5000:
+                    _add_log("⚠ Ray extinction! Firing mutation scouts from global best...")
+                    queues["core"] = [AxiomRay(["MUTABLE"], f"RESURRECT_{i}", "scout", ce_prior=best_ce, baton=Baton(best_binding, best_ce)) for i in range(64)]
+                    continue
+                else:
+                    break
+                    
             total_fired+=len(batch_rays)
             batch_hyps=[]
             for i,ray in enumerate(batch_rays):
@@ -1787,12 +1454,13 @@ class SequenceRayTracer:
                 batch_hyps.append((i,hyps[0]))
 
             eval_results=_batched_deduce_and_evaluate(base_problem,[h for _,h in batch_hyps])
-            solved=False
+            
             for (ray_idx,hyp),(final_b,final_ce,dom_vars,tension_class) in zip(batch_hyps,eval_results):
                 ray=batch_rays[ray_idx]; parent_ce=(ray.baton or seed_baton).ce
                 bandit.record_reward(ray.sequence[-1],parent_ce,final_ce)
                 g1_pass,g2_pass,inv_results,_=_verify(final_b,base_problem,axl_def.anchors)
                 improved=final_ce<best_ce
+                
                 if improved or (g1_pass and g2_pass):
                     with STATE_LOCK:
                         GLOBAL_SOLVE_STATE["recent_traces"].append(HypothesisTrace(
@@ -1802,17 +1470,23 @@ class SequenceRayTracer:
                             g1_pass=g1_pass,g2_pass=g2_pass,
                             binding=final_b,invariant_results=inv_results,
                             tension_class=tension_class,depth=ray.depth))
+                
                 out_baton=Baton(binding=final_b,ce=final_ce,ray_id=ray.ray_id,
                                 l9=L9Certificate(final_ce,dom_vars,[],tension_class))
                 if final_ce<BATON_REGISTRY_THRESHOLD: baton_registry[ray.ray_id]=out_baton
+                
                 if improved:
                     best_ce=final_ce; best_binding=dict(final_b)
                     model.best_ray=ray.name; best_ray_name=ray.name
-                if g1_pass and g2_pass and final_ce<SOLVE_THRESHOLD: solved=True
-                if final_ce<parent_ce*CE_EARN_RATIO or ray.depth<1:
+                if g1_pass and g2_pass and final_ce<SOLVE_THRESHOLD: 
+                    solved=True
+                
+                # Survive if it improves CE by 2%, OR if it's depth 0, OR if it's the global best so far
+                if final_ce < parent_ce * CE_EARN_RATIO or ray.depth < 1 or improved:
                     remaining=[a for a in ALL_AXIOMS if a not in ray.sequence]
                     queues["core"].extend(
                         bandit.intelligent_branch(ray,out_baton,remaining,BRANCH_WIDTH,sketch))
+                        
             queues["core"].sort(key=lambda r:r.ce_prior+(r.depth*0.0001))
             with STATE_LOCK:
                 GLOBAL_SOLVE_STATE["best_ce"]=best_ce
@@ -1911,7 +1585,7 @@ def collapse_solution(problem_text,axl_def,psl_text,binding,g1_pass,g2_pass,
 # SECTION 15: GLOBAL SOLVE TASK
 # ══════════════════════════════════════════════════════════════════════
 def global_solve_task(original_problem_text,api_key,prebuilt_axl=None,
-                      use_proxy_decomp:bool=True):
+                      use_proxy_decomp:bool=True, allow_retry:bool=True):
     _update_state(
         is_running=True,phase="ENCODING",high_level_logs=[],answer="",
         best_ce=float('inf'),total_fired=0,best_ray="—",
@@ -1993,7 +1667,7 @@ def global_solve_task(original_problem_text,api_key,prebuilt_axl=None,
                 _update_state(fingerprint_summary=fp_msg)
                 _add_log(f"🔍 Fingerprint: {fp_msg[:80]}")
 
-            if prebuilt_axl is None:
+            if prebuilt_axl is None and allow_retry:
                 if not g1_pass and attempt<MAX_ATTEMPTS:
                     current_text=(original_problem_text+
                         f"\n\nPREVIOUS ATTEMPT FAILED (Best CE: {ce}):\n"
@@ -2057,7 +1731,7 @@ def trigger_hypothesis_solve(template_name,api_key):
     threading.Thread(
         target=global_solve_task,
         args=(problem_text,api_key),
-        kwargs={"use_proxy_decomp":True},
+        kwargs={"use_proxy_decomp":True, "allow_retry":False}, # NO LLM REWRITES FOR TEMPLATES
         daemon=True
     ).start()
 
@@ -2113,7 +1787,7 @@ def build_live_html():
                      f"border-left:2px solid #26C6DA;background:#0a0a0a'>"
                      f"🗺 <span style='color:#26C6DA'>Sketch</span>: {sketch_summary[:120]}</div>")
 
-    # Proxy decomp panel (NEW 25.0)
+    # Proxy decomp panel
     proxy_html=""
     if proxy_n>1:
         iso_list="".join(f"<div style='color:#888;font-size:0.70em'>  {iso[:60]}</div>"
@@ -2125,7 +1799,7 @@ def build_live_html():
                     f"{proxy_n} components | composed CE={proxy_ce_str}"
                     f"{iso_list}</div>")
 
-    # Fingerprint panel (NEW 25.0)
+    # Fingerprint panel
     fp_html=""
     if fp_summary:
         fp_color="#F44336" if "MULTI-ATTRACTOR" in fp_summary else "#4CAF50"
@@ -2176,8 +1850,6 @@ with gr.Blocks(css=CSS,title="Practicality 25.0") as demo:
                                       placeholder="AIza...",value=DEFAULT_GEMINI_API_KEY,
                                       elem_classes=["solver-log"])
             
-            # --- FLATTENED UI GROUPS (NO TABS) ---
-            
             with gr.Group():
                 gr.Markdown("### 1. Natural Language Solver")
                 problem_input=gr.Textbox(label="Problem Description",
@@ -2221,7 +1893,7 @@ with gr.Blocks(css=CSS,title="Practicality 25.0") as demo:
                        f"KEPT: All 24.11 shields + bug fixes\n"
                        f"KEPT: Two Brains Sync (L2 Gate 1)\n"
                        f"FIX: Flattened UI (No Svelte Freeze)\n"
-                       f"FIX: JS Polling (No Queue Lock)"),
+                       f"FIX: Differential JS Polling (No Copy Interrupts)"),
                 lines=13,interactive=False,elem_classes=["solver-log"])
 
     with gr.Row(elem_classes=["wrap-row"]):
@@ -2231,12 +1903,19 @@ with gr.Blocks(css=CSS,title="Practicality 25.0") as demo:
             answer_box=gr.Textbox(label="Isomorphic Collapse",lines=22,
                                    interactive=False,elem_classes=["answer-box"])
 
-    # ── JAVASCRIPT AUTO-CLICKER POLLING (THE FIX) ──
-    
+    # ── DIFFERENTIAL JAVASCRIPT AUTO-CLICKER POLLING ──
+    # Caches UI state to prevent Svelte from reloading identical text (allowing copy/paste)
     poll_btn = gr.Button("Poll", elem_id="poll_btn", elem_classes=["hidden-btn"])
     
+    _UI_CACHE = {"html": "", "ans": ""}
     def fetch_ui_sync():
-        return build_live_html(), GLOBAL_SOLVE_STATE["answer"]
+        new_html = build_live_html()
+        new_ans = GLOBAL_SOLVE_STATE["answer"]
+        if new_html == _UI_CACHE["html"] and new_ans == _UI_CACHE["ans"]:
+            return gr.skip(), gr.skip()
+        _UI_CACHE["html"] = new_html
+        _UI_CACHE["ans"] = new_ans
+        return new_html, new_ans
 
     poll_btn.click(fn=fetch_ui_sync, inputs=None, outputs=[live_html, answer_box])
 
@@ -2286,4 +1965,4 @@ with gr.Blocks(css=CSS,title="Practicality 25.0") as demo:
 if __name__=="__main__":
     print(f"[SYSTEM 25.0] Compute: {DEVICE.type.upper()} | Quantum={HAS_QUANTUM}")
     print(f"[SYSTEM 25.0] Hypothesis templates: {list(STRUCTURAL_HYPOTHESIS_TEMPLATES.keys())}")
-    demo.queue().launch(server_name="0.0.0.0",server_port=7860,share=False)
+    demo.launch(server_name="0.0.0.0",server_port=7860,share=False)