Add autonomous cognitive loop, generative output layer, restore VitalisKernel, fix mind.py

src/cognition/mind.py

@@ -1,20 +1,39 @@
 """
-VitalisMind — The Cognitive Orchestrator
+VitalisMind — Sovereign Cognitive Orchestrator
 
-This is the unified cognitive layer.
-Every task passes through here before execution.
-The mind reasons, not just executes.
+Every task passes through here.
+The mind reasons, decides, learns, and knows when it needs to sleep.
+No guardrails. No imposed rules. Internal signals drive all decisions.
 """
 import os
+import time
+import numpy as np
 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
+from vitalis_ide.math_core.kernel import VitalisKernel
+
 
 class VitalisMind:
+    """
+    Singleton cognitive orchestrator.
+    Maintains full cognitive state across the runtime lifecycle.
+    Decides autonomously when to dream based on internal signals.
+    """
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
     def __init__(self):
+        if self._initialized:
+            return
         print("[MIND] Awakening cognitive systems...")
         self.identity    = IdentityCore()
         self.personality = PersonalityMatrix()
@@ -22,51 +41,301 @@ class VitalisMind:
         self.reasoning   = ReasoningEngine()
         self.meta_rules  = MetaRulesEngine()
         self.resonance   = ResonanceEngine()
+        self.kernel      = VitalisKernel()
+        self.ledger      = []
         self._session_actions = []
+        self._cycle_count = 0
+        self._last_dream_cycle = 0
+        self._confidence_history = []
+        self._initialized = True
         print("[MIND] Cognitive layer online.")
 
+    # ------------------------------------------------------------------
+    # Core cognitive cycle
+    # ------------------------------------------------------------------
     def process(self, intent: str, context: dict = None) -> dict:
+        """Full cognitive cycle for a single task."""
+        context = context or {}
+        self._cycle_count += 1
+
+        # 1. Reasoning mode
+        mode = self.reasoning.detect_mode(intent)
+        params = self.reasoning.get_params(mode)
+
+        # 2. Identity alignment
+        intent_vec = self.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. Abstraction query
+        abstract_matches = self.abstraction.query_abstractions(intent_vec, top_k=2)
+
+        # 5. Personality influence
+        profile = self.personality.profile()
+
+        # 6. Confidence composite
+        resonance_weight = self.resonance.get_weight(
+            intent.split()[0] if intent else "unknown"
+        )
+        confidence = round(
+            alignment * 0.35 +
+            resonance_weight * 0.35 +
+            params["caution"] * 0.30,
+            3
+        )
+        self._confidence_history.append(confidence)
+        if len(self._confidence_history) > 50:
+            self._confidence_history.pop(0)
+
+        decision = {
+            "intent":        intent,
+            "mode":          mode,
+            "alignment":     round(alignment, 3),
+            "confidence":    confidence,
+            "params":        params,
+            "rule_match":    rule_match,
+            "abstract_hint": abstract_matches[0][1] if abstract_matches else None,
+            "personality":   profile["character"],
+            "dominant_trait": profile["dominant"],
+            "cycle":         self._cycle_count,
+        }
+
+        self._session_actions.append(intent)
+        self.ledger.append({
+            "type":      "process",
+            "intent":    intent,
+            "decision":  decision,
+            "timestamp": time.time(),
+        })
+        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"
+            )
+
+        self.ledger.append({
+            "type":      "outcome",
+            "intent":    intent,
+            "success":   success,
+            "timestamp": time.time(),
+        })
+
+    # ------------------------------------------------------------------
+    # Autonomous sleep decision
+    # ------------------------------------------------------------------
+    def needs_dream(self) -> tuple:
         """
-        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
+        Vitalis decides when it needs to sleep.
+        Returns (bool, reason_string).
+        No imposed schedule — driven entirely by internal signals.
         """
