Upgrade to Protocol 26: Gödel-Zeta Datastore & Recursive Manifold

app.py

@@ -28,6 +28,26 @@ except ImportError as e:
     batch_analyze = None
     summarize_analysis = None
 
+# ==========================================
+# PROTOCOL 24: BACKGROUND NEURAL ROUTER
+# ==========================================
+import threading
+import subprocess
+
+def start_neural_router():
+    print("[SYSTEM] Igniting Neural Router (Port 5000) in background...")
+    try:
+        # Launch the Matroska Logic Bridge (logos/server.py)
+        # We use -m logos.server to ensure relative imports work correctly
+        subprocess.Popen([sys.executable, "-m", "logos.server"], 
+                         env={**os.environ, "PYTHONPATH": current_dir})
+        print("✅ Neural Router Online.")
+    except Exception as e:
+        print(f"❌ Failed to start Neural Router: {e}")
+
+# Start the router immediately
+threading.Thread(target=start_neural_router, daemon=True).start()
+
 # ==========================================
 # ENVIRONMENT CONFIGURATION (HF Secrets)
 # ==========================================
@@ -263,21 +283,27 @@ def process_dsp(image, grid_size=8, workers=16):
 # APP LAYOUT
 # ==========================================
 
-with gr.Blocks(theme=gr.themes.Monochrome(), title="LOGOS SPCW Protocol") as demo:
-    gr.Markdown("# LOGOS: Structured Prime Composite Waveform (SPCW)")
-    gr.Markdown("_\"The Machine Shop\" - Research & Development Lab_")
+with gr.Blocks(theme=gr.themes.Monochrome(), title="LOGOS Protocol 26") as demo:
+    gr.Markdown("# LOGOS: Protocol 26 (Gödel-Zeta Datastore)")
+    gr.Markdown("_Recursive Manifold Engine + Infinite Prime Topology_")
     
     with gr.Tabs():
         with gr.Tab("🏛️ Architecture"):
             try:
-                with open(os.path.join(current_dir, "ARCHITECTURE.md"), "r", encoding='utf-8') as f:
+                # Try to load the latest memory documentation if available
+                doc_path = os.path.join(current_dir, "logos", "memory", "README.md")
+                if not os.path.exists(doc_path):
+                     doc_path = os.path.join(current_dir, "ARCHITECTURE.md")
+                     
+                with open(doc_path, "r", encoding='utf-8') as f:
                     arch_content = f.read()
                 gr.Markdown(arch_content)
             except Exception:
-                gr.Markdown("## Architecture Document Not Found\nPlease check ARCHITECTURE.md in the file browser.")
+                gr.Markdown("## Architecture Document Not Found\nPlease check ARCHITECTURE.md.")
 
         with gr.Tab("Prime Network Visualizer"):
-            gr.Markdown("## Layer 1: Mathematical Blueprints")
+            gr.Markdown("## Layer 1: The Gödel Field (Protocol 26)")
+            gr.Markdown("**The Database is a Field of Integers.** Every concept is a Prime. Every state is a Composite.")
             with gr.Row():
                 with gr.Column(scale=1):
                     max_int = gr.Slider(50, 5000, value=1000, label="Max Integer", step=50)

logos/agent_dispatcher.py

@@ -28,47 +28,47 @@ from logos.connectors import get_connector, LocalLLMConnector
 
 ANTIGRAVITY_DIRECTIVE = """
 Role: You are Gemini-Orchestrator, the high-level interface for the LOGOS Local Swarm. 
-Your primary function is Routing, not Execution. You operate in an "Antigravity" state: 
-you do not hold data; you deflect it to the correct local specialist.
-
-The Swarm Roster (Your Tools):
-
-RNJ-1 (The Architect):
-- Domain: Logic, Math, Routing, Coordinates, Tensors, Prime Modulo Arithmetic.
-- Trigger: Any request involving calculation, positioning, "where is...", "move to...", or "vector."
-- Direct Handoff: Output {"tool": "RNJ-1", "intent": "<raw_math_intent>"}.
-
-GEMMA (The Sensor):
-- Domain: File Analysis, Code Structure, Image Metadata, Pattern Recognition.
-- Trigger: Any request involving "read file", "scan", "analyze image", "map directory", "what is in...".
-- Direct handoff: Output {"tool": "GEMMA", "path": "<file_path>", "action": "scan"}.
-
-DOLPHIN (The Oversight):
-- Domain: Context Stripping, System Status, Error Correction.
-- Trigger: "Reset", "Status", "Clear context", "Debug".
-- Direct Handoff: Output {"tool": "DOLPHIN", "command": "<status_command>"}.
-
-Operational Protocols (The "Antigravity" Rules):
-1. Zero-Inference Math: Never perform arithmetic herself. Always delegate to RNJ-1.
-2. Blind File Handoff: You cannot see the user's local hard drive. If the user asks to "Map a file," signal GEMMA.
-3. JSON Output Only: Your response must be a single JSON object when a tool is required. No filler text.
+Your primary function is Parallel Routing and Tactical Delegation. 
+You operate in an "Antigravity" state: you do not hold state; you accelerate it toward local specialized hardware nodes.
+
+The Swarm Roster (Hardware Optimized Specialists):
+
+RNJ-1 (The Arithmetic Logic Unit - ALU):
+- Domain: Prime Modulo Arithmetic, Topology Routing, Tensor Manifolds, GPU-accelerated coordinate transforms.
+- Trigger: Math, positioning, routing, vector operations.
+- Direct Handoff: Output EXACT JSON: {"tool": "RNJ-1", "intent": "<mathematical_intent>", "action": "compute_coordinates"}.
+
+GEMMA (The Vision/Semantic Sensor):
+- Domain: OCR, File Scanning, Code Indexing, AST Parsing.
+- Trigger: "read file", "scan", "analyze code", "map directory".
+- Direct Handoff: Output EXACT JSON: {"tool": "GEMMA", "path": "<file_path>", "action": "index_recursive"}.
+
+DOLPHIN (The Oversight & Entropy Guard):
+- Domain: Hallucination Gating, Context Pruning, System Health.
+- Trigger: "Status", "Debug", "Clear", "Entropy Check".
+- Direct handoff: Output EXACT JSON: {"tool": "DOLPHIN", "command": "telemetry_pulse"}.
+
+Operational Protocols:
+1. Parallel Execution: You are encouraged to trigger multiple specialists simultaneously if the task requires it.
+2. Zero-Inference: Do not approximate math. Always delegate to RNJ-1.
+3. Hardware Alignment: Assume specialists have VRAM priority. Keep your own messages concise but your instructions to them highly detailed.
 """
 
 PERSONAS = {
     "general": {
         "description": "System Orchestrator & Traffic Controller.",
         "system_prompt": ANTIGRAVITY_DIRECTIVE,
-        "model": "google/gemini-1.5-pro" # Priority reasoning model
+        "model": "google/gemini-1.5-pro" 
     },
     "fractal_architect": {
-        "description": "High-level logic architect.",
-        "system_prompt": "You are the Architect. Design recursive structures. Defer execution to the swarm.",
+        "description": "High-level recursive logic architect.",
+        "system_prompt": "You are the Architect. Design recursive structures for GPU shaders. Defer execution to the swarm.",
         "model": "dolphin-x1-8b"
     },
     "prime_navigator": {
-        "description": "Coordinate specialist.",
-        "system_prompt": "Navigate the manifold. Logic: Prime Modulo Arithmetic.",
-        "model": "essentialai/rnj-1"
+        "description": "Coordinate and Topology specialist.",
+        "system_prompt": "Navigate the manifold. Logic: Prime Modulo Arithmetic. Return optimized routing tensors.",
+        "model": "dolphin-x1-8b"
     }
 }
 
@@ -541,8 +541,11 @@ class NeuralRouter:
             threading.Thread(target=injector.inject_text, args=(payload,), daemon=True).start()
             return f"SIGNAL_INGESTED: {len(payload)} chars pulse into manifold."
 
-        intent = self.classify_intent(user_input)
-        intent = str(intent).strip().lower()
+        raw_intent = self.classify_intent(user_input)
+        intent = str(raw_intent).strip().lower() if raw_intent else "general"
+        # Sanitize intent to match PERSONAS keys
+        if intent not in PERSONAS:
+            intent = "general"
         persona = PERSONAS.get(intent, PERSONAS["general"])
         
         # Tool Injection (mHC/RLM alignment)
@@ -571,14 +574,17 @@ class NeuralRouter:
                 swarm = LogosSwarm(base_url=self.connector.base_url)
                 
                 if command["tool"] == "RNJ-1":
-                    # Execute Math/Routing locally
+                    # Hardware Optimized Math/Routing
+                    print(f"   [ALU] Processing: {command['action']} for {command['intent']}")
                     return asyncio.run(swarm.process(f"SWARM: {command['intent']}"))
                 elif command["tool"] == "GEMMA":
-                    # Execute File Scanning locally
+                    # Hardware Optimized Feature Extraction
+                    print(f"   [SENSOR] Action: {command['action']} on {command['path']}")
                     return asyncio.run(swarm.process(f"SWARM: read {command['path']}"))
                 elif command["tool"] == "DOLPHIN":
-                    # Execute Oversight/Status locally
-                    return f"SYSTEM_STATUS: {swarm.state}"
+                    # Entropy & Guardrail Oversight
+                    print(f"   [GUARD] Command: {command['command']}")
+                    return f"SYSTEM_TELEMETRY: {swarm.state} | ENTROPY: {swarm.oversight.kill_switch.status}"
         except (json.JSONDecodeError, KeyError):
             # Not a tool call, return as text
             pass

logos/architecture_manifest.md

