[VITALIS] Full FSI system — Tier 1-4 complete

failure_report.json

@@ -1 +1 @@
-{"intent": "auto_debug", "original_task": {"intent": "scaffold", "module_name": "security_audit", "status": "planned"}, "error_log": "/home/droid/vitalis_devcore/venv/bin/python3: No module named pytest\n"}
+{"intent": "auto_debug", "original_task": {"intent": "scaffold", "module_name": "test_module", "file": null, "code": null}, "error_log": "/usr/bin/python3: No module named pytest\n"}

memory_slot.json

@@ -0,0 +1 @@
+{"slot": 2}

project_ledger.json

@@ -1 +1 @@
-{"scaffold": "Failed: /home/droid/vitalis_devcore/venv/bin/python3: No m..."}
+{"scaffold": "Completed", "test_action": "Completed"}

src/brain/inference.py

@@ -1,3 +1,23 @@
-from vitalis_ide.brain.inference import InferenceEngine
+import numpy as np
+import os
+import sys
+sys.path.insert(0, os.path.expanduser("~/vitalis_devcore"))
+from vitalis_ide.math_core.kernel import VitalisKernel
 
-__all__ = ["InferenceEngine"]
+class InferenceEngine:
+    def __init__(self):
+        self.kernel = VitalisKernel()
+
+    def reason(self, prompt: str) -> str:
+        tokens = prompt.strip().split()
+        vec = self.kernel.vectorize_tokens(tokens)
+        confidence = float(np.mean(np.abs(vec)))
+        if "scaffold" in prompt.lower():
+            return "scaffold"
+        elif "write" in prompt.lower() or "fix" in prompt.lower():
+            return "write"
+        else:
+            return f"[INFER] Confidence={confidence:.3f} | Input={prompt[:80]}"
+
+    def embed(self, text: str) -> np.ndarray:
+        return self.kernel.vectorize_tokens(text.strip().split())

src/hippocampus.py

@@ -2,25 +2,20 @@ import numpy as np
 import os
 
 class Hippocampus:
-    def __init__(self, filename="vitalis_memory.bin", dim=10000, capacity=1000):
-        self.filename = filename
-        self.dim = dim
-        self.capacity = capacity
-        self.size = capacity * dim * 1
-        
-        self.fd = os.open(self.filename, os.O_RDWR | os.O_CREAT)
-        os.ftruncate(self.fd, self.size)
-        
-        self.mem = np.memmap(self.filename, dtype=np.int8, mode="r+", shape=(capacity, dim))
+    def __init__(self, path=None):
+        self.path = path or os.path.expanduser("~/.vitalis_workspace/hippocampus.npy")
+        os.makedirs(os.path.dirname(self.path), exist_ok=True)
+        if os.path.exists(self.path):
+            self.memory = np.load(self.path, allow_pickle=True).item()
+        else:
+            self.memory = {}
 
-    def store(self, index, vector):
-        if index >= self.capacity:
-            raise IndexError("Memory capacity exceeded")
-        self.mem[index] = vector
-        self.mem.flush()
+    def store(self, slot, vector):
+        self.memory[slot] = vector
+        np.save(self.path, self.memory)
 
-    def recall(self, index):
-        return self.mem[index].copy()
+    def recall(self, slot):
+        return self.memory.get(slot, None)
 
-    def close(self):
-        self.mem.flush()
+    def all_slots(self):
+        return list(self.memory.keys())

src/ide_kernel/gateway.py

@@ -1,7 +1,7 @@
 from flask import Flask, request, jsonify
 import json
 import os
-from pydantic import BaseModel, ValidationError, validator
+from pydantic import BaseModel, ValidationError
 from typing import Literal, Optional
 
 app = Flask(__name__)
@@ -17,9 +17,9 @@ class TaskPayload(BaseModel):
 @app.route('/execute', methods=['POST'])
 def execute_task():
     try:
-        data = TaskPayload.parse_obj(request.json or {})
+        data = TaskPayload.model_validate(request.json or {})
     except ValidationError as exc:
         return jsonify({"error": exc.errors()}), 400
     with open(TASK_FILE, "w") as f:
-        json.dump(data.dict(), f)
+        json.dump(data.model_dump(), f)
     return jsonify({"status": "Task Queued", "intent": data.intent}), 202

src/ide_kernel/kernel.py

@@ -1,26 +1,22 @@
 import os
-import ast
 
 class SovereignKernel:
-    def __init__(self, project_root):
-        self.root = os.path.abspath(project_root)
+    def __init__(self, workspace_path):
+        self.root = os.path.abspath(workspace_path)
 
-    def write_code(self, file_path, content):
+    def write_code(self, file_path, code):
         full_path = os.path.join(self.root, file_path)
         os.makedirs(os.path.dirname(full_path), exist_ok=True)
         with open(full_path, 'w') as f:
