Feature: Add ARCHITECTURE.md and display it in new UI tab

ARCHITECTURE.md

@@ -0,0 +1,32 @@
+# LOGOS Architecture: The Prime-Manifold Protocol
+
+## 1. The Core Thesis
+LOGOS is a **Manifold-Constrained Data Transport Protocol** that implements **Nested Domain Learning** at the bitstream layer. It replaces probabilistic software routing with deterministic prime topology.
+
+## 2. Theoretical Convergence
+
+### A. Hardware-Native "HOPE" (Nested Domains)
+Google's **HOPE** architecture separates learning into hierarchical "neighborhoods" to prevent catastrophic forgetting. LOGOS implements this physically via **Matroska Shells**:
+* **Inner Shells (Meta-Heat):** Low-entropy, high-persistence data anchored by Low-GPF primes (2, 3, 5). Equivalent to HOPE's "Slow Learning" layers.
+* **Outer Shells (Delta-Heat):** High-entropy, high-variance data anchored by High-GPF primes. Equivalent to HOPE's "Fast Learning" layers.
+* **Mechanism:** Data is not routed by a neural network; it is sorted by its **Prime Harmonic Resonance**.
+
+### B. Intrinsic "mHC" (Manifold Constraints)
+DeepSeek's **mHC** stabilizes networks by projecting connections onto a manifold. LOGOS achieves this via **Radial Prime Topology**:
+* **The Constraint:** Data atoms are valid ONLY if they align with the **Mod 10 Prime Vectors (1, 3, 7, 9)**.
+* **The Manifold:** The "Web" created by connecting Composites to their **Greatest Prime Factor (GPF)** forms a closed geometric surface.
+* **Stability:** Signal variance ("Heat") is dissipated by traversing this web from Outer Shells to Inner Shells, structurally preventing gradient explosion.
+
+## 3. The SPCW Engine (The Implementation)
+* **Input:** Raw Data Stream (Video/Image).
+* **Process:** Adaptive Quadtree Decomposition (The Baker).
+* **Routing:** 
+    * **Persistence (00):** Mapped to Inner Shell (Meta).
+    * **Change (11):** Mapped to Outer Shell (Delta).
+* **Validation:** Harmonic Checksum verifies that the Sum of Delta Heat matches the Topological Address.
+
+## 4. Summary for System Architects
+LOGOS is not just compression. It is a **Geometric Stability Engine**. It allows high-throughput AI streams to "self-organize" into nested domains of validity, reducing the thermal and computational load on the receiving hardware.
+
+---
+*Bridging Google’s Software Topology (HOPE) with DeepSeek’s Mathematical Constraint (mHC) using LOGOS’s Physical Geometry.*

README.md

@@ -12,7 +12,11 @@ short_description: "SPCW Protocol Visualizer & DSP Bridge"
 # LOGOS: Structured Prime Composite Waveform (SPCW)
 **"The Machine Shop"**
 
-LOGOS is a physics-first protocol for data transmission, treating information as thermodynamic "heat" and "waves" defined by prime number theory.
+**[📄 READ THE UNIFIED ARCHITECTURE (HOPE + mHC + LOGOS)](ARCHITECTURE.md)**
+
+LOGOS is a **Manifold-Constrained Data Transport Protocol** that implements **Nested Domain Learning** at the bitstream layer. It replaces probabilistic software routing with deterministic prime topology.
+
+It treats information as thermodynamic "heat" and "waves" defined by prime number theory.
 
 ## Features
 

app.py

@@ -268,6 +268,14 @@ with gr.Blocks(theme=gr.themes.Monochrome(), title="LOGOS SPCW Protocol") as dem
     gr.Markdown("_\"The Machine Shop\" - Research & Development Lab_")
     
     with gr.Tabs():
+        with gr.Tab("🏛️ Architecture"):
+            try:
+                with open(os.path.join(current_dir, "ARCHITECTURE.md"), "r", encoding='utf-8') as f:
+                    arch_content = f.read()
+                gr.Markdown(arch_content)
+            except Exception:
+                gr.Markdown("## Architecture Document Not Found\nPlease check ARCHITECTURE.md in the file browser.")
+
         with gr.Tab("Prime Network Visualizer"):
             gr.Markdown("## Layer 1: Mathematical Blueprints")
             with gr.Row():

