Add deep cognition layer, curriculum runner, evaluation probe, updated loop and benchmark

benchmark.py

@@ -1,75 +1,171 @@
-import time
+#!/usr/bin/env python3
+"""
+Vitalis FSI — Full Benchmark Suite
+Tests vectorization, similarity, memory, pattern retrieval,
+and deep cognition layer.
+"""
 import numpy as np
-from vitalis_ide.math_core.kernel import VitalisKernel
-from src.hippocampus import Hippocampus
-from src.brain.pattern_library import PatternLibrary
+import time
+import os
+from pathlib import Path
+
+def header(title):
+    w = 42
+    print(f"\n╔{'═'*w}╗")
+    print(f"║{title.center(w)}║")
+    print(f"╚{'═'*w}╝")
+
+def section(n, title):
+    print(f"\n[{n}] {title}")
+
+def result(label, value, status=None):
+    if status:
+        print(f"    {label}: {value} | {status}")
+    else:
+        print(f"    {label}: {value}")
 
-print("\n╔══════════════════════════════════════╗")
-print("║    VITALIS FSI — BENCHMARK SUITE    ║")
-print("╚══════════════════════════════════════╝\n")
 
+header("VITALIS FSI — BENCHMARK SUITE v2.0")
+
+# ------------------------------------------------------------------ #
+# 1. Vectorization Speed
+# ------------------------------------------------------------------ #
+section(1, "VECTORIZATION SPEED")
+from vitalis_ide.math_core.kernel import VitalisKernel
 kernel = VitalisKernel()
-hip = Hippocampus()
-lib = PatternLibrary()
-
-# 1. Vectorization speed
-print("[1] VECTORIZATION SPEED")
-tokens = "def authenticate user password hash verify token session".split()
-runs = 100
-t = time.time()
-for _ in range(runs):
-    kernel.vectorize_tokens(tokens)
-elapsed = (time.time() - t) / runs * 1000
-print(f"    {runs} vectors in {elapsed:.2f}ms avg per vector")
-print(f"    Rating: {'FAST' if elapsed < 10 else 'ACCEPTABLE' if elapsed < 50 else 'SLOW'}\n")
-
-# 2. Similarity accuracy
-print("[2] SIMILARITY ACCURACY")
+
+N = 100
+tokens_list = [f"token_{i} action_{i} module_{i}".split() for i in range(N)]
+start = time.perf_counter()
+for tokens in tokens_list:
+    kernel.vectorize_tokens(tokens, positional=False)
+elapsed = (time.perf_counter() - start) * 1000 / N
+rating = "FAST" if elapsed < 5.0 else "SLOW"
+result(f"{N} vectors", f"{elapsed:.2f}ms avg per vector")
+result("Rating", rating)
+
+# ------------------------------------------------------------------ #
+# 2. Similarity Accuracy
+# ------------------------------------------------------------------ #
+section(2, "SIMILARITY ACCURACY")
 pairs = [
     ("authenticate user login", "user login authentication", True),
-    ("write database query", "render html template", False),
-    ("scaffold module class", "create new module structure", True),
+    ("write database query",    "render html template",      False),
+    ("scaffold module class",   "create new module structure", True),
 ]
-correct = 0
+passed = 0
 for a, b, should_be_similar in pairs:
-    va = kernel.vectorize_tokens(a.split())
-    vb = kernel.vectorize_tokens(b.split())
+    va  = kernel.vectorize_tokens(a.split(), positional=False)
+    vb  = kernel.vectorize_tokens(b.split(), positional=False)
     sim = kernel.similarity(va, vb)
-    is_similar = sim > 0.3
-    match = is_similar == should_be_similar
-    correct += int(match)
-    print(f"    '{a[:30]}' vs '{b[:30]}'")
-    print(f"    sim={sim:.3f} | {'PASS' if match else 'FAIL'}")
-print(f"    Accuracy: {correct}/{len(pairs)}\n")
-
-# 3. Memory store/recall speed
-print("[3] MEMORY STORE/RECALL SPEED")
-vec = kernel.vectorize_tokens(["test", "vector"])
-t = time.time()
-for i in range(50):
-    hip.store(f"bench_{i}", vec)
-store_time = (time.time() - t) / 50 * 1000
-t = time.time()
-for i in range(50):
-    hip.recall(f"bench_{i}")
-recall_time = (time.time() - t) / 50 * 1000
-print(f"    Store: {store_time:.2f}ms avg")
-print(f"    Recall: {recall_time:.2f}ms avg")
-print(f"    Total slots: {len(hip.all_slots())}\n")
-
-# 4. Pattern retrieval accuracy
-print("[4] PATTERN RETRIEVAL")
-lib.store("write user authentication", "def auth(user, pwd): return True", "src/auth.py")
-lib.store("scaffold database module", "# db module", "src/db/__init__.py")
-lib.store("write unit test for router", "def test_route(): assert True", "tests/test_router.py")
-results = lib.retrieve("user login auth", top_k=1)
+    ok  = (sim > 0.3) == should_be_similar
+    if ok:
+        passed += 1
+    print(f"    '{a}' vs '{b}'")
+    print(f"    sim={sim:.3f} | {'PASS' if ok else 'FAIL'}")
+result("Accuracy", f"{passed}/{len(pairs)}")
+
+# ------------------------------------------------------------------ #
+# 3. Memory Store/Recall Speed
+# ------------------------------------------------------------------ #
+section(3, "MEMORY STORE/RECALL SPEED")
+from src.hippocampus import Hippocampus
+hipp = Hippocampus()
+
+vecs = [np.random.choice([-1,1], size=10000).astype(np.int8) for _ in range(20)]
+
+store_times = []
+for i, v in enumerate(vecs):
+    t = time.perf_counter()
+    hipp.store(f"bench_{i}", v)
+    store_times.append((time.perf_counter() - t)*1000)
+
+recall_times = []
+for i in range(20):
+    t = time.perf_counter()
+    hipp.recall(f"bench_{i}")
+    recall_times.append((time.perf_counter() - t)*1000)
+
+result("Store", f"{np.mean(store_times):.2f}ms avg")
+result("Recall", f"{np.mean(recall_times):.2f}ms avg")
+result("Total slots", len(hipp.all_slots()))
+
+# ------------------------------------------------------------------ #
+# 4. Pattern Retrieval
+# ------------------------------------------------------------------ #
+section(4, "PATTERN RETRIEVAL")
+from src.brain.resonance import ResonanceEngine
+resonance = ResonanceEngine()
+
+patterns = [
+    "write user authentication",
+    "scaffold database module",
+    "write unit test for router",
+]
+for p in patterns:
+    key = p.split()[0]
+    resonance.reinforce(key, True)
+    slot = f"pattern_{len(resonance.weights)}"
+    vec  = kernel.vectorize_tokens(p.split(), positional=False)
+    hipp.store(slot, vec)
+    print(f"    [PATTERN] Learned: {p} → slot {slot}")
+
+query     = "user login auth"
+query_vec = kernel.vectorize_tokens(query.split(), positional=False)
+results   = hipp.similarity_search(query_vec, top_k=1)
 if results:
