Protocol 22: Update HF Inference to Router endpoint

N8N_ARCHITECTURE.md

@@ -5,12 +5,58 @@ The "Google Antigravity" Neural Router
 Treat n8n as a **Neural Router**, decoupling "Thinking" (Logic/Architecture) from "Inference" (Execution/Code). This bypasses latencies and refusals by routing tasks to the most efficient model.
 
 ## 2. Infrastructure: The "OpenAI-Compatible" Bridge
+**Optimization**: Run n8n **NATIVELY** on Windows (`npm install -g n8n`) instead of Docker.
+- **Why**: Eliminates the `host.docker.internal` bridge bottleneck.
+- **Effect**: N8N talks directly to `localhost:1234` with zero latency overhead.
+
 Standardize all providers to the OpenAI API protocol.
 
 ### Local (Code & Privacy)
-- **Tool**: Ollama / LM Studio
-- **Endpoint**: `http://localhost:11434/v1`
-- **Model**: `dolphin-llama3` (Uncensored, fast, obedient)
+- **Tool**: Ollama / LM Studio (The "New Friends" Cluster)
+- **Endpoint**: 
+    - Ollama: `http://localhost:11434/v1`
+    - LM Studio: `http://localhost:1234/v1`
+### Local Stack (The "Nano Swarm")
+Instead of one giant model, use a stack of specialized lightweight models to save RAM:
+-   **Router/Logic**: `nvidia/nemotron-3-nano` or `Phi-3-Mini` (High logic/param ratio).
+-   **Coding**: `deepseek-coder-6.7b` or `dolphin-2.9-llama3-8b`.
+-   **Creative**: `openhermes-2.5-mistral-7b`.
+
+**Configuration**:
+-   **Endpoint**: `http://localhost:1234/v1`
+-   **Multi-Model**: If using LM Studio, load the specific model needed for the batch, or run multiple instances on ports `1234`, `1235`, `1236`.
+
+### Workflow Import
+A ready-to-use workflow file has been generated at:
+`hf_space/logos_n8n_workflow.json`
+
+**Usage**:
+1.  Open N8N Editor.
+2.  Click **Workflow** > **Import from File**.
+3.  Select `logos_n8n_workflow.json`.
+4.  Execute. It will scan your codebase using the Local Nano Swarm.
+
+### Connection Health Check
+Verify the stack is active with this rhyme test:
+```bash
+curl http://localhost:1234/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "nvidia/nemotron-3-nano",
+    "messages": [
+        {"role": "system", "content": "Always answer in rhymes. Today is Thursday"},
+        {"role": "user", "content": "What day is it today?"}
+    ],
+    "temperature": 0.7,
+    "stream": false
+}'
+```
+2.  Click the **Local Server** icon (`<->`) on the left sidebar.
+3.  Ensure settings:
+    -   **Port**: `1234`
+    -   **CORS**: On (Recommended)
+4.  Click **Start Server**.
+5.  *Green Light*: The log should say `Server listening on http://localhost:1234`.
 
 ### High-Speed Inference (Math & Logic)
 - **Tool**: DeepInfra / Groq
@@ -33,6 +79,14 @@ Classifies incoming request type:
 Use **Merge Node (Wait Mode)** to execute paths simultaneously.
 1.  **Path 1 (Math)**: DeepSeek analyzes Prime Potentiality/Manifold logic.
 2.  **Path 2 (Code)**: Dolphin writes adapters/scripts locally.
+    -   *Implementation Helper*:
+        ```python
+        # Use a pipeline as a high-level helper for local execution
+        from transformers import pipeline
+        pipe = pipeline("text-generation", model="dphn/Dolphin-X1-8B-GGUF")
+        messages = [{"role": "user", "content": "Write the adapter."}]
+        pipe(messages)
+        ```
 3.  **Path 3 (Sys)**: Gemini drafts Strategy/README.
 
 ### Phase C: Consensus (The Annealing)

analyze_uploads.py

@@ -9,14 +9,56 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 from logos.connectors import get_connector
 
 def analyze_uploads():
-    # Paths to uploaded images (Hardcoded from user context for this run)
-    base_dir = r"C:\Users\Nauti\.gemini\antigravity\brain\e29720ce-4e26-4c61-a243-8010483b5424"
-    images = glob.glob(os.path.join(base_dir, "uploaded_image_*.png"))
+    import argparse
+    parser = argparse.ArgumentParser(description="Analyze images from multiple folders.")
+    parser.add_argument("paths", nargs='*', help="File paths or glob patterns")
+    parser.add_argument("--recursive", "-r", action="store_true", help="Recursive search")
+    args = parser.parse_args()
+
+    images = []
+    if not args.paths:
+        # Default behavior: Search current dir
+        print("No paths provided. Searching current directory.")
+        images = glob.glob("*.png")
+    else:
+        for pattern in args.paths:
+            # Handle recursive globs (e.g. **/*.png)
+            if args.recursive and "**" not in pattern:
+                pattern = os.path.join(pattern, "**")
+            
+            # If pattern is a dir, add default extension
+            if os.path.isdir(pattern):
+                pattern = os.path.join(pattern, "*.png")
+                
+            found = glob.glob(pattern, recursive=args.recursive)
+            images.extend(found)
+            
+    # Remove duplicates
+    images = list(set(images))
     
     print(f"Found {len(images)} images to analyze.")
     
     ocr = get_connector('ocr')
-    dolphin = get_connector('dolphin')
+    ocr = get_connector('ocr')
+    
+    # Try Local Stack first (Nano Swarm), fallback to Dolphin Cloud
+    try:
+        from logos.connectors import LocalLLMConnector
+        # Quick check if port 1234 is open
+        import socket
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        result = sock.connect_ex(('localhost', 1234))
+        sock.close()
+        
+        if result == 0:
+            print("[INFO] Local Nano Swarm detected (Port 1234). Using Local Stack.")
+            dolphin = get_connector('local', model="local-model")
+        else:
+            print("[INFO] Local Stack offline. Falling back to Cloud Dolphin.")
+            dolphin = get_connector('dolphin')
+    except Exception as e:
+        print(f"[WARN] Local check failed ({e}). Defaulting to Cloud.")
+        dolphin = get_connector('dolphin')
     
     for img_path in images:
         print(f"\n--- Analyzing {os.path.basename(img_path)} ---")

antigravity_workflow.json

@@ -0,0 +1,345 @@
+{
+    "name": "Antigravity Image Research Extractor",
+    "nodes": [
+        {
+            "parameters": {
+                "path": "C:/Users/Nauti/Desktop/LOGOS CURSOR/LOGOS Notes",
+                "fileExtensions": "jpg,jpeg,png,pdf,heic",
+                "options": {
+                    "recurse": true
+                }
+            },
+            "id": "image_scanner",
+            "name": "Scan Images (Notes)",
+            "type": "n8n-nodes-base.readFilesFromFolder",
+            "position": [
+                250,
+                300
+            ]
+        },
+        {
+            "parameters": {
+                "jsCode": "// ROUTER: Classify images for specialized analysis\nconst images = items.map(item => {\n  const fileName = item.json.fileName;\n  const fileSize = item.json.size || 0;\n  \n  let taskType = 'general_vision';\n  let priority = 1;\n  \n  // Route by filename patterns and size\n  if (fileName.includes('diagram') || fileName.includes('sketch')) {\n    taskType = 'diagram_analysis';\n    priority = 3;\n  } else if (fileName.includes('note') || fileName.includes('handwritten')) {\n    taskType = 'handwriting_ocr';\n    priority = 2;\n  } else if (fileName.includes('ui') || fileName.includes('interface')) {\n    taskType = 'ui_analysis';\n    priority = 3;\n  } else if (fileSize < 500000) {\n    taskType = 'handwriting_ocr'; // Smaller files likely notes\n    priority = 2;\n  } else {\n    taskType = 'diagram_analysis'; // Larger files likely detailed diagrams\n    priority = 3;\n  }\n  \n  return {\n    json: {\n      fileName,\n      taskType,\n      priority,\n      fullPath: item.json.directory + '/' + fileName,\n      fileSize\n    },\n    binary: item.binary\n  };\n});\n\nreturn images;"
+            },
+            "id": "router",
+            "name": "Neural Router",
+            "type": "n8n-nodes-base.code",
+            "position": [
+                450,
+                300
+            ]
+        },
+        {
+            "parameters": {
+                "conditions": {
+                    "options": {
+                        "caseSensitive": false
+                    },
+                    "conditions": [
+                        {
+                            "id": "handwriting_path",
+                            "leftValue": "={{ $json.taskType }}",
+                            "rightValue": "handwriting_ocr",
+                            "operator": {
+                                "type": "string",
+                                "operation": "equals"
+                            }
+                        },
+                        {
+                            "id": "diagram_path",
+                            "leftValue": "={{ $json.taskType }}",
+                            "rightValue": "diagram_analysis",
+                            "operator": {
+                                "type": "string",
+                                "operation": "equals"
+                            }
+                        },
+                        {
+                            "id": "ui_path",
+                            "leftValue": "={{ $json.taskType }}",
+                            "rightValue": "ui_analysis",
+                            "operator": {
+                                "type": "string",
+                                "operation": "equals"
+                            }
+                        }
+                    ]
+                },
+                "options": {}
+            },
+            "id": "switch",
+            "name": "Task Switch",
+            "type": "n8n-nodes-base.switch",
+            "position": [
+                650,
+                300
+            ]
+        },
+        {
+            "parameters": {
+                "method": "POST",
+                "url": "https://api-inference.huggingface.co/models/microsoft/trocr-base-handwritten",
+                "authentication": "genericCredentialType",
+                "genericAuthType": "httpHeaderAuth",
+                "sendHeaders": true,
+                "headerParameters": {
+                    "parameters": [
+                        {
+                            "name": "Content-Type",
+                            "value": "application/json"
+                        }
+                    ]
+                },
+                "sendBody": true,
+                "specifyBody": "json",
+                "jsonBody": "={\n  \"inputs\": \"{{ $binary.data.toString('base64') }}\"\n}",
+                "options": {}
+            },
+            "id": "ocr_analyst",
+            "name": "OCR Handwriting (TrOCR)",
+            "type": "n8n-nodes-base.httpRequest",
+            "position": [
+                850,
+                200
+            ]
+        },
+        {
+            "parameters": {
+                "method": "POST",
+                "url": "http://localhost:1234/v1/chat/completions",
+                "authentication": "none",
+                "sendHeaders": true,
+                "headerParameters": {
+                    "parameters": [
+                        {
+                            "name": "Content-Type",
+                            "value": "application/json"
+                        }
+                    ]
+                },
+                "sendBody": true,
+                "specifyBody": "json",
+                "jsonBody": "={\n  \"model\": \"llava-v1.6-mistral-7b\",\n  \"messages\": [\n    {\n      \"role\": \"system\",\n      \"content\": \"You are a technical diagram analyst specializing in geometry, polyforms, and compression systems. Identify: 1) Mathematical concepts shown, 2) Geometric shapes/polyhedra types, 3) Compression techniques mentioned, 4) UI/workflow elements. Output structured JSON.\"\n    },\n    {\n      \"role\": \"user\",\n      \"content\": [\n        {\n          \"type\": \"text\",\n          \"text\": \"Analyze this diagram from {{ $json.fileName }}. Focus on polyform development, compression methods, and UI design.\"\n        },\n        {\n          \"type\": \"image_url\",\n          \"image_url\": {\n            \"url\": \"data:image/jpeg;base64,{{ $binary.data.toString('base64') }}\"\n          }\n        }\n      ]\n    }\n  ],\n  \"temperature\": 0.2,\n  \"max_tokens\": 1500\n}",
+                "options": {}
+            },
+            "id": "diagram_analyst",
+            "name": "Diagram Analyst (LLaVA)",
+            "type": "n8n-nodes-base.httpRequest",
+            "position": [
+                850,
+                300
+            ]
+        },
+        {
+            "parameters": {
+                "method": "POST",
+                "url": "http://localhost:1234/v1/chat/completions",
+                "authentication": "none",
+                "sendHeaders": true,
+                "headerParameters": {
+                    "parameters": [
+                        {
+                            "name": "Content-Type",
+                            "value": "application/json"
+                        }
+                    ]
+                },
+                "sendBody": true,
+                "specifyBody": "json",
+                "jsonBody": "={\n  \"model\": \"llava-v1.6-mistral-7b\",\n  \"messages\": [\n    {\n      \"role\": \"system\",\n      \"content\": \"You are a UI/UX analyst. Extract: 1) Interface components shown, 2) Interaction patterns, 3) Data visualization methods, 4) Success indicators mentioned, 5) User workflow steps. Output structured JSON.\"\n    },\n    {\n      \"role\": \"user\",\n      \"content\": [\n        {\n          \"type\": \"text\",\n          \"text\": \"Analyze UI design from {{ $json.fileName }}. Identify successful patterns for polyform visualization and user interaction.\"\n        },\n        {\n          \"type\": \"image_url\",\n          \"image_url\": {\n            \"url\": \"data:image/jpeg;base64,{{ $binary.data.toString('base64') }}\"\n          }\n        }\n      ]\n    }\n  ],\n  \"temperature\": 0.3,\n  \"max_tokens\": 1200\n}",
+                "options": {}
+            },
+            "id": "ui_analyst",
+            "name": "UI Analyst (LLaVA)",
+            "type": "n8n-nodes-base.httpRequest",
+            "position": [
+                850,
+                400
+            ]
+        },
+        {
+            "parameters": {
+                "mode": "mergeByPosition",
+                "options": {}
+            },
+            "id": "merge",
+            "name": "Merge Analysis",
+            "type": "n8n-nodes-base.merge",
+            "position": [
+                1050,
+                300
+            ]
+        },
+        {
+            "parameters": {
+                "jsCode": "// SYNTHESIS: Parse vision model responses and structure results\nconst results = items.map(item => {\n  let analysis = {};\n  \n  try {\n    // Handle TrOCR response (array format)\n    if (Array.isArray(item.json)) {\n      analysis = {\n        extracted_text: item.json[0]?.generated_text || item.json.toString(),\n        confidence: item.json[0]?.score || 0.8\n      };\n    }\n    // Handle LLaVA response (OpenAI format)\n    else if (item.json.choices) {\n      const content = item.json.choices[0]?.message?.content || '{}';\n      analysis = JSON.parse(content);\n    }\n    // Handle direct JSON response\n    else if (typeof item.json === 'object') {\n      analysis = item.json;\n    }\n    else {\n      analysis = { raw_response: JSON.stringify(item.json) };\n    }\n  } catch (e) {\n    analysis = {\n      raw_response: JSON.stringify(item.json),\n      parse_error: true,\n      error_detail: e.message\n    };\n  }\n  \n  return {\n    json: {\n      file: item.json.fileName || 'unknown',\n      taskType: item.json.taskType,\n      analysis,\n      timestamp: new Date().toISOString()\n    }\n  };\n});\n\nreturn results;"
+            },
+            "id": "synthesizer",
+            "name": "Synthesizer",
+            "type": "n8n-nodes-base.code",
+            "position": [
+                1250,
+                300
+            ]
+        },
+        {
+            "parameters": {
+                "method": "POST",
+                "url": "http://localhost:1234/v1/chat/completions",
+                "authentication": "none",
+                "sendHeaders": true,
+                "headerParameters": {
+                    "parameters": [
+                        {
+                            "name": "Content-Type",
+                            "value": "application/json"
+                        }
+                    ]
+                },
+                "sendBody": true,
+                "specifyBody": "json",
+                "jsonBody": "={\n  \"model\": \"nvidia/nemotron-3-nano\",\n  \"messages\": [\n    {\n      \"role\": \"system\",\n      \"content\": \"You are the RESEARCH SYNTHESIZER for a polyform compression project. Analyze handwritten notes and diagrams to extract: 1) POLYFORM TYPES (Platonic, Archimedean, Johnson, near-miss solids, geodesics), 2) COMPRESSION METHODS (vertex encoding, edge compression, spheroid nets), 3) SUCCESSFUL UI PATTERNS from iterations, 4) MATHEMATICAL INSIGHTS (topology, manifolds, optimization), 5) CRITICAL GAPS to address. Output: Executive Summary, Key Findings by Category, Priority Next Steps, Integration Opportunities.\"\n    },\n    {\n      \"role\": \"user\",\n      \"content\": \"Synthesize these image analyses from research notes:\\n\\n{{ JSON.stringify($json) }}\\n\\nFocus on actionable insights for building the polyform generator and compression library.\"\n    }\n  ],\n  \"temperature\": 0.3,\n  \"max_tokens\": 3000\n}",
+                "options": {}
+            },
+            "id": "jury",
+            "name": "Jury Consensus (Nemotron)",
+            "type": "n8n-nodes-base.httpRequest",
+            "position": [
+                1450,
+                300
+            ]
+        },
+        {
+            "parameters": {
+                "operation": "write",
+                "fileName": "=/tmp/polyform_research_{{ DateTime.now().toFormat('yyyyMMdd_HHmmss') }}.json",
+                "options": {}
+            },
+            "id": "save_results",
+            "name": "Save Research Synthesis",
+            "type": "n8n-nodes-base.writeFile",
+            "position": [
+                1650,
+                300
+            ]
+        }
+    ],
+    "connections": {
+        "image_scanner": {
+            "main": [
+                [
+                    {
+                        "node": "router",
+                        "type": "main",
+                        "index": 0
+                    }
+                ]
+            ]
+        },
+        "router": {
+            "main": [
+                [
+                    {
+                        "node": "switch",
+                        "type": "main",
+                        "index": 0
+                    }
+                ]
+            ]
+        },
+        "switch": {
+            "main": [
+                [
+                    {
+                        "node": "ocr_analyst",
+                        "type": "main",
+                        "index": 0
+                    }
+                ],
+                [
+                    {
+                        "node": "diagram_analyst",
+                        "type": "main",
+                        "index": 0
+                    }
+                ],
+                [
+                    {
+                        "node": "ui_analyst",
+                        "type": "main",
+                        "index": 0
+                    }
+                ]
+            ]
+        },
+        "ocr_analyst": {
+            "main": [
+                [
+                    {
+                        "node": "merge",
+                        "type": "main",
+                        "index": 0
+                    }
+                ]
+            ]
+        },
+        "diagram_analyst": {
+            "main": [
+                [
+                    {
+                        "node": "merge",
+                        "type": "main",
+                        "index": 1
+                    }
+                ]
+            ]
+        },
+        "ui_analyst": {
+            "main": [
+                [
+                    {
+                        "node": "merge",
+                        "type": "main",
+                        "index": 2
+                    }
+                ]
+            ]
+        },
+        "merge": {
+            "main": [
+                [
+                    {
+                        "node": "synthesizer",
+                        "type": "main",
+                        "index": 0
+                    }
+                ]
+            ]
+        },
+        "synthesizer": {
+            "main": [
+                [
+                    {
+                        "node": "jury",
+                        "type": "main",
+                        "index": 0
+                    }
+                ]
+            ]
+        },
+        "jury": {
+            "main": [
+                [
+                    {
+                        "node": "save_results",
+                        "type": "main",
+                        "index": 0
+                    }
+                ]
+            ]
+        }
+    },
+    "settings": {
+        "executionOrder": "v1"
+    }
+}

