[VITALIS] Advanced systems — Dream Mode, Resonance, Semantic Diff, Temporal Memory

src/brain/resonance.py

@@ -0,0 +1,49 @@
+"""
+Resonance Engine.
+Success strengthens weights. Failure weakens them.
+The system learns from its own execution history.
+No backpropagation. No gradient descent. Pure HDC resonance.
+"""
+import numpy as np
+import os
+
+class ResonanceEngine:
+    LEARNING_RATE = 0.05
+    MAX_WEIGHT = 2.0
+    MIN_WEIGHT = 0.1
+
+    def __init__(self):
+        self.path = os.path.expanduser("~/.vitalis_workspace/resonance_weights.npy")
+        os.makedirs(os.path.dirname(self.path), exist_ok=True)
+        self.weights = np.load(self.path, allow_pickle=True).item() \
+            if os.path.exists(self.path) else {}
+
+    def _save(self):
+        np.save(self.path, self.weights)
+
+    def reinforce(self, pattern_key: str, success: bool):
+        w = self.weights.get(pattern_key, 1.0)
+        if success:
+            w = min(w * (1 + self.LEARNING_RATE), self.MAX_WEIGHT)
+            print(f"[RESONANCE] Strengthened: {pattern_key} → {w:.3f}")
+        else:
+            w = max(w * (1 - self.LEARNING_RATE), self.MIN_WEIGHT)
+            print(f"[RESONANCE] Weakened:     {pattern_key} → {w:.3f}")
+        self.weights[pattern_key] = w
+        self._save()
+
+    def get_weight(self, pattern_key: str) -> float:
+        return self.weights.get(pattern_key, 1.0)
+
+    def top_patterns(self, n=10) -> list:
+        sorted_w = sorted(self.weights.items(), key=lambda x: x[1], reverse=True)
+        return sorted_w[:n]
+
+    def report(self) -> dict:
+        if not self.weights:
+            return {"status": "No patterns learned yet"}
+        return {
+            "total_patterns": len(self.weights),
+            "strongest": self.top_patterns(5),
+            "avg_weight": round(float(np.mean(list(self.weights.values()))), 3)
+        }

src/brain/semantic_diff.py

@@ -0,0 +1,45 @@
+"""
+Semantic Diff Engine.
+Normal diff tells you WHAT changed.
+This tells you WHAT IT MEANS that it changed.
+"""
+from vitalis_ide.math_core.kernel import VitalisKernel
+
+class SemanticDiff:
+    DRIFT_THRESHOLD = 0.3
+
+    def __init__(self):
+        self.kernel = VitalisKernel()
+
+    def diff(self, code_before: str, code_after: str) -> dict:
+        vec_before = self.kernel.vectorize_source(code_before)
+        vec_after  = self.kernel.vectorize_source(code_after)
+        similarity = self.kernel.similarity(vec_before, vec_after)
+        drift = 1.0 - similarity
+
+        if drift < 0.05:
+            verdict = "TRIVIAL"
+            description = "Cosmetic change only. Logic unchanged."
+        elif drift < self.DRIFT_THRESHOLD:
+            verdict = "MINOR"
+            description = "Minor semantic shift. Core logic preserved."
+        elif drift < 0.6:
+            verdict = "SIGNIFICANT"
+            description = "Significant semantic drift. Logic has changed."
+        else:
+            verdict = "BREAKING"
+            description = "Near-complete semantic rewrite. Treat as new module."
+
+        return {
+            "similarity": round(similarity, 4),
+            "drift": round(drift, 4),
+            "verdict": verdict,
+            "description": description,
+        }
+
+    def diff_files(self, path_before: str, path_after: str) -> dict:
+        with open(path_before) as f: before = f.read()
+        with open(path_after)  as f: after  = f.read()
+        result = self.diff(before, after)
+        result["files"] = {"before": path_before, "after": path_after}
+        return result

src/hippocampus.py

@@ -1,21 +1,111 @@
 import numpy as np
 import os
