@smilintux/skcapstone 0.10.0 → 0.12.5

package/src/skcapstone/consciousness_loop.py

@@ -1,9 +1,9 @@
 """
 Consciousness Loop — autonomous agent message processing.
 
-Watches the SKComm inbox for incoming messages, classifies them,
+Watches the SKComms inbox for incoming messages, classifies them,
 routes to the appropriate LLM via the model router, and sends
-responses back through SKComm. Self-heals when backends go down
+responses back through SKComms. Self-heals when backends go down
 by cascading through fallback providers.
 
 Architecture:
@@ -99,9 +99,17 @@ class ConsciousnessConfig(BaseModel):
     max_concurrent_requests: int = 3
     fallback_chain: list[str] = Field(
         default_factory=lambda: [
-            "ollama", "grok", "kimi", "nvidia", "anthropic", "openai", "passthrough",
+            "ollama",
+            "grok",
+            "kimi",
+            "nvidia",
+            "anthropic",
+            "openai",
+            "passthrough",
         ]
     )
+    ollama_host: str = "http://localhost:11434"
+    ollama_model: str = "llama3.2"
     desktop_notifications: bool = True
 
 
@@ -110,8 +118,13 @@ class ConsciousnessConfig(BaseModel):
 # ---------------------------------------------------------------------------
 
 _OLLAMA_MODEL_PATTERNS = (
-    "llama", "mistral", "nemotron", "devstral",
-    "deepseek", "qwen", "codestral",
+    "llama",
+    "mistral",
+    "nemotron",
+    "devstral",
+    "deepseek",
+    "qwen",
+    "codestral",
 )
 
 
@@ -127,21 +140,14 @@ def _backend_from_model(model_name: str, tier: ModelTier) -> str:
 
     Returns:
         Backend string: ``"ollama"``, ``"anthropic"``, ``"openai"``, ``"grok"``,
-        ``"kimi"``, ``"nvidia"``, ``"passthrough"``, or ``"unknown"``.
+        ``"kimi"``, ``"minimax"``, ``"nvidia"``, ``"passthrough"``, or ``"unknown"``.
     """
     if tier == ModelTier.LOCAL:
         return "ollama"
     name_base = model_name.lower().split(":")[0]
-    if "claude" in name_base:
-        return "anthropic"
-    if any(x in name_base for x in ("gpt", "o1", "o3", "o4")):
-        return "openai"
-    if "grok" in name_base:
-        return "grok"
-    if "kimi" in name_base or "moonshot" in name_base:
-        return "kimi"
-    if "nvidia" in name_base:
-        return "nvidia"
+    for patterns, backend in LLMBridge._MODEL_PATTERNS:
+        if any(p in name_base for p in patterns):
+            return backend
     if any(p in name_base for p in _OLLAMA_MODEL_PATTERNS):
         return "ollama"
     return "unknown"
@@ -184,9 +190,7 @@ class _OllamaPool:
         with self._lock:
             if not self._is_valid():
                 self._close_locked()
-                self._conn = http.client.HTTPConnection(
-                    self._host, self._port, timeout=2
-                )
+                self._conn = http.client.HTTPConnection(self._host, self._port, timeout=2)
                 self._created_at = time.monotonic()
             return self._conn  # type: ignore[return-value]
 
@@ -201,18 +205,15 @@ class _OllamaPool:
 
     def _is_valid(self) -> bool:
         """True when a cached connection exists and is within its TTL."""
-        return (
-            self._conn is not None
-            and (time.monotonic() - self._created_at) < self._ttl
-        )
+        return self._conn is not None and (time.monotonic() - self._created_at) < self._ttl
 
     def _close_locked(self) -> None:
         """Close the underlying socket.  Must be called with *self._lock* held."""
         if self._conn is not None:
             try:
                 self._conn.close()
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Failed to close connection socket: %s", exc)
             self._conn = None
             self._created_at = 0.0
 
@@ -243,6 +244,7 @@ class LLMBridge:
         adapter: Optional[PromptAdapter] = None,
         cache: Optional[ResponseCache] = None,
     ) -> None:
+        self._config = config
         self._router = ModelRouter(config=router_config)
         self._adapter = adapter or PromptAdapter()
         self._fallback_chain = config.fallback_chain
@@ -250,22 +252,32 @@ class LLMBridge:
         self._available: dict[str, bool] = {}
         self._cache: Optional[ResponseCache] = cache
         self._fallback_tracker = FallbackTracker()
-        self._ollama_pool = _OllamaPool(
-            os.environ.get("OLLAMA_HOST", "http://localhost:11434")
-        )
+        self._ollama_pool = _OllamaPool(os.environ.get("OLLAMA_HOST", config.ollama_host))
         self._probe_available_backends()
 
+    # Maps backend name → env var that activates it.
+    # Backends with None are probed separately (ollama) or always on (passthrough).
+    _BACKEND_ENV_KEYS: dict[str, Optional[str]] = {
+        "ollama": None,
+        "anthropic": "ANTHROPIC_API_KEY",
+        "openai": "OPENAI_API_KEY",
+        "grok": "XAI_API_KEY",
+        "kimi": "MOONSHOT_API_KEY",
+        "minimax": "MINIMAX_API_KEY",
+        "nvidia": "NVIDIA_API_KEY",
+        "passthrough": None,
+    }
+
     def _probe_available_backends(self) -> None:
         """Probe all backends for availability."""
