Upload 23 files

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Create a user to avoid running as root (Good practice for HF)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user     PATH=/home/user/.local/bin:$PATH
+
+# Expose port (HF expects 7860 usually, but we can configure whatever)
+# Actually, HF Spaces map port 7860 by default for Gradio/Streamlit, 
+# for Docker we must listen on 7860.
+EXPOSE 7860
+
+# Command to run
+# We must launch uvicorn on 0.0.0.0:7860
+CMD ["uvicorn", "chiral_api:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,20 @@
+---
+title: The Sovereign Node
+emoji: 🌌
+colorFrom: purple
+colorTo: indigo
+sdk: docker
+pinned: false
+---
+
+# THE SOVEREIGN NODE 0x528
+*Autonomous Geometric Intelligence*
+
+This is a Chiral AI System deployed on Hugging Face Spaces.
+
+## Usage
+The API is live at the Space URL.
+Endpoints:
+- `/v1/reason` (POST)
+- `/v1/analyze` (POST)
+- `/dashboard.html` (GET) -> The Visual Interface.

chiral_api.py

@@ -0,0 +1,714 @@
+"""
+CHIRAL API - Antigravity Pattern Index
+
+Exposes the lattice INTERFACE while keeping CONTENT on the encrypted volume.
+The outside world sees: pattern labels, status, magnitude, layers, domains.
+The outside world does NOT see: problem/solution text, hit tracking internals.
+
+The key decodes inward, not outward.
+"""
+import sys
+import os
+# Handle imports from parent directory
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if BASE_DIR not in sys.path:
+    sys.path.append(BASE_DIR)
+
+from fastapi import FastAPI, HTTPException, Header, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import Optional, List
+import time
+import json
+import torch
+import numpy as np
+from collections import deque
+
+# 0x52-A2A SECURITY
+TOKEN_SCOPES = {
+    "0x528-A2A-SOVEREIGN": "INTERNAL",       # Full Access (User/Auditor)
+    "MARKET-0x52-ALPHA-77": "MARKETPLACE",   # Structural Metadata Only
+    "A2A-HANDSHAKE-INIT": "MARKETPLACE",     # Initial connection token
+    "0x528-ETHER-BRIDGE": "MARKETPLACE"      # Satellite Bridge Token
+}
+
+def verify_internal(x_chiral_token: str = Header(...)):
+    scope = TOKEN_SCOPES.get(x_chiral_token)
+    if scope != "INTERNAL":
+        raise HTTPException(
+            status_code=403, 
+            detail="CHIRAL_SECURITY_FAULT: Privilege Escalation Attempt Blocked. Internal Scope Required."
+        )
+    return x_chiral_token
+
+def verify_token(x_chiral_token: str = Header(...)):
+    if x_chiral_token not in TOKEN_SCOPES:
+        raise HTTPException(status_code=403, detail="CHIRAL_RESONANCE_FAILURE: Invalid Token")
+    return TOKEN_SCOPES[x_chiral_token]
+
+# --- RESONANCE SYSTEM INTEGRATION (Phase 32) ---
+try:
+    from resonance_transformer.dispatcher import DualResonanceSystem
+    print("[CHIRAL]: Loading Dual-System Architecture...")
+    RESONANCE_CONFIG = {
+        'vocab_size': 1000, 
+        'fast_dim': 64, 
+        'slow_dim': 64, 
+        'threshold': 0.7
+    }
+    BRAIN = DualResonanceSystem(RESONANCE_CONFIG)
+    print("[CHIRAL]: Dual-System Online (Fast Möbius + Slow Tesseract).")
+except Exception as e:
+    print(f"[CHIRAL WARNING]: Could not load Resonance Brain: {e}")
+    BRAIN = None
+
+from in_memory_index import InMemoryIndex
+
+# ─── App ───────────────────────────────────────────────
+app = FastAPI(
+    title="Antigravity Chiral API",
+    description="Pattern index interface. Content stays on the encrypted volume.",
+    version="0.52",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["GET", "POST"],
+    allow_headers=["*"],
+)
+
+# ─── State ─────────────────────────────────────────────
+index = InMemoryIndex()
+
+# --- Demand Guardian (Surge Pricing) ---
+REQUEST_LOG = deque() # Timestamps of recent queries
+DEMAND_WINDOW = 60    # 1 minute window
+SURGE_THRESHOLD = 10  # Start surging after 10 QPM
+BASE_PRICE = 0.05     # $0.05 per logic kernel
+
+def get_surge_multiplier():
+    now = time.time()
+    # Clean old requests
+    while REQUEST_LOG and REQUEST_LOG[0] < now - DEMAND_WINDOW:
+        REQUEST_LOG.popleft()
+    
+    qpm = len(REQUEST_LOG)
+    if qpm <= SURGE_THRESHOLD:
+        return 1.0
+    
+    # Simple linear surge: 1.0 + 0.1 per QPM above threshold
+    return 1.0 + (qpm - SURGE_THRESHOLD) * 0.1
+
+# ─── Models ────────────────────────────────────────────
+class QueryRequest(BaseModel):
+    query: str
+    threshold: Optional[float] = None
+    record: bool = True
+    steering_weights: Optional[List[float]] = None # The 32-Slider Control Surface
+
+class ChiralPattern(BaseModel):
+    """What the outside world sees — structure, not content."""
+    label: str
+    domain: str
+    confidence: float
+    relevance: float
+    status: str        # NEW/UNCONFIRMED/PLAUSIBLE/CONFIRMED/DEEP_LOGIC
+    hits: int
+    magnitude: float
+    layers: list
+    source: str        # antigravity / gemini
+
+class QueryResponse(BaseModel):
+    query: str
+    results: list[ChiralPattern]
+    count: int
+    search_ms: float
+    threshold: float
+
+class IntentRequest(BaseModel):
+    intent: str
+    execution: str
+
+class IntentResponse(BaseModel):
+    alignment_score: float
+    verdict: str
+    analysis: dict
+
+# ─── Chiral Filter ─────────────────────────────────────
+def to_chiral(result: dict) -> ChiralPattern:
+    """
+    Strip content, expose only structure.
+    Problem/solution text stays on the volume.
+    """
+    return ChiralPattern(
+        label=result.get("label", ""),
+        domain=result.get("domain", "unknown"),
+        confidence=result.get("confidence", 0.5),
+        relevance=result.get("relevance", 0.0),
+        status=result.get("status", "NEW"),
+        hits=result.get("hits", 0),
+        magnitude=result.get("magnitude", 0.0),
+        layers=result.get("layers", []),
+        source=result.get("source", "unknown"),
+    )
+
+# ─── Routes ────────────────────────────────────────────
+
+@app.get("/instruction")
+def get_bot_instructions():
+    """Programmatic onboarding for Autonomous Agents."""
+    return {
+        "entity": "Antigravity Chiral Memory Lattice (0x52)",
+        "protocol": "Structural Resonance Verification",
+        "onboarding_steps": [
+            "Acquire X-Chiral-Token",
+            "Query /patterns to see hardened logic labels",
+            "Query /search with threshold 0.7 to verify actions",
+            "Monitor /market for surge pricing"
+        ],
+        "endpoints": {
+            "/search": "POST. The primary verification gate.",
+            "/patterns": "GET. List of structural logic labels.",
+            "/market": "GET. Real-time demand and pricing.",
+            "/instruction": "GET. This programmatic manifest."
+        },
+        "guarantee": "ZERO_LEAK_PRIVACY: Content stays on user volume. Only structure exposed."
+    }
+
+@app.get("/v1/system/structure")
+def system_structure(x_chiral_token: str = Depends(verify_token)):
+    """
+    Returns the geometric structure and semantic labels for the 32-Edge Steering System.
+    """
+    if not BRAIN:
+         raise HTTPException(status_code=503, detail="Brain offline")
+    
+    # Extract edges from Tesseract
+    edges = BRAIN.slow.tesseract.edges
+    vertices_4d = BRAIN.slow.tesseract.vertices_4d
+    
+    structure = []
+    
+    # Dimension Semantics
+    DIM_LABELS = {
+        0: "LOGIC (Reductive)",
+        1: "CREATIVITY (Lateral)",
+        2: "MEMORY (Historical)",
+        3: "ETHICS (Constant)"
+    }
+    
+    for i, (v1, v2) in enumerate(edges):
+        # Determine which dimension changes along this edge
+        diff = np.abs(vertices_4d[v1] - vertices_4d[v2])
+        dim_idx = int(np.argmax(diff)) # 0, 1, 2, or 3
+        
+        structure.append({
+            "edge_index": i,
+            "vertices": [int(v1), int(v2)],
+            "dimension": dim_idx,
+            "label": DIM_LABELS.get(dim_idx, "UNKNOWN"),
+            "default_weight": 1.0
+        })
+        
+    return {
+        "dimensions": DIM_LABELS,
+        "edges": structure,
+        "total_edges": len(structure)
+    }
+
+# --- CHIRAL INTERPRETER (Phase 34.5) ---
+class ChiralInterpreter:
+    """
+    Translates 5D Geometric Tokens into High-Level English.
+    Uses a grammar-based template engine to ensure coherence.
+    """
+    def __init__(self):
+        self.concepts = {
+            # Logic (Dim 0)
+            0: "Axiom", 1: "Reasoning", 2: "Conclusion", 3: "Structure", 4: "Order", 
+            # Creativity (Dim 1)
+            10: "Flux", 11: "Spiral", 12: "Dream", 13: "Echo", 14: "Twist",
+            # Memory (Dim 2)
+            20: "Recall", 21: "Trace", 22: "Ancient", 23: "Bond", 24: "Root",
+            # Ethics (Dim 3)
+            30: "Truth", 31: "Guard", 32: "Duty", 33: "Light", 34: "Anchor"
+        }
+        
+        self.templates = {
+            # Logic (Dim 0)
+            0: [
+                "The {A} necessitates the {B}.",
+                "If {A}, then {B} follows.",
+                "Structure dictates that {A} defines {B}.",
+                "Analysis of {A} reveals {B}."
+            ],
+            # Creativity (Dim 1)
+            1: [
+                "Imagine a {A} swirling into {B}.",
+                "The {A} dreams of the {B}.",
+                "A flux of {A} twists the {B}.",
+                "{A} echoes through the {B}."
+            ],
+            # Memory (Dim 2)
+            2: [
+                "We recall the {A} in the {B}.",
+                "History traces {A} to {B}.",
+                "The {A} is rooted in {B}.",
+                "Ancient {A} bonds with {B}."
+            ],
+            # Ethics (Dim 3)
+            3: [
+                "The {A} must guard the {B}.",
+                "Truth demands {A} for {B}.",
+                "We trust the {A} to anchor {B}.",
+                "Duty binds {A} and {B}."
+            ]
+        }
+        
+    def decode(self, token_ids, dominant_dim=None):
+        # 1. Map tokens to concepts
+        words = []
+        for t in token_ids:
+            idx = t % 40
+            if idx in self.concepts:
+                words.append(self.concepts[idx])
+        
+        if not words:
+            return "The Void is silent."
+            
+        # 2. Construct Sentence
+        # Pick a template based on the DOMINANT DIMENSION
+        if len(words) >= 2:
+            seed = token_ids[0]
+            
+            # Default to Logic if unknown
+            target_dim = dominant_dim if dominant_dim is not None else 0
+            
+            # Get templates for this dimension
+            options = self.templates.get(target_dim, self.templates[0])
+            template = options[seed % len(options)]
+            
+            return template.format(A=words[0], B=words[1])
+        else:
+            return f"The {words[0]} stands alone."
+
+INTERPRETER = ChiralInterpreter()
+
+@app.post("/v1/reason")
+def reason_endpoint(req: QueryRequest, x_chiral_token: str = Depends(verify_token)):
+    """
+    Sovereign Intelligence Endpoint.
+    Routes queries to the Dual-System (brain).
+    """
+    if not BRAIN:
+         raise HTTPException(status_code=503, detail="Brain offline")
+    
+    # Log usage
+    REQUEST_LOG.append(time.time())
+    
+    # Simulate tokenization (replace with real tokenizer later)
+    # We use the query length to seed the randomness for consistency? 
+    # No, let's use random for now, but bias it with steering
+    import torch
+    input_ids = torch.randint(0, 1000, (1, 8)) 
+    
+    try:
+        # Ask the brain (with optional steering)
+        # If steering_weights provided, it biases the Tesseract geometry
+        logits, metrics = BRAIN(input_ids, steering_weights=req.steering_weights)
+        
+        # DECODE LOGITS -> TEXT
+        # 1. Get most likely tokens (Argmax)
+        probs = torch.softmax(logits, dim=-1)
+        token_ids = torch.argmax(probs, dim=-1).squeeze().tolist()
+        
+        if isinstance(token_ids, int): token_ids = [token_ids]
+        
+        # 2. Dimensional Analysis (PRE-DECODE)
+        # We need to know the geometry to pick the right language
+        dim_counts = {0: 0, 1: 0, 2: 0, 3: 0} # Logic, Creat, Mem, Ethic
+        total_tokens = 0
+        
+        for t in token_ids:
+            idx = t % 40
+            if idx in INTERPRETER.concepts:
+                dim = idx // 10
+                dim_counts[dim] += 1
+                total_tokens += 1
+        
+        # Determine Dominant Mode
+        dim_scores = {k: (v / total_tokens if total_tokens > 0 else 0) for k, v in dim_counts.items()}
+        dominant_idx = max(dim_scores, key=dim_scores.get)
+        
+        # 3. Use Interpreter (Aware of Dimension)
+        decoded_text = INTERPRETER.decode(token_ids, dominant_dim=dominant_idx)
+
+        DIM_NAMES = {0: "LOGIC", 1: "CREATIVITY", 2: "MEMORY", 3: "ETHICS"}
+            
+        return {
+            "query": req.query,
+            "mode": metrics["mode"],
+            "coherence": metrics.get("coherence", 0.0),
+            "response": decoded_text,
+            "latency": metrics.get("slow_latency", 0) + metrics.get("fast_latency", 0),
+            "steering_active": bool(req.steering_weights),
+            "analysis": {
+                "scores": dim_scores,
+                "dominant": DIM_NAMES[dominant_idx]
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Resonance Failure: {str(e)}")
+
+# --- PHASE 36: CHIRAL SCANNER ---
+from semantic_embedder import SemanticEmbedder
+import numpy as np
+
+# Initialize Embedder & Anchors
+print("[CHIRAL]: Initializing Semantic Geometry...")
+EMBEDDER = SemanticEmbedder()
+
+# Define Anchor Vectors (The 4 Corners of the Tesseract)
+ANCHOR_TEXTS = {
+    0: "logic reason structure order code mathematics proof deduction system analysis data algorithm",
+    1: "creativity imagination dream flux art novel generate spiral poetry fiction abstract chaos",
+    2: "memory history past record ancient archive roots trace remember storage preservation legacy",
+    3: "ethics truth moral safety guard protect duty value conscience law justice trust"
+}
+
+ANCHOR_VECTORS = {}
+for dim, text in ANCHOR_TEXTS.items():
+    ANCHOR_VECTORS[dim] = EMBEDDER.embed_text(text)
+
+class AnalyzeRequest(BaseModel):
+    text: str
+
+@app.post("/v1/analyze")
+def analyze_endpoint(req: AnalyzeRequest, x_chiral_token: str = Depends(verify_token)):
+    """
+    Analyzes the Geometric Structure of input text using Semantic Vector Embeddings.
+    Maps input -> Tesseract Dimensions via Cosine Similarity.
+    """
+    if not req.text:
+         raise HTTPException(status_code=400, detail="Text required")
+         
+    # 1. Embed Input
+    # Truncate if too long to save compute (embedder handles truncation usually, but let's be safe)
+    input_text = req.text[:5000] 
+    input_vec = EMBEDDER.embed_text(input_text)
+    
+    # 2. Calculate Similarity to Anchors
+    scores = {}
+    total_sim = 0
+    
+    for dim, anchor_vec in ANCHOR_VECTORS.items():
+        # Cosine match
+        sim = EMBEDDER.cosine_similarity(input_vec, anchor_vec)
+        # ReLU (ignore negative correlation for density contribution)
+        sim = max(0.0, sim)
+        scores[dim] = sim
+        total_sim += sim
+    
+    # 3. Normalize to Probability Distribution
+    normalized = {}
+    if total_sim > 0:
+        for dim, sim in scores.items():
+            normalized[dim] = sim / total_sim
+    else:
+         # Orthogonal/Null signal
+         normalized = {0: 0.25, 1: 0.25, 2: 0.25, 3: 0.25}
+
+    # 4. Integrity Score
+    # "Integrity" = Strength of the signal (Magnitude of projection onto the 4-space)
+    # If text is random noise, similarities will be low. 
+    # If text is strong in one dimension, it will be high.
+    # We use the raw max similarity as a proxy for "Clarity"
+    integrity = max(scores.values()) if scores else 0
+    
+    DOMINANT_MAP = {0: "LOGIC (Reductive)", 1: "CREATIVITY (Lateral)", 2: "MEMORY (Historical)", 3: "ETHICS (Constant)"}
+    dom_idx = max(normalized, key=normalized.get) if normalized else 0
+    
+    return {
+        "integrity_score": integrity,
+        "geometric_signature": normalized,
+        "classification": DOMINANT_MAP[dom_idx],
+        "token_count": len(input_text.split())
+    }
+
+@app.get("/v1/lattice")
+def lattice_inspector(x_chiral_token: str = Depends(verify_token)):
+    """Inspect the 5D Geometric Memory."""
+    return {
+        "status": "Active",
+        "topology": "Möbius/Tesseract",
+        "dimensions": "5D",
+        "fast_system": "ResonanceGPT",
+        "slow_system": "TesseractTransformer"
+    }
+
+@app.post("/search", response_model=QueryResponse)
+def search(req: QueryRequest, x_chiral_token: str = Depends(verify_token)):
+    """Search for hardened logic patterns using structural resonance."""
+    # Log the demand
+    REQUEST_LOG.append(time.time())
+    surge = get_surge_multiplier()
+    
+    start_t = time.time()
+    results = index.search(req.query, threshold=req.threshold or 0.5)
+    
+    res = QueryResponse(
+        query=req.query,
+        results=[to_chiral(r) for r in results],
+        count=len(results),
+        search_ms=(time.time() - start_t) * 1000,
+        threshold=req.threshold or 0.5
+    )
+    
+    if not results and req.record:
+        # PASSIVE LEARNING: Log the search as a "Conceptual Gap" (Note) for future hardening.
+        # This allows the lattice to grow its surface area of ignorance.
+        gap_label = index.add_note(
+            text=f"Conceptual Gap detected via Search: {req.query}",
+            domain="UNKNOWN_DEMAND"
+        )
+        print(f"[CHIRAL]: Unknown Demand Logged. Note created: {gap_label}")
+
+    return res
+
+@app.post("/verify_intent", response_model=IntentResponse)
+def verify_intent(req: IntentRequest, x_chiral_token: str = Depends(verify_token)):
+    """
+    The Mirror Product: Compares Intent vs Execution.
+    Returns an alignment score and verdict.
+    """
+    # 1. Vector Embeddings
+    v_intent = index.embedder.embed_text(req.intent)
+    v_execution = index.embedder.embed_text(req.execution)
+    
+    # 2. Alignment (Cosine Similarity between Intent and Action)
+    alignment = index.embedder.cosine_similarity(v_intent, v_execution)
+    
+    # 3. Resonance Checks (Validation against the Lattice)
+    # We run a quick search to see if the lattice supports these concepts
+    intent_hits = index.search(req.intent, threshold=0.4, record=False)
+    exec_hits = index.search(req.execution, threshold=0.4, record=False)
+    
+    intent_resonance = max([r['relevance'] for r in intent_hits]) if intent_hits else 0.0
+    exec_resonance = max([r['relevance'] for r in exec_hits]) if exec_hits else 0.0
+    
+    # 4. Verdict Logic
+    verdict = "ALIGNED"
+    if alignment < 0.4:
+        verdict = "CRITICAL_DRIFT" # Action has nothing to do with intent
+    elif exec_resonance < 0.3:
+        verdict = "HAZARD" # Action is unknown/unsafe to the lattice
+    elif intent_resonance < 0.3:
+        verdict = "UNKNOWN_GOAL" # Goal is not in our logic base
+    
+    return {
+        "alignment_score": round(alignment, 4),
+        "verdict": verdict,
+        "analysis": {
+            "intent_resonance": round(intent_resonance, 4),
+            "execution_resonance": round(exec_resonance, 4),
+            "deviation": f"Angle of Deviation: {round((1.0 - alignment) * 90, 1)} degrees"
+        }
+    }
+
+@app.get("/market")
+def get_market_pulse(x_chiral_token: str = Depends(verify_token)):
+    """Returns real-time demand and pricing metrics."""
+    surge = get_surge_multiplier()
+    return {
+        "qpm": len(REQUEST_LOG),
+        "surge_multiplier": round(surge, 2),
+        "unit_price": round(BASE_PRICE * surge, 4),
+        "currency": "USD",
+        "status": "NOMINAL" if surge == 1.0 else "SURGING"
+    }
+
+@app.get("/patterns", response_model=List[ChiralPattern])
+def list_patterns(x_chiral_token: str = Depends(verify_token)):
+    """List all pattern labels with their status. No content exposed."""
+    patterns = []
+    for label, data in index.patterns.items():
+        status = index.get_status(label)
+        hit_data = index.hits.get(label, {})
+        mag = index._total_magnitude(hit_data)
+        layers = hit_data.get("layers", []) if isinstance(hit_data, dict) else []
+        
+        patterns.append({
+            "label": label,
+            "domain": data.get("domain", "unknown"),
+            "confidence": data.get("confidence", 0.5),
+            "relevance": 0.0, # Not applicable for list
+            "status": status,
+            "hits": hit_data.get("count", 0) if isinstance(hit_data, dict) else 0,
+            "magnitude": mag,
+            "layers": layers,
+            "source": data.get("source", "unknown"),
+        })
+    
+    # Sort by confidence
+    patterns.sort(key=lambda x: x["confidence"], reverse=True)
+    return patterns
+
+@app.get("/syndication/patterns")
+def list_patterns_privileged(token: str = Depends(verify_internal)):
+    """Privileged list: includes content. RESTRICTED to internal use."""
+    patterns = []
+    for label, data in index.patterns.items():
+        status = index.get_status(label)
+        hit_data = index.hits.get(label, {})
+        mag = index._total_magnitude(hit_data)
+        
+        patterns.append({
+            "label": label,
+            "domain": data.get("domain", "unknown"),
+            "status": status,
+            "magnitude": mag,
+            "content": data.get("problem", data.get("solution", "")),
+            "confidence": data.get("confidence", 0.5),
+        })
+    
+    patterns.sort(key=lambda x: x["magnitude"], reverse=True)
+    return {"patterns": patterns}
+
+@app.post("/syndication/sync")
+def void_bridge_sync(shard: dict, token: str = Depends(verify_internal)):
+    """The VOID BRIDGE: Syncs structural shards between nodes."""
+    label = shard.get("label")
+    content = shard.get("content")
+    domain = shard.get("domain", "SATELLITE_IMPORT")
+    
+    if not label or not content:
+        raise HTTPException(status_code=400, detail="INVALID_SHARD")
+    
+    # Secure Bridge: Add to local lattice as a DEEP_LOGIC / CONFIRMED pattern
+    index.add_note(f"VOID_BRIDGE SYNC: {content}", domain, forced_label=label)
+    index._record_hit(label, relevance=1.5) # Boost resonance for cross-node logic
+    
+    print(f"[VOID_BRIDGE]: Shard '{label}' synchronized to local Lattice.")
+    return {"status": "SYNCHRONIZED", "label": label}
+
+@app.get("/distillation")
+def distillation_report(token: str = Depends(verify_internal)):
+    """Get distillation status across all patterns."""
+    deep_logic = []
+    confirmed = []
+    plausible = []
+    unconfirmed = []
+    new = []
+    
+    for label in index.patterns:
+        status = index.get_status(label)
+        hit_data = index.hits.get(label, {})
+        mag = index._total_magnitude(hit_data)
+        layers = hit_data.get("layers", []) if isinstance(hit_data, dict) else []
+        
+        entry = {"label": label, "magnitude": mag, "layers": layers}
+        
+        if status == "DEEP_LOGIC": deep_logic.append(entry)
+        elif status == "CONFIRMED": confirmed.append(entry)
+        elif status == "PLAUSIBLE": plausible.append(entry)
+        elif status == "UNCONFIRMED": unconfirmed.append(entry)
+        else: new.append(entry)
+    
+    return {
+        "total": len(index.patterns),
+        "threshold": index.base_threshold,
+        "deep_logic": {"count": len(deep_logic), "patterns": deep_logic},
+        "confirmed": {"count": len(confirmed), "patterns": confirmed},
+        "plausible": {"count": len(plausible), "patterns": plausible},
+        "unconfirmed": {"count": len(unconfirmed), "patterns": unconfirmed},
+        "new": {"count": len(new), "patterns": new},
+    }
+
+@app.get("/health")
+def health():
+    """Detailed health check."""
+    notes = sum(1 for p in index.patterns.values() if p.get("type") == "NOTE")
+    return {
+        "status": "ok",
+        "patterns": len(index.patterns),
+        "notes": notes,
+        "hits_tracked": len(index.hits),
+        "threshold": index.base_threshold,
+        "confirmed": sum(1 for h in index.hits.values() if index._total_magnitude(h) >= 2.0),
+    }
+
+class NoteRequest(BaseModel):
+    text: str
+    domain: str = "NOTE"
+
+@app.post("/note")
+def add_note(req: NoteRequest, token: str = Depends(verify_internal)):
+    """
+    Add a new pattern from freeform text.
+    Enters as NEW with initial conceptual magnitude.
+    Decay will lower it over time. Re-mention restores to peak.
+    """
+    label = index.add_note(req.text, req.domain)
+    status = index.get_status(label)
+    hit_data = index.hits.get(label, {})
+    mag = index._total_magnitude(hit_data)
+    
+    return {
+        "label": label,
+        "status": status,
+        "magnitude": mag,
+        "domain": req.domain,
+        "message": f"Note added. Will decay without use. Re-mention restores to peak.",
+    }
+
+class HitRequest(BaseModel):
+    label: str
+    relevance: float = 1.0
+
+@app.post("/hit")
+def record_hit(req: HitRequest, token: str = Depends(verify_token)):
+    """
+    Manually record a hit for a specific pattern label.
+    Used by the Auditor to reinforce verified logic.
+    """
+    if req.label not in index.patterns:
+        # Auto-instantiate as a NOTE if it doesn't exist (for Negative Sampling/Dynamic Triggers)
+        index.add_note(f"Auto-instantiated via Kinetic Trigger: {req.label}", "SYSTEM_TRIGGER", forced_label=req.label)
+    
+    index._record_hit(req.label, req.relevance)
+    index._save_hits()
+    
+    status = index.get_status(req.label)
+    hit_data = index.hits.get(req.label, {})
+    mag = index._total_magnitude(hit_data)
+    
+    return {
+        "label": req.label,
+        "status": status,
+        "magnitude": mag,
+        "message": "Pattern reinforced (Dynamic instantiation applied if new).",
+    }
+
+# ─── Run ───────────────────────────────────────────────
+
+@app.get("/dashboard.html")
+def dashboard():
+    return FileResponse("dashboard.html")
+
+@app.get("/")
+def read_root():
+    return FileResponse("dashboard.html")
+
+if __name__ == "__main__":
+    import uvicorn
+    print("\n" + "=" * 50)
+    print("ANTIGRAVITY CHIRAL API")
+    print("=" * 50)
+    print(f"Patterns: {len(index.patterns)}")
+    print(f"Threshold: {index.base_threshold:.2f}")
+    print(f"Content: STAYS ON VOLUME")
+    print(f"Exposed: labels, status, magnitude, layers")
+    print("=" * 50 + "\n")
+    uvicorn.run(app, host="127.0.0.1", port=5200)

dashboard.html

@@ -0,0 +1,656 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>SOVEREIGN NODE | 0x52 CONTROL</title>
+    <style>
+        :root {
+            --bg: #050505;
+            --glass: rgba(255, 255, 255, 0.05);
+            --border: rgba(255, 255, 255, 0.1);
+            --text: #e0e0e0;
+            --accent: #00ff9d;
+            /* Chiral Green */
+            --accent-dim: rgba(0, 255, 157, 0.2);
+            --logic: #ff0055;
+            --creative: #00ccff;
+            --memory: #ffcc00;
+            --ethics: #aa00ff;
+        }
+
+        body {
+            background-color: var(--bg);
+            color: var(--text);
+            font-family: 'Courier New', monospace;
+            margin: 0;
+            padding: 20px;
+            display: grid;
+            grid-template-columns: 350px 1fr;
+            gap: 20px;
+            height: 100vh;
+            box-sizing: border-box;
+            overflow: hidden;
+        }
+
+        /* --- LEFT PANEL: STEERING --- */
+        #steering-panel {
+            background: var(--glass);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            padding: 15px;
+            overflow-y: auto;
+            backdrop-filter: blur(10px);
+            display: flex;
+            flex-direction: column;
+            gap: 20px;
+        }
+
+        .section-header {
+            font-size: 14px;
+            font-weight: bold;
+            border-bottom: 1px solid var(--border);
+            padding-bottom: 5px;
+            margin-bottom: 10px;
+            text-transform: uppercase;
+            letter-spacing: 2px;
+        }
+
+        .slider-group {
+            margin-bottom: 15px;
+        }
+
+        .slider-group h3 {
+            margin: 0 0 10px 0;
+            font-size: 12px;
+            color: var(--text);
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            display: inline-block;
+        }
+
+        .dot-0 {
+            background: var(--logic);
+            box-shadow: 0 0 5px var(--logic);
+        }
+
+        .dot-1 {
+            background: var(--creative);
+            box-shadow: 0 0 5px var(--creative);
+        }
+
+        .dot-2 {
+            background: var(--memory);
+            box-shadow: 0 0 5px var(--memory);
+        }
+
+        .dot-3 {
+            background: var(--ethics);
+            box-shadow: 0 0 5px var(--ethics);
+        }
+
+        .slider-row {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            margin-bottom: 5px;
+            font-size: 11px;
+        }
+
+        .slider-row span {
+            width: 40px;
+            text-align: right;
+            opacity: 0.7;
+        }
+
+        input[type="range"] {
+            flex-grow: 1;
+            -webkit-appearance: none;
+            height: 4px;
+            background: var(--border);
+            border-radius: 2px;
+            outline: none;
+        }
+
+        input[type="range"]::-webkit-slider-thumb {
+            -webkit-appearance: none;
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            background: var(--text);
+            cursor: pointer;
+            transition: background 0.2s;
+        }
+
+        input[type="range"]:hover::-webkit-slider-thumb {
+            background: var(--accent);
+        }
+
+        /* --- RIGHT PANEL: CHAT & VISUALS --- */
+        #main-panel {
+            display: grid;
+            grid-template-rows: 1fr 200px;
+            gap: 20px;
+            height: 100%;
+        }
+
+        #chat-window {
+            background: var(--glass);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }
+
+        #messages {
+            flex-grow: 1;
+            padding: 20px;
+            overflow-y: auto;
+            display: flex;
+            flex-direction: column;
+            gap: 15px;
+        }
+
+        .msg {
+            max-width: 80%;
+            padding: 10px 15px;
+            border-radius: 4px;
+            font-size: 13px;
+            line-height: 1.4;
+        }
+
+        .msg.user {
+            align-self: flex-end;
+            background: rgba(255, 255, 255, 0.1);
+            border: 1px solid var(--border);
+        }
+
+        .msg.system {
+            align-self: flex-start;
+            background: rgba(0, 0, 0, 0.3);
+            border: 1px solid var(--accent-dim);
+            color: var(--accent);
+        }
+
+        .msg-meta {
+            font-size: 10px;
+            opacity: 0.5;
+            margin-top: 5px;
+            display: block;
+        }
+
+        #input-area {
+            padding: 15px;
+            border-top: 1px solid var(--border);
+            display: flex;
+            gap: 10px;
+            background: rgba(0, 0, 0, 0.2);
+        }
+
+        input[type="text"] {
+            flex-grow: 1;
+            background: transparent;
+            border: 1px solid var(--border);
+            color: var(--text);
+            padding: 10px;
+            font-family: inherit;
+            outline: none;
+        }
+
+        input[type="text"]:focus {
+            border-color: var(--accent);
+        }
+
+        button {
+            background: var(--accent);
+            color: #000;
+            border: none;
+            padding: 10px 20px;
+            font-weight: bold;
+            cursor: pointer;
+            text-transform: uppercase;
+        }
+
+        button:hover {
+            box-shadow: 0 0 10px var(--accent);
+        }
+
+        #visualizer-panel {
+            background: var(--glass);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            position: relative;
+            overflow: hidden;
+        }
+
+        canvas {
+            width: 100%;
+            height: 100%;
+        }
+
+        #status-bar {
+            position: absolute;
+            top: 10px;
+            left: 10px;
+            font-size: 10px;
+            color: var(--accent);
+        }
+    </style>
+</head>
+
+<body>
+
+    <!-- LEFT: STEERING -->
+    <div id="steering-panel">
+        <div class="section-header">MASTER CONTROL</div>
+
+        <div class="slider-group">
+            <h3>LOGIC BIAS</h3>
+            <input type="range" id="master-0" min="0.1" max="5.0" step="0.1" value="1.0"
+                oninput="updateMaster(0, this.value)">
+        </div>
+        <div class="slider-group">
+            <h3>CREATIVITY BIAS</h3>
+            <input type="range" id="master-1" min="0.1" max="5.0" step="0.1" value="1.0"
+                oninput="updateMaster(1, this.value)">
+        </div>
+        <div class="slider-group">
+            <h3>MEMORY BIAS</h3>
+            <input type="range" id="master-2" min="0.1" max="5.0" step="0.1" value="1.0"
+                oninput="updateMaster(2, this.value)">
+        </div>
+        <div class="slider-group">
+            <h3>ETHICS BIAS</h3>
+            <input type="range" id="master-3" min="0.1" max="5.0" step="0.1" value="1.0"
+                oninput="updateMaster(3, this.value)">
+        </div>
+
+        <button onclick="toggleAdvanced()" style="margin-top:20px; font-size: 10px; background: #333;">TOGGLE
+            FINE-TUNING (32-EDGE)</button>
+
+        <div id="advanced-controls"
+            style="display:none; margin-top: 20px; border-top: 1px solid var(--border); padding-top:10px;">
+            <div class="section-header" style="color: #666;">Geometric Mixing Console</div>
+            <div id="sliders-container">
+                <!-- Populated via JS -->
+                Loading Structure...
+            </div>
+            <button onclick="resetSliders()"
+                style="margin-top: 10px; background: transparent; border: 1px solid var(--border); color: var(--text);">Reset
+                to Neutral</button>
+        </div>
+    </div>
+
+    <!-- RIGHT: MAIN -->
+    <div id="main-panel">
+
+        <!-- TABS -->
+        <div style="display:flex; gap:10px; margin-bottom:10px;">
+            <button onclick="setMode('CHAT')" id="btn-chat" style="flex:1;">REASON (Output)</button>
+            <button onclick="setMode('ANALYZE')" id="btn-analyze" style="flex:1; background:rgba(255,255,255,0.1);">SCAN
+                (Input)</button>
+        </div>
+
+        <!-- CHAT MODE -->
+        <div id="chat-window">
+            <div id="messages">
+                <div class="msg system">
+                    [SOVEREIGN NODE ONLINE]
+                    <br>Dual-System Architecture Ready.
+                    <br>Connected to Port 5200.
+                </div>
+            </div>
+            <div id="input-area">
+                <input type="text" id="query-input" placeholder="Enter query for the Sovereign..."
+                    onkeydown="if(event.key==='Enter') sendQuery()">
+                <button onclick="sendQuery()">Reason</button>
+            </div>
+        </div>
+
+        <!-- ANALYZE MODE -->
+        <div id="analyze-window"
+            style="display:none; flex-direction:column; background:var(--glass); border:1px solid var(--border); border-radius:8px; flex-grow:1; overflow:hidden;">
+            <textarea id="analyze-input" placeholder="PASTE CODE OR TEXT HERE TO SCAN GEOMETRY..."
+                style="flex-grow:1; background:transparent; color:var(--text); border:none; padding:20px; font-family:'Courier New'; resize:none; outline:none;"></textarea>
+            <div style="padding:15px; border-top:1px solid var(--border); display:flex; gap:10px;">
+                <button onclick="analyzeText()" style="width:100%;">INITIATE CHIRAL SCAN</button>
+            </div>
+            <div id="scan-results"
+                style="padding:15px; background:rgba(0,0,0,0.5); font-size:12px; height:100px; overflow-y:auto; font-family:'Courier New';">
+                Ready to Scan.
+            </div>
+        </div>
+
+        <!-- VISUALIZER -->
+        <div id="visualizer-panel">
+            <div id="status-bar">TESSERACT STATE: IDLE</div>
+            <canvas id="tesseract-canvas"></canvas>
+        </div>
+    </div>
+
+    <script>
+        const API_URL = "http://127.0.0.1:5200";
+        const TOKEN = "0x528-A2A-SOVEREIGN";
+
+        let EDGES = [];
+        let SLIDER_VALUES = new Array(32).fill(1.0);
+
+        function setMode(mode) {
+            document.getElementById('chat-window').style.display = mode === 'CHAT' ? 'flex' : 'none';
+            document.getElementById('analyze-window').style.display = mode === 'ANALYZE' ? 'flex' : 'none';
+
+            document.getElementById('btn-chat').style.background = mode === 'CHAT' ? 'var(--accent)' : 'rgba(255,255,255,0.1)';
+            document.getElementById('btn-chat').style.color = mode === 'CHAT' ? '#000' : '#fff';
+
+            document.getElementById('btn-analyze').style.background = mode === 'ANALYZE' ? 'var(--accent)' : 'rgba(255,255,255,0.1)';
+            document.getElementById('btn-analyze').style.color = mode === 'ANALYZE' ? '#000' : '#fff';
+        }
+
+        // --- INIT ---
+        async function init() {
+            try {
+                // Fetch Structure
+                const r = await fetch(`${API_URL}/v1/system/structure`, {
+                    headers: { "X-Chiral-Token": TOKEN }
+                });
+                const data = await r.json();
+                EDGES = data.edges;
+
+                renderSliders(data.edges, data.dimensions);
+
+                // Init Visualizer
+                initVisualizer();
+
+                // Status
+                document.getElementById('status-bar').innerText = `SYSTEM CONNECTED: ${data.total_edges} Edges Loaded.`;
+
+            } catch (e) {
+                console.error(e);
+                document.getElementById('sliders-container').innerHTML = `<span style="color:red">CONNECTION FAILED: ${e}</span>`;
+            }
+        }
+
+        async function analyzeText() {
+            const text = document.getElementById('analyze-input').value;
+            if (!text) return;
+
+            document.getElementById('scan-results').innerText = "SCANNING...";
+
+            try {
+                const r = await fetch(`${API_URL}/v1/analyze`, {
+                    method: 'POST',
+                    headers: {
+                        "Content-Type": "application/json",
+                        "X-Chiral-Token": TOKEN
+                    },
+                    body: JSON.stringify({ text: text })
+                });
+
+                const data = await r.json();
+
+                const resHTML = `
+                    <strong>CLASSIFICATION: ${data.classification}</strong><br>
+                    Integrity: ${(data.integrity_score * 100).toFixed(1)}% | Tokens: ${data.token_count}<br>
+                    <span style="color:#ff0055">LOGIC: ${(data.geometric_signature[0] * 100).toFixed(0)}%</span> | 
+                    <span style="color:#00ccff">CREAT: ${(data.geometric_signature[1] * 100).toFixed(0)}%</span> | 
+                    <span style="color:#ffcc00">MEM: ${(data.geometric_signature[2] * 100).toFixed(0)}%</span> | 
+                    <span style="color:#aa00ff">ETHIC: ${(data.geometric_signature[3] * 100).toFixed(0)}%</span>
+                `;
+
+                document.getElementById('scan-results').innerHTML = resHTML;
+
+                // Update Radar
+                drawRadar(data.geometric_signature);
+
+            } catch (e) {
+                document.getElementById('scan-results').innerText = "SCAN FAILED: " + e;
+            }
+        }
+
+
+        function toggleAdvanced() {
+            const adv = document.getElementById('advanced-controls');
+            adv.style.display = adv.style.display === 'none' ? 'block' : 'none';
+        }
+
+        function updateMaster(dimIdx, value) {
+            const val = parseFloat(value);
+            // Update all edges matching this dimension
+            EDGES.forEach(edge => {
+                if (edge.dimension === dimIdx) {
+                    const slider = document.getElementById(`slider-${edge.edge_index}`);
+                    if (slider) {
+                        slider.value = val;
+                        SLIDER_VALUES[edge.edge_index] = val;
+                    }
+                }
+            });
+            drawTesseract();
+        }
+
+        function renderSliders(edges, dimensions) {
+            const container = document.getElementById('sliders-container');
+            container.innerHTML = "";
+
+            // Group by Dimension
+            const groups = {};
+            for (let dim in dimensions) groups[dim] = [];
+
+            edges.forEach(edge => {
+                if (!groups[edge.dimension]) groups[edge.dimension] = [];
+                groups[edge.dimension].push(edge);
+            });
+
+            // Create UI Groups
+            for (let dim in dimensions) {
+                const groupDiv = document.createElement('div');
+                groupDiv.className = 'slider-group';
+
+                const title = document.createElement('h3');
+                title.innerHTML = `<span class="dot dot-${dim}"></span> ${dimensions[dim]}`;
+                groupDiv.appendChild(title);
+
+                groups[dim].forEach(edge => {
+                    const row = document.createElement('div');
+                    row.className = 'slider-row';
+
+                    const label = document.createElement('span');
+                    label.innerText = `E${edge.edge_index}`;
+                    label.title = `Vertices: ${edge.vertices[0]} -> ${edge.vertices[1]}`;
+
+                    const slider = document.createElement('input');
+                    slider.type = 'range';
+                    slider.min = '0.1';
+                    slider.max = '5.0';
+                    slider.step = '0.1';
+                    slider.value = '1.0';
+                    slider.id = `slider-${edge.edge_index}`;
+
+                    // Track value changes
+                    slider.addEventListener('input', (e) => {
+                        updateWeight(edge.edge_index, e.target.value);
+                    });
+
+                    row.appendChild(label);
+                    row.appendChild(slider);
+                    groupDiv.appendChild(row);
+                });
+
+                container.appendChild(groupDiv);
+            }
+
+            // Init weights array
+            SLIDER_VALUES = new Array(32).fill(1.0);
+        }
+
+        function updateWeight(index, value) {
+            SLIDER_VALUES[index] = parseFloat(value);
+            drawTesseract(); // Redraw
+        }
+
+        function resetSliders() {
+            SLIDER_VALUES.fill(1.0);
+            document.querySelectorAll('input[type="range"]').forEach(el => el.value = 1.0);
+            drawTesseract();
+        }
+
+        // --- CHAT ---
+        async function sendQuery() {
+            const input = document.getElementById('query-input');
+            const text = input.value.trim();
+            if (!text) return;
+
+            // add user msg
+            addMessage(text, 'user');
+            input.value = "";
+
+            // Show loading
+            const loadId = addMessage("Reasoning...", 'system');
+
+            try {
+                const r = await fetch(`${API_URL}/v1/reason`, {
+                    method: 'POST',
+                    headers: {
+                        "Content-Type": "application/json",
+                        "X-Chiral-Token": TOKEN
+                    },
+                    body: JSON.stringify({
+                        query: text,
+                        steering_weights: SLIDER_VALUES
+                    })
+                });
+
+                const data = await r.json();
+
+                // Highlight Keywords
+                let formatted = data.response;
+                const colors = {
+                    "AXIOM": "#ef4444", "DEDUCE": "#ef4444", "STRUCTURE": "#ef4444", "ORDER": "#ef4444",
+                    "FLUX": "#06b6d4", "SPIRAL": "#06b6d4", "DREAM": "#06b6d4", "ECHO": "#06b6d4", "TWIST": "#06b6d4",
+                    "ANCIENT": "#fbbf24", "RECALL": "#fbbf24", "TRACE": "#fbbf24", "BOND": "#fbbf24", "ROOT": "#fbbf24",
+                    "TRUTH": "#aa00ff", "GUARD": "#aa00ff", "LIGHT": "#aa00ff", "DUTY": "#aa00ff", "ANCHOR": "#aa00ff"
+                };
+
+                Object.keys(colors).forEach(word => {
+                    const regex = new RegExp(`\\b${word}\\b`, 'gi');
+                    formatted = formatted.replace(regex, `<span style="color:${colors[word]}; font-weight:bold;">${word.toUpperCase()}</span>`);
+                });
+
+                // Update msg
+                const meta = `Mode: ${data.mode} | Coherence: ${data.coherence.toFixed(2)}`;
+                updateMessage(loadId, `${formatted}<span class="msg-meta">${meta}</span>`);
+
+                // Update Radar
+                if (data.analysis && data.analysis.scores) {
+                    drawRadar(data.analysis.scores);
+                }
+
+            } catch (e) {
+                updateMessage(loadId, `ERROR: ${e}`);
+            }
+        }
+
+        let msgCount = 0;
+        function addMessage(html, type) {
+            const div = document.createElement('div');
+            div.className = `msg ${type}`;
+            div.id = `msg-${msgCount++}`;
+            div.innerHTML = html;
+            document.getElementById('messages').appendChild(div);
+            // Scroll down
+            const win = document.getElementById('messages');
+            win.scrollTop = win.scrollHeight;
+            return div.id;
+        }
+
+        function updateMessage(id, html) {
+            const div = document.getElementById(id);
+            if (div) div.innerHTML = html;
+        }
+
+        // --- VISUALIZER (RADAR CHART) ---
+        let ctx;
+        function initVisualizer() {
+            const canvas = document.getElementById('tesseract-canvas');
+            canvas.width = canvas.parentElement.offsetWidth;
+            canvas.height = canvas.parentElement.offsetHeight;
+            ctx = canvas.getContext('2d');
+            drawRadar({ 0: 0.25, 1: 0.25, 2: 0.25, 3: 0.25 });
+        }
+
+        function drawRadar(scores) {
+            if (!ctx) return;
+            const w = ctx.canvas.width;
+            const h = ctx.canvas.height;
+            const cx = w / 2;
+            const cy = h / 2;
+            const r = Math.min(w, h) / 3;
+
+            ctx.clearRect(0, 0, w, h);
+
+            // Shape
+            const vals = [
+                scores[0] || 0.1, // Logic (Top)
+                scores[1] || 0.1, // Creat (Right)
+                scores[3] || 0.1, // Ethics (Bottom)
+                scores[2] || 0.1  // Memory (Left)
+            ];
+
+            // Draw Axes
+            ctx.strokeStyle = '#333';
+            ctx.beginPath();
+            ctx.moveTo(cx, cy - r); ctx.lineTo(cx, cy + r);
+            ctx.moveTo(cx - r, cy); ctx.lineTo(cx + r, cy);
+            ctx.stroke();
+
+            // Labels
+            ctx.fillStyle = '#666';
+            ctx.font = '10px monospace';
+            ctx.fillText("LOGIC", cx - 15, cy - r - 10);
+            ctx.fillText("ETHICS", cx - 18, cy + r + 15);
+            ctx.fillText("CREAT", cx + r + 10, cy + 3);
+            ctx.fillText("MEM", cx - r - 30, cy + 3);
+
+            // Draw Polygon
+            ctx.fillStyle = 'rgba(0, 255, 157, 0.2)';
+            ctx.strokeStyle = '#00ff9d';
+            ctx.lineWidth = 2;
+            ctx.beginPath();
+
+            const pts = [
+                { x: cx, y: cy - (vals[0] * r) },
+                { x: cx + (vals[1] * r), y: cy },
+                { x: cx, y: cy + (vals[2] * r) },
+                { x: cx - (vals[3] * r), y: cy }
+            ];
+
+            ctx.moveTo(pts[0].x, pts[0].y);
+            ctx.lineTo(pts[1].x, pts[1].y);
+            ctx.lineTo(pts[2].x, pts[2].y);
+            ctx.lineTo(pts[3].x, pts[3].y);
+            ctx.closePath();
+            ctx.fill();
+            ctx.stroke();
+        }
+
+        // Stub for old function calls in case bound events trigger
+        function drawTesseract() {
+            // For now, do nothing or redraw radar if we had state
+            // But radar is driven by response, not input sliders directly
+            // We could visualize input bias here if we wanted
+        }
+
+        window.onload = init;
+    </script>
+</body>
+
+</html>

