Protocol 26: Configured mHC Hyper-Connections (Alpha/Beta) logic

architecture_manifest.md

@@ -0,0 +1,117 @@
+# 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`.
+
+### 1.10 mHC: Hyper-Connections (Research Video)
+*   **Dynamic Parametrization**: Stabilizing recursive loops by weighing "Residual" vs "New" information.
+*   **PID for Agents**:
+    *   **High Instability (Heat)**: Increase $\alpha$ (Residual/Memory Weight) to ground the model. "Stick to what you know."
+    *   **Low Instability**: Increase $\beta$ (New Insight Weight) to allow exploration.
+*   **Implementation**: Calculating $\alpha = min(0.9, HeatScore)$ in `mhc_router.py`. If $\alpha > 0.7$, we inject a "Stabilizer Atom".
+
+## 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/elements.py

@@ -8,12 +8,12 @@ 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):
+    def __init__(self, symbol: str, name: str, domain: str = "General"):
         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.domain = domain # e.g. "Physics", "Code", "Logic" (Video 26)
         self.heat = 0.0  # Dissonance/Energy
         self.valence = [] # Connections to other atoms (Hyper-Edges)
 

logos/knowledge_base/mhc_research.md

@@ -0,0 +1,30 @@
+
+# Research Note: mHC (Dynamic Hyper-Connections)
+**Source:** User Input / Arxiv[2512.24880]
+**Context:** Improving Residual Connections in Deep Learning
+
+## Core Concepts
+
+1.  **Hyper-Connections**: Generalization of residual connections. Instead of just `y = x + F(x)`, we have dynamic pathways.
+2.  **Dynamic Weighing**: The strength of the connection (residual vs. new) changes based on the input or state.
+3.  **Instability**: Standard residuals can lead to feature collapse or explosion in deep recursion.
+4.  **mHC Solution**: Stabilizes training by parametrizing the residual branch dynamically.
+
+## Integration into LOGOS (Recursive Manifold)
+
+We map "Training Instability" to **"Manifold Dissonance"**.
+The `mhc_router.py` (Recursive Loop) should implement **Dynamic Hyper-Connections**.
+
+### Dynamic Parametrization
+In our loop: `State[t+1] = alpha * State[t] + beta * New_Insight`
+Where `alpha` and `beta` are dynamic hyperparameters derived from the **Heat (Entropy)**.
+
+*   **High Heat (Unstable)** -> Increase `alpha` (Rely more on Residual/Memory), reducing the impact of the new chaotic token.
+*   **Low Heat (Stable)** -> Increase `beta` (Allow more new information/change).
+
+This is effectively a **PID Controller** for the Agent's thought process.
+
+## Implementation Plan
+1.  **Modify `mhc_router.py`**:
+    *   Introduce `hyper_connection_weight` calculated from `dissonance`.
+    *   Apply this weight when merging the recursive step result.

logos/mhc_router.py

@@ -164,10 +164,30 @@ def execute_recursive_manifold(prompt, target_model_id, max_recursion=3, is_visi
                 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. [NEW] mHC: Dynamic Hyper-Connection (Stabilization)
+            # Parametrization: Alpha (Residual) vs Beta (Change) derived from Heat.
+            # High Heat = High Instability = Increase Alpha (Stick to what you know).
+            # Low Heat = Stability = Increase Beta (Allow exploration).
+            
+            alpha = min(0.9, heat_score) # Dampening factor
+            beta = 1.0 - alpha
+            
+            logger.info(f"   ⚖️ [mHC] Hyper-Connection: alpha={alpha:.2f} (Residual), beta={beta:.2f} (New)")
+            
+            # If heat is extremely high, we might want to forcefully prepend the ORIGINAL prompt
+            # to ground the model, effectively a "Heavy Residual" connection.
+            if alpha > 0.7:
+                 logger.info("   ⚓ STABILIZING: Reinforcing Residual Connection (Original Context)")
+                 # We don't change current_content, but we might tweak the directive.
+                 # Actually, let's inject a "Stabilizer Atom"
+                 stabilizer = Atom("St", "mHC_Stabilizer", domain="Control")
+                 state.inject(stabilizer, parent_id=last_atom_id, relation="stablized_by_mHC:High Dissonance Damping")
+                 
+                 # Logic: If unstable, reduce temperature further than normal
+                 target_temp = 0.1
             
-        # 5. Hyper-Connection Routing & Context Expansion
+        # 6. Hyper-Connection Routing & Context Expansion
         if shell == "OUTER_SHELL":
             # Creative / Divergent
             meta_instruction = "Analyze entropy. Expand geometric implications. Think divergently. Use rich vocabulary."