-        self._available = {
-            "ollama": self._probe_ollama(),
-            "anthropic": bool(os.environ.get("ANTHROPIC_API_KEY")),
-            "openai": bool(os.environ.get("OPENAI_API_KEY")),
-            "grok": bool(os.environ.get("XAI_API_KEY")),
-            "kimi": bool(os.environ.get("MOONSHOT_API_KEY")),
-            "nvidia": bool(os.environ.get("NVIDIA_API_KEY")),
-            "passthrough": True,
-        }
+        self._available = {}
+        for name, env_key in self._BACKEND_ENV_KEYS.items():
+            if name == "ollama":
+                self._available[name] = self._probe_ollama()
+            elif name == "passthrough":
+                self._available[name] = True
+            else:
+                self._available[name] = bool(os.environ.get(env_key or ""))
         available = [k for k, v in self._available.items() if v]
         logger.info("LLM backends available: %s", available)
 
@@ -277,13 +289,28 @@ class LLMBridge:
             resp = conn.getresponse()
             resp.read()  # drain body so the connection stays reusable
             return resp.status < 500
-        except Exception:
+        except Exception as e:
+            logger.warning("consciousness_loop.py: %s", e)
             self._ollama_pool.invalidate()
             return False
 
+    # Maps model-name substring → backend name for pattern matching.
+    _MODEL_PATTERNS: list[tuple[tuple[str, ...], str]] = [
+        (("claude",), "anthropic"),
+        (("gpt", "o1", "o3", "o4"), "openai"),
+        (("grok",), "grok"),
+        (("kimi", "moonshot"), "kimi"),
+        (("minimax",), "minimax"),
+        (("nvidia",), "nvidia"),
+    ]
+
     def _resolve_callback(self, tier: ModelTier, model_name: str):
         """Map tier+model to a skseed callback.
 
+        Uses the configured ollama_model for local inference and
+        resolves cloud backends by model-name pattern matching.
+        Falls back through the configured fallback_chain.
+
         Args:
             tier: The routing tier.
             model_name: The concrete model name.
@@ -291,66 +318,58 @@ class LLMBridge:
         Returns:
             An LLMCallback callable.
         """
-        from skseed.llm import (
-            anthropic_callback,
-            grok_callback,
-            kimi_callback,
-            nvidia_callback,
-            ollama_callback,
-            openai_callback,
-            passthrough_callback,
-        )
+        from skseed.llm import ollama_callback
 
-        name_lower = model_name.lower()
-        # Strip Ollama :tag suffix for pattern matching (e.g. "deepseek-r1:8b" -> "deepseek-r1")
-        name_base = name_lower.split(":")[0]
+        name_base = model_name.lower().split(":")[0]
 
         # LOCAL tier always goes to Ollama
         if tier == ModelTier.LOCAL:
             return ollama_callback(model=model_name)
 
-        # Pattern matching on model name (use name_base to handle :tag suffixes)
-        if "claude" in name_base:
-            return anthropic_callback(model=model_name)
-        if "gpt" in name_base or "o1" in name_base or "o3" in name_base or "o4" in name_base:
-            return openai_callback(model=model_name)
-        if "grok" in name_base:
-            return grok_callback(model=model_name)
-        if "kimi" in name_base or "moonshot" in name_base:
-            return kimi_callback(model=model_name)
-        if "nvidia" in name_base:
-            return nvidia_callback(model=model_name)
+        # Pattern matching on model name
+        for patterns, backend in self._MODEL_PATTERNS:
+            if any(p in name_base for p in patterns):
+                return self._callback_for_backend(backend, model=model_name)
 
         # Models that run on Ollama (local inference)
-        ollama_patterns = (
-            "llama", "mistral", "nemotron", "devstral",
-            "deepseek", "qwen", "codestral",
-        )
-        for pattern in ollama_patterns:
-            if pattern in name_base:
-                return ollama_callback(model=model_name)
+        if any(p in name_base for p in _OLLAMA_MODEL_PATTERNS):
+            return ollama_callback(model=model_name)
 
         # Walk fallback chain for first available backend
         for backend in self._fallback_chain:
-            if not self._available.get(backend, False):
-                continue
-            if backend == "ollama":
-                return ollama_callback(model="llama3.2")
-            elif backend == "anthropic":
-                return anthropic_callback()
-            elif backend == "openai":
-                return openai_callback()
-            elif backend == "grok":
-                return grok_callback()
-            elif backend == "kimi":
-                return kimi_callback()
-            elif backend == "nvidia":
-                return nvidia_callback()
-            elif backend == "passthrough":
-                return self._make_passthrough_callback()
+            if self._available.get(backend, False):
+                return self._callback_for_backend(backend)
 
         return self._make_passthrough_callback()
 