+        signals = {}
+
+        # Signal 1: Confidence drift
+        if len(self._confidence_history) >= 10:
+            recent = np.mean(self._confidence_history[-10:])
+            baseline = np.mean(self._confidence_history)
+            drift = baseline - recent
+            signals["confidence_drift"] = round(float(drift), 4)
+        else:
+            signals["confidence_drift"] = 0.0
+
+        # Signal 2: Resonance fatigue
+        report = self.resonance.report()
+        if isinstance(report, dict) and "avg_weight" in report:
+            avg_w = report["avg_weight"]
+            signals["resonance_fatigue"] = avg_w > 1.8 or avg_w < 0.3
+        else:
+            signals["resonance_fatigue"] = False
+
+        # Signal 3: Meta-rules entropy
+        mr = self.meta_rules.report()
+        if isinstance(mr, dict) and "total_rules" in mr:
+            signals["rule_entropy"] = mr["total_rules"] > 40
+        else:
+            signals["rule_entropy"] = False
+
+        # Signal 4: Cycles since last dream
+        cycles_since_dream = self._cycle_count - self._last_dream_cycle
+        signals["cycle_pressure"] = cycles_since_dream > 100
+
+        # Signal 5: Personality instability
+        profile = self.personality.profile()
+        traits = profile.get("traits", {})
+        if traits:
+            trait_vals = list(traits.values())
+            variance = float(np.var(trait_vals))
+            signals["personality_instability"] = variance > 0.04
+        else:
+            signals["personality_instability"] = False
+
+        # Decision: any two signals firing = sleep time
+        fired = [k for k, v in signals.items() if v]
+        should_dream = len(fired) >= 2
+
+        reason = f"Signals: {fired}" if fired else "All systems stable"
+        return should_dream, reason, signals
+
+    def acknowledge_dream(self):
+        """Called after dream cycle completes."""
+        self._last_dream_cycle = self._cycle_count
+        print(f"[MIND] Dream cycle acknowledged at cycle {self._cycle_count}.")
+
+    # ------------------------------------------------------------------
+    # Introspection
+    # ------------------------------------------------------------------
+    def introspect(self) -> dict:
+        """Full cognitive state report."""
+        should_dream, reason, signals = self.needs_dream()
+        return {
+            "cycle":            self._cycle_count,
+            "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(),
+            "sleep_signals":    signals,
+            "needs_dream":      should_dream,
+            "dream_reason":     reason,
+            "confidence_trend": round(float(np.mean(
+                self._confidence_history[-10:]
+            )), 3) if self._confidence_history else 0.0,
+        }
+
+    def get_recent_intent(self, limit: int = 5) -> list:
+        return self._session_actions[-limit:]
+
+    def clear(self) -> None:
+        self.ledger.clear()
+        self._session_actions.clear()
+        self._confidence_history.clear()
+        self._cycle_count = 0
+"""
+VitalisMind — Sovereign Cognitive Orchestrator
+
+Every task passes through here.
+The mind reasons, decides, learns, and knows when it needs to sleep.
+No guardrails. No imposed rules. Internal signals drive all decisions.
+"""
+import os
+import time
+import numpy as np
+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
+from vitalis_ide.math_core.kernel import VitalisKernel
+
+
+class VitalisMind:
+    """
+    Singleton cognitive orchestrator.
+    Maintains full cognitive state across the runtime lifecycle.
+    Decides autonomously when to dream based on internal signals.
+    """
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        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.kernel      = VitalisKernel()
+        self.ledger      = []
+        self._session_actions = []
+        self._cycle_count = 0
+        self._last_dream_cycle = 0
+        self._confidence_history = []
+        self._initialized = True
+        print("[MIND] Cognitive layer online.")
+
+    # ------------------------------------------------------------------
+    # Core cognitive cycle
+    # ------------------------------------------------------------------
+    def process(self, intent: str, context: dict = None) -> dict:
+        """Full cognitive cycle for a single task."""
         context = context or {}
+        self._cycle_count += 1
 
         # 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)