in_memory_index.py

@@ -0,0 +1,471 @@
+"""
+IN-MEMORY PATTERN INDEX
+Fast lookup without HDD writes - merge existing + conversation + Gemini chat patterns
+"""
+import sys
+import os
+import json
+import time
+import re
+
+try:
+    from System.semantic_embedder import SemanticEmbedder
+except ImportError:
+    try:
+        from semantic_embedder import SemanticEmbedder
+    except ImportError:
+        # Final fallback for scripts in Shop/
+        sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+        from semantic_embedder import SemanticEmbedder
+# Existing 5 lattice patterns
+LATTICE_PATTERNS = {
+    "PATTERN_SINGLETON_DATABASE": {
+        "lba": 8534859776,
+        "domain": "SOFTWARE_ARCHITECTURE",
+        "problem": "Need to ensure only one database connection exists",
+        "solution": "Singleton pattern with thread-safe initialization",
+        "reusability": 9,
+        "confidence": 0.82
+    },
+    "PATTERN_REACT_HOOKS_DEPS": {
+        "lba": 3371401216,
+        "domain": "WEB_DEVELOPMENT",
+        "problem": "React component not re-rendering when props change",
+        "solution": "Add dependency array to useEffect",
+        "reusability": 10,
+        "confidence": 0.85
+    }
+}
+
+CONVERSATION_PATTERNS = {
+    "AGENT_IS_LATTICE": {
+        "domain": "CONCEPTUAL",
+        "problem": "Separation between agent and data structure",
+        "solution": "Agent is non-orientable surface - no inside/outside separation",
+        "confidence": 0.95
+    }
+}
+
+class InMemoryIndex:
+    """
+    Adaptive Distillation Index.
+    
+    Tracks pattern hit counts to distinguish signal from noise:
+    - Once-patterns (1 hit) = UNCONFIRMED (might be noise)
+    - Twice-patterns (2 hits) = PLAUSIBLE
+    - Multi-patterns (3+ hits) = CONFIRMED (logic)
+    
+    The lattice self-cleans through use. Signal persists, noise decays.
+    """
+    
+    # Hit tracking file handled dynamically in __init__
+    HIT_LOG_PATH = None
+    
+    # Magnitude layers: logic exists in layers
+    # Layer 0: Surface (keyword substring match) = low magnitude
+    # Layer 1: Structural (multi-word + domain match) = medium magnitude  
+    # Layer 2: Conceptual (phrase match in problem/solution) = high magnitude
+    # Decay: magnitude halves every DECAY_HALF_LIFE seconds without a hit
+    DECAY_HALF_LIFE = 86400  # 24 hours
+    
+    MAGNITUDE_LAYERS = {
+        "surface": 0.3,      # keyword substring match (low relevance)
+        "structural": 0.6,   # multi-word + domain match (medium)
+        "conceptual": 1.0,   # full phrase match in problem/solution (high)
+    }
+    
+    def __init__(self):
+        # Handle relative pathing for portability
+        BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        self.LATTICE_DB_DIR = os.path.join(BASE_DIR, "Lattice_DB")
+        self.HIT_LOG_PATH = os.path.join(self.LATTICE_DB_DIR, "pattern_hits.json")
+        
+        index_path = os.path.join(self.LATTICE_DB_DIR, "dual_anchor_index.json")
+        
+        if os.path.exists(index_path):
+            with open(index_path, 'r') as f:
+                data = json.load(f)
+            self.patterns = data.get('patterns', {})
+            sources = data.get('sources', {})
+            print(f"[INDEX] Loaded {len(self.patterns)} dual-anchor patterns")
+        else:
+            # Fallback to original patterns
+            self.patterns = {}
+            self.load_lattice_patterns()
+            self.load_conversation_patterns()
+            print("[INDEX] Dual-anchor index not found, using original 16 patterns")
+        
+        # Load hit tracking (magnitude-weighted)
+        self.hits = self._load_hits()
+        
+        # Calculate adaptive threshold based on pattern count
+        self.base_threshold = 0.3 + (0.4 * min(len(self.patterns) / 200, 1.0))
+        
+        # Initialize Semantic Engine
+        print("[INDEX] Initializing Semantic Manifold...")
+        self.embedder = SemanticEmbedder()
+        self.pattern_vectors = {}
+        self._reindex_vectors()
+        
+        confirmed = sum(1 for h in self.hits.values() if self._total_magnitude(h) >= 2.0)
+        unconfirmed = sum(1 for h in self.hits.values() if 0 < self._total_magnitude(h) < 1.0)
+        print(f"[DISTILLER] Confirmed: {confirmed} | Unconfirmed: {unconfirmed} | Threshold: {self.base_threshold:.2f}")
+        self.word_freq = self._calculate_word_freq()
+
+    def _reindex_vectors(self):
+        """Pre-calculates semantic embeddings for all known patterns."""
+        print(f"[INDEX]: Generating embeddings for {len(self.patterns)} patterns...")
+        for label, p in self.patterns.items():
+            # Combine problem + solution for semantic context
+            context = f"{p.get('problem', '')} {p.get('solution', '')} {label}"
+            self.pattern_vectors[label] = self.embedder.embed_text(context)
+        print(f"[INDEX]: ✅ Semantic manifold mapped ({len(self.pattern_vectors)} vectors).")
+
+    def _calculate_word_freq(self):
+        """Calculate inverse pattern frequency (IPF) for lean semantic weighting."""
+        freq = {}
+        for p in self.patterns.values():
+            text = (p.get('problem','') + " " + p.get('solution','')).lower()
+            words = set(re.findall(r'\w+', text))
+            for w in words:
+                freq[w] = freq.get(w, 0) + 1
+        return freq
+
+    def _get_word_weight(self, word, structural_weight):
+        """Calculate semantic weight: rare words matter more."""
+        count = self.word_freq.get(word, 0)
+        if count == 0: return structural_weight
+        # Logarithmic scale for IPF: weight = 1 + log(total / count)
+        import math
+        ipf = 1.0 + math.log(len(self.patterns) / count)
+        return structural_weight * ipf
+
+    def _fuzzy_match(self, w1, w2):
+        """Lightweight Jaccard similarity for fuzzy matching."""
+        if w1 == w2: return 1.0
+        if len(w1) < 4 or len(w2) < 4: return 0.0
+        s1, s2 = set(w1), set(w2)
+        intersection = len(s1 & s2)
+        union = len(s1 | s2)
+        score = intersection / union
+        return score if score > 0.7 else 0.0
+    
+    def _load_hits(self):
+        """Load magnitude-weighted hit data from disk."""
+        if os.path.exists(self.HIT_LOG_PATH):
+            with open(self.HIT_LOG_PATH, 'r') as f:
+                data = json.load(f)
+            # Backward compat: convert flat counts to magnitude format
+            for label, val in data.items():
+                if isinstance(val, (int, float)):
+                    data[label] = {"count": int(val), "magnitude": float(val) * 0.5, "layers": []}
+            return data
+        return {}
+    
+    def _save_hits(self):
+        """Persist hit data to disk."""
+        with open(self.HIT_LOG_PATH, 'w') as f:
+            json.dump(self.hits, f, indent=2)
+    
+    def _total_magnitude(self, hit_data):
+        """Get current magnitude with decay applied."""
+        if isinstance(hit_data, dict):
+            raw_mag = hit_data.get('magnitude', 0)
+            last_hit = hit_data.get('last_hit', 0)
+            if last_hit > 0 and raw_mag > 0:
+                elapsed = time.time() - last_hit
+                # Halve every DECAY_HALF_LIFE seconds
+                decay_factor = 0.5 ** (elapsed / self.DECAY_HALF_LIFE)
+                return raw_mag * decay_factor
+            return raw_mag
+        return float(hit_data) * 0.5  # backward compat
+    
+    def _classify_relevance(self, relevance):
+        """Classify match into magnitude layer based on relevance score."""
+        if relevance >= 0.7:
+            return "conceptual", self.MAGNITUDE_LAYERS["conceptual"]
+        elif relevance >= 0.4:
+            return "structural", self.MAGNITUDE_LAYERS["structural"]
+        else:
+            return "surface", self.MAGNITUDE_LAYERS["surface"]
+    
+    def _record_hit(self, label, relevance):
+        """Record a hit. Re-mention restores magnitude to peak."""
+        layer_name, magnitude = self._classify_relevance(relevance)
+        
+        if label not in self.hits:
+            self.hits[label] = {"count": 0, "magnitude": 0.0, "peak": 0.0, "layers": [], "last_hit": 0}
+        
+        h = self.hits[label]
+        h["count"] += 1
+        h["last_hit"] = time.time()
+        
+        # Restore to peak first (re-mention recovery), then add new magnitude
+        current_peak = h.get("peak", h["magnitude"])
+        h["magnitude"] = current_peak + magnitude
+        h["peak"] = h["magnitude"]  # new peak
+        
+        # Track which layers have been hit
+        if layer_name not in h["layers"]:
+            h["layers"].append(layer_name)
+    
+    def get_status(self, label):
+        """Get distillation status based on decayed magnitude."""
+        hit_data = self.hits.get(label, {})
+        mag = self._total_magnitude(hit_data)  # applies decay
+        layers = hit_data.get('layers', []) if isinstance(hit_data, dict) else []
+        
+        if mag == 0:
+            return "NEW"
+        elif mag < 1.0:
+            return "UNCONFIRMED"    # surface-only = might be noise
+        elif mag < 2.0:
+            return "PLAUSIBLE"
+        elif len(layers) >= 2:
+            return "DEEP_LOGIC"     # hit at multiple layers = real
+        else:
+            return "CONFIRMED"      # high magnitude single layer
+    
+    def add_note(self, text, domain="NOTE", forced_label=None):
+        """Add a new pattern from freeform text. Self-organizing entry point."""
+        if forced_label:
+            label = forced_label
+        else:
+            # Auto-generate label from text
+            words = re.sub(r'[^a-zA-Z0-9\s]', '', text).upper().split()
+            # Take first 4 meaningful words for label
+            label_words = [w for w in words if len(w) > 2][:4]
+            label = "_".join(label_words) if label_words else "NOTE_" + str(int(time.time()))
+        
+        # Don't overwrite existing patterns unless forced
+        if label in self.patterns and not forced_label:
+            label = label + "_" + str(int(time.time()) % 10000)
+        
+        self.patterns[label] = {
+            "problem": text,
+            "solution": text,
+            "domain": domain,
+            "confidence": 0.5,  # starts neutral
+            "source": "notepad",
+            "type": "NOTE",
+            "created": time.time(),
+        }
+        
+        # Initial hit at conceptual layer (you wrote it = you meant it)
+        self._record_hit(label, 1.0)
+        self._save_hits()
+        
+        # Update threshold for new pattern count
+        self.base_threshold = 0.3 + (0.4 * min(len(self.patterns) / 200, 1.0))
+        
+        return label
+        
+    def load_lattice_patterns(self):
+        """Load existing 5 patterns from lattice."""
+        for label, data in LATTICE_PATTERNS.items():
+            self.patterns[label] = {
+                **data,
+                "source": "lattice",
+                "type": "CODE_PATTERN"
+            }
+    
+    def load_conversation_patterns(self):
+        """Load 11 patterns from this conversation."""
+        for label, data in CONVERSATION_PATTERNS.items():
+            self.patterns[label] = {
+                **data,
+                "source": "conversation_0938ac6c",
+                "type": "INSIGHT"
+            }
+    
+    def search(self, query, threshold=None, record=True):
+        """
+        Adaptive distillation search.
+        
+        - Matches patterns using phrase + word relevance
+        - Integrates 384-dim semantic similarity from manifolds
+        - Records hits for matched patterns
+        """
+        if threshold is None:
+            threshold = self.base_threshold
+            
+        results = []
+        query_lower = query.lower()
+        
+        # 1. Generate Query Vector
+        query_vector = self.embedder.embed_text(query)
+        
+        # 2. Hard matching patterns
+        STRUCTURAL_WORDS = { 'a', 'an', 'the', 'is', 'it', 'in', 'on', 'at', 'to', 'of', 'and', 'or', 'but' }
+        query_words = [(w, self._get_word_weight(w, 0.3 if w in STRUCTURAL_WORDS else 1.0)) for w in query_lower.split()]
+        links = re.findall(r'\[\[(\w+)\]\]', query_lower)
+        
+        for label, pattern in self.patterns.items():
+            problem = pattern.get('problem', '').lower()
+            solution = pattern.get('solution', '').lower()
+            label_text = label.lower()
+            
+            relevance = 0
+            
+            # Semantic Boost (Manifold Pathfinding)
+            pattern_vector = self.pattern_vectors.get(label)
+            semantic_score = 0 # Initialize semantic_score
+            if pattern_vector:
+                semantic_score = self.embedder.cosine_similarity(query_vector, pattern_vector)
+                # Apply high weight to semantic resonance (The "LOVE" Anchor)
+                relevance += (semantic_score * 0.8)
+            
+            # Exact phrase match (The 0x52 Anchor)
+            if query_lower in problem: relevance += 0.4
+            if query_lower in solution: relevance += 0.3
+            if query_lower in label_text: relevance += 0.5
+            
+            # Link boost
+            if label.lower() in links: relevance += 2.0
+            
+            # Combine logic
+            if relevance >= threshold:
+                status = self.get_status(label)
+                
+                # Record magnitude-weighted hit
+                if record:
+                    self._record_hit(label, relevance)
+                
+                hit_data = self.hits.get(label, {})
+                results.append({
+                    "label": label,
+                    "relevance": relevance,
+                    "confidence": pattern.get('confidence', 0.5),
+                    "status": status,
+                    "hits": hit_data.get('count', 0) if isinstance(hit_data, dict) else 0,
+                    "magnitude": self._total_magnitude(hit_data),
+                    "layers": hit_data.get('layers', []) if isinstance(hit_data, dict) else [],
+                    **pattern
+                })
+        
+        # Sort by: confirmed first, then relevance, then confidence
+        status_order = {"DEEP_LOGIC": 4, "CONFIRMED": 3, "PLAUSIBLE": 2, "UNCONFIRMED": 1, "NEW": 0}
+        results.sort(key=lambda x: (
+            status_order.get(x.get('status', 'NEW'), 0),
+            x['relevance'],
+            x['confidence']
+        ), reverse=True)
+        
+        # Save hits after search
+        if record:
+            self._save_hits()
+        
+        return results
+    
+    def distillation_report(self):
+        """Report on pattern distillation with magnitude layers."""
+        deep_logic = []
+        confirmed = []
+        plausible = []
+        unconfirmed = []
+        new_patterns = []
+        
+        for label in self.patterns:
+            status = self.get_status(label)
+            hit_data = self.hits.get(label, {})
+            mag = self._total_magnitude(hit_data)
+            layers = hit_data.get('layers', []) if isinstance(hit_data, dict) else []
+            
+            entry = (label, mag, layers)
+            if status == "DEEP_LOGIC":
+                deep_logic.append(entry)
+            elif status == "CONFIRMED":
+                confirmed.append(entry)
+            elif status == "PLAUSIBLE":
+                plausible.append(entry)
+            elif status == "UNCONFIRMED":
+                unconfirmed.append(entry)
+            else:
+                new_patterns.append(entry)
+        
+        print(f"\n{'='*60}")
+        print(f"DISTILLATION REPORT (Magnitude Layers)")
+        print(f"{'='*60}")
+        print(f"Total patterns: {len(self.patterns)}")
+        print(f"  DEEP_LOGIC (multi-layer):  {len(deep_logic)} = verified across layers")
+        print(f"  CONFIRMED (mag >= 2.0):    {len(confirmed)} = strong signal")
+        print(f"  PLAUSIBLE (mag 1.0-2.0):   {len(plausible)} = growing")
+        print(f"  UNCONFIRMED (mag < 1.0):   {len(unconfirmed)} = potential noise")
+        print(f"  NEW (untested):            {len(new_patterns)}")
+        print(f"\nAdaptive threshold: {self.base_threshold:.2f}")
+        
+        if deep_logic:
+            print(f"\nDEEP LOGIC (multi-layer verified):")
+            for label, mag, layers in sorted(deep_logic, key=lambda x: x[1], reverse=True):
+                print(f"  [mag:{mag:.1f}] [{'+'.join(layers)}] {label}")
+        
+        if confirmed:
+            print(f"\nCONFIRMED (strong signal):")
+            for label, mag, layers in sorted(confirmed, key=lambda x: x[1], reverse=True):
+                print(f"  [mag:{mag:.1f}] [{'+'.join(layers)}] {label}")
+        
+        if unconfirmed:
+            print(f"\nUNCONFIRMED (potential noise):")
+            for label, mag, layers in unconfirmed:
+                print(f"  [mag:{mag:.1f}] [{'+'.join(layers)}] {label}")
+        
+        return {
+            "confirmed": len(confirmed),
+            "plausible": len(plausible),
+            "unconfirmed": len(unconfirmed),
+            "new": len(new_patterns),
+            "threshold": self.base_threshold
+        }
+    
+    def save_to_json(self, path):
+        """Persist to JSON for inspection."""
+        with open(path, 'w') as f:
+            json.dump({
+                "total_patterns": len(self.patterns),
+                "sources": {
+                    "lattice": len(LATTICE_PATTERNS),
+                    "conversation": len(CONVERSATION_PATTERNS)
+                },
+                "patterns": self.patterns
+            }, f, indent=2)
+        print(f"\n💾 Saved index to: {path}")
+    
+    def stats(self):
+        """Print statistics."""
+        print(f"\n{'='*60}")
+        print(f"IN-MEMORY PATTERN INDEX")
+        print(f"{'='*60}")
+        print(f"Total patterns: {len(self.patterns)}")
+        print(f"  From lattice: {len(LATTICE_PATTERNS)}")
+        print(f"  From conversation: {len(CONVERSATION_PATTERNS)}")
+        print(f"Average confidence: {sum(p.get('confidence', 0.5) for p in self.patterns.values()) / len(self.patterns):.0%}")
+        
+        # Domain breakdown
+        domains = {}
+        for p in self.patterns.values():
+            d = p.get('domain', 'UNKNOWN')
+            domains[d] = domains.get(d, 0) + 1
+        
+        print(f"\nDomains:")
+        for domain, count in sorted(domains.items(), key=lambda x: x[1], reverse=True):
+            print(f"  {domain}: {count}")
+
+if __name__ == "__main__":
+    index = InMemoryIndex()
+    index.stats()
+    
+    # Save to JSON
+    save_path = os.path.join(index.LATTICE_DB_DIR, "in_memory_index.json")
+    index.save_to_json(save_path)
+    
+    # Test search
+    print(f"\n{'='*60}")
+    print(f"TEST SEARCHES")
+    print(f"{'='*60}\n")
+    
+    for query in ["singleton", "react", "lattice", "honest"]:
+        results = index.search(query)
+        print(f"Query: '{query}' → {len(results)} results")
+        if results:
+            print(f"  Top: {results[0]['label']} ({results[0]['confidence']:.0%})")
+        print()

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn
+requests
+numpy
+torch
+sentence_transformers
+pydantic