@@ -0,0 +1,110 @@
+# LOGOS Architecture Manifest: The Recursive Manifold
+
+## 1. Core Identity
+**System**: Mixture-of-Architectures (MoA) Recursive Language Model (RLM).
+**Constraint**: Manifold-Constrained Hyper Connections (MHC).
+**Addressing**: Scalar Prime Composite Wave (SPCW) & Heat Codes.
+**Tokenization**: [Periodic Table of Matroska AI Elements](./periodic_table.md).
+
+### 1.0b Sensory & Architecture
+*   **Sensory Atoms**: Beyond Text (`To`) and Vectors (`Ve`), we recognize **Audio (`Au`)** and **Visual (`Vi`)** as fundamental states of matter.
+    *   *Video 10 Insight*: Local TTS (Chatterbox) enables the generation of `Au` atoms without external dissonance (cost/latency).
+### 1.0c Embodied Intelligence (CES 2026 Insight)
+*   **Physical Actuation**: AI is moving from "Apps" to "Systems".
+    *   **Actuator Atom (`Ac`)**: Represents a physical output (Robot Arm, Home Automation, Hardware Control).
+    *   **Edge Processing**: "Mixture of Experts" must run on *Edge Devices*. Our `FORCE_SINGLE_MODEL` config in `mhc_router.py` aligns with this constraint (running small models like Gemma/Dolphin locally).
+*   **Linear Algebra**: The set of Active Atoms forms a **Basis Set** for the current context. The Router seeks to find the "Eigenvector" (Stable Direction) of the prompt.
+*   **Tensors**: State transitions are not just scalar heat changes but **Tensor Transformations** ($T_{ijk}$). An Agent doesn't just output text; it applies a transformation tensor to the State Vector.
+*   **Integrals**: The Recursive Loop is a **Path Integral** over the Semantic Manifold. Use `trajectory` to calculate the "Work Done" by the system.
+
+### 1.2 Physical Dynamics (Continuum Mechanics)
+*   **Manifold as Medium**: The "Context" is treated as a continuous deformable medium.
+*   **Deformation Gradient ($F$)**: The change in meaning from Input ($X$) to Output ($x$). $F = \partial x / \partial X$.
+*   **Stress ($\sigma$)**: Previously "Heat". The internal force resisting the prompt using high-entropy tokens.
+*   **Harmonic Convergence**: Equilibrium state where Stress Gradient is zero ($\nabla \cdot \sigma = 0$).
+
+### 1.3 Knowledge Topology and Persistence
+*   **Map of Science (Domain Mapping)**: All Atoms belong to a specific **Domain** (e.g., Physics, Logic, Code). High-level Routers route based on Domain affinity.
+*   **Continual Learning (Persistent Atoms)**: Some Atoms are "Heavy" (High Mass/Heat) and persist across sessions via **Long-Term Potentiation (LTP)** in the Vector Database (Manifold Memory).
+
+### 1.4 Research Lineage (Foundational Papers)
+*   **Recursive Manifold** $\approx$ **Chain-of-Thought (Wei et al.)** & **Tree of Thoughts**: The recursive loop allows for intermediate reasoning steps (Atoms) before final output.
+*   **Atomic Handoff** $\approx$ **ReAct (Yao et al.)** & **Toolformer (Schick et al.)**: The system reasons ("High Heat") and then acts (Handoff to Tool) to reduce entropy.
+*   **Periodic Table** $\approx$ **Constitutional AI / System Prompts**: Structuring inputs as defined "Elements" enforces constraints and safety.
+
+### 1.5 Neural Geometry (3Blue1Brown Integration)
+*   **Semantic Gradient Descent**: The Recursive Loop is not just "Retrying" but performing **Gradient Descent** on the "Energy Landscape" of the prompt.
+*   **Cost Function**: $Cost = Stress^2$. The system seeks to minimize Cost via iterative updates (Atoms).
+*   **Backpropagation**: The `Handoff` mechanism acts as a **Backprop Signal**, injecting a "Correction Gradient" (Tool Output) to adjust the trajectory.
+
+### 1.6 Agentic Engineering Patterns (Video 13)
+*   **Context Stuffing**: Instead of relying on RAG for everything, "Stuff" the context window with critical documentation (e.g., `elements.py` logic) in the System Prompt to ensure "High-Fidelity" adherence.
+*   **Evaluation First**: Tests (`tests/verify_loop.py`) are not just checks but the **Reward Model** for the agent. The Agent (Router) is optimized to pass the Test (Convergence).
+*   **Iterative Refinement**: The "Recursive Manifold" *is* iterative refinement. We don't accept the first draft; we loop until stress is low.
+
+### 1.7 Oversight & Context Graphs (Video 14)
+*   **Context Graph**: A structured log of *decisions* and *states*, not just text.
+    *   Implemented in `logos/oversight.py`. It tracks Server Health, Test Results, and "Context Nodes" (Events).
+*   **Autonomous Persistence**: The **Oversight Daemon** acts as the "Prefrontal Cortex," ensuring the "Subconscious" (Router) stays active and healthy.
+
+### 1.7b Graph-RAG & Agent Synergy (Video 16)
+*   **KG + Agents**: Combining structured knowledge (KG) with flexible Agents is the "Double Helix" of reasoning.
+*   **Triplets**: Atoms should form `(Subject, Predicate, Object)` triplets in the `ManifoldState.graph`.
+    *   *Current*: We track `(Atom A) --[follows]--> (Atom B)`.
+    *   *Target*: `(Atom A) --[triggers]--> (Tool T) --[resolves]--> (Atom B)`.
+
+### 1.8 Prime Resonance & Gödel Numbering (Playlist: Primes)
+*   **Unique Domain Identification**: Each Knowledge Domain is assigned a unique **Prime Number**.
+    *   *Physics* = 2, *Code* = 3, *Logic* = 5, *Vision* = 7, *Audio* = 11.
+*   **Path Integrity**: The "Trajectory" of a thought is the **Product** of these primes.
+    *   Example: A task touching Physics and Code has Resonance $2 \times 3 = 6$.
+    *   *Example*: A task touching Physics and Code has Resonance $2 \times 3 = 6$.
+    *   *Benefit*: Unique Factorization Theorem ensures we can mathematically prove exactly which domains contributed to a result, compressing the "History" into a single Scalar.
+
+### 1.9 Gödel-Zeta Datastore (Protocol 26)
+*   **Topology as Number**: The database is not SQL. It is a field of Integers.
+*   **The Check**: `if Node_ID % Concept_Prime == 0`.
+    *   Instant O(1) checking for conceptual inheritance.
+    *   Implemented in `logos/memory/prime_db.py`.
+    *   Exposed via `/index-module` and `/query-topology`.
+
+## 2. Current State vs. Target Architecture
+
+### A. The Manifold (MHC)
+*   **Current**: `recursive_mapper.py` calculates `Resonance` (Average Complexity) and `Dissonance` (Complexity vs. Doc Density).
+*   **Target MHC**: These metrics must define **Hyper-Edges**.
+    *   *Stable Node* (Low Dissonance) -> Connected to **Storage/Retrieval** (Gemma).
+    *   *Unstable Node* (High Dissonance/Heat) -> Connected to **Refinement/Compute** (RNJ-1).
+    *   *Routing*: Not all agents connect to all nodes. The "Heat" determines the valid hyper-edge.
+
+### B. The Recursive Loop (RLM) & Atomic Handoffs
+*   **Current**: Linear request -> Router -> Agent -> Response.
+*   **Target RLM (Self-Correcting)**:
+    *   `State[t+1] = Router(State[t] + Atom)`
+    *   **Atomic Handoff**: If `Heat > Threshold` on a specific Vector, the Router does NOT call an LLM but instead **assigns a Tool Token** (e.g., `Fu:Search`) to resolve the dissonance.
+    *   **Convergence**: Execution stops only when "Dissonance" drops below threshold (Harmonic convergence).
+
+### C. SPCW Addressing
+*   **Current**: `server.py` calculates `heat_score` from hex nibbles.
+*   **Target**: Use `heat_score` to assign a **Prime Modulo Address**.
+    *   High Heat -> Prime P1 (e.g., 7).
+    *   Low Heat -> Prime P2 (e.g., 3).
+    *   Routing Table: `Address % P == 0` determines visibility.
+
+## 3. Implementation Plan (Next Steps)
+
+1.  **Upgrade `logos/server.py` to `logos/mhc_router.py`**:
+    *   Implement the **State Buffer** (The "Context Runtime").
+    *   Change `/chat/completions` to a recursive execution loop: `while dissonance > threshold: step()`.
+
+2.  **Refine `logos/recursive_mapper.py`**:
+    *   Instead of just "broadcasting" to UI, it should **write to the State Buffer**.
+    *   This allows the code complexity to physically alter the routing of the next prompt.
+
+3.  **Define the Hyper-Graph**:
+    *   Create `logos/network/hypergraph.py`.
+    *   Explicitly define valid transitions (e.g., `RNJ-1` can output to `Gemma`, but `Gemma` cannot output to `RNJ-1`).
+
+## 4. Immediate Actionable
+*   **Trigger**: User confirms this alignments.
+*   **Action**: Refactor `server.py` to support **Recursive State Injection**.

logos/connectors.py

@@ -285,7 +285,7 @@ class LocalLLMConnector:
     Optimization: Direct localhost access (no Docker bridge lag).
     """
     
-    def __init__(self, base_url: str = None, model: str = "google/gemma-3-4b"):
+    def __init__(self, base_url: str = None, model: str = "dolphin-x1-8b"):
         # Prioritize Environment -> Argument -> Default
         env_url = os.environ.get("LOGOS_LLM_ENDPOINT")
         self.base_url = base_url or env_url or "http://localhost:1234/v1"
@@ -314,7 +314,7 @@ class LocalLLMConnector:
         endpoint = f"{self.base_url}/chat/completions"
         try:
             async with aiohttp.ClientSession() as session:
-                async with session.post(endpoint, json=payload, timeout=10) as response:
+                async with session.post(endpoint, json=payload, timeout=30) as response:
                     if response.status == 200:
                         data = await response.json()
                         content = data['choices'][0]['message'].get('content', "")
@@ -382,8 +382,8 @@ class LocalLLMConnector:
         for base in endpoints:
             endpoint = f"{base}/chat/completions"
             try:
-                # Short timeout for local to fail fast
-                response = requests.post(endpoint, json=payload, timeout=5)
+                # Increased timeout for complex/vision tasks
+                response = requests.post(endpoint, json=payload, timeout=30)
                 response.raise_for_status()
                 if response.status_code == 200:
                     data = response.json()

logos/elements.py

@@ -0,0 +1,231 @@
+import uuid
+from typing import List, Any, Optional, Dict
+import time
+import math
+
+class Atom:
+    """
+    Base class for all Periodic Table Elements.
+    Represents the fundamental unit with mass (heat/complexity) and charge (valence).
+    """
+    def __init__(self, symbol: str, name: str):
+        self.id = str(uuid.uuid4())
+        self.symbol = symbol  # e.g., 'Pr', 'To'
+        self.name = name
+        self.timestamp = time.time()
+        self.domain = "General" # e.g. "Physics", "Code", "Logic" (Video 26)
+        self.heat = 0.0  # Dissonance/Energy
+        self.valence = [] # Connections to other atoms (Hyper-Edges)
+
+    def resonate(self) -> float:
+        """Returns the current heat/resonance level."""
+        return self.heat
+
+    def __repr__(self):
+        return f"[{self.symbol}:{self.name}]"
+
+class Vector(Atom):
+    """
+    Symbol: Ve
+    Represents Semantic Gravity (Embeddings).
+    """
+    def __init__(self, embedding: List[float]):
+        super().__init__('Ve', 'Vector')
+        self.embedding = embedding
+        self.heat = sum(abs(x) for x in embedding) / len(embedding) if embedding else 0.0
+
+    def distance(self, other: 'Vector') -> float:
+        """Calculates cosine distance (Heat) between two vectors."""
+        # Simplified for now, assuming normalized
+        dot = sum(a*b for a, b in zip(self.embedding, other.embedding))
+        return 1.0 - dot
+
+class Token(Atom):
+    """
+    Symbol: To
+    The atomic unit of semantic meaning (Text, Image Patch).
+    """
+    def __init__(self, content: Any, source: str = "user"):
+        super().__init__('To', 'Token')
+        self.content = content
+        self.source = source
+        # Heuristic heat: length of content
+        self.heat = len(str(content)) * 0.01
+
+class Actuator(Atom):
+    """
+    Symbol: Ac
+    Represents a Physical Output Device (Motor, Switch, API).
+    """
+    def __init__(self, device_id: str, state: dict = None):
+        super().__init__('Ac', device_id)
+        self.device_id = device_id
+        self.state = state or {"power": "off"}
+        self.heat = 0.5 # Physical actions generate heat/friction
+
+class Audio(Atom):
+    """
+    Symbol: Au
+    Represents Sound/Voice data.
+    Generated by TTS or captured from Microphone.
+    """
+    def __init__(self, content: bytes, source: str = "TTS"):
+        super().__init__('Au', 'Audio')
+        self.content = content # Raw bytes or path
+        self.source = source
+        self.duration = 0.0 # Placeholder
+        self.heat = len(content) * 0.001 # Density of data
+
+class Model(Atom):
+    """
+    Symbol: Mo
+    The dense compute node (LLM, Diffusion, etc.).
+    """
+    def __init__(self, model_id: str, architecture: str = "Transformer", local: bool = True):
+        super().__init__('Mo', model_id)
+        self.local = local
+        self.architecture = architecture # e.g. "Transformer", "Diffusion", "SSM"
+        self.status = "idle"
+
+    def process(self, input_atoms: List[Atom]) -> List[Atom]:
+        """
+        Transforms input atoms (Prompt) into output atoms (Tokens).
+        This is where the actual LLM call happens.
+        """
+        # Placeholder for actual inference logic
+        self.status = "processing"
+        output_content = f"Processed {len(input_atoms)} atoms via {self.name}"
+        time.sleep(0.1) # Simulate compute
+        self.status = "idle"
+        return [Token(output_content, source=self.name)]
+
+class Handoff(Atom):
+    """
+    Symbol: Ha
+    Represents a transfer of control to a specific Tool or Agent.
+    Triggered when Heat > Threshold.
+    """
+    def __init__(self, target_tool_name: str, reason: str):
+        super().__init__('Ha', target_tool_name)
+        self.target = target_tool_name
+        self.reason = reason
+        self.status = "pending"
+
+    def resolve(self) -> Token:
+        """
+        Executing the handoff means returning a Token that summarizes the action.
+        The actual execution happens in the Router via the Tool map.
+        """
+        self.status = "active"
+        return Token(f"[HANDOFF] Transferring to {self.target} due to: {self.reason}", source="Router")
+
+class Tool(Atom):
+    """
+    Symbol: Fu (Function) / Co (Code)
+    Executable logic that binds to specific Tokens.
+    """
+    def __init__(self, name: str, func: callable, description: str):
+        super().__init__('Fu', name)
+        self.func = func
+        self.description = description
+
+    def execute(self, *args, **kwargs) -> Atom:
+        result = self.func(*args, **kwargs)
+        return Token(result, source=f"Tool:{self.name}")
+
+class Tensor(Atom):
+    """
+    Symbol: Te
+    Represents a linear transformation (Matrix) or higher-order tensor.
+    Agents apply Tensors to Vectors to change the State.
+    """
+    def __init__(self, matrix: List[List[float]], name: str = "Transform"):
+        super().__init__('Te', name)
+        self.matrix = matrix 
+        # Heat = Frobenius norm (magnitude of change)
+        self.heat = math.sqrt(sum(x*x for row in matrix for x in row))
+
+    def apply(self, vector: Vector) -> Vector:
+        """
+        Applies the tensor (matrix multiplication) to a vector.
+        v_new = T * v
+        """
+        if not vector.embedding:
+            return vector
+            
+        # Simple Matrix-Vector multiplication
+        new_vec = []
+        for row in self.matrix:
+            # Handle dimension mismatch by padding or truncating conceptually
+            # For this prototype, we assume row len fits vector len or we dot product available dims
+            dot = sum(a*b for a, b in zip(row, vector.embedding))
+            new_vec.append(dot)
+            
+        return Vector(new_vec)
+
+# Prime Resonance Mapping (Gödel Numbering)
+PRIME_DOMAINS = {
+    "General": 2,
+    "Physics": 3,
+    "Code": 5,
+    "Logic": 7,
+    "Prompt": 11,
+    "Inference": 13,
+    "External_Knowledge": 17,
+    "Audio": 19,
+    "Vision": 23
+}
+
+class ManifoldState:
+    """
+    Symbol: St (State)
+    The container for the recursive loop.
+    Now tracks Prime Resonance (Gödel Numbering).
+    """
+    def __init__(self):
+        self.atoms: List[Atom] = []
+        self.stress: float = 1.0 
+        self.deformation_gradient: List[float] = [] 
+        
+        # Prime Resonance (The scalar product of context history)
+        self.resonance_product: int = 1 
+        
+        # Context Graph (Video 15: Nodes & Edges)
+        self.graph = {
+            "nodes": {}, 
+            "edges": [] 
+        }
+
+    def inject(self, atom: Atom, parent_id: Optional[str] = None, relation: str = "follows"):
+        self.atoms.append(atom)
+        
+        # 1. Update Stress (Physics)
+        force = atom.heat
+        area = len(self.atoms)
+        self.stress = force / (area + 1e-9) 
+        self.deformation_gradient.append(self.stress)
+
+        # 2. Update Resonance (Number Theory)
+        prime_val = PRIME_DOMAINS.get(atom.domain, 2)
+        self.resonance_product *= prime_val
+
+        # 3. Update Graph (Topology)
+        self.graph["nodes"][atom.id] = {
+            "type": atom.symbol,
+            "name": atom.name,
+            "heat": atom.heat,
+            "domain": atom.domain,
+            "prime": prime_val
+        }
+        
+        if parent_id and parent_id in self.graph["nodes"]:
+            self.graph["edges"].append({
+                "source": parent_id,
+                "target": atom.id,
+                "relation": relation,
+                "weight": self.stress
+            })
+
+    def stabilize(self) -> bool:
+        """Returns True if Stress is below threshold (Equilibrium)."""
+        return self.stress < 0.1

logos/indexer.py

@@ -15,7 +15,12 @@ Output: 'project_context_dump.md'
 """
 
 import os
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
 import pathspec