app.py

@@ -391,34 +391,14 @@ with gr.Blocks(theme=gr.themes.Monochrome(), title="LOGOS SPCW Protocol") as dem
                 history = history or []
                 history.append((message, None))
                 
-                # Try Dolphin connector first, fallback to simple response
+                # 1. Try Local Swarm (Protocol 5: Privacy First)
                 try:
                     from logos.connectors import get_connector
-                    dolphin = get_connector('dolphin')
+                    # Prioritize Local
+                    agent = get_connector('local') 
                     
-                    # Load Knowledge Base for Self-Contained Context
-                    kb_context = ""
-                    try:
-                        import json
-                        if os.path.exists("logos_knowledge_base.json"):
-                            with open("logos_knowledge_base.json", "r") as f:
-                                kb_data = json.load(f)
-                                # Summarize KB: List documents and word counts
-                                docs = kb_data.get('documents', [])
-                                kb_context = "\nINTERNAL KNOWLEDGE BASE:\n"
-                                for d in docs:
-                                    kb_context += f"- Doc: {d.get('filename')} ({d.get('word_count')} words)\n"
-                                    # Inject full text if small enough, otherwise summary
-                                    text = d.get('full_text', '')
-                                    if len(text) < 1000:
-                                        kb_context += f"  Content: {text}\n"
-                                    else:
-                                        kb_context += f"  Excerpt: {text[:500]}...\n"
-                    except Exception:
-                        kb_context = "\n[Knowledge Base Not Loaded]"
-
                     # LOGOS System Context
-                    logos_context = f"""You are LOGOS, an AI assistant specialized in:
+                    logos_context = f"""You are LOGOS (Local Swarm Node), specialized in:
 - Prime Network Architecture (integer topology, GCD routing)
 - SPCW (Structured Prime Composite Waveform) protocol
 - Hex/Binary Dissolution and enterprise routing