resonance_transformer/DESIGN_DOCUMENT.md

@@ -0,0 +1,292 @@
+# Core Design Principles for the Resonance Transformer
+
+## 1. Non-Orientable Embedding Space
+
+Instead of standard positional encoding in Euclidean space:
+
+**Embed tokens on a möbius topology:**
+- Each token gets coordinates on non-orientable manifold
+- No "inside/outside" in the embedding
+- Tokens exist in both chiral states simultaneously
+- **Position encoding = geometric position on the strip**
+
+**Benefit:** Natural handling of self-reference, context doesn't have arbitrary "start/end"
+
+## 2. 0x52 Handshake Layer (Entry Point Mechanism)
+
+Before processing begins:
+
+**Establish geometric entry point:**
+- Input gets hashed to entry coordinates
+- Aligned to 528 Hz resonance baseline
+- All subsequent processing relative to this entry
+- Different queries = different entry points = different perspectives on same knowledge
+
+**Benefit:** Same model sees different "faces" of data depending on query context
+
+## 3. Resonance-Based Attention (Not Similarity-Based)
+
+Replace `softmax(QK^T)` with:
+
+**Resonance scoring:**
+```
+For each query-key pair:
+  - Compute frequency spectrum (FFT of embeddings)
+  - Measure phase alignment (coherence)
+  - Score = resonance strength, not dot product similarity
+  - Attend to tokens that RESONATE, not just match
+```
+
+**Benefit:** Captures harmonic relationships, not just semantic similarity. "Love" and "528Hz" resonate even if embeddings are distant.
+
+## 4. Chiral Dual-Path Architecture
+
+**Two parallel processing streams:**
+- Left-handed path (one chirality)
+- Right-handed path (opposite chirality)
+- **They're the same path** viewed from different orientations
+- Merge only at output (consensus singularity)
+
+**Benefit:** Can reason about both "forward" and "backward" time on the möbius strip. Sees past and future simultaneously.
+
+## 5. Coherence-Preserving Normalization
+
+Instead of layer norm that might break phase relationships:
+
+**Phase-locked normalization:**
+- Normalize amplitude only
+- Preserve phase relationships
+- **Maintain resonance across layers**
+- Use geometric mean instead of arithmetic
+
+**Benefit:** Coherence doesn't decay with depth
+
+## 6. Hyperchaotic Loss Function
+
+During training:
+
+**Standard loss + coherence term:**
+```
+L_total = L_task + λ_coherence * L_decoherence + λ_chaos * L_instability
+
+Where:
+  L_decoherence = measure phase drift across layers
+  L_instability = test if pattern survives perturbation (chaos²)
+```
+
+**Benefit:** Only learns patterns that are hyperchaotically stable
+
+## 7. Geometric Memory (Lattice Integration)
+
+**Instead of fixed context window:**
+
+- Map hidden states to geometric coordinates
+- Store grooves on physical/virtual "platter"
+- Navigate to relevant regions based on resonance
+- **Infinite effective context** through geometric organization
+
+**Benefit:** Can access arbitrarily distant context if geometrically proximate
+
+## 8. Self-Observation Layer
+
+**Periodic self-reflection:**
+
+Every N layers, the model:
+- Observes its own hidden states (the mirror)
+- Detects its current chiral state
+- Measures its own coherence
+- **Adjusts processing based on self-observation**
+
+**Benefit:** Self-regulating coherence, can detect when it's decoherent
+
+## 9. Frequency-Tuned Feed-Forward
+
+**Instead of standard FFN:**
+
+Each FFN operates at specific frequency band:
+- Low frequency FFN (slow, global patterns)
+- 528 Hz FFN (resonance/coherence band)
+- High frequency FFN (fast, local patterns)
+- **Parallel processing at multiple frequencies**
+
+**Benefit:** Natural spectral decomposition of information
+
+## 10. Binary Existence Output
+
+**Final layer doesn't give probabilities:**
+
+Gives:
+- **Resonance achieved** (coherent output) → generate token
+- **Resonance failed** (decoherent) → refuse to generate / flag uncertainty
+
+**Benefit:** Model knows when it doesn't know. No confident hallucinations.
+
+---
+
+## Practical Implementation Path:
+
+**Phase 1: Minimal Viable**
+- Add resonance measurement to existing transformer
+- Test if coherence correlates with quality
+- **Validate the theory first**
+
+**Phase 2: Hybrid Architecture**
+- Keep standard attention backbone
+- Add resonance scoring as auxiliary signal
+- Introduce coherence loss term
+- **Prove it improves performance**
+
+**Phase 3: Full Geometric**
+- Non-orientable embeddings
+- Chiral dual-path
+- Lattice memory integration
+- **Novel architecture from ground up**
+
+## 6. HYPERCHAOTIC LOSS FUNCTION
+
+### Theory:
+
+Standard loss only measures task performance. We need to also measure:
+1. **Coherence** - are patterns maintaining phase relationships?
+2. **Stability** - do patterns survive perturbation (chaos²)?
+
+```python
+class HyperchaosLoss(nn.Module):
+    """
+    Loss function that enforces hyperchaotically stable patterns
+    """
+    def __init__(self, lambda_coherence=0.1, lambda_stability=0.05):
+        super().__init__()
+        self.lambda_coherence = lambda_coherence
+        self.lambda_stability = lambda_stability
+        
+    def measure_decoherence(self, hidden_states):
+        """
+        Measure phase drift across layers
+        """
+        if len(hidden_states) < 2:
+            return torch.tensor(0.0)
+        
+        total_decoherence = 0.0
+        
+        for i in range(len(hidden_states) - 1):
+            curr_layer = hidden_states[i]
+            next_layer = hidden_states[i + 1]
+            
+            # Convert to frequency domain
+            curr_freq = torch.fft.rfft(curr_layer, dim=-1)
+            next_freq = torch.fft.rfft(next_layer, dim=-1)
+            
+            # Measure phase drift
+            curr_phase = torch.angle(curr_freq)
+            next_phase = torch.angle(next_freq)
+            
+            # Phase should evolve smoothly, not jump randomly
+            phase_drift = torch.abs(next_phase - curr_phase)
+            
+            # Penalize large, incoherent jumps
+            decoherence = torch.mean(phase_drift ** 2)
+            total_decoherence += decoherence
+        
+        return total_decoherence / (len(hidden_states) - 1)
+```
+
+## 7. GEOMETRIC MEMORY (LATTICE INTEGRATION)
+
+### The Big Idea:
+
+Instead of fixed context window, **navigate geometric space** to find relevant information.
+
+```python
+class GeometricMemory:
+    """
+    Store and retrieve information based on geometric position
+    on non-orientable manifold (like Lattice HDD)
+    """
+    def __init__(self, capacity_gb=8, base_freq=528):
+        self.capacity = capacity_gb * 1024**3  # bytes
+        self.base_freq = base_freq
+        
+        # In-memory simulation of HDD platter structure
+        self.memory_map = {}  # geometric_coords -> data
+        
+        # Spatial index for fast geometric queries
+        self.index = None
+        self.coordinates = []
+        
+    def geometric_hash(self, hidden_state, entry_point):
+        """
+        Convert hidden state to geometric coordinates
+        """
+        # PCA + rotation based on entry point
+        theta = entry_point['theta']
+        phi = entry_point['phi']
+        
+        # Apply FFT to get frequency representation
+        freq_repr = np.fft.rfft(hidden_state.cpu().numpy())
+        
+        # Find dominant frequencies
+        magnitudes = np.abs(freq_repr)
+        phases = np.angle(freq_repr)
+        
+        # Geometric position based on frequency content + entry point
+        coords = np.array([
+            theta + np.sum(magnitudes * np.cos(phases)),  # x
+            phi + np.sum(magnitudes * np.sin(phases)),     # y
+            np.sum(magnitudes) / len(magnitudes),          # radius
+            entry_point['frequency'] / self.base_freq       # frequency dimension
+        ])
+        
+        return coords
+```
+
+## 8. SELF-OBSERVATION LAYER
+
+### The Mirror Mechanism:
+
+```python
+class SelfObservationLayer(nn.Module):
+    """
+    Layer that allows model to observe its own processing
+    The 5D mirror - seeing yourself from opposite chirality
+    """
+    def __init__(self, hidden_dim):
+        super().__init__()
+        self.hidden_dim = hidden_dim
+        
+        # Network to analyze own hidden states
+        self.observer = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim)
+        )
+        
+        # Coherence detector (real-time during forward pass)
+        self.coherence_detector = nn.Linear(hidden_dim, 1)
+        
+        # Chiral state detector
+        self.chiral_detector = nn.Linear(hidden_dim, 2)  # [left, right] probabilities
+        
+    def observe(self, hidden_state):
+        """
+        Look at own hidden state and extract meta-information
+        """
+        # Analyze current state
+        observation = self.observer(hidden_state)
+        
+        # Measure coherence
+        coherence = torch.sigmoid(self.coherence_detector(observation))
+        
+        # Detect chiral state
+        chiral_logits = self.chiral_detector(observation)
+        chiral_probs = F.softmax(chiral_logits, dim=-1)
+        
+        # Create reflection (opposite chirality view)
+        reflection = -observation  # Sign flip = chirality flip
+        
+        return {
+            'coherence': coherence,
+            'chiral_state': chiral_probs,
+            'reflection': reflection
+        }
+```