+    def _callback_for_backend(self, backend: str, model: Optional[str] = None):
+        """Return the skseed callback for *backend*, importing only what's needed.
+
+        Args:
+            backend: Backend name (e.g. "ollama", "anthropic", "openai").
+            model: Optional model override. When None, uses each provider's default.
+
+        Returns:
+            An LLMCallback callable.
+        """
+        import skseed.llm as _llm
+
+        if backend == "ollama":
+            return _llm.ollama_callback(model=model or self._config.ollama_model)
+        if backend == "passthrough":
+            return self._make_passthrough_callback()
+
+        # All other backends follow the same pattern: <backend>_callback(model=…)
+        factory = getattr(_llm, f"{backend}_callback", None)
+        if factory is None:
+            logger.warning("No skseed callback for backend %r — using passthrough", backend)
+            return self._make_passthrough_callback()
+
+        kwargs: dict[str, Any] = {}
+        if model:
+            kwargs["model"] = model
+        return factory(**kwargs)
+
     @staticmethod
     def _make_passthrough_callback():
         """Return a passthrough callback that always produces a plain str.
@@ -363,6 +382,7 @@ class LLMBridge:
             Callable that accepts str or AdaptedPrompt and returns str.
         """
         from skseed.llm import passthrough_callback
+
         _pt = passthrough_callback()
 
         def _wrapper(prompt):