@@ -426,10 +406,13 @@ with gr.Blocks(theme=gr.themes.Monochrome(), title="LOGOS SPCW Protocol") as dem
 
 {kb_context}
 """
+                    response = agent.chat(message, system_prompt=logos_context)
                     
-                    # Use Dolphin Chat
-                    # My DolphinAgentConnector.chat takes (message, system_prompt)
-                    response = dolphin.chat(message, system_prompt=logos_context)
+                    # If Local failed, try Cloud Dolphin
+                    if "[Local LLM Error]" in response:
+                        agent = get_connector('dolphin')
+                        response = agent.chat(message, system_prompt=logos_context)
+                        
                     history[-1] = (message, response)
                 except Exception as e:
                     # Fallback response
@@ -470,6 +453,205 @@ with gr.Blocks(theme=gr.themes.Monochrome(), title="LOGOS SPCW Protocol") as dem
             btn_refresh = gr.Button("🔄 Refresh Status")
             btn_refresh.click(lambda: get_connector_status(), None, status_display)
 
+        with gr.Tab("🔮 Manifold Geometry"):
+            gr.Markdown("## Protocol 5: Prime Topology Viewer")
+            gr.Markdown("*Live Telemetry from the Matroska Router*")
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 🐚 Shell Token Intake")
+                    shell_plot = gr.Plot(label="Token Consumption by Shell")
+                with gr.Column():
+                    gr.Markdown("### 🧠 Macro Context (Recent Intent)")
+                    context_log = gr.Dataframe(headers=["Time", "Shell", "Summary"], label="Swarm Memory")
+
+            manifold_timer = gr.Timer(5) # Auto-refresh every 5s
+
+            def fetch_manifold_data():
+                """Poll the Router for State."""
+                import requests
+                import pandas as pd
+                try:
+                    # Target Router specifically (Port 5000)
+                    url = "http://localhost:5000/v1" 
+                    resp = requests.get(url, timeout=1)
+                    data = resp.json()
+                    state = data.get("manifold_state", {})
+                    
+                    # 1. Plot Shell Stats
+                    shells = state.get("shells", {})
+                    names = list(shells.keys())
+                    tokens = [shells[k]["tokens_intake"] for k in names]
+                    
+                    # Color mapping for shells
+                    colors = {
+                        "INNER_SHELL": "#00ffea",   # Cyan (Structure)
+                        "PRIME_CHANNEL": "#9d4edd", # Purple (Math)
+                        "OUTER_SHELL": "#ff0055"    # Red (Entropy)
+                    }
+                    bar_colors = [colors.get(n, "#888") for n in names]
+
+                    # --- 3D Manifold Structure (AlphaFold View) ---
+                    nodes = state.get("graph", {}).get("nodes", [])
+                    if nodes:
+                        x_vals = [n["geometry"]["position"]["x"] for n in nodes if "position" in n.get("geometry", {})]
+                        y_vals = [n["geometry"]["position"]["y"] for n in nodes if "position" in n.get("geometry", {})]
+                        z_vals = [n["geometry"]["position"]["z"] for n in nodes if "position" in n.get("geometry", {})]
+                        colors = [1 if n["geometry"]["domain"] == "OUTER_SHELL" else 0.5 if n["geometry"]["domain"] == "PRIME_CHANNEL" else 0 for n in nodes if "position" in n.get("geometry", {})]
+                        text_labels = [n["name"] for n in nodes if "position" in n.get("geometry", {})]
+
+                        # Map Liveness to Opacity/Size
+                        opacity_vals = [0.8 if n.get("alive", 1) == 1 else 0.1 for n in nodes if "position" in n.get("geometry", {})]
+                        size_vals = [5 if n.get("alive", 1) == 1 else 2 for n in nodes if "position" in n.get("geometry", {})]
+                        
+                        # Map Liveness & Morphogenesis to Visuals
+                        colors = []
+                        for n in nodes:
+                            if "position" not in n.get("geometry", {}): 
+                                continue
+                            
+                            action = n.get("action_pending")
+                            if action == "MITOSIS":
+                                colors.append("#00FF00") # Green for Growth/Split
+                            elif action == "REGENERATE":
+                                colors.append("#FFD700") # Gold for Healing
+                            elif action == "SPAWN_META_TOKEN":
+                                colors.append("#00FFFF") # Azure for Birth
+                            elif n.get("alive", 1) == 1:
+                                # Normal Alive: Domain Color matches Plotly defaults for Shells
+                                d = n["geometry"]["domain"]
+                                if d == "OUTER_SHELL": colors.append(1)
+                                elif d == "PRIME_CHANNEL": colors.append(0.5)
+                                else: colors.append(0)
+                            else:
+                                colors.append("#222222") # Dead/Gray
+
+                        text_labels = []
+                        for n in nodes:
+                             if "position" in n.get("geometry", {}):
+                                 status = "ALIVE" if n.get("alive", 1) else "DEAD"
+                                 action = n.get("action_pending", "")
+                                 label = f"{n['name']} ({status})"
+                                 if action: label += f" [{action}]"
+                                 text_labels.append(label)
+
+                        fig = go.Figure(data=[go.Scatter3d(
+                            x=x_vals, y=y_vals, z=z_vals,
+                            mode='markers',
+                            text=text_labels,
+                            marker=dict(
+                                size=size_vals,
+                                color=colors,
+                                colorscale='Viridis',
+                                opacity=opacity_vals
+                            )
+                        )])
+                        fig.update_layout(
+                            title="Codebase Manifold Geometry",
+                            scene=dict(
+                                xaxis_title='Hash Resonance (X)',
+                                yaxis_title='Hash Resonance (Y)',
+                                zaxis_title='Domain Depth (Z)'
+                            ),
+                            margin=dict(l=0, r=0, b=0, t=30)
+                        )
+                    else:
+                        # Fallback empty plot
+                        fig = go.Figure()
+                        fig.add_annotation(text="No 3D graph data available.", showarrow=False)
+                    
+                    # 2. Context Log
+                    ctx = state.get("macro_context", [])
+                    df_data = []
+                    for c in reversed(ctx): # Show newest first
+                        t_str = time.strftime('%H:%M:%S', time.localtime(c['time']))
+                        df_data.append([t_str, c['shell'], c['summary']])
+                    
+                    if not df_data:
+                        df_data = [["-", "-", "No history yet"]]
+                        
+                    return fig, df_data
+                    
+                except Exception as e:
+                    # Return empty/error state
+                    err_fig = go.Figure()
+                    err_fig.add_annotation(text=f"Router Offline: {e}", showarrow=False)
+                    return err_fig, [["ERROR", "-", str(e)]]
+
+            manifold_timer.tick(fetch_manifold_data, outputs=[shell_plot, context_log])
+            # Initial load
+            demo.load(fetch_manifold_data, outputs=[shell_plot, context_log])
+
+        with gr.Tab("🚀 Mission Control"):
+            gr.Markdown("## Unified Command Deck")
+            gr.Markdown("*Manage your agents and workflows from a single pane.*")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📡 Local Nanostack (The Swarm)")
+                    swarm_status = gr.Markdown("Checking...")
+                    btn_ping = gr.Button("Ping Localhost:1234")
+                
+                with gr.Column(scale=2):
+                    gr.Markdown("### ⚡ Workflow Actions")
+                    with gr.Row():
+                        btn_scan = gr.Button("📂 Analyze Notes (Run Script)", variant="secondary")
+                        btn_n8n = gr.Button("🔗 Import N8N Workflow", link="file=hf_space/logos_n8n_workflow.json")
+            
+            log_output = gr.Code(label="System Logs / Analysis Output", language="markdown", lines=20)
+            
+            def check_swarm():
+                """Ping Localhost:1234 (Auto-detecting Docker Bridge)"""
+                endpoints = [
+                    "http://localhost:1234/v1/models",
+                    "http://host.docker.internal:1234/v1/models"
+                ]
+                
+                for url in endpoints:
+                    try:
+                        import requests
+                        resp = requests.get(url, timeout=2)
+                        if resp.status_code == 200:
+                            models = [m['id'] for m in resp.json().get('data', [])]
+                            host_alias = "Localhost" if "localhost" in url else "DockerHost"
+                            return f"### ✅ ONLINE ({host_alias})\n**Port:** 1234\n**Active Models:**\n`{', '.join(models[:3])}`" 
+                    except:
+                        continue
+                
+                return "### 🔴 OFFLINE\nEnsure LM Studio Server is running on Port 1234."
+
+            def run_analysis_script():
+                """Run analyze_uploads.py and capture output"""
+                import subprocess
+                try:
+                    # Run the script we upgraded earlier
+                    result = subprocess.run(
+                        [sys.executable, "hf_space/analyze_uploads.py", "--recursive"],
+                        capture_output=True,
+                        text=True,
+                        cwd=os.path.dirname(current_dir) # Run from project root
+                    )
+                    
+                    output = f"### Execution Result (Exit Code: {result.returncode})\n\n"
+                    if result.stdout:
+                        output += f"**STDOUT**:\n```\n{result.stdout}\n```\n"
+                    if result.stderr:
+                        output += f"**STDERR**:\n```\n{result.stderr}\n```\n"
+                    
+                    if result.returncode == 0:
+                        output += "\n\n✅ Analysis Complete. Check knowledge base."
+                    else:
+                        output += "\n\n❌ Analysis Failed."
+                        
+                    return output
+                except Exception as e:
+                    return f"### Execution Error\n{str(e)}"
+
+            btn_ping.click(check_swarm, None, swarm_status)
+            btn_scan.click(run_analysis_script, None, log_output)
+            # Auto-check on load
+            demo.load(check_swarm, None, swarm_status)
+
 
 if __name__ == "__main__":
     # HF Spaces configuration

dist/assets/index-W_vgHdSs.css

@@ -0,0 +1 @@
+*,:before,:after{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }::backdrop{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }*,:before,:after{box-sizing:border-box;border-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:JetBrains Mono,Fira Code,monospace;font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-size:100%;font-weight:inherit;line-height:inherit;letter-spacing:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}button,input:where([type=button]),input:where([type=reset]),input:where([type=submit]){-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}ol,ul,menu{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,textarea::-moz-placeholder{opacity:1;color:#9ca3af}input::placeholder,textarea::placeholder{opacity:1;color:#9ca3af}button,[role=button]{cursor:pointer}:disabled{cursor:default}img,svg,video,canvas,audio,iframe,embed,object{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}.pointer-events-none{pointer-events:none}.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.bottom-10{bottom:2.5rem}.bottom-6{bottom:1.5rem}.bottom-8{bottom:2rem}.left-1\/2{left:50%}.left-6{left:1.5rem}.right-4{right:1rem}.right-8{right:2rem}.top-1\/2{top:50%}.top-8{top:2rem}.z-50{z-index:50}.mb-0\.5{margin-bottom:.125rem}.mb-10{margin-bottom:2.5rem}.mb-2{margin-bottom:.5rem}.mb-3{margin-bottom:.75rem}.mb-4{margin-bottom:1rem}.mb-6{margin-bottom:1.5rem}.mt-1{margin-top:.25rem}.mt-4{margin-top:1rem}.mt-auto{margin-top:auto}.flex{display:flex}.h-1{height:.25rem}.h-1\.5{height:.375rem}.h-12{height:3rem}.h-14{height:3.5rem}.h-2{height:.5rem}.h-32{height:8rem}.h-5{height:1.25rem}.h-full{height:100%}.h-screen{height:100vh}.max-h-48{max-height:12rem}.w-1\.5{width:.375rem}.w-14{width:3.5rem}.w-2{width:.5rem}.w-5{width:1.25rem}.w-80{width:20rem}.w-\[850px\]{width:850px}.w-full{width:100%}.w-screen{width:100vw}.flex-1{flex:1 1 0%}.-translate-x-1\/2{--tw-translate-x: -50%;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.-translate-y-1\/2{--tw-translate-y: -50%;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}@keyframes ping{75%,to{transform:scale(2);opacity:0}}.animate-ping{animation:ping 1s cubic-bezier(0,0,.2,1) infinite}@keyframes pulse{50%{opacity:.5}}.animate-pulse{animation:pulse 2s cubic-bezier(.4,0,.6,1) infinite}@keyframes spin{to{transform:rotate(360deg)}}.animate-spin{animation:spin 1s linear infinite}.cursor-crosshair{cursor:crosshair}.cursor-pointer{cursor:pointer}.select-none{-webkit-user-select:none;-moz-user-select:none;user-select:none}.flex-col{flex-direction:column}.items-start{align-items:flex-start}.items-end{align-items:flex-end}.items-center{align-items:center}.items-stretch{align-items:stretch}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-1{gap:.25rem}.gap-12{gap:3rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.gap-4{gap:1rem}.gap-6{gap:1.5rem}.space-y-1>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.25rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.25rem * var(--tw-space-y-reverse))}.space-y-2>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.space-y-3>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.75rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.75rem * var(--tw-space-y-reverse))}.space-y-6>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1.5rem * var(--tw-space-y-reverse))}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-y-auto{overflow-y:auto}.truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.break-all{word-break:break-all}.rounded{border-radius:.25rem}.rounded-2xl{border-radius:1rem}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:.5rem}.rounded-sm{border-radius:.125rem}.rounded-xl{border-radius:.75rem}.border{border-width:1px}.border-b{border-bottom-width:1px}.border-l-2{border-left-width:2px}.border-t{border-top-width:1px}.border-green-500\/50{border-color:#22c55e80}.border-prime-gold\/40{border-color:#ffd70066}.border-red-500{--tw-border-opacity: 1;border-color:rgb(239 68 68 / var(--tw-border-opacity, 1))}.border-red-500\/50{border-color:#ef444480}.border-white\/10{border-color:#ffffff1a}.border-white\/5{border-color:#ffffff0d}.bg-\[\#00FFFF\]{--tw-bg-opacity: 1;background-color:rgb(0 255 255 / var(--tw-bg-opacity, 1))}.bg-\[\#050505\]{--tw-bg-opacity: 1;background-color:rgb(5 5 5 / var(--tw-bg-opacity, 1))}.bg-\[\#FF00FF\]{--tw-bg-opacity: 1;background-color:rgb(255 0 255 / var(--tw-bg-opacity, 1))}.bg-black{--tw-bg-opacity: 1;background-color:rgb(0 0 0 / var(--tw-bg-opacity, 1))}.bg-black\/40{background-color:#0006}.bg-black\/50{background-color:#00000080}.bg-black\/70{background-color:#000000b3}.bg-black\/80{background-color:#000c}.bg-green-500{--tw-bg-opacity: 1;background-color:rgb(34 197 94 / var(--tw-bg-opacity, 1))}.bg-prime-gold{--tw-bg-opacity: 1;background-color:rgb(255 215 0 / var(--tw-bg-opacity, 1))}.bg-red-500{--tw-bg-opacity: 1;background-color:rgb(239 68 68 / var(--tw-bg-opacity, 1))}.bg-red-500\/10{background-color:#ef44441a}.bg-red-500\/20{background-color:#ef444433}.bg-white{--tw-bg-opacity: 1;background-color:rgb(255 255 255 / var(--tw-bg-opacity, 1))}.bg-white\/5{background-color:#ffffff0d}.bg-white\/\[0\.02\]{background-color:#ffffff05}.bg-white\/\[0\.03\]{background-color:#ffffff08}.bg-white\/\[0\.05\]{background-color:#ffffff0d}.p-2{padding:.5rem}.p-3{padding:.75rem}.p-4{padding:1rem}.p-6{padding:1.5rem}.px-1{padding-left:.25rem;padding-right:.25rem}.px-1\.5{padding-left:.375rem;padding-right:.375rem}.px-10{padding-left:2.5rem;padding-right:2.5rem}.px-2{padding-left:.5rem;padding-right:.5rem}.px-6{padding-left:1.5rem;padding-right:1.5rem}.py-0\.5{padding-top:.125rem;padding-bottom:.125rem}.py-1\.5{padding-top:.375rem;padding-bottom:.375rem}.py-4{padding-top:1rem;padding-bottom:1rem}.pb-2{padding-bottom:.5rem}.pl-4{padding-left:1rem}.pt-4{padding-top:1rem}.pt-8{padding-top:2rem}.text-center{text-align:center}.font-mono{font-family:JetBrains Mono,Fira Code,monospace}.text-2xl{font-size:1.5rem;line-height:2rem}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.text-\[8px\]{font-size:8px}.text-\[9px\]{font-size:9px}.text-lg{font-size:1.125rem;line-height:1.75rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xs{font-size:.75rem;line-height:1rem}.font-bold{font-weight:700}.font-light{font-weight:300}.uppercase{text-transform:uppercase}.italic{font-style:italic}.leading-none{line-height:1}.leading-relaxed{line-height:1.625}.tracking-\[0\.2em\]{letter-spacing:.2em}.tracking-\[0\.3em\]{letter-spacing:.3em}.tracking-\[0\.4em\]{letter-spacing:.4em}.tracking-\[0\.5em\]{letter-spacing:.5em}.tracking-tighter{letter-spacing:-.05em}.tracking-widest{letter-spacing:.1em}.text-gray-500{--tw-text-opacity: 1;color:rgb(107 114 128 / var(--tw-text-opacity, 1))}.text-green-400{--tw-text-opacity: 1;color:rgb(74 222 128 / var(--tw-text-opacity, 1))}.text-green-500{--tw-text-opacity: 1;color:rgb(34 197 94 / var(--tw-text-opacity, 1))}.text-green-500\/70{color:#22c55eb3}.text-prime-gold{--tw-text-opacity: 1;color:rgb(255 215 0 / var(--tw-text-opacity, 1))}.text-red-400{--tw-text-opacity: 1;color:rgb(248 113 113 / var(--tw-text-opacity, 1))}.text-red-500{--tw-text-opacity: 1;color:rgb(239 68 68 / var(--tw-text-opacity, 1))}.text-white{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity, 1))}.opacity-10{opacity:.1}.opacity-20{opacity:.2}.opacity-30{opacity:.3}.opacity-40{opacity:.4}.opacity-60{opacity:.6}.opacity-80{opacity:.8}.shadow-2xl{--tw-shadow: 0 25px 50px -12px rgb(0 0 0 / .25);--tw-shadow-colored: 0 25px 50px -12px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-\[0_0_15px_rgba\(239\,68\,68\,0\.4\)\]{--tw-shadow: 0 0 15px rgba(239,68,68,.4);--tw-shadow-colored: 0 0 15px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-\[0_0_50px_rgba\(0\,0\,0\,1\)\]{--tw-shadow: 0 0 50px rgba(0,0,0,1);--tw-shadow-colored: 0 0 50px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-inner{--tw-shadow: inset 0 2px 4px 0 rgb(0 0 0 / .05);--tw-shadow-colored: inset 0 2px 4px 0 var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-xl{--tw-shadow: 0 20px 25px -5px rgb(0 0 0 / .1), 0 8px 10px -6px rgb(0 0 0 / .1);--tw-shadow-colored: 0 20px 25px -5px var(--tw-shadow-color), 0 8px 10px -6px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.ring-1{--tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);--tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow, 0 0 #0000)}.ring-white\/5{--tw-ring-color: rgb(255 255 255 / .05)}.blur{--tw-blur: blur(8px);filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.drop-shadow-lg{--tw-drop-shadow: drop-shadow(0 10px 8px rgb(0 0 0 / .04)) drop-shadow(0 4px 3px rgb(0 0 0 / .1));filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.backdrop-blur{--tw-backdrop-blur: blur(8px);-webkit-backdrop-filter:var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);backdrop-filter:var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia)}.backdrop-blur-2xl{--tw-backdrop-blur: blur(40px);-webkit-backdrop-filter:var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);backdrop-filter:var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia)}.backdrop-blur-3xl{--tw-backdrop-blur: blur(64px);-webkit-backdrop-filter:var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);backdrop-filter:var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia)}.backdrop-blur-xl{--tw-backdrop-blur: blur(24px);-webkit-backdrop-filter:var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);backdrop-filter:var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia)}.transition-all{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-opacity{transition-property:opacity;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.duration-300{transition-duration:.3s}.duration-500{transition-duration:.5s}.duration-700{transition-duration:.7s}:root{font-family:Inter,system-ui,Avenir,Helvetica,Arial,sans-serif;line-height:1.5;font-weight:400;color-scheme:dark}body{margin:0;min-height:100vh;background-color:#050505;color:#eee;overflow:hidden}.glass-panel{background:#14141e99;-webkit-backdrop-filter:blur(12px);backdrop-filter:blur(12px);border:1px solid rgba(255,255,255,.1);box-shadow:0 8px 32px #0000005e}.prime-text{text-shadow:0 0 10px rgba(255,215,0,.5)}.mersenne-text{text-shadow:0 0 10px rgba(0,163,255,.5)}::-webkit-scrollbar{width:6px}::-webkit-scrollbar-track{background:#050505}::-webkit-scrollbar-thumb{background:#333;border-radius:3px}::-webkit-scrollbar-thumb:hover{background:#555}.placeholder\:text-gray-600::-moz-placeholder{--tw-text-opacity: 1;color:rgb(75 85 99 / var(--tw-text-opacity, 1))}.placeholder\:text-gray-600::placeholder{--tw-text-opacity: 1;color:rgb(75 85 99 / var(--tw-text-opacity, 1))}.hover\:scale-150:hover{--tw-scale-x: 1.5;--tw-scale-y: 1.5;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.hover\:border-white\/20:hover{border-color:#fff3}.hover\:bg-white:hover{--tw-bg-opacity: 1;background-color:rgb(255 255 255 / var(--tw-bg-opacity, 1))}.hover\:bg-white\/5:hover{background-color:#ffffff0d}.hover\:text-black:hover{--tw-text-opacity: 1;color:rgb(0 0 0 / var(--tw-text-opacity, 1))}.focus\:border-prime-gold\/50:focus{border-color:#ffd70080}.focus\:bg-white\/\[0\.05\]:focus{background-color:#ffffff0d}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.active\:scale-95:active{--tw-scale-x: .95;--tw-scale-y: .95;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.group:focus-within .group-focus-within\:opacity-40{opacity:.4}

dist/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>logos-gui</title>
+    <script type="module" crossorigin src="/assets/index-EWlo7g0h.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-W_vgHdSs.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

logos/agent_dispatcher.py

@@ -0,0 +1,614 @@
+"""
+logos/agent_dispatcher.py - The Neural Router
+Protocol 5: Mixture of Agents (MoA) Optimization
+
+This module implements the "Neural Router" for the Local Nano Swarm.
+It decouples "Thinking" (Routing) from "Inference" (Execution).
+
+Workflow:
+1. User Input -> Router Agent (Classifies intent)
+2. Router -> Selects Specialized Agent (Persona)
+3. Specialized Agent -> Execution -> Result
+"""
+
+import json
+import re
+import uuid
+import ast
+import os
+import math
+import asyncio
+import time
+from typing import Dict, Any, Optional, List
+from logos.connectors import get_connector, LocalLLMConnector
+
+# ==========================================
+# AGENT PERSONAS (The Nano Swarm)
+# ==========================================
+
+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.
+"""
+
+PERSONAS = {
+    "general": {
+        "description": "System Orchestrator & Traffic Controller.",
+        "system_prompt": ANTIGRAVITY_DIRECTIVE,
+        "model": "google/gemini-1.5-pro" # Priority reasoning model
+    },
+    "fractal_architect": {
+        "description": "High-level logic architect.",
+        "system_prompt": "You are the Architect. Design recursive structures. 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"
+    }
+}
+
+# ==========================================
+# PROTOCOL 18: THE ASSEMBLY LINE (D-G-R-L)
+# ==========================================
+
+from logos.agents.dolphin import DolphinOversight
+
+class GemmaMetadata:
+    """
+    Role: METADATA (The 'G' Node)
+    Function: Extracts semantic features from Code, Images, or Text.
+    """
+    def __init__(self):
+        self.name = "Gemma-3"
+        print(f"[{self.name}] Semantic Sensor Online. Ready for Feature Extraction.")
+
+    async def process(self, packet):
+        """
+        Deep Dissolution: Pruning complex data into Atomic Integers.
+        """
+        content = packet.get('content', '')
+        intent = packet.get('intent', '')
+        
+        print(f"[{self.name}] Initiating Deep Dissolution (Bottom-Up Pruning)...")
+
+        # Atomic Dissolution: Convert content into a single addressable Integer (Atom)
+        # In this manifold, the integer represents its structural DNA.
+        try:
+            atoms = self.analyze_code_structure(content)
+            # Find the 'Structural Address' based on cumulative complexity
+            atomic_integer = sum(int(t.split(':')[1]) if ':' in t and t.split(':')[1].isdigit() else 1 for t in atoms)
+            packet['atomic_integer'] = atomic_integer
+        except Exception as e:
+            print(f"[{self.name}] Dissolution Error: {e}")
+            packet['atomic_integer'] = 101 # Default prime anchor
+
+        packet['meta_tags'] = atoms
+        mass = len(atoms)
+        return "ATOMIC_DISSOLUTION_COMPLETE", mass
+
+    def analyze_code_structure(self, code_content):
+        tags = []
+        # Calculate Initial Heat (Metaspace Complexity)
+        try:
+            if os.path.exists(code_content):
+                # If content is a path, read it
+                with open(code_content, 'r', encoding='utf-8') as f:
+                    tree = ast.parse(f.read())
+            else:
+                tree = ast.parse(code_content)
+
+            node_count = 0
+            for node in ast.walk(tree):
+                node_count += 1
+                if isinstance(node, ast.ClassDef):
+                    tags.append(f"class:{node.name}")
+                elif isinstance(node, ast.FunctionDef):
+                    tags.append(f"func:{node.name}")
+                elif isinstance(node, ast.Import):
+                    for alias in node.names:
+                        tags.append(f"import:{alias.name}")
+                elif isinstance(node, ast.ImportFrom):
+                    tags.append(f"import_from:{node.module}")
+            
+            tags.append(f"complexity:{node_count}")
+            # Heat is log complexity to avoid explosion
+            heat = math.log10(node_count) if node_count > 0 else 0
+            tags.append(f"heat:{heat:.2f}")
+        except Exception as e:
+            print(f"[{self.name}] AST Parse Error: {e}")
+            tags.append("parse_error")
+        return tags
+
+class RNJ1Routing:
+    """
+    Role: ROUTER (The 'R' Node)
+    Function: Calculates the 'Tensor Slot' based on Origin + Intent.
+              It implements the 'Lisp/Fractran' logic where movement is
+              defined by prime factorization and relative positioning.
+    """
+    def __init__(self, swarm_state, connector):
+        self.name = "RNJ-1"
+        self.swarm_state = swarm_state
+        self.connector = connector
+        print(f"[{self.name}] Tensor Logic Gate Online. Matroska Topology Active.")
+
+    def get_prime_factors(self, n):
+        if n == 0: return [0]
+        i, factors, temp = 2, [], abs(n)
+        while i * i <= temp:
+            if temp % i: i += 1
+            else: temp //= i; factors.append(i)
+        if temp > 1: factors.append(temp)
+        return factors
+
+    def get_gpf(self, n):
+        factors = self.get_prime_factors(n)
+        return max(factors) if factors else 0
+
+    def mhc_stabilize(self, destination, mass):
+        sectors = [1, 3, 7, 9]
+        if (destination % 10) in sectors: return destination
+        for _ in range(3):
+            nudge = 1 if mass % 2 == 0 else -1
+            destination += nudge
+            if (destination % 10) in sectors: return destination
+        for i in range(1, 6):
+            if ((destination + i) % 10) in sectors: return destination + i
+            if ((destination - i) % 10) in sectors: return destination - i
+        return destination
+
+    def get_gap_resonance(self, n):
+        """
+        Prime Gap Analysis: Searches for 'AA B' or harmonic ratios (7177).
+        """
+        # Logic: Check gaps between primes around 'n'
+        # Simulating a gap chain hunt
+        last_digit = n % 10
+        if last_digit in [1, 3, 7, 9]:
+            return "HARMONIC_RESONANCE (7177)"
+        return "STOCHASTIC_NOISE"
+
+    def get_heat_code(self, delta_heat):
+        """
+        Generates the 8-bit Hex Heat Code (Turbulence Metric).
+        """
+        heat_val = int(abs(delta_heat) * 10) % 256
+        return f"0x{heat_val:02X}"
+
+    def calculate_tensor_slot(self, origin, operation, modifier, mass_tags=[]):
+        """
+        The Core OS Logic with SPCW Wave Synthesis and Hex Heat Analysis.
+        """
+        destination = 0
+        if operation == 'mul':
+            destination = origin * modifier
+        elif operation == 'add':
+            destination = origin + modifier
+        elif operation == 'sub':
+            destination = origin - modifier
+        elif operation == 'div':
+            destination = origin // modifier if modifier != 0 else 0
+            
+        # 1. SEMANTIC GRAVITY
+        mass = len(mass_tags)
+        destination += int(math.sin(mass) * 10)
+
+        # 2. MHC STABILIZATION (Mod 10 Tension Web Alignment)
+        old_dest = destination
+        destination = self.mhc_stabilize(destination, mass)
+        
+        # 3. SPCW ATOMIC ANALYSIS & HOPE NESTING
+        origin_factors = self.get_prime_factors(origin)
+        dest_factors = self.get_prime_factors(destination)
+        gpf = self.get_gpf(destination) 
+        
+        # Protocol 22: Google HOPE (Nested Learning for Titans/Miras)
+        # Nested Rank: Depth of the factor manifold
+        hope_rank = len(dest_factors)
+        
+        # 4. HEAT CODE & RESONANCE
+        origin_heat = sum(origin_factors)
+        dest_heat = sum(dest_factors)
+        delta_heat = dest_heat - origin_heat
+        heat_code = self.get_heat_code(delta_heat)
+        resonance = self.get_gap_resonance(destination)
+
+        # 5. 3D Tensor Mobility
+        depth_z = len(dest_factors)
+        
+        # The Matroska Tensor: [Origin, [Op, Modifier], Destination, {Meta}]
+        tensor_trace = [
+            origin_factors, 
+            [operation, self.get_prime_factors(modifier)], 
+            dest_factors, 
+            {
+                "z": depth_z, 
+                "gpf": gpf,
+                "hope_rank": hope_rank,
+                "heat_code": heat_code,
+                "delta_heat": delta_heat,
+                "resonance": resonance,
+                "stabilized": old_dest != destination
+            }
+        ]
+        
+        return {
+            "destination_node": destination,
+            "tensor_trace": tensor_trace,
+            "sector": destination % 10,
+            "z_depth": depth_z,
+            "gpf": gpf,
+            "heat_code": heat_code,
+            "delta_heat": delta_heat,
+            "resonance": resonance
+        }
+
+    def fast_path_extract(self, intent: str) -> Optional[Dict[str, Any]]:
+        """
+        FAST PATH: Regex/Python extraction to bypass expensive LLM calls (~0.01ms).
+        """
+        intent_lower = intent.lower()
+        
+        # 1. THE REGEX GUARD (Protocol 18 Fix) - Identity/Ping Check
+        # Intercepts 'add 0', 'sub 0', 'stay', 'ping' to prevent 4s lag
+        if re.search(r"(?:add|sub|subtract)\s+0|stay|ping|keep-alive", intent_lower):
+            print(f"[{self.name}] [FAST-PATH] Identity Operation Detected (0ms).")
+            return {"op": "add", "mod": 0}
+
+        # 2. Regex for Math Operations (Expanded Pattern A)
+        # Matches: "multiply by 30", "* 30", "times 30", etc.
+        mul_match = re.search(r'(?:mul|multiply|times|\*)\s*(?:by\s+)?(\d+)', intent_lower)
+        add_match = re.search(r'(?:add|plus|\+)\s*(?:by\s+)?(\d+)', intent_lower)
+        sub_match = re.search(r'(?:sub|subtract|minus|-)\s*(?:by\s+)?(\d+)', intent_lower)
+        div_match = re.search(r'(?:div|divide|\/)\s*(?:by\s+)?(\d+)', intent_lower)
+
+        if mul_match: return {"op": "mul", "mod": int(mul_match.group(1))}
+        if add_match: return {"op": "add", "mod": int(add_match.group(1))}
+        if sub_match: return {"op": "sub", "mod": int(sub_match.group(1))}
+        if div_match: return {"op": "div", "mod": int(div_match.group(1))}
+
+        # 2. General Number Extraction Fallback
+        nums = re.findall(r'\d+', intent_lower)
+        if nums:
+            mod = int(nums[0])
+            op = "sub" if any(x in intent_lower for x in ["sub", "-", "less"]) else \
+                 "add" if any(x in intent_lower for x in ["add", "+", "plus"]) else "mul"
+            return {"op": op, "mod": mod}
+
+        return None
+
+    async def calculate_position(self, packet: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Logical Waveform: Calculates the Prime Rail trajectory.
+        """
+        origin = packet.get('origin_node', 1)
+        if origin == 0: origin = 1
+        
+        # --- FAST PATH CHECK ---
+        fast_data = self.fast_path_extract(packet['intent'])
+        if fast_data:
+            op = fast_data['op']
+            modifier = fast_data['mod']
+        else:
+            # Parallel Handoff would call LLM here, we keep it logic-first
+            op, modifier = "mul", 1
+
+        result_data = self.calculate_tensor_slot(origin, op, modifier, mass_tags=packet.get('meta_tags', []))
+        self.swarm_state['last_node'] = result_data['destination_node']
+        
+        return result_data
+
+class VectorizationLayer:
+    """
+    Protocol 21: Bit-Modal Vector Engine.
+    Converts logical nodes into Rotational Coordinates (sin, cos).
+    """
+    def __init__(self):
+        self.frequency_seed = 8 * math.pi / 113 # Grokking Frequency
+
+    def vectorize(self, node_id, mass, sector):
+        """
+        Calculates the Geometric Intersection of the node.
+        """
+        angle = (node_id * self.frequency_seed) + (sector * math.pi / 5)
+        # Rotational Coordinates [X, Y, Z]
+        x = math.sin(angle) * (1 + mass/100)
+        y = math.cos(angle) * (1 + mass/100)
+        z = mass / 10 # Depth reflects complexity
+        
+        return {"x": x, "y": y, "z": z, "angle": angle}
+
+class LogosSwarm:
+    """
+    Protocol 21: The Async Interference Bus.
+    Agents pulse in parallel; the solution is the geometric intersection.
+    """
+    def __init__(self, base_url="http://192.168.0.105:1234/v1"):
+        self.connector = get_connector('local', base_url=base_url)
+        self.state = {
+            "last_node": 1,
+            "tensor_history": [],
+            "active_mode": "HOLOGRAPHIC"
+        }
+        self.vector_layer = VectorizationLayer()
+        self.oversight = DolphinOversight(self.state)
+        self.metadata = GemmaMetadata()
+        self.routing = RNJ1Routing(self.state, self.connector)
+
+    async def process(self, raw_input: str):
+        print("\n🌊 [HOLOGRAPHIC BUS] PULSING WAVE FUNCTIONS...")
+        start_time = time.time()
+        
+        # 1. OVERSIGHT (Dolphin - sanitize)
+        user_packet = {"content": raw_input, "type": "text_command"}
+        action, packet = self.oversight.ingest(user_packet)
+        
+        # 2. PARALLEL INTERFERENCE: Gemma (Semantic), RNJ-1 (Logic), and Gemini (Reasoning)
+        # They "interfere" to find the true crystalline coordinate
+        gemma_task = asyncio.create_task(self.metadata.process(packet))
+        rnj1_task = asyncio.create_task(self.routing.calculate_position(packet))
+        
+        # reasoning_task: Pulse to LLM for high-level topological insights
+        reasoning_task = asyncio.create_task(self.routing.connector.chat_async(
+            f"Analyze this packet for topological resonance: {raw_input}",
+            system_prompt="You are the SWARM_REASONER. Identify the high-level intent and potential manifold collisions."
+        ))
+        
+        # Wait for the High-Frequency Triple Wave to align
+        await asyncio.gather(gemma_task, rnj1_task, reasoning_task)
+        
+        gemma_status, mass = gemma_task.result()
+        res = rnj1_task.result()
+        reasoning = reasoning_task.result()
+        
+        # 3. VECTORIZATION (The Twist)
+        # Transform node identity into Rotational Field Coordinates
+        coords = self.vector_layer.vectorize(res['destination_node'], mass, res['sector'])
+        
+        # 4. GROKKING CHECK
+        # Interference between Logic (RNJ-1) and Prediction (Vector Field)
+        aligned = abs(coords['angle'] % (2*math.pi) - (res['destination_node'] * self.vector_layer.frequency_seed) % (2*math.pi)) < 0.01
+        
+        print(f"✨ [INTERFERENCE] Result: Node {res['destination_node']} | Grokking Alignment: {aligned}")
+        print(f"⏱️ [BUS] Cycle Time: {(time.time() - start_time)*1000:.2f}ms")
+
+        # 5. PULSE TO MANIFOLD
+        full_tensor = res['tensor_trace']
+        full_tensor[3].update(coords) # Inject Rotational Coordinates
+        
+        self.pulse_to_manifold(res['destination_node'], packet['origin_node'], full_tensor)
+        
+        return {
+            "node": res['destination_node'],
+            "coords": coords,
+            "tensor": full_tensor,
+            "alignment": aligned,
+            "status": "HOLOGRAPHIC_ALIGNMENT",
+            "entropy_status": self.oversight.kill_switch.status,
+            "entropy_trace": self.oversight.kill_switch.entropy_trace[-10:]
+        }
+
+    async def execute_flow(self, flow_path: str):
+        """
+        Protocol 22: Autonomous Flow Execution.
+        Loads an agent flow file and orchestrates the swarm agents.
+        """
+        if not os.path.exists(flow_path):
+            return {"error": f"Flow file {flow_path} not found."}
+            
+        with open(flow_path, 'r') as f:
+            flow = json.load(f)
+            
+        print(f"\n🚀 [FLOW] Initiating: {flow['name']}")
+        context = {}
+        
+        # Group steps by dependency for parallel execution
+        # For now, we allow a 'parallel' hint in the step definition
+        async def execute_step(step):
+            print(f"   ➜ Step: {step['id']} ({step['agent']})")
+            # 1. Prepare Input
+            input_val = context.get(step.get('input_key'), step.get('target', ""))
+            # 2. Execute Agent Logic
+            if step['agent'] == "GEMMA":
+                res = await self.metadata.process({"content": input_val})
+                context[step['output_key']] = res[1] 
+            elif step['agent'] == "RNJ-1":
+                res = await self.routing.calculate_position({"intent": f"add {input_val}", "origin_node": self.state['last_node']})
+                context[step['output_key']] = res
+            elif step['agent'] == "DOLPHIN":
+                res = self.oversight.mhs_smoothing(input_val, context.get('semantic_mass', 1))
+                context[step['output_key']] = res
+            elif step['agent'] == "ORCHESTRATOR":
+                self.pulse_to_manifold(input_val['node_id'], self.state['last_node'], {"mhs": input_val})
+
+        # Sequential execution for now, but scanning for parallel groups
+        for step in flow['steps']:
+            if step.get('parallel'):
+                # Future: Group consecutive parallel steps
+                await execute_step(step)
+            else:
+                await execute_step(step)
+                
+        return {"status": "FLOW_COMPLETE", "result": context.get('aligned_manifold')}
+
+    def pulse_to_manifold(self, val, source, tensor):
+        import requests
+        try:
+            requests.post("http://127.0.0.1:5000/ingest", json={
+                "value": val, 
+                "source": source,
+                "tensor": tensor
+            })
+        except: pass
+
+ROUTER_PROMPT = """
+Analyze the following user input and classify it into one of these categories:
+- 'fractal_architect': For code, debugging, storage, sharding, or technical implementation.
+- 'prime_navigator': For math, primes, geometry, calculations, or physics.
+- 'creative': For descriptions, stories, or documentation style.
+- 'general': For greetings or anything else.
+
+Reply with ONLY a JSON object in this format:
+{"intent": "category_name", "confidence": 0.9}
+Do not write any introductory text.
+"""
+
+
+class NeuralRouter:
+    """
+    Implements the Routing Logic to dispatch tasks to the Nano Swarm.
+    """
+    
+    def __init__(self, base_url: str = "http://192.168.0.105:1234/v1", router_model: str = "google/gemma-3-4b"):
+        # The router itself uses a fast model (Gemma 4B)
+        self.connector = get_connector('local', base_url=base_url, model=router_model)
+        self.history = []
+
+    def classify_intent(self, user_input: str) -> str:
+        """
+        Uses the LLM to 'think' about the best route.
+        """
+        prompt = f"{ROUTER_PROMPT}\n\nUser Input: \"{user_input}\""
+        
+        # We use a lower temperature for routing to be deterministic
+        response = self.connector.chat(prompt, system_prompt="You are a classifier system. Output JSON only.")
+        
+        # Attempt to parse JSON
+        try:
+            # Clean up markdown if model adds it
+            clean_response = response.replace("```json", "").replace("```", "").strip()
+            # Find the first { and last }
+            start = clean_response.find("{")
+            end = clean_response.rfind("}")
+            if start != -1 and end != -1:
+                json_str = clean_response[start:end+1]
+                data = json.loads(json_str)
+                return data.get("intent", "general")
+            return "general"
+        except json.JSONDecodeError:
+            print(f"[Router Warning] Could not parse intent. Raw: {response}")
+            return "general" # Fallback
+
+    def run(self, user_input: str) -> str:
+        """Matched Vector Execution."""
+        # Protocol 17: Assembly Line (SWARM) Mode
+        if user_input.startswith("SWARM:"):
+            payload = user_input.replace("SWARM:", "").strip()
+            print(f"🔥 Initiating LOGOS Assembly Line: '{payload}'")
+            swarm = LogosSwarm(base_url=self.connector.base_url)
+            result = asyncio.run(swarm.process(payload))
+            return f"ASSEMBLY_COMPLETE: Node {result['node']} anchored via {result['status']}."
+
+        # Protocol 16: Signal Injection Trigger
+        if user_input.startswith("INJECT:"):
+            payload = user_input.replace("INJECT:", "").strip()
+            print(f"🌊 Injecting Signal Path: {payload}")
+            from logos.agents.sensor_agent import SensorAgent
+            injector = SensorAgent()
+            # Run in a separate thread to not block the console
+            import threading
+            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()
+        persona = PERSONAS.get(intent, PERSONAS["general"])
+        
+        # Tool Injection (mHC/RLM alignment)
+        tools = {
+            "fractal_architect": "[SHARD_FS: QuadTree 4KB->64B]",
+            "prime_navigator": "[RESONANCE_SCAN: Modulo 9973]"
+        }.get(intent, "")
+        
+        response = self.connector.chat(f"{tools} {user_input}", 
+                                      system_prompt=persona['system_prompt'], 
+                                      model=persona['model'])
+        
+        # Protocol 22: Autonomous Flow Intercept
+        if "synthesis" in user_input.lower() or "optimize" in user_input.lower() or "full scan" in user_input.lower():
+            print(f"[{self.name}] Detected Synthesis Directive. Invoking Autonomous Agent Flow...")
+            swarm = LogosSwarm(base_url=self.connector.base_url)
+            flow_path = os.path.join(os.getcwd(), ".agent", "flows", "synthesis_flow.json")
+            return asyncio.run(swarm.execute_flow(flow_path))
+
+        # --- THE ANTIGRAVITY HOOK ---
+        # Intercept Gemini's delegation JSON and execute locally
+        try:
+            command = json.loads(response.strip().replace("```json", "").replace("```", ""))
+            if command.get("tool"):
+                print(f"[ORCHESTRATOR] Delegating to Local Specialist: {command['tool']}")
+                swarm = LogosSwarm(base_url=self.connector.base_url)
+                
+                if command["tool"] == "RNJ-1":
+                    # Execute Math/Routing locally
+                    return asyncio.run(swarm.process(f"SWARM: {command['intent']}"))
+                elif command["tool"] == "GEMMA":
+                    # Execute File Scanning locally
+                    return asyncio.run(swarm.process(f"SWARM: read {command['path']}"))
+                elif command["tool"] == "DOLPHIN":
+                    # Execute Oversight/Status locally
+                    return f"SYSTEM_STATUS: {swarm.state}"
+        except (json.JSONDecodeError, KeyError):
+            # Not a tool call, return as text
+            pass
+
+        print(f"[{intent.upper()}] {response}")
+        return response
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="LOGOS Neural Router (Nano Swarm Dispatcher)")
+    parser.add_argument("prompt", nargs="?", help="Input prompt (optional)")
+    parser.add_argument("--loop", action="store_true", help="Run in interactive loop")
+    
+    args = parser.parse_args()
+    
+    # Default to Gemma for routing (fast)
+    router = NeuralRouter(router_model="google/gemma-3-4b")
+    
+    if args.loop:
+        print("--- LOGOS Neural Router Online ---")
+        print("Type 'exit' to quit.")
+        while True:
+            try:
+                user_input = input("\n> ")
+                if user_input.lower() in ['exit', 'quit']:
+                    break
+                router.run(user_input)
+            except KeyboardInterrupt:
+                break
+    elif args.prompt:
+        router.run(args.prompt)
+    else:
+        # Default demo
+        router.run("Write a Python function to calculate the Fibonacci sequence.")
+
+
+if __name__ == "__main__":
+    main()

logos/agents/connector.py

@@ -0,0 +1,126 @@
+
+import os
+import logging
+from logos.manifold_state import ManifoldState
+
+logger = logging.getLogger("ConnectorAgent")
+
+class ConnectorAgent:
+    """
+    Protocol 6: Connector Agent
+    Weaves the "Prime Network" by connecting tokens based on Domain Potentiality.
+    Uses "Canonical Separation" to link Inner/Prime/Outer domains appropriately.
+    """
+    def __init__(self):
+        self.manifold = ManifoldState()
+
+    def connect_swarm(self):
+        """Builds edges in the Manifold Graph."""
+        graph = self.manifold.state.get("graph", {})
+        if not graph:
+            logger.warning("No graph to connect. Run Tokenizer first.")
+            return 0
+
+        nodes = graph.get("nodes", [])
+        if not nodes:
+            logger.warning("No nodes in graph.")
+            return 0
+
+        # Assign 3D Geometry (Manifold Folding)
+        for node in nodes:
+            if "position" not in node.get("geometry", {}):
+                node["geometry"]["position"] = self._calculate_3d_position(node)
+
+        edges = []
+        logger.info(f"Connecting {len(nodes)} nodes in Potentiality Space...")
+        
+        # O(N^2) connection scan (acceptable for local repo size)
+        for i in range(len(nodes)):
+            n1 = nodes[i]
+            for j in range(i + 1, len(nodes)):
+                n2 = nodes[j]
+                weight = self._calculate_affinity(n1, n2)
+                if weight > 0:
+                    edges.append({
+                        "source": n1["id"],
+                        "target": n2["id"],
+                        "weight": weight,
+                        "type": "resonance"
+                    })
+        
+        graph["edges"] = edges
+        self.manifold.save()
+        logger.info(f"Weaved {len(edges)} connections & folded geometry.")
+        return len(edges)
+
+    def _calculate_3d_position(self, node):
+        """
+        Determines (x, y, z) based on Prime Topology.
+        Z-axis = Domain Depth (Outer=10, Prime=5, Inner=0).
+        X/Y-axis = Hash Resonance (Pseudo-random scatter).
+        """
+        import math
+        
+        domain = node["geometry"]["domain"]
+        h = node["geometry"]["hash"]
+        
+        # Z-Axis: Hierarchy
+        z = 0
+        if domain == "OUTER_SHELL": z = 10.0
+        elif domain == "PRIME_CHANNEL": z = 5.0
+        elif domain == "INNER_SHELL": z = 0.0
+        
+        # X/Y-Axis: Spiral Distribution based on Hash
+        # Use simple polar -> cartesian mapping
+        angle = (h % 360) * (math.pi / 180)
+        radius = (h % 100) / 10.0
+        
+        x = radius * math.cos(angle)
+        y = radius * math.sin(angle)
+        
+        return {"x": round(x, 2), "y": round(y, 2), "z": round(z, 2)}
+
+    def _calculate_affinity(self, n1, n2):
+        """
+        Determines connection strength (W_Lo/W_Hi canonical logic).
+        """
+        weight = 0.0
+        
+        # 1. Physical Affinity (Same Directory)
+        # Represents "Local Connectivity" (W_Lo)
+        dir1 = os.path.dirname(n1["path"])
+        dir2 = os.path.dirname(n2["path"])
+        if dir1 == dir2:
+            weight += 0.5
+            
+        # 2. Domain Hierarchy (Nested Domains)
+        # Represents "Hyper Connectivity" (W_Hi) via Prime Resonance
+        d1 = n1["geometry"]["domain"]
+        d2 = n2["geometry"]["domain"]
+        domains = {d1, d2}
+        
+        # Inner <-> Prime: Structure is controlled by Logic (Strong Link)
+        if "INNER_SHELL" in domains and "PRIME_CHANNEL" in domains:
+            weight += 0.4
+            
+        # Prime <-> Outer: Logic organizes Entropy (Medium Link)
+        if "PRIME_CHANNEL" in domains and "OUTER_SHELL" in domains:
+            weight += 0.3
+            
+        # Inner <-> Outer: Direct entropy injection (Weak/Chaos Link)
+        if "INNER_SHELL" in domains and "OUTER_SHELL" in domains:
+            weight += 0.1
+
+        # Same Domain Resonance (e.g. Logic <-> Logic)
+        if d1 == d2:
+            weight += 0.2
+
+        if weight >= 1.0: weight = 0.99
+            
+        return round(weight, 2)
+
+if __name__ == "__main__":
+    # Test Run
+    agent = ConnectorAgent()
+    count = agent.connect_swarm()
+    print(f"Connector finished. Edges: {count}")

logos/agents/dolphin.py

@@ -0,0 +1,175 @@
+
+import numpy as np
+import math
+import uuid
+import re
+
+class EntropyKillSwitch:
+    """
+    Role: SYSTEM GUARD (The 'Prefix Integrator')
+    Function: Monitors the 'Temperature' of the reasoning chain.
+              If Entropy > Threshold, it KILLS the generation to prevent hallucination.
+    """
+    def __init__(self, threshold=0.75, window_size=5):
+        self.threshold = threshold
+        self.window_size = window_size
+        self.entropy_trace = []
+        self.status = "STABLE"
+
+    def calculate_entropy(self, logprobs):
+        """
+        Converts log probabilities into Shannon Entropy.
+        High Entropy = High Uncertainty = Likely Hallucination.
+        """
+        if not logprobs:
+            return 0.0
+        
+        # Convert logprobs (dict) to probability distribution
+        # Some APIs return logprobs as a list of dicts, others as a flat dict
+        if isinstance(logprobs, list):
+            probs = [math.exp(item.get('logprob', -100)) for item in logprobs]
+        else:
+            probs = [math.exp(lp) for lp in logprobs.values()]
+        
+        # Normalize (just in case)
+        total_p = sum(probs)
+        if total_p == 0: return 1.0
+        probs = [p/total_p for p in probs]
+        
+        # Shannon Entropy Formula: H = -sum(p * log(p))
+        entropy = -sum(p * math.log(p) for p in probs if p > 0)
+        return entropy
+
+    def monitor(self, token, logprobs):
+        """
+        Ingests a single token's data. Returns TRUE if we need to KILL.
+        """
+        current_entropy = self.calculate_entropy(logprobs)
+        self.entropy_trace.append(current_entropy)
+        
+        # Keep window small (Prefix Integration)
+        if len(self.entropy_trace) > self.window_size:
+            self.entropy_trace.pop(0)
+            
+        # Calculate Rolling Average
+        avg_entropy = np.mean(self.entropy_trace)
+        
+        # THE KILL SWITCH
+        if avg_entropy > self.threshold:
+            self.status = "HALLUCINATION_DETECTED"
+            return True # TRIGGER KILL
+            
+        self.status = "STABLE"
+        return False # CONTINUE
+
+class DolphinOversight:
+    def __init__(self, swarm_state=None):
+        self.name = "Dolphin-x1-8b"
+        self.kill_switch = EntropyKillSwitch(threshold=0.8) # Tunable sensitivity
+        self.state = swarm_state or {}
+
+    def strip_context(self, raw_input):
+        """
+        Sanitizes input to remove conversational fluff, isolating the core directive.
+        """
+        # 1. Remove common conversational prefixes
+        clean_text = re.sub(r'^(please|can you|would you|swarm|logos|logo)\s+', '', raw_input, flags=re.IGNORECASE)
+        return clean_text.strip()
+
+    def ingest(self, user_packet):
+        """
+        The main entry point for Protocol 18.
+        """
+        packet_id = str(uuid.uuid4())[:8]
+        core_intent = self.strip_context(user_packet['content'])
+        previous_node_id = self.state.get('last_node', 1)
+        
+        print(f"[{self.name}] Packet {packet_id} Ingested.")
+        
+        logos_packet = {
+            "id": packet_id,
+            "type": user_packet.get('type', 'text_command'),
+            "origin_node": previous_node_id, 
+            "intent": core_intent,           
+            "content": user_packet['content'],
+            "meta_tags": [],                 
+            "target_coords": None            
+        }
+
+        return self.route_packet(logos_packet)
+
+    def route_packet(self, packet):
+        # Dolphin Deciphers Intent
+        print(f"[{self.name}] Decoding Intent: '{packet['intent']}'")
+        
+        if "image" in packet['type'] or "scan" in packet['intent'].lower() or ".py" in packet['intent']:
+            return "HANDOFF_TO_GEMMA", packet
+        else:
+            return "HANDOFF_TO_RNJ1", packet
+
+    def mhs_smoothing(self, tensor_coords, mass):
+        """
+        Protocol 22: Manifold Harmonic Smoothing (mhs).
+        """
+        node_id = tensor_coords.get('destination_node', 1)
+        resonance = tensor_coords.get('resonance', 'STOCHASTIC_NOISE')
+        delta_heat = tensor_coords.get('delta_heat', 0)
+        
+        # If noise is detected, nudge towards nearest prime anchor
+        if resonance == "STOCHASTIC_NOISE":
+            anchors = [1, 3, 7, 9]
+            if (node_id % 10) not in anchors:
+                for i in range(1, 6):
+                    if ((node_id + i) % 10) in anchors:
+                        node_id += i
+                        break
+                    elif ((node_id - i) % 10) in anchors:
+                        node_id -= i
+                        break
+        
+        # Apply 'Mass Dampening' if complexity is too high
+        dampened_heat = delta_heat / (1 + mass/100)
+        
+        return {
+            "node_id": node_id,
+            "fidelity": 1.0 - (abs(dampened_heat) * 0.01),
+            "status": "MHS_STABILIZED" if not self.entropy_kill_switch(dampened_heat) else "KILL_SWITCH_ACTIVE_TURBULENCE"
+        }
+
+    def entropy_kill_switch(self, delta_heat):
+        """
+        Legacy heat-based kill switch for MHS logic.
+        """
+        threshold = 500 
+        if abs(delta_heat) > threshold:
+            print(f"[{self.name}] ⚠️ !ENTROPY_CRITICAL! Delta Heat: {delta_heat}")
+            return True 
+        return False
+
+    async def verify_output_stream(self, generator_stream):
+        """
+        Wraps the LLM output stream.
+        Filtering text through the Prefix Integrator Entropy Kill Switch.
+        """
+        verified_text = ""
+        
+        async for token_data in generator_stream:
+            token = token_data.get('text', '')
+            logprobs = token_data.get('logprobs', None) 
+            
+            # CHECK ENTROPY
+            should_kill = self.kill_switch.monitor(token, logprobs)
+            
+            if should_kill:
+                print(f"[{self.name}] 🚫 KILL SWITCH TRIGGERED! Entropy: {self.kill_switch.entropy_trace[-1]:.2f}")
+                yield "[SYSTEM INTERRUPT: HALLUCINATION DETECTED. RE-ROUTING...]"
+                self.trigger_correction()
+                break 
+            
+            verified_text += token
+            yield token
+
+    def trigger_correction(self):
+        # Update Swarm State to 'CAUTION' mode
+        self.state['active_mode'] = "HIGH_PRECISION"
+        print(f"[{self.name}] Swarm Mode shifted to HIGH_PRECISION due to entropy spike.")

logos/agents/life.py

@@ -0,0 +1,110 @@
+
+import logging
+from logos.manifold_state import ManifoldState
+
+logger = logging.getLogger("LifeAgent")
+
+class LifeAgent:
+    """
+    Protocol 9: Life Agent (Cellular Dynamics)
+    Applies 'Game of Life' rules to the Manifold Graph.
+    Nodes are 'Cells'. Edges define 'Neighborhood'.
+    """
+    def __init__(self):
+        self.manifold = ManifoldState()
+        
+    def evolve(self):
+        """Runs one generation of evolution."""
+        graph = self.manifold.state.get("graph", {})
+        nodes = graph.get("nodes", [])
+        if not nodes: return
+
+        # Initialize 'alive' state if not present (Default to Alive)
+        for n in nodes:
+            if "alive" not in n:
+                n["alive"] = 1 # 1 = Alive, 0 = Dead
+
+        # Calculate Next State
+        updates = {}
+        for node in nodes:
+            node_id = node["id"]
+            alive_neighbors = self._count_alive_neighbors(node_id, graph["edges"], nodes)
+            
+            is_alive = node["alive"]
+            new_state = is_alive
+
+            # -- Conway's Rules (Adapted for Code Graph) --
+            # 1. Loneliness (Underpopulation): < 1 neighbor -> Die (Dead Code)
+            if is_alive and alive_neighbors < 1:
+                new_state = 0
+            
+            # 2. Survival: 2 or 3 neighbors -> Stay Alive
+            elif is_alive and (alive_neighbors == 2 or alive_neighbors == 3):
+                new_state = 1
+                
+            # 3. Overcrowding: > 4 neighbors -> Check for Mitosis (Refactor) vs Death
+            elif is_alive and alive_neighbors > 4:
+                # Protocol 11: Active Inference - Mitosis
+                if self._check_mitosis_potential(node):
+                    node["action_pending"] = "MITOSIS"
+                    new_state = 1 # Stay alive to split
+                else:
+                    new_state = 0 # Complexity Collapse
+                
+            # 4. Reproduction: Exactly 3 neighbors -> Be born (if dead)
+            elif not is_alive and alive_neighbors == 3:
+                new_state = 1
+                node["action_pending"] = "SPAWN_META_TOKEN" # New abstract node
+            
+            # Protocol 11: Active Inference - Regeneration
+            # If dead but high Prime Resonance (Critical Logic), attempt Regeneration
+            if new_state == 0 and node["geometry"]["domain"] in ["PRIME_CHANNEL", "INNER_SHELL"]:
+                if self._check_regeneration_potential(node):
+                    new_state = 1
+                    node["action_pending"] = "REGENERATE"
+
+            # Static Override: Prime Channel nodes are "Immortal" (Logic Core)
+            if node["geometry"]["domain"] == "PRIME_CHANNEL":
+                new_state = 1
+            
+            updates[node_id] = new_state
+
+        # Apply Updates
+        changes = 0
+        for node in nodes:
+            if node["alive"] != updates[node["id"]]:
+                node["alive"] = updates[node["id"]]
+                changes += 1
+        
+        self.manifold.save()
+        logger.info(f"Evolution complete. {changes} cells changed state.")
+        return changes
+
+    def _check_mitosis_potential(self, node):
+        """Active Inference: Should this overcrowded node split?"""
+        # Heuristic: If GPF is small (Structure) and Hash is high (Complex content)
+        # In a real Neural CA, this would be a learned policy query.
+        gpf = node["geometry"]["gpf"]
+        return gpf < 100 # Structural nodes handle complexity by splitting
+
+    def _check_regeneration_potential(self, node):
+        """Active Inference: Should this dead node be healed?"""
+        # Heuristic: If it's a critical Logic node (Prime Channel)
+        domain = node["geometry"]["domain"]
+        return domain == "PRIME_CHANNEL"
+
+    def _count_alive_neighbors(self, node_id, edges, nodes):
+        node_map = {n["id"]: n for n in nodes}
+        count = 0
+        for e in edges:
+            if e["source"] == node_id:
+                neighbor = node_map.get(e["target"])
+                if neighbor and neighbor.get("alive", 1): count += 1
+            elif e["target"] == node_id:
+                neighbor = node_map.get(e["source"])
+                if neighbor and neighbor.get("alive", 1): count += 1
+        return count
+
+if __name__ == "__main__":
+    agent = LifeAgent()
+    agent.evolve()

logos/agents/orchestrator.py

@@ -0,0 +1,45 @@
+
+import logging
+from logos.agent_dispatcher import NeuralRouter
+
+# Setup Logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+logger = logging.getLogger("SwarmMissionControl")
+
+def main():
+    print("========================================")
+    print("   LOGOS LOCAL SWARM MISSION CONTROL    ")
+    print("========================================")
+    print("Available Agents:")
+    print(" - FRACTAL ARCHITECT (Storage/Code)")
+    print(" - PRIME NAVIGATOR   (Math/Physics)")
+    print(" - CREATIVE DIRECTOR (Aesthetics/Vision)")
+    print("----------------------------------------")
+    
+    # Initialize the Router
+    # Assuming port 1234 is LM Studio
+    router = NeuralRouter(base_url="http://localhost:1234/v1")
+    
+    print("\n[SYSTEM] Swarm standing by. Enter a mission prompt.")
+    print("Example: 'Analyze the project topology and shard its memory.'")
+    
+    while True:
+        try:
+            mission = input("\n[ARCHITECT] > ")
+            if mission.lower() in ['exit', 'quit']:
+                break
+            
+            # Run the mission through the Neural Router
+            router.run(mission)
+            
+        except KeyboardInterrupt:
+            break
+        except Exception as e:
+            logger.error(f"Mission Failed: {e}")
+
+if __name__ == "__main__":
+    main()

logos/agents/scout.py

@@ -0,0 +1,78 @@
+
+import logging
+import time
+from logos.manifold_state import ManifoldState
+
+logger = logging.getLogger("ScoutAgent")
+
+class ScoutAgent:
+    """
+    Protocol 7: Recursive Scout Agent
+    Implements the 'Recursive Language Model' (arXiv:2512.24601) paradigm.
+    Treats the Manifold Graph as an external environment to be traversed recursively.
+    """
+    def __init__(self, start_node=None):
+        self.manifold = ManifoldState()
+        self.graph = self.manifold.state.get("graph", {})
+        self.nodes = {n["id"]: n for n in self.graph.get("nodes", [])}
+        self.edges = self.graph.get("edges", [])
+        self.start_node = start_node
+        self.mission_log = []
+
+    def recursive_traverse(self, node_id=None, depth=0, max_depth=5):
+        """
+        The Core Recursive Operator.
+        Drills down from Outer Shell (High Entropy) to Inner Shell (Structure).
+        """
+        if depth > max_depth:
+            return
+
+        if node_id is None:
+            # Start at a random Outer Shell node if not specified
+            candidates = [n for n in self.nodes.values() if n["geometry"]["domain"] == "OUTER_SHELL"]
+            if not candidates:
+                logger.warning("No Outer Shell nodes found to start traversal.")
+                return
+            node_id = candidates[0]["id"]
+
+        current_node = self.nodes.get(node_id)
+        if not current_node: return
+
+        # 1. Observe (Read the Node)
+        indent = "  " * depth
+        domain = current_node["geometry"]["domain"]
+        log_entry = f"{indent}Visiting [{domain}] {current_node['name']} (ID: {node_id})"
+        logger.info(log_entry)
+        self.mission_log.append(log_entry)
+        
+        # 2. Act (Find Connections)
+        # We value connections that lead "Deeper" into Logic (Prime) or Structure (Inner)
+        connections = [
+            e for e in self.edges 
+            if e["source"] == node_id or e["target"] == node_id
+        ]
+        
+        # Sort connections by weight (Resonance)
+        connections.sort(key=lambda x: x["weight"], reverse=True)
+
+        # 3. Recurse (Traverse Neighbors)
+        # Limit recursion to top 2 strongest links to prevent explosion
+        for link in connections[:2]:
+            neighbor_id = link["target"] if link["source"] == node_id else link["source"]
+            neighbor = self.nodes.get(neighbor_id)
+            if not neighbor: continue
+            
+            # recursive call
+            self.recursive_traverse(neighbor_id, depth + 1, max_depth)
+
+    def report(self):
+        """Returns the Mission Log."""
+        return "\n".join(self.mission_log)
+
+if __name__ == "__main__":
+    # Test Run
+    scout = ScoutAgent()
+    print("Scout initializing sequence...")
+    scout.recursive_traverse()
+    print("\n--- MISSION LOG ---")
+    print(scout.report())

logos/agents/sensor_agent.py

@@ -0,0 +1,60 @@
+
+import time
+import requests
+import json
+import os
+from logos.network.dissolution import DissolutionEngine
+
+class SensorAgent:
+    """
+    Protocol 16: Signal Injector.
+    Monitors data streams and dissolves them into tokens for the Manifold.
+    """
+    def __init__(self, target_url="http://localhost:5000/ingest"):
+        self.target_url = target_url
+
+    def inject_text(self, text, throttle=0.05):
+        """
+        Dissolves a string and injects its byte-tokens into the manifold.
+        """
+        print(f"🌊 Dissolving Pulse Stream: {len(text)} chars...")
+        
+        # We use dissolve_bytes to get 0-255 range tokens
+        # Or we can use the character ordinals for more diversity
+        for char in text:
+            token = ord(char)
+            # Filter for the manifold's potentiality (1,3,7,9 or 2,5)
+            # Actually, the manifold visualizer handles the filtering
+            payload = {
+                "value": token,
+                "type": "DATA_PACKET",
+                "timestamp": time.time()
+            }
+            try:
+                requests.post(self.target_url, json=payload, timeout=0.1)
+            except:
+                pass # Silently drop if server is busy
+            time.sleep(throttle)
+
+    def watch_file(self, filepath, interval=1.0):
+        """
+        Watches a file for changes and injects new content.
+        """
+        print(f"👁️ Monitoring: {filepath}")
+        last_mtime = 0
+        while True:
+            try:
+                mtime = os.path.getmtime(filepath)
+                if mtime > last_mtime:
+                    with open(filepath, 'r') as f:
+                        content = f.read()
+                        self.inject_text(content)
+                    last_mtime = mtime
+            except Exception as e:
+                print(f"Error: {e}")
+            time.sleep(interval)
+
+if __name__ == "__main__":
+    injector = SensorAgent()
+    # Test injection
+    injector.inject_text("LOGOS MISSION CONTROL ACTIVATED - SIGNAL STABLE")

logos/agents/tokenizer.py

@@ -0,0 +1,99 @@
+
+import os
+import ast
+import zlib
+import json
+import logging
+from logos.logos_core import get_gpf
+from logos.manifold_state import ManifoldState
+
+logger = logging.getLogger("TokenizerAgent")
+
+class TokenizerAgent:
+    """
+    Protocol 6: Tokenizer Agent
+    Parses a repository (Source) into Prime Tokens (Domain Potentiality Space).
+    """
+    def __init__(self, root_dir):
+        self.root_dir = root_dir
+        self.manifold = ManifoldState() # Connects to logos/manifold.json
+
+    def scan_and_tokenize(self):
+        """Scans root_dir and tokenizes all supported files."""
+        tokens = []
+        for root, dirs, files in os.walk(self.root_dir):
+            # Skip hidden/system dirs
+            dirs[:] = [d for d in dirs if not d.startswith('.') and not d.startswith('__')]
+            
+            for file in files:
+                if file.endswith(".py") or file.endswith(".md"):
+                    path = os.path.join(root, file)
+                    token = self._tokenize_file(path)
+                    if token:
+                        tokens.append(token)
+        
+        self._register_tokens_to_manifold(tokens)
+        return tokens
+
+    def _tokenize_file(self, filepath):
+        """Parses a single file into a Prime Token."""
+        try:
+            with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read()
+
+            rel_path = os.path.relpath(filepath, self.root_dir)
+            
+            # --- Prime Topology Analysis ---
+            # 1. Hash Content -> Integer Field
+            h = zlib.adler32(content.encode('utf-8'))
+            
+            # 2. Calculate Resonance (GPF)
+            gpf = get_gpf(h)
+            
+            # 3. Determine Domain
+            if gpf < 200:
+                domain = "INNER_SHELL"
+            elif gpf < 2000:
+                domain = "PRIME_CHANNEL"
+            else:
+                domain = "OUTER_SHELL"
+
+            token = {
+                "id": h,
+                "name": os.path.basename(filepath),
+                "path": rel_path,
+                "type": "file",
+                "geometry": {
+                    "hash": h,
+                    "gpf": gpf,
+                    "domain": domain
+                },
+                "content_preview": content[:100]
+            }
+            return token
+
+        except Exception as e:
+            logger.error(f"Failed to tokenize {filepath}: {e}")
+            return None
+
+    def _register_tokens_to_manifold(self, tokens):
+        """Updates the physical Manifold State with new tokens."""
+        # Ensure manifold state has a graph structure
+        if "graph" not in self.manifold.state:
+            self.manifold.state["graph"] = {"nodes": [], "edges": []}
+            
+        # Add new nodes (deduplicated by ID)
+        existing_ids = {n["id"] for n in self.manifold.state["graph"]["nodes"]}
+        for t in tokens:
+            if t["id"] not in existing_ids:
+                self.manifold.state["graph"]["nodes"].append(t)
+                
+        self.manifold.save()
+        logger.info(f"Registered {len(tokens)} tokens to Manifold.")
+
+if __name__ == "__main__":
+    # Test Run
+    agent = TokenizerAgent(".")
+    print("Tokenizing current directory...")
+    agent.scan_and_tokenize()
+    print("Done.")

logos/agents/video_atomizer.py

@@ -0,0 +1,73 @@
+import re
+import asyncio
+from youtube_transcript_api import YouTubeTranscriptApi
+
+class VideoAtomizer:
+    """
+    Role: V-NODE (Video Ingest)
+    Function: Rips semantic atoms from video streams and collides them
+              with the existing Project Manifold.
+    """
+    def __init__(self):
+        self.name = "VideoAtomizer"
+
+    def extract_video_id(self, url):
+        # Extracts 'R9czY1uVq_k' from the URL
+        match = re.search(r"v=([a-zA-Z0-9_-]+)", url)
+        # Handle short URLs too
+        if not match:
+            match = re.search(r"youtu\.be/([a-zA-Z0-9_-]+)", url)
+        return match.group(1) if match else None
+
+    async def ingest_and_align(self, url, project_dna):
+        """
+        The Main Pipeline: URL -> Transcript -> Atoms -> Manifold Alignment
+        """
+        video_id = self.extract_video_id(url)
+        if not video_id:
+            return {"error": "Invalid Video URL"}
+            
+        print(f"[{self.name}] Locking onto Signal: {video_id}")
+        
+        # 1. FETCH TRANSCRIPT (The Raw Atoms)
+        try:
+            # We use a thread pool for the blocking API call
+            loop = asyncio.get_event_loop()
+            transcript_list = await loop.run_in_executor(None, YouTubeTranscriptApi.get_transcript, video_id)
+            full_text = " ".join([t['text'] for t in transcript_list])
+        except Exception as e:
+            return {"error": f"Signal Lost: {e}"}
+
+        # 2. ATOMIZE (Extract Key Concepts via Regex/Heuristics for Speed)
+        # We look for 'High-Entropy' terms that match your Engineering Protocol
+        atoms = []
+        keywords = ["entropy", "gradient", "hallucination", "probe", "layer", "state", "kill switch", "backtracking", "prefix integrator", "nesting", "hope"]
+        
+        for word in keywords:
+            if word in full_text.lower():
+                # Create a 'Particle' with weight based on frequency
+                count = full_text.lower().count(word)
+                atoms.append({"concept": word, "mass": count})
+
+        # 3. INTERFERENCE (The Alignment Step)
+        # We check which files in your Project DNA resonate with these video atoms
+        aligned_nodes = []
+        for atom in atoms:
+            for file, dna_list in project_dna.items():
+                # dna_list is usually a list of tags/strings
+                for dna_term in dna_list:
+                    if atom['concept'] in dna_term.lower(): 
+                        aligned_nodes.append({
+                            "source_concept": atom['concept'],
+                            "target_file": file,
+                            "resonance_strength": atom['mass']
+                        })
+                        break # One match per file/atom pair
+
+        return {
+            "status": "GROKKED",
+            "video_id": video_id,
+            "atoms_found": len(atoms),
+            "alignments": aligned_nodes, # These will become Gold Threads in UI
+            "summary_vector": "Detected 'Entropy Gating' - Recommend applying to Dolphin Node."
+        }

logos/connectors.py

@@ -49,7 +49,7 @@ class HuggingFaceConnector:
         if self._client is None:
             try:
                 from huggingface_hub import InferenceClient
-                self._client = InferenceClient(token=self.config.hf_token)
+                self._client = InferenceClient(token=self.config.hf_token, base_url="https://router.huggingface.co")
             except ImportError:
                 raise ImportError("huggingface_hub not installed. Run: pip install huggingface_hub")
         return self._client
@@ -93,49 +93,38 @@ class HuggingFaceConnector:
 
 class OCRConnector:
     """
-    Adapter for EasyOCR.
-    Provides text extraction from images.
+    Adapter for Optical Character Recognition via Local Vision Model.
+    Uses 'google/gemma-3-4b' (or configured local model) to transcribe text from images.
     """
     
     def __init__(self, languages: List[str] = None, gpu: bool = False):
-        self.languages = languages or ['en']
-        self.gpu = gpu
-        self._reader = None
-    
-    def _ensure_reader(self):
-        """Lazy initialization of EasyOCR reader."""
-        if self._reader is None:
-            try:
-                import easyocr
-                self._reader = easyocr.Reader(self.languages, gpu=self.gpu)
-            except ImportError:
-                raise ImportError("easyocr not installed. Run: pip install easyocr")
-        return self._reader
+        # We rely on the local LLM connector, 'gpu' arg is ignored as it's handled by LM Studio
+        from .connectors import get_connector
+        # Hardcoded to Gemma as requested by user ("gemma is your vision model")
+        self.client = get_connector('local', model="google/gemma-3-4b")
     
     def extract_text(self, image_path: str) -> Dict[str, Any]:
         """
-        Extract text from image.
-        
-        Args:
-            image_path: Path to image file
-            
-        Returns:
-            Dict with text_blocks and full_text
+        Extract text from image using Vision Model.
         """
-        reader = self._ensure_reader()
-        results = reader.readtext(image_path)
-        
-        text_blocks = [
-            {"text": text, "confidence": conf, "bbox": bbox}
-            for bbox, text, conf in results
-        ]
-        full_text = " ".join([r[1] for r in results])
-        
-        return {
-            "text_blocks": text_blocks,
-            "full_text": full_text,
-            "word_count": len(full_text.split())
-        }
+        try:
+            prompt = "Extract and transcribe all visible text from this image exactly as it appears. Return only the text."
+            full_text = self.client.chat(message=prompt, image_path=image_path)
+            
+            # Simple heuristic for word count
+            word_count = len(full_text.split())
+            
+            return {
+                "text_blocks": [], # VLM doesn't give bounding boxes easily
+                "full_text": full_text,
+                "word_count": word_count
+            }
+        except Exception as e:
+            return {
+                "text_blocks": [],
+                "full_text": f"[OCR ERROR] Vision Model Failed: {e}",
+                "word_count": 0
+            }
 
 
 # ==========================================
@@ -238,7 +227,7 @@ class DolphinAgentConnector:
         if self._client is None:
             try:
                 from huggingface_hub import InferenceClient
-                self._client = InferenceClient(token=self.config.hf_token)
+                self._client = InferenceClient(token=self.config.hf_token, base_url="https://router.huggingface.co")
             except ImportError:
                 raise ImportError("huggingface_hub not installed.")
         return self._client
@@ -296,20 +285,67 @@ class LocalLLMConnector:
     Optimization: Direct localhost access (no Docker bridge lag).
     """
     
-    def __init__(self, base_url: str = "http://localhost:1234/v1", model: str = "local-model"):
-        self.base_url = base_url
+    def __init__(self, base_url: str = None, model: str = "local-model"):
+        # Prioritize Environment -> Argument -> Default
+        env_url = os.environ.get("LOGOS_LLM_ENDPOINT")
+        self.base_url = base_url or env_url or "http://192.168.0.105:1234/v1"
         self.model = model
     
-    def chat(self, message: str, system_prompt: str = None) -> str:
-        """Chat with local model via requests."""
+    async def chat_async(self, message: str, system_prompt: str = None, model: str = None):
+        """
+        Asynchronous chat with local model via aiohttp.
+        """
+        import aiohttp
+        import json
+
+        target_model = model or self.model
+        payload = {
+            "model": target_model,
+            "messages": [],
+            "temperature": 0.7,
+            "stream": False
+        }
+        if system_prompt:
+            payload["messages"].append({"role": "system", "content": system_prompt})
+        payload["messages"].append({"role": "user", "content": message})
+
+        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:
+                    if response.status == 200:
+                        data = await response.json()
+                        return data['choices'][0]['message']['content']
+                    else:
+                        return f"[Error] Local LLM returned status {response.status}"
+        except Exception as e:
+            return f"[Async Local LLM Error] {e}"
+
+    def chat(self, message: str, system_prompt: str = None, model: str = None, image_path: str = None) -> str:
+        """
+        Chat with local model via requests. Supports Vision if image_path is provided.
+        Auto-detects Docker host.
+        """
         import requests
         import json
+        import base64
+        import os
+
+        # Helper to encode image
+        def encode_image(path):
+            with open(path, "rb") as image_file:
+                return base64.b64encode(image_file.read()).decode('utf-8')
+
+        # Potential endpoints to try
+        endpoints = [self.base_url]
+        if "localhost" in self.base_url:
+             endpoints.append(self.base_url.replace("localhost", "host.docker.internal"))
         
-        endpoint = f"{self.base_url}/chat/completions"
-        headers = {"Content-Type": "application/json"}
+        # Use instance default if no specific model requested
+        target_model = model or self.model
         
         payload = {
-            "model": self.model,
+            "model": target_model,
             "messages": [],
             "temperature": 0.7,
             "stream": False
@@ -317,15 +353,39 @@ class LocalLLMConnector:
         
         if system_prompt:
             payload["messages"].append({"role": "system", "content": system_prompt})
-        payload["messages"].append({"role": "user", "content": message})
+            
+        if image_path and os.path.exists(image_path):
+            # Format message for Vision API (OpenAI compatible)
+            base64_image = encode_image(image_path)
+            user_content = [
+                {"type": "text", "text": message},
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{base64_image}"
+                    }
+                }
+            ]
+            payload["messages"].append({"role": "user", "content": user_content})
+        else:
+            # Standard Text Chat
+            payload["messages"].append({"role": "user", "content": message})
         
