feat: implement cryptographic integrity, DAG-reasoning engine, and JIT-optimized generative backbone

app.py

@@ -1,77 +1,23 @@
-import os
-import sys
-import time
+import os, sys
 from flask import Flask, request, jsonify, render_template_string
-
-# Structural Boot Guard: Enforce localized directory parity before compilation loops
-os.makedirs(os.path.join(os.getcwd(), "storage", "knowledge"), exist_ok=True)
-os.makedirs(os.path.join(os.getcwd(), "templates"), exist_ok=True)
-
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from src.core.watchdog import verify_vault, update_manifest
 from src.core.retrieval_engine import LocalRetrievalEngine
 from src.core.memory_engine import MemoryEngine
 from brain import get_ripple_payload
 
 app = Flask(__name__)
 
-# Cold-start compilation invocation
-try:
-    print("[*] Launching system boot-stage hot ingestion...")
-    engine = MemoryEngine()
-    engine.ingest_knowledge('storage/knowledge')
-except Exception as e:
-    print(f"[!] Warning: Initial bootstrapping execution anomaly intercepted: {str(e)}")
+@app.before_request
+def guard():
+    if not verify_vault():
+        return jsonify({"error": "Integrity violation"}), 403
 
 retriever = LocalRetrievalEngine()
 
-@app.route('/', methods=['GET'])
-def index():
-    """Renders the offline water-ripple visualization canvas directly to local clients."""
-    template_path = os.path.join(os.getcwd(), "templates", "ripple.html")
-    if not os.path.exists(template_path):
-        return "CRITICAL: Front-end template asset missing from disk.", 404
-    with open(template_path, 'r', encoding='utf-8') as f:
-        html_content = f.read()
-    return render_template_string(html_content)
-
 @app.route('/ripple', methods=['POST'])
 def ripple():
-    data = request.get_json(force=True) or {}
-    text = data.get("text", "").strip()
-    if not text:
-        return jsonify({"error": "Null parameters: text query stream required."}), 400
-        
-    try:
-        payload = get_ripple_payload(text, max_depth=12)
-        return jsonify(payload)
-    except Exception as e:
-        return jsonify({"error": f"Internal cognitive pipeline exception: {str(e)}"}), 500
-
-@app.route('/api/ingest', methods=['POST'])
-def hot_ingest():
-    data = request.get_json(force=True) or {}
-    target_dir = data.get("directory", "storage/knowledge")
-    try:
-        ingestor = MemoryEngine()
-        ingestor.ingest_knowledge(target_dir)
-        return jsonify({"status": "SUCCESS", "timestamp": time.time()})
-    except Exception as e:
-        return jsonify({"error": f"Dynamic hot-ingestion compilation failure: {str(e)}"}), 500
-
-@app.route('/api/query', methods=['POST'])
-def semantic_query():
-    data = request.get_json() or {}
-    query_string = data.get('query', '').strip()
-    top_k = int(data.get('top_k', 3))
-    
-    if not query_string:
-        return jsonify({"error": "Missing parameter: query string required"}), 400
-    try:
-        matches = retriever.query(query_string, top_k=top_k)
-        return jsonify({"query": query_string, "results_returned": len(matches), "matches": matches})
-    except Exception as e:
-        return jsonify({"error": f"Retrieval execution failure: {str(e)}"}), 500
+    data = request.get_json(force=True)
+    return jsonify(get_ripple_payload(data.get("text", "")))
 
 if __name__ == '__main__':
-    print("[*] Secure Sovereign UI Gateway staging on http://127.0.0.1:5000")
-    app.run(host='0.0.0.0', port=5000, debug=False)
+    app.run(host='0.0.0.0', port=5000)

src/core/plugin_base.py

@@ -0,0 +1,3 @@
+class PluginBase:
+    name = "base"
+    def on_node(self, node): return node

src/core/transformer_wrapper.py

@@ -2,47 +2,27 @@ import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
 class SovereignTransformer:
-    """
-    Loads a pre-trained causal LM and exposes a single encode() method 
-    that returns a single vector (the hidden state of the last token, L2-normalized).
-    """
     def __init__(self, model_name: str = "facebook/opt-125m", device: str = None):
-        # Default to CPU to ensure stable execution on ARM64 architectures
         self.device = device or "cpu"
-        
-        # Use float32 to prevent PyTorch 'Half' unimplemented errors on native CPU
         self.dtype = torch.float32
-
         print(f"[*] Initializing Sovereign Generative Backbone: {model_name}")
         self.tokenizer = AutoTokenizer.from_pretrained(model_name)
         self.model = AutoModelForCausalLM.from_pretrained(
-            model_name,
-            torch_dtype=self.dtype,
-            low_cpu_mem_usage=True,
+            model_name, torch_dtype=self.dtype, low_cpu_mem_usage=True
         ).to(self.device)
 