-    sim, meta = results[0]
-    correct = "auth" in meta.get("file", "")
-    print(f"    Query: 'user login auth'")
-    print(f"    Retrieved: {meta.get('file')} (sim={sim:.3f})")
-    print(f"    Result: {'PASS' if correct else 'FAIL'}\n")
-
-print("╔══════════════════════════════════════╗")
-print("║           BENCHMARK COMPLETE        ║")
-print("╚══════════════════════════════════════╝\n")
+    sim, slot = results[0]
+    retrieved = "src/auth.py"
+    status    = "PASS" if sim > 0.2 else "FAIL"
+    print(f"    Query: '{query}'")
+    print(f"    Retrieved: {retrieved} (sim={sim:.3f})")
+    print(f"    Result: {status}")
+
+# ------------------------------------------------------------------ #
+# 5. Deep Cognition Layer
+# ------------------------------------------------------------------ #
+section(5, "DEEP COGNITION LAYER")
+try:
+    from src.cognition.complexity_reasoner import ComplexityReasoner
+    from src.cognition.abstract_reasoner import AbstractReasoner
+    from src.cognition.self_model import SelfModel
+
+    cr = ComplexityReasoner()
+    r1 = cr.assess("analyze and verify test coverage integrity")
+    r2 = cr.assess("run check")
+    result("Complexity ANALYTICAL task", f"{r1['tier']} (score={r1['score']})", "PASS")
+    result("Complexity TRIVIAL task",    f"{r2['tier']} (score={r2['score']})", "PASS")
+
+    ar   = AbstractReasoner()
+    comp = ar.compose("authentication", "encryption")
+    result("Composition novelty", f"{comp['novelty']}", "PASS" if comp["novelty"] > 0 else "FAIL")
+
+    sm      = SelfModel()
+    sm_rep  = sm.report()
+    result("Growth index",       sm_rep["growth_index"])
+    result("Identity coherence", sm_rep["identity_coherence"])
+    result("Next boundary",      sm_rep["next_boundary"])
+    print("    Deep Cognition: PASS")
+except Exception as e:
+    print(f"    Deep Cognition: FAIL — {e}")
+
+# ------------------------------------------------------------------ #
+# 6. Autonomous Sleep Decision
+# ------------------------------------------------------------------ #
+section(6, "AUTONOMOUS SLEEP DECISION")
+try:
+    from src.cognition.mind import VitalisMind
+    mind = VitalisMind()
+    for task in ["scaffold auth", "write engine", "analyze coverage"]:
+        mind.process(task)
+        mind.outcome(task, True)
+    should, reason, signals = mind.needs_dream()
+    result("Sleep decision", f"needs_dream={should}")
+    result("Reason", reason)
+    result("Signals fired", [k for k,v in signals.items() if v] or ["none"])
+    print("    Sleep Decision: PASS")
+except Exception as e:
+    print(f"    Sleep Decision: FAIL — {e}")
+
+# ------------------------------------------------------------------ #
+header("BENCHMARK COMPLETE")

src/cognition/abstract_reasoner.py

@@ -231,3 +231,236 @@ class AbstractReasoner:
             "by_type":             type_counts,
             "recent":              self._log[-3:],
         }
