Fix architecture integration: remove duplicate mind class, add LFM-backed embeddings, wire SovereignLFMBridge with chat/process/generate

src/cognition/mind.py

@@ -223,231 +223,6 @@ class VitalisMind:
         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
-        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:
-        """
-        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 < 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"] > 150
-        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
 
 
 # Deep cognition layer — imported here to extend VitalisMind

src/core/lfm_controller.py

@@ -0,0 +1,73 @@
+import os
+import asyncio
+import logging
+from concurrent.futures import ThreadPoolExecutor
+from llama_cpp import Llama
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - [LFMController] - %(levelname)s - %(message)s')
+logger = logging.getLogger("LFMController")
+
+class LFMController:
+    def __init__(self, model_path: str = "", n_ctx: int = 4096, n_threads: int = 6, n_gpu_layers: int = -1):
+        if not model_path:
+            candidates = [
+                os.path.expanduser("~/.vitalis/models/Llama-3.2-3B-Instruct-Q4_K_M.gguf"),
+                os.path.expanduser("~/.vitalis/models/LFM2.5-1.2B-Instruct-Q4_K_M.gguf"),
+                "Llama-3.2-3B-Instruct-Q4_K_M.gguf",
+                "LFM2.5-1.2B-Instruct-Q4_K_M.gguf",
+            ]
+            for c in candidates:
+                if os.path.exists(c):
+                    model_path = c
+                    break
+            if not model_path:
+                model_path = candidates[0]
+        if not os.path.exists(model_path):
+            logger.critical(f"Target model weights missing at path: {model_path}")
+            raise FileNotFoundError(f"Model file target missing: {model_path}")
+
+        logger.info(f"Initializing local model instance from {model_path}...")
+        try:
+            self.llm = Llama(
+                model_path=model_path,
+                n_ctx=n_ctx,
+                n_threads=n_threads,
+                n_gpu_layers=n_gpu_layers,
+                verbose=False
+            )
+            logger.info("Model hardware acceleration context successfully initialized.")
+        except Exception as e:
+            logger.error(f"Failed to load hardware context for GGUF: {str(e)}")
+            raise e
+
+        self.executor = ThreadPoolExecutor(max_workers=1)
+
+    def execute_raw(self, prompt: str, max_tokens: int = 1024, temperature: float = 0.2, top_p: float = 0.95) -> str:
+        try:
+            response = self.llm(
+                prompt=prompt,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                stop=["<|endoftext|>", "###", "Instruction:", "Response:"]
+            )
+            output_text = response["choices"][0]["text"].strip()
+            return output_text
+        except Exception as e:
+            logger.error(f"Error encountered during raw execution sequence: {str(e)}")
+            return f"EXECUTION_ERROR: {str(e)}"
+
+    async def generate_async(self, prompt: str, max_tokens: int = 1024, temperature: float = 0.2, top_p: float = 0.95) -> str:
+        loop = asyncio.get_running_loop()
+        try:
+            return await loop.run_in_executor(
+                self.executor,
+                self.execute_raw,
+                prompt, max_tokens, temperature, top_p
+            )
+        except Exception as e:
+            logger.error(f"Async worker thread crashed: {str(e)}")
+            return f"ASYNC_EXECUTION_ERROR: {str(e)}"
+
+    def shutdown(self):
+        self.executor.shutdown(wait=True)

src/core/sovereign_lfm_bridge.py

@@ -0,0 +1,125 @@
+import os
+import subprocess
+import ast
+from src.devcore.quad_flow_engine import NeurosynthticQuadFlowEngine
+from src.core.lfm_controller import LFMController
+
+class SovereignLFMBridge:
+    def __init__(self, model_path: str = ""):
+        if not model_path:
+            candidates = [
+                os.path.expanduser("~/.vitalis/models/Llama-3.2-3B-Instruct-Q4_K_M.gguf"),
+                os.path.expanduser("~/.vitalis/models/LFM2.5-1.2B-Instruct-Q4_K_M.gguf"),
+                "Llama-3.2-3B-Instruct-Q4_K_M.gguf",
+                "LFM2.5-1.2B-Instruct-Q4_K_M.gguf",
+            ]
+            for c in candidates:
+                if os.path.exists(c):
+                    model_path = c
+                    break
+            if not model_path:
+                model_path = candidates[0]
+        self.model = LFMController(model_path=model_path, n_ctx=8192, n_threads=4, n_gpu_layers=-1)
+        self.engine = NeurosynthticQuadFlowEngine()
+
+    def process(self, query: str, mode: str = None) -> str:
+        return self.chat(query)
+
+    def chat(self, user_input: str, max_tokens: int = 2048, temperature: float = 0.7) -> str:
+        from src.cognition.mind import VitalisMind, _extend_mind
+        mind = _extend_mind(VitalisMind())
+        d = mind.process(user_input)
+        mode = d["mode"]
+        conf = d["confidence"]
+        personality = d.get("personality", "Balanced. Adapting.")
+        dominant_trait = d.get("dominant_trait", "PRECISION")
+
+        prompt = (
+            f"<|im_start|>system\n"
+            f"Identity: Vitalis Cognitive Engine (mode: {mode}, confidence: {conf}).\n"
+            f"Personality: {personality}. Dominant trait: {dominant_trait}.\n"
+            f"Respond naturally, honestly, and according to your identity alignment.\n"
+            f"<|im_end|>\n"
+            f"<|im_start|>user\n{user_input}<|im_end|>\n"
+            f"<|im_start|>assistant\n"
+        )
+
+        response = self.model.execute_raw(prompt, max_tokens=max_tokens, temperature=temperature)
+
+        mind.outcome(user_input, True)
+
+        try:
+            vec = mind.kernel.vectorize_tokens(user_input.split(), positional=False)
+            self.engine.nexus.wm.push(user_input, vec, conf)
+            self.engine.nexus.helix.encode(
+                event=user_input,
+                meaning=f"chat mode={mode} conf={conf}",
+            )
+        except Exception:
+            pass
+
+        return response
+
+    def generate(self, intent: str) -> dict:
+        from src.cognition.mind import VitalisMind, _extend_mind
+        mind = _extend_mind(VitalisMind())
+        d    = mind.process(intent)
+        mode = d["mode"]
+        conf = d["confidence"]
+
+        response = self.model.llm.create_chat_completion(
+            messages=[
+                {"role": "system", "content": f"You are a Python code engine in {mode} mode. Output executable Python code only. No explanations. Always end with a print() statement."},
+                {"role": "user",   "content": f"Write Python code to: {intent}"}
+            ],
+            max_tokens=512,
+            temperature=0.2,
+        )
+        raw    = response["choices"][0]["message"]["content"].strip()
+        code   = self._extract_code(raw)
+        result = self._sandbox(code)
+        mind.outcome(intent, result["status"] == "SUCCESS")
+
+        vec = mind.kernel.vectorize_tokens(intent.split(), positional=False)
+        self.engine.nexus.wm.push(intent, vec, conf)
+        self.engine.nexus.helix.encode(intent, result["output"] or "fail")
+
+        return {"intent":intent,"mode":mode,"confidence":conf,
+                "code":code,"output":result["output"],"status":result["status"]}
+
+    def _extract_code(self, raw: str) -> str:
+        raw = raw.replace("```python","").replace("```","").strip()
+        if not raw: return "print('no output')"
+        lines = raw.splitlines()
+        clean = []
+        for line in lines:
+            s = line.strip()
+            if s and not s.startswith('#'):
+                if (s[0].isupper() and '=' not in s and '(' not in s
+                        and not any(s.startswith(k) for k in
+                        ['def ','class ','import ','from ','for ',
+                         'if ','while ','try','return','print','True','False'])):
+                    break
+            clean.append(line)
+        code = '\n'.join(clean).strip()
+        try:
+            ast.parse(code)
+        except SyntaxError:
+            code = "print('syntax error in generated code')"
+        if not code: return "print('no output')"
+        if "print(" not in code:
+            defs = [l for l in code.splitlines() if l.strip().startswith("def ")]
+            if defs:
+                fname = defs[-1].strip().split("def ")[1].split("(")[0]
+                code += f"\nprint({fname}(10))"
+        return code
+
+    def _sandbox(self, code: str) -> dict:
+        try:
+            r = subprocess.run(["python3","-c",code],
+                capture_output=True, text=True, timeout=10)
+            if r.returncode == 0:
+                return {"status":"SUCCESS","output":r.stdout.strip()}
+            return {"status":"FAIL","output":r.stderr.strip()[:200]}
+        except subprocess.TimeoutExpired:
+            return {"status":"TIMEOUT","output":""}

src/core/transformer_wrapper.py

@@ -7,14 +7,24 @@ import numpy as np
 import torch
 
 class SovereignTransformer:
-    def __init__(self, model_name: str = "facebook/opt-125m"):
+    def __init__(self, model_name: str = "facebook/opt-125m", controller=None):
         self.model_name = model_name
         self.dim = 768
+        self.controller = controller
 
     def encode(self, text: str):
+        if self.controller is not None:
+            try:
+                resp = self.controller.llm.create_embedding(input=text)
+                emb = resp["data"][0]["embedding"]
+                return torch.tensor(emb, dtype=torch.float32)
+            except Exception:
+                pass
+
         seed = sum(ord(c) for c in (text or "")[:80]) % (2**31)
         rng  = np.random.default_rng(seed)
         vec  = rng.standard_normal(self.dim).astype(np.float32)
         norm = np.linalg.norm(vec)
-        if norm > 0: vec /= norm
+        if norm > 0:
+            vec /= norm
         return torch.from_numpy(vec)

src/devcore/quad_flow_engine.py

@@ -0,0 +1,88 @@
+import logging
+from src.devcore.vitalis_cognitive_engine import VitalisCognitiveEngine
+from src.cognition.working_memory import WorkingMemory
+from src.cognition.predictive_engine import PredictiveEngine
+from src.dream_engine.synthetic_helix import SyntheticHelixMemory
+from vitalis_ide.math_core.kernel import VitalisKernel
+
+log = logging.getLogger('QuadFlow')
+
+
+class NexusHead:
+    def __init__(self):
+        self.kernel    = VitalisKernel()
+        self.wm        = WorkingMemory()
+        self.predictor = PredictiveEngine()
+        self.helix     = SyntheticHelixMemory()
+
+    def pre(self, intent, mind_state):
+        resonance_w = {
+            k: v for k, v in
+            mind_state.get('resonance', {}).get('strongest', [])
+        }
+        prediction = self.predictor.predict_next(
+            intent,
+            mind_state.get('meta_rules', {}),
+            resonance_w,
+        )
+        if prediction.get('predicted_next'):
+            self.predictor.anticipate(prediction, self.wm)
+        vec = self.kernel.vectorize_tokens(intent.split(), positional=False)
+        self.wm.push(intent, vec, 1.0)
+        return {'prediction': prediction, 'wm_context': self.wm.context(3)}
+
+    def post(self, intent, result, success):
+        accuracy = self.predictor.score(intent)
+        mode     = result.get('mode', 'unknown')
+        conf     = result.get('confidence', 0.0)
+        status   = 'success' if success else 'fail'
+        meaning  = status + ' mode=' + mode + ' conf=' + str(round(conf, 3))
+        self.helix.encode(event=intent, meaning=meaning)
+        return {'accuracy': accuracy}
+
+    def report(self):
+        return {
+            'working_memory': self.wm.report(),
+            'predictor':      self.predictor.report(),
+            'helix':          self.helix.report(),
+        }
+
+
+class NeurosynthticQuadFlowEngine(VitalisCognitiveEngine):
+    def __init__(self):
+        super().__init__()
+        self.nexus = NexusHead()
+        print('')
+        print('  ╔══════════════════════════════════════╗')
+        print('  ║   NEUROSYNTHETIC QUAD FLOW ENGINE    ║')
+        print('  ║   Sensu | Ratio | Cor | Nexus        ║')
+        print('  ║   WorkingMem + Foresight + Helix     ║')
+        print('  ╚══════════════════════════════════════╝')
+        print('')
+
+    def think_and_act(self, intent, token, **kwargs):
+        if not self.auth.validate_request(token):
+            return {'success': False, 'error': 'UNAUTHORIZED'}
+        from src.cognition.mind import VitalisMind, _extend_mind
+        mind      = VitalisMind()
+        ms        = mind.introspect()
+        pre       = self.nexus.pre(intent, ms)
+        predicted = pre['prediction'].get('predicted_next', '?')
+        wm_ctx    = pre['wm_context']
+        log.info('[NEXUS] Predicted: ' + str(predicted))
+        log.info('[NEXUS] WM: ' + str(wm_ctx))
+        result    = super().think_and_act(intent, token, **kwargs)
+        post      = self.nexus.post(intent, result, result.get('success', False))
+        result['nexus'] = {
+            'predicted_next':      predicted,
+            'wm_context':          wm_ctx,
+            'prediction_accuracy': post['accuracy'],
+        }
+        return result
+
+    def status(self):
+        return {
+            'engine': 'NeurosynthticQuadFlowEngine v2.1',
+            'heads':  ['Sensu', 'Ratio', 'Cor', 'Nexus'],
+            'nexus':  self.nexus.report(),
+        }

src/engine/quadruflow.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import os
+import time
+from datetime import datetime
+from typing import Dict, Any
+
+from src.cognition.curriculum import CurriculumManager, CurriculumTask
+from src.memory.ledger import QuantumResistantLedger
+from src.engine.validator import ArtifactValidator
+from src.cognition._constants import logger
+from src.core.lfm_controller import LFMController
+
+
+class QuadruflowOrchestrator:
+    """The Neurosynthetic Quadruflow Engine implementing four discrete cognitive flows."""
+
+    def __init__(self, random_seed: int | None = None):
+        logger.info("Initializing Quadruflow Engine Core...")
+        self.curriculum = CurriculumManager(random_seed=random_seed)
+        self.ledger = QuantumResistantLedger()
+        self.validator = ArtifactValidator()
+
+        candidates = [
+            os.path.expanduser("~/.vitalis/models/Llama-3.2-3B-Instruct-Q4_K_M.gguf"),
+            os.path.expanduser("~/.vitalis/models/LFM2.5-1.2B-Instruct-Q4_K_M.gguf"),
+            "Llama-3.2-3B-Instruct-Q4_K_M.gguf",
+            "LFM2.5-1.2B-Instruct-Q4_K_M.gguf",
+        ]
+        model_path = ""
+        for c in candidates:
+            if os.path.exists(c):
+                model_path = c
+                break
+        if not model_path:
+            model_path = candidates[0]
+        logger.info("Wiring LFMController -> %s", model_path)
+        self.controller = LFMController(
+            model_path=model_path,
+            n_ctx=8192,
+            n_threads=6,
+            n_gpu_layers=-1,
+        )
+
+        if not self.ledger.verify_integrity():
+            raise SecurityError("Critical Error: Cryptographic ledger validation failed during boot sequence.")
+        logger.info("[Evaluation Ready] Core engine verified and integrated with evaluation hooks.")
+
+    def _normalize_val_report(self, v_out) -> dict:
+        if isinstance(v_out, dict):
+            return v_out
+        if isinstance(v_out, tuple) and len(v_out) == 2:
+            valid, reason = v_out
+            valid = bool(valid)
+            return {
+                "valid": valid,
+                "errors": [] if valid else [str(reason)],
+                "score_components": {
+                    "schema": 1.0 if valid else 0.0,
+                    "semantics": 1.0 if valid else 0.0,
+                    "length": 1.0,
+                },
+            }
+        return {
+            "valid": getattr(v_out, "valid", False),
+            "errors": getattr(v_out, "errors", []),
+            "score_components": getattr(v_out, "score_components", {"schema": 0.0, "semantics": 0.0, "length": 0.0}),
+        }
+
+    def flow1_ingest(self, state: dict) -> dict:
+        if "task_id" not in state or "prompt" not in state:
+            raise ValueError("Schema validation failed: missing task_id or prompt")
+        return {
+            "task_id": str(state["task_id"]),
+            "prompt": str(state["prompt"]),
+            "expected_type": state.get("expected_type", "code"),
+            "provenance": "vitalis_devcore_ingest",
+        }
+
+    def flow2_simulate(self, state: dict, seed: int) -> dict:
+        formatted_prompt = f"<|im_start|>user\n{state['prompt']}<|im_end|>\n<|im_start|>assistant\n"
+        text = self.controller.execute_raw(formatted_prompt, max_tokens=256, temperature=0.0)
+        return {"text": text, "task_id": state["task_id"]}
+
+    def flow3_debug(self, candidate: dict, errors: list) -> tuple[dict, dict]:
+        repair_prompt = (
+            f"Fix the following errors in your previous output:\n"
+            f"Errors: {', '.join(errors)}\n"
+            f"Previous Output:\n{candidate['text']}"
+        )
+        return (
+            {"task_id": candidate["task_id"], "prompt": repair_prompt},
+            {"repair_prompt": repair_prompt, "previous_errors": errors},
+        )
+
+    def flow4_attest(self, candidate: dict, corrections: dict | None, val_report: dict, retries: int, runtime_ms: float, attested: bool, rejection_reason: str | None = None) -> dict:
+        det_hash = hashlib.sha256(candidate["text"].encode("utf-8")).hexdigest()
+        return {
+            "artifact_id": f"art_{candidate['task_id']}_{int(time.time())}",
+            "task_id": candidate["task_id"],
+            "result": {"output": candidate["text"]},
+            "validator": {
+                "valid": val_report.get("valid", False),
+                "errors": val_report.get("errors", []),
+                "score_components": val_report.get("score_components", {"schema": 0.0, "semantics": 0.0, "length": 0.0}),
+            },
+            "attestation": {
+                "hash": det_hash,
+                "signature": "<placeholder>",
+                "timestamp": datetime.utcnow().isoformat() + "Z",
+                "attested": attested,
+            },
+            "meta": {
+                "retries": retries,
+                "runtime_ms": int(runtime_ms),
+                "rejection_reason": rejection_reason,
+            },
+        }
+
+    def run_cognitive_cycle(self, task: CurriculumTask, seed: int) -> dict:
+        start_time = time.time()
+        initial_state = {
+            "task_id": task.task_id,
+            "prompt": getattr(task, "prompt", f"Complete task {task.task_id}"),
+            "expected_type": task.expected_type,
+        }
+        state = self.flow1_ingest(initial_state)
+        retries = 0
+        rejection_reason = None
+        candidate = {"text": "", "task_id": task.task_id}
+        corrections = None
+        val_report: dict = {
+            "valid": False,
+            "errors": [],
+            "score_components": {"schema": 0.0, "semantics": 0.0, "length": 0.0},
+        }
+
+        while retries <= 2:
+            candidate = self.flow2_simulate(state, seed)
+            v_out = self.validator.validate(candidate["text"])
+            val_report = self._normalize_val_report(v_out)
+            if val_report.get("valid"):
+                break
+            retries += 1
+            if retries <= 2:
+                state, corrections = self.flow3_debug(candidate, val_report.get("errors", []))
+            else:
+                rejection_reason = "Max retries exceeded without valid artifact"
+
+        runtime_ms = (time.time() - start_time) * 1000
+        attested = val_report.get("valid", False) and (rejection_reason is None)
+        artifact = self.flow4_attest(candidate, corrections, val_report, min(retries, 2), runtime_ms, attested, rejection_reason)
+
+        sc = val_report.get("score_components", {"schema": 0.0, "semantics": 0.0, "length": 0.0})
+        risk = (
+            0.5 * (1.0 - sc.get("schema", 0.0))
+            + 0.3 * (1.0 - sc.get("semantics", 0.0))
+            + 0.2 * (min(retries, 2) / 2.0)
+        )
+
+        metrics_payload = (
+            f"status={'SUCCESS' if attested else 'REJECTED'}"
+            f"|risk={round(risk, 4)}"
+            f"|duration={int(runtime_ms)}"
+            f"|attested={str(attested).lower()}"
+            f"|rejection_reason={rejection_reason}"
+        )
+        block = self.ledger.append_record(task_id=task.task_id, outcome_metrics=metrics_payload)
+        artifact["attestation"]["signature"] = getattr(block, "signature", "<placeholder>")
+        self.curriculum.record_result(success=attested, risk_encountered=risk)
+        return artifact
+
+    async def execute_closed_loop_cycle(self) -> Dict[str, Any]:
+        task: CurriculumTask = self.curriculum.generate_next_task()
+        logger.info("Executing Task Channel: %s [Tier %d]", task.task_id, task.tier)
+        loop = asyncio.get_running_loop()
+        try:
+            artifact = await loop.run_in_executor(None, lambda: self.run_cognitive_cycle(task, 42))
+            success = artifact["attestation"]["attested"]
+            sig = artifact["attestation"]["signature"]
+            block_idx = artifact.get("ledger_block_index", 1)
+        except Exception as err:
+            logger.error("Execution exception encountered on %s: %s", task.task_id, str(err))
+            block = self.ledger.append_record(
+                task_id=task.task_id,
+                outcome_metrics="status=CRASHED|risk=1.0|duration=0|attested=false|rejection_reason=catastrophic_failure",
+            )
+            success = False
+            sig = getattr(block, "signature", "<placeholder>")
+            block_idx = getattr(block, "index", 1)
+
+        return {
+            "task_id": task.task_id,
+            "success": success,
+            "ledger_block_index": block_idx,
+            "ledger_signature": sig,
+            "curriculum_state": self.curriculum.export_state(),
+        }
+
+    def verify_system_health(self) -> bool:
+        return self.ledger.verify_integrity()
+
+    def shutdown(self) -> None:
+        self.controller.shutdown()
+
+
+class SecurityError(Exception):
+    """Raised when cryptographic data structures show validation failures."""