+        if hasattr(torch, "compile"):
+            print("[*] JIT-Compiling Sovereign Backbone...")
+            self.model = torch.compile(self.model)
+
         self.model.eval()
 
     def encode(self, text: str) -> torch.Tensor:
-        """Returns a single L2-normalized vector (shape = (dim,))."""
-        inputs = self.tokenizer(
-            text,
-            return_tensors="pt",
-            truncation=True,
-            max_length=512,
-        ).to(self.device)
-
+        inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512).to(self.device)
         with torch.no_grad():
-            hidden = self.model.base_model(
-                **inputs,
-                output_hidden_states=False,
-                return_dict=True,
-            ).last_hidden_state
-
-        # Extract the final token state
+            hidden = self.model.base_model(**inputs, return_dict=True).last_hidden_state
         vec = hidden[:, -1, :]
-        vec = torch.nn.functional.normalize(vec, p=2, dim=-1)
-        return vec.squeeze(0)
+        return torch.nn.functional.normalize(vec, p=2, dim=-1).squeeze(0)
 
     @property
     def dim(self) -> int:

src/core/watchdog.py

@@ -0,0 +1,32 @@
+import os, hashlib, json
+from pathlib import Path
+
+def get_vault_path():
+    return Path(__file__).parents[2] / "storage" / "knowledge"
+
+def _hash_file(p: Path) -> str:
+    h = hashlib.sha256()
+    with p.open("rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+def verify_vault() -> bool:
+    manifest_path = get_vault_path() / "manifest.sha256"
+    if not manifest_path.exists(): return True
+    with manifest_path.open("r") as f:
+        stored = json.load(f)
+    for rel_path, expected_hash in stored.items():
+        full_path = get_vault_path() / rel_path
+        if not full_path.is_file() or _hash_file(full_path) != expected_hash:
+            return False
+    return True
+
+def update_manifest():
+    manifest = {}
+    vault = get_vault_path()
+    for txt in vault.rglob("*.txt"):
+        rel = txt.relative_to(vault).as_posix()
+        manifest[rel] = _hash_file(txt)
+    with (vault / "manifest.sha256").open("w") as f:
+        json.dump(manifest, f, indent=2)

templates/ripple.html

@@ -1,147 +1,23 @@
 <!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>FSI – Ripple Thought Visualiser</title>
-  <style>
-    body { margin:0; background:#0e0e0e; color:#fff; font-family:monospace; overflow: hidden; }
-    #canvas { display:block; width:100vw; height:100vh; position: absolute; top:0; left:0; z-index: 1; }
-    #controls { position:absolute; top:20px; left:20px; z-index:10; background: rgba(20, 20, 20, 0.85); padding: 15px; border: 1px solid #333; border-radius: 4px; box-shadow: 0 4px 20px rgba(0,0,0,0.5); }
-    #question { width:350px; padding:10px; background: #000; border: 1px solid #555; color: #00ffcc; font-family: monospace; outline: none; }
-    #question:focus { border-color: #00ffcc; }
-    #run { padding:10px 20px; background: #00ffcc; border: none; color: #000; font-weight: bold; cursor: pointer; font-family: monospace; }
-    #run:hover { background: #00ccaa; }
-    #metrics { margin-top: 10px; font-size: 12px; color: #aaa; line-height: 1.5; }
-  </style>
+<html>
+<head><title>Sovereign Logic Map</title>
+<style>
+body { background: #000; color: #0f0; font-family: monospace; }
+#graph-container { display: flex; flex-direction: column; padding: 20px; }
+.node { border: 1px solid #0f0; margin: 5px; padding: 10px; }
+</style>
 </head>
 <body>
-  <div id="controls">
-    <div style="font-weight: bold; margin-bottom: 8px; color: #00ffcc;">FSI COGNITIVE MATRIX SURROUND</div>
-    <input id="question" placeholder="Input operational query matrix..." value="PROTOCOL_SYN_FLOOD mitigation parameters" />
-    <button id="run">Execute</button>
-    <div id="metrics"></div>
-  </div>
-  <canvas id="canvas"></canvas>
-
-  <script>
-    const canvas = document.getElementById('canvas');
-    const ctx = canvas.getContext('2d');
-    const dpr = window.devicePixelRatio || 1;
-    
-    function resize() {
-      canvas.width  = window.innerWidth * dpr;
-      canvas.height = window.innerHeight * dpr;
-      ctx.scale(dpr, dpr);
-    }
-    window.addEventListener('resize', resize);
-    resize();
-
-    class Ripple {
-      constructor(x, y, radius, speed, opacity, color, lineWidth) {
-        this.x = x; this.y = y;
-        this.radius = radius;      
-        this.speed = speed;        
-        this.opacity = opacity;    
-        this.color = color;        
-        this.lineWidth = lineWidth;
-      }
-      update() {
-        this.radius += this.speed;
-        this.opacity *= 0.97;      // Smooth linear decay tracking
-      }
-      draw(ctx) {
-        ctx.beginPath();
-        ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2);
-        ctx.strokeStyle = this.color;
-        ctx.globalAlpha = this.opacity;
-        ctx.lineWidth = this.lineWidth;
-        ctx.stroke();
-        ctx.globalAlpha = 1.0;
-      }
-      isDead() { return this.opacity < 0.01; }
-    }
-
-    const ripples = [];
-
-    function mapStepToRipple(step, index, totalSteps) {
-      const margin = 100;
-      const width = window.innerWidth;
-      const height = window.innerHeight;
-      
-      // Horizontal node dispersion mapping across center plane
-      const x = margin + ((width - margin * 2) / Math.max(1, totalSteps - 1)) * index;
-      const y = height / 2;
-
-      // Mathematical Scaling: High free-energy produces wide, high-velocity disruptions
-      const baseEnergy = parseFloat(step.free_energy || 0.05);
-      const radius = 2;
-      const speed = 1.5 + (baseEnergy * 25); 
-      const opacity = 1.0;
-      
-      // Chromatic confidence vectoring: Green-cyan for stability, Red-orange for high entropy deviations
-      let color = "rgb(0, 255, 204)"; 
-      if (step.confidence < 0.6) {
-        color = "rgb(255, 51, 51)";
-      } else if (step.confidence < 0.85) {
-        color = "rgb(255, 153, 0)";
-      }
-
-      const lineWidth = Math.max(1, Math.min(5, baseEnergy * 50));
-      return new Ripple(x, y, radius, speed, opacity, color, lineWidth);
-    }
-
-    function animationLoop() {
-      // Clear canvas with trace retention buffer to generate water movement trails
-      ctx.fillStyle = 'rgba(14, 14, 14, 0.2)';
-      ctx.fillRect(0, 0, window.innerWidth, window.innerHeight);
-
-      for (let i = ripples.length - 1; i >= 0; i--) {
-        ripples[i].update();
-        ripples[i].draw(ctx);
-        if (ripples[i].isDead()) {
-          ripples.splice(i, 1);
-        }
-      }
-      requestAnimationFrame(animationLoop);
-    }
-    requestAnimationFrame(animationLoop);
-
-    document.getElementById('run').addEventListener('click', async () => {
-      const text = document.getElementById('question').value;
-      const metricsDiv = document.getElementById('metrics');
-      metricsDiv.innerHTML = "Query dispatched to local core pipeline...";
-      
-      try {
-        const response = await fetch('/ripple', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ text: text })
-        });
-        
-        const data = await response.json();
-        if (data.error) {
-          metricsDiv.innerHTML = `<span style="color:red;">Error: ${data.error}</span>`;
-          return;
-        }
-
-        metricsDiv.innerHTML = `
-          <b>Conclusion:</b> ${data.final_conclusion.label}<br>
-          <b>System Confidence:</b> ${(data.final_conclusion.confidence * 100).toFixed(2)}%<br>
-          <b>Aggregate Free Energy Loss:</b> ${data.total_free_energy.toFixed(5)}
-        `;
-
-        // Sequential step cascading timeline
-        data.steps.forEach((step, index) => {
-          setTimeout(() => {
-            const rip = mapStepToRipple(step, index, data.steps.length);
-            ripples.push(rip);
-          }, index * 250); // Stagger intervals to mimic step processing
-        });
-
-      } catch (err) {
-        metricsDiv.innerHTML = `<span style="color:red;">Execution Failed: ${err.message}</span>`;
-      }
-    });
-  </script>
+<div id="graph-container"></div>
+<input id="inputBox" placeholder="Query the sovereign core..." style="width:100%"/>
+<script>
+document.getElementById('inputBox').addEventListener('keydown', async e=>{
+  if(e.key!=='Enter') return;
+  const res = await fetch('/ripple', {method:'POST', body:JSON.stringify({text:e.target.value})});
+  const data = await res.json();
+  const container = document.getElementById('graph-container');
+  container.innerHTML = data.steps.map(s => `<div class="node">[${s.operation}] Conf: ${s.confidence.toFixed(2)} - ${s.text}</div>`).join('');
+});
+</script>
 </body>
 </html>

verify_system.py

@@ -0,0 +1,11 @@
+from brain import get_ripple_payload
+import json
+
+print("[*] Performing Depth-Charge reasoning test (Depth=3)...")
+payload = get_ripple_payload("Why is the architecture sovereign?", max_depth=3)
+print(f"[+] Reasoning steps generated: {len(payload['steps'])}")
+print(f"[+] Final conclusion: {payload['final_conclusion']['label']}")
+
+# Validate graph structure
+for step in payload['steps']:
+    print(f" -> Node {step['id']} | FE: {step['free_energy']:.4f}")