Add stage 8 upgrades

blux/agent/advanced/adaptive_memory.py

@@ -1,54 +1,57 @@
-from datetime import datetime
+# blux/agent/advanced/adaptive_memory.py
+
+import time
+from threading import Lock
 
 class AdaptiveMemory:
     """
-    Implements advanced adaptive memory for BLUX-cA agents.
-    Features:
-    - Long-term and weighted memory
-    - Reinforcement loops based on interactions
-    - Memory decay for outdated or irrelevant entries
+    Thread-safe adaptive memory for BLUX-cA agents.
+    Supports decay, priority weighting, tag-based recall, and checkpointing.
     """
-    def __init__(self, decay_rate=0.01):
-        self.memory_store = []
-        self.decay_rate = decay_rate  # Amount memory weight decays per cycle
 
-    def store(self, entry, weight=1.0):
-        """
-        Stores a memory entry with optional weight.
-        Entry format: {'input': str, 'user_type': str, 'decision': str, 'timestamp': datetime, 'weight': float}
-        """
-        memory_entry = {
-            "input": entry.get("input", ""),
-            "user_type": entry.get("user_type", "unknown"),
-            "decision": entry.get("decision", ""),
-            "timestamp": datetime.now(),
-            "weight": weight
-        }
-        self.memory_store.append(memory_entry)
-        self.reinforce(memory_entry)
+    def __init__(self):
+        self.memory_store = {}
+        self.lock = Lock()
 
-    def recall(self, filter_fn=None, top_n=None):
-        """
-        Returns filtered memory, optionally limited to top_n weighted entries.
-        """
-        memory = self.memory_store
-        if filter_fn:
-            memory = [e for e in memory if filter_fn(e)]
-        memory = sorted(memory, key=lambda x: x["weight"], reverse=True)
-        if top_n:
-            memory = memory[:top_n]
-        return memory
+    def add(self, key, value, user_type="default", priority=1, tags=None):
+        if tags is None:
+            tags = []
+        with self.lock:
+            self.memory_store[key] = {
+                "value": value,
+                "user_type": user_type,
+                "priority": priority,
+                "tags": tags,
+                "timestamp": time.time()
+            }
 
-    def reinforce(self, entry, factor=0.1):
-        """
-        Adjusts the weight of memory entries based on reinforcement.
-        Placeholder: reinforcement logic can be updated based on user success or relevance.
-        """
-        entry["weight"] += factor
-        self.apply_decay()
+    def recall(self, key, decay_rate=0.001):
+        with self.lock:
+            data = self.memory_store.get(key)
+            if not data:
+                return None
+            age = time.time() - data["timestamp"]
+            weight = max(0, data["priority"] * (1 - decay_rate * age))
+            return {"value": data["value"], "weight": weight, "tags": data["tags"]}
 
-    def apply_decay(self):
-        """
+    def recall_by_tag(self, tag):
+        with self.lock:
+            return [
+                {key: data}
+                for key, data in self.memory_store.items()
+                if tag in data["tags"]
+            ]e_path="memory_checkpoint.json"):
+        with self.lock:
+            with open(file_path, "w") as f:
+                json.dump(self.memory_store, f, indent=2)
+
+    def load_checkpoint(self, file_path="memory_checkpoint.json"):
+        try:
+            with open(file_path, "r") as f:
+                with self.lock:
+                    self.memory_store = json.load(f)
+        except FileNotFoundError:
+            self.memory_store = {}     """
         Applies decay to all memory entries to reduce relevance of older/unimportant items.
         """
         for entry in self.memory_store:

blux/agent/advanced/monitoring.py

@@ -1,43 +1,48 @@
+# blux/agent/advanced/monitoring.py
+
+import logging
+import json
 import time
-from threading import Thread
+from threading import Lock, Thread
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("BLUX-cA-Monitor")
 
-class MonitoringDashboard:
+class AgentMonitor:
     """
