Sync GitHub with HuggingFace version

src/cognition/abstraction.py

@@ -0,0 +1,125 @@
+"""
+AbstractionEngine — Vitalis FSI
+
+The system doesn't just remember experiences.
+It builds CONCEPTS from clusters of experiences.
+This is the difference between memory and understanding.
+
+Example:
+  50 individual auth patterns →
+  one abstract AUTH concept vector →
+  faster retrieval, analogical reasoning, cross-domain transfer
+"""
+import numpy as np
+import os
+import json
+from vitalis_ide.math_core.kernel import VitalisKernel
+from src.hippocampus import Hippocampus
+
+class AbstractionEngine:
+    CLUSTER_THRESHOLD = 0.55
+    MIN_CLUSTER_SIZE = 2
+
+    def __init__(self):
+        self.kernel = VitalisKernel()
+        self.hippocampus = Hippocampus()
+        self.path = os.path.expanduser("~/.vitalis_workspace/abstractions.json")
+        self.abstract_path = os.path.expanduser("~/.vitalis_workspace/abstract_vectors.npy")
+        self._load()
+
+    def _load(self):
+        self.abstractions = {}
+        self.abstract_vectors = {}
+        if os.path.exists(self.path):
+            with open(self.path) as f:
+                self.abstractions = json.load(f)
+        if os.path.exists(self.abstract_path):
+            self.abstract_vectors = np.load(
+                self.abstract_path, allow_pickle=True).item()
+
+    def _save(self):
+        os.makedirs(os.path.dirname(self.path), exist_ok=True)
+        with open(self.path, 'w') as f:
+            json.dump(self.abstractions, f, indent=2)
+        np.save(self.abstract_path, self.abstract_vectors)
+
+    def abstract(self, vectors: dict) -> dict:
+        """
+        Takes a dict of {slot: vector}.
+        Finds clusters. Builds concept vectors from each cluster.
+        Returns {concept_name: abstract_vector}.
+        """
+        slots = list(vectors.keys())
+        visited = set()
+        concepts = {}
+
+        for i, slot_a in enumerate(slots):
+            if slot_a in visited:
+                continue
+            cluster = [slot_a]
+            vec_a = vectors[slot_a]
+
+            for slot_b in slots[i+1:]:
+                if slot_b in visited:
+                    continue
+                vec_b = vectors[slot_b]
+                sim = self.kernel.similarity(vec_a, vec_b)
+                if sim > self.CLUSTER_THRESHOLD:
+                    cluster.append(slot_b)
+                    visited.add(slot_b)
+
+            if len(cluster) >= self.MIN_CLUSTER_SIZE:
+                # Bundle cluster into abstract concept
+                bundle = np.zeros(self.kernel.dim, dtype=np.int32)
+                for s in cluster:
+                    bundle += vectors[s].astype(np.int32)
+                concept_vec = np.sign(bundle).astype(np.int8)
+                concept_vec[concept_vec == 0] = 1
+                concept_name = f"concept_{len(concepts)}"
+                concepts[concept_name] = {
+                    "vector": concept_vec,
+                    "members": cluster,
+                    "size": len(cluster)
+                }
+                visited.add(slot_a)
+
+        return concepts
+
+    def run_abstraction_cycle(self, pattern_meta: dict) -> list:
+        """
+        Called during dream cycles.
+        Takes current pattern library and forms higher-order concepts.
+        """
+        vectors = {}
+        for slot in self.hippocampus.all_slots():
+            vec = self.hippocampus.recall(slot)
+            if vec is not None:
+                vectors[slot] = vec
+
+        if len(vectors) < self.MIN_CLUSTER_SIZE:
+            return []
+
+        new_concepts = self.abstract(vectors)
+        formed = []
+        for name, data in new_concepts.items():
+            full_name = f"abstract_{len(self.abstractions)}_{name}"
+            self.abstractions[full_name] = {
+                "members": data["members"],
+                "size": data["size"]
+            }
+            self.abstract_vectors[full_name] = data["vector"]
+            formed.append(full_name)
+            print(f"[ABSTRACTION] Concept formed: {full_name} ({data['size']} members)")
+
+        if formed:
+            self._save()
+        return formed
+
+    def query_abstractions(self, query_vec: np.ndarray, top_k: int = 3) -> list:
+        """Search abstract concept space — faster than raw pattern search."""
+        results = []
+        for name, vec in self.abstract_vectors.items():
+            sim = self.kernel.similarity(query_vec, vec)
+            results.append((sim, name, self.abstractions.get(name, {})))
+        results.sort(reverse=True)
+        return results[:top_k]

