logos/agents/scout.py

import logging
import time
from logos.manifold_state import ManifoldState

logger = logging.getLogger("ScoutAgent")

class ScoutAgent:
    """
    Protocol 7: Recursive Scout Agent
    Implements the 'Recursive Language Model' (arXiv:2512.24601) paradigm.
    Treats the Manifold Graph as an external environment to be traversed recursively.
    """
    def __init__(self, start_node=None):
        self.manifold = ManifoldState()
        self.graph = self.manifold.state.get("graph", {})
        self.nodes = {n["id"]: n for n in self.graph.get("nodes", [])}
        self.edges = self.graph.get("edges", [])
        self.start_node = start_node
        self.mission_log = []

    def recursive_traverse(self, node_id=None, depth=0, max_depth=5):
        """
        The Core Recursive Operator.
        Drills down from Outer Shell (High Entropy) to Inner Shell (Structure).
        """
        if depth > max_depth:
            return

        if node_id is None:
            # Start at a random Outer Shell node if not specified
            candidates = [n for n in self.nodes.values() if n["geometry"]["domain"] == "OUTER_SHELL"]
            if not candidates:
                logger.warning("No Outer Shell nodes found to start traversal.")
                return
            node_id = candidates[0]["id"]

        current_node = self.nodes.get(node_id)
        if not current_node: return

        # 1. Observe (Read the Node)
        indent = "  " * depth
        domain = current_node["geometry"]["domain"]
        log_entry = f"{indent}Visiting [{domain}] {current_node['name']} (ID: {node_id})"
        logger.info(log_entry)
        self.mission_log.append(log_entry)
        
        # 2. Act (Find Connections)
        # We value connections that lead "Deeper" into Logic (Prime) or Structure (Inner)
        connections = [
            e for e in self.edges 
            if e["source"] == node_id or e["target"] == node_id
        ]
        
        # Sort connections by weight (Resonance)
        connections.sort(key=lambda x: x["weight"], reverse=True)

        # 3. Recurse (Traverse Neighbors)
        # Limit recursion to top 2 strongest links to prevent explosion
        for link in connections[:2]:
            neighbor_id = link["target"] if link["source"] == node_id else link["source"]
            neighbor = self.nodes.get(neighbor_id)
            if not neighbor: continue
            
            # recursive call
            self.recursive_traverse(neighbor_id, depth + 1, max_depth)

    def report(self):
        """Returns the Mission Log."""
        return "\n".join(self.mission_log)

if __name__ == "__main__":
    # Test Run
    scout = ScoutAgent()
    print("Scout initializing sequence...")
    scout.recursive_traverse()
    print("\n--- MISSION LOG ---")
    print(scout.report())