-    Real-time monitoring dashboard for BLUX-cA agents.
-    Features:
-    - Live console monitoring
-    - Optional threaded update
-    - Integration with SecureController
+    Monitors BLUX-cA agent actions:
+    - Input processing
+    - Memory updates
+    - Reasoning/strategy decisions
+    - Audit compliance
     """
-    def __init__(self, controller):
-        self.controller = controller
-        self.running = False
 
-    def show_status(self):
-        agents = getattr(self.controller.registry, "agents", {})
-        adaptors = getattr(self.controller.registry, "adaptors", {})
-        evaluators = getattr(self.controller.registry, "evaluators", {})
-        print("=== BLUX-cA System Status ===")
-        print(f"Agents registered: {list(agents.keys())}")
-        print(f"Adaptors registered: {list(adaptors.keys())}")
-        print(f"Evaluators registered: {list(evaluators.keys())}")
-        print("==============================")
+    def __init__(self, log_file="blux_agent.log"):
+        self.log_file = log_file
+        self.lock = Lock()
+        self.logs = []
 
-    def live_monitor(self, interval=5):
-        """
-        Continuously display system status every `interval` seconds.
-        """
-        self.running = True
-        try:
-            while self.running:
-                self.show_status()
-                time.sleep(interval)
-        except KeyboardInterrupt:
-            print("Monitoring stopped.")
+    def log_action(self, agent_name, action_type, details):
+        entry = {
+            "timestamp": time.time(),
+            "agent": agent_name,
+            "action": action_type,
+            "details": details
+        }
+        with self.lock:
+            self.logs.append(entry)
+            try:
+                with open(self.log_file, "a") as f:
+                    f.write(json.dumps(entry) + "\n")
+            except Exception as e:
+                logger.error(f"Failed to write log: {e}")
 
-    def start_threaded_monitor(self, interval=5):
-        """
-        Starts monitoring in a separate thread, allowing main process to continue.
+    def get_logs(self, agent_name=None):
+        with self.lock:
+            if agent_name:
+                return [log for log in self.logs if log["agent"] == agent_name]
+            return list(self.logs)g for log in self.logs if log["agent"] == agent_name]
+            return list(self.logs)ts monitoring in a separate thread, allowing main process to continue.
         """
         thread = Thread(target=self.live_monitor, args=(interval,), daemon=True)
         thread.start()

blux/agent/advanced/multi_agent.py

@@ -1,74 +1,155 @@
+# blux/agent/advanced/multi_agent.py
+
+from blux.agent.advanced.reasoning import ReasoningLayer
+
 class MultiAgentManager:
     """
-    Manages multiple BLUX-cA agents simultaneously.
-    Features:
-    - Task delegation
-    - Broadcast and aggregation of responses
-    - Conflict resolution based on constitutional rules
+    Multi-agent manager with memory broadcasting, secure monitoring,
+    reasoning integration, and constitutional enforcement.
     """
+
     def __init__(self, constitution=None):
         self.agents = {}
-        self.constitution = constitution  # Optional: used for arbitration
+        self.constitution = constitution
+        self.monitor = None
+        self.reasoning = {}
+
+    def attach_monitor(self, monitor):
+        self.monitor = monitor
 
     def register_agent(self, name, agent_instance):
         self.agents[name] = agent_instance
+        # Attach reasoning layer per agent
+        self.reasoning[name] = ReasoningLayer(agent_instance, constitution=self.constitution)
+        if self.monitor:
+            self.monitor.log(name, "agent_registered")
 
-    def broadcast_input(self, user_input):
+    def _enforce_constitution(self, agent_name, response):
         """
