Aggressive Tactical Upgrade: Parallel Foraging & Search Identity Juggling

backend/app/services/holocron.py

@@ -11,6 +11,7 @@ import threading
 import time
 from app.services.tools import search
 from app.services import state_sync, watchdog, state
+import concurrent.futures
 
 logger = logging.getLogger("friday.holocron")
 
@@ -217,20 +218,28 @@ def batch_mine_priorities():
     ]
     random.shuffle(domains) # Jitter topic order to avoid pattern matching
     
+    def _threaded_mine(d: str):
+        """Thread wrapper for mining a specific topic."""
+        if _check_halt(): return
+        _active_foraging_threads.add(d)
+        try:
+            _mine_sync(d, depth=1)
+        finally:
+            _active_foraging_threads.remove(d)
+
     def _run_batch():
-        logger.info("Holocron: Initiating Sovereign Priority Ingestion Cycle...")
-        for d in domains:
-            if _check_halt():
-                logger.warning("Holocron: Sovereign Termination signal received. Aborting batch cycle.")
-                break
-            _active_foraging_threads.add(d)
-            try:
-                _mine_sync(d, depth=1)
-            finally:
-                _active_foraging_threads.remove(d)
-            
-            time.sleep(random.randint(15, 30))
+        logger.info("Holocron: Initiating Sovereign Parallel Ingestion (Workers: 3)...")
+        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+            futures = [executor.submit(_threaded_mine, d) for d in domains if not _check_halt()]
+            for future in concurrent.futures.as_completed(futures):
+                if _check_halt(): break
+                try: 
+                    future.result()
+                except Exception as e:
+                    logger.error(f"Parallel Worker Error: {e}")
+        
         logger.info("Holocron: Sovereign Priority Ingestion Cycle Complete.")
+        time.sleep(random.randint(45, 90)) # Increased sleep after a parallel burst to cool down IP
 
     threading.Thread(target=_run_batch, daemon=True).start()
 

backend/app/services/tools/search.py

@@ -37,6 +37,7 @@ def search_web(query: str, max_results: int = 5, bypass_cache: bool = False) ->
                 logger.info(f"Memory hit for: {query}. Using local cache.")
                 return [{"title": "Cached Local Memory", "href": "local://memory", "body": cached_result}]
 
+        backends = ["lite", "html", "auto"]
         for attempt in range(max_retries):
             # INSTANT KILL-SWITCH CHECK
             if state.is_sovereign_locked() or state.is_learning_locked():
@@ -44,17 +45,16 @@ def search_web(query: str, max_results: int = 5, bypass_cache: bool = False) ->
                 return []
 
             try:
-                # [STEALH] Adaptive Jitter: 5-12 seconds to mimic human reading/thinking
-                jitter = random.uniform(5, 12)
-                time.sleep(jitter)
+                # [STEALH] Smaller Jitter for speed (3-6s)
+                time.sleep(random.uniform(3, 6))
                 
-                logger.info(f"Searching web for: {query} (Attempt {attempt+1}/{max_retries})")
-                
-                # [STEALTH] User-Agent Rotation
+                # [STEALTH] Identity Juggling: UA + Backend Rotation
                 ua = random.choice(user_agents)
-                with DDGS(headers={"User-Agent": ua}, timeout=45) as ddgs:
-                    # [SOVEREIGN HARDENING]: Lite backend is more robust against automation detection
-                    backend = "lite" 
+                backend = backends[attempt % len(backends)]
+                
+                logger.info(f"Searching [{backend}] for: {query} (Attempt {attempt+1}/{max_retries})")
+                
+                with DDGS(headers={"User-Agent": ua}, timeout=40) as ddgs:
                     results = [r for r in ddgs.text(query, max_results=max_results, backend=backend)]
                 
                 # Consolidate into memory if useful
@@ -64,16 +64,18 @@ def search_web(query: str, max_results: int = 5, bypass_cache: bool = False) ->
                     memory.embed_conversation("knowledge_cache", summary, entities=query)
                     
                 return results
-            except (RatelimitException, TimeoutException, Exception) as e:
+            except Exception as e:
                 err_str = str(e).lower()
                 is_transient = any(k in err_str for k in ["ratelimit", "timeout", "202", "connection"])
                 
                 if is_transient and attempt < max_retries - 1:
-                    wait_time = retry_delay * (2 ** attempt)
-                    logger.warning(f"Search Transient Error: {e}. Retrying in {wait_time}s...")
+                    # [TACTICAL] 2-5s burst retry with NEW identity
+                    wait_time = random.uniform(2, 5)
+                    logger.warning(f"Search Tactical Maneuver: {e}. Swapping Identity & Retrying in {wait_time:.1f}s...")
                     time.sleep(wait_time)
                 else:
-                    raise e
+                    logger.error(f"Search Exhausted: {e}")
+                    return []
 
     except Exception as e:
         logger.error(f"Web search failed after critical retries: {e}")