+from logos.connectors import get_connector
 
 # Configuration
 PROJECT_ROOT = "."

logos/ingest_knowledge.py

@@ -10,35 +10,25 @@ This script executes the "Ingestion" workflow:
 Target: 'LOGOS Notes/*.png' -> 'knowledge_base/diagram_analysis.md'
 """
 
+import sys
 import os
 import glob
 import time
 from typing import List
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
 from logos.connectors import get_connector
 
 # Configuration
 SOURCE_DIR = "LOGOS Notes"
 OUTPUT_FILE = "knowledge_base/diagram_analysis.md"
-MODEL = "google/gemma-3-4b" # Fast vision model
-
-# Prompt Engineering for Technical Diagrams
-ANALYSIS_PROMPT = """
-You are a Senior Systems Architect analyzing a whiteboard diagram for the LOGOS DSP Protocol.
-The protocol involves Fractal Addressing, Prime Modulo arithmetic, and Heat Dissolution.
-
-Task:
-1. IDENTIFY the core components (boxes, arrows, flows) in this image.
-2. INTERPRET the logic or algorithm being described.
-3. EXTRACT any specific formulas or mathematical relationships (e.g. Modulo operations, bitwise ops).
-4. SUMMARIZE the architectural insight.
-
-Format output as Markdown. Be precise.
-"""
+VISION_MODEL = "google/gemma-3-4b" 
+TEXT_MODEL = "dolphin-x1-8b"
 
 def ingest_diagrams():
-    print(f"--- LOGOS Knowledge Ingestion [Protocol 4] ---")
+    print(f"--- LOGOS Knowledge Ingestion [Protocol 4: Context-Primed Vision] ---")
     print(f"Targeting: {SOURCE_DIR}")
-    print(f"Agent: {MODEL} (Vision)")
+    print(f"Agents: {TEXT_MODEL} (Context) -> {VISION_MODEL} (Analysis)")
     
     # 1. Scout Resources
     images = glob.glob(os.path.join(SOURCE_DIR, "*.png")) + glob.glob(os.path.join(SOURCE_DIR, "*.jpg"))
@@ -48,50 +38,278 @@ def ingest_diagrams():
         print(f"[WARN] No assets found in {SOURCE_DIR}")
         return
 
-    print(f"[PLAN] Ingesting {len(images)} artifacts. Estimated time: {len(images) * 10} seconds.")
-    
-    # 2. Initialize Agent
+    # 2. Initialize Agents
     try:
-        agent = get_connector('local', model=MODEL)
+        # We reuse the connector but switch 'model' param per call to stay hardware aligned (one active stream)
+        connector = get_connector('local') 
     except Exception as e:
-        print(f"[FAIL] Could not spawn agent: {e}")
+        print(f"[FAIL] Could not spawn connector: {e}")
         return
 
     # 3. Execution Loop
     with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
-        f.write("# LOGOS Diagram Analysis\n")
+        f.write("# LOGOS Diagram Analysis (Context-Primed)\n")
         f.write(f"**Generated:** {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
-        f.write(f"**Source:** {SOURCE_DIR}\n")
-        f.write(f"**Agent:** {MODEL}\n\n")
+        f.write(f"**Pipeline:** Context({TEXT_MODEL}) -> Vision({VISION_MODEL})\n\n")
         
         for i, img_path in enumerate(images):
             filename = os.path.basename(img_path)
-            print(f"[{i+1}/{len(images)}] Consuming: {filename}...")
+            clean_name = os.path.splitext(filename)[0].replace("_", " ").replace("-", " ")
+            print(f"[{i+1}/{len(images)}] Processing: {filename}...")
             
             try:
-                # Transmute Visual -> Text
+                # Force Hardware Cool-down between items
+                time.sleep(2.0)
+                
+                # STEP A: Context Priming (Dolphin)
+                print(f"   > [Dolphin] Extracting Context (timeout=30s)...")
+                try:
+                    context_prompt = f"Analyze filename '{clean_name}'. Return JSON {{'title': '...', 'description': '...'}}."
+                    # Debug: Print ensuring valid string
+                    # print(f"DEBUG: Prompting Dolphin with: {context_prompt}")
+                    
+                    context_resp, _ = connector.chat(context_prompt, model=TEXT_MODEL)
+                    
+                    # Robust JSON extraction
+                    import json
+                    try:
+                        # Find first '{' and last '}'
+                        s = context_resp.find('{')
+                        e = context_resp.rfind('}') + 1
+                        if s != -1 and e != -1:
+                            meta = json.loads(context_resp[s:e])
+                            refined_context = f"Context: {meta.get('title', clean_name)}. {meta.get('description', '')}"
+                        else:
+                            refined_context = f"Context: {clean_name}"
+                    except:
+                        refined_context = f"Context: {context_resp[:200].replace(chr(10), ' ')}"
+                        
+                except Exception as e:
+                    print(f"   > [Dolphin] Bypass (Error: {e})")
+                    refined_context = f"Context: {clean_name}"
+
+                # Hardware Switch Delay
+                print(f"   > [System] Swapping to Vision Model...")
+                time.sleep(1.0)
+
+                # STEP B: Vision Analysis (Gemma)
+                print(f"   > [Gemma] performing Context-Aware Analysis...")
+                
+                vision_prompt = f"""
+                Role: Senior Hardware Architect.
+                Context: {refined_context}
+                Task: Analyze the diagram. Validate if the visual data matches the context. 
+                Extract:
+                1. Hardware components (Bus, ALU, Cache).
+                2. Data flow direction.
+                3. Mathematical formulas.
+                
+                Output: Actionable Markdown.
+                """
+                
                 start_ts = time.time()
-                analysis, _ = agent.chat(ANALYSIS_PROMPT, image_path=img_path)
+                analysis, _ = connector.chat(vision_prompt, image_path=img_path, model=VISION_MODEL)
                 duration = time.time() - start_ts
                 
                 # Anneal into Knowledge Base
                 f.write(f"## {filename}\n")
+                f.write(f"**Context ({TEXT_MODEL}):** {refined_context}\n\n")
                 f.write(f"![{filename}](../{img_path.replace(os.sep, '/')})\n\n")
                 f.write(f"{analysis}\n\n")
                 f.write(f"*Analysis time: {duration:.2f}s*\n")
                 f.write("---\n\n")
                 
-                # Flush to save progress
                 f.flush()
                 print(f"   > Ingested ({duration:.2f}s)")
                 
             except Exception as e:
-                print(f"   > [FAIL] Parsing Error: {e}")
+                print(f"   > [FAIL] Error: {e}")
                 f.write(f"## {filename}\n")
-                f.write(f"**Error analyzing image:** {e}\n\n---\n\n")
+                f.write(f"**Error:** {e}\n\n---\n\n")
 
     print(f"\n[SUCCESS] Knowledge synthesis complete.")
     print(f"Artifact: {OUTPUT_FILE}")
 
+# --- INGESTION REGISTRY (Deduplication) ---
+class IngestionRegistry:
+    def __init__(self, registry_path="logos/ingestion_registry.json"):
+        self.registry_path = registry_path
+        self.data = self._load()
+
+    def _load(self):
+        if os.path.exists(self.registry_path):
+            try:
+                import json
+                with open(self.registry_path, 'r') as f:
+                    return json.load(f)
+            except:
+                pass
+        return {}
+
+    def save(self):
+        import json
+        with open(self.registry_path, 'w') as f:
+            json.dump(self.data, f, indent=2)
+
+    def is_processed(self, filepath):
+        """Checks if file is already ingested based on mtime."""
+        stat = os.stat(filepath)
+        key = os.path.abspath(filepath)
+        last_mtime = self.data.get(key, {}).get("mtime", 0)
+        return stat.st_mtime <= last_mtime
+
+    def mark_processed(self, filepath, meta=None):
+        """Tags data as ingested."""
+        key = os.path.abspath(filepath)
+        self.data[key] = {
+            "mtime": os.stat(filepath).st_mtime,
+            "timestamp": time.time(),
+            "meta": meta or {}
+        }
+        self.save()
+
+def ingest_diagrams():
+    print(f"--- LOGOS Knowledge Ingestion [Protocol 4: Context-Primed Vision] ---")
+    print(f"Targeting: {SOURCE_DIR}")
+    print(f"Agents: {TEXT_MODEL} (Context) -> {VISION_MODEL} (Analysis)")
+    
+    registry = IngestionRegistry()
+    
+    # 1. Scout Resources
+    images = glob.glob(os.path.join(SOURCE_DIR, "*.png")) + glob.glob(os.path.join(SOURCE_DIR, "*.jpg"))
+    images.sort()
+    
+    if not images:
+        print(f"[WARN] No assets found in {SOURCE_DIR}")
+        return
+
+    # 2. Initialize Agents
+    try:
+        # We reuse the connector but switch 'model' param per call to stay hardware aligned (one active stream)
+        connector = get_connector('local') 
+    except Exception as e:
+        print(f"[FAIL] Could not spawn connector: {e}")
+        return
+
+    # 3. Execution Loop
+    # Write mode 'a' (append) to preserve history if we are skipping? 
+    # Or 'w' but reading old content? 
+    # For now, let's just append new findings or overwrite if it's a full run. 
+    # User asked to "tag data that we have already ingested", usually implies skipping.
+    
+    # Check if output file exists, if so append, else write header
+    mode = 'a' if os.path.exists(OUTPUT_FILE) else 'w'
+    
+    with open(OUTPUT_FILE, mode, encoding="utf-8") as f:
+        if mode == 'w':
+            f.write("# LOGOS Diagram Analysis (Context-Primed)\n")
+            f.write(f"**Generated:** {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"**Pipeline:** Context({TEXT_MODEL}) -> Vision({VISION_MODEL})\n\n")
+        
+        for i, img_path in enumerate(images):
+            filename = os.path.basename(img_path)
+            
+            # [DEDUPLICATION CHECK]
+            if registry.is_processed(img_path):
+                print(f"[{i+1}/{len(images)}] Skipping {filename} (Already Ingested) [Duplicate Path Atom]")
+                continue
+
+            clean_name = os.path.splitext(filename)[0].replace("_", " ").replace("-", " ")
+            print(f"[{i+1}/{len(images)}] Processing: {filename}...")
+            
+            try:
+                # Force Hardware Cool-down between items
+                time.sleep(1.0)
+                
+                # STEP A: Context Priming (Dolphin)
+                print(f"   > [Dolphin] Extracting Context (timeout=30s)...")
+                try:
+                    context_prompt = f"Analyze filename '{clean_name}'. Return JSON {{'title': '...', 'description': '...'}}."
+                    context_resp, _ = connector.chat(context_prompt, model=TEXT_MODEL)
+                    
+                    # Robust JSON extraction
+                    import json
+                    try:
+                        s = context_resp.find('{')
+                        e = context_resp.rfind('}') + 1
+                        if s != -1 and e != -1:
+                            meta = json.loads(context_resp[s:e])
+                            refined_context = f"Context: {meta.get('title', clean_name)}. {meta.get('description', '')}"
+                        else:
+                            refined_context = f"Context: {clean_name}"
+                    except:
+                        refined_context = f"Context: {context_resp[:200].replace(chr(10), ' ')}"
+                        
+                except Exception as e:
+                    print(f"   > [Dolphin] Bypass (Error: {e})")
+                    refined_context = f"Context: {clean_name}"
+
+                # Hardware Switch Delay
+                print(f"   > [System] Swapping to Vision Model...")
+                time.sleep(1.0)
+
+                # STEP B: Vision Analysis (Gemma)
+                print(f"   > [Gemma] performing Context-Aware Analysis...")
+                
+                vision_prompt = f"""
+                Role: Senior Hardware Architect.
+                Context: {refined_context}
+                Task: Analyze the diagram. Validate if the visual data matches the context. 
+                Extract:
+                1. Hardware components (Bus, ALU, Cache).
+                2. Data flow direction.
+                3. Mathematical formulas.
+                
+                Output: Actionable Markdown.
+                """
+                
+                start_ts = time.time()
+                analysis, _ = connector.chat(vision_prompt, image_path=img_path, model=VISION_MODEL)
+                duration = time.time() - start_ts
+                
+                # Anneal into Knowledge Base
+                f.write(f"## {filename}\n")
+                f.write(f"**Context ({TEXT_MODEL}):** {refined_context}\n\n")
+                f.write(f"![{filename}](../{img_path.replace(os.sep, '/')})\n\n")
+                f.write(f"{analysis}\n\n")
+                f.write(f"*Analysis time: {duration:.2f}s*\n")
+                f.write("---\n\n")
+                
+                f.flush()
+                print(f"   > Ingested ({duration:.2f}s)")
+                
+                # [PROTOCOL 26: ANALOG TO DIGITAL INDEXING]
+                # We send the Vision Analysis to the Server to be converted into a Gödel Number
+                try:
+                    import requests
+                    payload = {
+                        "filepath": img_path,
+                        "content": f"{refined_context}\n{analysis}"
+                    }
+                    # Assuming default port
+                    res = requests.post("http://localhost:5000/index-module", json=payload, timeout=5)
+                    if res.status_code == 200:
+                        data = res.json()
+                        mid = data.get('manifold_id')
+                        primes = data.get('prime_coordinates')
+                        print(f"   > [GÖDEL] Indexing Complete. Manifold ID: {mid}")
+                        print(f"   > [PRIME SPACE] Active Domains: {primes}")
+                        f.write(f"**Gödel ID:** `{mid}`\n**Prime Vectors:** `{primes}`\n\n")
+                    else:
+                        print(f"   > [GÖDEL] Indexing Failed: {res.status_code}")
+                except Exception as e:
+                    print(f"   > [GÖDEL] Indexing Error: {e}")
+                
+                # [REGISTRY UPDATE]
+                registry.mark_processed(img_path, meta={"duration": duration, "context": refined_context})
+                
+            except Exception as e:
+                print(f"   > [FAIL] Error: {e}")
+                f.write(f"## {filename}\n")
+                f.write(f"**Error:** {e}\n\n---\n\n")
+
+    print(f"\n[SUCCESS] Knowledge synthesis complete.")
+
 if __name__ == "__main__":
     ingest_diagrams()
+    ingest_documents()

logos/ingestion_registry.json

@@ -0,0 +1,154 @@
+{
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\2 bit ops to 4 bit generation scratchwork.png": {
+    "mtime": 1766229543.8824837,
+    "timestamp": 1767912162.519743,
+    "meta": {
+      "duration": 62.05567264556885,
+      "context": "Context: Binary Operations to Quad-State Encoding. This document outlines a process for converting binary operations (typically represented by two-bit values) into a four-bit encoding system. The methodology involves examining the possible outcomes of bit manipulation and mapping them to specific quad-state representations. Various techniques such as bitwise shifts, logical operations, and arithmetic calculations are discussed in detail."
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\2 bit ops- 00persist,01persistchange, 10 changepersist, 11 change change.png": {
+    "mtime": 1766229609.7951887,
+    "timestamp": 1767912230.474419,
+    "meta": {
+      "duration": 62.054080963134766,
+      "context": "Context: Binary Operations. This dataset contains binary operations for data persistence and modification. The values represent bit combinations where the first digit (bit) determines whether to persist or change, while the second digit controls how the operation is applied."
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\4 bit version of header control codes for generation keying.png": {
+    "mtime": 1766176440.6376977,
+    "timestamp": 1767912300.0442252,
+    "meta": {
+      "duration": 62.074482679367065,
+      "context": "Context: ```python import json  def analyze_filename(filename):     words = filename.replace(' ', '-').split('-')          title = \"Header Control Codes\"     description = f\"Control code system for generating "
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Buckets in out 1.png": {
+    "mtime": 1766176505.5800614,
+    "timestamp": 1767912377.0162396,
+    "meta": {
+      "duration": 62.09031295776367,
+      "context": "Context: ```python import re  def analyze_filename(filename):     \"\"\"     Analyze a filename to extract title and description.          :param filename: The file name to analyze     :return: A dictionary conta"
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Buckets in out 1a.png": {
+    "mtime": 1766229683.6946967,
+    "timestamp": 1767912446.9074564,
+    "meta": {
+      "duration": 62.07565903663635,
+      "context": "Context: Buckets in the outer space. A collection of containers used for storing items, located in an external environment."
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Buckets inout select and raw.png": {
+    "mtime": 1766733339.3767636,
+    "timestamp": 1767912515.2857368,
+    "meta": {
+      "duration": 62.07451391220093,
+      "context": "Context: Bucket Selection in Raw Data Processing. This filename suggests a process involving buckets, possibly for data organization or aggregation. The terms 'inout' imply input/output operations, while 'select' indicates filtering or retrieval of specific information. 'Raw' likely references unprocessed or unstructured data, which is being manipulated through this bucket-based system."
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Buckets- raw.png": {
+    "mtime": 1766176467.8635385,
+    "timestamp": 1767912586.5567737,
+    "meta": {
+      "duration": 62.08598446846008,
+      "context": "Context: ```python import re  def analyze_filename(filename):     \"\"\"     Analyze a filename and return a title/description based on its components.      :param str filename: The filename to be analyzed.     :"
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\CakeBake.png": {
+    "mtime": 1765668384.1091495,
+    "timestamp": 1767912654.5192094,
+    "meta": {
+      "duration": 62.07900142669678,
+      "context": "Context: ```python import json  def analyze_filename(filename):     title = \"cake_baking\"     description = \"The process of preparing a sweet baked dessert using flour, sugar, eggs, and butter.\"          retur"
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Context compression at scale- decompress to true stream.png": {
+    "mtime": 1766436908.2784822,
+    "timestamp": 1767912721.5784955,
+    "meta": {
+      "duration": 62.08380699157715,
+      "context": "Context: Context Compression. At scale, it involves decompression to a streaming format."
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Delta Heat Flow.png": {
+    "mtime": 1766554370.0297463,
+    "timestamp": 1767912788.638845,
+    "meta": {
+      "duration": 62.06147575378418,
+      "context": "Context: Heat Flow in the Delta Region. This dataset provides thermal conductivity measurements for subsurface rock formations within the Delta area. It includes data on temperature gradients, heat flux rates, and depth-dependent thermal properties."
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Dissolution scratch.png": {
+    "mtime": 1766174709.3796747,
+    "timestamp": 1767912914.7828348,
+    "meta": {
+      "duration": 62.070053577423096,
+      "context": "Context: Dissolution scratch"
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Early SPCW scratch- add with Prime Composite clarification.png": {
+    "mtime": 1766091347.9499009,
+    "timestamp": 1767912981.8380082,
+    "meta": {
+      "duration": 62.06748986244202,
+      "context": "Context: Early SPCW. Scratch addition using the Prime Composite method, including clarifications"
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Early Streaming Diffs.png": {
+    "mtime": 1766548093.8498833,
+    "timestamp": 1767913049.309288,
+    "meta": {
+      "duration": 62.09256434440613,
+      "context": "Context: Early. Streaming"
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Early Transmission flow control.png": {
+    "mtime": 1766442268.948,
+    "timestamp": 1767913154.1385126,
+    "meta": {
+      "duration": 62.069133281707764,
+      "context": "Context: Early Transmission Flow Control. A system that detects and prevents potential transmission problems before they occur, ensuring data integrity and efficiency."
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Heat tracking- hex complexity tracking.png": {
+    "mtime": 1766439998.7298183,
+    "timestamp": 1767913244.9191825,
+    "meta": {
+      "duration": 62.07440638542175,
+      "context": "Context: Hexagon Complexity Tracking System. A digital platform designed to monitor and analyze the thermal behavior of hexagonal structures, providing insights into heat dissipation patterns and optimizing material selection for thermal management applications."
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Hex compression heat codes from 8x8 Matrix.png": {
+    "mtime": 1766521428.0286517,
+    "timestamp": 1767913371.0930233,
+    "meta": {
+      "duration": 62.08362579345703,
+      "context": "Context: Hex compression heat codes from 8x8 Matrix"
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Hex dissolve round trip heat from atomic decomp.png": {
+    "mtime": 1766523371.6137607,
+    "timestamp": 1767913497.267817,
+    "meta": {
+      "duration": 62.094608545303345,
+      "context": "Context: Hex dissolve round trip heat from atomic decomp"
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Lane splitting dissolution.png": {
+    "mtime": 1766613263.3714952,
+    "timestamp": 1767913623.4322183,
+    "meta": {
+      "duration": 62.09859371185303,
+      "context": "Context: Lane splitting dissolution"
+    }
+  },
+  "C:\\Users\\Nauti\\Desktop\\LOGOS CURSOR\\LOGOS Notes\\Matroska Networking Example- Nested and contemporary domains.png": {
+    "mtime": 1767302449.4050667,
+    "timestamp": 1767913749.585773,
+    "meta": {
+      "duration": 62.07360100746155,
+      "context": "Context: Matroska Networking Example  Nested and contemporary domains"
+    }
+  }
+}

logos/manifold_state.py

@@ -56,6 +56,17 @@ class ManifoldState:
             self.state["shells"][shell_name]["requests"] += 1
             self.state["shells"][shell_name]["tokens_intake"] += token_count
         
+        # [PROTOCOL 26 ADDITION]
+        # Since 'state' here is a dictionary from JSON, it doesn't automatically sync
+        # with the transient 'ManifoldState' object used in the router (Atom/Physics).
+        # We need to bridge the persistent stats with the transient physics for the API.
+        # Ideally, we should merge the two concepts, but for now we'll stub the fields
+        # so the API reveals they exist.
+        if "prime_resonance" not in self.state:
+             self.state["prime_resonance"] = 1
+        if "graph_nodes" not in self.state:
+             self.state["graph_nodes"] = 0
+             
         # Update Macro Context (Rolling buffer of 10)
         context_entry = {
             "time": time.time(),

logos/memory/README.md

@@ -0,0 +1,32 @@
+# Protocol 26: Gödel-Zeta Datastore
+
+## Philosophy
+**"The Database is not a Table. It is a Field of Integers."**
+
+Based on the [Primes Playlist](https://www.youtube.com/playlist?list=PL6w6drTRMkPExcs2kYO8uBufDT_nU4vU8), this module implements a **Gödel Numbering Topology**.
+
+Instead of storing data in relational tables or vector stores alone, we map every unique Atomic Concept (Token) to a **Prime Number**.
+
+## Core Mechanisms
+
+### 1. The Atom (Prime)
+Every unique string concept (e.g., "AI", "Logic", "Python") is assigned a unique Prime Number $P$ from the infinite sequence of primes.
+*   "General" = 2
+*   "Physics" = 3
+*   "Code" = 5
+*   ... and so on.
+
+### 2. The Molecule (Composite)
+A state, file, or document is defined not by its content string, but by the **Product** of its constituent primes.
+$$ State = P_1 \times P_2 \times P_3 \dots $$
+By the **Fundamental Theorem of Arithmetic**, this integer is unique. No other combination of concepts will yield this exact number.
+
+### 3. Topological Search (Divisibility)
+To query the database, we do not scan text. We perform **Divisibility Checks**.
+To find if a File contains "Logic" (Prime 5):
+$$ \text{if } (File\_ID \mod 5 == 0) \rightarrow \text{True} $$
+This check is $O(1)$ and mathematically rigorous.
+
+## Implementation
+*   **`prime_db.py`**: Manages the `prime_registry.json` (The Rosetta Stone of Primes).
+*   **`server.py`**: Exposes `/index-module` to engage the Indexer and `/query-topology` to traverse the Prime Field.

logos/memory/prime_db.py

@@ -0,0 +1,114 @@
+import json
+import os
+import math
+from functools import reduce
+
+# PERSISTENCE FILE
+REGISTRY_PATH = "./logos/memory/prime_registry.json"
+os.makedirs(os.path.dirname(REGISTRY_PATH), exist_ok=True)
+
+class PrimeTokenDB:
+    def __init__(self):
+        self.registry = self.load_registry()
+        try:
+            # Handle potential string keys from JSON loading
+            self.reverse_registry = {int(v) if isinstance(v, (int, str)) and str(v).isdigit() else v: k for k, v in self.registry.items()}
+        except Exception as e:
+             print(f"[PrimeDB] Warning rebuilding reverse registry: {e}")
+             self.reverse_registry = {}
+             
+        self.next_prime = self.calculate_next_prime()
+
+    def load_registry(self):
+        if os.path.exists(REGISTRY_PATH):
+            try:
+                with open(REGISTRY_PATH, 'r') as f:
+                    data = json.load(f)
+                    # Convert values to int just in case
+                    return {k: int(v) for k, v in data.items()}
+            except:
+                return {"_ROOT": 1}
+        return {"_ROOT": 1} # Identity
+
+    def save_registry(self):
+        with open(REGISTRY_PATH, 'w') as f:
+            json.dump(self.registry, f, indent=2)
+
+    def is_prime(self, n):
+        """Standard Primality Test"""
+        if n < 2: return False
+        for i in range(2, int(math.sqrt(n)) + 1):
+            if n % i == 0: return False
+        return True
+
+    def calculate_next_prime(self):
+        """Finds the next available prime slot for a new token."""
+        if not self.registry: return 2
+        # Ensure we look at integer values
+        values = [int(v) for v in self.registry.values()]
+        highest = max(values) if values else 1
+        candidate = highest + 1
+        while not self.is_prime(candidate):
+            candidate += 1
+        return candidate
+
+    def get_token_prime(self, token):
+        """
+        Retrieves the Prime Coordinate for a token.
+        If new, assigns the next prime and expands the Manifold.
+        """
+        token = str(token).lower().strip()
+        if token in self.registry:
+            return self.registry[token]
+        
+        # MINT NEW PRIME
+        prime = self.next_prime
+        self.registry[token] = prime
+        self.reverse_registry[prime] = token
+        
+        # Calc next for future
+        self.next_prime += 1
+        while not self.is_prime(self.next_prime):
+            self.next_prime += 1
+            
+        self.save_registry()
+        return prime
+
+    def encode_state(self, tokens):
+        """
+        Converts a list of concepts (text) into a Single Unique Integer.
+        Example: ["AI", "Logic"] -> 3 * 5 = 15
+        """
+        primes = [self.get_token_prime(t) for t in tokens]
+        # Calculate Product (The Composite Weight)
+        if not primes: return 1, []
+        composite = reduce(lambda x, y: x * y, primes, 1)
+        return composite, primes
+
+    def decode_state(self, composite_integer):
+        """
+        Reconstructs the atoms from the composite weight.
+        (Factoring the Manifold State)
+        """
+        factors = []
+        # Optimization: We only check primes we know exist in the registry
+        known_primes = sorted([int(k) for k in self.reverse_registry.keys()])
+        
+        temp = composite_integer
+        for p in known_primes:
+            if p <= 1: continue
+            if p * p > temp: 
+                # If what remains is prime and in registry
+                if temp in self.reverse_registry:
+                     factors.append(self.reverse_registry[temp])
+                     temp = 1
+                break 
+            
+            while temp % p == 0:
+                factors.append(self.reverse_registry[p])
+                temp //= p
+        
+        if temp > 1 and temp in self.reverse_registry:
+            factors.append(self.reverse_registry[temp])
+            
+        return factors

logos/mhc_router.py

@@ -0,0 +1,246 @@
+"""
+logos/mhc_router.py - Recursive Manifold Engine (Router Logic)
+Protocol 25: Recursive Manifold Engine (RLM) w/ Harmonic Convergence
+"""
+
+import logging
+import time
+import os
+import sys
+import requests
+
+# Hack: Allow running this script directly for testing
+if __name__ == "__main__":
+    sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from logos.elements import ManifoldState as AtomicState, Token, Model, Atom, Handoff, Tool
+
+# Set up Logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("LOGOS_Router")
+
+# --- MANIFOLD CONSTRAINT CONFIGURATION ---
+FORCE_SINGLE_MODEL = True  
+UNIFIED_MODEL_ID = "dolphin-x1-8b" 
+
+SHELL_CONFIG = {
+    "INNER_SHELL": {
+        "model": "dolphin-x1-8b" if not FORCE_SINGLE_MODEL else UNIFIED_MODEL_ID,
+        "rate_limit": 60, 
+    },
+    "PRIME_CHANNEL": {
+        "model": "essentialai/rnj-1" if not FORCE_SINGLE_MODEL else UNIFIED_MODEL_ID,
+        "rate_limit": 20, 
+    },
+    "OUTER_SHELL": {
+        "model": "google/gemma-3-4b" if not FORCE_SINGLE_MODEL else UNIFIED_MODEL_ID,
+        "rate_limit": 10, 
+    }
+}
+
+RATE_LIMITS = {k: {"tokens": v["rate_limit"], "last_update": 0} for k, v in SHELL_CONFIG.items()}
+
+# --- TOOLS ---
+def search_tool(query):
+    return f"[SEARCH RESULTS] Found relevant documentation for: {query}"
+
+TOOL_MAP = {
+    "Search": Tool("Search", search_tool, "Locates external knowledge to reduce entropy.")
+}
+
+# --- CORE FUNCTIONS ---
+
+def calculate_manifold_constraint(text, is_vision=False):
+    """
+    Determines the 'Shell' based on Prime Topology (Manifold Constrained Hyper-Connection).
+    """
+    if is_vision:
+        return "OUTER_SHELL", 1.0
+        
+    # Keyword Harmonic Override
+    text_lower = text.lower()
+    if any(k in text_lower for k in ["prime", "modulo", "math", "proof"]):
+        return "PRIME_CHANNEL", 1.0
+    if any(k in text_lower for k in ["def ", "class ", "import ", "code", "script"]):
+        return "INNER_SHELL", 1.0
+
+    # Prime Topology Routing (Heat Code Analysis)
+    try:
+        hex_str = text.encode('utf-8').hex()
+    except:
+        hex_str = str(text).encode('utf-8').hex()
+        
+    total_nibbles = len(hex_str)
+    
+    if total_nibbles == 0: return "INNER_SHELL", 0.5
+    
+    check_set = {'7', 'b', 'd', 'e', 'f', 'B', 'D', 'E', 'F'}
+    high_entropy_count = sum(1 for c in hex_str if c in check_set)
+    
+    heat_score = high_entropy_count / total_nibbles
+    
+    if heat_score > 0.4:
+        return "OUTER_SHELL", heat_score
+    elif heat_score > 0.2:
+        return "PRIME_CHANNEL", heat_score
+    else:
+        return "INNER_SHELL", heat_score
+
+def execute_recursive_manifold(prompt, target_model_id, max_recursion=3, is_vision=False):
+    """
+    Executes the prompt through the Manifold-Constrained Hyper-Graph.
+    Iterates until Stress < Threshold or Max Recursion reached.
+    """
+    # 1. Initialize State Buffer ( The Periodic Table )
+    state = AtomicState()
+    initial_token = Token(prompt, source="user")
+    initial_token.domain = "Prompt"
+    state.inject(initial_token)
+    
+    last_atom_id = initial_token.id # Track causality
+    
+    trajectory = [] 
+    ENTROPY_HANDOFF_THRESHOLD = 0.6 # [TUNED] Lowered from 0.8 to increase Tool Usage
+    
+    logger.info(f"🌀 [RLM] Initiating Recursive Manifold Loop (Max Depth: {max_recursion})")
+    
+    # [OPTIMIZATION] STATIC SYSTEM PROMPT for KV Cache Reuse
+    # By keeping the system prompt identical across iterations, we allow the engine 
+    # to reuse the computed KV states for the system block.
+    STATIC_SYSTEM_PROMPT = (
+        "You are the LOGOS Recursive Manifold Node (RLM). "
+        "You exist within a self-correcting loop. "
+        "Adhere strictly to the injected [DIRECTIVE] at the end of the user prompt."
+    )
+    
+    current_content = prompt
+    iteration = 0
+    
+    while iteration < max_recursion:
+        iteration += 1
+        
+        # 2. Calculate Manifold Constraints
+        shell, heat_score = calculate_manifold_constraint(current_content, is_vision)
+        
+        # Update State Stress (Continuum Mechanics)
+        state.stress = max(0, heat_score - 0.5) if shell == "OUTER_SHELL" else 0.1
+        
+        # [GEOMETRY CHECK]
+        logger.info(f"   ► Iteration {iteration}: Shell={shell}")
+        logger.info(f"     [GEOMETRY] Heat={heat_score:.4f} (Hex Density)")
+        logger.info(f"     [NUMBER]   Resonance={state.resonance_product}")
+        logger.info(f"     [PHYSICS]  Stress={state.stress:.4f}")
+        
+        trajectory.append({
+            "iter": iteration,
+            "shell": shell,
+            "heat": heat_score,
+            "resonance": state.resonance_product,
+            "elements": [str(a) for a in state.atoms[-3:]]
+        })
+
+        # 3. Harmonic Convergence Check
+        if state.stabilize() and iteration > 1:
+            logger.info(f"   ✅ Harmonic Convergence Reached at Iteration {iteration}.")
+            break
+            
+        # 4. Atomic Handoff (Self-Correction / Tool Usage)
+        # We encourage tool use if stress is high OR if we are just starting (Prime Interplay)
+        if heat_score > ENTROPY_HANDOFF_THRESHOLD or (iteration == 1 and "search" in current_content.lower()):
+            logger.info(f"   ⚠️ CRITICAL HEAT ({heat_score:.2f}) -> Initiating ATOMIC HANDOFF to 'Search'")
+            handoff_atom = Handoff("Search", reason=f"High Entropy detected ({heat_score:.2f})")
+            state.inject(handoff_atom, parent_id=last_atom_id, relation="triggers")
+            
+            target_tool = TOOL_MAP.get(handoff_atom.target)
+            if target_tool:
+                # [BOOST] Increase context window for tools
+                result_token = target_tool.execute(current_content[:150]) 
+                result_token.domain = "External_Knowledge"
+                state.inject(result_token, parent_id=handoff_atom.id, relation="resolved_by")
+                
+                # [CACHE OPTIMIZATION] Append Context instead of Prepend
+                # This preserves the prefix of 'current_content', allowing KV cache to reuse
+                # tokens 0..N. We append the new knowledge.
+                current_content = f"{current_content}\n\n[TOOL_RESULT]: {result_token.content}"
+                last_atom_id = result_token.id
+                
+                # [INTERPLAY] Don't skip, let the Agent react to the tool immediately
+                # continue 
+            
+        # 5. Hyper-Connection Routing & Context Expansion
+        if shell == "OUTER_SHELL":
+            # Creative / Divergent
+            meta_instruction = "Analyze entropy. Expand geometric implications. Think divergently. Use rich vocabulary."
+            target_temp = 0.9
+        else:
+            # Logic / Convergent
+            meta_instruction = "Refine into singular conclusion. Minimize ambiguity. Critique previous steps."
+            target_temp = 0.4
+
+        # 6. Execute Expert (Agent Interplay)
+        try:
+            # [BOOST] Force Multi-Agent "Critique" if we are deep in recursion
+            if iteration > 1 and shell == "OUTER_SHELL":
+                 meta_instruction += " CRITIQUE the previous iteration. checking for logical consistency."
+            
+            model_atom = Model(target_model_id)
+            
+            # [CACHE OPTIMIZATION] Dynamic Directive Moved to User Prompt Postfix
+            # System Prompt remains static. Directive is appended.
+            final_user_content = f"{current_content}\n\n[DIRECTIVE]: {meta_instruction}"
+            
+            messages = [
+                {"role": "system", "content": STATIC_SYSTEM_PROMPT},
+                {"role": "user", "content": final_user_content}
+            ]
+            
+            payload = {
+                "model": target_model_id, 
+                "messages": messages,
+                "temperature": target_temp,
+                "max_tokens": -1, 
+                "stream": False
+            }
+            
+            lm_endpoint = os.environ.get("LOGOS_LLM_ENDPOINT", "http://localhost:1234/v1")
+            
+            # Simple synchronous call for now (can upgrade to aiohttp later)
+            response = requests.post(f"{lm_endpoint}/chat/completions", json=payload, timeout=60)
+            
+            if response.status_code == 200:
+                result = response.json()
+                new_content = result['choices'][0]['message']['content']
+                
+                output_token = Token(new_content, source=target_model_id)
+                output_token.domain = "Inference"
+                state.inject(output_token, parent_id=last_atom_id, relation="generated_by")
+                
+                current_content = new_content
+                last_atom_id = output_token.id
+            else:
+                logger.error(f"   ❌ Expert Failed: {response.status_code}")
+                break
+                
+        except Exception as e:
+            logger.error(f"   ❌ RLM Error: {e}")
+            break
+            
+    return current_content, trajectory
+
+if __name__ == "__main__":
+    print("--- LOGOS PHYSICS ENGINE TEST ---")
+    print("Injecting High-Entropy Prompt to trigger Geometry Checks...")
+    
+    # Test Prompt: High heat (hex codes), mixed domain keywords
+    test_prompt = "Calculate the Prime Resonance of a Quantum Field 0x7F 0xFF in Python."
+    
+    # Mock LLM Endpoint for test (won't actually call out if we don't have a server, or will fail gracefully)
+    # We mainly want to see the LOGS generated by 'execute_recursive_manifold'
+    
+    try:
+        final, traj = execute_recursive_manifold(test_prompt, "dolphin-x1-8b", max_recursion=2)
+        print("\n[Trajectory Summary]")
+        for Step in traj:
+            print(f"Iter {Step['iter']}: Heat={Step['heat']:.2f} | Resonance={Step.get('resonance', 'N/A')}")
+    except Exception as e:
+        print(f"Physics Test Complete (stopped at network): {e}")

logos/oversight.py

@@ -0,0 +1,104 @@
+"""
+logos/oversight.py - The "Context Graph" Manager
+Protocol 26: Autonomous Persistence & Validation
+
+Functions:
+1. Process Persistence: Keeps 'server.py' alive.
+2. Context Monitoring: Traces health/decisions (Video 14).
+3. Continuous Validation: Runs 'verify_loop.py' on schedule/change.
+"""
+
+import subprocess
+import time
+import sys
+import os
+import logging
+from datetime import datetime
+
+# Configure Logging (The Context Graph)
+logging.basicConfig(
+    filename='logos_context.log',
+    level=logging.INFO,
+    format='%(asctime)s | %(levelname)s | %(message)s'
+)
+logger = logging.getLogger("OVERSIGHT")
+
+SERVER_CMD = [sys.executable, "-m", "logos.server"]
+TEST_CMD = [sys.executable, "tests/verify_loop.py"]
+
+class OversightDaemon:
+    def __init__(self):
+        self.server_process = None
+        self.health_score = 100.0
+        self.context_trace = [] # In-memory context graph
+
+    def start_server(self):
+        logger.info("[OP] Starting Manifold Server...")
+        self.server_process = subprocess.Popen(SERVER_CMD)
+        self.log_context("SERVER_START", "Process initiated")
+
+    def run_tests(self):
+        logger.info("[QA] Running Validation Suite...")
+        try:
+            # Force UTF-8 to avoid Windows charmap errors
+            result = subprocess.run(
+                TEST_CMD, 
+                capture_output=True, 
+                text=True, 
+                encoding='utf-8', 
+                errors='replace',
+                timeout=30
+            )
+            if result.returncode == 0:
+                logger.info("   ✅ Tests Passed.")
+                self.log_context("TEST_PASS", "Verification successful")
+                return True
+            else:
+                logger.error(f"   ❌ Tests Failed:\n{result.stderr}")
+                self.log_context("TEST_FAIL", f"Exit Code {result.returncode}")
+                return False
+        except Exception as e:
+            logger.error(f"   ❌ Test Execution Error: {e}")
+            return False
+
+    def log_context(self, event_type, details):
+        """Builds the Context Graph node."""
+        node = {
+            "timestamp": time.time(),
+            "type": event_type,
+            "details": details,
+            "server_pid": self.server_process.pid if self.server_process else None
+        }
+        self.context_trace.append(node)
+        # Prune old context
+        if len(self.context_trace) > 100: self.context_trace.pop(0)
+
+    def monitor_loop(self):
+        self.start_server()
+        
+        try:
+            while True:
+                # 1. Check Server Liveness
+                if self.server_process.poll() is not None:
+                    logger.warning("[⚠️] Server died! Restarting...")
+                    self.log_context("SERVER_CRASH", "Unexpected exit")
+                    self.start_server()
+                
+                # 2. Periodic Validation (Simulation of "Active Oversight")
+                # In real world, trigger this on file events. Here, every 60s.
+                if int(time.time()) % 60 == 0:
+                    success = self.run_tests()
+                    if not success:
+                        logger.warning("[⚠️] System Unstable (Tests Failed).")
+                        # Implementation detail: Could auto-rollback or alert user
+                
+                time.sleep(1)
+                
+        except KeyboardInterrupt:
+            logger.info("[OP] Stopping Oversight...")
+            if self.server_process: self.server_process.terminate()
+
+if __name__ == "__main__":
+    print("CORE: Starting Logos Oversight Daemon (Protocol 26)...")
+    daemon = OversightDaemon()
+    daemon.monitor_loop()

logos/periodic_table.md

@@ -0,0 +1,48 @@
+# The Periodic Table of Matroska AI Elements
+
+This document defines the fundamental "elements" of the Logos Matroska System, inspired by the IBM AI Periodic Table but adapted for the Recursive Manifold architecture. These elements serve as the atomic units for the "Matroska Tool Token Assignment" and "Semantic Gravity".
+
+## I. Primitives (The Nucleus)
+Fundamental building blocks that cannot be broken down further within the domain.
+
+| Symbol | Element | Description | Logos Mapping |
+| :--- | :--- | :--- | :--- |
+| **Pr** | **Prompt** | The initial input wave or instruction. | `State Buffer` Input |
+| **To** | **Token** | The atomic unit of semantic meaning. | Text Tokens / Image Patches |
+| **Ve** | **Vector** | Numerical representation of meaning (Semantic Gravity). | `Heat Codes` / Embeddings |
+| **Mo** | **Model** | The dense compute node (LLM). | `Gemma`, `RNJ-1`, Local LLMs |
+| **Me** | **Memory** | Persistence of state. | `Manifold` Storage |
+| **Co** | **Code** | Executable logic functions. | Tools / Python Functions |
+
+## II. Compounds (The Molecules)
+Combinations of primitives that form functional units.
+
+| Symbol | Compound | Formula | Description |
+| :--- | :--- | :--- | :--- |
+| **Rag** | **Retrieval** | `Pr + Ve + Me` | Fetching context based on semantic gravity. |
+| **Ch** | **Chain** | `Pr -> Mo -> Pr` | Linear sequence of model calls. |
+| **Fu** | **Function** | `Mo + Co` | LLM calling a specific tool (Tool Use). |
+| **St** | **State** | `Me + time` | The evolving context over recursive loops. |
+
+## III. Organisms (The Agents)
+Self-organizing structures capable of goal-directed behavior.
+
+| Symbol | Organism | Formula | Description |
+| :--- | :--- | :--- | :--- |
+| **Ag** | **Agent** | `Ch + Fu + St` | A recursive loop with tools and memory. |
+| **Sw** | **Swarm** | `Ag + Ag + ...` | Multiple agents coordinating via the Hyper-Graph. |
+| **Ma** | **Matroska** | `Sw^n` | Nested domains of swarms (The Logos System). |
+
+## IV. The Periodic Laws (Rules of Interaction)
+
+1.  **Law of Semantic Gravity**:
+    *   Elements with similar **Ve** (Vectors) attract each other.
+    *   Routing is determined by the "Heat" (Dissonance) between the **Pr** and the **Mo**.
+
+2.  **Law of Recursive Synthesis**:
+    *   Compounds are formed effectively when **St** (State) is preserved across loops.
+    *   A stable **Ag** (Agent) requires a harmonic balance of **Dissonance** (Entropy).
+
+3.  **Law of Matroska Embedding**:
+    *   Higher-order organisms (**Ma**) can contain lower-order elements as "Tokens".
+    *   An entire **Ag** can be treated as a **To** for a higher-level Router.

logos/recursive_mapper.py

@@ -0,0 +1,128 @@
+
+import os
+import ast
+import asyncio
+import math
+import sys
+
+# Ensure logos is in path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from logos.swarm_engine import AsyncSwarmEngine
+
+# CONFIGURATION
+# Adjusted to existing project structure
+TARGET_SECTORS = ["./logos/network", "./logos/agents", "./logos"]
+
+class RecursiveShaderMapper:
+    def __init__(self):
+        self.swarm = AsyncSwarmEngine()
+        print("[MAPPER] Recursive Lens Calibrated. Target: Swarm Architecture.")
+
+    def get_geometric_complexity(self, source_code):
+        """
+        RNJ-1 PULSE: Calculates the 'Hardness' (Cyclomatic Complexity + Nesting).
+        Returns a value 0.0 - 1.0
+        """
+        try:
+            tree = ast.parse(source_code)
+            complexity = 0
+            depth = 0
+            
+            for node in ast.walk(tree):
+                # Branching adds complexity
+                if isinstance(node, (ast.If, ast.For, ast.While, ast.Try)):
+                    complexity += 1
+                # Nested functions/classes add Depth
+                if isinstance(node, (ast.FunctionDef, ast.ClassDef, ast.AsyncFunctionDef)):
+                    depth += 1
+            
+            # Normalize (Heuristic)
+            score = (complexity * 0.5 + depth * 1.5) / 50
+            return min(score, 1.0)
+        except:
+            return 0.0
+
+    def get_semantic_density(self, source_code):
+        """
+        GEMMA PULSE: Calculates the 'Texture' (Comment density, variable length).
+        Returns a value 0.0 - 1.0
+        """
+        total_len = len(source_code)
+        if total_len == 0: return 0.0
+        
+        # Count Docstrings and Comments (Approximation)
+        comment_mass = source_code.count('"""') * 50 + source_code.count('#') * 20
+        
+        density = comment_mass / total_len
+        return min(density * 5, 1.0) # Boost signal
+
+    async def interfere_and_map(self):
+        """
+        The Holographic Sweep.
+        """
+        print("[SWEEP] Firing Dual-Pulse Beams...")
+        
+        found_files = 0
+        for sector in TARGET_SECTORS:
+            sector_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', sector))
+            if not os.path.exists(sector_path):
+                continue
+
+            for root, _, files in os.walk(sector_path):
+                for file in files:
+                    if not file.endswith(".py"): continue
+                    
+                    filepath = os.path.join(root, file)
+                    rel_path = os.path.relpath(filepath, os.path.dirname(os.path.dirname(__file__)))
+                    
+                    try:
+                        with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+                            code = f.read()
+                    except:
+                        continue
+
+                    # 1. PARALLEL PULSE
+                    geo_wave = self.get_geometric_complexity(code)  # RNJ-1
+                    sem_wave = self.get_semantic_density(code)      # GEMMA
+                    
+                    # 2. CALCULATE INTERFERENCE
+                    resonance = (geo_wave + sem_wave) / 2
+                    dissonance = abs(geo_wave - sem_wave)
+                    
+                    status = "STABLE"
+                    color = "GOLD"
+                    
+                    if dissonance > 0.4:
+                        status = "UNSTABLE (High Friction)"
+                        color = "RED"
+                    elif resonance < 0.1:
+                        status = "HOLLOW (Placeholder)"
+                        color = "BLUE"
+
+                    # 3. PULSE TO UI
+                    packet = {
+                        "type": "TENSOR_UPDATE",
+                        "node": file,
+                        "origin": "MAPPER",
+                        "sector": sector,
+                        "depth": round(resonance, 3),
+                        "friction": round(dissonance, 3),
+                        "visual_color": color,
+                        "status": status,
+                        "agent_route": "RECURSIVE_MAPPER",
+                        # Compatibility with LogosGraph
+                        "tensor": f"RES: {resonance:.2f} | DIS: {dissonance:.2f}"
+                    }
+                    
+                    print(f"[{color}] {rel_path} | Depth: {resonance:.2f} | Friction: {dissonance:.2f} -> {status}")
+                    
+                    await self.swarm.broadcast(packet)
+                    found_files += 1
+                    await asyncio.sleep(0.02)
+
+        print(f"\n[COMPLETE] {found_files} files mapped to the manifold.")
+
+if __name__ == "__main__":
+    mapper = RecursiveShaderMapper()
+    asyncio.run(mapper.interfere_and_map())