-        Sends input to all registered agents and returns their responses in a dict.
+        Placeholder for rule enforcement.
+        Could veto, flag, or alter responses that violate constitutional rules.
         """
+        if self.constitution and "violation" in response:
+            if self.monitor:
+                self.monitor.log(agent_name, "constitutional_violation", {"response": response})
+            return "[VIOLATION DETECTED]"
+        return response
+
+    def broadcast_input(self, user_input, user_type="unknown"):
         results = {}
         for name, agent in self.agents.items():
-            results[name] = agent.process_input(user_input)
+            reasoning = self.reasoning[name]
+            reasoning_result = reasoning.process(user_input, user_type=user_type)
+            resp = self._enforce_constitution(name, reasoning_result["decision"])
+            results[name] = resp
+            if self.monitor:
+                self.monitor.log(name, "input_processed", {
+                    "input": user_input,
+                    "response": resp,
+                    "reasoning": reasoning_result
+                })
         return results
 
-    def delegate_task(self, user_input, target_agent=None):
-        """
-        Sends input to a specific agent or selects one dynamically.
-        Returns a dict of {agent_name: response}.
-        """
+    def delegate_task(self, user_input, target_agent=None, user_type="unknown"):
         if target_agent and target_agent in self.agents:
-            return {target_agent: self.agents[target_agent].process_input(user_input)}
+            resp = self.broadcast_input(user_input, user_type)[target_agent]
+            if self.monitor:
+                self.monitor.log(target_agent, "task_delegated", {"input": user_input, "response": resp})
+            return {target_agent: resp}
         elif self.agents:
-            # Default: choose first agent
             first_agent_name = next(iter(self.agents))
-            return {first_agent_name: self.agents[first_agent_name].process_input(user_input)}
+            resp = self.broadcast_input(user_input, user_type)[first_agent_name]
+            if self.monitor:
+                self.monitor.log(first_agent_name, "task_delegated", {"input": user_input, "response": resp})
+            return {first_agent_name: resp}
         else:
+            if self.monitor:
+                self.monitor.log("manager", "task_delegated_failed", {"input": user_input})
             return {"error": "No agents registered"}
 
+    def broadcast_memory(self, key, value, user_type="default", priority=1, tags=None):
+        for agent in self.agents.values():
+            if hasattr(agent, "memory"):
+                agent.memory.add(key, value, user_type=user_type, priority=priority, tags=tags or [])
+                if self.monitor:
+                    self.monitor.log(agent.name, "memory_broadcast", {"key": key, "value": value, "tags": tags})
+
+    def aggregate_memory(self, key, predictive=True):
+        aggregated = []
+        for name, agent in self.agents.items():
+            if hasattr(agent, "memory"):
+                entries = agent.memory.recall(key)
+                if entries:
+                    if predictive:
+                        weighted = [e for e in entries if "urgent" in e.get("tags", [])]
+                        aggregated.extend(weighted or entries)
+                    else:
+                        aggregated.extend(entries)
+        if self.monitor:
+            self.monitor.log("manager", "memory_aggregated", {"key": key, "entries": aggregated})
+        return aggregated
+
+    def resolve_conflict(self, responses, use_prediction=True):
+        enforced = {agent: self._enforce_constitution(agent, resp) for agent, resp in responses.items()}
+        if use_prediction:
+            sorted_agents = sorted(
+                enforced.keys(),
+                key=lambda name: getattr(self.reasoning[name], "predict_behavior", lambda x: [1])(None)[0] if hasattr(self.reasoning[name], "predict_behavior") else 1,
+                reverse=True
+            )
+            resolved = {a: enforced[a] for a in sorted_agents}
+        else:
+            resolved = enforced
+        return "\n".join(f"[{agent}] {resp}" for agent, resp in resolved.items())
+
     def aggregate_responses(self, responses):
+        return "\n".join(f"[{agent}] {resp}" for agent, resp in responses.items())ive aggregation =====
+    def broadcast_memory(self, key, value, user_type="default", priority=1, tags=None):
+        for agent in self.agents.values():
+            if hasattr(agent, "memory"):
+                agent.memory.add(key, value, user_type=user_type, priority=priority, tags=tags or [])
+                if self.monitor:
+                    self.monitor.log(agent.name, "memory_broadcast", {"key": key, "value": value, "tags": tags})
+
+    def aggregate_memory(self, key, predictive=True):
         """