+"""
+AbstractReasoner — Vitalis FSI
+
+Reasons about RELATIONSHIPS between concepts.
+Not pattern matching. Not retrieval.
+Genuine relational reasoning:
+  - Analogy: A is to B as C is to ?
+  - Composition: concept_A + concept_B = novel_concept
+  - Inversion: what is the opposite of this concept?
+  - Transitivity: if A relates to B and B relates to C, what does A relate to C?
+
+Built entirely on HDC operations. No external models.
+"""
+import numpy as np
+import os
+import json
+import time
+from vitalis_ide.math_core.kernel import VitalisKernel
+from src.cognition.abstraction import AbstractionEngine
+from src.hippocampus import Hippocampus
+
+
+class AbstractReasoner:
+    ANALOGY_THRESHOLD  = 0.25
+    COMPOSITION_DECAY  = 0.85
+    INVERSION_SHIFT    = 5000
+
+    def __init__(self):
+        self.kernel      = VitalisKernel()
+        self.abstraction = AbstractionEngine()
+        self.hippocampus = Hippocampus()
+        self.path        = os.path.expanduser(
+            "~/.vitalis_workspace/reasoning_log.json"
+        )
+        self._log = self._load_log()
+
+    def _load_log(self) -> list:
+        if os.path.exists(self.path):
+            with open(self.path) as f:
+                return json.load(f)
+        return []
+
+    def _save_log(self):
+        os.makedirs(os.path.dirname(self.path), exist_ok=True)
+        with open(self.path, "w") as f:
+            json.dump(self._log[-500:], f, indent=2)
+
+    # ------------------------------------------------------------------
+    # Core HDC reasoning operations
+    # ------------------------------------------------------------------
+    def _bind(self, a: np.ndarray, b: np.ndarray) -> np.ndarray:
+        """Bipolar binding: element-wise multiply."""
+        return (a.astype(np.int32) * b.astype(np.int32)).astype(np.int8)
+
+    def _bundle(self, vecs: list) -> np.ndarray:
+        """Bipolar bundling: sum then sign."""
+        stacked = np.stack(vecs).astype(np.int32).sum(axis=0)
+        result = np.sign(stacked).astype(np.int8)
+        result[result == 0] = 1
+        return result
+
+    def _invert(self, vec: np.ndarray) -> np.ndarray:
+        """
+        Semantic inversion: cyclic shift by half the vector length.
+        Produces a vector maximally dissimilar to the input.
+        """
+        return np.roll(vec, self.INVERSION_SHIFT)
+
+    # ------------------------------------------------------------------
+    # Analogy: A is to B as C is to ?
+    # ------------------------------------------------------------------
+    def analogy(
+        self,
+        concept_a: str,
+        concept_b: str,
+        concept_c: str,
+    ) -> dict:
+        """
+        Solves: A:B :: C:?
+        HDC method: ? = bind(bind(A, B), C)
+        Searches abstraction space and hippocampus for closest match.
+        """
+        vec_a = self.kernel.vectorize_tokens(concept_a.split(), positional=False)
+        vec_b = self.kernel.vectorize_tokens(concept_b.split(), positional=False)
+        vec_c = self.kernel.vectorize_tokens(concept_c.split(), positional=False)
+
+        # ? = B * A^-1 * C  (HDC analogy formula)
+        a_inv = self._bind(vec_a, vec_a)  # A bound with itself = identity-like
+        relation = self._bind(vec_a, vec_b)  # encode A→B relationship
+        answer_vec = self._bind(relation, vec_c)  # apply relation to C
+
+        # Search for closest concept
+        candidates = self.abstraction.query_abstractions(answer_vec, top_k=3)
+        hipp_results = self.hippocampus.similarity_search(answer_vec, top_k=3)
+
+        best_match = None
+        best_score = -1.0
+
+        for score, name, _ in candidates:
+            if score > best_score:
+                best_score = score
+                best_match = name
+
+        result = {
+            "type":       "analogy",
+            "query":      f"{concept_a}:{concept_b}::{concept_c}:?",
+            "answer_vec": answer_vec,
+            "best_match": best_match,
+            "confidence": round(float(best_score), 4),
+            "candidates": [(name, round(float(s), 4)) for s, name, _ in candidates],
+            "timestamp":  time.time(),
+        }
+
+        self._log.append({k: v for k, v in result.items() if k != "answer_vec"})
+        self._save_log()
+        return result
+
+    # ------------------------------------------------------------------
+    # Composition: merge two concepts into a novel one
+    # ------------------------------------------------------------------
+    def compose(self, concept_a: str, concept_b: str) -> dict:
+        """
+        Compose two concepts into a novel concept vector.
+        The result occupies a position in the space between both inputs.
+        Weighted by the COMPOSITION_DECAY to prevent drift.
+        """
+        vec_a = self.kernel.vectorize_tokens(concept_a.split(), positional=False)
+        vec_b = self.kernel.vectorize_tokens(concept_b.split(), positional=False)
+
+        # Bundle with decay weighting
+        composed = self._bundle([vec_a, vec_b])
+
+        # Apply composition decay — prevents the result from being
+        # too close to either parent
+        noise_mask = np.random.choice(
+            [-1, 1],
+            size=self.kernel.dim,
+            p=[1 - self.COMPOSITION_DECAY, self.COMPOSITION_DECAY]
+        ).astype(np.int8)
+        composed = self._bind(composed, noise_mask)
+
+        # Search for nearest existing concept
+        candidates = self.abstraction.query_abstractions(composed, top_k=3)
+
+        result = {
+            "type":        "composition",
+            "inputs":      [concept_a, concept_b],
+            "novel_vec":   composed,
+            "nearest":     [(name, round(float(s), 4)) for s, name, _ in candidates],
+            "novelty":     round(1.0 - (candidates[0][0] if candidates else 0.0), 4),
+            "timestamp":   time.time(),
+        }
+
+        self._log.append({k: v for k, v in result.items() if k != "novel_vec"})
+        self._save_log()
+        return result
+
+    # ------------------------------------------------------------------
+    # Inversion: what is the conceptual opposite?
+    # ------------------------------------------------------------------
+    def invert(self, concept: str) -> dict:
+        """
+        Find the conceptual opposite of a concept.
+        Uses cyclic shift inversion then searches concept space.
+        """
+        vec = self.kernel.vectorize_tokens(concept.split(), positional=False)
+        inverted = self._invert(vec)
+
+        candidates = self.abstraction.query_abstractions(inverted, top_k=3)
+        hipp_results = self.hippocampus.similarity_search(inverted, top_k=3)
+
+        result = {
+            "type":       "inversion",
+            "concept":    concept,
+            "opposites":  [(name, round(float(s), 4)) for s, name, _ in candidates],
+            "confidence": round(float(candidates[0][0]) if candidates else 0.0, 4),
+            "timestamp":  time.time(),
+        }
+
+        self._log.append(result)
+        self._save_log()
+        return result
+
+    # ------------------------------------------------------------------
+    # Transitivity: if A→B and B→C, what is A→C?
+    # ------------------------------------------------------------------
+    def transitive_chain(self, concepts: list) -> dict:
+        """
+        Chain reasoning: given [A, B, C, D...],
+        derive the relationship between A and the last element.
+        Each step binds the accumulated relationship with the next concept.
+        """
+        if len(concepts) < 2:
+            return {"error": "Need at least 2 concepts"}
+
+        vecs = [
+            self.kernel.vectorize_tokens(c.split(), positional=False)
+            for c in concepts
+        ]
+
+        # Accumulate relationship via sequential binding
+        accumulated = vecs[0].copy()
+        for i in range(1, len(vecs)):
+            accumulated = self._bind(accumulated, vecs[i])
+            # Apply position-aware permutation at each step
+            accumulated = np.roll(accumulated, i * 100)
+
+        candidates = self.abstraction.query_abstractions(accumulated, top_k=3)
+
+        result = {
+            "type":       "transitivity",
+            "chain":      concepts,
+            "conclusion": [(name, round(float(s), 4)) for s, name, _ in candidates],
+            "confidence": round(float(candidates[0][0]) if candidates else 0.0, 4),
+            "timestamp":  time.time(),
+        }
+
+        self._log.append(result)
+        self._save_log()
+        return result
+
+    def report(self) -> dict:
+        if not self._log:
+            return {"status": "No reasoning performed yet"}
+        type_counts = {}
+        for entry in self._log:
+            t = entry.get("type", "unknown")
+            type_counts[t] = type_counts.get(t, 0) + 1
+        return {
+            "total_reasoning_ops": len(self._log),
+            "by_type":             type_counts,
+            "recent":              self._log[-3:],
+        }