+import json
+import time
 
 class Hippocampus:
+    """
+    Biologically-inspired vector memory.
+    Memories strengthen with use. Memories decay without use.
+    Based on Ebbinghaus forgetting curve.
+    """
+
     def __init__(self, path=None):
         self.path = path or os.path.expanduser("~/.vitalis_workspace/hippocampus.npy")
+        self.meta_path = os.path.expanduser("~/.vitalis_workspace/hippocampus_meta.json")
         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()
+        self.memory = np.load(self.path, allow_pickle=True).item() if os.path.exists(self.path) else {}
+        self._load_meta()
+
+    def _load_meta(self):
+        if os.path.exists(self.meta_path):
+            with open(self.meta_path) as f:
+                self.meta = json.load(f)
         else:
-            self.memory = {}
+            self.meta = {}
+
+    def _save_meta(self):
+        with open(self.meta_path, 'w') as f:
+            json.dump(self.meta, f, indent=2)
+
+    def _strength(self, slot) -> float:
+        """Ebbinghaus forgetting curve: R = e^(-t/S)"""
+        if slot not in self.meta:
+            return 1.0
+        m = self.meta[slot]
+        t = (time.time() - m.get("last_access", time.time())) / 3600
+        S = m.get("stability", 24.0)
+        return float(np.exp(-t / S))
 
     def store(self, slot, vector):
+        slot = str(slot)
         self.memory[slot] = vector
+        now = time.time()
+        if slot not in self.meta:
+            self.meta[slot] = {"created": now, "access_count": 0, "stability": 24.0}
+        self.meta[slot]["last_access"] = now
         np.save(self.path, self.memory)
+        self._save_meta()
 
     def recall(self, slot):
-        return self.memory.get(slot, None)
+        slot = str(slot)
+        vec = self.memory.get(slot)
+        if vec is not None:
+            # Strengthen on recall — spaced repetition
+            if slot in self.meta:
+                self.meta[slot]["access_count"] = self.meta[slot].get("access_count", 0) + 1
+                self.meta[slot]["stability"] = min(
+                    self.meta[slot].get("stability", 24.0) * 1.2, 720.0
+                )
+                self.meta[slot]["last_access"] = time.time()
+                self._save_meta()
+        return vec
+
+    def forget_weak(self, threshold=0.05):
+        """Prune memories below strength threshold. Called during dream mode."""
+        pruned = []
+        for slot in list(self.memory.keys()):
+            if self._strength(slot) < threshold:
+                del self.memory[slot]
+                self.meta.pop(slot, None)
+                pruned.append(slot)
+        if pruned:
+            np.save(self.path, self.memory)
+            self._save_meta()
+            print(f"[HIPPOCAMPUS] Pruned {len(pruned)} weak memories.")
+        return pruned
 
     def all_slots(self):
         return list(self.memory.keys())
+
+    def memory_report(self) -> dict:
+        report = {}
+        for slot in self.memory:
+            report[slot] = {
+                "strength": round(self._strength(slot), 3),
+                "access_count": self.meta.get(slot, {}).get("access_count", 0),
+                "stability_hours": round(self.meta.get(slot, {}).get("stability", 24.0), 1)
+            }
+        return report
+
+    def similarity_search(self, query_vec, top_k=5):
+        qf = query_vec.astype(np.float32)
+        qn = np.linalg.norm(qf)
+        if qn == 0:
+            return []
+        results = []
+        for slot, vec in self.memory.items():
+            if vec is None:
+                continue
+            strength = self._strength(slot)
+            if strength < 0.01:
+                continue
+            vf = vec.astype(np.float32)
+            vn = np.linalg.norm(vf)
+            if vn == 0:
+                continue
+            # Similarity weighted by memory strength
+            sim = float(np.dot(qf, vf) / (qn * vn)) * strength
+            results.append((sim, slot))
+        results.sort(reverse=True)
+        return results[:top_k]

src/ide_kernel/daemon.py