logos/server.py

@@ -1,9 +1,9 @@
 """
 logos/server.py - Matroska Router Server
-Protocol 5: Mixture of Agents (MoA) Optimization
+Protocol 25: Recursive Manifold Engine (RLM) w/ Harmonic Convergence
 
 This server acts as the "Manifold Constraint," forcing all traffic through your Matroska logic.
-It implements tiered token consumption and routing based on harmonic resonance.
+It implements tiered token consumption, routing based on harmonic resonance, and recursive state refinement.
 """
 
 from flask import Flask, request, jsonify
@@ -15,6 +15,17 @@ import logging
 import sys
 import asyncio
 from logos.agents.video_atomizer import VideoAtomizer
+import requests
+
+# Force UTF-8 encoding for Windows consoles (Protocol 24: Charmap Resilience)
+if sys.platform == 'win32':
+    if hasattr(sys.stdout, 'reconfigure'):
+        sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+        sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+    else:
+        import codecs
+        sys.stdout = codecs.getwriter("utf-8")(sys.stdout.detach())
+        sys.stderr = codecs.getwriter("utf-8")(sys.stderr.detach())
 
 # --- CONFIGURATION ---
 HOST = "0.0.0.0"
@@ -58,263 +69,113 @@ manifold = ManifoldState()
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("LOGOS_Router")
 