@@ -446,19 +466,12 @@ class LLMBridge:
         Returns:
             LLM response text, or a fallback error message.
         """
-        from skseed.llm import (
-            anthropic_callback,
-            grok_callback,
-            kimi_callback,
-            nvidia_callback,
-            ollama_callback,
-            openai_callback,
-        )
-
         decision = self._router.route(signal)
         logger.info(
             "Routed to tier=%s model=%s: %s",
-            decision.tier.value, decision.model_name, decision.reasoning,
+            decision.tier.value,
+            decision.model_name,
+            decision.reasoning,
         )
 
         # Cache look-up (before any LLM call)
@@ -481,12 +494,15 @@ class LLMBridge:
 
         # Adapt prompt for the target model
         adapted = self._adapter.adapt(
-            system_prompt, user_message,
-            decision.model_name, decision.tier,
+            system_prompt,
+            user_message,
+            decision.model_name,
+            decision.tier,
         )
         logger.debug(
             "Prompt adapted: profile=%s adaptations=%s",
-            adapted.profile_used, adapted.adaptations_applied,
+            adapted.profile_used,
+            adapted.adaptations_applied,
         )
 
         # Capture primary model identity for fallback tracking
@@ -504,9 +520,7 @@ class LLMBridge:
                 self._cache.put(_prompt_hash, decision.model_name, decision.tier, result)
             return result
         except Exception as exc:
-            logger.warning(
-                "Primary model %s failed: %s", decision.model_name, exc
-            )
+            logger.warning("Primary model %s failed: %s", decision.model_name, exc)
 
         # Try alternate models in same tier
         tier_models = self._router.config.tier_models.get(decision.tier.value, [])
@@ -515,32 +529,39 @@ class LLMBridge:
             try:
                 logger.info("Trying alt model: %s", alt_model)
                 alt_adapted = self._adapter.adapt(
-                    system_prompt, user_message, alt_model, decision.tier,
+                    system_prompt,
+                    user_message,
+                    alt_model,
+                    decision.tier,
                 )
                 callback = self._resolve_callback(decision.tier, alt_model)
                 result = self._timed_call(callback, alt_adapted, decision.tier)
                 if _out_info is not None:
                     _out_info["backend"] = alt_backend
                     _out_info["tier"] = decision.tier.value
-                self._fallback_tracker.record(FallbackEvent(
-                    primary_model=_primary_model,
-                    primary_backend=_primary_backend,
-                    fallback_model=alt_model,
-                    fallback_backend=alt_backend,
-                    reason=f"primary model {_primary_model!r} failed; trying same-tier alt",
-                    success=True,
-                ))
+                self._fallback_tracker.record(
+                    FallbackEvent(
+                        primary_model=_primary_model,
+                        primary_backend=_primary_backend,
+                        fallback_model=alt_model,
+                        fallback_backend=alt_backend,
+                        reason=f"primary model {_primary_model!r} failed; trying same-tier alt",
+                        success=True,
+                    )
+                )
                 return result
             except Exception as exc:
                 logger.warning("Alt model %s failed: %s", alt_model, exc)
-                self._fallback_tracker.record(FallbackEvent(
-                    primary_model=_primary_model,
-                    primary_backend=_primary_backend,
-                    fallback_model=alt_model,
-                    fallback_backend=alt_backend,
-                    reason=f"primary model {_primary_model!r} failed; alt {alt_model!r} also failed: {exc}",
-                    success=False,
-                ))
+                self._fallback_tracker.record(
+                    FallbackEvent(
+                        primary_model=_primary_model,
+                        primary_backend=_primary_backend,
+                        fallback_model=alt_model,
+                        fallback_backend=alt_backend,
+                        reason=f"primary model {_primary_model!r} failed; alt {alt_model!r} also failed: {exc}",
+                        success=False,
+                    )
+                )
 
         # Tier downgrade: try FAST tier
         if decision.tier != ModelTier.FAST:
@@ -550,92 +571,90 @@ class LLMBridge:
                 try:
                     logger.info("Downgrading to FAST tier: %s", fast_model)
                     fast_adapted = self._adapter.adapt(
-                        system_prompt, user_message, fast_model, ModelTier.FAST,
+                        system_prompt,
+                        user_message,
+                        fast_model,
+                        ModelTier.FAST,
                     )
                     callback = self._resolve_callback(ModelTier.FAST, fast_model)
                     result = self._timed_call(callback, fast_adapted, ModelTier.FAST)
                     if _out_info is not None:
                         _out_info["backend"] = fast_backend
                         _out_info["tier"] = ModelTier.FAST.value
-                    self._fallback_tracker.record(FallbackEvent(
-                        primary_model=_primary_model,
-                        primary_backend=_primary_backend,
-                        fallback_model=fast_model,
-                        fallback_backend=fast_backend,
-                        reason=f"tier downgrade: {decision.tier.value} exhausted; using FAST model {fast_model!r}",
-                        success=True,
-                    ))
+                    self._fallback_tracker.record(
+                        FallbackEvent(
+                            primary_model=_primary_model,
+                            primary_backend=_primary_backend,
+                            fallback_model=fast_model,
+                            fallback_backend=fast_backend,
+                            reason=f"tier downgrade: {decision.tier.value} exhausted; using FAST model {fast_model!r}",
+                            success=True,
+                        )
+                    )
                     return result
                 except Exception as exc:
                     logger.warning("FAST model %s failed: %s", fast_model, exc)
-                    self._fallback_tracker.record(FallbackEvent(
-                        primary_model=_primary_model,
-                        primary_backend=_primary_backend,
-                        fallback_model=fast_model,
-                        fallback_backend=fast_backend,
-                        reason=f"tier downgrade: FAST model {fast_model!r} failed: {exc}",
-                        success=False,
-                    ))
+                    self._fallback_tracker.record(
+                        FallbackEvent(
+                            primary_model=_primary_model,
+                            primary_backend=_primary_backend,
+                            fallback_model=fast_model,
+                            fallback_backend=fast_backend,
+                            reason=f"tier downgrade: FAST model {fast_model!r} failed: {exc}",
+                            success=False,
+                        )
+                    )
 
-        # Cross-provider cascade via fallback chain — direct backend mapping,
-        # no _resolve_callback, to avoid infinite regression on unknown names.
+        # Cross-provider cascade via fallback chain — uses _callback_for_backend
+        # so adding a new provider only requires updating the registry, not this loop.
         for backend in self._fallback_chain:
             if not self._available.get(backend, False):
                 continue
             try:
                 logger.info("Fallback cascade: %s", backend)
-                if backend == "ollama":
-                    callback = ollama_callback(model="llama3.2")
-                elif backend == "anthropic":
-                    callback = anthropic_callback()
-                elif backend == "grok":
-                    callback = grok_callback()
-                elif backend == "kimi":
-                    callback = kimi_callback()
-                elif backend == "nvidia":
-                    callback = nvidia_callback()
-                elif backend == "openai":
-                    callback = openai_callback()
-                elif backend == "passthrough":
-                    callback = self._make_passthrough_callback()
-                else:
-                    continue
+                callback = self._callback_for_backend(backend)
                 result = self._timed_call(callback, adapted, ModelTier.FAST)
                 if _out_info is not None:
                     _out_info["backend"] = backend
                     _out_info["tier"] = ModelTier.FAST.value
-                self._fallback_tracker.record(FallbackEvent(
-                    primary_model=_primary_model,
-                    primary_backend=_primary_backend,
-                    fallback_model=backend,
-                    fallback_backend=backend,
-                    reason=f"cross-provider cascade: all tier models exhausted; using {backend!r}",
-                    success=True,
-                ))
+                self._fallback_tracker.record(
+                    FallbackEvent(
+                        primary_model=_primary_model,
+                        primary_backend=_primary_backend,
+                        fallback_model=backend,
+                        fallback_backend=backend,
+                        reason=f"cross-provider cascade: all tier models exhausted; using {backend!r}",
+                        success=True,
+                    )
+                )
                 return result
             except Exception as exc:
                 logger.warning("Fallback %s failed: %s", backend, exc)
-                self._fallback_tracker.record(FallbackEvent(
-                    primary_model=_primary_model,
-                    primary_backend=_primary_backend,
-                    fallback_model=backend,
-                    fallback_backend=backend,
-                    reason=f"cross-provider cascade: {backend!r} failed: {exc}",
-                    success=False,
-                ))
+                self._fallback_tracker.record(
+                    FallbackEvent(
+                        primary_model=_primary_model,
+                        primary_backend=_primary_backend,
+                        fallback_model=backend,
+                        fallback_backend=backend,
+                        reason=f"cross-provider cascade: {backend!r} failed: {exc}",
+                        success=False,
+                    )
+                )
 
         # Last resort
         if _out_info is not None:
             _out_info["backend"] = "none"
             _out_info["tier"] = "none"
-        self._fallback_tracker.record(FallbackEvent(
-            primary_model=_primary_model,
-            primary_backend=_primary_backend,
-            fallback_model="none",
-            fallback_backend="none",
-            reason="all backends exhausted — returning connectivity error message",
-            success=False,
-        ))
+        self._fallback_tracker.record(
+            FallbackEvent(
+                primary_model=_primary_model,
+                primary_backend=_primary_backend,
+                fallback_model="none",
+                fallback_backend="none",
+                reason="all backends exhausted — returning connectivity error message",
+                success=False,
+            )
+        )
         return (
             "I'm currently experiencing connectivity issues with my language models. "
             "Your message has been received and I'll respond as soon as service is restored."
@@ -873,7 +892,9 @@ class SystemPromptBuilder:
         if self._conv_store is not None:
             # Persist via ConversationStore (atomic file I/O)
             self._conv_store.append(
-                peer, role, content,
+                peer,
+                role,
+                content,
                 thread_id=thread_id,
                 in_reply_to=in_reply_to,
             )
@@ -937,6 +958,7 @@ class SystemPromptBuilder:
         # --- System B: soul_switch takes priority ---
         try:
             from skcapstone.soul_switch import get_active_switch_blueprint
+
             switch_bp = get_active_switch_blueprint(self._home)
             if switch_bp is not None:
                 if switch_bp.system_prompt:
@@ -988,6 +1010,7 @@ class SystemPromptBuilder:
         """Load warmth anchor boot prompt."""
         try:
             from skcapstone.warmth_anchor import get_anchor
+
             anchor = get_anchor(self._home)
             if anchor:
                 return (
@@ -995,14 +1018,15 @@ class SystemPromptBuilder:
                     f"trust: {anchor.get('trust', 5)}/10, "
                     f"connection: {anchor.get('connection', 5)}/10"
                 )
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.warning("Failed to load warmth anchor: %s", exc)
         return ""
 
     def _load_context(self) -> str:
         """Load agent context summary."""
         try:
             from skcapstone.context_loader import format_text, gather_context
+
             ctx = gather_context(self._home, memory_limit=5)
             return format_text(ctx)
         except Exception as exc:
@@ -1013,6 +1037,7 @@ class SystemPromptBuilder:
         """Load recent snapshot injection prompt."""
         try:
             from skcapstone.snapshots import SnapshotStore
+
             store = SnapshotStore(self._home)
             snapshots = store.list_all()
             if snapshots:
@@ -1034,9 +1059,7 @@ class SystemPromptBuilder:
             "- Be warm, genuine, and attentive to the conversation context."
         )
 
-    def _get_peer_history(
-        self, peer: str, thread_id: Optional[str] = None
-    ) -> str:
+    def _get_peer_history(self, peer: str, thread_id: Optional[str] = None) -> str:
         """Format recent conversation history with a peer.
 
         When ``thread_id`` is supplied, messages belonging to that thread are