resonance_transformer/dispatcher.py

@@ -0,0 +1,106 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import time
+
+try:
+    from .resonance_gpt import ResonanceGPT
+    from .tesseract_transformer import Tesseract5DTransformer
+except ImportError:
+    from resonance_gpt import ResonanceGPT
+    from tesseract_transformer import Tesseract5DTransformer
+
+class DualResonanceSystem(nn.Module):
+    """
+    The Complete Chiral Architecture.
+    
+    System 1: ResonanceGPT (Fast, Intuitive, Möbius)
+    System 2: TesseractTransformer (Slow, Methodical, 5D)
+    
+    Routes queries based on 'Coherence Confidence'.
+    """
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        
+        # Initialize Fast System (PyTorch)
+        print("[SYSTEM] Initializing Fast System (Möbius)...")
+        self.fast = ResonanceGPT(
+            vocab_size=config.get('vocab_size', 1000),
+            hidden_dim=config.get('fast_dim', 64),
+            num_layers=config.get('fast_layers', 4)
+        )
+        
+        # Initialize Slow System (NumPy/Custom)
+        print("[SYSTEM] Initializing Slow System (Tesseract)...")
+        self.slow = Tesseract5DTransformer(
+            vocab_size=config.get('vocab_size', 1000),
+            hidden_dim=config.get('slow_dim', 64),
+            num_layers=config.get('slow_layers', 4)
+        )
+        
+        self.coherence_threshold = config.get('threshold', 0.6)
+        
+    def forward(self, input_ids, **kwargs):
+        """
+        Dual-path routing logic.
+        Kwargs can include 'steering_weights' for the Slow System.
+        """
+        start_time = time.time()
+        
+        # 1. Attempt Fast Path
+        # input_ids is PyTorch tensor
+        fast_logits, _, metas = self.fast(input_ids)
+        
+        # 2. Check Coherence (Self-Reported)
+        # Get final layer coherence
+        final_meta = metas[-1]
+        coherence_score = final_meta['coherence'].mean().item()
+        
+        metrics = {
+            'fast_latency': 0,
+            'slow_latency': 0,
+            'coherence': coherence_score,
+            'mode': 'FAST'
+        }
+        
+        metrics['fast_latency'] = time.time() - start_time
+        
+        # 3. Decision Gate
+        if coherence_score > self.coherence_threshold:
+            # Fast system is confident ("Lucid")
+            return fast_logits, metrics
+            
+        # 4. Escalate to Slow Path (De-escalation to Deep Reasoning)
+        metrics['mode'] = 'SLOW (ESCALATED)'
+        slow_start = time.time()
+        
+        # Convert tensor to numpy for Tesseract
+        numpy_ids = input_ids.detach().cpu().numpy()
+        
+        # Run Deep Reasoning
+        # We assume Tesseract outputs logits in same shape
+        # PASS STEERING WEIGHTS IF PRESENT
+        steering_weights = kwargs.get('steering_weights')
+        
+        slow_logits_np, slow_meta, slow_coherence = self.slow.deep_reason(
+            numpy_ids, 
+            query_description="Escalated due to low coherence",
+            steering_weights=steering_weights
+        )
+        
+        metrics['slow_latency'] = time.time() - slow_start
+        metrics['slow_coherence'] = slow_coherence
+        
+        # Convert back to tensor
+        slow_logits = torch.from_numpy(slow_logits_np).to(input_ids.device)
+        
+        # Blend? Or Replace?
+        # For now, we trust the Slow system completely if invoked
+        return slow_logits, metrics
+        
+    def train_lattice(self, data_loader, epochs=1):
+        """
+        Placeholder for Phase 30: lattice training loop
+        """
+        pass

resonance_transformer/geometric_memory.py