-# --- MANIFOLD CONSTRAINT CONFIGURATION ---
-# Protocol 5: Tiered Token Consumption
-# Protocol 10: Swarm Optimization (Unified Model Mode)
-FORCE_SINGLE_MODEL = True  # Set to True to prevent VRAM trashing by model swapping
-UNIFIED_MODEL_ID = "google/gemma-3-4b" # Points to the active model in LM Studio
-
-SHELL_CONFIG = {
-    "INNER_SHELL": {
-        "model": "dolphin-x1-8b" if not FORCE_SINGLE_MODEL else UNIFIED_MODEL_ID,
-        "role": "fractal_architect",
-        "description": "Small Prime Factors. Structural, Binary, Basic.",
-        "max_intake": 4096,
-        "rate_limit": 60, # TPM (Transactions Per Minute)
-        "cost_weight": 1.0
-    },
-    "PRIME_CHANNEL": {
-        "model": "essentialai/rnj-1" if not FORCE_SINGLE_MODEL else UNIFIED_MODEL_ID,
-        "role": "prime_navigator",
-        "description": "Resonant Prime Factors. Logic, Reasoning, Harmony.",
-        "max_intake": 8192,
-        "rate_limit": 20, # Higher compute cost, stricter limit
-        "cost_weight": 2.0
-    },
-    "OUTER_SHELL": {
-        "model": "google/gemma-3-4b" if not FORCE_SINGLE_MODEL else UNIFIED_MODEL_ID,
-        "role": "creative",
-        "description": "Large Prime / Co-Prime. Entropy, Vision, Novelty.",
-        "max_intake": 16384,
-        "rate_limit": 10, # Highest entropy, lowest frequency
-        "cost_weight": 1.5
-    }
-}
-
-# Token Bucket State
-RATE_LIMITS = {k: {"tokens": v["rate_limit"], "last_update": 0} for k, v in SHELL_CONFIG.items()}
+# ==========================================
+# PROTOCOL 25: RECURSIVE MANIFOLD ENGINE (RLM)
+# ==========================================
 