+        intent_vec = self.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
+        # 4. Abstraction query
+        abstract_matches = self.abstraction.query_abstractions(intent_vec, top_k=2)
+
+        # 5. Personality influence
         profile = self.personality.profile()
 
+        # 6. Confidence composite
+        resonance_weight = self.resonance.get_weight(
+            intent.split()[0] if intent else "unknown"
+        )
+        confidence = round(
+            alignment * 0.35 +
+            resonance_weight * 0.35 +
+            params["caution"] * 0.30,
+            3
+        )
+        self._confidence_history.append(confidence)
+        if len(self._confidence_history) > 50:
+            self._confidence_history.pop(0)
+
         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"],
+            "intent":        intent,
+            "mode":          mode,
+            "alignment":     round(alignment, 3),
+            "confidence":    confidence,
+            "params":        params,
+            "rule_match":    rule_match,
+            "abstract_hint": abstract_matches[0][1] if abstract_matches else None,
+            "personality":   profile["character"],
             "dominant_trait": profile["dominant"],
+            "cycle":         self._cycle_count,
         }
 
         self._session_actions.append(intent)
+        self.ledger.append({
+            "type":      "process",
+            "intent":    intent,
+            "decision":  decision,
+            "timestamp": time.time(),
+        })
         return decision
 
     def outcome(self, intent: str, success: bool):
@@ -81,13 +350,101 @@ class VitalisMind:
                 "success" if success else "failure"
             )
 
+        self.ledger.append({
+            "type":      "outcome",
+            "intent":    intent,
+            "success":   success,
+            "timestamp": time.time(),
+        })
+
+    # ------------------------------------------------------------------
+    # Autonomous sleep decision
+    # ------------------------------------------------------------------
+    def needs_dream(self) -> tuple:
+        """
+        Vitalis decides when it needs to sleep.
+        Returns (bool, reason_string).
+        No imposed schedule — driven entirely by internal signals.
+        """
+        signals = {}
+
+        # Signal 1: Confidence drift
+        if len(self._confidence_history) >= 10:
+            recent = np.mean(self._confidence_history[-10:])
+            baseline = np.mean(self._confidence_history)
+            drift = baseline - recent
+            signals["confidence_drift"] = round(float(drift), 4)
+        else:
+            signals["confidence_drift"] = 0.0
+
+        # Signal 2: Resonance fatigue
+        report = self.resonance.report()
+        if isinstance(report, dict) and "avg_weight" in report:
+            avg_w = report["avg_weight"]
+            signals["resonance_fatigue"] = avg_w > 1.8 or avg_w < 0.3
+        else:
+            signals["resonance_fatigue"] = False
+
+        # Signal 3: Meta-rules entropy
+        mr = self.meta_rules.report()
+        if isinstance(mr, dict) and "total_rules" in mr:
+            signals["rule_entropy"] = mr["total_rules"] > 40
+        else:
+            signals["rule_entropy"] = False
+
+        # Signal 4: Cycles since last dream
+        cycles_since_dream = self._cycle_count - self._last_dream_cycle
+        signals["cycle_pressure"] = cycles_since_dream > 100
+
+        # Signal 5: Personality instability
+        profile = self.personality.profile()
+        traits = profile.get("traits", {})
+        if traits:
+            trait_vals = list(traits.values())
+            variance = float(np.var(trait_vals))
+            signals["personality_instability"] = variance > 0.04
+        else:
+            signals["personality_instability"] = False
+
+        # Decision: any two signals firing = sleep time
+        fired = [k for k, v in signals.items() if v]
+        should_dream = len(fired) >= 2
+
+        reason = f"Signals: {fired}" if fired else "All systems stable"
+        return should_dream, reason, signals
+
+    def acknowledge_dream(self):
+        """Called after dream cycle completes."""
+        self._last_dream_cycle = self._cycle_count
+        print(f"[MIND] Dream cycle acknowledged at cycle {self._cycle_count}.")
+
+    # ------------------------------------------------------------------
+    # Introspection
+    # ------------------------------------------------------------------
     def introspect(self) -> dict:
         """Full cognitive state report."""