-            f.write(content)
-        return f"File updated: {file_path}"
+            f.write(code)
+        print(f"[KERNEL] Written: {full_path}")
+        return full_path
 
     def scaffold_module(self, module_name):
-        """Generates enterprise-standard module structure."""
-        files = {
-            f"app/modules/{module_name}/__init__.py": "",
-            f"app/modules/{module_name}/logic.py": f"def process():\n    return '{module_name} active'",
-            f"tests/test_{module_name}.py": f"def test_{module_name}():\n    assert True"
-        }
-        
-        results = []
-        for path, content in files.items():
-            results.append(self.write_code(path, content))
-        return results
+        module_dir = os.path.join(self.root, module_name)
+        os.makedirs(module_dir, exist_ok=True)
+        init_path = os.path.join(module_dir, "__init__.py")
+        with open(init_path, 'w') as f:
+            f.write(f"# {module_name} module\n")
+        print(f"[KERNEL] Scaffolded: {module_dir}")
+        return module_dir

src/ide_kernel/ledger.py

@@ -1,16 +1,44 @@
 import json
 import os
+import numpy as np
+from src.hippocampus import Hippocampus
 
 class ProjectLedger:
     def __init__(self, workspace_path):
         self.ledger_path = os.path.join(workspace_path, "project_ledger.json")
+        self.hippocampus = Hippocampus()
+        self.slot_path = os.path.join(workspace_path, "memory_slot.json")
+
+    def _next_slot(self):
+        if os.path.exists(self.slot_path):
+            with open(self.slot_path, 'r') as f:
+                data = json.load(f)
+        else:
+            data = {"slot": 0}
+        slot = data["slot"]
+        data["slot"] = slot + 1
+        with open(self.slot_path, 'w') as f:
+            json.dump(data, f)
+        return slot
 
     def update_state(self, action, status):
+        # 1. Write to JSON ledger as before
         data = {}
         if os.path.exists(self.ledger_path):
             with open(self.ledger_path, 'r') as f:
                 data = json.load(f)
-        
         data[action] = status
         with open(self.ledger_path, 'w') as f:
             json.dump(data, f)
+
+        # 2. If successful, imprint into Hippocampus
+        if "Completed" in status or "Recovered" in status:
+            try:
+                seed = sum(ord(c) for c in action)
+                np.random.seed(seed)
+                vector = np.random.choice([-1, 1], size=10000).astype(np.int8)
+                slot = self._next_slot()
+                self.hippocampus.store(slot, vector)
+                print(f"[LEDGER] Action '{action}' imprinted to memory slot {slot}.")
+            except Exception as e:
+                print(f"[LEDGER] Memory imprint failed: {e}")

src/router.py

@@ -1,22 +1,8 @@
-import numpy as np
-from src.hippocampus import Hippocampus
-import hdc_engine
+from src.brain.inference import InferenceEngine
 
 class Router:
     def __init__(self):
-        self.brain = Hippocampus()
-        self.next_slot = 0
-        
-    def process(self, raw_input):
-        # 1. Map input to a vector
-        # (Simplified encoding: using the sum of character codes as a seed)
-        seed = sum(ord(c) for c in raw_input)
-        np.random.seed(seed)
-        vector = np.random.choice([-1, 1], size=10000).astype(np.int8)
-        
-        # 2. Routing logic
-        # For this prototype, we store everything as 'new learning'
-        self.brain.store(self.next_slot, vector)
-        print(f"Router: Imprinted '{raw_input}' into slot {self.next_slot}")
-        self.next_slot += 1
-        return vector
+        self.engine = InferenceEngine()
+
+    def route(self, prompt: str) -> str:
+        return self.engine.reason(prompt)

test_module/__init__.py

@@ -0,0 +1 @@
+# test_module module

test_module2/__init__.py

@@ -0,0 +1 @@
+# test_module2 module

vitalis_ide/brain/bridge.py

@@ -1,19 +1,9 @@
-"""
-Bridge Module — Autonomous confidence recovery.
-If confidence is in the hypothesis zone, this module forces a RAG retrieval
-to boost context and re-evaluate.
-"""
-
-from vitalis_ide.brain.rag import RAGEngine
+from src.brain.inference import InferenceEngine
 
 class ConfidenceBridge:
-    def __init__(self, rag_engine: RAGEngine):
-        self.rag = rag_engine
-
-    def needs_augmentation(self, confidence: float) -> bool:
-        # Range 0.45 to 0.65 triggers the Bridge
-        return 0.45 <= confidence < 0.65
+    def __init__(self):
+        self.engine = InferenceEngine()
 
-    def bridge_query(self, prompt: str) -> str:
-        # Augment existing prompt with fresh RAG data
-        return self.rag.augment_prompt(prompt, k=5)
+    def evaluate(self, prompt: str) -> dict:
+        result = self.engine.reason(prompt)
+        return {"result": result, "status": "ok"}