@@ -1,9 +1,8 @@
-import json
-import os
-import time
+import json, os, time
 from src.ide_kernel.kernel import SovereignKernel
 from src.ide_kernel.validator import KernelValidator
 from src.ide_kernel.ledger import ProjectLedger
+from src.brain.resonance import ResonanceEngine
 
 class KernelDaemon:
     def __init__(self, workspace_path):
@@ -11,52 +10,48 @@ class KernelDaemon:
         self.task_file = os.path.join(self.root, "workspace_tasks.json")
         self.kernel = SovereignKernel(self.root)
         self.ledger = ProjectLedger(self.root)
+        self.resonance = ResonanceEngine()
 
     def handle_failure(self, task, output):
-        failure_path = os.path.join(self.root, "failure_report.json")
-        failure_data = {
-            "intent": "auto_debug",
-            "original_task": task,
-            "error_log": output
-        }
-        with open(failure_path, 'w') as f:
-            json.dump(failure_data, f)
-        print(f"[!] FAILURE LOGGED. Auto-Debug agent initialized: {failure_path}")
+        path = os.path.join(self.root, "failure_report.json")
+        with open(path, 'w') as f:
+            json.dump({"intent":"auto_debug","original_task":task,"error_log":output}, f)
+        self.resonance.reinforce(task.get('intent','unknown'), success=False)
+        print(f"[!] FAILURE LOGGED. Auto-Debug initialized: {path}")
 
     def start(self):
-        print("[+] FSI Kernel Daemon Active (Self-Healing Enabled).")
+        print("[+] FSI Kernel Daemon Active (Self-Healing + Resonance Enabled).")
         while True:
             if os.path.exists(self.task_file):
                 with open(self.task_file, 'r') as f:
-                    try:
-                        task = json.load(f)
+                    try: task = json.load(f)
                     except json.JSONDecodeError:
                         print("[!] Error reading task file. Retrying...")
                         time.sleep(1)
                         continue
-                
-                # 1. Execute
                 intent = task.get('intent')
                 try:
                     if intent == 'scaffold':
                         res = self.kernel.scaffold_module(task.get('module_name'))
                     else:
                         res = self.kernel.write_code(task.get('file'), task.get('code'))
-
-                    # 2. Validate
-                    target = self.root if intent == 'scaffold' else os.path.dirname(os.path.join(self.root, task.get('file', '')))
+                    target = self.root if intent == 'scaffold' else os.path.dirname(
+                        os.path.join(self.root, task.get('file', '')))
                     success, output = KernelValidator.run_tests(target)
-                    
-                    # 3. Memory & Recovery
                     if success:
                         self.ledger.update_state(intent, "Completed")
-                        print(f"[SUCCESS] Action: {intent}. State Logged.")
+                        self.resonance.reinforce(intent, success=True)
+                        try:
+                            from src.brain.pattern_library import PatternLibrary
+                            PatternLibrary().store(intent, task.get('code') or intent, task.get('file'))
+                        except Exception as e:
+                            print(f"[DAEMON] Pattern learning skipped: {e}")
+                        print(f"[SUCCESS] Action: {intent}. Resonance reinforced.")
                     else:
                         self.handle_failure(task, output)
                         self.ledger.update_state(intent, f"Failed: {output[:50]}...")
                 except Exception as e:
                     print(f"[CRITICAL ERROR] {e}")
-                
                 os.remove(self.task_file)
             time.sleep(1)
 