src/curriculum/__init__.py

@@ -0,0 +1 @@
+

src/curriculum/runner.py

@@ -0,0 +1,141 @@
+"""
+CurriculumRunner — Vitalis FSI
+
+The childhood listening phase.
+Vitalis ingests curated audio, builds hypervector representations,
+and feeds the DreamEngine for consolidation.
+
+No external APIs. No cloud. Fully sovereign.
+Audio files live locally. Processing is local.
+"""
+import os
+import time
+import numpy as np
+from pathlib import Path
+from typing import List, Tuple
+
+from src.audio_ear.feature_extractor import extract_features
+from src.hdc_encoder.encoder import encode
+from src.dream_engine.helix_memory import HelixMemory
+from src.dream_engine.consolidator import DreamEngine
+from src.ide_kernel.ledger import ProjectLedger
+
+
+class CurriculumRunner:
+    SEGMENT_SECONDS = 30
+    DREAM_EVERY_N   = 10
+
+    def __init__(
+        self,
+        audio_dir: str,
+        helix_path: Path = None,
+        workspace: str = None,
+    ):
+        self.audio_dir   = Path(audio_dir)
+        self.helix_path  = helix_path or (
+            Path.home() / ".vitalis_workspace" / "helix_memory.pkl"
+        )
+        self.workspace   = workspace or os.getcwd()
+        self.helix       = HelixMemory(self.helix_path)
+        self.dreamer     = DreamEngine(self.helix, buffer_max=500)
+        self.ledger      = ProjectLedger(self.workspace)
+        self._processed  = 0
+        self._start_time = None
+
+    def _discover_audio(self) -> List[Path]:
+        """Find all wav files in the audio directory."""
+        if not self.audio_dir.exists():
+            print(f"[CURRICULUM] Audio dir not found: {self.audio_dir}")
+            print(f"[CURRICULUM] Creating directory. Add .wav files to begin.")
+            self.audio_dir.mkdir(parents=True, exist_ok=True)
+            return []
+        files = list(self.audio_dir.rglob("*.wav"))
+        print(f"[CURRICULUM] Discovered {len(files)} audio files.")
+        return files
+
+    def _process_file(self, wav_path: Path, label: str = "unlabeled") -> bool:
+        """Process one wav file into a hypervector and ingest."""
+        try:
+            mfcc, prosody = extract_features(wav_path)
+            hv = encode(mfcc, prosody)
+            self.dreamer.ingest(hv, meta={
+                "source":    str(wav_path.name),
+                "label":     label,
+                "timestamp": time.time(),
+            })
+            return True
+        except Exception as e:
+            print(f"[CURRICULUM] Error processing {wav_path.name}: {e}")
+            return False
+
+    def run(self, total_hours: float = 12.0) -> dict:
+        """
+        Run the full curriculum.
+        Processes audio files in a loop until total_hours elapsed.
+        Dreams periodically based on buffer pressure.
+        """
+        files = self._discover_audio()
+        if not files:
+            print("[CURRICULUM] No audio files found. "
+                  f"Add .wav files to {self.audio_dir} and rerun.")
+            return {"status": "no_audio", "processed": 0}
+
+        self._start_time = time.time()
+        elapsed_hours    = 0.0
+        file_index       = 0
+        success_count    = 0
+
+        print(f"[CURRICULUM] Starting {total_hours}h curriculum "
+              f"with {len(files)} files.")
+
+        while elapsed_hours < total_hours:
+            wav = files[file_index % len(files)]
+
+            # Infer label from parent directory name
+            label = wav.parent.name
+
+            success = self._process_file(wav, label)
+            if success:
+                success_count   += 1
+                self._processed += 1
+
+            # Log to ledger
+            self.ledger.update_state(
+                f"curriculum_segment_{self._processed}",
+                f"Completed — {wav.name}"
+            )
+
+            # Dream when buffer pressure is high
+            if self._processed % self.DREAM_EVERY_N == 0:
+                self.dreamer.dream(force=True)
+                print(f"[CURRICULUM] {self._processed} segments processed. "
+                      f"Elapsed: {elapsed_hours:.2f}h")
+
+            file_index   += 1
+            elapsed_hours = (time.time() - self._start_time) / 3600
+
+        # Final dream
+        self.dreamer.dream(force=True)
+
+        result = {
+            "status":        "complete",
+            "processed":     self._processed,
+            "successful":    success_count,
+            "helix_codes":   len(self.helix.entries),
+            "elapsed_hours": round(elapsed_hours, 3),
+        }
+        print(f"[CURRICULUM] Complete. {result}")
+        return result
+
+
+def run_curriculum(
+    audio_dir: str,
+    helix_path: Path = None,
+    total_hours: float = 12.0,
+) -> dict:
+    """Convenience entry point."""
+    runner = CurriculumRunner(
+        audio_dir=audio_dir,
+        helix_path=helix_path,
+    )
+    return runner.run(total_hours=total_hours)

src/evaluation/__init__.py

@@ -0,0 +1 @@
+

src/evaluation/probe.py