build_kb.py

@@ -0,0 +1,63 @@
+
+import os
+import json
+import logging
+from logos.connectors import get_connector
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def build_knowledge_base(source_dirs: list, output_file: str = "logos_knowledge_base.json"):
+    """
+    Scans directories for images, applies OCR, and saves a JSON knowledge base.
+    """
+    ocr = get_connector('ocr')
+    knowledge_base = []
+    
+    total_files = 0
+    for directory in source_dirs:
+        if not os.path.exists(directory):
+            logging.warning(f"Directory not found: {directory}")
+            continue
+            
+        logging.info(f"Scanning {directory}...")
+        for root, _, files in os.walk(directory):
+            for file in files:
+                if file.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp')):
+                    file_path = os.path.join(root, file)
+                    try:
+                        logging.info(f"Processing {file}...")
+                        result = ocr.extract_text(file_path)
+                        
+                        entry = {
+                            "filename": file,
+                            "path": file_path,
+                            "word_count": result['word_count'],
+                            "full_text": result['full_text'],
+                            "text_blocks": result['text_blocks'] # Keep blocks for spatial context if needed
+                        }
+                        knowledge_base.append(entry)
+                        total_files += 1
+                    except Exception as e:
+                        logging.error(f"Failed to process {file}: {e}")
+
+    with open(output_file, 'w', encoding='utf-8') as f:
+        json.dump(knowledge_base, f, indent=2, ensure_ascii=False)
+    
+    logging.info(f"Knowledge Base built! Processed {total_files} images. Saved to {output_file}")
+
+if __name__ == "__main__":
+    # Define source directories - Adjust these paths to where the user's notes actually are
+    # Using absolute paths based on previous context
+    PROJECT_ROOT = r"c:\Users\Nauti\Desktop\LOGOS CURSOR"
+    DIRS_TO_SCAN = [
+        os.path.join(PROJECT_ROOT, "LOGOS Screenshots"),
+        os.path.join(PROJECT_ROOT, "LOGOS Notes"),
+        os.path.join(PROJECT_ROOT, "LOGOS PRIME FUSE") 
+    ]
+    
+    # Check if we should only scan a subset for testing first? 
+    # Or just go for it. Given "external resources are sparse, my notes are streamlined", 
+    # we want as much as possible.
+    
+    build_knowledge_base(DIRS_TO_SCAN)

logos_knowledge_base.json

@@ -0,0 +1 @@
+[]

query_kb.py

@@ -0,0 +1,55 @@
+
+import json
+import argparse
+import os
+
+def query_knowledge_base(query, kb_file="logos_knowledge_base.json"):
+    if not os.path.exists(kb_file):
+        print(f"Knowledge base not found at {kb_file}. Run build_kb.py first.")
+        return
+
+    with open(kb_file, 'r', encoding='utf-8') as f:
+        kb = json.load(f)
+
+    print(f"\nSearching for: '{query}' in {len(kb)} documents...\n")
+    print("-" * 60)
+
+    hits = []
+    query = query.lower()
+
+    for entry in kb:
+        filename = entry['filename']
+        full_text = entry['full_text'].lower()
+        
+        if query in full_text:
+            # Find context
+            idx = full_text.find(query)
+            start = max(0, idx - 50)
+            end = min(len(full_text), idx + 50 + len(query))
+            context = entry['full_text'][start:end].replace('\n', ' ')
+            
+            hits.append({
+                'filename': filename,
+                'path': entry['path'],
+                'context': f"...{context}...",
+                'score': full_text.count(query)
+            })
+
+    # Sort by number of occurrences
+    hits.sort(key=lambda x: x['score'], reverse=True)
+
+    if not hits:
+        print("No matches found.")
+    else:
+        for hit in hits[:10]: # Top 10
+            print(f"📄 {hit['filename']} (Matches: {hit['score']})")
+            print(f"   Path: {hit['path']}")
+            print(f"   Context: {hit['context']}")
+            print("-" * 60)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Query LOGOS Knowledge Base")
+    parser.add_argument("query", help="Search term")
+    args = parser.parse_args()
+    
+    query_knowledge_base(args.query)