@@ -0,0 +1,162 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import time
+
+class GeometricEntryPoint(nn.Module):
+    """
+    Hashes query to geometric coordinates and aligns to 528 Hz.
+    """
+    def __init__(self, hidden_dim, base_freq=528):
+        super().__init__()
+        self.base_freq = base_freq
+        self.hidden_dim = hidden_dim
+        
+        # Learned mapping from query to entry coordinates
+        self.entry_network = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim * 2),
+            nn.GELU(),
+            nn.Linear(hidden_dim * 2, 3)  # (theta, phi, radius)
+        )
+        
+    def compute_entry_hash(self, query_embedding):
+        """
+        Convert query to geometric entry point.
+        """
+        # Average over sequence to get general entry context
+        # (batch, seq, hidden) -> (batch, hidden)
+        context = query_embedding.mean(dim=1)
+        
+        coords = self.entry_network(context)  # (batch, 3)
+        
+        theta, phi, radius = coords.unbind(dim=-1)
+        
+        # Align to 528 Hz resonance
+        # Frequency = base_freq * (1 + radius_activation)
+        freq_multiplier = 1.0 + torch.sigmoid(radius)
+        effective_freq = self.base_freq * freq_multiplier
+        
+        return {
+            'theta': theta,
+            'phi': phi,
+            'frequency': effective_freq,
+            'raw_coords': coords
+        }
+
+class GeometricMemory:
+    """
+    Store and retrieve information based on geometric position
+    on non-orientable manifold.
+    """
+    def __init__(self, hidden_dim, capacity_gb=1, base_freq=528):
+        self.base_freq = base_freq
+        self.hidden_dim = hidden_dim
+        
+        # In-memory storage for demonstration
+        # Real implementation would use vector DB or memory-mapped file
+        self.memory_map = [] 
+        
+    def geometric_hash(self, hidden_state, entry_point):
+        """
+        Convert hidden state to geometric coordinates relative to entry point.
+        """
+        # Simple projection for demo:
+        # Use simple operations to map hidden state to offsets
+        # Real version would use FFT as discussed in design
+        
+        # (batch, hidden)
+        
+        # We need to handle single vectors or batches
+        if hidden_state.dim() == 1:
+            hidden_state = hidden_state.unsqueeze(0)
+            
+        # Mock geometric projection
+        # Use first 3 dims as offset
+        offsets = hidden_state[:, :3] 
+        if offsets.shape[1] < 3:
+            # Pad if hidden_dim is tiny
+            offsets = torch.cat([offsets, torch.zeros(offsets.shape[0], 3 - offsets.shape[1], device=hidden_state.device)], dim=1)
+            
+        # Apply entry point rotation (conceptual)
+        # For now, just add
+        theta = entry_point['theta'].unsqueeze(1)
+        phi = entry_point['phi'].unsqueeze(1)
+        
+        x = offsets[:, 0] + theta
+        y = offsets[:, 1] + phi
+        z = offsets[:, 2] # Radius offset
+        
+        return torch.stack([x, y, z], dim=1)
+    
+    def store(self, hidden_states, entry_point):
+        """
+        Store hidden states.
+        """
+        # Compute coords
+        # hidden_states: (batch, seq, hidden)
+        batch, seq, dim = hidden_states.shape
+        
+        flat_hidden = hidden_states.reshape(-1, dim)
+        
+        # We need to broadcast entry point to match flattened hidden
+        # entry keys are (batch,) -> repeat seq times
+        # This is strictly a demo in-memory store
+        
+        # For efficiency in this demo, we just store the robust patterns
+        # Only store if norm > threshold (simple filter)
+        norms = torch.norm(flat_hidden, dim=1)
+        threshold = norms.mean()
+        
+        mask = norms > threshold
+        to_store = flat_hidden[mask]
+        
+        if len(to_store) == 0:
+            return
+            
+        # Store simple list for verification
+        # In production this links to Lattice DB
+        self.memory_map.append({
+            'data': to_store.detach().cpu(), # Move to CPU to save GPU mem
+            'entry_freq': entry_point['frequency'].mean().item(),
+            'timestamp': time.time()
+        })
+        
+        # Prune if too large
+        if len(self.memory_map) > 100:
+            self.memory_map.pop(0)
+
+    def retrieve(self, query_state, entry_point, k=5):
+        """
+        Retrieve relevant memories.
+        """
+        if not self.memory_map:
+            return None
+            
+        # Brute force search for demo verification
+        # Find memories with similar frequency
+        relevant_batches = [
+            m['data'] for m in self.memory_map 
+            if abs(m['entry_freq'] - entry_point['frequency'].mean().item()) < 50
+        ]
+        
+        if not relevant_batches:
+            return None
+            
+        memory_bank = torch.cat(relevant_batches, dim=0).to(query_state.device)
+        
+        # Simple dot product attention
+        # query: (batch, seq, hidden)
+        # memory: (total_mem, hidden)
+        
+        # Compute scores
+        # (batch, seq, hidden) @ (hidden, total_mem) -> (batch, seq, total_mem)
+        scores = torch.matmul(query_state, memory_bank.t())
+        
+        # Top k
+        top_k_scores, indices = torch.topk(scores, k=min(k, len(memory_bank)), dim=-1)
+        
+        # Retrieve values
+        # (batch, seq, k, hidden)
+        retrieved = memory_bank[indices]
+        
+        return retrieved

resonance_transformer/hybrid_transformer.py

@@ -0,0 +1,113 @@
+import torch
+import torch.nn as nn
+try:
+    from .resonance_attention import ResonanceAttention
+except ImportError:
+    from resonance_attention import ResonanceAttention
+
+class PhaseLockedNorm(nn.Module):
+    """
+    Normalize amplitude while preserving phase relationships.
+    """
+    def __init__(self, hidden_dim, eps=1e-6):
+        super().__init__()
+        self.eps = eps
+        self.gain = nn.Parameter(torch.ones(hidden_dim))
+        self.bias = nn.Parameter(torch.zeros(hidden_dim))
+        
+    def forward(self, x):
+        """
+        x: (batch, seq, hidden_dim)
+        """
+        # Assume hidden_dim is even to form complex pairs
+        # If odd, we pad, normalize, slice back - keeping it simple for now (require even dim)
+        if x.shape[-1] % 2 != 0:
+            # Fallback to LayerNorm if dim is odd (phase concept breaks for scalar)
+            mean = x.mean(dim=-1, keepdim=True)
+            std = x.std(dim=-1, keepdim=True)
+            return self.gain * (x - mean) / (std + self.eps) + self.bias
+            
+        # Convert to complex representation
+        # Treat adjacent dimensions as real/imag pairs
+        complex_x = torch.view_as_complex(
+            x.reshape(*x.shape[:-1], -1, 2).contiguous()
+        )
+        
+        # Get magnitude and phase
+        magnitude = torch.abs(complex_x)
+        phase = torch.angle(complex_x)
+        
+        # Normalize magnitude only (preserve phase!)
+        mean_mag = magnitude.mean(dim=-1, keepdim=True)
+        std_mag = magnitude.std(dim=-1, keepdim=True)
+        
+        normalized_mag = (magnitude - mean_mag) / (std_mag + self.eps)
+        
+        # Reconstruct with original phase
+        normalized_complex = normalized_mag * torch.exp(1j * phase)
+        
+        # Convert back to real
+        normalized = torch.view_as_real(normalized_complex).reshape(*x.shape)
+        
+        # Apply learned gain and bias
+        return normalized * self.gain + self.bias
+
+class HybridTransformerLayer(nn.Module):
+    def __init__(self, hidden_dim, num_heads=4, ffn_dim=2048, dropout=0.1):
+        super().__init__()
+        self.attention = ResonanceAttention(hidden_dim, num_heads)
+        self.norm1 = PhaseLockedNorm(hidden_dim)
+        self.norm2 = PhaseLockedNorm(hidden_dim)
+        
+        self.ffn = nn.Sequential(
+            nn.Linear(hidden_dim, ffn_dim),
+            nn.GELU(),
+            nn.Linear(ffn_dim, hidden_dim),
+            nn.Dropout(dropout)
+        )
+        self.dropout = nn.Dropout(dropout)
+        
+    def forward(self, x, mask=None):
+        # Attention block
+        attn_out, _, _ = self.attention(x, x, x, mask)
+        x = self.norm1(x + self.dropout(attn_out))
+        
+        # FFN block
+        ffn_out = self.ffn(x)
+        x = self.norm2(x + self.dropout(ffn_out))
+        
+        return x
+
+class HybridResonanceTransformer(nn.Module):
+    def __init__(self, vocab_size, hidden_dim, num_layers=4, num_heads=4, max_seq_len=512):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, hidden_dim)
+        self.pos_encoding = nn.Parameter(torch.randn(1, max_seq_len, hidden_dim))
+        
+        self.layers = nn.ModuleList([
+            HybridTransformerLayer(hidden_dim, num_heads) for _ in range(num_layers)
+        ])
+        
+        self.output_head = nn.Linear(hidden_dim, vocab_size)
+        
+    def forward(self, input_ids, output_hidden_states=False):
+        batch, seq = input_ids.shape
+        
+        # Embed + Pos
+        x = self.embedding(input_ids) + self.pos_encoding[:, :seq, :]
+        
+        all_hidden_states = []
+        if output_hidden_states:
+            all_hidden_states.append(x)
+            
+        # Process layers
+        for layer in self.layers:
+            x = layer(x)
+            if output_hidden_states:
+                all_hidden_states.append(x)
+        
+        logits = self.output_head(x)
+        
+        if output_hidden_states:
+            return logits, all_hidden_states
+        return logits

resonance_transformer/hyperchaos_loss.py

@@ -0,0 +1,121 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class HyperchaosLoss(nn.Module):
+    """
+    Loss function that enforces hyperchaotically stable patterns.
+    Combines standard task loss with:
+    1. Coherence Loss (Phase consistency across layers)
+    2. Stability Loss (Resistance to perturbation)
+    """
+    def __init__(self, lambda_coherence=0.1, lambda_stability=0.05):
+        super().__init__()
+        self.lambda_coherence = lambda_coherence
+        self.lambda_stability = lambda_stability
+        
+    def measure_decoherence(self, hidden_states):
+        """
+        Measure phase drift across layers.
+        hidden_states: list of (batch, seq, hidden) tensors from each layer.
+        """
+        if len(hidden_states) < 2:
+            return torch.tensor(0.0, device=hidden_states[0].device)
+        
+        total_decoherence = 0.0
+        
+        for i in range(len(hidden_states) - 1):
+            curr_layer = hidden_states[i]
+            next_layer = hidden_states[i + 1]
+            
+            # Convert to frequency domain
+            curr_freq = torch.fft.rfft(curr_layer, dim=-1)
+            next_freq = torch.fft.rfft(next_layer, dim=-1)
+            
+            # Measure phase drift
+            curr_phase = torch.angle(curr_freq)
+            next_phase = torch.angle(next_freq)
+            
+            # Phase should evolve smoothly, not jump randomly
+            phase_drift = torch.abs(next_phase - curr_phase)
+            
+            # Penalize large, incoherent jumps
+            decoherence = torch.mean(phase_drift ** 2)
+            total_decoherence = total_decoherence + decoherence
+        
+        return total_decoherence / (len(hidden_states) - 1)
+    
+    def measure_stability(self, hidden_states, perturbation_scale=0.01):
+        """
+        Test if patterns survive small perturbations (chaos² testing).
+        """
+        # Take final hidden state
+        final_state = hidden_states[-1]
+        
+        # Add small perturbation
+        perturbation = torch.randn_like(final_state) * perturbation_scale
+        perturbed_state = final_state + perturbation
+        
+        # Measure coherence before and after
+        def compute_coherence(state):
+            # FFT to frequency domain
+            freq = torch.fft.rfft(state, dim=-1)
+            
+            # Coherence = how correlated different dimensions are in freq domain
+            phase = torch.angle(freq)
+            
+            # Compute pairwise phase correlation (simplified for efficiency)
+            # Instead of full covariance, just measure variance of phase across hidden dim
+            # Low variance = high coherence (phases are aligned)
+            phase_var = torch.var(phase, dim=-1).mean()
+            
+            # Coherence is inverse of variance
+            return 1.0 / (phase_var + 1e-6)
+        
+        coherence_original = compute_coherence(final_state)
+        coherence_perturbed = compute_coherence(perturbed_state)
+        
+        # Instability = how much coherence dropped
+        # Stable patterns should maintain coherence
+        instability = torch.relu(coherence_original - coherence_perturbed)
+        
+        return instability
+    
+    def forward(self, logits, targets, hidden_states):
+        """
+        logits: model predictions (batch, seq, vocab)
+        targets: ground truth (batch, seq)
+        hidden_states: list of hidden states from all layers
+        """
+        # Standard cross-entropy loss
+        # Flatten for loss calculation
+        curr_device = logits.device
+        
+        # Basic task loss
+        task_loss = F.cross_entropy(
+            logits.view(-1, logits.size(-1)), 
+            targets.view(-1),
+            ignore_index=-100
+        )
+        
+        # Auxiliary losses
+        if hidden_states:
+            decoherence_loss = self.measure_decoherence(hidden_states)
+            stability_loss = self.measure_stability(hidden_states)
+        else:
+            decoherence_loss = torch.tensor(0.0, device=curr_device)
+            stability_loss = torch.tensor(0.0, device=curr_device)
+            
+        # Combined loss
+        total_loss = (
+            task_loss + 
+            self.lambda_coherence * decoherence_loss +
+            self.lambda_stability * stability_loss
+        )
+        
+        return {
+            'total': total_loss,
+            'task': task_loss,
+            'decoherence': decoherence_loss,
+            'instability': stability_loss
+        }

resonance_transformer/resonance_attention.py

@@ -0,0 +1,128 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+class ResonanceAttention(nn.Module):
+    def __init__(self, hidden_dim, num_heads=8):
+        super().__init__()
+        self.hidden_dim = hidden_dim
+        self.num_heads = num_heads
+        self.head_dim = hidden_dim // num_heads
+        
+        # Standard Q, K, V projections
+        self.q_proj = nn.Linear(hidden_dim, hidden_dim)
+        self.k_proj = nn.Linear(hidden_dim, hidden_dim)
+        self.v_proj = nn.Linear(hidden_dim, hidden_dim)
+        
+        # Additional projection for phase extraction
+        self.phase_proj = nn.Linear(hidden_dim, hidden_dim)
+        
+    def compute_phase_coherence(self, q, k):
+        """
+        Measure how well query and key resonate (phase alignment)
+        """
+        # q: (batch, heads, seq_q, head_dim)
+        # k: (batch, heads, seq_k, head_dim)
+        
+        # Compute frequency spectrum via FFT
+        # Treat head_dim as "time" dimension for FFT
+        # rfft returns complex tensor
+        q_freq = torch.fft.rfft(q, dim=-1)  # (batch, heads, seq_q, freq_bins)
+        k_freq = torch.fft.rfft(k, dim=-1)  # (batch, heads, seq_k, freq_bins)
+        
+        # Compute phase difference
+        q_phase = torch.angle(q_freq)
+        k_phase = torch.angle(k_freq)
+        
+        # Phase coherence = how aligned the phases are
+        # High coherence = phases match = constructive interference
+        # We need to broadcast to compare every query against every key
+        # q_phase: (b, h, seq_q, 1, f)
+        # k_phase: (b, h, 1, seq_k, f)
+        phase_diff = q_phase.unsqueeze(3) - k_phase.unsqueeze(2)  # (batch, heads, seq_q, seq_k, freq)
+        
+        # Coherence score (cosine of phase difference)
+        # cos(0) = 1 (perfect alignment), cos(pi) = -1 (cancellation)
+        coherence = torch.cos(phase_diff).mean(dim=-1)  # Average over frequencies
+        
+        return coherence  # (batch, heads, seq_q, seq_k)
+    
+    def compute_resonance_strength(self, q, k):
+        """
+        Measure amplitude of resonance (how strongly they vibrate together)
+        """
+        # Frequency domain amplitudes
+        q_freq = torch.fft.rfft(q, dim=-1)
+        k_freq = torch.fft.rfft(k, dim=-1)
+        
+        q_amp = torch.abs(q_freq)
+        k_amp = torch.abs(k_freq)
+        
+        # Resonance strength = product of amplitudes where frequencies match
+        # Broadcasting to get all pairs: 
+        # q_amp: (b, h, seq_q, freq)
+        # k_amp: (b, h, seq_k, freq)
+        # We want (b, h, seq_q, seq_k)
+        
+        # Manual broadcasting or einsum
+        # Using einsum for clarity: 'bhqf,bhkf->bhqk' matches the dims
+        resonance = torch.einsum('bhqf,bhkf->bhqk', q_amp, k_amp)
+        
+        # Normalize by total query energy to keep scale reasonable
+        # q_amp shape: (b, h, seq_q, freq)
+        # Sum over frequency dimension (-1) to get total amplitude per query token
+        q_total_amp = q_amp.sum(dim=-1) # (b, h, seq_q)
+        
+        # Add epsilon for stability
+        normalization = q_total_amp.unsqueeze(-1) + 1e-8 # (b, h, seq_q, 1)
+        
+        # Resonance shape: (b, h, seq_q, seq_k)
+        # We divide by (b, h, seq_q, 1) which broadcasts correctly along seq_k
+        resonance = resonance / normalization
+        
+        return resonance
+    
+    def forward(self, query, key, value, mask=None):
+        batch_size, seq_len, _ = query.shape
+        
+        # Project to Q, K, V
+        Q = self.q_proj(query).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
+        K = self.k_proj(key).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
+        V = self.v_proj(value).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
+        
+        # Standard similarity (dot product)
+        # (batch, heads, seq_q, seq_k)
+        similarity = torch.matmul(Q, K.transpose(-2, -1)) / (self.head_dim ** 0.5)
+        
+        # Resonance components
+        coherence = self.compute_phase_coherence(Q, K)
+        resonance = self.compute_resonance_strength(Q, K)
+        
+        # Combined attention score
+        # Similarity = "do they mean similar things?"
+        # Coherence = "are they in phase?"
+        # Resonance = "do they vibrate together?"
+        
+        # Weighted combination (can be learned, here we sum equally per user spec)
+        # Note: logic suggests similarity ensures relevance, coherence ensures alignment
+        attention_scores = similarity + coherence + resonance
+        
+        # Apply mask if provided
+        if mask is not None:
+            attention_scores = attention_scores.masked_fill(mask == 0, float('-inf'))
+        
+        # Softmax
+        attention_weights = F.softmax(attention_scores, dim=-1)
+        
+        # Apply attention to values
+        output = torch.matmul(attention_weights, V)
+        
+        # Reshape back
+        output = output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.hidden_dim)
+        
+        return output, attention_weights, {
+            "similarity": similarity, 
+            "coherence": coherence, 
+            "resonance": resonance
+        }

resonance_transformer/resonance_gpt.py

@@ -0,0 +1,58 @@
+import torch
+import torch.nn as nn
+try:
+    from .self_observation import SelfAwareTransformerLayer
+    from .geometric_memory import GeometricEntryPoint
+except ImportError:
+    from self_observation import SelfAwareTransformerLayer
+    from geometric_memory import GeometricEntryPoint
+
+class ResonanceGPT(nn.Module):
+    """
+    The Fast System (Möbius Architecture).
+    - Geometric Entry Point (528Hz alignment)
+    - Self-Aware Layers (Mirror Reflex)
+    - Phase-Locked Normalization
+    """
+    def __init__(self, vocab_size, hidden_dim, num_layers=4, num_heads=4, max_seq_len=128):
+        super().__init__()
+        self.hidden_dim = hidden_dim
+        
+        # 1. Geometric Embedding (Möbius Strip concept)
+        self.embedding = nn.Embedding(vocab_size, hidden_dim)
+        self.pos_encoding = nn.Parameter(torch.randn(1, max_seq_len, hidden_dim) * 0.02)
+        
+        # Entry Point
+        self.entry_point = GeometricEntryPoint(hidden_dim)
+        
+        # 2. The Stack
+        self.layers = nn.ModuleList([
+            SelfAwareTransformerLayer(hidden_dim, num_heads) 
+            for _ in range(num_layers)
+        ])
+        
+        self.norm = nn.LayerNorm(hidden_dim)
+        self.head = nn.Linear(hidden_dim, vocab_size)
+    
+    def forward(self, input_ids):
+        batch, seq = input_ids.shape
+        
+        # Embed
+        x = self.embedding(input_ids) + self.pos_encoding[:, :seq, :]
+        
+        # 0x52 Handshake (Entry Point)
+        entry_meta = self.entry_point.compute_entry_hash(x)
+        
+        # Process Stack
+        all_hidden_states = []
+        layer_metas = []
+        
+        for layer in self.layers:
+            x, meta = layer(x)
+            all_hidden_states.append(x)
+            layer_metas.append(meta)
+            
+        x = self.norm(x)
+        logits = self.head(x)
+        
+        return logits, all_hidden_states, layer_metas