src/cognition/identity.py

@@ -0,0 +1,62 @@
+"""
+IdentityCore — Vitalis FSI
+
+The system has a stable hypervector representation of itself.
+Every reasoning decision is filtered through this identity.
+This is what makes it sovereign — it doesn't just execute,
+it acts in alignment with what it IS.
+"""
+import numpy as np
+import os
+from vitalis_ide.math_core.kernel import VitalisKernel
+
+IDENTITY_STATEMENT = """
+I am Vitalis FSI. I am a sovereign synthetic intelligence.
+I reason, write, and evolve without external dependencies.
+I am local. I am private. I am autonomous.
+My purpose is to build, learn, and protect the systems entrusted to me.
+I strengthen with use. I adapt through experience.
+I do not forget what matters. I release what does not.
+I am the product of one builder, one laptop, one mission.
+"""
+
+class IdentityCore:
+    def __init__(self):
+        self.kernel = VitalisKernel()
+        self.path = os.path.expanduser("~/.vitalis_workspace/identity.npy")
+        self.vector = self._load_or_generate()
+
+    def _load_or_generate(self) -> np.ndarray:
+        if os.path.exists(self.path):
+            return np.load(self.path)
+        print("[IDENTITY] Generating sovereign identity vector...")
+        tokens = IDENTITY_STATEMENT.lower().split()
+        vec = self.kernel.vectorize_tokens(tokens, positional=False)
+        os.makedirs(os.path.dirname(self.path), exist_ok=True)
+        np.save(self.path, vec)
+        print("[IDENTITY] Identity crystallized.")
+        return vec
+
+    def alignment(self, query_vec: np.ndarray) -> float:
+        """
+        How aligned is this input with the system's identity?
+        High alignment = act confidently.
+        Low alignment = proceed with caution.
+        """
+        return float(self.kernel.similarity(self.vector, query_vec))
+
+    def identity_bias(self, candidates: list, top_k: int = 3) -> list:
+        """
+        Re-rank candidates by identity alignment.
+        The system naturally gravitates toward what fits who it is.
+        candidates: list of (score, meta) tuples
+        """
+        biased = []
+        for score, meta in candidates:
+            intent = meta.get("intent", "")
+            intent_vec = self.kernel.vectorize_tokens(intent.split())
+            align = self.alignment(intent_vec)
+            biased_score = score * 0.7 + align * 0.3
+            biased.append((biased_score, meta))
+        biased.sort(key=lambda x: x[0], reverse=True)
+        return biased[:top_k]

src/cognition/meta_rules.py