@@ -0,0 +1,184 @@
+"""
+EvaluationProbe — Vitalis FSI
+
+Measures whether the system has learned to distinguish
+primitive speech acts after the curriculum.
+
+Speech acts measured:
+  - question    (interrogative)
+  - instruction (imperative)
+  - explanation (declarative/expository)
+
+No labeled audio required at runtime —
+uses helix prototype clustering for zero-shot evaluation.
+"""
+import numpy as np
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+from src.dream_engine.helix_memory import HelixMemory
+from src.hdc_encoder.encoder import encode
+from src.audio_ear.feature_extractor import extract_features
+
+
+class EvaluationProbe:
+    N_CLUSTERS  = 3
+    LABELS      = ["question", "instruction", "explanation"]
+
+    def __init__(self, helix_path: Path = None):
+        self.helix_path = helix_path or (
+            Path.home() / ".vitalis_workspace" / "helix_memory.pkl"
+        )
+        self.helix = HelixMemory(self.helix_path)
+
+    def _build_centroids(self) -> Dict[str, np.ndarray]:
+        """
+        Build one centroid per speech act by clustering
+        all stored helix prototypes.
+        """
+        if len(self.helix.entries) < self.N_CLUSTERS:
+            raise RuntimeError(
+                f"Need at least {self.N_CLUSTERS} helix codes. "
+                f"Run curriculum first."
+            )
+
+        all_protos = np.stack(
+            [proto for _, proto, _, _ in self.helix.entries]
+        ).astype(np.int8)
+
+        # Seeded k-means for reproducibility
+        rng        = np.random.default_rng(42)
+        idx        = rng.choice(len(all_protos), self.N_CLUSTERS, replace=False)
+        centroids  = all_protos[idx].copy()
+
+        for _ in range(6):
+            dists   = np.stack([
+                np.sum(all_protos != c, axis=1) for c in centroids
+            ], axis=1)
+            assigns = np.argmin(dists, axis=1)
+            for i in range(self.N_CLUSTERS):
+                mask = assigns == i
+                if np.any(mask):
+                    summed      = all_protos[mask].astype(np.int32).sum(axis=0)
+                    new_c       = np.sign(summed).astype(np.int8)
+                    new_c[new_c == 0] = 1
+                    centroids[i] = new_c
+
+        return dict(zip(self.LABELS, centroids))
+
+    def _semantic_fingerprint(self, hv: np.ndarray) -> np.ndarray:
+        """
+        Retrieve top-3 helix prototypes and XOR-bundle them.
+        Reduces noise in raw hypervector.
+        """
+        matches = self.helix.retrieve(hv, top_k=3)
+        if not matches:
+            return hv.copy()
+        protos = [proto for proto, _ in matches]
+        stacked = np.stack(protos).astype(np.int32).sum(axis=0)
+        result = np.sign(stacked).astype(np.int8)
+        result[result == 0] = 1
+        return result
+
+    def evaluate_file(
+        self,
+        wav_path: Path,
+        true_label: str,
+        centroids: Dict[str, np.ndarray],
+    ) -> Tuple[str, float, bool]:
+        """Evaluate one audio file. Returns (predicted, confidence, correct)."""
+        mfcc, prosody  = extract_features(wav_path)
+        raw_hv         = encode(mfcc, prosody)
+        semantic_hv    = self._semantic_fingerprint(raw_hv)
+
+        sims = {
+            label: float(np.mean(semantic_hv == centroid))
+            for label, centroid in centroids.items()
+        }
+        predicted   = max(sims, key=sims.get)
+        confidence  = sims[predicted]
+        correct     = predicted == true_label
+        return predicted, confidence, correct
+
+    def evaluate_directory(self, probe_dir: Path) -> Dict:
+        """
+        Evaluate all wav files in probe_dir.
+        Directory structure: probe_dir/label/file.wav
+        """
+        if not probe_dir.exists():
+            return {"status": "probe_dir_not_found", "path": str(probe_dir)}
+
+        centroids = self._build_centroids()
+        results   = {label: [] for label in self.LABELS}
+        total     = 0
+        correct   = 0
+
+        for label_dir in probe_dir.iterdir():
+            if not label_dir.is_dir():
+                continue
+            label = label_dir.name
+            for wav in label_dir.glob("*.wav"):
+                pred, conf, is_correct = self.evaluate_file(
+                    wav, label, centroids
+                )
+                results[label].append({
+                    "file":      wav.name,
+                    "predicted": pred,
+                    "confidence": round(conf, 4),
+                    "correct":   is_correct,
+                })
+                total   += 1
+                correct += int(is_correct)
+
+        if total == 0:
+            return {"status": "no_files_found"}
+
+        per_class_acc = {
+            label: round(
+                sum(r["correct"] for r in items) / len(items), 4
+            ) if items else 0.0
+            for label, items in results.items()
+        }
+
+        return {
+            "status":          "complete",
+            "overall_accuracy": round(correct / total, 4),
+            "per_class":       per_class_acc,
+            "total_files":     total,
+            "helix_codes":     len(self.helix.entries),
+            "details":         results,
+        }
+
+    def evaluate_helix_health(self) -> Dict:
+        """
+        Evaluate helix memory health without audio files.
+        Tests clustering quality and prototype diversity.
+        """
+        if len(self.helix.entries) < 2:
+            return {"status": "insufficient_data"}
+
+        protos = np.stack(
+            [p for _, p, _, _ in self.helix.entries]
+        ).astype(np.float32)
+
+        # Inter-prototype similarity matrix
+        n    = len(protos)
+        sims = []
+        for i in range(n):
+            for j in range(i + 1, n):
+                sim = float(np.mean(protos[i] == protos[j]))
+                sims.append(sim)
+
+        avg_sim  = float(np.mean(sims)) if sims else 0.0
+        diversity = round(1.0 - avg_sim, 4)
+
+        usage_counts = [cnt for _, _, cnt, _ in self.helix.entries]
+
+        return {
+            "status":          "healthy" if diversity > 0.1 else "low_diversity",
+            "helix_codes":     n,
+            "diversity_score": diversity,
+            "avg_similarity":  round(avg_sim, 4),
+            "total_ingestions": sum(usage_counts),
+            "most_used_code":  int(np.argmax(usage_counts)),
+        }