-        try:
-            response = requests.post(endpoint, headers=headers, json=payload, timeout=30)
-            response.raise_for_status()
-            data = response.json()
-            return data['choices'][0]['message']['content']
-        except Exception as e:
-            return f"[Local LLM Error] Is LM Studio/Ollama running? {e}"
+        last_error = ""
+        
+        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)
+                response.raise_for_status()
+                data = response.json()
+                return data['choices'][0]['message']['content']
+            except Exception as e:
+                last_error = str(e)
+                continue
+                
+        return f"[Local LLM Error] Could not connect to Local Swarm on {endpoints}. Is LM Studio running? ({last_error})"
 
 
 # ==========================================
@@ -524,3 +584,81 @@ AVAILABLE_CONNECTORS = {
         'env_vars': []
     }
 }
+
+# ==========================================
+# CLI / TESTING
+# ==========================================
+
+def main():
+    """
+    CLI for testing connectors directly.
+    Usage: python -m logos.connectors --test local --model google/gemma-3-4b
+    """
+    import argparse
+    import sys
+    
+    parser = argparse.ArgumentParser(description="LOGOS Connectors Utilities")
+    parser.add_argument("--test", choices=list(AVAILABLE_CONNECTORS.keys()), help="Connector to test")
+    parser.add_argument("--model", help="Model name for HF or Local connector")
+    parser.add_argument("--prompt", default="Hello, are you online?", help="Prompt to send")
+    parser.add_argument("--image", help="Path to image for OCR or Vision test")
+    
+    args = parser.parse_args()
+    
+    if not args.test:
+        print("Available Connectors:")
+        for k, v in AVAILABLE_CONNECTORS.items():
+            print(f"  - {k:<10} : {v['name']}")
+        print("\nRun with --test <name> to verify a connection.")
+        return
+
+    print(f"--- Testing Connector: {args.test.upper()} ---")
+    
+    try:
+        if args.test == 'local':
+            # Local LLM / Vision Test
+            model = args.model or "local-model"
+            print(f"Targeting Model: {model}")
+            client = get_connector('local', model=model)
+            
+            if args.image:
+                print(f"Sending Vision Request with {args.image}...")
+                resp = client.chat(args.prompt, image_path=args.image)
+            else:
+                print(f"Sending Chat Request: '{args.prompt}'...")
+                resp = client.chat(args.prompt)
+            
+            print(f"\n[RESPONSE]\n{resp}")
+
+        elif args.test == 'ocr':
+            # OCR Test (via Vision)
+            if not args.image:
+                print("Error: --image argument required for OCR test.")
+                return
+            
+            client = get_connector('ocr')
+            print(f"Extracting text from {args.image}...")
+            res = client.extract_text(args.image)
+            print(f"\n[RESULT]\n{res['full_text']}")
+
+        elif args.test == 'hf':
+            # Hugging Face Test
+            client = get_connector('hf')
+            if args.image:
+                # Image Captioning
+                resp = client.image_to_text(args.image)
+            else:
+                # Text Gen
+                resp = client.text_generation(args.prompt)
+            print(f"\n[RESPONSE]\n{resp}")
+            
+        else:
+            print(f"Test CLI not yet implemented for {args.test}. Import and use in Python.")
+
+    except Exception as e:
+        print(f"\n[FAIL] {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

logos/indexer.py

@@ -0,0 +1,130 @@
+"""
+logos/indexer.py - The Codebase Aggregator
+Protocol 4: Automated Context indexing
+
+This script creates a monolithic "Dump File" of the entire project to facilitate 
+LLM ingestion and token indexing.
+
+Workflow:
+1. Traverses the project root.
+2. Filters for "Signal" (Source code, Docs) vs "Noise" (Venv, Data, Cache).
+3. Aggregates content into a structured markdown file.
+4. Provides Token Estimation.
+
+Output: 'project_context_dump.md'
+"""
+
+import os
+import pathspec
+
+# Configuration
+PROJECT_ROOT = "."
+OUTPUT_FILE = "project_context_dump.md"
+
+# Whitelist: Only these extensions contain "Logic/Knowledge"
+INCLUDE_EXTENSIONS = {
+    '.py',   # Source Logic
+    '.md',   # Documentation & Knowledge Base
+    '.txt',  # Requirements / Notes
+    '.bat',  # Orchestration
+    '.sh',   # Scripts
+    '.yaml', # Config
+    '.json'  # Config (Be careful with data files)
+}
+
+# Blacklist: Always ignore these directories
+IGNORE_DIRS = {
+    '.git',
+    '.venv',
+    '__pycache__',
+    'node_modules',
+    '_archive',        # Legacy code
+    'LOGOS Screenshots', # Binary Data
+    'LOGOS Notes',     # Binary Data (Ingested via ingest_knowledge.py)
+    '.gemini',         # Agent memory
+    'artifacts'        # Agent outputs
+}
+
+# Max file size to include (avoid dumping huge data files by accident)
+MAX_FILE_SIZE = 100 * 1024 # 100KB
+
+def load_gitignore(root):
+    """Load .gitignore to respect project exclusions."""
+    gitignore = os.path.join(root, ".gitignore")
+    if os.path.exists(gitignore):
+        with open(gitignore, 'r') as f:
+            return pathspec.PathSpec.from_lines('gitwildmatch', f)
+    return None
+
+def estimate_tokens(text):
+    """Rough estimation: 4 chars ~= 1 token"""
+    return len(text) // 4
+
+def main():
+    print(f"--- LOGOS Indexing Protocol ---")
+    print(f"Root: {os.path.abspath(PROJECT_ROOT)}")
+    
+    spec = load_gitignore(PROJECT_ROOT)
+    
+    total_files = 0
+    total_chars = 0
+    
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as out:
+        # Header
+        out.write(f"# LOGOS Project Context Dump\n")
+        out.write(f"Generated: {os.path.abspath(OUTPUT_FILE)}\n\n")
+        
+        for root, dirs, files in os.walk(PROJECT_ROOT):
+            # 1. Filtering Directories
+            dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+            
+            for file in files:
+                ext = os.path.splitext(file)[1].lower()
+                
+                # 2. Filtering Extensions
+                if ext not in INCLUDE_EXTENSIONS:
+                    continue
+                    
+                filepath = os.path.join(root, file)
+                relpath = os.path.relpath(filepath, PROJECT_ROOT)
+                
+                # 3. Filtering GitIgnore
+                if spec and spec.match_file(relpath):
+                    continue
+                
+                # 4. Filtering Size
+                try:
+                    size = os.path.getsize(filepath)
+                    if size > MAX_FILE_SIZE:
+                        print(f"[SKIP] Too large: {relpath} ({size/1024:.1f}KB)")
+                        continue
+                        
+                    # 5. Ingestion
+                    with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+                        content = f.read()
+                        
+                    # Format
+                    out.write(f"================================================================================\n")
+                    out.write(f"FILE: {relpath}\n")
+                    out.write(f"================================================================================\n")
+                    out.write(f"```{ext[1:]}\n")
+                    out.write(content)
+                    out.write(f"\n```\n\n")
+                    
+                    total_files += 1
+                    total_chars += len(content)
+                    print(f"[INDEX] Added: {relpath}")
+                    
+                except Exception as e:
+                    print(f"[WARN] Could not read {relpath}: {e}")
+
+    # Stats
+    tokens = total_chars // 4
+    print(f"\n--- Indexing Complete ---")
+    print(f"Files Processed: {total_files}")
+    print(f"Total Characters: {total_chars:,}")
+    print(f"Estimated Tokens: {tokens:,}")
+    print(f"Output: {OUTPUT_FILE}")
+
+if __name__ == "__main__":
+    main()