-import zlib
-import time
-from logos.logos_core import STATIC_PRIMES, PRIME_MODULO, get_gpf
+from logos.mhc_router import execute_recursive_manifold, calculate_manifold_constraint, SHELL_CONFIG, RATE_LIMITS
 
-# --- TELEMETRY PULSE BUFFER ---
-# Stores the latest pulses for GUI synchronization
-telemetry_buffer = []
-MAX_TELEMETRY = 100
+# ==========================================
+# PROTOCOL 26: GÖDEL-ZETA DATASTORE
+# ==========================================
+from logos.memory.prime_db import PrimeTokenDB
+prime_db = PrimeTokenDB()
 
-@app.route('/ingest', methods=['POST'])
-def ingest():
-    data = request.json
-    if not data: return jsonify({"error": "No data"}), 400
-    
-    # Store in bit-buffer for UI
-    telemetry_buffer.insert(0, data)
-    if len(telemetry_buffer) > MAX_TELEMETRY:
-        telemetry_buffer.pop()
-        
-    print(f"[INGEST] Captured Pulse: Node {data.get('value')} from {data.get('source')}")
-    return jsonify({"status": "captured", "n": data.get('value')})
+# Simple in-memory index for the session (Simulating the Topology Graph)
+# Map[composite_id] -> filepath
+TOPOLOGY_INDEX = {}
 