-        Aggregates multiple agent responses.
-        Simple placeholder: concatenates results; could use voting or constitution-based arbitration.
+        Aggregates memory across all agents.
+        If predictive=True, weights results based on reasoning predictions.
         """
-        if not responses:
-            return "No responses to aggregate."
         aggregated = []
-        for agent_name, response in responses.items():
-            aggregated.append(f"[{agent_name}] {response}")
-        return "\n".join(aggregated)
+        for name, agent in self.agents.items():
+            if hasattr(agent, "memory"):
+                entries = agent.memory.recall(key)
+                if entries:
+                    if predictive:
+                        # Simple weighting: prioritize entries tagged as urgent or from predicted struggler
+                        weighted = [e for e in entries if "urgent" in e.get("tags", [])]
+                        aggregated.extend(weighted or entries)
+                    else:
+                        aggregated.extend(entries)
+        if self.monitor:
+            self.monitor.log("manager", "memory_aggregated", {"key": key, "entries": aggregated})
+        return aggregated
 
-    def resolve_conflict(self, responses):
+    # ===== Stage 6: Response aggregation & advanced conflict resolution =====
+    def resolve_conflict(self, responses, use_prediction=True):
         """
-        Optional: Resolve conflicting responses using constitutional rules.
-        Placeholder: currently returns aggregated response.
+        Stage 6 conflict resolution:
+        - Enforce constitutional rules
+        - Optionally use reasoning prediction to weight responses
         """
-        # Future: implement rule-based arbitration
-        return self.aggregate_responses(responses)
-
-
-# Example usage:
-if __name__ == "__main__":
-    from blux.agent.core_agent import BLUXAgent
-
-    # Create multiple agents
-    agent1 = BLUXAgent(name="Agent_A")
-    agent2 = BLUXAgent(name="Agent_B")
-
-    manager = MultiAgentManager()
-    manager.register_agent(agent1.name, agent1)
-    manager.register_agent(agent2.name, agent2)
+        enforced = {agent: self._enforce_constitution(agent, resp) for agent, resp in responses.items()}
+        if use_prediction:
+            # Simple prediction-based sorting: 'struggler' > 'neutral' > 'indulgent'
+            sorted_agents = sorted(
+                enforced.keys(),
+                key=lambda name: self.reasoning[name].predict_behavior("")[0] if hasattr(self.reasoning[name], "predict_behavior") else 1,
+                reverse=True
+            )
+            resolved = {a: enforced[a] for a in sorted_agents}
+        else:
+            resolved = enforced
+        return "\n".join(f"[{agent}] {resp}" for agent, resp in resolved.items())
 
-    input_text = "I need help with a problem"
-    responses = manager.broadcast_input(input_text)
-    print("Aggregated responses:\n", manager.aggregate_responses(responses))
+    def aggregate_responses(self, responses):
+        return "\n".join(f"[{agent}] {resp}" for agent, resp in responses.items())

blux/agent/advanced/reasoning.py

@@ -1,3 +1,5 @@
+# blux/agent/advanced/reasoning.py
+
 from datetime import datetime
 
 class ReasoningLayer:
@@ -14,46 +16,25 @@ class ReasoningLayer:
         self.constitution = constitution
 
     def select_strategy(self, user_input, user_type="unknown"):
-        """
-        Chooses response strategy based on input type and memory patterns.
-        """
         if user_type == "struggler":
-            strategy = "validate_and_guide"
+            return "validate_and_guide"
         elif user_type == "indulgent":
-            strategy = "set_boundaries"
+            return "set_boundaries"
         else:
-            strategy = "neutral_response"
-        return strategy
+            return "neutral_response"
 
     def meta_cognition(self, user_input, decision):
-        """
-        Evaluates the agent's own decision for consistency with constitutional rules.
-        """
-        # Placeholder for rules-based evaluation
         audit_result = {"compliant": True, "notes": "Decision aligns with constitution"}
-        # Could integrate memory reinforcement or corrections
         return audit_result
 
     def predict_behavior(self, user_input, memory_entries=None):
-        """
-        Optional: Predicts likely patterns (struggler/indulgent tendencies) from memory.
-        """
-        if memory_entries is None:
-            memory_entries = self.agent.memory.recall()
-        # Simple heuristic placeholder
-        prediction = "struggler" if any("help" in e["input"].lower() for e in memory_entries) else "neutral"
+        if memory_entries is None and hasattr(self.agent, "memory"):
+            memory_entries = [self.agent.memory.recall(user_input)]
+        prediction = "struggler" if any(memory_entries) and "help" in str(memory_entries).lower() else "neutral"
         return prediction
 
     def process(self, user_input, user_type="unknown"):
-        """
-        Full reasoning pipeline:
-        1. Select strategy
-        2. Make decision via agent
-        3. Self-audit decision
-        4. Optional predictive behavior
-        """
         strategy = self.select_strategy(user_input, user_type)
-        # Agent processes input
         decision = self.agent.process_input(user_input)
         audit = self.meta_cognition(user_input, decision)
         prediction = self.predict_behavior(user_input)
@@ -64,6 +45,20 @@ class ReasoningLayer:
             "audit": audit,
             "prediction": prediction,
             "timestamp": datetime.utcnow().isoformat()
+        }trategy.
+        """
+        if strategy == "default":
+            return f"{self.agent_name} considers: {user_input}"
+        elif strategy == "reflective":
+            past = memory_context["value"] if memory_context else "nothing"
+            return f"{self.agent_name} reflects: {user_input} (past: {past})"
+        elif strategy == "aggressive":
+            return f"{self.agent_name} aggressively resolves: {user_input}"
+        else:
+            return f"{self.agent_name} handles: {user_input}": decision,
+            "audit": audit,
+            "prediction": prediction,
+            "timestamp": datetime.utcnow().isoformat()
         }
 
 # Example usage:

blux/agent/constitution.py

@@ -10,8 +10,8 @@ class Constitution:
         ]
 
     def apply_rules(self, user_input, user_type):
-        # Simplified placeholder: returns a decision string
         if user_type == "struggler":
             return "validate and provide guidance"
+        return "set boundaries / off-ramp"provide guidance"
         else:
             return "set boundaries / off-ramp"

blux/agent/core_agent.py

@@ -19,14 +19,11 @@ class BLUXAgent:
         self.audit = AuditTrail()
 
     def process_input(self, user_input):
-        # 1. Analyze input via discernment
         user_type = self.discernment.classify(user_input)
-
-        # 2. Apply constitutional rules
         decision = self.constitution.apply_rules(user_input, user_type)
-
-        # 3. Store context in memory
         self.memory.store(user_input, user_type, decision)
+        self.audit.log(user_input, user_type, decision)
+        return f"[{user_type}] Decision: {decision}"pe, decision)
 
         # 4. Record audit
         self.audit.log(user_input, user_type, decision)

blux/agent/discernment.py

@@ -5,8 +5,8 @@ class DiscernmentCompass:
     - Indulgent: boundary & off-ramp
     """
     def classify(self, user_input):
-        # Placeholder logic: keyword based for demo
         if any(word in user_input.lower() for word in ["help", "struggle", "problem"]):
             return "struggler"
+        return "indulgent"       return "struggler"
         else:
             return "indulgent"

blux/agent/memory.py

@@ -13,11 +13,10 @@ class Memory:
             "decision": decision
         }
         self.session_memory.append(entry)
-        # Placeholder for consented long-term memory
-        self.long_term_memory.append(entry)
+        self.long_term_memory.append(entry)  # placeholder for consented storage
 
     def recall_session(self):
         return self.session_memory
 
     def recall_long_term(self):
-        return self.long_term_memory
+        return self.long_term_memorylong_term_memory