vitalis_ide/math_core/kernel.py

@@ -1,11 +1,120 @@
 import numpy as np
 from pathlib import Path
+import ast
+import hdc_engine
+
+DIM = 10000
 
 class VitalisKernel:
     def __init__(self):
+        self.dim = DIM
         self.weights_path = Path.home() / ".vitalis_workspace" / "kernel.weights.npy"
+        self.codebook_path = Path.home() / ".vitalis_workspace" / "codebook.npy"
+        self.codebook_index_path = Path.home() / ".vitalis_workspace" / "codebook_index.npy"
         self.bias = np.load(self.weights_path) if self.weights_path.exists() else np.array([0.0])
+        self._load_codebook()
+
+    def _load_codebook(self):
+        """Load or initialize the token codebook."""
+        if self.codebook_path.exists():
+            self.codebook = np.load(self.codebook_path, allow_pickle=True).item()
+        else:
+            self.codebook = {}
+
+    def _save_codebook(self):
+        self.codebook_path.parent.mkdir(parents=True, exist_ok=True)
+        np.save(self.codebook_path, self.codebook)
+
+    def _get_token_vector(self, token: str) -> np.ndarray:
+        """Get or create a stable hypervector for a token."""
+        if token not in self.codebook:
+            self.codebook[token] = np.random.choice(
+                [-1, 1], size=self.dim
+            ).astype(np.int8)
+            self._save_codebook()
+        return self.codebook[token]
+
+    def _get_position_vector(self, position: int) -> np.ndarray:
+        """Generate a stable position vector by seeded random."""
+        rng = np.random.default_rng(seed=position)
+        return rng.choice([-1, 1], size=self.dim).astype(np.int8)
+
+    def vectorize_tokens(self, tokens: list) -> np.ndarray:
+        """
+        Encode a list of tokens into a single hypervector.
+        Each token is bound with its position, then all are bundled.
+        """
+        bundle = np.zeros(self.dim, dtype=np.int32)
+        for i, token in enumerate(tokens):
+            token_vec = self._get_token_vector(token)
+            pos_vec = self._get_position_vector(i)
+            bound = hdc_engine.bind(token_vec, pos_vec)
+            bundle += bound
+        # Binarize the bundle
+        result = np.sign(bundle).astype(np.int8)
+        result[result == 0] = 1
+        return result
+
+    def vectorize_source(self, source_code: str) -> np.ndarray:
+        """
+        Map a source file string into a single hypervector.
+        Extracts AST-level tokens for semantic richness.
+        """
+        tokens = self._extract_tokens(source_code)
+        return self.vectorize_tokens(tokens)
+
+    def vectorize_file(self, file_path: str) -> np.ndarray:
+        """
+        Map a source file on disk into a hypervector.
+        """
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Source file not found: {file_path}")
+        source = path.read_text(encoding="utf-8")
+        return self.vectorize_source(source)
+
+    def _extract_tokens(self, source_code: str) -> list:
+        """
+        Extract meaningful tokens from source code via AST.
+        Falls back to whitespace splitting if parsing fails.
+        """
+        tokens = []
+        try:
+            tree = ast.parse(source_code)
+            for node in ast.walk(tree):
+                # Function and class names
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                    tokens.append(f"DEF:{node.name}")
+                # Variable names
+                elif isinstance(node, ast.Name):
+                    tokens.append(f"NAME:{node.id}")
+                # String constants
+                elif isinstance(node, ast.Constant) and isinstance(node.value, str):
+                    tokens.append(f"STR:{node.value[:32]}")
+                # Imports
+                elif isinstance(node, ast.Import):
+                    for alias in node.names:
+                        tokens.append(f"IMPORT:{alias.name}")
+                elif isinstance(node, ast.ImportFrom):
+                    tokens.append(f"FROM:{node.module}")
+        except SyntaxError:
+            # Fallback for non-Python or malformed files
+            tokens = source_code.split()
+        return tokens if tokens else ["EMPTY"]
+
+    def similarity(self, vec_a: np.ndarray, vec_b: np.ndarray) -> float:
+        """Cosine similarity between two hypervectors."""
+        a = vec_a.astype(np.float32)
+        b = vec_b.astype(np.float32)
+        denom = np.linalg.norm(a) * np.linalg.norm(b)
+        if denom == 0:
+            return 0.0
+        return float(np.dot(a, b) / denom)
 
     def matmul(self, a, b):
-        # Apply the resonant bias (our 'learned' state) to the raw math
+        """Legacy math operation with resonant bias."""
         return np.dot(a, b) + self.bias
+
+    def activation(self, x):
+        """Simple sign activation."""
+        return np.sign(x)