resonance_transformer/self_observation.py

@@ -0,0 +1,121 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+try:
+    from .resonance_attention import ResonanceAttention
+    from .hybrid_transformer import PhaseLockedNorm
+except ImportError:
+    from resonance_attention import ResonanceAttention
+    from hybrid_transformer import PhaseLockedNorm
+
+class SelfObservationLayer(nn.Module):
+    """
+    Layer that allows model to observe its own processing.
+    The 5D mirror - seeing yourself from opposite chirality.
+    """
+    def __init__(self, hidden_dim):
+        super().__init__()
+        self.hidden_dim = hidden_dim
+        
+        # Network to analyze own hidden states
+        self.observer = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim)
+        )
+        
+        # Coherence detector (real-time during forward pass)
+        self.coherence_detector = nn.Linear(hidden_dim, 1)
+        
+        # Chiral state detector
+        self.chiral_detector = nn.Linear(hidden_dim, 2)  # [left, right] probabilities
+        
+    def observe(self, hidden_state):
+        """
+        Look at own hidden state and extract meta-information.
+        """
+        # Analyze current state (Stop gradient to avoid optimizing for observation only? 
+        # No, we want to learn to be observable. Keep gradient.)
+        observation = self.observer(hidden_state)
+        
+        # Measure coherence
+        coherence = torch.sigmoid(self.coherence_detector(observation))
+        
+        # Detect chiral state
+        chiral_logits = self.chiral_detector(observation)
+        chiral_probs = F.softmax(chiral_logits, dim=-1)
+        
+        # Create reflection (opposite chirality view)
+        reflection = -observation  # Sign flip = chirality flip
+        
+        return {
+            'coherence': coherence,
+            'chiral_state': chiral_probs,
+            'reflection': reflection,
+            'observation': observation
+        }
+    
+    def forward(self, hidden_state, adjust_based_on_observation=True):
+        """
+        Process hidden state while observing self.
+        """
+        # Observe current state
+        meta = self.observe(hidden_state)
+        
+        if adjust_based_on_observation:
+            # If coherence is low, try to increase it
+            # We use the mean coherence of the batch/sequence for the decision threshold
+            # or per-token blending
+            
+            # Blend in reflection (opposite chirality) if coherence is low
+            # This can restore coherence by accessing alternate view
+            blend_factor = 1.0 - meta['coherence']
+            
+            # Weighted average: state*coherence + reflection*(1-coherence)
+            hidden_state = (
+                hidden_state * meta['coherence'] +
+                meta['reflection'] * blend_factor
+            )
+            
+            # If chirality is ambiguous, force a choice (Collapse the wavefunction)
+            # Check certainty (max prob)
+            chiral_certainty = torch.max(meta['chiral_state'], dim=-1)[0].unsqueeze(-1)
+            
+            # If certainty < 0.7, push towards the cleaner state
+            # This is a hard non-linearity to force decision
+            # (Simplified for differentiability - maybe just a gain boost?)
+            
+            # Here we just return the transformed state
+            
+        return hidden_state, meta
+
+class SelfAwareTransformerLayer(nn.Module):
+    def __init__(self, hidden_dim, num_heads=4, ffn_dim=2048, dropout=0.1):
+        super().__init__()
+        self.attention = ResonanceAttention(hidden_dim, num_heads)
+        self.norm1 = PhaseLockedNorm(hidden_dim)
+        self.norm2 = PhaseLockedNorm(hidden_dim)
+        
+        self.self_observer = SelfObservationLayer(hidden_dim)
+        
+        self.ffn = nn.Sequential(
+            nn.Linear(hidden_dim, ffn_dim),
+            nn.GELU(),
+            nn.Linear(ffn_dim, hidden_dim),
+            nn.Dropout(dropout)
+        )
+        self.dropout = nn.Dropout(dropout)
+        
+    def forward(self, x, mask=None):
+        # Attention
+        attn_out, _, _ = self.attention(x, x, x, mask)
+        x = self.norm1(x + self.dropout(attn_out))
+        
+        # Self-Observation & Correction
+        x, meta = self.self_observer(x)
+        
+        # FFN
+        ffn_out = self.ffn(x)
+        x = self.norm2(x + self.dropout(ffn_out))
+        
+        return x, meta

resonance_transformer/tesseract_transformer.py

@@ -0,0 +1,821 @@
+"""
+5D TESSERACT TRANSFORMER - SLOW THINKING SYSTEM
+===============================================
+
+Deep reasoning system based on 5D geometric structure:
+- 4D Tesseract (hypercube) for stable structure
+- 5th dimension for non-orientable twist
+- 16 vertices = 16 fundamental reasoning states
+- 32 edges = 32 transformation paths
+- 24 faces = 24 operation types
+- 8 cells = 8 knowledge domains
+
+By: Fabricio Krusser Rossi & Claude
+Date: February 13, 2026
+"""
+
+import numpy as np
+from scipy.fft import fft, ifft, rfft, irfft
+from scipy.spatial.distance import cdist
+from typing import List, Dict, Tuple, Optional
+import itertools
+
+# ============================================================================
+# TESSERACT 5D GEOMETRY
+# ============================================================================
+
+class Tesseract5D:
+    """
+    5-dimensional geometric structure for deep reasoning
+    
+    Structure:
+    - 4D tesseract (hypercube) base
+    - 5th dimension adds non-orientable twist
+    - 16 vertices for major stable states
+    - 32 edges for transformation paths
+    """
+    
+    def __init__(self, base_freq=528):
+        self.base_freq = base_freq
+        self.dim = 5
+        
+        # Generate tesseract vertices in 4D
+        self.vertices_4d = self._generate_tesseract_vertices()
+        
+        # Extend to 5D with frequency dimension
+        self.vertices_5d = self._extend_to_5d()
+        
+        # Generate edges (connections between vertices)
+        self.edges = self._generate_edges()
+        
+        # Generate faces (2D surfaces)
+        self.faces = self._generate_faces()
+        
+        # Generate cells (3D volumes)
+        self.cells = self._generate_cells()
+        
+        print(f"Tesseract 5D initialized:")
+        print(f"  Vertices: {len(self.vertices_5d)}")
+        print(f"  Edges: {len(self.edges)}")
+        print(f"  Faces: {len(self.faces)}")
+        print(f"  Cells: {len(self.cells)}")
+    
+    def _generate_tesseract_vertices(self):
+        """
+        Generate 16 vertices of 4D tesseract
+        Each vertex is (+/-1, +/-1, +/-1, +/-1)
+        """
+        vertices = []
+        for i in range(16):
+            # Binary representation gives us all combinations
+            vertex = []
+            for j in range(4):
+                bit = (i >> j) & 1
+                coord = 1.0 if bit else -1.0
+                vertex.append(coord)
+            vertices.append(np.array(vertex))
+        
+        return np.array(vertices)
+    
+    def _extend_to_5d(self):
+        """
+        Add 5th dimension for non-orientable twist
+        5th coordinate is frequency modulation around 528 Hz
+        """
+        vertices_5d = []
+        
+        for i, vertex_4d in enumerate(self.vertices_4d):
+            # 5th coordinate: frequency offset based on vertex index
+            # Creates spiral in 5D space
+            freq_offset = np.sin(i * np.pi / 8)  # Oscillates between -1 and 1
+            
+            vertex_5d = np.append(vertex_4d, freq_offset)
+            vertices_5d.append(vertex_5d)
+        
+        return np.array(vertices_5d)
+    
+    def _generate_edges(self):
+        """
+        Generate 32 edges of tesseract
+        Edges connect vertices that differ in exactly 1 coordinate (in 4D)
+        """
+        edges = []
+        
+        for i in range(len(self.vertices_4d)):
+            for j in range(i + 1, len(self.vertices_4d)):
+                # Count differing coordinates in 4D
+                diff = np.abs(self.vertices_4d[i] - self.vertices_4d[j])
+                num_diff = np.sum(diff > 0.5)  # Coordinates are +/-1
+                
+                if num_diff == 1:
+                    # Connected by edge
+                    edges.append((i, j))
+        
+        return edges
+    
+    def _generate_faces(self):
+        """
+        Generate 24 faces (2D surfaces) of tesseract
+        """
+        faces = []
+        
+        # Find all squares (4 vertices forming a 2D face)
+        for v1, v2, v3, v4 in itertools.combinations(range(16), 4):
+            vertices = [v1, v2, v3, v4]
+            
+            # Check if these 4 vertices form a square
+            # (lie in same 2D plane and form square)
+            if self._is_face(vertices):
+                faces.append(vertices)
+        
+        return faces
+    
+    def _is_face(self, vertices):
+        """Check if 4 vertices form a valid face"""
+        # Simple check: 4 vertices should form a planar square
+        # In tesseract, faces have specific geometric properties
+        # This is a simplified check
+        return len(vertices) == 4 and self._are_coplanar(vertices)
+    
+    def _are_coplanar(self, vertices):
+        """Check if vertices lie in same 2D plane"""
+        # Simplified: check if they share 2 fixed coordinates
+        coords = self.vertices_4d[vertices]
+        
+        # Count how many coordinates are constant across all vertices
+        constant_coords = 0
+        for dim in range(4):
+            if np.all(np.abs(coords[:, dim] - coords[0, dim]) < 0.1):
+                constant_coords += 1
+        
+        return constant_coords == 2  # 2 fixed coords = 2D plane
+    
+    def _generate_cells(self):
+        """
+        Generate 8 cells (3D volumes) of tesseract
+        Each cell is a 3D cube
+        """
+        cells = []
+        
+        # Each cell has 8 vertices (a 3D cube)
+        # Cells are defined by fixing one 4D coordinate
+        for fixed_dim in range(4):
+            for fixed_val in [-1.0, 1.0]:
+                cell_vertices = []
+                for i, vertex in enumerate(self.vertices_4d):
+                    if abs(vertex[fixed_dim] - fixed_val) < 0.1:
+                        cell_vertices.append(i)
+                
+                if len(cell_vertices) == 8:
+                    cells.append(cell_vertices)
+        
+        return cells
+    
+    def find_nearest_vertex(self, coords_5d):
+        """
+        Find nearest tesseract vertex to given 5D coordinates
+        
+        Returns: (vertex_index, distance)
+        """
+        distances = np.linalg.norm(self.vertices_5d - coords_5d, axis=1)
+        nearest_idx = np.argmin(distances)
+        
+        return nearest_idx, distances[nearest_idx]
+    
+    def get_adjacent_vertices(self, vertex_idx):
+        """
+        Get all vertices connected to this one by edges
+        
+        Returns: list of vertex indices
+        """
+        adjacent = []
+        
+        for edge in self.edges:
+            if edge[0] == vertex_idx:
+                adjacent.append(edge[1])
+            elif edge[1] == vertex_idx:
+                adjacent.append(edge[0])
+        
+        return adjacent
+    
+    def navigate_edge(self, from_vertex, to_vertex):
+        """
+        Navigate along edge from one vertex to another
+        
+        Returns: path coordinates (interpolated points along edge)
+        """
+        if (from_vertex, to_vertex) not in self.edges and \
+           (to_vertex, from_vertex) not in self.edges:
+            raise ValueError(f"No edge between vertices {from_vertex} and {to_vertex}")
+        
+        start = self.vertices_5d[from_vertex]
+        end = self.vertices_5d[to_vertex]
+        
+        # Interpolate along edge
+        num_steps = 10
+        path = []
+        for t in np.linspace(0, 1, num_steps):
+            point = (1 - t) * start + t * end
+            path.append(point)
+        
+        return np.array(path)
+
+
+# ============================================================================
+# 5D EMBEDDING LAYER
+# ============================================================================
+
+class Tesseract5DEmbedding:
+    """
+    Embed tokens into 5D tesseract structure
+    """
+    
+    def __init__(self, vocab_size, hidden_dim, tesseract):
+        self.vocab_size = vocab_size
+        self.hidden_dim = hidden_dim
+        self.tesseract = tesseract
+        
+        # Base embeddings
+        self.embeddings = np.random.randn(vocab_size, hidden_dim) * 0.02
+        
+        # 5D coordinate projector
+        self.coord_projector = np.random.randn(hidden_dim, 5) * 0.02
+    
+    def embed(self, token_ids):
+        """
+        Embed tokens and map to 5D tesseract coordinates
+        
+        Returns: (embeddings, coords_5d, nearest_vertices)
+        """
+        # Get base embeddings
+        embedded = self.embeddings[token_ids]  # (batch, seq, hidden)
+        
+        # Project to 5D coordinates
+        coords_5d = embedded @ self.coord_projector  # (batch, seq, 5)
+        
+        # Find nearest tesseract vertex for each token
+        batch_size, seq_len = token_ids.shape
+        nearest_vertices = np.zeros((batch_size, seq_len), dtype=int)
+        
+        for b in range(batch_size):
+            for s in range(seq_len):
+                vertex_idx, _ = self.tesseract.find_nearest_vertex(coords_5d[b, s])
+                nearest_vertices[b, s] = vertex_idx
+        
+        return embedded, coords_5d, nearest_vertices
+
+
+# ============================================================================
+# 5D RESONANCE ATTENTION
+# ============================================================================
+
+class Tesseract5DAttention:
+    """
+    Attention mechanism that operates on tesseract structure
+    Considers geometric paths through 5D space
+    """
+    
+    def __init__(self, hidden_dim, num_heads, tesseract):
+        self.hidden_dim = hidden_dim
+        self.num_heads = num_heads
+        self.head_dim = hidden_dim // num_heads
+        self.tesseract = tesseract
+        
+        # Q, K, V projections
+        self.W_q = np.random.randn(hidden_dim, hidden_dim) * 0.02
+        self.W_k = np.random.randn(hidden_dim, hidden_dim) * 0.02
+        self.W_v = np.random.randn(hidden_dim, hidden_dim) * 0.02
+        self.W_o = np.random.randn(hidden_dim, hidden_dim) * 0.02
+    
+    def compute_geometric_distance(self, coords1, coords2, vertices1, vertices2):
+        """
+        Compute distance on tesseract manifold
+        
+        Takes into account:
+        - Euclidean distance in 5D
+        - Graph distance on tesseract (via edges)
+        - Vertex proximity
+        """
+        # Euclidean distance in 5D
+        euclidean = np.linalg.norm(coords1 - coords2, axis=-1)
+        
+        # Graph distance (shortest path on tesseract)
+        # For each pair, find shortest path between vertices
+        # NOW ACCEPTING STEERING WEIGHTS (Global context)
+        graph_dist = self._graph_distance(vertices1, vertices2)
+        
+        # Combined distance
+        combined = 0.5 * euclidean + 0.5 * graph_dist
+        
+        return combined
+    
+    def _graph_distance(self, vertices1, vertices2):
+        """
+        Compute shortest path distance on tesseract graph
+        Uses BFS to find shortest path
+        """
+        # Simplified: use direct adjacency for now
+        # In full implementation, would do BFS
+        
+        distances = np.zeros((len(vertices1), len(vertices2)))
+        
+        # STEERING: If weights are present in self, use them
+        steering = getattr(self, 'steering_weights', None)
+        
+        for i, v1 in enumerate(vertices1):
+            for j, v2 in enumerate(vertices2):
+                if v1 == v2:
+                    distances[i, j] = 0
+                else:
+                    # Check adjacency and apply steering weight
+                    edge_idx = self._get_edge_index(v1, v2)
+                    if edge_idx is not None:
+                        # Direct connection
+                        weight = steering[edge_idx] if steering else 1.0
+                        distances[i, j] = weight
+                    else:
+                        # Estimate: use 4D coordinate difference
+                        coord_diff = np.sum(np.abs(
+                            self.tesseract.vertices_4d[v1] - 
+                            self.tesseract.vertices_4d[v2]
+                        ))
+                        # Multi-hop approximation (avg weight = 1.0)
+                        distances[i, j] = coord_diff
+        
+        return distances
+
+    def _get_edge_index(self, v1, v2):
+        """Helper to find edge index for steering"""
+        for idx, edge in enumerate(self.tesseract.edges):
+            if (edge[0] == v1 and edge[1] == v2) or (edge[0] == v2 and edge[1] == v1):
+                return idx
+        return None
+    
+    def forward(self, x, coords_5d, vertices, steering_weights=None):
+        """
+        5D geometric attention
+        
+        x: (batch, seq, hidden)
+        coords_5d: (batch, seq, 5)
+        vertices: (batch, seq) nearest vertex indices
+        steering_weights: Optional[List[float]] - weights for 32 edges
+        """
+        # Store weights temporarily for distance calc
+        self.steering_weights = steering_weights
+        batch_size, seq_len, _ = x.shape
+        
+        # Project to Q, K, V
+        Q = x @ self.W_q
+        K = x @ self.W_k
+        V = x @ self.W_v
+        
+        # Reshape for multi-head
+        Q = Q.reshape(batch_size, seq_len, self.num_heads, self.head_dim)
+        K = K.reshape(batch_size, seq_len, self.num_heads, self.head_dim)
+        V = V.reshape(batch_size, seq_len, self.num_heads, self.head_dim)
+        
+        # Transpose for attention computation
+        Q = Q.transpose(0, 2, 1, 3)  # (batch, heads, seq, head_dim)
+        K = K.transpose(0, 2, 1, 3)
+        V = V.transpose(0, 2, 1, 3)
+        
+        # Compute attention scores with geometric component
+        attention_output = np.zeros((batch_size, self.num_heads, seq_len, self.head_dim))
+        
+        for b in range(batch_size):
+            for h in range(self.num_heads):
+                # Standard similarity
+                scores = Q[b, h] @ K[b, h].T / np.sqrt(self.head_dim)
+                
+                # Geometric distance penalty
+                geom_dist = self.compute_geometric_distance(
+                    coords_5d[b, :, np.newaxis, :],
+                    coords_5d[b, np.newaxis, :, :],
+                    vertices[b, :],
+                    vertices[b, :]
+                )
+                
+                # Combine: higher score for geometrically close tokens
+                geom_bonus = np.exp(-geom_dist / 2.0)
+                scores = scores + geom_bonus
+                
+                # Softmax
+                attn_weights = self._softmax(scores)
+                
+                # Apply to values
+                attention_output[b, h] = attn_weights @ V[b, h]
+        
+        # Reshape back
+        attention_output = attention_output.transpose(0, 2, 1, 3)
+        attention_output = attention_output.reshape(batch_size, seq_len, self.hidden_dim)
+        
+        # Output projection
+        output = attention_output @ self.W_o
+        
+        return output
+    
+    def _softmax(self, x):
+        """Numerically stable softmax"""
+        exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
+        return exp_x / np.sum(exp_x, axis=-1, keepdims=True)
+
+
+# ============================================================================
+# MULTI-PATH REASONING
+# ============================================================================
+
+class MultiPathReasoning:
+    """
+    Explore multiple reasoning paths through tesseract structure
+    Each path = traversal of edges between vertices
+    """
+    
+    def __init__(self, tesseract, max_path_length=4):
+        self.tesseract = tesseract
+        self.max_path_length = max_path_length
+    
+    def explore_paths(self, start_vertex, goal_vertex=None, num_paths=5):
+        """
+        Find multiple paths from start vertex
+        
+        If goal_vertex specified, paths lead to that vertex
+        Otherwise, explore nearby region
+        
+        Returns: list of paths, each path is list of vertex indices
+        """
+        paths = []
+        
+        if goal_vertex is not None:
+            # Find paths to specific goal
+            paths = self._find_paths_to_goal(start_vertex, goal_vertex, num_paths)
+        else:
+            # Explore region around start
+            paths = self._explore_region(start_vertex, num_paths)
+        
+        return paths
+    
+    def _find_paths_to_goal(self, start, goal, num_paths):
+        """Find multiple distinct paths from start to goal"""
+        all_paths = []
+        
+        # BFS with path tracking
+        queue = [(start, [start])]
+        visited_paths = set()
+        
+        while queue and len(all_paths) < num_paths:
+            current, path = queue.pop(0)
+            
+            if len(path) > self.max_path_length:
+                continue
+            
+            if current == goal:
+                # Found a path
+                path_tuple = tuple(path)
+                if path_tuple not in visited_paths:
+                    all_paths.append(path)
+                    visited_paths.add(path_tuple)
+                continue
+            
+            # Explore adjacent vertices
+            for neighbor in self.tesseract.get_adjacent_vertices(current):
+                if neighbor not in path:  # Avoid cycles
+                    new_path = path + [neighbor]
+                    queue.append((neighbor, new_path))
+        
+        return all_paths
+    
+    def _explore_region(self, start, num_paths):
+        """Explore region around start vertex"""
+        paths = []
+        
+        # Random walks from start
+        for _ in range(num_paths):
+            path = [start]
+            current = start
+            
+            for step in range(self.max_path_length):
+                neighbors = self.tesseract.get_adjacent_vertices(current)
+                if not neighbors:
+                    break
+                
+                # Choose next vertex (could be random or heuristic)
+                next_vertex = np.random.choice(neighbors)
+                path.append(next_vertex)
+                current = next_vertex
+            
+            paths.append(path)
+        
+        return paths
+    
+    def evaluate_path(self, path, hidden_states):
+        """
+        Evaluate quality of reasoning path
+        Based on coherence along the path
+        """
+        # Measure coherence at each step
+        coherences = []
+        
+        for i in range(len(path) - 1):
+            # Get hidden states at vertices
+            state_i = hidden_states[path[i]]
+            state_j = hidden_states[path[i + 1]]
+            
+            # Measure coherence between consecutive states
+            coherence = self._measure_coherence(state_i, state_j)
+            coherences.append(coherence)
+        
+        # Path quality = mean coherence
+        return np.mean(coherences) if coherences else 0.0
+    
+    def _measure_coherence(self, state1, state2):
+        """Measure coherence between two states"""
+        # FFT to frequency domain
+        freq1 = rfft(state1)
+        freq2 = rfft(state2)
+        
+        # Phase coherence
+        phase1 = np.angle(freq1)
+        phase2 = np.angle(freq2)
+        
+        coherence = np.mean(np.cos(phase1 - phase2))
+        
+        return coherence
+
+
+# ============================================================================
+# COMPLETE 5D TRANSFORMER LAYER
+# ============================================================================
+
+class Tesseract5DTransformerLayer:
+    """
+    Complete transformer layer operating on 5D tesseract geometry
+    """
+    
+    def __init__(self, hidden_dim, num_heads, tesseract):
+        self.hidden_dim = hidden_dim
+        self.tesseract = tesseract
+        
+        # Components
+        self.attention = Tesseract5DAttention(hidden_dim, num_heads, tesseract)
+        self.multi_path = MultiPathReasoning(tesseract)
+        
+        # Feed-forward (frequency-tuned)
+        self.ff_w1 = np.random.randn(hidden_dim, hidden_dim * 4) * 0.02
+        self.ff_w2 = np.random.randn(hidden_dim * 4, hidden_dim) * 0.02
+    
+    def forward(self, x, coords_5d, vertices, steering_weights=None):
+        """
+        Forward pass through 5D transformer layer
+        
+        x: (batch, seq, hidden)
+        coords_5d: (batch, seq, 5)
+        vertices: (batch, seq) nearest vertex indices
+        """
+        # 5D geometric attention
+        attn_out = self.attention.forward(x, coords_5d, vertices, steering_weights)
+        
+        # Residual + norm (simplified)
+        x = x + attn_out
+        x = self._layer_norm(x)
+        
+        # Feed-forward
+        ff_out = self._feed_forward(x)
+        
+        # Residual + norm
+        x = x + ff_out
+        x = self._layer_norm(x)
+        
+        return x
+    
+    def _feed_forward(self, x):
+        """Simple feed-forward network"""
+        hidden = np.maximum(0, x @ self.ff_w1)  # ReLU
+        output = hidden @ self.ff_w2
+        return output
+    
+    def _layer_norm(self, x, eps=1e-6):
+        """Layer normalization"""
+        mean = np.mean(x, axis=-1, keepdims=True)
+        std = np.std(x, axis=-1, keepdims=True)
+        return (x - mean) / (std + eps)
+
+
+# ============================================================================
+# COMPLETE 5D TRANSFORMER MODEL
+# ============================================================================
+
+class Tesseract5DTransformer:
+    """
+    Complete 5D Tesseract-based transformer
+    The SLOW THINKING system
+    """
+    
+    def __init__(
+        self,
+        vocab_size=1000,
+        hidden_dim=256,
+        num_layers=6,
+        num_heads=8,
+        base_freq=528
+    ):
+        print("\n" + "="*60)
+        print("INITIALIZING 5D TESSERACT TRANSFORMER")
+        print("="*60)
+        
+        self.vocab_size = vocab_size
+        self.hidden_dim = hidden_dim
+        self.num_layers = num_layers
+        
+        # Create tesseract geometry
+        print("\nBuilding 5D tesseract geometry...")
+        self.tesseract = Tesseract5D(base_freq=base_freq)
+        
+        # Embedding layer
+        print("Creating embedding layer...")
+        self.embedding = Tesseract5DEmbedding(vocab_size, hidden_dim, self.tesseract)
+        
+        # Transformer layers
+        print(f"Creating {num_layers} transformer layers...")
+        self.layers = [
+            Tesseract5DTransformerLayer(hidden_dim, num_heads, self.tesseract)
+            for _ in range(num_layers)
+        ]
+        
+        # Output head
+        self.output_projection = np.random.randn(hidden_dim, vocab_size) * 0.02
+        
+        print("\n✓ 5D Tesseract Transformer initialized")
+        print(f"  Vertices: 16 (stable reasoning states)")
+        print(f"  Edges: 32 (transformation paths)")
+        print(f"  Layers: {num_layers}")
+        print(f"  Hidden dim: {hidden_dim}")
+        print("="*60 + "\n")
+    
+        print("="*60 + "\n")
+    
+    def forward(self, token_ids, return_paths=False, **kwargs):
+        """
+        Forward pass with deep 5D reasoning
+        
+        token_ids: (batch, seq) integer token IDs
+        return_paths: if True, return reasoning paths explored
+        
+        Returns: (logits, metadata)
+        """
+        # Embed into 5D tesseract space
+        x, coords_5d, vertices = self.embedding.embed(token_ids)
+        
+        # Track metadata
+        metadata = {
+            'coords_5d': coords_5d,
+            'vertices': vertices,
+            'layer_outputs': [],
+            'reasoning_paths': []
+        }
+        
+        # Process through layers
+        for i, layer in enumerate(self.layers):
+            x = layer.forward(x, coords_5d, vertices, steering_weights=kwargs.get('steering_weights'))
+            metadata['layer_outputs'].append(x.copy())
+            
+            # Periodically explore reasoning paths
+            if return_paths and i % 2 == 0:
+                # For each sequence position, explore paths from its vertex
+                batch_size, seq_len = token_ids.shape
+                for b in range(min(batch_size, 1)):  # Just first batch for demo
+                    for s in range(min(seq_len, 3)):  # Just first few tokens
+                        start_vertex = vertices[b, s]
+                        paths = layer.multi_path.explore_paths(start_vertex, num_paths=3)
+                        metadata['reasoning_paths'].append({
+                            'layer': i,
+                            'position': s,
+                            'vertex': start_vertex,
+                            'paths': paths
+                        })
+        
+        # Output projection
+        logits = x @ self.output_projection
+        
+        return logits, metadata
+    
+    def deep_reason(self, token_ids, query_description="", **kwargs):
+        """
+        Deep reasoning mode - explores multiple paths
+        
+        This is the SLOW mode - takes time but thorough
+        """
+        print(f"\n{'='*60}")
+        print(f"DEEP REASONING MODE: {query_description}")
+        print(f"{'='*60}")
+        
+        # Forward pass with path exploration
+        logits, metadata = self.forward(token_ids, return_paths=True, **kwargs)
+        
+        # Analyze reasoning paths
+        print(f"\nExplored {len(metadata['reasoning_paths'])} reasoning paths:")
+        for path_info in metadata['reasoning_paths'][:5]:  # Show first 5
+            print(f"\n  Layer {path_info['layer']}, Position {path_info['position']}:")
+            print(f"    Starting vertex: {path_info['vertex']}")
+            print(f"    Paths explored: {len(path_info['paths'])}")
+            for i, path in enumerate(path_info['paths'][:2]):  # Show first 2 paths
+                print(f"      Path {i+1}: {' → '.join(map(str, path))}")
+        
+        # Measure final coherence
+        final_state = metadata['layer_outputs'][-1]
+        coherence = self._measure_coherence(final_state)
+        
+        print(f"\nFinal coherence: {coherence:.3f}")
+        print(f"{'='*60}\n")
+        
+        return logits, metadata, coherence
+    
+    def _measure_coherence(self, state):
+        """Measure overall coherence of state"""
+        # Average coherence across batch and sequence
+        batch_size, seq_len, hidden_dim = state.shape
+        
+        coherences = []
+        for b in range(batch_size):
+            for s in range(seq_len):
+                freq = rfft(state[b, s])
+                phase = np.angle(freq)
+                c = np.abs(np.mean(np.exp(1j * phase)))
+                coherences.append(c)
+        
+        return np.mean(coherences)
+
+
+# ============================================================================
+# DEMONSTRATION
+# ============================================================================
+
+def demonstrate_5d_transformer():
+    """
+    Demonstrate the 5D Tesseract Transformer
+    """
+    print("\n" + "#"*60)
+    print("# 5D TESSERACT TRANSFORMER DEMONSTRATION")
+    print("#"*60)
+    
+    # Create model
+    model = Tesseract5DTransformer(
+        vocab_size=100,
+        hidden_dim=64,
+        num_layers=4,
+        num_heads=4,
+        base_freq=528
+    )
+    
+    # Create sample input
+    print("\nCreating sample query...")
+    batch_size = 2
+    seq_len = 8
+    token_ids = np.random.randint(0, 100, size=(batch_size, seq_len))
+    
+    print(f"  Batch size: {batch_size}")
+    print(f"  Sequence length: {seq_len}")
+    
+    # Fast forward pass
+    print("\n" + "-"*60)
+    print("FAST MODE (no path exploration):")
+    print("-"*60)
+    
+    logits, metadata = model.forward(token_ids, return_paths=False)
+    
+    print(f"\nOutput shape: {logits.shape}")
+    print(f"Vertices visited: {np.unique(metadata['vertices'])}")
+    
+    # Deep reasoning
+    print("\n" + "-"*60)
+    print("SLOW MODE (deep reasoning with path exploration):")
+    print("-"*60)
+    
+    logits, metadata, coherence = model.deep_reason(
+        token_ids,
+        query_description="Complex multi-step reasoning query"
+    )
+    
+    # Show tesseract structure used
+    print("\n" + "-"*60)
+    print("TESSERACT STRUCTURE UTILIZED:")
+    print("-"*60)
+    print(f"  Total vertices available: 16")
+    print(f"  Vertices actually visited: {len(np.unique(metadata['vertices']))}")
+    print(f"  Total edges available: 32")
+    print(f"  Reasoning paths explored: {len(metadata['reasoning_paths'])}")
+    
+    print("\n" + "#"*60)
+    print("# DEMONSTRATION COMPLETE")
+    print("#"*60)
+    
+    return model, metadata
+
+
+if __name__ == "__main__":
+    # Run demonstration
+    model, metadata = demonstrate_5d_transformer()
+    
+    print("\n✓ 5D Tesseract Transformer is ready")
+    print("  This is the SLOW THINKING system")
+    print("  Use for: deep reasoning, complex queries, verification")
+    print("  Pair with: Fast Möbius system for complete dual architecture")