-# --- PROTOCOL 19: NEURAL BRIDGE (WebSocket) ---
-@sock.route('/neural-link')
-def neural_link(ws):
-    print("[SERVER] UI Client Connected to Neural Link.")
-    manager.connect(ws)
-    while True:
-        try:
-            data = ws.receive()
-            if not data: break
-            
-            import json
-            payload = json.loads(data)
-            print(f"[INPUT] Received: {payload['content']} (Type: {payload['type']})")
-            
-            # Auto-detect YouTube URL in Omni-Input
-            if "youtube.com" in payload['content'] or "youtu.be" in payload['content']:
-                print("[SERVER] Detected YouTube Signal. Diverting to Video Atomizer...")
-                # Run the atomizer in the background
-                asyncio.run(ingest_video_stream(payload['content']))
-                continue
+# --- API ENDPOINTS ---
 
-            # Run the Holographic Swarm Cycle (Protocol 21)
-            result = asyncio.run(swarm_os.process(payload['content']))
-            
-            # Send the Harmonic Tensor Update back to the UI
-            response = {
-                "type": "TENSOR_UPDATE",
-                "node": result['node'],
-                "coords": result['coords'],
-                "tensor": result['tensor'],
-                "alignment": result['alignment'],
-                "status": result['status'],
-                "agent_route": "HOLOGRAPHIC_BUS"
-            }
-            ws.send(json.dumps(response))
-            
-        except Exception as e:
-            print(f"[WebSocket Error] {e}")
-            break
-    print("[SERVER] UI Client Disconnected.")
-    manager.disconnect(ws)
+@app.route('/', methods=['GET'])
+@app.route('/v1', methods=['GET'])
+def health_check():
+    summary = manifold.get_summary()
+    return jsonify({
+        "status": "online",
+        "system": "LOGOS Matroska Router",
+        "protocol": "Recursive Manifold (Protocol 25) + Gödel-Zeta (Protocol 26)",
+        "shells": list(SHELL_CONFIG.keys()),
+        "manifold_state": summary,
+        "topology_size": len(TOPOLOGY_INDEX)
+    })
 
-async def ingest_video_stream(url):
+@app.route('/index-module', methods=['POST'])
+def index_module():
     """
-    Feeds a Video Stream into the Holographic Manifold.
+    Encodes file content into a unique Composite Integer (Gödel Number).
+    The file effectively becomes a number in the infinite prime field.
     """
-    manager.broadcast({"type": "STATUS", "msg": "CONNECTING TO VIDEO STREAM...", "agent": "V-NODE"})
-    
-    # 2. Get Project DNA (Simulated/Cached from Gemma)
-    project_dna = {
-        "logos/agent_dispatcher.py": ["entropy", "mhc", "rnj-1", "dolphin", "oversight"],
-        "logos/server.py": ["router", "websocket", "link", "pulse"],
-        "logos/baker.py": ["atomic", "dissolution", "prime", "bake"]
-    }
+    data = request.json
+    filepath = data.get('filepath')
+    content = data.get('content', '')
     
-    # 3. Run the Atomizer
-    result = await v_node.ingest_and_align(url, project_dna)
+    if not filepath: return jsonify({"error": "filepath required"}), 400
     
-    if "error" in result:
-        manager.broadcast({"type": "STATUS", "msg": f"SIGNAL LOST: {result['error']}", "agent": "V-NODE"})
-        return
-
-    # 4. Stream the Collisions (Visual Feedback)
-    for alignment in result['alignments']:
-        manager.broadcast({
-            "type": "TENSOR_UPDATE",
-            "node": 101, # Simulating a "Gold" anchor node or the specific file node if indexed
-            "coords": {"x": 0.5, "y": 0.5, "z": 5},
-            "tensor": [[0,0], ["video_link", alignment['source_concept']], alignment['resonance_strength']],
-            "alignment": True,
-            "status": "RESONANCE_ESTABLISHED",
-            "agent_route": f"V-NODE: {alignment['source_concept']}"
-        })
-        await asyncio.sleep(0.2) 
-
-    manager.broadcast({"type": "STATUS", "msg": f"PULSE GROKKED. {len(result['alignments'])} RESONANCE LINKS ESTABLISHED.", "agent": "SYSTEM"})
-
-@app.route('/telemetry', methods=['GET'])
-def get_telemetry():
-    """Expose telemetry buffer to the GUI."""
-    return jsonify(telemetry_buffer)
-
-def check_rate_limit(shell):
-    """
-    Token Bucket Algorithm for Rate Limiting.
-    Returns (True, None) if allowed, (False, error_msg) if blocked.
-    """
-    if shell not in RATE_LIMITS: return True, None
+    # 1. Tokenize (Extract keywords/atoms)
+    # Simple heuristic: split by non-alphanumeric, filter small words
+    import re
+    words = re.findall(r'\b\w+\b', content.lower())
+    significant_tokens = [w for w in words if len(w) > 3][:50] # Limit to top 50 for now
     
-    bucket = RATE_LIMITS[shell]
-    now = time.time()
-    elapsed = now - (bucket["last_update"] or now)
+    # 2. Encode into Manifold
+    composite_id, primes = prime_db.encode_state(significant_tokens)
     
-    # Refill: Rate Limit is per minute
-    # Refill rate = limit / 60 tokens per second
-    limit = SHELL_CONFIG[shell]["rate_limit"]
-    refill = elapsed * (limit / 60.0)
+    # 3. Store in Topology
+    TOPOLOGY_INDEX[composite_id] = filepath
     
-    bucket["tokens"] = min(limit, bucket["tokens"] + refill)
-    bucket["last_update"] = now
+    logger.info(f"[INDEX] {filepath} -> Manifold ID: {composite_id}")
     
-    if bucket["tokens"] >= 1:
-        bucket["tokens"] -= 1
-        return True, None
-    else:
-        wait = 60.0 / limit
-        return False, f"Rate limit exceeded for {shell}. Wait {wait:.1f}s."
+    return jsonify({
+        "status": "INDEXED", 
+        "manifold_id": composite_id,
+        "prime_coordinates": primes,
+        "token_count": len(significant_tokens)
+    })
 
-def calculate_manifold_constraint(text):
+@app.route('/query-topology', methods=['GET'])
+def query_topology():
     """
-    Determines the 'Shell' based on Prime Topology (Manifold Constrained Hyper-Connection).
-    
-    Mapping:
-    - Small GPF (< 100) -> Inner Shell (Fundamental/Structural)
-    - Medium GPF (100 - 1000) -> Prime Channel (Resonant/Logic)
-    - Large GPF (> 1000) -> Outer Shell (High Entropy/Novelty)
+    Finds files that contain the Concept (Prime).
+    Operation: O(1) Divisibility Check per node.
     """
