Fix: Stop rebuild_intelligence_baseline on every turn, skip LLM detection when sticky

app/agents/intelligence_extractor.py

@@ -17,6 +17,7 @@ from app.utils.logger import AgentLogger
 from app.utils.json_utils import robust_json_loads
 from app.config import settings
 import re
+from app.core.session_cache import session_cache
 
 
 class IntelligenceExtractor:
@@ -126,6 +127,24 @@ class IntelligenceExtractor:
     async def llm_extract(self, message: str, context: Optional[Any] = None) -> Dict[str, List[str]]:
         """Perform semantic extraction using the LLM."""
         try:
+            # --- SESSION CACHE CHECK (Fast-win) ---
+            session_id = None
+            try:
+                if context is not None:
+                    # TurnContext has `.session` or `.session_id`
+                    session = getattr(context, "session", None)
+                    if isinstance(session, dict):
+                        session_id = session.get("id") or session.get("conversation_id") or session.get("session_id")
+                    if not session_id:
+                        session_id = getattr(context, "session_id", None)
+            except Exception:
+                session_id = None
+
+            cached = session_cache.get(session_id, message)
+            if cached:
+                self.logger.info("LLM extraction cache HIT", session_id=session_id)
+                return cached
+
             # Define Strict Schema for Intelligence
             schema = {
                 "type": "object",
@@ -184,7 +203,16 @@ class IntelligenceExtractor:
             def clean_list(lst):
                 return [str(v).strip() for v in lst if v and len(str(v).strip()) > 3]
 
-            return {k: clean_list(v) for k, v in data.items() if isinstance(v, list)}
+            cleaned = {k: clean_list(v) for k, v in data.items() if isinstance(v, list)}
+
+            # Store in session cache for subsequent turns
+            try:
+                if session_id:
+                    session_cache.set(session_id, message, cleaned)
+            except Exception:
+                pass
+
+            return cleaned
             
         except Exception as e:
             self.logger.error("LLM Extraction failed", error=str(e))

app/agents/orchestrator.py

@@ -305,15 +305,18 @@ class HoneypotOrchestrator:
                 # but we can check if the last turn was 'conclude' or 'escalate'
             
             if existing_scam: # If sticky, we can run extraction immediately with high confidence
-                 detection_task = asyncio.Future()
-                 detection_task.set_result({
+                 # 🔥 SKIP LLM DETECTION entirely - use cached result
+                 detection = {
                     "scam_type": existing_scam,
                     "confidence": conversation.get("scam_confidence", 0.9),
                     "is_scam": True,
                     "reasoning": "Sticky detection from session memory",
-                    "source": "memory"
-                 })
-                 extraction_task = self.intel_extractor.extract(
+                    "source": "memory",
+                    "matched_keywords": conversation.get("aggregated_intelligence", {}).get("keywords", [])
+                 }
+                 # 🔥 SKIP LLM EXTRACTION on most turns - regex is sufficient
+                 # Only do LLM extraction on turn 1 and every 5th turn (handled inside extract())
+                 intelligence = await self.intel_extractor.extract(
                     message, 
                     context=ctx, 
                     turn_count=message_count,
@@ -321,7 +324,6 @@ class HoneypotOrchestrator:
                     current_confidence=conversation.get("scam_confidence", 0.9),
                     behavior_changed=behavior_changed
                  )
-                 detection, intelligence = await asyncio.gather(detection_task, extraction_task)
             else:
                  # If not sticky, we MUST run detection first to get 'current_confidence' for extraction novelty
                  try:

app/core/session_cache.py

@@ -0,0 +1,61 @@
+import time
+import hashlib
+from collections import OrderedDict
+from typing import Any, Dict, Optional
+
+
+class SessionCache:
+    """Lightweight in-memory per-session cache with TTL and simple LRU eviction.
+
+    Keyed by session_id -> dict of key -> (timestamp, value)
+    """
+
+    def __init__(self, max_per_session: int = 200, default_ttl: int = 300):
+        self.store: Dict[str, OrderedDict] = {}
+        self.max_per_session = max_per_session
+        self.default_ttl = default_ttl
+
+    @staticmethod
+    def _make_key(text: str) -> str:
+        return hashlib.sha1(text.encode('utf-8', errors='ignore')).hexdigest()
+
+    def get(self, session_id: Optional[str], text: str) -> Optional[Any]:
+        if not session_id:
+            return None
+        key = self._make_key(text)
+        bucket = self.store.get(session_id)
+        if not bucket:
+            return None
+        item = bucket.get(key)
+        if not item:
+            return None
+        ts, value = item
+        if time.time() - ts > self.default_ttl:
+            # expired
+            del bucket[key]
+            return None
+        # Move to end (LRU)
+        bucket.move_to_end(key)
+        return value
+
+    def set(self, session_id: Optional[str], text: str, value: Any) -> None:
+        if not session_id:
+            return
+        key = self._make_key(text)
+        bucket = self.store.get(session_id)
+        if not bucket:
+            bucket = OrderedDict()
+            self.store[session_id] = bucket
+        bucket[key] = (time.time(), value)
+        bucket.move_to_end(key)
+        # Evict oldest if over limit
+        while len(bucket) > self.max_per_session:
+            bucket.popitem(last=False)
+
+    def invalidate_session(self, session_id: str) -> None:
+        if session_id in self.store:
+            del self.store[session_id]
+
+
+# Create a default global cache instance
+session_cache = SessionCache()

app/utils/guvi_handler.py

@@ -169,20 +169,26 @@ class GUVIHandler:
                 )
             
             # Inject history
-            if request.conversationHistory:
+            # 🔥 OPTIMIZATION: Only replay history ONCE per session (cold start recovery)
+            # Track with 'sys_history_synced' flag to avoid expensive rebuild every turn
+            agg_intel = conv.get("aggregated_intelligence", {})
+            already_synced = agg_intel.get("sys_history_synced", False)
+            
+            if request.conversationHistory and not already_synced:
                 try:
-                    # conv already fetched above
-                    # [SCORING] Replay FULL history from request to ensure state consistency
-                    # This prevents Turn 1 resets if database is purged or session ID shifts
+                    # Only sync if our DB is significantly behind (cold start scenario)
+                    # A gap of 1-2 messages is normal turn progression, not cold start
                     full_history = request.conversationHistory
-                    if len(conv.get("history", [])) < len(full_history):
-                        # Clear existing history and replay to ensure perfect sync
-                        # (Only if history is provided by platform)
+                    db_len = len(conv.get("history", []))
+                    history_gap = len(full_history) - db_len
+                    
+                    # Only do full replay if gap >= 3 messages (actual cold start)
+                    if history_gap >= 3:
+                        logger.info(f"Cold start detected (gap={history_gap}). Replaying history...")
                         if hasattr(orchestrator.conversation_manager.memory, "clear"):
                              await orchestrator.conversation_manager.memory.clear(session_id)
                         
                         for i, msg in enumerate(full_history):
-                            # Robust extraction from Any type msg
                             h_text = ""
                             h_sender = "scammer"
                             
@@ -198,8 +204,6 @@ class GUVIHandler:
                                 
                             if h_text:
                                 is_scammer = h_sender == "scammer"
-                                # [OPTIMIZATION] Use Regex extraction for history to avoid "Latency Bomb"
-                                # We assume history was already processed for logic in previous runs
                                 hist_intel = extract_all(h_text)
                                 await orchestrator.conversation_manager.update(
                                     conversation_id=session_id,
@@ -210,13 +214,17 @@ class GUVIHandler:
                                     scam_type=None, persona=None
                                 )
                         
-                        # [SCORING] Finalize baseline rebuild (Guarded)
+                        # Rebuild baseline ONCE
                         if hasattr(orchestrator, "rebuild_intelligence_baseline"):
                             await orchestrator.rebuild_intelligence_baseline(session_id)
+                    
+                    # Mark synced to prevent future rebuilds this session
+                    await orchestrator.conversation_manager.update_intelligence(
+                        session_id, {"sys_history_synced": True}
+                    )
                 except Exception as hist_e:
                     safe_error = str(hist_e).encode('utf-8', 'replace').decode('utf-8')
                     logger.warning(f"Error parsing history: {safe_error}")
-                    # Continue anyway, history is secondary
             
             # [LATENCY] Turbo Mode: Only run expensive forensics (XAI) on the concluding turn.
             # We predict if this is the end using the unified lifecycle rules.