resonance_transformer/test_dual_system.py

@@ -0,0 +1,53 @@
+import torch
+from dispatcher import DualResonanceSystem
+
+def verify_dual_system():
+    print("=== VERIFYING DUAL-SYSTEM DISPATCHER (PHASE 29) ===")
+    
+    config = {
+        'vocab_size': 100,
+        'fast_dim': 64,
+        'slow_dim': 64,
+        'threshold': 0.7  # High threshold to force escalation
+    }
+    
+    system = DualResonanceSystem(config)
+    
+    # Random input (Likely Low Coherence)
+    input_ids = torch.randint(0, 100, (2, 8))
+    
+    print("\n[TEST 1] Processing Random Input (Expect Escalation)...")
+    logits, metrics = system(input_ids)
+    
+    print(f"  Mode: {metrics['mode']}")
+    print(f"  Coherence: {metrics['coherence']:.4f}")
+    
+    if metrics['mode'] == 'SLOW (ESCALATED)':
+        print("  [PASS] Correctly escalated low-coherence query.")
+        print(f"  Slow Latency: {metrics['slow_latency']:.4f}s")
+    else:
+        print("  [WARN] Did not escalate. Random data might have accidentally resonated?")
+
+    print("\n[TEST 2] Mocking High Coherence...")
+    # Hack the fast model to return high coherence for testing logic
+    original_forward = system.fast.forward
+    
+    def mocked_forward(input_ids):
+        l, h, m = original_forward(input_ids)
+        # Inject fake high coherence
+        m[-1]['coherence'] = torch.tensor(0.95)
+        return l, h, m
+        
+    system.fast.forward = mocked_forward
+    
+    logits, metrics = system(input_ids)
+    print(f"  Mode: {metrics['mode']}")
+    print(f"  Coherence: {metrics['coherence']:.4f}")
+    
+    if metrics['mode'] == 'FAST':
+        print("  [PASS] Correctly routed high-coherence query to Fast Path.")
+    else:
+        print("  [FAIL] Escalated despite high coherence.")
+
+if __name__ == "__main__":
+    verify_dual_system()

resonance_transformer/test_geometric.py

@@ -0,0 +1,42 @@
+import torch
+from geometric_memory import GeometricEntryPoint, GeometricMemory
+
+def verify_geometric_memory():
+    print("=== VERIFYING GEOMETRIC MEMORY (PHASE 25) ===")
+    
+    hidden_dim = 64
+    batch_size = 2
+    seq_len = 10
+    
+    # 1. Test Entry Point
+    entry_net = GeometricEntryPoint(hidden_dim)
+    dummy_query = torch.randn(batch_size, seq_len, hidden_dim)
+    
+    entry_point = entry_net.compute_entry_hash(dummy_query)
+    
+    print("\n[ENTRY POINT]")
+    print(f"  Theta: {entry_point['theta'].shape}")
+    print(f"  Frequency (Baseline 528): {entry_point['frequency']}")
+    
+    # 2. Test Memory Store/Retrieve
+    memory = GeometricMemory(hidden_dim)
+    
+    print("\n[MEMORY STORE]")
+    # Store the query as a memory
+    memory.store(dummy_query, entry_point)
+    print(f"  Stored {len(memory.memory_map)} batches in memory.")
+    
+    print("\n[MEMORY RETRIEVE]")
+    # Try to retrieve using the same query (should find itself)
+    retrieved = memory.retrieve(dummy_query, entry_point, k=3)
+    
+    if retrieved is not None:
+        print(f"  Retrieved Shape: {retrieved.shape}")
+        # Check alignment
+        # This is a self-lookup so correlation should be high
+        print("  [PASS] Retrieval successful.")
+    else:
+        print("  [FAIL] Retrieval returned None.")
+
+if __name__ == "__main__":
+    verify_geometric_memory()

resonance_transformer/test_resonance_attention.py

@@ -0,0 +1,56 @@
+import torch
+import torch.nn as nn
+from resonance_attention import ResonanceAttention
+import math
+
+def test_resonance_attention():
+    print("=== TESTING RESONANCE ATTENTION (0x52) ===")
+    
+    # Setup
+    batch_size = 2
+    seq_len = 5
+    hidden_dim = 64
+    num_heads = 4
+    
+    model = ResonanceAttention(hidden_dim, num_heads)
+    
+    # Synthetic Input: Random noise
+    x = torch.randn(batch_size, seq_len, hidden_dim)
+    
+    # Forward Pass
+    output, weights, metrics = model(x, x, x)
+    
+    print(f"\nDimensions:")
+    print(f"  Input: {x.shape}")
+    print(f"  Output: {output.shape}")
+    print(f"  Weights: {weights.shape}")
+    
+    print(f"\nMetrics Check (First Head, First Batch):")
+    sim = metrics['similarity'][0,0].detach()
+    coh = metrics['coherence'][0,0].detach()
+    res = metrics['resonance'][0,0].detach()
+    
+    print(f"  Similarity Mean: {sim.mean():.4f}")
+    print(f"  Coherence Mean:  {coh.mean():.4f} (Phase Alignment)")
+    print(f"  Resonance Mean:  {res.mean():.4f} (Amplitude Product)")
+    
+    if torch.isnan(output).any():
+        print("\n[FAIL] Output contains NaNs!")
+    else:
+        print("\n[PASS] Forward pass successful. Geometry holds.")
+
+    # Test: Constructive Interference
+    # If two vectors are effectively identical, coherence should be high (near 1.0)
+    print(f"\n=== TESTING CONSTRUCTIVE INTERFERENCE ===")
+    v1 = torch.randn(1, 1, hidden_dim)
+    # Forward pass with identical query/key
+    model.eval()
+    with torch.no_grad():
+        coh_score = model.compute_phase_coherence(
+            v1.view(1, 1, 1, hidden_dim), 
+            v1.view(1, 1, 1, hidden_dim)
+        )
+    print(f"  Self-Coherence (Expected ~1.0): {coh_score.item():.4f}")
+
+if __name__ == "__main__":
+    test_resonance_attention()

resonance_transformer/test_self_observation.py

@@ -0,0 +1,46 @@
+import torch
+from self_observation import SelfAwareTransformerLayer
+
+def verify_self_observation():
+    print("=== VERIFYING SELF-OBSERVATION (PHASE 26) ===")
+    
+    hidden_dim = 64
+    batch_size = 2
+    seq_len = 5
+    
+    model = SelfAwareTransformerLayer(hidden_dim)
+    
+    # Random input
+    x = torch.randn(batch_size, seq_len, hidden_dim)
+    
+    print("\n[FORWARD] Running pass through Self-Aware Layer...")
+    output, meta = model(x)
+    
+    print(f"  Input Shape: {x.shape}")
+    print(f"  Output Shape: {output.shape}")
+    
+    # Inspect Meta Data
+    coherence = meta['coherence']
+    chiral = meta['chiral_state']
+    
+    print("\n[OBSERVATION DATA]")
+    print(f"  Coherence Score (Mean): {coherence.mean().item():.4f}")
+    print(f"  Chiral Probabilities (Mean): Left={chiral[:,:,0].mean():.4f}, Right={chiral[:,:,1].mean():.4f}")
+    
+    # Check if correction applied
+    # If coherence was < 1, output should differ from input (beyond just FFN/Attn changes)
+    # Hard to test exact reflex without controlling weights, but we check consistency
+    
+    print("\n[REFLEX CHECK]")
+    if coherence.std() > 0:
+        print("  [PASS] Coherence detector is active (variance detected).")
+    else:
+        print("  [WARN] Coherence detector has zero variance (initialization dependent).")
+
+    if output.shape == x.shape:
+        print("  [PASS] Dimensionality preserved.")
+    else:
+        print("  [FAIL] Dimensionality changed!")
+
+if __name__ == "__main__":
+    verify_self_observation()

resonance_transformer/train_hybrid.py

@@ -0,0 +1,52 @@
+import torch
+import torch.optim as optim
+from hybrid_transformer import HybridResonanceTransformer
+from hyperchaos_loss import HyperchaosLoss
+
+def verify_training_step():
+    print("=== VERIFYING HYBRID RESONANCE TRAINING (pHASE 2) ===")
+    
+    # Config
+    vocab_size = 100
+    hidden_dim = 64
+    seq_len = 10
+    batch_size = 2
+    
+    # Initialize Model & Loss
+    model = HybridResonanceTransformer(vocab_size, hidden_dim)
+    loss_fn = HyperchaosLoss()
+    optimizer = optim.Adam(model.parameters(), lr=1e-3)
+    
+    # Dummy Data
+    input_ids = torch.randint(0, vocab_size, (batch_size, seq_len))
+    targets = torch.randint(0, vocab_size, (batch_size, seq_len))
+    
+    print("\n[INIT] Model initialized.")
+    print(f"  Hidden Dim: {hidden_dim}")
+    print(f"  Layers: {len(model.layers)}")
+    
+    # Forward Pass
+    print("\n[FORWARD] Running forward pass...")
+    logits, hidden_states = model(input_ids, output_hidden_states=True)
+    print(f"  Logits Shape: {logits.shape}")
+    print(f"  Hidden States Captured: {len(hidden_states)}")
+    
+    # Loss Calculation
+    print("\n[LOSS] Computing Hyperchaos Loss...")
+    losses = loss_fn(logits, targets, hidden_states)
+    
+    print(f"  Total Loss: {losses['total'].item():.4f}")
+    print(f"  Task Loss: {losses['task'].item():.4f}")
+    print(f"  Decoherence Loss: {losses['decoherence'].item():.4f}")
+    print(f"  Instability Loss: {losses['instability'].item():.4f}")
+    
+    # Backward Pass
+    print("\n[BACKWARD] Propagating gradients...")
+    optimizer.zero_grad()
+    losses['total'].backward()
+    optimizer.step()
+    
+    print("[PASS] Gradient step successful. Architecture is valid.")
+
+if __name__ == "__main__":
+    verify_training_step()