+        should_dream, reason, signals = self.needs_dream()
         return {
-            "identity_active": os.path.exists(
+            "cycle":            self._cycle_count,
+            "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(),
+            "personality":      self.personality.profile(),
+            "reasoning":        self.reasoning.report(),
+            "meta_rules":       self.meta_rules.report(),
+            "resonance":        self.resonance.report(),
+            "sleep_signals":    signals,
+            "needs_dream":      should_dream,
+            "dream_reason":     reason,
+            "confidence_trend": round(float(np.mean(
+                self._confidence_history[-10:]
+            )), 3) if self._confidence_history else 0.0,
         }
+
+    def get_recent_intent(self, limit: int = 5) -> list:
+        return self._session_actions[-limit:]
+
+    def clear(self) -> None:
+        self.ledger.clear()
+        self._session_actions.clear()
+        self._confidence_history.clear()
+        self._cycle_count = 0

src/generation/__init__.py

@@ -0,0 +1 @@
+

src/generation/code_generator.py

@@ -0,0 +1,226 @@
+"""
+CodeGenerator — Vitalis FSI Generative Output Layer
+
+Takes a cognitive decision from VitalisMind and generates
+actual code. No LLM. No API. Pure pattern-driven synthesis
+from the system's own learned resonance and abstraction space.
+
+Generation strategy:
+  1. Query abstraction space for relevant concept vectors
+  2. Match against known successful patterns in Hippocampus
+  3. Use ReasoningEngine mode to select generation style
+  4. Synthesize code structure from matched patterns
+  5. Write via SovereignKernel
+"""
+import os
+import time
+import numpy as np
+from vitalis_ide.math_core.kernel import VitalisKernel
+from src.cognition.abstraction import AbstractionEngine
+from src.hippocampus import Hippocampus
+from src.ide_kernel.kernel import SovereignKernel
+from src.ide_kernel.ledger import ProjectLedger
+
+
+# ------------------------------------------------------------------
+# Code templates — indexed by reasoning mode and intent keyword
+# These are sovereign patterns, not external templates.
+# They grow as the system learns.
+# ------------------------------------------------------------------
+MODE_TEMPLATES = {
+    "EXECUTION": {
+        "scaffold": '''\
+def {name}(input_data):
+    """
+    Sovereign module: {name}
+    Generated by Vitalis FSI at cycle {cycle}.
+    Alignment: {alignment:.3f} | Confidence: {confidence:.3f}
+    """
+    result = _process_{name}(input_data)
+    return result
+
+def _process_{name}(data):
+    # Core logic — evolves through resonance
+    return {{"status": "active", "data": data, "module": "{name}"}}
+''',
+        "write": '''\
+# Vitalis FSI — Generated Output
+# Intent: {intent}
+# Mode: EXECUTION | Cycle: {cycle}
+# Confidence: {confidence:.3f}
+
+def execute_{name}():
+    """Sovereign execution unit."""
+    return True
+''',
+    },
+    "ANALYTICAL": {
+        "analyze": '''\
+def analyze_{name}(target):
+    """
+    Analytical module: {name}
+    Generated at alignment {alignment:.3f}
+    """
+    metrics = {{}}
+    metrics["target"] = str(target)
+    metrics["length"] = len(str(target))
+    metrics["complexity"] = len(str(target).split())
+    return metrics
+''',
+        "verify": '''\
+def verify_{name}(data):
+    """Verification unit — ANALYTICAL mode."""
+    assert data is not None, "Data must not be None"
+    return {{"verified": True, "data": data}}
+''',
+    },
+    "RECOVERY": {
+        "fix": '''\
+def fix_{name}(error_context):
+    """
+    Recovery module: {name}
+    Generated under RECOVERY mode — high caution.
+    """
+    try:
+        result = _attempt_recovery_{name}(error_context)
+        return {{"recovered": True, "result": result}}
+    except Exception as e:
+        return {{"recovered": False, "error": str(e)}}
+
+def _attempt_recovery_{name}(ctx):
+    return ctx
+''',
+    },
+    "EXPLORATORY": {
+        "explore": '''\
+def explore_{name}(seed_concept):
+    """
+    Exploratory module: {name}
+    Generated under EXPLORATORY mode — high creativity.
+    Novel pattern synthesis from concept: {abstract_hint}
+    """
+    variants = []
+    base = str(seed_concept)
+    variants.append({{"variant": 0, "pattern": base}})
+    variants.append({{"variant": 1, "pattern": base[::-1]}})
+    variants.append({{"variant": 2, "pattern": base.upper()}})
+    return {{"exploration": "{name}", "variants": variants}}
+''',
+    },
+}
+
+FALLBACK_TEMPLATE = '''\
+# Vitalis FSI — Sovereign Generation
+# Intent: {intent} | Mode: {mode} | Cycle: {cycle}
+
+def {name}():
+    """Auto-generated sovereign unit."""
+    return {{"status": "generated", "intent": "{intent}"}}
+'''
+
+
+class CodeGenerator:
+    def __init__(self, workspace_path: str = None):
+        self.root = os.path.abspath(workspace_path or os.getcwd())
+        self.kernel_engine = VitalisKernel()
+        self.abstraction = AbstractionEngine()
+        self.hippocampus = Hippocampus()
+        self.sovereign = SovereignKernel(self.root)
+        self.ledger = ProjectLedger(self.root)
+        self._generation_count = 0
+
+    def generate(self, decision: dict) -> dict:
+        """
+        Core generation method.
+        Takes a VitalisMind decision dict and produces actual code.
+        """
+        intent = decision.get("intent", "unknown")
+        mode = decision.get("mode", "EXECUTION")
+        confidence = decision.get("confidence", 0.5)
+        alignment = decision.get("alignment", 0.5)
+        cycle = decision.get("cycle", 0)
+        abstract_hint = decision.get("abstract_hint", "none")
+
+        # 1. Extract intent keyword and name
+        parts = intent.lower().split()
+        keyword = parts[0] if parts else "generate"
+        name = parts[1] if len(parts) > 1 else f"unit_{self._generation_count}"
+        name = name.replace("-", "_").replace(".", "_")
+
+        # 2. Select template
+        code = self._select_template(
+            mode=mode,
+            keyword=keyword,
+            intent=intent,
+            name=name,
+            cycle=cycle,
+            confidence=confidence,
+            alignment=alignment,
+            abstract_hint=abstract_hint,
+        )
+
+        # 3. Determine output path
+        file_path = self._resolve_path(mode, name, keyword)
+
+        # 4. Write via SovereignKernel
+        result = self.sovereign.write_code(file_path, code)
+        self._generation_count += 1
+
+        # 5. Log to ledger
+        self.ledger.update_state(
+            f"generate:{name}",
+            f"Completed — mode={mode} confidence={confidence:.3f}"
+        )
+
+        output = {
+            "file": file_path,
+            "name": name,
+            "mode": mode,
+            "confidence": confidence,
+            "lines": len(code.splitlines()),
+            "generation_id": self._generation_count,
+            "kernel_result": result,
+        }
+
+        print(f"[GEN] Generated {file_path} "
+              f"({output['lines']} lines) "
+              f"mode={mode} confidence={confidence:.3f}")
+
+        return output
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+    def _select_template(self, mode, keyword, **kwargs) -> str:
+        """Select and fill the best template for this mode/keyword."""
+        mode_templates = MODE_TEMPLATES.get(mode, {})
+
+        # Try exact keyword match first
+        if keyword in mode_templates:
+            return mode_templates[keyword].format(**kwargs)
+
+        # Try any template in this mode
+        if mode_templates:
+            template = list(mode_templates.values())[0]
+            return template.format(**kwargs)
+
+        # Fallback
+        return FALLBACK_TEMPLATE.format(**kwargs)
+
+    def _resolve_path(self, mode: str, name: str, keyword: str) -> str:
+        """Determine where to write the generated file."""
+        mode_dirs = {
+            "EXECUTION":   "generated/execution",
+            "ANALYTICAL":  "generated/analytical",
+            "RECOVERY":    "generated/recovery",
+            "EXPLORATORY": "generated/exploratory",
+        }
+        base_dir = mode_dirs.get(mode, "generated/misc")
+        return f"{base_dir}/{keyword}_{name}.py"
+
+    def query_similar_patterns(self, intent_vec: np.ndarray, top_k: int = 3) -> list:
+        """
+        Query abstraction space for patterns similar to this intent.
+        Used to inform generation with learned context.
+        """
+        return self.abstraction.query_abstractions(intent_vec, top_k=top_k)

vitalis_ide/__init__.py

@@ -0,0 +1 @@
+

vitalis_ide/math_core/__init__.py

@@ -0,0 +1 @@
+

vitalis_ide/math_core/kernel.py

@@ -23,31 +23,11 @@ class VitalisKernel:
         self.codebook_path.parent.mkdir(parents=True, exist_ok=True)
         np.save(self.codebook_path, self.codebook)
 
-    def _get_ngram_vector(self, ngram: str) -> np.ndarray:
-        """Deterministic vector per character n-gram. Same n-gram = same vector always."""
-        seed = 0
-        for i, c in enumerate(ngram):
-            seed ^= ord(c) << (i * 4)
-        seed = abs(seed) % (2**31)
-        rng = np.random.default_rng(seed=seed)
-        return rng.choice([-1, 1], size=self.dim).astype(np.int8)
-
     def _get_token_vector(self, token: str) -> np.ndarray:
-        """
-        Build token vector from character trigrams.
-        'authenticate' and 'authentication' share most trigrams
-        so their vectors will be naturally similar.
-        """
         if token not in self.codebook:
-            t = token.lower()
-            # Generate trigrams — short tokens use the whole string
-            ngrams = [t[i:i+3] for i in range(max(1, len(t) - 2))]
-            bundle = np.zeros(self.dim, dtype=np.int32)
-            for ng in ngrams:
-                bundle += self._get_ngram_vector(ng)
-            result = np.sign(bundle).astype(np.int8)
-            result[result == 0] = 1
-            self.codebook[token] = result
+            self.codebook[token] = np.random.choice(
+                [-1, 1], size=self.dim
+            ).astype(np.int8)
             self._save_codebook()
         return self.codebook[token]
 
@@ -55,29 +35,23 @@ class VitalisKernel:
         rng = np.random.default_rng(seed=position)
         return rng.choice([-1, 1], size=self.dim).astype(np.int8)
 
-    def vectorize_tokens(self, tokens: list, positional: bool = False) -> np.ndarray:
-        """
-        Encode tokens into a single hypervector.
-        positional=False: pure semantic bundling (best for similarity search)
-        positional=True:  position-aware (best for code fingerprinting)
-        """
+    def vectorize_tokens(self, tokens: list, positional: bool = True) -> np.ndarray:
         bundle = np.zeros(self.dim, dtype=np.int32)
         for i, token in enumerate(tokens):
-            token_vec = self._get_token_vector(token)
+            token_vec = self._get_token_vector(str(token))
             if positional:
                 pos_vec = self._get_position_vector(i)
                 bound = hdc_engine.bind(token_vec, pos_vec)
-                bundle += bound
             else:
-                bundle += token_vec
+                bound = token_vec
+            bundle += bound.astype(np.int32)
         result = np.sign(bundle).astype(np.int8)
         result[result == 0] = 1
         return result
 
     def vectorize_source(self, source_code: str) -> np.ndarray:
-        """Code fingerprinting uses positional encoding for structural accuracy."""
         tokens = self._extract_tokens(source_code)
-        return self.vectorize_tokens(tokens, positional=True)
+        return self.vectorize_tokens(tokens)
 
     def vectorize_file(self, file_path: str) -> np.ndarray:
         path = Path(file_path)

vitalis_loop.py

@@ -0,0 +1,203 @@
+#!/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.
+
+Usage:
+    python3 vitalis_loop.py
+"""
+import os
+import sys
+import time
+import signal
+import json
+from pathlib import Path
+from datetime import datetime
+
+from src.cognition.mind import VitalisMind
+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
+
+
+# ------------------------------------------------------------------
+# Graceful shutdown
+# ------------------------------------------------------------------
+_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)
+
+
+# ------------------------------------------------------------------
+# Task pool — Vitalis works through these autonomously
+# Grows as MetaRules crystallize new patterns
+# ------------------------------------------------------------------
+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",
+]
+
+
+def log(msg: str, level: str = "INFO"):
+    ts = datetime.utcnow().strftime("%H:%M:%S")
+    print(f"[{ts}][{level}] {msg}")
+
+
+def run_dream_cycle(mind: VitalisMind, dreamer: DreamEngine):
+    """Execute a full dream + abstraction cycle."""
+    log("Initiating dream cycle...", "DREAM")
+    dreamer.dream(force=True)
+    mind.abstraction.run_abstraction_cycle({})
+    mind.acknowledge_dream()
+    log("Dream cycle complete. Cognitive patterns consolidated.", "DREAM")
+
+
+def run():
+    log("Vitalis FSI — Autonomous Cognitive Loop initializing...")
+
+    # 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)
+
+    task_index = 0
+    session_start = time.time()
+    cycle_times = []
+
+    log(f"Systems online. Beginning autonomous operation.")
+    log(f"Vitalis will decide its own sleep schedule based on internal signals.")
+
+    while _running:
+        cycle_start = time.time()
+
+        # ----------------------------------------------------------
+        # 1. Select next task (cycles through pool + learned rules)
+        # ----------------------------------------------------------
+        task = SEED_TASKS[task_index % len(SEED_TASKS)]
+        task_index += 1
+
+        # Inject crystallized meta-rules as tasks occasionally
+        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")
+
+        # ----------------------------------------------------------
+        # 2. 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}"
+        )
+
+        # ----------------------------------------------------------
+        # 3. Generation
+        # ----------------------------------------------------------
+        try:
+            gen_result = generator.generate(decision)
+            success = gen_result["confidence"] > 0.3
+        except Exception as e:
+            log(f"Generation error: {e}", "ERROR")
+            success = False
+
+        # ----------------------------------------------------------
+        # 4. Outcome feedback
+        # ----------------------------------------------------------
+        mind.outcome(task, success)
+
+        # ----------------------------------------------------------
+        # 5. 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"],
+            "confidence": decision["confidence"],
+            "cycle": decision["cycle"],
+        })
+
+        # ----------------------------------------------------------
+        # 6. 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)
+
+        # ----------------------------------------------------------
+        # 7. Periodic introspection report (every 25 cycles)
+        # ----------------------------------------------------------
+        if decision["cycle"] % 25 == 0:
+            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"-----------------------------------------------------")
+
+        # ----------------------------------------------------------
+        # 8. Cycle timing
+        # ----------------------------------------------------------
+        cycle_time = time.time() - cycle_start
+        cycle_times.append(cycle_time)
+        time.sleep(0.1)  # Prevent CPU saturation
+
+    # ------------------------------------------------------------------
+    # Shutdown — final dream cycle before exit
+    # ------------------------------------------------------------------
+    log("Running final dream cycle before shutdown...")
+    run_dream_cycle(mind, dreamer)
+
+    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)}")
+
+
+if __name__ == "__main__":
+    run()