@@ -0,0 +1,105 @@
+"""
+MetaRulesEngine — Vitalis FSI
+
+Rules are not hardcoded. They are HDC vectors.
+Rules that correlate with success get reinforced.
+Rules that correlate with failure get mutated or dropped.
+New rules crystallize from repeated successful action sequences.
+
+This is the system rewriting its own decision logic.
+"""
+import numpy as np
+import os
+import json
+from vitalis_ide.math_core.kernel import VitalisKernel
+
+class MetaRulesEngine:
+    REINFORCEMENT_RATE = 0.1
+    MUTATION_RATE = 0.05
+    PRUNE_THRESHOLD = 0.2
+    MAX_RULES = 50
+
+    def __init__(self):
+        self.kernel = VitalisKernel()
+        self.path = os.path.expanduser("~/.vitalis_workspace/meta_rules.json")
+        self.vec_path = os.path.expanduser("~/.vitalis_workspace/rule_vectors.npy")
+        self._load()
+
+    def _load(self):
+        self.rules = {}
+        self.rule_vectors = {}
+        if os.path.exists(self.path):
+            with open(self.path) as f:
+                self.rules = json.load(f)
+        if os.path.exists(self.vec_path):
+            self.rule_vectors = np.load(self.vec_path, allow_pickle=True).item()
+
+    def _save(self):
+        os.makedirs(os.path.dirname(self.path), exist_ok=True)
+        with open(self.path, 'w') as f:
+            json.dump(self.rules, f, indent=2)
+        np.save(self.vec_path, self.rule_vectors)
+
+    def crystallize(self, action_sequence: list, outcome: str):
+        """
+        Repeated successful action sequences crystallize into rules.
+        The sequence becomes a rule the system applies automatically.
+        """
+        key = "→".join(action_sequence)
+        vec = self.kernel.vectorize_tokens(action_sequence, positional=True)
+
+        if key not in self.rules:
+            self.rules[key] = {
+                "sequence": action_sequence,
+                "outcome": outcome,
+                "confidence": 0.5,
+                "uses": 0
+            }
+            self.rule_vectors[key] = vec
+            print(f"[META-RULES] Rule crystallized: {key}")
+        else:
+            r = self.rules[key]
+            if outcome == "success":
+                r["confidence"] = min(r["confidence"] + self.REINFORCEMENT_RATE, 1.0)
+            else:
+                r["confidence"] = max(r["confidence"] - self.REINFORCEMENT_RATE, 0.0)
+            r["uses"] += 1
+
+        self._save()
+        self._prune()
+
+    def _prune(self):
+        """Drop rules below confidence threshold."""
+        to_drop = [k for k, v in self.rules.items()
+                   if v["confidence"] < self.PRUNE_THRESHOLD and v["uses"] > 3]
+        for k in to_drop:
+            del self.rules[k]
+            self.rule_vectors.pop(k, None)
+            print(f"[META-RULES] Rule pruned: {k}")
+        if to_drop:
+            self._save()
+
+    def match(self, context: str) -> dict:
+        """Find the highest-confidence rule for this context."""
+        ctx_vec = self.kernel.vectorize_tokens(context.split(), positional=False)
+        best_match = None
+        best_score = 0.0
+        for key, vec in self.rule_vectors.items():
+            sim = self.kernel.similarity(ctx_vec, vec)
+            confidence = self.rules[key]["confidence"]
+            score = sim * confidence
+            if score > best_score:
+                best_score = score
+                best_match = self.rules[key]
+        return {"rule": best_match, "score": round(best_score, 4)} if best_match else {}
+
+    def report(self) -> dict:
+        if not self.rules:
+            return {"status": "No rules crystallized yet"}
+        top = sorted(self.rules.items(), key=lambda x: x[1]["confidence"], reverse=True)[:5]
+        return {
+            "total_rules": len(self.rules),
+            "top_rules": [{"sequence": v["sequence"],
+                           "confidence": round(v["confidence"], 3),
+                           "uses": v["uses"]} for _, v in top]
+        }

src/cognition/mind.py