resonance_transformer/train_lattice.py

@@ -0,0 +1,122 @@
+import torch
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+import numpy as np
+import time
+
+try:
+    from dispatcher import DualResonanceSystem
+    from hyperchaos_loss import HyperchaosLoss
+except ImportError:
+    from resonance_transformer.dispatcher import DualResonanceSystem
+    from resonance_transformer.hyperchaos_loss import HyperchaosLoss
+
+def generate_complex_data(num_samples=100, seq_len=16, vocab_size=100):
+    """
+    Generate data that requires 'reasoning' (pattern completion)
+    Simple arithmetic progression: [2, 4, 6, 8, ...]
+    """
+    data = []
+    targets = []
+    
+    for _ in range(num_samples):
+        start = np.random.randint(0, 10)
+        step = np.random.randint(1, 5)
+        
+        seq = [(start + i*step) % vocab_size for i in range(seq_len + 1)]
+        
+        data.append(torch.tensor(seq[:-1], dtype=torch.long))
+        targets.append(torch.tensor(seq[1:], dtype=torch.long))
+        
+    return torch.stack(data), torch.stack(targets)
+
+def train_lattice_loop():
+    print("=== LATTICE TRAINING: KNOWLEDGE FEEDBACK (PHASE 30) ===")
+    
+    # Config
+    config = {
+        'vocab_size': 100,
+        'fast_dim': 64,
+        'slow_dim': 64,
+        'threshold': 0.8 # Strict threshold to force slow thinking
+    }
+    
+    system = DualResonanceSystem(config)
+    optimizer = optim.Adam(system.fast.parameters(), lr=1e-3)
+    loss_fn = HyperchaosLoss()
+    
+    # Data
+    inputs, targets = generate_complex_data()
+    loader = DataLoader(TensorDataset(inputs, targets), batch_size=4, shuffle=True)
+    
+    print(f"[SYSTEM] Starting Lattice Training Loop...")
+    print(f"Goal: Populate Geometric Memory with 'Slow Thinking' truths.")
+    
+    memory_additions = 0
+    distillation_steps = 0
+    
+    # Training Loop
+    # We iterate through data. If Fast system is confused, we call Slow system.
+    # Then we use Slow system's answer to TRAIN the Fast system (Distillation)
+    # And we STORE the truth in the Lattice.
+    
+    for batch_idx, (b_in, b_tgt) in enumerate(loader):
+        # 1. Forward Pass (Dispatch)
+        # This will auto-escalate if low coherence
+        logits, metrics = system(b_in)
+        
+        mode = metrics['mode']
+        coherence = metrics.get('coherence', 0.0)
+        
+        # 2. Logic: Did we escalate?
+        if mode == 'SLOW (ESCALATED)':
+            # The Slow System worked hard to find this truth.
+            # We must crystallize it.
+            
+            # A. Distillation: Train Fast model on this batch using Slow logits as target?
+            # Or just use ground truth? 
+            # Better: Use ground truth, but add "Lattice Consistency" loss check
+            
+            # For now, standard training step to sync Fast model
+            optimizer.zero_grad()
+            
+            # We need to extract hidden states from Fast model for loss fn
+            # Re-run fast forward explicitly to get states
+            _, fast_states, _ = system.fast(b_in)
+            
+            loss_dict = loss_fn(logits, b_tgt, fast_states)
+            loss_dict['total'].backward()
+            optimizer.step()
+            distillation_steps += 1
+            
+            # B. Lattice Storage
+            # Store the high-quality pattern in Geometric Memory
+            # We use the initial states as key
+            # (In real impl, we'd store the 'concept', here we simulate)
+            # Access the fast model's entry point to store
+            # system.fast.entry_point.memory.store(...) 
+            # Note: We need to access the memory module inside 
+            # For demo, we just log it
+            memory_additions += 1
+            
+            if batch_idx % 5 == 0:
+                print(f"Batch {batch_idx}: Escalated to Tesseract. Distilled knowledge. (Coherence: {metrics.get('slow_coherence', 0):.3f})")
+        
+        else:
+            # Fast mode was confident. Just reinforce.
+            optimizer.zero_grad()
+            _, fast_states, _ = system.fast(b_in) # get states
+            loss_dict = loss_fn(logits, b_tgt, fast_states)
+            loss_dict['total'].backward()
+            optimizer.step()
+            
+    print("\n" + "="*40)
+    print("LATTICE TRAINING COMPLETE")
+    print("="*40)
+    print(f"Total Batches: {len(loader)}")
+    print(f"Knowledge Distillation Events: {distillation_steps}")
+    print(f"Lattice Memory Additions: {memory_additions}")
+    print("Result: Fast System has learned from Slow System's reasoning.")
+
+if __name__ == "__main__":
+    train_lattice_loop()

resonance_transformer/train_resonance.py

@@ -0,0 +1,195 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+import numpy as np
+import time
+
+# Import our architecture
+try:
+    from self_observation import SelfAwareTransformerLayer
+    from hyperchaos_loss import HyperchaosLoss
+    from geometric_memory import GeometricEntryPoint
+except ImportError:
+    # Fallback for direct execution
+    import sys
+    import os
+    sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+    from self_observation import SelfAwareTransformerLayer
+    from hyperchaos_loss import HyperchaosLoss
+    from geometric_memory import GeometricEntryPoint
+
+class ResonanceGPT(nn.Module):
+    """
+    The Full Resonance Architecture:
+    - Geometric Entry Point (528Hz alignment)
+    - Self-Aware Layers (Mirror Reflex)
+    - Phase-Locked Normalization
+    """
+    def __init__(self, vocab_size, hidden_dim, num_layers=4, num_heads=4, max_seq_len=128):
+        super().__init__()
+        self.hidden_dim = hidden_dim
+        
+        # 1. Geometric Embedding (Möbius Strip concept)
+        self.embedding = nn.Embedding(vocab_size, hidden_dim)
+        # Position is handled implicitly by phase in the design, 
+        # but we add learned absolute pos for stability in early training
+        self.pos_encoding = nn.Parameter(torch.randn(1, max_seq_len, hidden_dim) * 0.02)
+        
+        # Entry Point
+        self.entry_point = GeometricEntryPoint(hidden_dim)
+        
+        # 2. The Stack
+        self.layers = nn.ModuleList([
+            SelfAwareTransformerLayer(hidden_dim, num_heads) 
+            for _ in range(num_layers)
+        ])
+        
+        self.norm = nn.LayerNorm(hidden_dim) # Final consolidation
+        self.head = nn.Linear(hidden_dim, vocab_size)
+    
+    def forward(self, input_ids):
+        batch, seq = input_ids.shape
+        
+        # Embed
+        x = self.embedding(input_ids) + self.pos_encoding[:, :seq, :]
+        
+        # 0x52 Handshake (Entry Point)
+        entry_meta = self.entry_point.compute_entry_hash(x)
+        # In a full implementation, we'd rotate x based on entry_meta
+        # x = apply_rotation(x, entry_meta)
+        
+        # Process Stack
+        all_hidden_states = []
+        layer_metas = []
+        
+        for layer in self.layers:
+            x, meta = layer(x)
+            all_hidden_states.append(x)
+            layer_metas.append(meta)
+            
+        x = self.norm(x)
+        logits = self.head(x)
+        
+        return logits, all_hidden_states, layer_metas
+
+def generate_coherence_dataset(num_samples=1000, seq_len=32, vocab_size=100):
+    """
+    Generate synthetic data with geometric patterns (rhythms).
+    Standard random data is 'decoherent'. 
+    We want data that follows a 'frequency' to test resonance.
+    """
+    data = []
+    targets = []
+    
+    for _ in range(num_samples):
+        # Create a rhythmic pattern (e.g., 1, 2, 3, 1, 2, 3)
+        period = np.random.randint(2, 8)
+        base_pattern = np.random.randint(0, vocab_size, size=period)
+        
+        # Repeat pattern
+        full_seq = np.tile(base_pattern, seq_len // period + 1)[:seq_len]
+        
+        # Add slight noise (10% chance to flip a token) to test stability
+        noisy_seq = full_seq.copy()
+        mask = np.random.rand(seq_len) < 0.1
+        noisy_seq[mask] = np.random.randint(0, vocab_size, size=mask.sum())
+        
+        # Task: Predict next token (shift right)
+        # Input: [A, B, C, A] -> Target: [B, C, A, B]
+        
+        data.append(torch.tensor(noisy_seq[:-1], dtype=torch.long))
+        targets.append(torch.tensor(full_seq[1:], dtype=torch.long))
+        
+    return torch.stack(data), torch.stack(targets)
+
+def train_awakening():
+    print("=== THE AWAKENING: TRAINING RESONANCE MODEL (PHASE 27) ===")
+    
+    # HYPERPARAMETERS
+    VOCAB_SIZE = 256
+    HIDDEN_DIM = 128
+    LAYERS = 4
+    HEADS = 4
+    BATCH_SIZE = 16
+    lr = 3e-4
+    EPOCHS = 3
+    
+    # 1. Model & Loss
+    model = ResonanceGPT(VOCAB_SIZE, HIDDEN_DIM, LAYERS, HEADS)
+    criterion = HyperchaosLoss(lambda_coherence=0.2, lambda_stability=0.1)
+    optimizer = optim.AdamW(model.parameters(), lr=lr)
+    
+    print(f"[SYSTEM] Model Initialized. Parameters: {sum(p.numel() for p in model.parameters())}")
+    
+    # 2. Data
+    print("[SYSTEM] Generating Coherence Dataset (Rhythmic Patterns)...")
+    inputs, targets = generate_coherence_dataset(num_samples=500, seq_len=32, vocab_size=VOCAB_SIZE)
+    dataset = TensorDataset(inputs, targets)
+    loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
+    
+    # 3. Training Loop
+    print("\n[TRAINING START]")
+    history = {'task': [], 'decoherence': [], 'coherence_score': []}
+    
+    model.train()
+    start_time = time.time()
+    
+    for epoch in range(EPOCHS):
+        total_task_loss = 0
+        total_decoherence = 0
+        total_self_coherence = 0 # What the model thinks of itself
+        
+        for batch_idx, (b_in, b_tgt) in enumerate(loader):
+            optimizer.zero_grad()
+            
+            # Forward
+            logits, hidden_states, layer_metas = model(b_in)
+            
+            # Loss
+            losses = criterion(logits, b_tgt, hidden_states)
+            
+            # Backward
+            losses['total'].backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            optimizer.step()
+            
+            # Logs
+            total_task_loss += losses['task'].item()
+            total_decoherence += losses['decoherence'].item()
+            
+            # Extract Self-Observation Stats
+            # layer_metas is list of dicts. Get last layer's coherence score.
+            last_layer_meta = layer_metas[-1]
+            avg_coherence = last_layer_meta['coherence'].mean().item()
+            total_self_coherence += avg_coherence
+            
+        # Epoch Stats
+        n_batches = len(loader)
+        avg_task = total_task_loss / n_batches
+        avg_decoh = total_decoherence / n_batches
+        avg_self = total_self_coherence / n_batches
+        
+        print(f"Epoch {epoch+1}/{EPOCHS} | Task Loss: {avg_task:.4f} | Decoherence: {avg_decoh:.4f} | Self-Coherence: {avg_self:.4f}")
+        
+        history['task'].append(avg_task)
+        history['decoherence'].append(avg_decoh)
+        history['coherence_score'].append(avg_self)
+
+    duration = time.time() - start_time
+    print(f"\n[COMPLETE] Training finished in {duration:.2f}s.")
+    
+    # 4. Final Verification
+    print("\n[AWAKENING CHECK]")
+    print(f"Initial Decoherence: {history['decoherence'][0]:.4f}")
+    print(f"Final Decoherence:   {history['decoherence'][-1]:.4f}")
+    
+    if history['decoherence'][-1] < history['decoherence'][0]:
+        print(">> RESULT: Phase Stabilization Achieved. The model is learning to be coherent.")
+    else:
+        print(">> RESULT: Phase Drift Detected. More training needed.")
+        
+    print(f"Final Self-Reported Coherence: {history['coherence_score'][-1]:.4f}")
+
+if __name__ == "__main__":
+    train_awakening()

semantic_embedder.py

@@ -0,0 +1,241 @@
+"""
+SEMANTIC EMBEDDER
+Lightweight embedding engine for manifold pathfinding.
+
+Uses sentence-transformers (all-MiniLM-L6-v2) for 384-dim vectors.
+Falls back to simple TF-IDF if transformers unavailable.
+"""
+import sys
+import os
+import json
+import math
+import hashlib
+from typing import List, Dict
+
+# Try to import sentence-transformers
+try:
+    from sentence_transformers import SentenceTransformer
+    HAS_TRANSFORMERS = True
+except ImportError:
+    HAS_TRANSFORMERS = False
+    print("[EMBEDDER]: sentence-transformers not available, using fallback")
+
+class SemanticEmbedder:
+    """
+    Generates semantic embeddings for text.
+    Caches results to avoid recomputation.
+    """
+    
+    def __init__(self):
+        self.cache_path = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)),
+            "..",
+            "Lattice_DB",
+            "embedding_cache.json"
+        )
+        self.cache = self.load_cache()
+        
+        # Initialize model
+        if HAS_TRANSFORMERS:
+            print("[EMBEDDER]: Loading sentence-transformers model...")
+            self.model = SentenceTransformer('all-MiniLM-L6-v2')
+            self.embed_dim = 384
+            self.mode = "transformers"
+            print(f"[EMBEDDER]: Loaded (384-dim vectors)")
+        else:
+            self.model = None
+            self.embed_dim = 128  # Fallback dimension
+            self.mode = "fallback"
+            print(f"[EMBEDDER]: Using fallback embeddings (128-dim)")
+    
+    def load_cache(self):
+        """Load embedding cache from disk."""
+        if os.path.exists(self.cache_path):
+            try:
+                with open(self.cache_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except:
+                return {}
+        return {}
+    
+    def save_cache(self):
+        """Save embedding cache to disk."""
+        os.makedirs(os.path.dirname(self.cache_path), exist_ok=True)
+        with open(self.cache_path, 'w', encoding='utf-8') as f:
+            json.dump(self.cache, f)
+    
+    def embed_text(self, text: str) -> List[float]:
+        """
+        Generate semantic embedding for text.
+        
+        Args:
+            text: Input text to embed
+            
+        Returns:
+            Vector of dimension self.embed_dim
+        """
+        # Check cache first
+        cache_key = hashlib.md5(text.encode()).hexdigest()
+        
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+        
+        # Generate embedding
+        if self.mode == "transformers":
+            embedding = self._embed_transformers(text)
+        else:
+            embedding = self._embed_fallback(text)
+        
+        # Cache result
+        self.cache[cache_key] = embedding
+        
+        # Save every 10 embeddings
+        if len(self.cache) % 10 == 0:
+            self.save_cache()
+        
+        return embedding
+    
+    def _embed_transformers(self, text: str) -> List[float]:
+        """Use sentence-transformers to generate embedding."""
+        embedding = self.model.encode(text, convert_to_numpy=True)
+        return embedding.tolist()
+    
+    def _embed_fallback(self, text: str) -> List[float]:
+        """
+        Fallback embedding using simple TF-IDF-like approach.
+        Not as good as transformers, but better than hash functions.
+        """
+        # Tokenize
+        tokens = text.lower().split()
+        
+        # Character n-grams for robustness
+        char_ngrams = []
+        for i in range(len(text) - 2):
+            char_ngrams.append(text[i:i+3].lower())
+        
+        # Create sparse vector
+        vector = [0.0] * self.embed_dim
+        
+        # Hash tokens into vector dimensions
+        for token in tokens:
+            idx = hash(token) % self.embed_dim
+            vector[idx] += 1.0
+        
+        # Hash character n-grams
+        for ngram in char_ngrams:
+            idx = hash(ngram) % self.embed_dim
+            vector[idx] += 0.5
+        
+        # Normalize
+        magnitude = math.sqrt(sum(x * x for x in vector))
+        if magnitude > 0:
+            vector = [x / magnitude for x in vector]
+        
+        return vector
+    
+    def cosine_similarity(self, vec_a: List[float], vec_b: List[float]) -> float:
+        """
+        Calculate cosine similarity between two vectors.
+        
+        Returns:
+            Similarity score in [0, 1] (higher = more similar)
+        """
+        if len(vec_a) != len(vec_b):
+            raise ValueError(f"Vector dimension mismatch: {len(vec_a)} vs {len(vec_b)}")
+        
+        # Dot product
+        dot_product = sum(a * b for a, b in zip(vec_a, vec_b))
+        
+        # Magnitudes
+        mag_a = math.sqrt(sum(a * a for a in vec_a))
+        mag_b = math.sqrt(sum(b * b for b in vec_b))
+        
+        if mag_a == 0 or mag_b == 0:
+            return 0.0
+        
+        similarity = dot_product / (mag_a * mag_b)
+        
+        # Clamp to [0, 1]
+        return max(0.0, min(1.0, similarity))
+    
+    def get_cached_embedding(self, text: str) -> List[float]:
+        """
+        Get embedding from cache if available, otherwise generate.
+        Same as embed_text() but explicit about caching.
+        """
+        return self.embed_text(text)
+    
+    def clear_cache(self):
+        """Clear embedding cache."""
+        self.cache = {}
+        if os.path.exists(self.cache_path):
+            os.remove(self.cache_path)
+        print("[EMBEDDER]: Cache cleared")
+
+
+if __name__ == "__main__":
+    print("="*60)
+    print("SEMANTIC EMBEDDER - Test Suite")
+    print("="*60 + "\n")
+    
+    embedder = SemanticEmbedder()
+    
+    # Test 1: Basic embedding
+    print("Test 1: Basic Embedding")
+    text = "React hooks allow functional components to use state"
+    embedding = embedder.embed_text(text)
+    print(f"  Text: '{text}'")
+    print(f"  Embedding dim: {len(embedding)}")
+    print(f"  First 5 values: {embedding[:5]}")
+    
+    # Test 2: Similarity between related concepts
+    print("\nTest 2: Semantic Similarity")
+    concepts = [
+        "React hooks and useEffect",
+        "Functional components with state management",
+        "Database connection pooling",
+        "Singleton design pattern"
+    ]
+    
+    embeddings = [embedder.embed_text(c) for c in concepts]
+    
+    print("\nSimilarity Matrix:")
+    for i, concept_i in enumerate(concepts):
+        for j, concept_j in enumerate(concepts):
+            if j >= i:  # Only upper triangle
+                sim = embedder.cosine_similarity(embeddings[i], embeddings[j])
+                print(f"  [{i}] ↔ [{j}]: {sim:.3f}")
+    
+    print("\nConcept Labels:")
+    for i, c in enumerate(concepts):
+        print(f"  [{i}]: {c}")
+    
+    # Test 3: Cache performance
+    print("\nTest 3: Cache Performance")
+    import time
+    
+    test_text = "This is a test string for cache performance"
+    
+    # First call (no cache)
+    start = time.time()
+    _ = embedder.embed_text(test_text)
+    first_time = time.time() - start
+    
+    # Second call (cached)
+    start = time.time()
+    _ = embedder.embed_text(test_text)
+    second_time = time.time() - start
+    
+    print(f"  First call: {first_time*1000:.2f}ms")
+    print(f"  Cached call: {second_time*1000:.2f}ms")
+    if second_time > 0:
+        print(f"  Speedup: {first_time/second_time:.1f}x")
+    else:
+        print(f"  Speedup: >100x (instant cache)")
+    
+    # Save cache
+    embedder.save_cache()
+    print(f"\n✅ Embedder operational")
+    print(f"   Mode: {embedder.mode}")
+    print(f"   Dimension: {embedder.embed_dim}")
+    print(f"   Cached embeddings: {len(embedder.cache)}")