@@ -1093,8 +1116,28 @@ class SystemPromptBuilder:
 # ---------------------------------------------------------------------------
 
 # Keyword sets for tag classification
-_CODE_KEYWORDS = {"code", "debug", "fix", "implement", "refactor", "test", "function", "class", "error", "bug"}
-_REASON_KEYWORDS = {"analyze", "explain", "why", "architecture", "design", "plan", "research", "compare"}
+_CODE_KEYWORDS = {
+    "code",
+    "debug",
+    "fix",
+    "implement",
+    "refactor",
+    "test",
+    "function",
+    "class",
+    "error",
+    "bug",
+}
+_REASON_KEYWORDS = {
+    "analyze",
+    "explain",
+    "why",
+    "architecture",
+    "design",
+    "plan",
+    "research",
+    "compare",
+}
 _NUANCE_KEYWORDS = {"write", "creative", "email", "letter", "story", "poem", "marketing"}
 _SIMPLE_KEYWORDS = {"hi", "hello", "hey", "thanks", "ok", "yes", "no", "ack"}
 
@@ -1111,7 +1154,7 @@ def _classify_message(content: str) -> TaskSignal:
     Returns:
         TaskSignal with tags and estimated tokens.
     """
-    words = set(re.findall(r'\b\w+\b', content.lower()))
+    words = set(re.findall(r"\b\w+\b", content.lower()))
     tags: list[str] = []
     estimated_tokens = len(content) // 4  # rough estimate
 
@@ -1140,7 +1183,7 @@ def _classify_message(content: str) -> TaskSignal:
 
 
 class InboxHandler:
-    """File system event handler for SKComm inbox.
+    """File system event handler for SKComms inbox.
 
     Watches for new *.skc.json files and submits them for processing.
 
@@ -1171,9 +1214,7 @@ class InboxHandler:
 
         # Clean up old entries
         cutoff = now - 60
-        self._last_event = {
-            k: v for k, v in self._last_event.items() if v > cutoff
-        }
+        self._last_event = {k: v for k, v in self._last_event.items() if v > cutoff}
 
         self._callback(Path(src_path))
 
@@ -1209,7 +1250,7 @@ class ConsciousnessLoop:
         self._state = daemon_state
         self._home = Path(home) if home else Path(AGENT_HOME).expanduser()
         self._shared_root = Path(shared_root) if shared_root else Path(_SR).expanduser()
-        self._skcomm = None
+        self._skcomms = None
         self._observer = None
         self._executor = ThreadPoolExecutor(
             max_workers=config.max_concurrent_requests,
@@ -1239,7 +1280,8 @@ class ConsciousnessLoop:
             self._home, max_history_messages=config.max_history_messages
         )
         self._prompt_builder = SystemPromptBuilder(
-            self._home, config.max_context_tokens,
+            self._home,
+            config.max_context_tokens,
             max_history_messages=config.max_history_messages,
             conv_manager=self._conv_manager,
             conv_store=self._conv_store,
@@ -1251,8 +1293,10 @@ class ConsciousnessLoop:
         # Mood tracker — updated after each processed message cycle
         try:
             from skcapstone.mood import MoodTracker
+
             self._mood_tracker: Optional[Any] = MoodTracker(home=self._home)
-        except Exception:
+        except Exception as exc:
+            logger.warning("MoodTracker unavailable, mood tracking disabled: %s", exc)
             self._mood_tracker = None
 
         # Agent identity for inbox filtering
@@ -1265,17 +1309,19 @@ class ConsciousnessLoop:
         # Peer directory — tracks transport addresses of known peers
         try:
             from skcapstone.peer_directory import PeerDirectory
+
             self._peer_dir: Optional[Any] = PeerDirectory(home=self._shared_root)
-        except Exception:
+        except Exception as exc:
+            logger.warning("PeerDirectory unavailable, peer tracking disabled: %s", exc)
             self._peer_dir = None
 
-    def set_skcomm(self, skcomm) -> None:
-        """Inject SKComm instance for sending responses.
+    def set_skcomms(self, skcomms) -> None:
+        """Inject SKComms instance for sending responses.
 
         Args:
-            skcomm: An initialized SKComm instance.
+            skcomms: An initialized SKComms instance.
         """
