polyrob 0.5.0__py3-none-any.whl

modules/memory/task/lexical_retriever.py

@@ -0,0 +1,71 @@
+"""Lexical (no-embedder) cross-phase finding retriever.
+
+Drop-in for SemanticRetriever.search_similar so H-MEM section-3 (cross-phase recall)
+works on the server (no torch) instead of silently degrading. Cosine over term-frequency
+vectors — deterministic, dependency-free.
+"""
+import re
+from collections import Counter
+from typing import Any, Dict, List, Optional, Tuple
+
+
+def _toks(s: str) -> List[str]:
+    return [t for t in re.findall(r"[a-z0-9$]+", (s or "").lower()) if len(t) > 1]
+
+
+class LexicalRetriever:
+    def __init__(self, min_similarity: float = 0.1):
+        self.min_similarity = min_similarity
+
+    def search_similar(self, query: str, findings: Dict[str, List[str]],
+                       top_k: int = 3) -> List[Tuple[str, str, float]]:
+        """Search for lexically similar findings across all phases.
+
+        Args:
+            query: Query text (usually from brain_state).
+            findings: Dict of {phase_name: [finding1, finding2, ...]}.
+            top_k: Number of top results to return.
+
+        Returns:
+            List of (finding, phase_name, score) tuples sorted by score descending.
+        """
+        if not query or not findings:
+            return []
+        q = Counter(_toks(query))
+        qnorm = sum(v * v for v in q.values()) ** 0.5
+        if qnorm == 0:
+            return []
+        results: List[Tuple[str, str, float]] = []
+        for phase_name, phase_findings in findings.items():
+            for finding in (phase_findings or []):
+                if not finding or not finding.strip():
+                    continue
+                fc = Counter(_toks(finding))
+                fnorm = sum(v * v for v in fc.values()) ** 0.5
+                if fnorm == 0:
+                    continue
+                dot = sum(q[t] * fc[t] for t in q if t in fc)
+                sim = dot / (qnorm * fnorm)
+                if sim >= self.min_similarity:
+                    results.append((finding, phase_name, sim))
+        results.sort(key=lambda x: x[2], reverse=True)
+        return results[:top_k]
+
+    # ── parity stubs so the consumer can call these without guard branches ───
+
+    def embed_text(self, text: str) -> Optional[Any]:  # noqa: ARG002
+        """Parity stub — lexical path does not embed; returns None.
+
+        Returning None causes ``hierarchical_search`` in ContextRetriever to
+        bail out early (it checks ``if query_embedding is None``), which is the
+        correct fallback behaviour when no embedder is available.
+        """
+        return None
+
+    def clear_cache(self) -> None:
+        """Parity no-op — no embedding cache to clear."""
+        return None
+
+    def get_cache_stats(self) -> Dict[str, Any]:
+        """Parity no-op stats — no embedding cache."""
+        return {"cache_size": 0, "cache_limit": 0, "min_similarity": self.min_similarity}

modules/memory/task/null_context_manager.py