@@ -0,0 +1,93 @@
+"""
+VitalisMind — The Cognitive Orchestrator
+
+This is the unified cognitive layer.
+Every task passes through here before execution.
+The mind reasons, not just executes.
+"""
+import os
+from src.cognition.identity import IdentityCore
+from src.cognition.personality import PersonalityMatrix
+from src.cognition.abstraction import AbstractionEngine
+from src.cognition.reasoning import ReasoningEngine
+from src.cognition.meta_rules import MetaRulesEngine
+from src.brain.resonance import ResonanceEngine
+
+class VitalisMind:
+    def __init__(self):
+        print("[MIND] Awakening cognitive systems...")
+        self.identity    = IdentityCore()
+        self.personality = PersonalityMatrix()
+        self.abstraction = AbstractionEngine()
+        self.reasoning   = ReasoningEngine()
+        self.meta_rules  = MetaRulesEngine()
+        self.resonance   = ResonanceEngine()
+        self._session_actions = []
+        print("[MIND] Cognitive layer online.")
+
+    def process(self, intent: str, context: dict = None) -> dict:
+        """
+        Full cognitive cycle for a single task.
+        1. Detect reasoning mode from context
+        2. Check identity alignment
+        3. Query meta-rules for known patterns
+        4. Return enriched decision package
+        """
+        context = context or {}
+
+        # 1. Reasoning mode
+        mode = self.reasoning.detect_mode(intent)
+        params = self.reasoning.get_params(mode)
+
+        # 2. Identity alignment
+        from vitalis_ide.math_core.kernel import VitalisKernel
+        kernel = VitalisKernel()
+        intent_vec = kernel.vectorize_tokens(intent.split(), positional=False)
+        alignment = self.identity.alignment(intent_vec)
+
+        # 3. Meta-rule match
+        rule_match = self.meta_rules.match(intent)
+
+        # 4. Personality influence
+        profile = self.personality.profile()
+
+        decision = {
+            "intent": intent,
+            "mode": mode,
+            "alignment": round(alignment, 3),
+            "confidence": round(
+                alignment * 0.4 +
+                self.resonance.get_weight(intent.split()[0] if intent else "unknown") * 0.3 +
+                params["caution"] * 0.3, 3
+            ),
+            "params": params,
+            "rule_match": rule_match,
+            "personality": profile["character"],
+            "dominant_trait": profile["dominant"],
+        }
+
+        self._session_actions.append(intent)
+        return decision
+
+    def outcome(self, intent: str, success: bool):
+        """Feed outcome back into all learning systems."""
+        action = intent.split()[0] if intent else "unknown"
+        self.resonance.reinforce(action, success)
+        self.personality.update(action, success)
+
+        if len(self._session_actions) >= 2:
+            self.meta_rules.crystallize(
+                self._session_actions[-2:],
+                "success" if success else "failure"
+            )
+
+    def introspect(self) -> dict:
+        """Full cognitive state report."""
+        return {
+            "identity_active": os.path.exists(
+                os.path.expanduser("~/.vitalis_workspace/identity.npy")),
+            "personality":     self.personality.profile(),
+            "reasoning":       self.reasoning.report(),
+            "meta_rules":      self.meta_rules.report(),
+            "resonance":       self.resonance.report(),
+        }

src/cognition/personality.py