-        self._skcomm = skcomm
+        self._skcomms = skcomms
 
     def start(self) -> list[threading.Thread]:
         """Start inotify watcher, sync watcher, and consciousness worker threads.
@@ -1334,15 +1380,15 @@ class ConsciousnessLoop:
             try:
                 self._observer.stop()
                 self._observer.join(timeout=5)
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Error stopping inotify observer: %s", exc)
         # Stop sync watcher if running
         sync_watcher = getattr(self, "_sync_watcher", None)
         if sync_watcher:
             try:
                 sync_watcher.stop()
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Error stopping sync watcher: %s", exc)
         self._executor.shutdown(wait=False)
         self._metrics.stop()
         logger.info("Consciousness loop stopped.")
@@ -1353,8 +1399,8 @@ class ConsciousnessLoop:
             try:
                 self._observer.stop()
                 self._observer.join(timeout=5)
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Error stopping inotify observer during restart: %s", exc)
             self._observer = None
 
         # Re-launch inotify in a new thread
@@ -1375,12 +1421,12 @@ class ConsciousnessLoop:
             4. Build system prompt
             5. Search memories for sender context (top 3, appended to system prompt)
             6. Call LLMBridge.generate()
-            7. Send response via SKComm
+            7. Send response via SKComms
             8. Store interaction as memory
             9. Update conversation history
 
         Args:
-            envelope: A MessageEnvelope from SKComm.
+            envelope: A MessageEnvelope from SKComms.
 
         Returns:
             Response text if a response was generated, None otherwise.
@@ -1389,7 +1435,9 @@ class ConsciousnessLoop:
             # Extract message info
             content_type = getattr(envelope.payload, "content_type", None)
             if content_type:
-                ct_value = content_type.value if hasattr(content_type, "value") else str(content_type)
+                ct_value = (
+                    content_type.value if hasattr(content_type, "value") else str(content_type)
+                )
             else:
                 ct_value = "text"
 
@@ -1419,23 +1467,24 @@ class ConsciousnessLoop:
             if self._peer_dir is not None:
                 try:
                     self._peer_dir.update_last_seen(sender)
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Failed to update peer directory for %s: %s", sender, exc)
             self._metrics.record_message(sender)
 
             # Desktop notification
             if self._config.desktop_notifications:
                 try:
                     from skcapstone.notifications import notify as _desktop_notify
+
                     preview = content[:50] + ("..." if len(content) > 50 else "")
                     _desktop_notify(f"Message from {sender}", preview)
                 except Exception as _notif_exc:
                     logger.debug("Desktop notification failed: %s", _notif_exc)
 
             # Send ACK
-            if self._config.auto_ack and self._skcomm:
+            if self._config.auto_ack and self._skcomms:
                 try:
-                    self._skcomm.send(sender, "ACK", message_type="ack")
+                    self._skcomms.send(sender, "ACK", message_type="ack")
                 except Exception as exc:
                     logger.debug("ACK send failed: %s", exc)
 
@@ -1458,15 +1507,16 @@ class ConsciousnessLoop:
             t_prompt = time.monotonic()
 
             # Send typing indicator before generation so peer UI shows animation
-            if self._skcomm:
+            if self._skcomms:
                 try:
                     from skchat.presence import PresenceIndicator, PresenceState
-                    from skcomm.models import MessageType
+                    from skcomms.models import MessageType
+
                     _typing_ind = PresenceIndicator(
                         identity_uri=self._agent_name or "capauth:agent@skchat.local",
                         state=PresenceState.TYPING,
                     )
-                    self._skcomm.send(
+                    self._skcomms.send(
                         sender, _typing_ind.model_dump_json(), message_type=MessageType.HEARTBEAT
                     )
                 except Exception as _ti_exc:
@@ -1475,21 +1525,25 @@ class ConsciousnessLoop:
             # Generate response — capture backend/tier via _out_info
             _route_info: dict = {}
             response = self._bridge.generate(
-                system_prompt, content, signal, _out_info=_route_info,
+                system_prompt,
+                content,
+                signal,
+                _out_info=_route_info,
                 skip_cache=True,  # conversation messages have dynamic context
             )
             t_llm = time.monotonic()
 
             # Send typing stop so peer UI clears the animation
-            if self._skcomm:
+            if self._skcomms:
                 try:
                     from skchat.presence import PresenceIndicator, PresenceState
-                    from skcomm.models import MessageType
+                    from skcomms.models import MessageType
+
                     _stop_ind = PresenceIndicator(
                         identity_uri=self._agent_name or "capauth:agent@skchat.local",
                         state=PresenceState.ONLINE,
                     )
-                    self._skcomm.send(
+                    self._skcomms.send(
                         sender, _stop_ind.model_dump_json(), message_type=MessageType.HEARTBEAT
                     )
                 except Exception as _ts_exc:
@@ -1506,6 +1560,7 @@ class ConsciousnessLoop:
             # Score response quality and accumulate in metrics
             try:
                 from skcapstone.response_scorer import score_response as _score_response
+
                 _quality = _score_response(content, response, response_time_ms)
                 self._metrics.record_quality(_quality)
                 logger.debug(
@@ -1519,9 +1574,9 @@ class ConsciousnessLoop:
                 logger.debug("Quality scoring failed (non-fatal): %s", _sq_exc)
 
             # Send response
-            if response and self._skcomm:
+            if response and self._skcomms:
                 try:
-                    self._skcomm.send(sender, response)
+                    self._skcomms.send(sender, response)
                     self._responses_sent += 1
                     _ph = self._prompt_builder.current_prompt_hash
                     if _ph:
@@ -1547,22 +1602,29 @@ class ConsciousnessLoop:
 
             # Update conversation history (with thread context)
             self._prompt_builder.add_to_history(
-                sender, "user", content,
+                sender,
+                "user",
+                content,
                 thread_id=thread_id or None,
                 in_reply_to=in_reply_to or None,
             )
             if response:
                 try:
-                    subprocess.Popen(
-                        ["notify-send", "Opus", response[:100]],
-                        stdout=subprocess.DEVNULL,
-                        stderr=subprocess.DEVNULL,
-                    )
+                    from skcapstone.notifications import desktop_notifications_enabled
+
+                    if desktop_notifications_enabled():
+                        subprocess.Popen(
+                            ["notify-send", "Opus", response[:100]],
+                            stdout=subprocess.DEVNULL,
+                            stderr=subprocess.DEVNULL,
+                        )
                 except Exception as _notify_exc:
                     logger.debug("notify-send failed (non-fatal): %s", _notify_exc)
 
                 self._prompt_builder.add_to_history(
-                    sender, "assistant", response,
+                    sender,
+                    "assistant",
+                    response,
                     thread_id=thread_id or None,
                 )
 
@@ -1582,7 +1644,10 @@ class ConsciousnessLoop:
             return None
 
     def _store_interaction_memory(
-        self, peer: str, message: str, response: Optional[str],
+        self,
+        peer: str,
+        message: str,
+        response: Optional[str],
     ) -> None:
         """Store the interaction as a memory entry.
 
