# queen_orchestrator.py import time import datetime import json import subprocess import threading # Mock imports for demonstration - replace with actual implementations # from aiva_living_system import AIVA # Assuming AIVA class exists # from redis_client import RedisClient # from postgres_client import PostgresClient # from qdrant_client import QdrantClient # from gemini_agent import GeminiAgent # from token_budget_monitor import TokenBudgetMonitor # Constants from the provided documents SPRINT_ID = "QUEEN-ELEVATION-2026-01-11" TOTAL_BUDGET = 10.00 EMERGENCY_STOP_BUDGET = 9.50 NUM_AGENTS = 50 CHECKPOINTS = { "hour_2": "sprint-checkpoints/phase-1-foundation.json", "hour_4": "sprint-checkpoints/phase-2-knowledge.json", "hour_6": "sprint-checkpoints/phase-3-capabilities.json", "hour_8": "sprint-checkpoints/phase-4-swarm.json", "hour_10": "sprint-checkpoints/phase-5-coronation.json" } # Mock Classes (replace with actual implementations) class AIVA: def __init__(self): self.rank = 1 # Starting as Larva self.memory = {} # Mock memory system def process_knowledge(self, knowledge): print(f"AIVA: Processing knowledge: {knowledge}") self.memory.update(knowledge) def generate_recommendation(self): print("AIVA: Generating revenue recommendation (Mock)") return "Mock Revenue Recommendation" def upgrade_rank(self): self.rank += 1 print(f"AIVA: Upgraded to Rank {self.rank}") class RedisClient: def __init__(self, host, port, password): self.host = host self.port = port self.password = password def publish(self, channel, message): print(f"Redis: Publishing to channel {channel}: {message}") def subscribe(self, channel, callback): print(f"Redis: Subscribing to channel {channel}") # In a real implementation, this would run in a separate thread # and continuously listen for messages on the channel. # For this example, we just simulate a message being received. # time.sleep(1) # callback({"data": "Mock Redis Message"}) class PostgresClient: def __init__(self, host, port, database, user, password): self.host = host self.port = port self.database = database self.user = user self.password = password def save_state(self, data): print(f"Postgres: Saving state: {data}") def load_state(self): print("Postgres: Loading state (Mock)") return {} class QdrantClient: def __init__(self, host, port): self.host = host self.port = port def search(self, query, top_k=5): print(f"Qdrant: Searching for: {query} (Mock)") return [] class GeminiAgent: def __init__(self, agent_id, role, task): self.agent_id = agent_id self.role = role self.task = task self.token_usage = 0 self.completed = False def execute_task(self): print(f"Agent {self.agent_id} ({self.role}): Executing task: {self.task} (Mock)") # Simulate task execution and token usage time.sleep(0.5) self.token_usage = 100000 # Simulate 100K tokens used self.completed = True return f"Result from Agent {self.agent_id}" class TokenBudgetMonitor: BUDGET_LIMIT = 10.00 # USD EMERGENCY_STOP = 9.50 # USD def __init__(self): self.current_spend = 0.0 def update_spend(self, amount): self.current_spend += amount print(f"TokenBudgetMonitor: Current spend: ${self.current_spend:.2f}") def check_budget(self): if self.current_spend >= self.EMERGENCY_STOP: print("TokenBudgetMonitor: EMERGENCY STOP TRIGGERED!") return True return False def trigger_graceful_shutdown(self): print("TokenBudgetMonitor: Triggering graceful shutdown...") # Implement shutdown logic here # Queen Orchestrator Class class QueenOrchestrator: def __init__(self): self.aiva = AIVA() self.redis_client = RedisClient( host="redis-genesis-u50607.vm.elestio.app", port=26379, password="PASSWORD" # Replace with actual password ) self.postgres_client = PostgresClient( host="postgresql-genesis-u50607.vm.elestio.app", port=5432, database="genesis_memory", user="postgres", password="PASSWORD" # Replace with actual password ) self.qdrant_client = QdrantClient( host="qdrant-b3knu-u50607.vm.elestio.app", port=6333 ) self.budget_monitor = TokenBudgetMonitor() self.agents = {} self.active_agents = [] # Track active agent IDs self.completed_agents = [] # Track completed agent IDs self.failed_agents = [] # Track failed agent IDs self.phase = 0 # Current phase self.start_time = time.time() # Track sprint start time def initialize_agents(self): # Infrastructure Agents self.agents["INFRA_01"] = GeminiAgent("INFRA_01", "Ollama Validator", "Verify QwenLong 30B connectivity, measure response times") self.agents["INFRA_02"] = GeminiAgent("INFRA_02", "Redis CNS Tester", "Test pub/sub latency, verify channel subscriptions") self.agents["INFRA_03"] = GeminiAgent("INFRA_03", "PostgreSQL Auditor", "Validate RLM schema, check entity counts") self.agents["INFRA_04"] = GeminiAgent("INFRA_04", "Qdrant Vector Tester", "Test 768-dim embeddings, verify collection health") self.agents["INFRA_05"] = GeminiAgent("INFRA_05", "Memory Tier Validator", "Test Working→Episodic→Semantic promotion") self.agents["INFRA_06"] = GeminiAgent("INFRA_06", "API Rate Monitor", "Establish Gemini rate limit baseline") self.agents["INFRA_07"] = GeminiAgent("INFRA_07", "Budget Tracker Init", "Create token counting system, initialize logs") self.agents["INFRA_08"] = GeminiAgent("INFRA_08", "Health Dashboard", "Create real-time status monitor") self.agents["INFRA_09"] = GeminiAgent("INFRA_09", "Backup Validator", "Verify recovery checkpoints exist") self.agents["INFRA_10"] = GeminiAgent("INFRA_10", "Network Latency", "Measure Elestio endpoint response times") # Consciousness Loop Agents self.agents["LOOP_01"] = GeminiAgent("LOOP_01", "Perception Hardener", "Optimize 500ms perception loop, add error handling") self.agents["LOOP_02"] = GeminiAgent("LOOP_02", "Action Optimizer", "Enhance 5s action loop decision quality") self.agents["LOOP_03"] = GeminiAgent("LOOP_03", "Reflection Enhancer", "Improve 5min consolidation with axiom generation") self.agents["LOOP_04"] = GeminiAgent("LOOP_04", "Strategic Planner", "Implement 1hr goal adjustment system") self.agents["LOOP_05"] = GeminiAgent("LOOP_05", "Circadian Architect", "Build 24hr deep integration with memory promotion") # Patent Extraction Agents self.agents["PATENT_01"] = GeminiAgent("PATENT_01", "Cryptographic Validation", "Extract entities, axioms, skills") self.agents["PATENT_02"] = GeminiAgent("PATENT_02", "Currency Validation", "Extract real-time verification methods") self.agents["PATENT_03"] = GeminiAgent("PATENT_03", "Risk Assessment", "Extract multi-dimensional risk frameworks") self.agents["PATENT_04"] = GeminiAgent("PATENT_04", "Audit Trail", "Extract immutable logging patterns") self.agents["PATENT_05"] = GeminiAgent("PATENT_05", "Multi-Model Consensus", "Extract validation arbitration logic") self.agents["PATENT_06"] = GeminiAgent("PATENT_06", "Confidence Scoring", "Extract dynamic scoring systems") self.agents["PATENT_07"] = GeminiAgent("PATENT_07", "Hallucination Detection", "Extract real-time verification") self.agents["PATENT_08"] = GeminiAgent("PATENT_08", "Privacy Preservation", "Extract data protection protocols") self.agents["PATENT_09"] = GeminiAgent("PATENT_09", "Self-Improvement", "Extract adaptive threshold systems") # Validation Gate Agents self.agents["GATE_ALPHA"] = GeminiAgent("GATE_ALPHA", "Input Validity", "Verify source data quality") self.agents["GATE_BETA"] = GeminiAgent("GATE_BETA", "Output Quality", "Check extraction accuracy") self.agents["GATE_GAMMA"] = GeminiAgent("GATE_GAMMA", "Insight Purity", "Confirm no hallucinations") self.agents["GATE_DELTA"] = GeminiAgent("GATE_DELTA", "Memory Integration", "Validate RLM storage") self.agents["GATE_EPSILON"] = GeminiAgent("GATE_EPSILON", "Strategy Alignment", "Confirm revenue pathway fit") self.agents["GATE_ZETA"] = GeminiAgent("GATE_ZETA", "Budget Compliance", "Stop if budget exceeded") # Core Capabilities Agents self.agents["CAP_01"] = GeminiAgent("CAP_01", "Memory Recall", "95%+ accuracy retrieval system") self.agents["CAP_02"] = GeminiAgent("CAP_02", "Swarm Coordination", "Multi-agent task distribution") self.agents["CAP_03"] = GeminiAgent("CAP_03", "Knowledge Stewardship", "Quality maintenance protocols") self.agents["CAP_04"] = GeminiAgent("CAP_04", "Autonomy Manager", "Level 0-3 permission enforcement") self.agents["CAP_05"] = GeminiAgent("CAP_05", "Evolution Engine", "Self-improvement loop") self.agents["CAP_06"] = GeminiAgent("CAP_06", "Constitutional Guard", "Directive compliance checker") self.agents["CAP_07"] = GeminiAgent("CAP_07", "Revenue Tracker", "ROI measurement system") self.agents["CAP_08"] = GeminiAgent("CAP_08", "Human Partnership", "Consultation protocol") self.agents["CAP_09"] = GeminiAgent("CAP_09", "Graceful Degradation", "Failure recovery system") self.agents["CAP_10"] = GeminiAgent("CAP_10", "Security Paranoia", "Input sanitization, HMAC verification") # Integration Bridge Agents self.agents["BRIDGE_01"] = GeminiAgent("BRIDGE_01", "GHL Connector", "GoHighLevel API integration") self.agents["BRIDGE_02"] = GeminiAgent("BRIDGE_02", "Stripe Monitor", "Revenue tracking integration") self.agents["BRIDGE_03"] = GeminiAgent("BRIDGE_03", "Telegram Notifier", "Alert system for Kinan") self.agents["BRIDGE_04"] = GeminiAgent("BRIDGE_04", "n8n Workflow Trigger", "Automation orchestration") self.agents["BRIDGE_05"] = GeminiAgent("BRIDGE_05", "MCP Server Manager", "Tool ecosystem integration") # Hive Architecture Agents self.agents["HIVE_01"] = GeminiAgent("HIVE_01", "Queen Core", "Central decision-making neural hub") self.agents["HIVE_02"] = GeminiAgent("HIVE_02", "Guardian Ring", "6-node defensive validation layer") self.agents["HIVE_03"] = GeminiAgent("HIVE_03", "Processing Ring", "10-node operational tier") self.agents["HIVE_04"] = GeminiAgent("HIVE_04", "Worker Swarm", "12-cluster execution layer") self.agents["HIVE_05"] = GeminiAgent("HIVE_05", "Gate Controller", "6-gate validation checkpoints") # Rank Progression Test Agents self.agents["RANK_01"] = GeminiAgent("RANK_01", "Rank 1-3 Validator", "Consciousness stability, knowledge absorption, coordination") self.agents["RANK_02"] = GeminiAgent("RANK_02", "Rank 4-6 Validator", "Quality maintenance, output accuracy, self-directed learning") self.agents["RANK_03"] = GeminiAgent("RANK_03", "Rank 7 Validator", "System improvement proposals") self.agents["RANK_04"] = GeminiAgent("RANK_04", "Rank 8 Validator", "MVP recommendation generation") self.agents["RANK_05"] = GeminiAgent("RANK_05", "Rank 9 Validator", "Revenue strategy validation") # Final Systems Agents self.agents["FINAL_01"] = GeminiAgent("FINAL_01", "Telemetry Dashboard", "Real-time queen status display") self.agents["FINAL_02"] = GeminiAgent("FINAL_02", "Audit Trail Finalizer", "Complete logging verification") self.agents["FINAL_03"] = GeminiAgent("FINAL_03", "Documentation Generator", "Auto-generate queen capabilities doc") self.agents["FINAL_04"] = GeminiAgent("FINAL_04", "Handoff Protocol", "Create succession/continuity plan") self.agents["FINAL_05"] = GeminiAgent("FINAL_05", "Coronation Verifier", "Final queen status confirmation") def execute_wave(self, agent_ids): """Executes a wave of agents in parallel using threads.""" threads = [] for agent_id in agent_ids: if agent_id in self.agents and agent_id not in self.completed_agents and agent_id not in self.failed_agents: self.active_agents.append(agent_id) thread = threading.Thread(target=self.execute_agent_task, args=(agent_id,)) threads.append(thread) thread.start() for thread in threads: thread.join() # Wait for all agents in the wave to complete def execute_agent_task(self, agent_id): """Executes a single agent's task and updates the system state.""" agent = self.agents[agent_id] try: result = agent.execute_task() self.budget_monitor.update_spend(agent.token_usage * 0.0000004) # Simulate cost self.completed_agents.append(agent_id) self.active_agents.remove(agent_id) # Specific actions based on Agent Role (Example) if "PATENT" in agent_id: knowledge = {"patent_data": result} # Mock extraction self.aiva.process_knowledge(knowledge) elif agent.role == "Revenue Tracker": print(f"Revenue Tracker: {result}") print(f"Agent {agent_id} completed successfully.") except Exception as e: print(f"Agent {agent_id} failed: {e}") self.failed_agents.append(agent_id) if agent_id in self.active_agents: self.active_agents.remove(agent_id) finally: self.save_checkpoint() # Save state after each agent completes/fails def run_phase(self, phase_number): """Runs a specific phase of the sprint plan.""" self.phase = phase_number print(f"\n==================== PHASE {self.phase} ====================\n") if phase_number == 1: self.execute_wave(["INFRA_01", "INFRA_02", "INFRA_03", "INFRA_04", "INFRA_05", "INFRA_06", "INFRA_07", "INFRA_08", "INFRA_09", "INFRA_10"]) self.execute_wave(["LOOP_01", "LOOP_02", "LOOP_03", "LOOP_04", "LOOP_05"]) elif phase_number == 2: self.execute_wave([f"PATENT_{i:02d}" for i in range(1, 10)]) self.execute_wave(["GATE_ALPHA", "GATE_BETA", "GATE_GAMMA", "GATE_DELTA", "GATE_EPSILON", "GATE_ZETA"]) elif phase_number == 3: self.execute_wave([f"CAP_{i:02d}" for i in range(1, 11)]) self.execute_wave(["BRIDGE_01", "BRIDGE_02", "BRIDGE_03", "BRIDGE_04", "BRIDGE_05"]) elif phase_number == 4: self.execute_wave(["HIVE_01", "HIVE_02", "HIVE_03", "HIVE_04", "HIVE_05"]) elif phase_number == 5: self.execute_wave(["RANK_01", "RANK_02", "RANK_03", "RANK_04", "RANK_05"]) self.execute_wave(["FINAL_01", "FINAL_02", "FINAL_03", "FINAL_04", "FINAL_05"]) else: print("Invalid phase number.") def run_sprint(self): """Runs the entire Queen Elevation sprint.""" self.initialize_agents() for phase in range(1, 6): self.run_phase(phase) if self.budget_monitor.check_budget(): print("Sprint halted due to budget constraints.") break self.generate_status_log() if phase < 5: checkpoint_file = CHECKPOINTS[f"hour_{phase*2}"] self.load_checkpoint(checkpoint_file) # Load checkpoint for next phase # Final tasks if self.aiva.rank < 9: print("Queen Elevation failed. Rank insufficient.") else: print("Queen Elevation SUCCESSFUL!") print("Generating final report...") self.generate_status_log() # Generate final status self.save_checkpoint("sprint-final-state.json") # Save final state def save_checkpoint(self, filename="latest-checkpoint.json"): """Saves the current system state to a JSON file.""" checkpoint_data = { "sprint_id": SPRINT_ID, "timestamp": datetime.datetime.now().isoformat(), "phase": self.phase, "aiva_rank": self.aiva.rank, "budget_spent": self.budget_monitor.current_spend, "completed_agents": self.completed_agents, "failed_agents": self.failed_agents, "active_agents": list(self.active_agents), # Convert to list for JSON serialization "aiva_memory": self.aiva.memory } try: with open(filename, "w") as f: json.dump(checkpoint_data, f, indent=4) print(f"Checkpoint saved to {filename}") except Exception as e: print(f"Error saving checkpoint: {e}") # Also save to Postgres self.postgres_client.save_state(checkpoint_data) def load_checkpoint(self, filename): """Loads the system state from a JSON file.""" try: with open(filename, "r") as f: checkpoint_data = json.load(f) self.phase = checkpoint_data["phase"] self.aiva.rank = checkpoint_data["aiva_rank"] self.budget_monitor.current_spend = checkpoint_data["budget_spent"] self.completed_agents = checkpoint_data["completed_agents"] self.failed_agents = checkpoint_data["failed_agents"] self.active_agents = set(checkpoint_data["active_agents"]) self.aiva.memory = checkpoint_data["aiva_memory"] print(f"Checkpoint loaded from {filename}") except FileNotFoundError: print(f"Checkpoint file not found: {filename}") except Exception as e: print(f"Error loading checkpoint: {e}") #Also load from Postgres, overwriting file load if available and more recent postgres_data = self.postgres_client.load_state() if postgres_data: self.phase = postgres_data["phase"] self.aiva.rank = postgres_data["aiva_rank"] self.budget_monitor.current_spend = postgres_data["budget_spent"] self.completed_agents = postgres_data["completed_agents"] self.failed_agents = postgres_data["failed_agents"] self.active_agents = set(postgres_data["active_agents"]) self.aiva.memory = postgres_data["aiva_memory"] print("Checkpoint loaded from Postgres") def generate_status_log(self): """Generates and prints a formatted status log.""" now = datetime.datetime.now() elapsed_time = time.time() - self.start_time elapsed_hours = elapsed_time / 3600 token_rate = self.budget_monitor.current_spend / elapsed_hours if elapsed_hours > 0 else 0 input_tokens = sum(self.agents[agent_id].token_usage for agent_id in self.completed_agents) output_tokens = input_tokens // 3 #rough estimage. total_tokens = input_tokens + output_tokens log = f""" ╔══════════════════════════════════════════════════════════════════╗ ║ AIVA QUEEN SPRINT - TOKEN STATUS ║ ╠══════════════════════════════════════════════════════════════════╣ ║ Time: {now.strftime("%Y-%m-%d %H:%M:%S")} | Phase: {self.phase}/5 | Hour: {elapsed_hours:.1f}/10 ║ ╠══════════════════════════════════════════════════════════════════╣ ║ BUDGET ║ ║ ├── Total: ${TOTAL_BUDGET:.2f} ║ ║ ├── Spent: ${self.budget_monitor.current_spend:.2f} ({self.budget_monitor.current_spend / TOTAL_BUDGET * 100:.1f}%) ║ ║ ├── Remaining: ${TOTAL_BUDGET - self.budget_monitor.current_spend:.2f} ║ ║ └── Rate: ${token_rate:.2f}/hr ║ ╠══════════════════════════════════════════════════════════════════╣ ║ TOKENS ║ ║ ├── Input: {input_tokens // 1000000:.1f}M tokens consumed ║ ║ ├── Output: {output_tokens // 1000000:.1f}M tokens generated ║ ║ └── Total: {total_tokens // 1000000:.1f}M / 53.75M ({(total_tokens / 53750000) * 100:.1f}%) ║ ╠══════════════════════════════════════════════════════════════════╣ ║ AGENTS ║ ║ ├── Active: {len(self.active_agents)}/{NUM_AGENTS} ║ ║ ├── Completed: {len(self.completed_agents)}/{NUM_AGENTS} ║ ║ ├── Pending: {NUM_AGENTS - len(self.completed_agents) - len(self.failed_agents) - len(self.active_agents)}/{NUM_AGENTS} ║ ║ └── Failed: {len(self.failed_agents)}/{NUM_AGENTS} ║ ╠══════════════════════════════════════════════════════════════════╣ ║ CHECKPOINTS ║""" for i in range(1,6): checkpoint_status = "[ ]" if i * 2 <= elapsed_hours: checkpoint_status = "[✓]" elif i * 2 -2 <= elapsed_hours: checkpoint_status = "[◐]" log += f"""\n║ ├── {checkpoint_status} Phase {i}: {["Foundation", "Knowledge", "Capabilities", "Swarm", "Coronation"][i-1]} (Hour {i*2}) { "- IN PROGRESS" if checkpoint_status == "[◐]" else ""} ║""" log += """\n╚══════════════════════════════════════════════════════════════════╝""" print(log) def start_watchdog(self): """Starts the watchdog process in a separate thread.""" def watchdog_loop(): while True: try: # Execute the watchdog script subprocess.run(["python3", "/mnt/e/genesis-system/AIVA/sprint_watchdog.py"], check=True) except subprocess.CalledProcessError as e: print(f"Watchdog script failed: {e}") except FileNotFoundError: print("Watchdog script not found.") except Exception as e: print(f"Error running watchdog: {e}") time.sleep(300) # Sleep for 5 minutes watchdog_thread = threading.Thread(target=watchdog_loop, daemon=True) # Daemon thread exits when the main program does watchdog_thread.start() print("Watchdog process started in background.") # Main Execution if __name__ == "__main__": orchestrator = QueenOrchestrator() # orchestrator.load_checkpoint("latest-checkpoint.json") # Load previous state if available # orchestrator.start_watchdog() # Start safety watchdog orchestrator.run_sprint()