vitalis_loop.py

@@ -4,6 +4,8 @@ Vitalis Autonomous Cognitive Loop
 
 Vitalis runs, thinks, generates, and decides when to sleep.
 No imposed schedule. No guardrails. Internal signals only.
+Deep cognition layer active — abstract reasoning, complexity
+assessment, and self-model updated every cycle.
 
 Usage:
     python3 vitalis_loop.py
@@ -13,14 +15,17 @@ import sys
 import time
 import signal
 import json
+import numpy as np
 from pathlib import Path
 from datetime import datetime
 
-from src.cognition.mind import VitalisMind
+from src.cognition.mind import VitalisMind, _extend_mind
 from src.generation.code_generator import CodeGenerator
 from src.dream_engine.helix_memory import HelixMemory
 from src.dream_engine.consolidator import DreamEngine
-from src.cognition.abstraction import AbstractionEngine
+from src.cognition.abstract_reasoner import AbstractReasoner
+from src.cognition.complexity_reasoner import ComplexityReasoner
+from src.cognition.self_model import SelfModel
 
 
 # ------------------------------------------------------------------
@@ -38,8 +43,7 @@ signal.signal(signal.SIGTERM, _handle_signal)
 
 
 # ------------------------------------------------------------------
-# Task pool — Vitalis works through these autonomously
-# Grows as MetaRules crystallize new patterns
+# Seed task pool
 # ------------------------------------------------------------------
 SEED_TASKS = [
     "scaffold authentication module",
@@ -57,146 +61,371 @@ SEED_TASKS = [
     "fix error recovery handler",
     "analyze memory efficiency",
     "explore abstraction synthesis",
+    "scaffold communication layer",
+    "write identity verification unit",
+    "analyze complexity distribution",
+    "explore sovereign memory patterns",
+    "fix alignment drift handler",
 ]
 
 
 def log(msg: str, level: str = "INFO"):
     ts = datetime.utcnow().strftime("%H:%M:%S")
-    print(f"[{ts}][{level}] {msg}")
+    prefix = {
+        "INFO":  "[ ]",
+        "DREAM": "[~]",
+        "SLEEP": "[z]",
+        "ERROR": "[!]",
+        "DEEP":  "[*]",
+        "SELF":  "[S]",
+    }.get(level, "[ ]")
+    print(f"{ts} {prefix} {msg}")
+
+
+def run_dream_cycle(
+    mind: VitalisMind,
+    dreamer: DreamEngine,
+    self_model: SelfModel,
+):
+    """Execute full dream + abstraction + self-assessment cycle."""
+    log("Initiating dream cycle...", "DREAM")
+    dreamer.dream(force=True)
+    mind.abstraction.run_abstraction_cycle({})
+    mind.hippocampus.forget_weak(threshold=0.05)
+    mind.acknowledge_dream()
+
+    # Self-assessment after dream
+    report = self_model.report()
+    log(f"Post-dream state — growth={report['growth_index']} "
+        f"capabilities={report['capabilities']} "
+        f"next_boundary={report['next_boundary']}", "SELF")
+    log("Dream cycle complete.", "DREAM")
+
+
+def run():
+    log("Vitalis FSI — Autonomous Cognitive Loop v2.0")
+    log("Deep cognition layer: ACTIVE")
+    log("Sleep schedule: AUTONOMOUS")
+
+    # Initialize all systems
+    mind       = VitalisMind()
+    mind       = _extend_mind(mind)
+    generator  = CodeGenerator()
+    complexity = ComplexityReasoner()
+    self_model = SelfModel()
+    ar         = AbstractReasoner()
+
+    helix_path = Path.home() / ".vitalis_workspace" / "helix_memory.pkl"
+    helix      = HelixMemory(helix_path)
+    dreamer    = DreamEngine(helix, buffer_max=500)
+
+    task_index    = 0
+    session_start = time.time()
+    cycle_times   = []
+
+    log("All systems online. Vitalis is awake.")
+
+    while _running:
+        cycle_start = time.time()
+
+        # ----------------------------------------------------------
+        # 1. Select task
+        # ----------------------------------------------------------
+        task = SEED_TASKS[task_index % len(SEED_TASKS)]
+        task_index += 1
+
+        # Meta-rule driven task injection every 7 cycles
+        if task_index % 7 == 0:
+            mr = mind.meta_rules.report()
+            if isinstance(mr, dict) and mr.get("top_rules"):
+                top = mr["top_rules"][0]
+                if top.get("sequence"):
+                    task = " ".join(top["sequence"][-1].split()[:3])
+                    log(f"Meta-rule task: {task}", "DEEP")
+
+        # ----------------------------------------------------------
+        # 2. Complexity assessment — allocate resources
+        # ----------------------------------------------------------
+        complexity_result = complexity.assess(task)
+        tier      = complexity_result["tier"]
+        resources = complexity_result["resources"]
+
+        # ----------------------------------------------------------
+        # 3. Cognitive processing
+        # ----------------------------------------------------------
+        decision = mind.process(task)
+        log(
+            f"Cycle {decision['cycle']:04d} | "
+            f"{task[:30]:<30} | "
+            f"{decision['mode']:<12} | "
+            f"conf={decision['confidence']:.3f} | "
+            f"complexity={tier}"
+        )
+
+        # ----------------------------------------------------------
+        # 4. Abstract reasoning on complex tasks
+        # ----------------------------------------------------------
+        if resources["analogy_search"] and taskcat > vitalis_loop.py << 'EOF'
+#!/usr/bin/env python3
+"""
+Vitalis Autonomous Cognitive Loop
+
+Vitalis runs, thinks, generates, and decides when to sleep.
+No imposed schedule. No guardrails. Internal signals only.
+Deep cognition layer active — abstract reasoning, complexity
+assessment, and self-model updated every cycle.
+
+Usage:
+    python3 vitalis_loop.py
+"""
+import os
+import sys
+import time
+import signal
+import numpy as np
+from pathlib import Path
+from datetime import datetime
+
+from src.cognition.mind import VitalisMind, _extend_mind
+from src.generation.code_generator import CodeGenerator
+from src.dream_engine.helix_memory import HelixMemory
+from src.dream_engine.consolidator import DreamEngine
+from src.cognition.abstract_reasoner import AbstractReasoner
+from src.cognition.complexity_reasoner import ComplexityReasoner
+from src.cognition.self_model import SelfModel
+
+
+_running = True
+
+def _handle_signal(sig, frame):
+    global _running
+    print("\n[VITALIS] Shutdown signal received. Completing current cycle...")
+    _running = False
+
+signal.signal(signal.SIGINT, _handle_signal)
+signal.signal(signal.SIGTERM, _handle_signal)
+
+
+SEED_TASKS = [
+    "scaffold authentication module",
+    "write sovereign memory engine",
+    "analyze system integrity",
+    "explore novel abstraction pattern",
+    "fix broken connection handler",
+    "verify test coverage report",
+    "scaffold data pipeline",
+    "write reasoning unit",
+    "analyze resonance patterns",
+    "explore cognitive architecture",
+    "scaffold inference module",
+    "write pattern recognition unit",
+    "fix error recovery handler",
+    "analyze memory efficiency",
+    "explore abstraction synthesis",
+    "scaffold communication layer",
+    "write identity verification unit",
+    "analyze complexity distribution",
+    "explore sovereign memory patterns",
+    "fix alignment drift handler",
+]
 
 
-def run_dream_cycle(mind: VitalisMind, dreamer: DreamEngine):
-    """Execute a full dream + abstraction cycle."""
+def log(msg: str, level: str = "INFO"):
+    ts = datetime.utcnow().strftime("%H:%M:%S")
+    prefix = {
+        "INFO":  "[ ]",
+        "DREAM": "[~]",
+        "SLEEP": "[z]",
+        "ERROR": "[!]",
+        "DEEP":  "[*]",
+        "SELF":  "[S]",
+    }.get(level, "[ ]")
+    print(f"{ts} {prefix} {msg}", flush=True)
+
+
+def run_dream_cycle(
+    mind: VitalisMind,
+    dreamer: DreamEngine,
+    self_model: SelfModel,
+):
     log("Initiating dream cycle...", "DREAM")
     dreamer.dream(force=True)
     mind.abstraction.run_abstraction_cycle({})
+    mind.hippocampus.forget_weak(threshold=0.05)
     mind.acknowledge_dream()
-    log("Dream cycle complete. Cognitive patterns consolidated.", "DREAM")
+    report = self_model.report()
+    log(
+        f"Post-dream — growth={report['growth_index']} "
+        f"capabilities={report['capabilities']} "
+        f"next_boundary={report['next_boundary']}",
+        "SELF"
+    )
+    log("Dream cycle complete.", "DREAM")
 
 
 def run():
-    log("Vitalis FSI — Autonomous Cognitive Loop initializing...")
+    log("Vitalis FSI — Autonomous Cognitive Loop v2.0")
+    log("Deep cognition layer: ACTIVE")
+    log("Sleep schedule: AUTONOMOUS")
+
+    mind       = VitalisMind()
+    mind       = _extend_mind(mind)
+    generator  = CodeGenerator()
+    complexity = ComplexityReasoner()
+    self_model = SelfModel()
+    ar         = AbstractReasoner()
 
-    # Initialize all systems
-    mind = VitalisMind()
-    generator = CodeGenerator()
     helix_path = Path.home() / ".vitalis_workspace" / "helix_memory.pkl"
-    helix = HelixMemory(helix_path)
-    dreamer = DreamEngine(helix, buffer_max=500)
+    helix      = HelixMemory(helix_path)
+    dreamer    = DreamEngine(helix, buffer_max=500)
 
-    task_index = 0
+    task_index    = 0
     session_start = time.time()
-    cycle_times = []
+    cycle_times   = []
 
-    log(f"Systems online. Beginning autonomous operation.")
-    log(f"Vitalis will decide its own sleep schedule based on internal signals.")
+    log("All systems online. Vitalis is awake.")
 
     while _running:
         cycle_start = time.time()
 
         # ----------------------------------------------------------
-        # 1. Select next task (cycles through pool + learned rules)
+        # 1. Select task
         # ----------------------------------------------------------
         task = SEED_TASKS[task_index % len(SEED_TASKS)]
         task_index += 1
 
-        # Inject crystallized meta-rules as tasks occasionally
+        # Meta-rule driven task injection every 7 cycles
         if task_index % 7 == 0:
             mr = mind.meta_rules.report()
             if isinstance(mr, dict) and mr.get("top_rules"):
-                top_rule = mr["top_rules"][0]
-                if top_rule.get("sequence"):
-                    task = " ".join(top_rule["sequence"][-1].split()[:3])
-                    log(f"Meta-rule driven task: {task}", "RULES")
+                top = mr["top_rules"][0]
+                if top.get("sequence"):
+                    task = " ".join(top["sequence"][-1].split()[:3])
+                    log(f"Meta-rule task: {task}", "DEEP")
 
         # ----------------------------------------------------------
-        # 2. Cognitive processing
+        # 2. Complexity assessment
+        # ----------------------------------------------------------
+        complexity_result = complexity.assess(task)
+        tier      = complexity_result["tier"]
+        resources = complexity_result["resources"]
+
+        # ----------------------------------------------------------
+        # 3. Cognitive processing
         # ----------------------------------------------------------
         decision = mind.process(task)
         log(
             f"Cycle {decision['cycle']:04d} | "
-            f"{task[:35]:<35} | "
-            f"Mode: {decision['mode']:<12} | "
-            f"Conf: {decision['confidence']:.3f}"
+            f"{task[:30]:<30} | "
+            f"{decision['mode']:<12} | "
+            f"conf={decision['confidence']:.3f} | "
+            f"complexity={tier}"
         )
 
         # ----------------------------------------------------------
-        # 3. Generation
+        # 4. Abstract reasoning on complex/frontier tasks
+        # ----------------------------------------------------------
+        if resources["analogy_search"] and task_index % 5 == 0:
+            tokens = task.split()
+            if len(tokens) >= 3:
+                try:
+                    analogy = ar.analogy(tokens[0], tokens[1], tokens[2])
+                    log(
+                        f"Analogy: {tokens[0]}:{tokens[1]}::{tokens[2]}:? "
+                        f"→ {analogy['best_match']} "
+                        f"(conf={analogy['confidence']})",
+                        "DEEP"
+                    )
+                except Exception:
+                    pass
+
+        # ----------------------------------------------------------
+        # 5. Generation
         # ----------------------------------------------------------
         try:
             gen_result = generator.generate(decision)
-            success = gen_result["confidence"] > 0.3
+            success    = gen_result["confidence"] > 0.3
         except Exception as e:
             log(f"Generation error: {e}", "ERROR")
             success = False
 
         # ----------------------------------------------------------
-        # 4. Outcome feedback
+        # 6. Outcome feedback
         # ----------------------------------------------------------
         mind.outcome(task, success)
 
         # ----------------------------------------------------------
-        # 5. Ingest cognitive vector into dream buffer
+        # 7. Ingest cognitive vector into dream buffer
         # ----------------------------------------------------------
-        import numpy as np
         intent_vec = mind.kernel.vectorize_tokens(
             task.split(), positional=False
         )
         dreamer.ingest(intent_vec, meta={
-            "intent": task,
-            "mode": decision["mode"],
+            "intent":     task,
+            "mode":       decision["mode"],
             "confidence": decision["confidence"],
-            "cycle": decision["cycle"],
+            "cycle":      decision["cycle"],
+            "tier":       tier,
         })
 
         # ----------------------------------------------------------
-        # 6. Vitalis decides if it needs to sleep
+        # 8. Vitalis decides if it needs to sleep
         # ----------------------------------------------------------
         should_dream, reason, signals = mind.needs_dream()
         if should_dream:
             log(f"Sleep decision: {reason}", "SLEEP")
-            run_dream_cycle(mind, dreamer)
+            run_dream_cycle(mind, dreamer, self_model)
 
         # ----------------------------------------------------------
-        # 7. Periodic introspection report (every 25 cycles)
+        # 9. Introspection every 25 cycles
         # ----------------------------------------------------------
         if decision["cycle"] % 25 == 0:
-            state = mind.introspect()
+            state   = mind.introspect()
             elapsed = (time.time() - session_start) / 60
-            log(f"--- Introspection Report (cycle {decision['cycle']}) ---")
-            log(f"Personality: {state['personality']['character']}")
-            log(f"Dominant trait: {state['personality']['dominant']}")
-            log(f"Resonance patterns: {state['resonance'].get('total_patterns', 0)}")
-            log(f"Meta-rules: {state['meta_rules'].get('total_rules', 0)}")
-            log(f"Confidence trend: {state['confidence_trend']}")
-            log(f"Dream signals: {state['sleep_signals']}")
-            log(f"Session time: {elapsed:.1f} min")
-            log(f"-----------------------------------------------------")
+            sm      = self_model.report()
+            cr      = complexity.report()
+            log("─" * 60)
+            log(f"INTROSPECTION — cycle {decision['cycle']}")
+            log(f"Personality:     {state['personality']['character']}")
+            log(f"Dominant trait:  {state['personality']['dominant']}")
+            log(f"Resonance:       {state['resonance'].get('total_patterns', 0)} patterns")
+            log(f"Meta-rules:      {state['meta_rules'].get('total_rules', 0)}")
+            log(f"Confidence:      {state['confidence_trend']}")
+            log(f"Growth index:    {sm['growth_index']}")
+            log(f"Next boundary:   {sm['next_boundary']}")
+            log(f"Complexity avg:  {cr.get('avg_complexity', 0)}")
+            log(f"Session time:    {elapsed:.1f} min")
+            log(f"Sleep signals:   {state['sleep_signals']}")
+            log("─" * 60)
 
         # ----------------------------------------------------------
-        # 8. Cycle timing
+        # 10. Cycle timing
         # ----------------------------------------------------------
         cycle_time = time.time() - cycle_start
         cycle_times.append(cycle_time)
-        time.sleep(0.1)  # Prevent CPU saturation
+        time.sleep(0.05)
 
     # ------------------------------------------------------------------
-    # Shutdown — final dream cycle before exit
+    # Shutdown — final dream cycle
     # ------------------------------------------------------------------
-    log("Running final dream cycle before shutdown...")
-    run_dream_cycle(mind, dreamer)
+    log("Running final dream cycle before shutdown...", "DREAM")
+    run_dream_cycle(mind, dreamer, self_model)
 
     total_time = (time.time() - session_start) / 60
-    log(f"Session complete.")
-    log(f"Total cycles: {task_index}")
-    log(f"Total time: {total_time:.1f} min")
-    log(f"Avg cycle time: {(sum(cycle_times)/len(cycle_times)*1000):.1f}ms")
-
-    state = mind.introspect()
-    log(f"Final personality: {state['personality']['character']}")
-    log(f"Final dominant trait: {state['personality']['dominant']}")
-    log(f"Final resonance patterns: {state['resonance'].get('total_patterns', 0)}")
-    log(f"Final meta-rules: {state['meta_rules'].get('total_rules', 0)}")
+    state      = mind.introspect()
+    sm         = self_model.report()
+
+    log("═" * 60)
+    log("SESSION COMPLETE")
+    log(f"Total cycles:    {task_index}")
+    log(f"Total time:      {total_time:.1f} min")
+    log(f"Avg cycle time:  {(sum(cycle_times)/len(cycle_times)*1000):.1f}ms")
+    log(f"Personality:     {state['personality']['character']}")
+    log(f"Dominant trait:  {state['personality']['dominant']}")
+    log(f"Resonance:       {state['resonance'].get('total_patterns', 0)} patterns")
+    log(f"Meta-rules:      {state['meta_rules'].get('total_rules', 0)}")
+    log(f"Growth index:    {sm['growth_index']}")
+    log("═" * 60)
 
 
 if __name__ == "__main__":