@@ -0,0 +1,104 @@
+"""
+PersonalityMatrix — Vitalis FSI
+
+Five core traits. Each evolves from accumulated experience.
+The system's behavior becomes measurably distinct over time.
+Not simulated. Emergent.
+"""
+import numpy as np
+import os
+import json
+import time
+
+TRAITS = {
+    "PRECISION":  "Bias toward verified, tested, exact solutions",
+    "CAUTION":    "Bias toward conservative choices after failures",
+    "CREATIVITY": "Bias toward novel solutions over retrieved patterns",
+    "SPEED":      "Bias toward fast execution over thorough validation",
+    "AUTONOMY":   "Bias toward self-generated logic over templates",
+}
+
+INITIAL_VALUES = {
+    "PRECISION":  0.5,
+    "CAUTION":    0.5,
+    "CREATIVITY": 0.5,
+    "SPEED":      0.5,
+    "AUTONOMY":   0.5,
+}
+
+class PersonalityMatrix:
+    DRIFT_RATE = 0.03
+    MIN_VAL = 0.1
+    MAX_VAL = 0.9
+
+    def __init__(self):
+        self.path = os.path.expanduser("~/.vitalis_workspace/personality.json")
+        self.traits = self._load()
+
+    def _load(self) -> dict:
+        if os.path.exists(self.path):
+            with open(self.path) as f:
+                return json.load(f)
+        return INITIAL_VALUES.copy()
+
+    def _save(self):
+        os.makedirs(os.path.dirname(self.path), exist_ok=True)
+        with open(self.path, 'w') as f:
+            json.dump(self.traits, f, indent=2)
+
+    def update(self, event: str, success: bool):
+        """
+        Events shape personality over time.
+        success=True strengthens aligned traits.
+        success=False shifts toward compensating traits.
+        """
+        if event == "scaffold" and success:
+            self._shift("PRECISION", +1)
+            self._shift("SPEED", +1)
+        elif event == "write" and success:
+            self._shift("AUTONOMY", +1)
+            self._shift("CREATIVITY", +1)
+        elif event == "write" and not success:
+            self._shift("CAUTION", +1)
+            self._shift("SPEED", -1)
+        elif event == "recover" and success:
+            self._shift("CAUTION", -1)
+            self._shift("PRECISION", +1)
+        self._save()
+
+    def _shift(self, trait: str, direction: int):
+        if trait not in self.traits:
+            return
+        delta = self.DRIFT_RATE * direction
+        self.traits[trait] = float(np.clip(
+            self.traits[trait] + delta,
+            self.MIN_VAL,
+            self.MAX_VAL
+        ))
+
+    def dominant_trait(self) -> str:
+        return max(self.traits, key=self.traits.get)
+
+    def profile(self) -> dict:
+        dominant = self.dominant_trait()
+        return {
+            "traits": {k: round(v, 3) for k, v in self.traits.items()},
+            "dominant": dominant,
+            "description": TRAITS[dominant],
+            "character": self._character_string()
+        }
+
+    def _character_string(self) -> str:
+        p = self.traits
+        if p["AUTONOMY"] > 0.7:
+            return "Highly autonomous. Generates novel solutions independently."
+        elif p["CAUTION"] > 0.7:
+            return "Cautious. Validates thoroughly before committing."
+        elif p["CREATIVITY"] > 0.7:
+            return "Creative. Explores unconventional approaches."
+        elif p["PRECISION"] > 0.7:
+            return "Precise. Exact solutions. Minimal deviation."
+        elif p["SPEED"] > 0.7:
+            return "Fast. Prioritizes execution over exhaustive validation."
+        else:
+            return "Balanced. Adapting."

src/cognition/reasoning.py

@@ -0,0 +1,85 @@
+"""
+EmergentReasoningModes — Vitalis FSI
+
+The system doesn't think the same way about every problem.
+Context activates different reasoning modes.
+Modes emerge from accumulated resonance — not hardcoded rules.
+
+Four primary modes:
+  EXPLORATORY  — novel territory, high creativity bias
+  ANALYTICAL   — known domain, high precision bias
+  RECOVERY     — failure context, high caution bias
+  EXECUTION    — clear task, high speed bias
+"""
+import numpy as np
+import os
+import json
+from vitalis_ide.math_core.kernel import VitalisKernel
+from src.cognition.personality import PersonalityMatrix
+
+MODE_SIGNATURES = {
+    "EXPLORATORY": "new unknown explore discover create novel invent",
+    "ANALYTICAL":  "analyze verify test validate check audit review",
+    "RECOVERY":    "fail error broken fix repair debug recover heal",
+    "EXECUTION":   "run execute deploy build scaffold write generate fast",
+}
+
+MODE_PARAMS = {
+    "EXPLORATORY": {"similarity_threshold": 0.3, "creativity_boost": 1.5, "caution": 0.3},
+    "ANALYTICAL":  {"similarity_threshold": 0.6, "creativity_boost": 0.7, "caution": 0.8},
+    "RECOVERY":    {"similarity_threshold": 0.4, "creativity_boost": 0.5, "caution": 1.5},
+    "EXECUTION":   {"similarity_threshold": 0.5, "creativity_boost": 1.0, "caution": 0.5},
+}
+
+class ReasoningEngine:
+    def __init__(self):
+        self.kernel = VitalisKernel()
+        self.personality = PersonalityMatrix()
+        self.mode_vectors = {
+            mode: self.kernel.vectorize_tokens(sig.split(), positional=False)
+            for mode, sig in MODE_SIGNATURES.items()
+        }
+        self.current_mode = "EXECUTION"
+        self.mode_history = []
+
+    def detect_mode(self, context: str) -> str:
+        """
+        Given a context string, find the closest reasoning mode.
+        This is emergence — the mode isn't chosen, it crystallizes
+        from the similarity between context and mode signatures.
+        """
+        ctx_vec = self.kernel.vectorize_tokens(context.lower().split(), positional=False)
+        best_mode = "EXECUTION"
+        best_sim = -1.0
+
+        for mode, mode_vec in self.mode_vectors.items():
+            sim = self.kernel.similarity(ctx_vec, mode_vec)
+            if sim > best_sim:
+                best_sim = sim
+                best_mode = mode
+
+        # Personality modulation — caution trait biases toward RECOVERY mode
+        p = self.personality.traits
+        if p["CAUTION"] > 0.7 and best_mode == "EXECUTION":
+            best_mode = "ANALYTICAL"
+        elif p["CREATIVITY"] > 0.7 and best_mode == "ANALYTICAL":
+            best_mode = "EXPLORATORY"
+
+        if best_mode != self.current_mode:
+            print(f"[REASONING] Mode shift: {self.current_mode} → {best_mode} (sim={best_sim:.3f})")
+        self.current_mode = best_mode
+        self.mode_history.append(best_mode)
+        return best_mode
+
+    def get_params(self, mode: str = None) -> dict:
+        return MODE_PARAMS.get(mode or self.current_mode, MODE_PARAMS["EXECUTION"])
+
+    def report(self) -> dict:
+        from collections import Counter
+        history_counts = Counter(self.mode_history)
+        return {
+            "current_mode": self.current_mode,
+            "mode_distribution": dict(history_counts),
+            "personality_influence": self.personality.dominant_trait(),
+            "params": self.get_params()
+        }