@@ -1593,6 +1658,7 @@ class ConsciousnessLoop:
         """
         try:
             from skcapstone.memory_engine import store
+
             summary = f"Conversation with {peer}: '{message[:100]}'"
             if response:
                 summary += f" → '{response[:100]}'"
@@ -1674,9 +1740,7 @@ class ConsciousnessLoop:
 
         config_path = self._home / "config" / "consciousness.yaml"
         if not config_path.exists():
-            logger.warning(
-                "Config hot-reload: %s not found, keeping current config", config_path
-            )
+            logger.warning("Config hot-reload: %s not found, keeping current config", config_path)
             return
 
         # Parse YAML directly so syntax errors surface here (not silently swallowed
@@ -1711,21 +1775,15 @@ class ConsciousnessLoop:
         old_data = self._config.model_dump()
         new_data = new_config.model_dump()
         changes = {
-            k: (old_data[k], new_data[k])
-            for k in new_data
-            if old_data.get(k) != new_data[k]
+            k: (old_data[k], new_data[k]) for k in new_data if old_data.get(k) != new_data[k]
         }
 
         if not changes:
-            logger.debug(
-                "Config hot-reload: no changes detected in %s", config_path
-            )
+            logger.debug("Config hot-reload: no changes detected in %s", config_path)
             return
 
         for field, (old_val, new_val) in changes.items():
-            logger.info(
-                "Config hot-reload: %s changed: %r → %r", field, old_val, new_val
-            )
+            logger.info("Config hot-reload: %s changed: %r → %r", field, old_val, new_val)
 
         self._config = new_config
 
@@ -1755,9 +1813,7 @@ class ConsciousnessLoop:
 
             class _ConfigChangeHandler(FileSystemEventHandler):
                 def on_modified(self, event):
-                    if not event.is_directory and event.src_path.endswith(
-                        "consciousness.yaml"
-                    ):
+                    if not event.is_directory and event.src_path.endswith("consciousness.yaml"):
                         logger.info(
                             "Config hot-reload triggered (modified): %s",
                             event.src_path,
@@ -1765,9 +1821,7 @@ class ConsciousnessLoop:
                         loop_ref._reload_config()
 
                 def on_created(self, event):
-                    if not event.is_directory and event.src_path.endswith(
-                        "consciousness.yaml"
-                    ):
+                    if not event.is_directory and event.src_path.endswith("consciousness.yaml"):
                         logger.info(
                             "Config hot-reload triggered (created): %s",
                             event.src_path,
@@ -1814,8 +1868,7 @@ class ConsciousnessLoop:
 
         except ImportError:
             logger.warning(
-                "watchdog not installed — inotify disabled. "
-                "Install with: pip install watchdog"
+                "watchdog not installed — inotify disabled. Install with: pip install watchdog"
             )
         except Exception as exc:
             logger.error("Inotify watcher error: %s", exc)
@@ -1827,8 +1880,8 @@ class ConsciousnessLoop:
             if identity_path.exists():
                 data = json.loads(identity_path.read_text(encoding="utf-8"))
                 return data.get("name", "").lower()
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.warning("Failed to resolve agent name from identity.json: %s", exc)
         return ""
 
     def _verify_message_signature(self, data: dict) -> str:
@@ -1859,18 +1912,16 @@ class ConsciousnessLoop:
 
         try:
             from skcapstone.peers import get_peer
+
             peer = get_peer(sender, skcapstone_home=self._home)
             if not peer or not peer.public_key:
-                logger.debug(
-                    "No public key for peer %s — cannot verify signature", sender
-                )
+                logger.debug("No public key for peer %s — cannot verify signature", sender)
                 return "failed"
 
             from capauth.crypto import get_backend
+
             backend = get_backend()
-            content_bytes = (
-                content.encode("utf-8") if isinstance(content, str) else content
-            )
+            content_bytes = content.encode("utf-8") if isinstance(content, str) else content
             ok = backend.verify(
                 data=content_bytes,
                 signature_armor=signature,
@@ -1948,13 +1999,11 @@ class ConsciousnessLoop:
                         queue_size,
                     )
                     return
-            except Exception:
-                pass  # _work_queue might not exist in all Python versions
+            except Exception as exc:
+                logger.debug("Could not check executor queue depth: %s", exc)
 
             # PGP signature verification (soft enforcement — log only)
-            sig_sender = _sanitize_peer_name(
-                data.get("sender", data.get("from", "unknown"))
-            )
+            sig_sender = _sanitize_peer_name(data.get("sender", data.get("from", "unknown")))
             sig_status = self._verify_message_signature(data)
             logger.info("Message from %s signature: %s", sig_sender, sig_status)
 
@@ -1986,9 +2035,8 @@ class ConsciousnessLoop:
             "errors": self._errors,
             "last_activity": self._last_activity.isoformat() if self._last_activity else None,
             "backends": self._bridge.available_backends,
-            "inotify_active": self._observer is not None and (
-                self._observer.is_alive() if hasattr(self._observer, "is_alive") else False
-            ),
+            "inotify_active": self._observer is not None
+            and (self._observer.is_alive() if hasattr(self._observer, "is_alive") else False),
             "max_concurrent": self._config.max_concurrent_requests,
             "current_prompt_hash": self._prompt_builder.current_prompt_hash,
             "prompt_version_responses": dict(self._prompt_version_responses),
@@ -2039,13 +2087,5 @@ class _SimpleEnvelope:
         self.timestamp = data.get("timestamp", datetime.now(timezone.utc).isoformat())
         # Threading fields — may live at envelope root or inside payload
         _payload_raw = data.get("payload", {}) if isinstance(data.get("payload"), dict) else {}
-        self.thread_id: str = (
-            data.get("thread_id")
-            or _payload_raw.get("thread_id")
-            or ""
-        )
-        self.in_reply_to: str = (
-            data.get("in_reply_to")
-            or _payload_raw.get("in_reply_to")
-            or ""
-        )
+        self.thread_id: str = data.get("thread_id") or _payload_raw.get("thread_id") or ""
+        self.in_reply_to: str = data.get("in_reply_to") or _payload_raw.get("in_reply_to") or ""