@@ -0,0 +1,213 @@
+"""Null object pattern for sub-agent task context.
+
+Sub-agents don't need H-MEM but the code expects the interface.
+This provides safe no-op implementations that won't crash.
+
+FIX (Jan 2026): Created to prevent AttributeError when sub-agents
+access task_context_manager methods on None.
+
+Usage:
+    if is_sub_agent:
+        agent.task_context_manager = NullTaskContextManager()
+    else:
+        agent.task_context_manager = TaskContextManager(...)
+"""
+
+import logging
+from typing import Optional, Dict, Any, List
+
+logger = logging.getLogger(__name__)
+
+
+class NullTaskContextManager:
+    """Null object for sub-agents - safe to call but does nothing.
+
+    This class implements the same interface as TaskContextManager
+    but all methods are no-ops. This allows sub-agents to safely
+    call any method without special-casing throughout the codebase.
+
+    Benefits:
+    - No AttributeError on None access
+    - No if-checks scattered throughout code
+    - Clean separation between main and sub-agent behavior
+    - Explicit about sub-agent's memory isolation
+    """
+
+    def __init__(self) -> None:
+        """Initialize null context manager."""
+        logger.debug("NullTaskContextManager initialized for sub-agent isolation")
+
+    def load_session(
+        self,
+        session_id: str = "",
+        task_description: str = "",
+        **kwargs
+    ) -> None:
+        """No-op: Sub-agents don't load H-MEM sessions.
+
+        Args:
+            session_id: Ignored
+            task_description: Ignored
+            **kwargs: Ignored
+
+        Returns:
+            None (sub-agents have no session data)
+        """
+        return None
+
+    def create_session(
+        self,
+        session_id: str = "",
+        task_description: str = "",
+        **kwargs
+    ) -> None:
+        """No-op: Sub-agents don't create H-MEM sessions.
+
+        Args:
+            session_id: Ignored
+            task_description: Ignored
+            **kwargs: Ignored
+
+        Returns:
+            None
+        """
+        return None
+
+    def record_step(
+        self,
+        session_id: str = "",
+        step_number: int = 0,
+        action: str = "",
+        result: str = "",
+        **kwargs
+    ) -> None:
+        """No-op: Sub-agents don't record steps to H-MEM.
+
+        Args:
+            session_id: Ignored
+            step_number: Ignored
+            action: Ignored
+            result: Ignored
+            **kwargs: Ignored
+        """
+        pass
+
+    def get_context_injection(
+        self,
+        session_id: str = "",
+        brain_state: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> str:
+        """No-op: Return empty string for sub-agents.
+
+        Sub-agents don't have H-MEM context to inject.
+
+        Args:
+            session_id: Ignored
+            brain_state: Ignored
+            **kwargs: Ignored
+
+        Returns:
+            Empty string (no context to inject)
+        """
+        return ""
+
+    def save_session(
+        self,
+        session_id: str = "",
+        **kwargs
+    ) -> None:
+        """No-op: Sub-agents don't save H-MEM sessions.
+
+        Args:
+            session_id: Ignored
+            **kwargs: Ignored
+        """
+        pass
+
+    def add_finding(
+        self,
+        session_id: str = "",
+        finding: str = "",
+        phase_name: str = "",
+        **kwargs
+    ) -> None:
+        """No-op: Sub-agents don't add findings to H-MEM.
+
+        Args:
+            session_id: Ignored
+            finding: Ignored
+            phase_name: Ignored
+            **kwargs: Ignored
+        """
+        pass
+
+    def transition_phase(
+        self,
+        session_id: str = "",
+        from_phase: str = "",
+        to_phase: str = "",
+        **kwargs
+    ) -> None:
+        """No-op: Sub-agents don't transition phases.
+
+        Args:
+            session_id: Ignored
+            from_phase: Ignored
+            to_phase: Ignored
+            **kwargs: Ignored
+        """
+        pass
+
+    def get_session_stats(
+        self,
+        session_id: str = "",
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Return empty stats for sub-agents.
+
+        Args:
+            session_id: Ignored
+            **kwargs: Ignored
+
+        Returns:
+            Empty stats dict
+        """
+        return {
+            "is_null_manager": True,
+            "session_id": session_id,
+            "steps": 0,
+            "findings": 0,
+            "phases": []
+        }
+
+    def drain_promoted_findings(self, session_id: str) -> list:
+        """No-op: Sub-agents have no H-MEM findings to drain."""
+        return []
+
+    def cleanup(self, session_id: str = "", **kwargs) -> None:
+        """No-op: Nothing to clean up.
+
+        Args:
+            session_id: Ignored
+            **kwargs: Ignored
+        """
+        pass
+
+    def __bool__(self) -> bool:
+        """Return False for truthiness checks.
+
+        This allows code like:
+            if self.task_context_manager:
+                self.task_context_manager.do_something()
+
+        To skip operations for sub-agents.
+
+        Returns:
+            False (null manager is falsy)
+        """
+        return False
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        return "NullTaskContextManager(sub-agent isolation)"