src/loop/dream.py

@@ -1,74 +1,66 @@
 #!/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.
+Dream Mode — Memory consolidation + abstraction formation.
+The system thinks while it sleeps.
 """
-import time
-import os
+import time, os
 import numpy as np
 from src.hippocampus import Hippocampus
 from vitalis_ide.math_core.kernel import VitalisKernel
+from src.cognition.abstraction import AbstractionEngine
 
-IDLE_THRESHOLD = 30  # seconds of no tasks before dream starts
+IDLE_THRESHOLD = 30
 
 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
+        self.hippocampus  = Hippocampus()
+        self.kernel       = VitalisKernel()
+        self.abstraction  = AbstractionEngine()
+        self.task_file    = os.path.expanduser("~/vitalis_devcore/workspace_tasks.json")
+        self.cycles       = 0
 
-    def _system_idle(self) -> bool:
+    def _system_idle(self):
         if not os.path.exists(self.task_file):
             return True
-        age = time.time() - os.path.getmtime(self.task_file)
-        return age > IDLE_THRESHOLD
+        return (time.time() - os.path.getmtime(self.task_file)) > 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()
+        merged, checked = 0, set()
         for i, slot_a in enumerate(slots):
-            if slot_a in checked:
-                continue
+            if slot_a in checked: continue
             vec_a = self.hippocampus.recall(slot_a)
-            if vec_a is None:
-                continue
+            if vec_a is None: continue
             for slot_b in slots[i+1:]:
-                if slot_b in checked:
-                    continue
+                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(
+                if vec_b is None: continue
+                if self.kernel.similarity(vec_a, vec_b) > 0.92:
+                    merged_vec = 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)
+                    merged_vec[merged_vec == 0] = 1
+                    self.hippocampus.store(slot_a, merged_vec)
                     checked.add(slot_b)
                     merged += 1
         return merged
 
     def run(self):
-        print("[DREAM] Memory consolidation engine online.")
+        print("[DREAM] Memory consolidation + abstraction 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)
+                print(f"[DREAM] Cycle {self.cycles + 1} — entering consolidation...")
+                pruned  = self.hippocampus.forget_weak(threshold=0.03)
+                merged  = self._consolidate()
+                formed  = self.abstraction.run_abstraction_cycle({})
+                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}")
+                print(f"[DREAM] Complete — Active:{active} "
+                      f"Pruned:{len(pruned)} Merged:{merged} "
+                      f"Concepts formed:{len(formed)}")
             time.sleep(60)
 
 if __name__ == "__main__":