src/loop/dream.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""
+Dream Mode — Vitalis FSI Memory Consolidation Engine.
+Runs during idle time. Strengthens important patterns.
+Prunes weak memories. Merges similar vectors.
+This is what makes the system get smarter without explicit training.
+"""
+import time
+import os
+import numpy as np
+from src.hippocampus import Hippocampus
+from vitalis_ide.math_core.kernel import VitalisKernel
+
+IDLE_THRESHOLD = 30  # seconds of no tasks before dream starts
+
+class DreamEngine:
+    def __init__(self):
+        self.hippocampus = Hippocampus()
+        self.kernel = VitalisKernel()
+        self.task_file = os.path.expanduser("~/vitalis_devcore/workspace_tasks.json")
+        self.dream_log = os.path.expanduser("~/.vitalis_workspace/dream_log.json")
+        self.cycles = 0
+
+    def _system_idle(self) -> bool:
+        if not os.path.exists(self.task_file):
+            return True
+        age = time.time() - os.path.getmtime(self.task_file)
+        return age > IDLE_THRESHOLD
+
+    def _consolidate(self):
+        """Merge similar memory vectors to build stronger generalizations."""
+        slots = self.hippocampus.all_slots()
+        if len(slots) < 2:
+            return 0
+        merged = 0
+        checked = set()
+        for i, slot_a in enumerate(slots):
+            if slot_a in checked:
+                continue
+            vec_a = self.hippocampus.recall(slot_a)
+            if vec_a is None:
+                continue
+            for slot_b in slots[i+1:]:
+                if slot_b in checked:
+                    continue
+                vec_b = self.hippocampus.recall(slot_b)
+                if vec_b is None:
+                    continue
+                sim = self.kernel.similarity(vec_a, vec_b)
+                # Merge very similar memories into one stronger pattern
+                if sim > 0.92:
+                    bundle = np.sign(
+                        vec_a.astype(np.int32) + vec_b.astype(np.int32)
+                    ).astype(np.int8)
+                    bundle[bundle == 0] = 1
+                    self.hippocampus.store(slot_a, bundle)
+                    checked.add(slot_b)
+                    merged += 1
+        return merged
+
+    def run(self):
+        print("[DREAM] Memory consolidation engine online.")
+        while True:
+            if self._system_idle():
+                print(f"[DREAM] Cycle {self.cycles + 1} — consolidating...")
+                pruned = self.hippocampus.forget_weak(threshold=0.03)
+                merged = self._consolidate()
+                report = self.hippocampus.memory_report()
+                active = sum(1 for v in report.values() if v["strength"] > 0.5)
+                self.cycles += 1
+                print(f"[DREAM] Complete — Active:{active} Pruned:{len(pruned)} Merged:{merged}")
+            time.sleep(60)
+
+if __name__ == "__main__":
+    DreamEngine().run()

start.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+ROOT="$HOME/vitalis_devcore"
+SESSION="vitalis"
+
+echo "╔══════════════════════════════════════════╗"
+echo "║     VITALIS FSI — SOVEREIGN BOOT        ║"
+echo "║     Local. Private. Autonomous.         ║"
+echo "╚══════════════════════════════════════════╝"
+
+if ! command -v tmux &>/dev/null; then
+    sudo apt-get install -y tmux -q
+fi
+
+tmux kill-session -t $SESSION 2>/dev/null
+tmux new-session -d -s $SESSION -n daemon  "cd $ROOT && python3 -m src.ide_kernel.daemon; bash"
+tmux new-window     -t $SESSION -n gateway "cd $ROOT && python3 -m flask --app src.ide_kernel.gateway run --port 5001; bash"
+tmux new-window     -t $SESSION -n healing "cd $ROOT && python3 -m src.loop.self_healing; bash"
+tmux new-window     -t $SESSION -n trainer "cd $ROOT && python3 -m src.loop.trainer; bash"
+tmux new-window     -t $SESSION -n dream   "cd $ROOT && python3 -m src.loop.dream; bash"
+tmux new-window     -t $SESSION -n shell   "cd $ROOT; bash"
+
+echo ""
+echo "[+] ALL SYSTEMS ONLINE"
+echo "[+] Dashboard  → http://localhost:5001"
+echo "[+] Daemon     → task execution + resonance learning"
+echo "[+] Gateway    → REST API"
+echo "[+] Healer     → failure recovery"
+echo "[+] Trainer    → pattern learning"
+echo "[+] Dream      → memory consolidation"
+echo ""
+sleep 2
+tmux attach -t $SESSION