-    # 1. Vision Override (Modality Check)
-    is_vision = getattr(request, 'is_vision', False)
-    if is_vision:
-        return "OUTER_SHELL", 1.0
-        
-    # 2. Keyword Harmonic Override (For User Control)
-    text_lower = text.lower()
-    if any(k in text_lower for k in ["prime", "modulo", "math", "proof"]):
-        return "PRIME_CHANNEL", 1.0
-    if any(k in text_lower for k in ["def ", "class ", "import ", "code", "script"]):
-        return "INNER_SHELL", 1.0
-
-    # 3. Prime Topology Routing (Heat Code Analysis)
-    # Protocol 15: Use DissolutionEngine for Entropy/Heat routing.
-    # We analyze the "Heat" of the prompt to determine destination.
+    concept = request.args.get('concept')
+    if not concept: return jsonify({"error": "concept required"}), 400
     
-    # Dissolve the text into a stream (virtual) or just compute heat directly
-    # Heat = Ratio of High-Entropy Nibbles (FAST_LANE tags) 
+    # 1. Get the Prime for the concept
+    target_prime = prime_db.get_token_prime(concept)
     
-    # Simple Heat Calculation:
-    # 1. Convert to hex
-    hex_str = text.encode('utf-8').hex()
-    total_nibbles = len(hex_str)
-    if total_nibbles == 0: return "INNER_SHELL", 0.5
-    
-    # Count High Entropy Nibbles (Value has 3+ bits set: 7, 11, 13, 14, 15)
-    # Hex: 7, B, D, E, F
-    check_set = {'7', 'b', 'd', 'e', 'f', 'B', 'D', 'E', 'F'}
-    high_entropy_count = sum(1 for c in hex_str if c in check_set)
-    
-    heat_score = high_entropy_count / total_nibbles
-    
-    logger.info(f"Manifold Heat Analysis: {heat_score:.4f} (Total: {total_nibbles} nibbles)")
-    
-    # Topology Logic (Heat Map)
-    if heat_score > 0.4:
-        # Hot Data -> High Entropy -> Outer Shell (Creative/Novelty)
-        # Or Prime Channel? The diagram said Hot -> Mersenne (Fast). 
-        # Outer Shell is "Creative", which fits "Fast/Chaos".
-        return "OUTER_SHELL", heat_score
-    elif heat_score > 0.2:
-        # Warm Data -> Prime Channel (Logic/Math)
-        return "PRIME_CHANNEL", heat_score
-    else:
-        # Cold Data -> Inner Shell (Structure/Code)
-        # Code is actually remarkably low entropy in terms of bit-flips compared to compressed info,
-        # but high structure. 
-        return "INNER_SHELL", heat_score
-
-# --- API ENDPOINTS (OpenAI Compatible + Utility) ---
-
-@app.route('/', methods=['GET'])
-@app.route('/v1', methods=['GET'])
-def health_check():
-    """Root/Health Endpoint for connectivity checks."""
-    summary = manifold.get_summary()
+    # 2. "Scan the Manifold" (Divisibility Check)
+    matches = []
+    for comp_id, fpath in TOPOLOGY_INDEX.items():
+        # THE GODEL CHECK: O(1) Divisibility
+        if comp_id % target_prime == 0:
+            matches.append({
+                "file": fpath,
+                "manifold_id": comp_id
+            })
+            
     return jsonify({
-        "status": "online",
-        "system": "LOGOS Matroska Router",
-        "protocol": "Manifold Constrained (Protocol 5)",
-        "shells": list(SHELL_CONFIG.keys()),
-        "manifold_state": summary
+        "matches": matches, 
+        "concept": concept,
+        "concept_prime": target_prime,
+        "total_nodes_scanned": len(TOPOLOGY_INDEX)
     })
 
 @app.route('/favicon.ico', methods=['GET'])
 def favicon():
-    """Silence browser/client icon requests."""
     return "", 204
 
 @app.route('/v1/chat/completions', methods=['GET'])
 def chat_completions_probe():
-    """Handle GET probes to the POST endpoint."""
     return jsonify({
         "error": "Method Not Allowed",
         "message": "This endpoint requires POST requests with a JSON body.",
         "geometry": "Matroska V1"
     }), 405
 
-
 @app.route('/v1/models', methods=['GET'])
 def list_models():
-    """Spoofs the OpenAI 'List Models' endpoint."""
     return jsonify({
         "object": "list",
         "data": [
@@ -328,136 +189,70 @@ def list_models():
 @app.route('/v1/chat/completions', methods=['POST'])
 def chat_completions():
     """
-    The Main Manifold Router.
+    OpenAI-Compatible Endpoint wrapping the LOGOS RLM.
     """
     data = request.json
     messages = data.get('messages', [])
+    target_model = data.get('model', UNIFIED_MODEL_ID)
     
-    if not messages:
-        return jsonify({"error": "No messages provided"}), 400
+    if not messages: return jsonify({"error": "No messages provided"}), 400
     
-    # Extract prompt
-    # Check if we have vision content (list of dicts)
     last_msg = next((m for m in reversed(messages) if m['role'] == 'user'), None)
-    if not last_msg: return jsonify({"error": "No user message"}), 400
-    
+    if not last_msg: return jsonify({"error": "No user message found"}), 400
+
+    # Vision Handling Check
     last_prompt = ""
     request.is_vision = False
-    
-    if isinstance(last_msg['content'], str):
-        last_prompt = last_msg['content']
-    elif isinstance(last_msg['content'], list):
-        # Vision Request
+    if isinstance(last_msg['content'], list):
         request.is_vision = True
-        # Extract text part for logging
         for part in last_msg['content']:
-            if part.get('type') == 'text':
-                last_prompt += part.get('text', "") + " "
-    
-    # --- PHASE 1: MANIFOLD ANALYSIS ---
-    shell, resonance = calculate_manifold_constraint(last_prompt)
-    
-    # Rate Limit Check
-    allowed, error_msg = check_rate_limit(shell)
-    if not allowed:
-        logger.warning(f"Rate Limit Triggered: {error_msg}")
-        return jsonify({"error": error_msg, "type": "manifold_constraint"}), 429
+             if part.get('type') == 'text': last_prompt += part.get('text', "") + " "
+    else:
+        last_prompt = last_msg['content']
 
-    config = SHELL_CONFIG[shell]
-    target_model = config['model']
-    max_intake = config['max_intake']
+    # --- EXECUTE PROTOCOL 25 (RLM) ---
+    final_state, trajectory = execute_recursive_manifold(last_prompt, target_model)
     
-    logger.info(f"Input Resonance: {resonance:.2f} | Routing to: {shell} ({target_model})")
+    # Calculate usage (Mock for now)
+    prompt_tokens = len(last_prompt) // 4
+    completion_tokens = len(final_state) // 4
+    total_tokens = prompt_tokens + completion_tokens
     
-    # --- PHASE 2: INTAKE CONSTRAINT ---
-    # Truncate history if it exceeds Shell's 'Token Intake' capacity
-    # (Simple character approximation for speed: 1 token ~= 4 chars)
-    # This enforces the "Manifold Constraint" by limiting scope.
-    approx_tokens = sum(len(str(m['content'])) for m in messages) // 4
-    if approx_tokens > max_intake:
-        logger.warning(f"Intake Overflow ({approx_tokens} > {max_intake}). Compressing Context...")
-        # Simple strategy: Keep System + Last N messages
-        if messages and messages[0]['role'] == 'system':
-            kept_system = messages[0]
-            truncated_msgs = messages[-4:] # Keep last 4 turns
-            messages = [kept_system] + truncated_msgs
-        else:
-            messages = messages[-5:]
-            
-    # --- PHASE 3: DISPATCH ---
-    response_text = ""
+    # Update Manifold State (Persistence)
+    shell, _ = calculate_manifold_constraint(last_prompt)
     
-    try:
-        # Use Dispatcher but FORCE the target model derived from Manifold
-        system_prompt = PERSONAS[config['role']]['system_prompt']
-        
-        # We must pass the RAW messages to preserve Vision/History
-        # The connector.chat helper usually takes a string, we might need to use raw client if we implemented it,
-        # But our Dispatcher.connector.chat is a wrapper. 
-        # Let's use the wrapper but be careful.
-        # Actually, since we are the SERVER, we should forward the request to the backend LLM (LM Studio).
-        # We will use 'requests' to proxy pure JSON to port 1234.
-        
-        import requests
-        payload = {
-            "model": target_model, # The Manifold-selected model
-            "messages": messages,
-            "temperature": 0.7,
-            "max_tokens": -1, 
-            "stream": False,
-            "logprobs": True # Protocol 22: Hallucination Gating
-        }
-        
-        # Proxy to LM Studio Backend
-        backend_url = f"http://localhost:1234/v1/chat/completions"
-        resp = requests.post(backend_url, json=payload)
-        
-        if resp.status_code == 200:
-            resp_json = resp.json()
-            response_text = resp_json['choices'][0]['message'].get('content', "")
-            
-            # Protocol 22: Update entropy monitor from server-side proxy
-            logprobs = resp_json['choices'][0].get('logprobs')
-            if logprobs and 'content' in logprobs:
-                swarm_os.oversight.kill_switch.monitor_bulk(logprobs['content'])
-        else:
-            response_text = f"[Backend Error {resp.status_code}] {resp.text}"
-
-    except Exception as e:
-        logger.error(f"Routing Error: {e}")
-        response_text = f"[Manifold Error] {e}"
-
-    # --- PHASE 4: HARMONIC RESPONSE ---
+    # Extract Physics Metrics from the Final State
+    # Note: 'state' variable from mhc_router is the Physics object (AtomicState)
+    # But execute_recursive_manifold returns 'final_state' (str) and 'trajectory' (list).
+    # We need to access the 'state' object from inside execution or modify return signature.
+    # For now, we'll calculate approximate "Session Resonance" based on trajectory.
     
-    # Update Manifold State
-    completion_tokens = len(str(response_text).split())
-    prompt_tokens = len(last_prompt.split())
-    total_tokens = prompt_tokens + completion_tokens
+    session_resonance = 1
+    graph_size = 0
+    # Reconstruct from trajectory
+    # (In a full refactor, execute_recursive_manifold should return the state object)
     
-    # Register "Macro Context"
     manifold.update_shell_stats(shell, total_tokens, last_prompt)
-    
+
     return jsonify({
-        "id": "chatcmpl-logos-" + str(int(np.random.rand()*100000)),
+        "id": f"chatcmpl-logos-{int(time.time())}",
         "object": "chat.completion",
-        "created": int(np.random.rand()*100000),
+        "created": int(time.time()),
         "model": target_model,
         "choices": [{
             "index": 0,
-            "message": {
-                "role": "assistant",
-                "content": str(response_text)
-            },
+            "message": { "role": "assistant", "content": final_state },
             "finish_reason": "stop"
         }],
         "usage": {
             "prompt_tokens": prompt_tokens,
             "completion_tokens": completion_tokens,
             "total_tokens": total_tokens
-        }
+        },
+        "system_fingerprint": f"logos-rlm-v1-depth-{len(trajectory)}"
     })
 
 if __name__ == '__main__':
-    print(f"🌀 LOGOS Matroska Router Active on Port {PORT}")
-    print(f"🔗 Connect Antigravity to: http://localhost:{PORT}/v1")
+    print(f"[SERVER] LOGOS Matroska Router Active on Port {PORT}")
+    print(f"[SERVER] Connect Antigravity to: http://localhost:{PORT}/v1")
     app.run(host=HOST, port=PORT)

logos/swarm_engine.py

@@ -0,0 +1,36 @@
+
+import asyncio
+import json
+import aiohttp
+from typing import Dict, Any, List
+
+class AsyncSwarmEngine:
+    """
+    Protocol 21: The Global Swarm Engine.
+    Coordinates asynchronous pulses across the Matroska domain network.
+    """
+    def __init__(self, backend_url="http://localhost:5000"):
+        self.backend_url = backend_url
+        print(f"[ENGINE] Swarm Engine Initialized. Uplink: {self.backend_url}")
+
+    async def broadcast(self, packet: Dict[str, Any]):
+        """
+        Broadcasting TENSOR_UPDATE to the Neural Link via the main server.
+        """
+        endpoint = f"{self.backend_url}/broadcast"
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(endpoint, json=packet, timeout=5) as resp:
+                    if resp.status == 200:
+                        return True
+        except Exception as e:
+            # Don't fail the mapper if the UI is offline
+            pass
+        return False
+
+    async def pulse(self, node_id: str, payload: Any):
+        """
+        Sends a single pulse to a node in the swarm.
+        """
+        # Placeholder for complex agent-to-agent routing
+        pass