fix(nix): preserve container writable layer across nixos-rebuild

The container identity hash included the entrypoint's Nix store path,
which changes on every nixpkgs update (due to runtimeShell/stdenv
input-addressing). This caused false-positive identity mismatches,
triggering container recreation and losing the persistent writable layer.

- Use stable symlink (current-entrypoint) like current-package already does
- Remove entrypoint from identity hash (only image/volumes/options matter)
- Add GC root for entrypoint so nix-collect-garbage doesn't break it
- Remove global HERMES_HOME env var from addToSystemPackages (conflicted
  with interactive CLI use, service already sets its own)

acp_adapter/events.py

@@ -10,7 +10,7 @@ thread while the event loop lives on the main thread).
 import asyncio
 import json
 import logging
-from collections import deque
+from collections import defaultdict, deque
 from typing import Any, Callable, Deque, Dict
 
 import acp

acp_adapter/permissions.py

@@ -5,11 +5,14 @@ from __future__ import annotations
 import asyncio
 import logging
 from concurrent.futures import TimeoutError as FutureTimeout
-from typing import Callable
+from typing import Any, Callable, Optional
 
 from acp.schema import (
     AllowedOutcome,
+    DeniedOutcome,
     PermissionOption,
+    RequestPermissionRequest,
+    SelectedPermissionOutcome,
 )
 
 logger = logging.getLogger(__name__)

agent/auxiliary_client.py

@@ -41,7 +41,7 @@ import logging
 import os
 import threading
 import time
-from pathlib import Path  # noqa: F401 — used by test mocks
+from pathlib import Path
 from types import SimpleNamespace
 from typing import Any, Dict, List, Optional, Tuple
 

agent/context_compressor.py

@@ -14,6 +14,7 @@ Improvements over v1:
 """
 
 import logging
+import os
 from typing import Any, Dict, List, Optional
 
 from agent.auxiliary_client import call_llm

agent/display.py

@@ -239,6 +239,7 @@ class KawaiiSpinner:
         self.frame_idx = 0
         self.start_time = None
         self.last_line_len = 0
+        self._last_flush_time = 0.0  # Rate-limit flushes for patch_stdout compat
         # Capture stdout NOW, before any redirect_stdout(devnull) from
         # child agents can replace sys.stdout with a black hole.
         self._out = sys.stdout
@@ -252,50 +253,16 @@ class KawaiiSpinner:
         except (ValueError, OSError):
             pass
 
-    @property
-    def _is_tty(self) -> bool:
-        """Check if output is a real terminal, safe against closed streams."""
-        try:
-            return hasattr(self._out, 'isatty') and self._out.isatty()
-        except (ValueError, OSError):
-            return False
-
-    def _is_patch_stdout_proxy(self) -> bool:
-        """Return True when stdout is prompt_toolkit's StdoutProxy.
-
-        patch_stdout wraps sys.stdout in a StdoutProxy that queues writes and
-        injects newlines around each flush().  The \\r overwrite never lands on
-        the correct line — each spinner frame ends up on its own line.
-
-        The CLI already drives a TUI widget (_spinner_text) for spinner display,
-        so KawaiiSpinner's \\r-based animation is redundant under StdoutProxy.
-        """
-        out = self._out
-        # StdoutProxy has a 'raw' attribute (bool) that plain file objects lack.
-        if hasattr(out, 'raw') and type(out).__name__ == 'StdoutProxy':
-            return True
-        return False
-
     def _animate(self):
         # When stdout is not a real terminal (e.g. Docker, systemd, pipe),
         # skip the animation entirely — it creates massive log bloat.
         # Just log the start once and let stop() log the completion.
-        if not self._is_tty:
+        if not hasattr(self._out, 'isatty') or not self._out.isatty():
             self._write(f"  [tool] {self.message}", flush=True)
             while self.running:
                 time.sleep(0.5)
             return
 
-        # When running inside prompt_toolkit's patch_stdout context the CLI
-        # renders spinner state via a dedicated TUI widget (_spinner_text).
-        # Driving a \r-based animation here too causes visual overdraw: the
-        # StdoutProxy injects newlines around each flush, so every frame lands
-        # on a new line and overwrites the status bar.
-        if self._is_patch_stdout_proxy():
-            while self.running:
-                time.sleep(0.1)
-            return
-
         # Cache skin wings at start (avoid per-frame imports)
         skin = _get_skin()
         wings = skin.get_spinner_wings() if skin else []
@@ -312,7 +279,18 @@ class KawaiiSpinner:
             else:
                 line = f"  {frame} {self.message} ({elapsed:.1f}s)"
             pad = max(self.last_line_len - len(line), 0)
-            self._write(f"\r{line}{' ' * pad}", end='', flush=True)
+            # Rate-limit flush() calls to avoid spinner spam under
+            # prompt_toolkit's patch_stdout.  Each flush() pushes a queue
+            # item that may trigger a separate run_in_terminal() call; if
+            # items are processed one-at-a-time the \r overwrite is lost
+            # and every frame appears on its own line.  By flushing at
+            # most every 0.4s we guarantee multiple \r-frames are batched
+            # into a single write, so the terminal collapses them correctly.
+            now = time.time()
+            should_flush = (now - self._last_flush_time) >= 0.4
+            self._write(f"\r{line}{' ' * pad}", end='', flush=should_flush)
+            if should_flush:
+                self._last_flush_time = now
             self.last_line_len = len(line)
             self.frame_idx += 1
             time.sleep(0.12)
@@ -351,7 +329,7 @@ class KawaiiSpinner:
         if self.thread:
             self.thread.join(timeout=0.5)
 
-        is_tty = self._is_tty
+        is_tty = hasattr(self._out, 'isatty') and self._out.isatty()
         if is_tty:
             # Clear the spinner line with spaces instead of \033[K to avoid
             # garbled escape codes when prompt_toolkit's patch_stdout is active.

agent/prompt_builder.py

@@ -354,15 +354,8 @@ def build_skills_system_prompt(
         fm_name = frontmatter.get("name", skill_name)
         if fm_name in disabled or skill_name in disabled:
             continue
-        # Extract conditions inline from already-parsed frontmatter
-        # (avoids redundant file re-read that _read_skill_conditions would do)
-        hermes_meta = frontmatter.get("metadata", {}).get("hermes", {})
-        conditions = {
-            "fallback_for_toolsets": hermes_meta.get("fallback_for_toolsets", []),
-            "requires_toolsets": hermes_meta.get("requires_toolsets", []),
-            "fallback_for_tools": hermes_meta.get("fallback_for_tools", []),
-            "requires_tools": hermes_meta.get("requires_tools", []),
-        }
+        # Skip skills whose conditional activation rules exclude them
+        conditions = _read_skill_conditions(skill_file)
         if not _skill_should_show(conditions, available_tools, available_toolsets):
             continue
         skills_by_category.setdefault(category, []).append((skill_name, desc))

agent/usage_pricing.py

@@ -649,8 +649,7 @@ def format_token_count_compact(value: int) -> str:
                 text = f"{scaled:.1f}"
             else:
                 text = f"{scaled:.0f}"
-            if "." in text:
-                text = text.rstrip("0").rstrip(".")
+            text = text.rstrip("0").rstrip(".")
             return f"{sign}{text}{suffix}"
 
     return f"{value:,}"

cli.py

@@ -458,8 +458,13 @@ from run_agent import AIAgent
 from model_tools import get_tool_definitions, get_toolset_for_tool
 
 # Extracted CLI modules (Phase 3)
-from hermes_cli.banner import build_welcome_banner
-from hermes_cli.commands import SlashCommandCompleter, SlashCommandAutoSuggest
+from hermes_cli.banner import (
+    cprint as _cprint, _GOLD, _BOLD, _DIM, _RST,
+    HERMES_AGENT_LOGO, HERMES_CADUCEUS, COMPACT_BANNER,
+    build_welcome_banner,
+)
+from hermes_cli.commands import COMMANDS, SlashCommandCompleter, SlashCommandAutoSuggest
+from hermes_cli import callbacks as _callbacks
 from toolsets import get_all_toolsets, get_toolset_info, validate_toolset
 
 # Cron job system for scheduled tasks (execution is handled by the gateway)
@@ -1049,8 +1054,6 @@ class HermesCLI:
         self._stream_buf = ""        # Partial line buffer for line-buffered rendering
         self._stream_started = False  # True once first delta arrives
         self._stream_box_opened = False  # True once the response box header is printed
-        self._reasoning_stream_started = False  # True once live reasoning starts streaming
-        self._reasoning_preview_buf = ""  # Coalesce tiny reasoning chunks for [thinking] output
         
         # Configuration - priority: CLI args > env vars > config file
         # Model comes from: CLI arg or config.yaml (single source of truth).
@@ -1183,8 +1186,8 @@ class HermesCLI:
         try:
             from hermes_state import SessionDB
             self._session_db = SessionDB()
-        except Exception as e:
-            logger.warning("Failed to initialize SessionDB — session will NOT be indexed for search: %s", e)
+        except Exception:
+            pass
         
         # Deferred title: stored in memory until the session is created in the DB
         self._pending_title: Optional[str] = None
@@ -1475,108 +1478,11 @@ class HermesCLI:
 
     def _on_thinking(self, text: str) -> None:
         """Called by agent when thinking starts/stops. Updates TUI spinner."""
-        if not text:
-            self._flush_reasoning_preview(force=True)
         self._spinner_text = text or ""
         self._invalidate()
 
     # ── Streaming display ────────────────────────────────────────────────
 
-    def _current_reasoning_callback(self):
-        """Return the active reasoning display callback for the current mode."""
-        if self.show_reasoning and self.streaming_enabled:
-            return self._stream_reasoning_delta
-        if self.verbose and not self.show_reasoning:
-            return self._on_reasoning
-        return None
-
-    def _emit_reasoning_preview(self, reasoning_text: str) -> None:
-        """Render a buffered reasoning preview as a single [thinking] block."""
-        import re
-        import textwrap
-
-        preview_text = reasoning_text.strip()
-        if not preview_text:
-            return
-
-        try:
-            term_width = shutil.get_terminal_size().columns
-        except Exception:
-            term_width = 80
-        prefix = "  [thinking] "
-        wrap_width = max(30, term_width - len(prefix) - 2)
-
-        paragraphs = []
-        raw_paragraphs = re.split(r"\n\s*\n+", preview_text.replace("\r\n", "\n"))
-        for paragraph in raw_paragraphs:
-            compact = " ".join(line.strip() for line in paragraph.splitlines() if line.strip())
-            if compact:
-                paragraphs.append(textwrap.fill(compact, width=wrap_width))
-        preview_text = "\n".join(paragraphs)
-        if not preview_text:
-            return
-
-        if self.verbose:
-            _cprint(f"  {_DIM}[thinking] {preview_text}{_RST}")
-            return
-
-        lines = preview_text.splitlines()
-        if len(lines) > 5:
-            preview = "\n".join(lines[:5])
-            preview += f"\n  ... ({len(lines) - 5} more lines)"
-        else:
-            preview = preview_text
-        _cprint(f"  {_DIM}[thinking] {preview}{_RST}")
-
-    def _flush_reasoning_preview(self, *, force: bool = False) -> None:
-        """Flush buffered reasoning text at natural boundaries.
-
-        Some providers stream reasoning in tiny word or punctuation chunks.
-        Buffer them here so the preview path does not print one `[thinking]`
-        line per token.
-        """
-        buf = getattr(self, "_reasoning_preview_buf", "")
-        if not buf:
-            return
-
-        try:
-            term_width = shutil.get_terminal_size().columns
-        except Exception:
-            term_width = 80
-        target_width = max(40, term_width - len("  [thinking] ") - 4)
-
-        flush_text = ""
-
-        if force:
-            flush_text = buf
-            buf = ""
-        else:
-            line_break = buf.rfind("\n")
-            min_newline_flush = max(16, target_width // 3)
-            if line_break != -1 and (
-                line_break >= min_newline_flush
-                or buf.endswith("\n\n")
-                or buf.endswith(".\n")
-                or buf.endswith("!\n")
-                or buf.endswith("?\n")
-                or buf.endswith(":\n")
-            ):
-                flush_text = buf[: line_break + 1]
-                buf = buf[line_break + 1 :]
-            elif len(buf) >= target_width:
-                search_start = max(20, target_width // 2)
-                search_end = min(len(buf), max(target_width + (target_width // 3), target_width + 8))
-                cut = -1
-                for boundary in (" ", "\t", ".", "!", "?", ",", ";", ":"):
-                    cut = max(cut, buf.rfind(boundary, search_start, search_end))
-                if cut != -1:
-                    flush_text = buf[: cut + 1]
-                    buf = buf[cut + 1 :]
-
-        self._reasoning_preview_buf = buf.lstrip() if flush_text else buf
-        if flush_text:
-            self._emit_reasoning_preview(flush_text)
-
     def _stream_reasoning_delta(self, text: str) -> None:
         """Stream reasoning/thinking tokens into a dim box above the response.
 
@@ -1590,7 +1496,6 @@ class HermesCLI:
         """
         if not text:
             return
-        self._reasoning_stream_started = True
         if getattr(self, "_stream_box_opened", False):
             return
 
@@ -1604,14 +1509,10 @@ class HermesCLI:
 
         self._reasoning_buf = getattr(self, "_reasoning_buf", "") + text
 
-        # Emit complete lines, and force-flush long partial lines so
-        # reasoning is visible in real-time even without newlines.
+        # Emit complete lines
         while "\n" in self._reasoning_buf:
             line, self._reasoning_buf = self._reasoning_buf.split("\n", 1)
             _cprint(f"{_DIM}{line}{_RST}")
-        if len(self._reasoning_buf) > 80:
-            _cprint(f"{_DIM}{self._reasoning_buf}{_RST}")
-            self._reasoning_buf = ""
 
     def _close_reasoning_box(self) -> None:
         """Close the live reasoning box if it's open."""
@@ -1786,13 +1687,11 @@ class HermesCLI:
         self._stream_buf = ""
         self._stream_started = False
         self._stream_box_opened = False
-        self._reasoning_stream_started = False
         self._stream_text_ansi = ""
         self._stream_prefilt = ""
         self._in_reasoning_block = False
         self._reasoning_box_opened = False
         self._reasoning_buf = ""
-        self._reasoning_preview_buf = ""
 
     def _slow_command_status(self, command: str) -> str:
         """Return a user-facing status message for slower slash commands."""
@@ -1949,7 +1848,7 @@ class HermesCLI:
                 from hermes_state import SessionDB
                 self._session_db = SessionDB()
             except Exception as e:
-                logger.warning("SQLite session store not available — session will NOT be indexed: %s", e)
+                logger.debug("SQLite session store not available: %s", e)
         
         # If resuming, validate the session exists and load its history.
         # _preload_resumed_session() may have already loaded it (called from
@@ -2023,7 +1922,11 @@ class HermesCLI:
                 platform="cli",
                 session_db=self._session_db,
                 clarify_callback=self._clarify_callback,
-                reasoning_callback=self._current_reasoning_callback(),
+                reasoning_callback=(
+                    self._stream_reasoning_delta if (self.streaming_enabled and self.show_reasoning)
+                    else self._on_reasoning if (self.show_reasoning or self.verbose)
+                    else None
+                ),
                 honcho_session_key=None,  # resolved by run_agent via config sessions map / title
                 fallback_model=self._fallback_model,
                 thinking_callback=self._on_thinking,
@@ -2336,7 +2239,7 @@ class HermesCLI:
             /rollback diff <N>        — preview changes since checkpoint N
             /rollback <N> <file>      — restore a single file from checkpoint N
         """
-        from tools.checkpoint_manager import format_checkpoint_list
+        from tools.checkpoint_manager import CheckpointManager, format_checkpoint_list
 
         if not hasattr(self, 'agent') or not self.agent:
             print("  No active agent session.")
@@ -2536,7 +2439,7 @@ class HermesCLI:
     def _show_tool_availability_warnings(self):
         """Show warnings about disabled tools due to missing API keys."""
         try:
-            from model_tools import check_tool_availability
+            from model_tools import check_tool_availability, TOOLSET_REQUIREMENTS
             
             available, unavailable = check_tool_availability()
             
@@ -2876,7 +2779,7 @@ class HermesCLI:
         if self.agent and self.conversation_history:
             try:
                 self.agent.flush_memories(self.conversation_history)
-            except (Exception, KeyboardInterrupt):
+            except Exception:
                 pass
 
         old_session_id = self.session_id
@@ -4024,13 +3927,7 @@ class HermesCLI:
                 if not response and result and result.get("error"):
                     response = f"Error: {result['error']}"
 
-                # Display result in the CLI (thread-safe via patch_stdout).
-                # Force a TUI refresh first so spinner/status bar don't overlap
-                # with the output (fixes #2718).
-                if self._app:
-                    self._app.invalidate()
-                    import time as _tmod
-                    _tmod.sleep(0.05)  # brief pause for refresh
+                # Display result in the CLI (thread-safe via patch_stdout)
                 print()
                 ChatConsole().print(f"[{_accent_hex()}]{'─' * 40}[/]")
                 _cprint(f"  ✅ Background task #{task_num} complete")
@@ -4067,11 +3964,6 @@ class HermesCLI:
                     sys.stdout.flush()
 
             except Exception as e:
-                # Same TUI refresh pattern as success path (#2718)
-                if self._app:
-                    self._app.invalidate()
-                    import time as _tmod
-                    _tmod.sleep(0.05)
                 print()
                 _cprint(f"  ❌ Background task #{task_num} failed: {e}")
             finally:
@@ -4129,6 +4021,7 @@ class HermesCLI:
     def _handle_browser_command(self, cmd: str):
         """Handle /browser connect|disconnect|status — manage live Chrome CDP connection."""
         import platform as _plat
+        import subprocess as _sp
 
         parts = cmd.strip().split(None, 1)
         sub = parts[1].lower().strip() if len(parts) > 1 else "status"
@@ -4338,7 +4231,11 @@ class HermesCLI:
         if self.agent:
             self.agent.verbose_logging = self.verbose
             self.agent.quiet_mode = not self.verbose
-            self.agent.reasoning_callback = self._current_reasoning_callback()
+            # Auto-enable reasoning display in verbose mode
+            if self.verbose:
+                self.agent.reasoning_callback = self._on_reasoning
+            elif not self.show_reasoning:
+                self.agent.reasoning_callback = None
 
         # Use raw ANSI codes via _cprint so the output is routed through
         # prompt_toolkit's renderer.  self.console.print() with Rich markup
@@ -4385,7 +4282,7 @@ class HermesCLI:
         if arg in ("show", "on"):
             self.show_reasoning = True
             if self.agent:
-                self.agent.reasoning_callback = self._current_reasoning_callback()
+                self.agent.reasoning_callback = self._on_reasoning
             save_config_value("display.show_reasoning", True)
             _cprint(f"  {_GOLD}✓ Reasoning display: ON (saved){_RST}")
             _cprint(f"  {_DIM}  Model thinking will be shown during and after each response.{_RST}")
@@ -4393,7 +4290,7 @@ class HermesCLI:
         if arg in ("hide", "off"):
             self.show_reasoning = False
             if self.agent:
-                self.agent.reasoning_callback = self._current_reasoning_callback()
+                self.agent.reasoning_callback = None
             save_config_value("display.show_reasoning", False)
             _cprint(f"  {_GOLD}✓ Reasoning display: OFF (saved){_RST}")
             return
@@ -4416,10 +4313,17 @@ class HermesCLI:
 
     def _on_reasoning(self, reasoning_text: str):
         """Callback for intermediate reasoning display during tool-call loops."""
-        if not reasoning_text:
-            return
-        self._reasoning_preview_buf = getattr(self, "_reasoning_preview_buf", "") + reasoning_text
-        self._flush_reasoning_preview(force=False)
+        if self.verbose:
+            # Verbose mode: show full reasoning text
+            _cprint(f"  {_DIM}[thinking] {reasoning_text.strip()}{_RST}")
+        else:
+            lines = reasoning_text.strip().splitlines()
+            if len(lines) > 5:
+                preview = "\n".join(lines[:5])
+                preview += f"\n  ... ({len(lines) - 5} more lines)"
+            else:
+                preview = reasoning_text.strip()
+            _cprint(f"  {_DIM}[thinking] {preview}{_RST}")
 
     def _manual_compress(self):
         """Manually trigger context compression on the current conversation."""
@@ -4630,7 +4534,7 @@ class HermesCLI:
         sees the updated tools on the next turn.
         """
         try:
-            from tools.mcp_tool import shutdown_mcp_servers, discover_mcp_tools, _servers, _lock
+            from tools.mcp_tool import shutdown_mcp_servers, discover_mcp_tools, _load_mcp_config, _servers, _lock
 
             # Capture old server names
             with _lock:
@@ -4950,6 +4854,7 @@ class HermesCLI:
         try:
             from tools.tts_tool import text_to_speech_tool
             from tools.voice_mode import play_audio_file
+            import json
             import re
 
             # Strip markdown and non-speech content for cleaner TTS
@@ -5719,7 +5624,7 @@ class HermesCLI:
 
             # Display reasoning (thinking) box if enabled and available.
             # Skip when streaming already showed reasoning live.
-            if self.show_reasoning and result and not self._reasoning_stream_started:
+            if self.show_reasoning and result and not self._stream_started:
                 reasoning = result.get("last_reasoning")
                 if reasoning:
                     w = shutil.get_terminal_size().columns
@@ -6523,7 +6428,8 @@ class HermesCLI:
             """Return provider/model info for /model autocomplete."""
             try:
                 from hermes_cli.models import (
-                    _PROVIDER_LABELS, normalize_provider, provider_model_ids,
+                    _PROVIDER_LABELS, _PROVIDER_MODELS, normalize_provider,
+                    provider_model_ids,
                 )
                 current = getattr(cli_ref, "provider", None) or getattr(cli_ref, "requested_provider", "openrouter")
                 current = normalize_provider(current)
@@ -7209,7 +7115,7 @@ class HermesCLI:
             if self.agent and self.conversation_history:
                 try:
                     self.agent.flush_memories(self.conversation_history)
-                except (Exception, KeyboardInterrupt):
+                except Exception:
                     pass
             # Shut down voice recorder (release persistent audio stream)
             if hasattr(self, '_voice_recorder') and self._voice_recorder:

cron/scheduler.py

@@ -24,6 +24,7 @@ except ImportError:
         import msvcrt
     except ImportError:
         msvcrt = None
+from datetime import datetime
 from pathlib import Path
 from typing import Optional
 
@@ -279,7 +280,6 @@ def run_job(job: dict) -> tuple[bool, str, str, Optional[str]]:
     job_name = job["name"]
     prompt = _build_job_prompt(job)
     origin = _resolve_origin(job)
-    _cron_session_id = f"cron_{job_id}_{_hermes_now().strftime('%Y%m%d_%H%M%S')}"
 
     logger.info("Running job '%s' (ID: %s)", job_name, job_id)
     logger.info("Prompt: %s", prompt[:100])
@@ -411,7 +411,7 @@ def run_job(job: dict) -> tuple[bool, str, str, Optional[str]]:
             disabled_toolsets=["cronjob", "messaging", "clarify"],
             quiet_mode=True,
             platform="cron",
-            session_id=_cron_session_id,
+            session_id=f"cron_{job_id}_{_hermes_now().strftime('%Y%m%d_%H%M%S')}",
             session_db=_session_db,
         )
         
@@ -476,10 +476,6 @@ def run_job(job: dict) -> tuple[bool, str, str, Optional[str]]:
         ):
             os.environ.pop(key, None)
         if _session_db:
-            try:
-                _session_db.end_session(_cron_session_id, "cron_complete")
-            except Exception as e:
-                logger.debug("Job '%s': failed to end session: %s", job_id, e)
             try:
                 _session_db.close()
             except Exception as e:

gateway/channel_directory.py

@@ -9,6 +9,7 @@ action="list" and for resolving human-friendly channel names to numeric IDs.
 import json
 import logging
 from datetime import datetime
+from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from hermes_cli.config import get_hermes_home
@@ -89,7 +90,7 @@ def _build_discord(adapter) -> List[Dict[str, str]]:
         return channels
 
     try:
-        import discord as _discord  # noqa: F401 — SDK presence check
+        import discord as _discord
     except ImportError:
         return channels
 
@@ -118,6 +119,7 @@ def _build_slack(adapter) -> List[Dict[str, str]]:
         return _build_from_sessions("slack")
 
     try:
+        import asyncio
         from tools.send_message_tool import _send_slack  # noqa: F401
         # Use the Slack Web API directly if available
     except Exception:

gateway/delivery.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from datetime import datetime
 from dataclasses import dataclass
 from typing import Dict, List, Optional, Any, Union
+from enum import Enum
 
 from hermes_cli.config import get_hermes_home
 

gateway/hooks.py

@@ -21,6 +21,8 @@ Errors in hooks are caught and logged but never block the main pipeline.
 
 import asyncio
 import importlib.util
+import os
+from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
 import yaml

gateway/mirror.py

@@ -12,6 +12,7 @@ the full SessionStore machinery.
 import json
 import logging
 from datetime import datetime
+from pathlib import Path
 from typing import Optional
 
 from hermes_cli.config import get_hermes_home

gateway/platforms/api_server.py

@@ -478,15 +478,7 @@ class APIServerAdapter(BasePlatformAdapter):
             _stream_q: _q.Queue = _q.Queue()
 
             def _on_delta(delta):
-                # Filter out None — the agent fires stream_delta_callback(None)
-                # to signal the CLI display to close its response box before
-                # tool execution, but the SSE writer uses None as end-of-stream
-                # sentinel.  Forwarding it would prematurely close the HTTP
-                # response, causing Open WebUI (and similar frontends) to miss
-                # the final answer after tool calls.  The SSE loop detects
-                # completion via agent_task.done() instead.
-                if delta is not None:
-                    _stream_q.put(delta)
+                _stream_q.put(delta)
 
             # Start agent in background
             agent_task = asyncio.ensure_future(self._run_agent(

gateway/platforms/base.py

@@ -819,16 +819,6 @@ class BasePlatformAdapter(ABC):
                 await asyncio.sleep(interval)
         except asyncio.CancelledError:
             pass  # Normal cancellation when handler completes
-        finally:
-            # Ensure the underlying platform typing loop is stopped.
-            # _keep_typing may have called send_typing() after an outer
-            # stop_typing() cleared the task dict, recreating the loop.
-            # Cancelling _keep_typing alone won't clean that up.
-            if hasattr(self, "stop_typing"):
-                try:
-                    await self.stop_typing(chat_id)
-                except Exception:
-                    pass
     
     async def handle_message(self, event: MessageEvent) -> None:
         """
@@ -1140,13 +1130,6 @@ class BasePlatformAdapter(ABC):
                 await typing_task
             except asyncio.CancelledError:
                 pass
-            # Also cancel any platform-level persistent typing tasks (e.g. Discord)
-            # that may have been recreated by _keep_typing after the last stop_typing()
-            try:
-                if hasattr(self, "stop_typing"):
-                    await self.stop_typing(event.source.chat_id)
-            except Exception:
-                pass
             # Clean up session tracking
             if session_key in self._active_sessions:
                 del self._active_sessions[session_key]

gateway/platforms/discord.py

@@ -20,7 +20,7 @@ import threading
 import time
 from collections import defaultdict
 from pathlib import Path
-from typing import Callable, Dict, Optional, Any
+from typing import Callable, Dict, List, Optional, Any
 
 logger = logging.getLogger(__name__)
 

gateway/platforms/email.py

@@ -24,6 +24,7 @@ import re
 import smtplib
 import ssl
 import uuid
+from datetime import datetime
 from email.header import decode_header
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
@@ -453,6 +454,7 @@ class EmailAdapter(BasePlatformAdapter):
 
     async def send_typing(self, chat_id: str, metadata: Optional[Dict[str, Any]] = None) -> None:
         """Email has no typing indicator — no-op."""
+        pass
 
     async def send_image(
         self,

gateway/platforms/homeassistant.py

@@ -19,7 +19,7 @@ import os
 import time
 import uuid
 from datetime import datetime
-from typing import Any, Dict, Optional, Set
+from typing import Any, Dict, List, Optional, Set
 
 try:
     import aiohttp
@@ -435,6 +435,7 @@ class HomeAssistantAdapter(BasePlatformAdapter):
 
     async def send_typing(self, chat_id: str, metadata=None) -> None:
         """No typing indicator for Home Assistant."""
+        pass
 
     async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
         """Return basic info about the HA event channel."""

gateway/platforms/matrix.py

@@ -17,13 +17,14 @@ Environment variables:
 from __future__ import annotations
 
 import asyncio
+import json
 import logging
 import mimetypes
 import os
 import re
 import time
 from pathlib import Path
-from typing import Any, Dict, Optional, Set
+from typing import Any, Dict, List, Optional, Set
 
 from gateway.config import Platform, PlatformConfig
 from gateway.platforms.base import (

gateway/platforms/mattermost.py

@@ -20,7 +20,7 @@ import os
 import re
 import time
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 from gateway.config import Platform, PlatformConfig
 from gateway.platforms.base import (

gateway/platforms/slack.py

@@ -12,7 +12,7 @@ import asyncio
 import logging
 import os
 import re
-from typing import Dict, Optional, Any
+from typing import Dict, List, Optional, Any
 
 try:
     from slack_bolt.async_app import AsyncApp
@@ -37,6 +37,8 @@ from gateway.platforms.base import (
     SendResult,
     SUPPORTED_DOCUMENT_TYPES,
     cache_document_from_bytes,
+    cache_image_from_url,
+    cache_audio_from_url,
 )
 
 

gateway/platforms/sms.py

@@ -17,11 +17,12 @@ Gateway-specific env vars:
 
 import asyncio
 import base64
+import json
 import logging
 import os
 import re
 import urllib.parse
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from gateway.config import Platform, PlatformConfig
 from gateway.platforms.base import (

gateway/platforms/telegram.py

@@ -11,7 +11,7 @@ import asyncio
 import logging
 import os
 import re
-from typing import Dict, Optional, Any
+from typing import Dict, List, Optional, Any
 
 logger = logging.getLogger(__name__)
 

gateway/platforms/whatsapp.py

@@ -16,6 +16,7 @@ with different backends via a bridge pattern.
 """
 
 import asyncio
+import json
 import logging
 import os
 import platform
@@ -23,7 +24,7 @@ import subprocess
 
 _IS_WINDOWS = platform.system() == "Windows"
 from pathlib import Path
-from typing import Dict, Optional, Any
+from typing import Dict, List, Optional, Any
 
 from hermes_cli.config import get_hermes_home
 
@@ -73,7 +74,6 @@ from gateway.platforms.base import (
     MessageEvent,
     MessageType,
     SendResult,
-    SUPPORTED_DOCUMENT_TYPES,
     cache_image_from_url,
     cache_audio_from_url,
 )
@@ -665,7 +665,7 @@ class WhatsAppAdapter(BasePlatformAdapter):
                 user_name=data.get("senderName"),
             )
             
-            # Download media URLs to the local cache so agent tools
+            # Download image media URLs to the local cache so the vision tool
             # can access them reliably regardless of URL expiration.
             raw_urls = data.get("mediaUrls", [])
             cached_urls = []
@@ -696,59 +696,12 @@ class WhatsAppAdapter(BasePlatformAdapter):
                         print(f"[{self.name}] Failed to cache voice: {e}", flush=True)
                         cached_urls.append(url)
                         media_types.append("audio/ogg")
-                elif msg_type == MessageType.VOICE and os.path.isabs(url):
-                    # Local file path — bridge already downloaded the audio
-                    cached_urls.append(url)
-                    media_types.append("audio/ogg")
-                    print(f"[{self.name}] Using bridge-cached audio: {url}", flush=True)
-                elif msg_type == MessageType.DOCUMENT and os.path.isabs(url):
-                    # Local file path — bridge already downloaded the document
-                    cached_urls.append(url)
-                    ext = Path(url).suffix.lower()
-                    mime = SUPPORTED_DOCUMENT_TYPES.get(ext, "application/octet-stream")
-                    media_types.append(mime)
-                    print(f"[{self.name}] Using bridge-cached document: {url}", flush=True)
-                elif msg_type == MessageType.VIDEO and os.path.isabs(url):
-                    cached_urls.append(url)
-                    media_types.append("video/mp4")
-                    print(f"[{self.name}] Using bridge-cached video: {url}", flush=True)
                 else:
                     cached_urls.append(url)
                     media_types.append("unknown")
-
-            # For text-readable documents, inject file content directly into
-            # the message text so the agent can read it inline.
-            # Cap at 100KB to match Telegram/Discord/Slack behaviour.
-            body = data.get("body", "")
-            MAX_TEXT_INJECT_BYTES = 100 * 1024
-            if msg_type == MessageType.DOCUMENT and cached_urls:
-                for doc_path in cached_urls:
-                    ext = Path(doc_path).suffix.lower()
-                    if ext in (".txt", ".md", ".csv", ".json", ".xml", ".yaml", ".yml", ".log", ".py", ".js", ".ts", ".html", ".css"):
-                        try:
-                            file_size = Path(doc_path).stat().st_size
-                            if file_size > MAX_TEXT_INJECT_BYTES:
-                                print(f"[{self.name}] Skipping text injection for {doc_path} ({file_size} bytes > {MAX_TEXT_INJECT_BYTES})", flush=True)
-                                continue
-                            content = Path(doc_path).read_text(errors="replace")
-                            fname = Path(doc_path).name
-                            # Remove the doc_<hex>_ prefix for display
-                            display_name = fname
-                            if "_" in fname:
-                                parts = fname.split("_", 2)
-                                if len(parts) >= 3:
-                                    display_name = parts[2]
-                            injection = f"[Content of {display_name}]:\n{content}"
-                            if body:
-                                body = f"{injection}\n\n{body}"
-                            else:
-                                body = injection
-                            print(f"[{self.name}] Injected text content from: {doc_path}", flush=True)
-                        except Exception as e:
-                            print(f"[{self.name}] Failed to read document text: {e}", flush=True)
-
+            
             return MessageEvent(
-                text=body,
+                text=data.get("body", ""),
                 message_type=msg_type,
                 source=source,
                 raw_message=data,

gateway/run.py

@@ -220,7 +220,7 @@ from gateway.session import (
     build_session_context_prompt,
     build_session_key,
 )
-from gateway.delivery import DeliveryRouter
+from gateway.delivery import DeliveryRouter, DeliveryTarget
 from gateway.platforms.base import BasePlatformAdapter, MessageEvent, MessageType
 
 logger = logging.getLogger(__name__)
@@ -2771,6 +2771,8 @@ class GatewayRunner:
         """Handle /model command - show or change the current model."""
         import yaml
         from hermes_cli.models import (
+            parse_model_input,
+            validate_requested_model,
             curated_models_for_provider,
             normalize_provider,
             _PROVIDER_LABELS,
@@ -5286,18 +5288,7 @@ class GatewayRunner:
                         if msg.get("mirror"):
                             mirror_src = msg.get("mirror_source", "another session")
                             content = f"[Delivered from {mirror_src}] {content}"
-                        entry = {"role": role, "content": content}
-                        # Preserve reasoning fields on assistant messages so
-                        # multi-turn reasoning context survives session reload.
-                        # The agent's _build_api_kwargs converts these to the
-                        # provider-specific format (reasoning_content, etc.).
-                        if role == "assistant":
-                            for _rkey in ("reasoning", "reasoning_details",
-                                          "codex_reasoning_items"):
-                                _rval = msg.get(_rkey)
-                                if _rval:
-                                    entry[_rkey] = _rval
-                        agent_history.append(entry)
+                        agent_history.append({"role": role, "content": content})
             
             # Collect MEDIA paths already in history so we can exclude them
             # from the current turn's extraction. This is compression-safe:

gateway/session.py

@@ -13,21 +13,15 @@ import logging
 import os
 import json
 import re
-import threading
 import uuid
 from pathlib import Path
 from datetime import datetime, timedelta
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Any
 
 logger = logging.getLogger(__name__)
 
 
-def _now() -> datetime:
-    """Return the current local time."""
-    return datetime.now()
-
-
 # ---------------------------------------------------------------------------
 # PII redaction helpers
 # ---------------------------------------------------------------------------
@@ -65,7 +59,7 @@ def _looks_like_phone(value: str) -> bool:
 from .config import (
     Platform,
     GatewayConfig,
-    SessionResetPolicy,  # noqa: F401 — re-exported via gateway/__init__.py
+    SessionResetPolicy,
     HomeChannel,
 )
 
@@ -477,7 +471,6 @@ class SessionStore:
         self.config = config
         self._entries: Dict[str, SessionEntry] = {}
         self._loaded = False
-        self._lock = threading.Lock()
         self._has_active_processes_fn = has_active_processes_fn
         # on_auto_reset is deprecated — memory flush now runs proactively
         # via the background session expiry watcher in GatewayRunner.
@@ -493,17 +486,12 @@ class SessionStore:
     
     def _ensure_loaded(self) -> None:
         """Load sessions index from disk if not already loaded."""
-        with self._lock:
-            self._ensure_loaded_locked()
-
-    def _ensure_loaded_locked(self) -> None:
-        """Load sessions index from disk. Must be called with self._lock held."""
         if self._loaded:
             return
-
+        
         self.sessions_dir.mkdir(parents=True, exist_ok=True)
         sessions_file = self.sessions_dir / "sessions.json"
-
+        
         if sessions_file.exists():
             try:
                 with open(sessions_file, "r", encoding="utf-8") as f:
@@ -516,7 +504,7 @@ class SessionStore:
                             continue
             except Exception as e:
                 print(f"[gateway] Warning: Failed to load sessions: {e}")
-
+        
         self._loaded = True
     
     def _save(self) -> None:
@@ -568,7 +556,7 @@ class SessionStore:
         if policy.mode == "none":
             return False
 
-        now = _now()
+        now = datetime.now()
 
         if policy.mode in ("idle", "both"):
             idle_deadline = entry.updated_at + timedelta(minutes=policy.idle_minutes)
@@ -609,7 +597,7 @@ class SessionStore:
         if policy.mode == "none":
             return None
         
-        now = _now()
+        now = datetime.now()
         
         if policy.mode in ("idle", "both"):
             idle_deadline = entry.updated_at + timedelta(minutes=policy.idle_minutes)
@@ -649,97 +637,87 @@ class SessionStore:
                 pass  # fall through to heuristic
         # Fallback: check if sessions.json was loaded with existing data.
         # This covers the rare case where the DB is unavailable.
-        with self._lock:
-            self._ensure_loaded_locked()
-            return len(self._entries) > 1
-
+        self._ensure_loaded()
+        return len(self._entries) > 1
+    
     def get_or_create_session(
-        self,
+        self, 
         source: SessionSource,
         force_new: bool = False
     ) -> SessionEntry:
         """
         Get an existing session or create a new one.
-
+        
         Evaluates reset policy to determine if the existing session is stale.
         Creates a session record in SQLite when a new session starts.
         """
+        self._ensure_loaded()
+        
         session_key = self._generate_session_key(source)
-        now = _now()
-
-        # SQLite calls are made outside the lock to avoid holding it during I/O.
-        # All _entries / _loaded mutations are protected by self._lock.
-        db_end_session_id = None
-        db_create_kwargs = None
-
-        with self._lock:
-            self._ensure_loaded_locked()
-
-            if session_key in self._entries and not force_new:
-                entry = self._entries[session_key]
-
-                reset_reason = self._should_reset(entry, source)
-                if not reset_reason:
-                    entry.updated_at = now
-                    self._save()
-                    return entry
-                else:
-                    # Session is being auto-reset.  The background expiry watcher
-                    # should have already flushed memories proactively; discard
-                    # the marker so it doesn't accumulate.
-                    was_auto_reset = True
-                    auto_reset_reason = reset_reason
-                    # Track whether the expired session had any real conversation
-                    reset_had_activity = entry.total_tokens > 0
-                    db_end_session_id = entry.session_id
-                    self._pre_flushed_sessions.discard(entry.session_id)
+        now = datetime.now()
+        
+        if session_key in self._entries and not force_new:
+            entry = self._entries[session_key]
+            
+            reset_reason = self._should_reset(entry, source)
+            if not reset_reason:
+                entry.updated_at = now
+                self._save()
+                return entry
             else:
-                was_auto_reset = False
-                auto_reset_reason = None
-                reset_had_activity = False
-
-            # Create new session
-            session_id = f"{now.strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
-
-            entry = SessionEntry(
-                session_key=session_key,
-                session_id=session_id,
-                created_at=now,
-                updated_at=now,
-                origin=source,
-                display_name=source.chat_name,
-                platform=source.platform,
-                chat_type=source.chat_type,
-                was_auto_reset=was_auto_reset,
-                auto_reset_reason=auto_reset_reason,
-                reset_had_activity=reset_had_activity,
-            )
-
-            self._entries[session_key] = entry
-            self._save()
-            db_create_kwargs = {
-                "session_id": session_id,
-                "source": source.platform.value,
-                "user_id": source.user_id,
-            }
-
-        # SQLite operations outside the lock
-        if self._db and db_end_session_id:
+                # Session is being auto-reset.  The background expiry watcher
+                # should have already flushed memories proactively; discard
+                # the marker so it doesn't accumulate.
+                was_auto_reset = True
+                auto_reset_reason = reset_reason
+                # Track whether the expired session had any real conversation
+                reset_had_activity = entry.total_tokens > 0
+                self._pre_flushed_sessions.discard(entry.session_id)
+                if self._db:
+                    try:
+                        self._db.end_session(entry.session_id, "session_reset")
+                    except Exception as e:
+                        logger.debug("Session DB operation failed: %s", e)
+        else:
+            was_auto_reset = False
+            auto_reset_reason = None
+            reset_had_activity = False
+        
+        # Create new session
+        session_id = f"{now.strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
+        
+        entry = SessionEntry(
+            session_key=session_key,
+            session_id=session_id,
+            created_at=now,
+            updated_at=now,
+            origin=source,
+            display_name=source.chat_name,
+            platform=source.platform,
+            chat_type=source.chat_type,
+            was_auto_reset=was_auto_reset,
+            auto_reset_reason=auto_reset_reason,
+            reset_had_activity=reset_had_activity,
+        )
+        
+        self._entries[session_key] = entry
+        self._save()
+        
+        # Create session in SQLite
+        if self._db:
             try:
-                self._db.end_session(db_end_session_id, "session_reset")
-            except Exception as e:
-                logger.debug("Session DB operation failed: %s", e)
-
-        if self._db and db_create_kwargs:
-            try:
-                self._db.create_session(**db_create_kwargs)
+                self._db.create_session(
+                    session_id=session_id,
+                    source=source.platform.value,
+                    user_id=source.user_id,
+                )
             except Exception as e:
                 print(f"[gateway] Warning: Failed to create SQLite session: {e}")
-
+        
         return entry
-
+    
     def update_session(
-        self,
+        self, 
         session_key: str,
         input_tokens: int = 0,
         output_tokens: int = 0,
@@ -754,100 +732,91 @@ class SessionStore:
         base_url: Optional[str] = None,
     ) -> None:
         """Update a session's metadata after an interaction."""
-        db_session_id = None
-
-        with self._lock:
-            self._ensure_loaded_locked()
-
-            if session_key in self._entries:
-                entry = self._entries[session_key]
-                entry.updated_at = _now()
-                entry.input_tokens += input_tokens
-                entry.output_tokens += output_tokens
-                entry.cache_read_tokens += cache_read_tokens
-                entry.cache_write_tokens += cache_write_tokens
-                if last_prompt_tokens is not None:
-                    entry.last_prompt_tokens = last_prompt_tokens
-                if estimated_cost_usd is not None:
-                    entry.estimated_cost_usd += estimated_cost_usd
-                if cost_status:
-                    entry.cost_status = cost_status
-                entry.total_tokens = (
-                    entry.input_tokens
-                    + entry.output_tokens
-                    + entry.cache_read_tokens
-                    + entry.cache_write_tokens
-                )
-                self._save()
-                db_session_id = entry.session_id
-
-        if self._db and db_session_id:
-            try:
-                self._db.update_token_counts(
-                    db_session_id,
-                    input_tokens=input_tokens,
-                    output_tokens=output_tokens,
-                    cache_read_tokens=cache_read_tokens,
-                    cache_write_tokens=cache_write_tokens,
-                    estimated_cost_usd=estimated_cost_usd,
-                    cost_status=cost_status,
-                    cost_source=cost_source,
-                    billing_provider=provider,
-                    billing_base_url=base_url,
-                    model=model,
-                )
-            except Exception as e:
-                logger.debug("Session DB operation failed: %s", e)
-
+        self._ensure_loaded()
+        
+        if session_key in self._entries:
+            entry = self._entries[session_key]
+            entry.updated_at = datetime.now()
+            entry.input_tokens += input_tokens
+            entry.output_tokens += output_tokens
+            entry.cache_read_tokens += cache_read_tokens
+            entry.cache_write_tokens += cache_write_tokens
+            if last_prompt_tokens is not None:
+                entry.last_prompt_tokens = last_prompt_tokens
+            if estimated_cost_usd is not None:
+                entry.estimated_cost_usd += estimated_cost_usd
+            if cost_status:
+                entry.cost_status = cost_status
+            entry.total_tokens = (
+                entry.input_tokens
+                + entry.output_tokens
+                + entry.cache_read_tokens
+                + entry.cache_write_tokens
+            )
+            self._save()
+            
+            if self._db:
+                try:
+                    self._db.update_token_counts(
+                        entry.session_id,
+                        input_tokens=input_tokens,
+                        output_tokens=output_tokens,
+                        cache_read_tokens=cache_read_tokens,
+                        cache_write_tokens=cache_write_tokens,
+                        estimated_cost_usd=estimated_cost_usd,
+                        cost_status=cost_status,
+                        cost_source=cost_source,
+                        billing_provider=provider,
+                        billing_base_url=base_url,
+                        model=model,
+                    )
+                except Exception as e:
+                    logger.debug("Session DB operation failed: %s", e)
+    
     def reset_session(self, session_key: str) -> Optional[SessionEntry]:
         """Force reset a session, creating a new session ID."""
-        db_end_session_id = None
-        db_create_kwargs = None
-        new_entry = None
-
-        with self._lock:
-            self._ensure_loaded_locked()
-
-            if session_key not in self._entries:
-                return None
-
-            old_entry = self._entries[session_key]
-            db_end_session_id = old_entry.session_id
-
-            now = _now()
-            session_id = f"{now.strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
-
-            new_entry = SessionEntry(
-                session_key=session_key,
-                session_id=session_id,
-                created_at=now,
-                updated_at=now,
-                origin=old_entry.origin,
-                display_name=old_entry.display_name,
-                platform=old_entry.platform,
-                chat_type=old_entry.chat_type,
-            )
-
-            self._entries[session_key] = new_entry
-            self._save()
-            db_create_kwargs = {
-                "session_id": session_id,
-                "source": old_entry.platform.value if old_entry.platform else "unknown",
-                "user_id": old_entry.origin.user_id if old_entry.origin else None,
-            }
-
-        if self._db and db_end_session_id:
+        self._ensure_loaded()
+        
+        if session_key not in self._entries:
+            return None
+        
+        old_entry = self._entries[session_key]
+        
+        # End old session in SQLite
+        if self._db:
             try:
-                self._db.end_session(db_end_session_id, "session_reset")
+                self._db.end_session(old_entry.session_id, "session_reset")
             except Exception as e:
                 logger.debug("Session DB operation failed: %s", e)
-
-        if self._db and db_create_kwargs:
+        
+        now = datetime.now()
+        session_id = f"{now.strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
+        
+        new_entry = SessionEntry(
+            session_key=session_key,
+            session_id=session_id,
+            created_at=now,
+            updated_at=now,
+            origin=old_entry.origin,
+            display_name=old_entry.display_name,
+            platform=old_entry.platform,
+            chat_type=old_entry.chat_type,
+        )
+        
+        self._entries[session_key] = new_entry
+        self._save()
+        
+        # Create new session in SQLite
+        if self._db:
             try:
-                self._db.create_session(**db_create_kwargs)
+                self._db.create_session(
+                    session_id=session_id,
+                    source=old_entry.platform.value if old_entry.platform else "unknown",
+                    user_id=old_entry.origin.user_id if old_entry.origin else None,
+                )
             except Exception as e:
                 logger.debug("Session DB operation failed: %s", e)
-
+        
         return new_entry
 
     def switch_session(self, session_key: str, target_session_id: str) -> Optional[SessionEntry]:
@@ -858,58 +827,52 @@ class SessionStore:
         generating a fresh session ID, re-uses ``target_session_id`` so the
         old transcript is loaded on the next message.
         """
-        db_end_session_id = None
-        new_entry = None
+        self._ensure_loaded()
 
-        with self._lock:
-            self._ensure_loaded_locked()
+        if session_key not in self._entries:
+            return None
 
-            if session_key not in self._entries:
-                return None
+        old_entry = self._entries[session_key]
 
-            old_entry = self._entries[session_key]
+        # Don't switch if already on that session
+        if old_entry.session_id == target_session_id:
+            return old_entry
 
-            # Don't switch if already on that session
-            if old_entry.session_id == target_session_id:
-                return old_entry
-
-            db_end_session_id = old_entry.session_id
-
-            now = _now()
-            new_entry = SessionEntry(
-                session_key=session_key,
-                session_id=target_session_id,
-                created_at=now,
-                updated_at=now,
-                origin=old_entry.origin,
-                display_name=old_entry.display_name,
-                platform=old_entry.platform,
-                chat_type=old_entry.chat_type,
-            )
-
-            self._entries[session_key] = new_entry
-            self._save()
-
-        if self._db and db_end_session_id:
+        # End the current session in SQLite
+        if self._db:
             try:
-                self._db.end_session(db_end_session_id, "session_switch")
+                self._db.end_session(old_entry.session_id, "session_switch")
             except Exception as e:
                 logger.debug("Session DB end_session failed: %s", e)
 
+        now = datetime.now()
+        new_entry = SessionEntry(
+            session_key=session_key,
+            session_id=target_session_id,
+            created_at=now,
+            updated_at=now,
+            origin=old_entry.origin,
+            display_name=old_entry.display_name,
+            platform=old_entry.platform,
+            chat_type=old_entry.chat_type,
+        )
+
+        self._entries[session_key] = new_entry
+        self._save()
         return new_entry
 
     def list_sessions(self, active_minutes: Optional[int] = None) -> List[SessionEntry]:
         """List all sessions, optionally filtered by activity."""
-        with self._lock:
-            self._ensure_loaded_locked()
-            entries = list(self._entries.values())
-
+        self._ensure_loaded()
+        
+        entries = list(self._entries.values())
+        
         if active_minutes is not None:
-            cutoff = _now() - timedelta(minutes=active_minutes)
+            cutoff = datetime.now() - timedelta(minutes=active_minutes)
             entries = [e for e in entries if e.updated_at >= cutoff]
-
+        
         entries.sort(key=lambda e: e.updated_at, reverse=True)
-
+        
         return entries
     
     def get_transcript_path(self, session_id: str) -> Path:

gateway/sticker_cache.py

@@ -9,7 +9,9 @@ Cache location: ~/.hermes/sticker_cache.json
 """
 
 import json
+import os
 import time
+from pathlib import Path
 from typing import Optional
 
 from hermes_cli.config import get_hermes_home

hermes_cli/banner.py

@@ -11,7 +11,7 @@ import subprocess
 import threading
 import time
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict, List, Any, Optional
 
 from rich.console import Console
 from rich.panel import Panel
@@ -257,7 +257,7 @@ def build_welcome_banner(console: Console, model: str, cwd: str,
         get_toolset_for_tool: Callable to map tool name -> toolset name.
         context_length: Model's context window size in tokens.
     """
-    from model_tools import check_tool_availability
+    from model_tools import check_tool_availability, TOOLSET_REQUIREMENTS
     if get_toolset_for_tool is None:
         from model_tools import get_toolset_for_tool
 

hermes_cli/claw.py

@@ -18,8 +18,10 @@ from hermes_cli.setup import (
     print_header,
     print_info,
     print_success,
+    print_warning,
     print_error,
     prompt_yes_no,
+    prompt_choice,
 )
 
 logger = logging.getLogger(__name__)

hermes_cli/commands.py

@@ -13,7 +13,8 @@ from __future__ import annotations
 import os
 import re
 from collections.abc import Callable, Mapping
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Any
 
 from prompt_toolkit.auto_suggest import AutoSuggest, Suggestion

hermes_cli/config.py

@@ -343,8 +343,6 @@ DEFAULT_CONFIG = {
         "provider": "",    # e.g. "openrouter" (empty = inherit parent provider + credentials)
         "base_url": "",    # direct OpenAI-compatible endpoint for subagents
         "api_key": "",     # API key for delegation.base_url (falls back to OPENAI_API_KEY)
-        "max_iterations": 50,  # per-subagent iteration cap (each subagent gets its own budget,
-                               # independent of the parent's max_iterations)
     },
 
     # Ephemeral prefill messages file — JSON list of {role, content} dicts

hermes_cli/copilot_auth.py

@@ -21,11 +21,12 @@ from __future__ import annotations
 import json
 import logging
 import os
+import re
 import shutil
 import subprocess
 import time
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 logger = logging.getLogger(__name__)
 

hermes_cli/doctor.py

@@ -8,6 +8,7 @@ import os
 import sys
 import subprocess
 import shutil
+from pathlib import Path
 
 from hermes_cli.config import get_project_root, get_hermes_home, get_env_path
 
@@ -447,7 +448,7 @@ def run_doctor(args):
             check_fail("DAYTONA_API_KEY not set", "(required for TERMINAL_ENV=daytona)")
             issues.append("Set DAYTONA_API_KEY environment variable")
         try:
-            from daytona import Daytona  # noqa: F401 — SDK presence check
+            from daytona import Daytona
             check_ok("daytona SDK", "(installed)")
         except ImportError:
             check_fail("daytona SDK not installed", "(pip install daytona)")

hermes_cli/env_loader.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
+from typing import Iterable
 
 from dotenv import load_dotenv
 

hermes_cli/main.py

@@ -548,6 +548,7 @@ def cmd_gateway(args):
 
 def cmd_whatsapp(args):
     """Set up WhatsApp: choose mode, configure, install bridge, pair via QR."""
+    import os
     import subprocess
     from pathlib import Path
     from hermes_cli.config import get_env_value, save_env_value
@@ -741,9 +742,12 @@ def cmd_setup(args):
 def cmd_model(args):
     """Select default model — starts with provider selection, then model picker."""
     from hermes_cli.auth import (
-        resolve_provider, AuthError, format_auth_error,
+        resolve_provider, get_provider_auth_state, PROVIDER_REGISTRY,
+        _prompt_model_selection, _save_model_choice, _update_config_for_provider,
+        resolve_nous_runtime_credentials, fetch_nous_models, AuthError, format_auth_error,
+        _login_nous,
     )
-    from hermes_cli.config import load_config, get_env_value
+    from hermes_cli.config import load_config, save_config, get_env_value, save_env_value
 
     config = load_config()
     current_model = config.get("model")
@@ -1979,7 +1983,7 @@ def _model_flow_api_key_provider(config, provider_id, current_model=""):
     """Generic flow for API-key providers (z.ai, MiniMax)."""
     from hermes_cli.auth import (
         PROVIDER_REGISTRY, _prompt_model_selection, _save_model_choice,
-        deactivate_provider,
+        _update_config_for_provider, deactivate_provider,
     )
     from hermes_cli.config import get_env_value, save_env_value, load_config, save_config
 
@@ -2163,7 +2167,7 @@ def _model_flow_anthropic(config, current_model=""):
     import os
     from hermes_cli.auth import (
         PROVIDER_REGISTRY, _prompt_model_selection, _save_model_choice,
-        deactivate_provider,
+        _update_config_for_provider, deactivate_provider,
     )
     from hermes_cli.config import (
         get_env_value, save_env_value, load_config, save_config,

hermes_cli/mcp_config.py

@@ -14,14 +14,15 @@ import logging
 import os
 import re
 import time
-from typing import Any, Dict, List, Optional, Tuple
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 from hermes_cli.config import (
     load_config,
     save_config,
     get_env_value,
     save_env_value,
-    get_hermes_home,  # noqa: F401 — used by test mocks
+    get_hermes_home,
 )
 from hermes_cli.colors import Colors, color
 

hermes_cli/model_switch.py

@@ -13,7 +13,9 @@ concerns: state mutation, config persistence, output formatting.
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+import os
+from dataclasses import dataclass, field
+from typing import Optional
 
 
 @dataclass

hermes_cli/setup.py

@@ -283,6 +283,7 @@ from hermes_cli.config import (
     save_env_value,
     get_env_value,
     ensure_hermes_home,
+    DEFAULT_CONFIG,
 )
 
 from hermes_cli.colors import Colors, color
@@ -797,11 +798,15 @@ def setup_model_provider(config: dict):
     """Configure the inference provider and default model."""
     from hermes_cli.auth import (
         get_active_provider,
+        get_provider_auth_state,
         PROVIDER_REGISTRY,
+        format_auth_error,
+        AuthError,
         fetch_nous_models,
         resolve_nous_runtime_credentials,
         _update_config_for_provider,
         _login_openai_codex,
+        get_codex_auth_status,
         resolve_codex_runtime_credentials,
         DEFAULT_CODEX_BASE_URL,
         detect_external_credentials,
@@ -970,7 +975,7 @@ def setup_model_provider(config: dict):
         print()
 
         try:
-            from hermes_cli.auth import _login_nous
+            from hermes_cli.auth import _login_nous, ProviderConfig
             import argparse
 
             mock_args = argparse.Namespace(
@@ -3298,6 +3303,7 @@ def _run_quick_setup(config: dict, hermes_home):
         get_missing_env_vars,
         get_missing_config_fields,
         check_config_version,
+        migrate_config,
     )
 
     print()

hermes_cli/skills_config.py

@@ -11,7 +11,7 @@ Config stored in ~/.hermes/config.yaml under:
       telegram: [skill-c]
       cli: []
 """
-from typing import List, Optional, Set
+from typing import Dict, List, Optional, Set
 
 from hermes_cli.config import load_config, save_config
 from hermes_cli.colors import Colors, color

hermes_cli/skills_hub.py

@@ -186,7 +186,7 @@ def do_browse(page: int = 1, page_size: int = 20, source: str = "all",
     Official skills are always shown first, regardless of source filter.
     """
     from tools.skills_hub import (
-        GitHubAuth, create_source_router,
+        GitHubAuth, create_source_router, OptionalSkillSource, SkillMeta,
     )
 
     # Clamp page_size to safe range

hermes_cli/tools_config.py

@@ -13,9 +13,11 @@ import sys
 from pathlib import Path
 from typing import Dict, List, Optional, Set
 
+import os
 
 from hermes_cli.config import (
     load_config, save_config, get_env_value, save_env_value,
+    get_hermes_home,
 )
 from hermes_cli.colors import Colors, color
 
@@ -380,7 +382,7 @@ def _platform_toolset_summary(config: dict, platforms: Optional[List[str]] = Non
 
 def _get_platform_tools(config: dict, platform: str) -> Set[str]:
     """Resolve which individual toolset names are enabled for a platform."""
-    from toolsets import resolve_toolset
+    from toolsets import resolve_toolset, TOOLSETS
 
     platform_toolsets = config.get("platform_toolsets", {})
     toolset_names = platform_toolsets.get(platform)

hermes_cli/uninstall.py

@@ -7,9 +7,11 @@ Provides options for:
 """
 
 import os
+import sys
 import shutil
 import subprocess
 from pathlib import Path
+from typing import Optional
 
 from hermes_cli.colors import Colors, color
 

hermes_state.py

@@ -26,7 +26,7 @@ from typing import Dict, Any, List, Optional
 
 DEFAULT_DB_PATH = Path(os.getenv("HERMES_HOME", Path.home() / ".hermes")) / "state.db"
 
-SCHEMA_VERSION = 6
+SCHEMA_VERSION = 5
 
 SCHEMA_SQL = """
 CREATE TABLE IF NOT EXISTS schema_version (
@@ -73,10 +73,7 @@ CREATE TABLE IF NOT EXISTS messages (
     tool_name TEXT,
     timestamp REAL NOT NULL,
     token_count INTEGER,
-    finish_reason TEXT,
-    reasoning TEXT,
-    reasoning_details TEXT,
-    codex_reasoning_items TEXT
+    finish_reason TEXT
 );
 
 CREATE INDEX IF NOT EXISTS idx_sessions_source ON sessions(source);
@@ -192,25 +189,6 @@ class SessionDB:
                     except sqlite3.OperationalError:
                         pass
                 cursor.execute("UPDATE schema_version SET version = 5")
-            if current_version < 6:
-                # v6: add reasoning columns to messages table — preserves assistant
-                # reasoning text and structured reasoning_details across gateway
-                # session turns.  Without these, reasoning chains are lost on
-                # session reload, breaking multi-turn reasoning continuity for
-                # providers that replay reasoning (OpenRouter, OpenAI, Nous).
-                for col_name, col_type in [
-                    ("reasoning", "TEXT"),
-                    ("reasoning_details", "TEXT"),
-                    ("codex_reasoning_items", "TEXT"),
-                ]:
-                    try:
-                        safe = col_name.replace('"', '""')
-                        cursor.execute(
-                            f'ALTER TABLE messages ADD COLUMN "{safe}" {col_type}'
-                        )
-                    except sqlite3.OperationalError:
-                        pass  # Column already exists
-                cursor.execute("UPDATE schema_version SET version = 6")
 
         # Unique title index — always ensure it exists (safe to run after migrations
         # since the title column is guaranteed to exist at this point)
@@ -609,9 +587,6 @@ class SessionDB:
         tool_call_id: str = None,
         token_count: int = None,
         finish_reason: str = None,
-        reasoning: str = None,
-        reasoning_details: Any = None,
-        codex_reasoning_items: Any = None,
     ) -> int:
         """
         Append a message to a session. Returns the message row ID.
@@ -620,20 +595,10 @@ class SessionDB:
         if role is 'tool' or tool_calls is present).
         """
         with self._lock:
-            # Serialize structured fields to JSON for storage
-            reasoning_details_json = (
-                json.dumps(reasoning_details)
-                if reasoning_details else None
-            )
-            codex_items_json = (
-                json.dumps(codex_reasoning_items)
-                if codex_reasoning_items else None
-            )
             cursor = self._conn.execute(
                 """INSERT INTO messages (session_id, role, content, tool_call_id,
-                   tool_calls, tool_name, timestamp, token_count, finish_reason,
-                   reasoning, reasoning_details, codex_reasoning_items)
-                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                   tool_calls, tool_name, timestamp, token_count, finish_reason)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                 (
                     session_id,
                     role,
@@ -644,9 +609,6 @@ class SessionDB:
                     time.time(),
                     token_count,
                     finish_reason,
-                    reasoning,
-                    reasoning_details_json,
-                    codex_items_json,
                 ),
             )
             msg_id = cursor.lastrowid
@@ -698,8 +660,7 @@ class SessionDB:
         """
         with self._lock:
             cursor = self._conn.execute(
-                "SELECT role, content, tool_call_id, tool_calls, tool_name, "
-                "reasoning, reasoning_details, codex_reasoning_items "
+                "SELECT role, content, tool_call_id, tool_calls, tool_name "
                 "FROM messages WHERE session_id = ? ORDER BY timestamp, id",
                 (session_id,),
             )
@@ -716,22 +677,6 @@ class SessionDB:
                     msg["tool_calls"] = json.loads(row["tool_calls"])
                 except (json.JSONDecodeError, TypeError):
                     pass
-            # Restore reasoning fields on assistant messages so providers
-            # that replay reasoning (OpenRouter, OpenAI, Nous) receive
-            # coherent multi-turn reasoning context.
-            if row["role"] == "assistant":
-                if row["reasoning"]:
-                    msg["reasoning"] = row["reasoning"]
-                if row["reasoning_details"]:
-                    try:
-                        msg["reasoning_details"] = json.loads(row["reasoning_details"])
-                    except (json.JSONDecodeError, TypeError):
-                        pass
-                if row["codex_reasoning_items"]:
-                    try:
-                        msg["codex_reasoning_items"] = json.loads(row["codex_reasoning_items"])
-                    except (json.JSONDecodeError, TypeError):
-                        pass
             messages.append(msg)
         return messages
 

hermes_time.py

@@ -15,7 +15,7 @@ crashes due to a bad timezone string.
 
 import logging
 import os
-from datetime import datetime
+from datetime import datetime, timezone as _tz
 from pathlib import Path
 from typing import Optional
 

nix/checks.nix

@@ -12,31 +12,7 @@
       };
 
       configMergeScript = pkgs.callPackage ./configMergeScript.nix { };
-
-      # Auto-generated config key reference — always in sync with Python
-      configKeys = pkgs.runCommand "hermes-config-keys" {} ''
-        set -euo pipefail
-        export HOME=$TMPDIR
-        ${hermesVenv}/bin/python3 -c '
-import json, sys
-from hermes_cli.config import DEFAULT_CONFIG
-
-def leaf_paths(d, prefix=""):
-    paths = []
-    for k, v in sorted(d.items()):
-        path = f"{prefix}.{k}" if prefix else k
-        if isinstance(v, dict) and v:
-            paths.extend(leaf_paths(v, path))
-        else:
-            paths.append(path)
-    return paths
-
-json.dump(sorted(leaf_paths(DEFAULT_CONFIG)), sys.stdout, indent=2)
-' > $out
-      '';
     in {
-      packages.configKeys = configKeys;
-
       checks = lib.optionalAttrs pkgs.stdenv.hostPlatform.isLinux {
         # Verify binaries exist and are executable
         package-contents = pkgs.runCommand "hermes-package-contents" { } ''
@@ -125,6 +101,63 @@ json.dump(sorted(leaf_paths(DEFAULT_CONFIG)), sys.stdout, indent=2)
           echo "ok" > $out/result
         '';
 
+        # ── Config drift detection ────────────────────────────────────────
+        # Extracts leaf key paths from Python's DEFAULT_CONFIG and compares
+        # against the committed reference in nix/config-keys.json.
+        config-drift = pkgs.runCommand "hermes-config-drift" {
+          nativeBuildInputs = [ pkgs.jq ];
+          referenceKeys = ./config-keys.json;
+        } ''
+          set -e
+          export HOME=$(mktemp -d)
+
+          echo "=== Extracting DEFAULT_CONFIG leaf keys from Python ==="
+          ${hermesVenv}/bin/python3 -c '
+import json, sys
+from hermes_cli.config import DEFAULT_CONFIG
+
+def leaf_paths(d, prefix=""):
+    paths = []
+    for k, v in sorted(d.items()):
+        path = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict) and v:
+            paths.extend(leaf_paths(v, path))
+        else:
+            paths.append(path)
+    return paths
+
+json.dump(sorted(leaf_paths(DEFAULT_CONFIG)), sys.stdout)
+' > /tmp/actual-keys.json
+
+          echo "=== Comparing against reference ==="
+          jq -r '.[]' $referenceKeys | sort > /tmp/reference.txt
+          jq -r '.[]' /tmp/actual-keys.json | sort > /tmp/actual.txt
+
+          ADDED=$(comm -23 /tmp/actual.txt /tmp/reference.txt || true)
+          REMOVED=$(comm -13 /tmp/actual.txt /tmp/reference.txt || true)
+          FAILED=false
+
+          if [ -n "$ADDED" ]; then
+            echo "FAIL: New keys in DEFAULT_CONFIG not in nix/config-keys.json:"
+            echo "$ADDED" | sed 's/^/  + /'
+            FAILED=true
+          fi
+          if [ -n "$REMOVED" ]; then
+            echo "FAIL: Keys in nix/config-keys.json missing from DEFAULT_CONFIG:"
+            echo "$REMOVED" | sed 's/^/  - /'
+            FAILED=true
+          fi
+
+          if [ "$FAILED" = "true" ]; then
+            exit 1
+          fi
+
+          ACTUAL_COUNT=$(wc -l < /tmp/actual.txt)
+          echo "PASS: All $ACTUAL_COUNT config keys match reference"
+          mkdir -p $out
+          echo "ok" > $out/result
+        '';
+
         # ── Config merge + round-trip test ────────────────────────────────
         # Tests the merge script (Nix activation behavior) across 7
         # scenarios, then verifies Python's load_config() reads correctly.

nix/config-keys.json

@@ -0,0 +1,129 @@
+[
+  "_config_version",
+  "agent.max_turns",
+  "approvals.mode",
+  "auxiliary.approval.api_key",
+  "auxiliary.approval.base_url",
+  "auxiliary.approval.model",
+  "auxiliary.approval.provider",
+  "auxiliary.compression.api_key",
+  "auxiliary.compression.base_url",
+  "auxiliary.compression.model",
+  "auxiliary.compression.provider",
+  "auxiliary.flush_memories.api_key",
+  "auxiliary.flush_memories.base_url",
+  "auxiliary.flush_memories.model",
+  "auxiliary.flush_memories.provider",
+  "auxiliary.mcp.api_key",
+  "auxiliary.mcp.base_url",
+  "auxiliary.mcp.model",
+  "auxiliary.mcp.provider",
+  "auxiliary.session_search.api_key",
+  "auxiliary.session_search.base_url",
+  "auxiliary.session_search.model",
+  "auxiliary.session_search.provider",
+  "auxiliary.skills_hub.api_key",
+  "auxiliary.skills_hub.base_url",
+  "auxiliary.skills_hub.model",
+  "auxiliary.skills_hub.provider",
+  "auxiliary.vision.api_key",
+  "auxiliary.vision.base_url",
+  "auxiliary.vision.model",
+  "auxiliary.vision.provider",
+  "auxiliary.vision.timeout",
+  "auxiliary.web_extract.api_key",
+  "auxiliary.web_extract.base_url",
+  "auxiliary.web_extract.model",
+  "auxiliary.web_extract.provider",
+  "browser.command_timeout",
+  "browser.inactivity_timeout",
+  "browser.record_sessions",
+  "checkpoints.enabled",
+  "checkpoints.max_snapshots",
+  "command_allowlist",
+  "compression.enabled",
+  "compression.protect_last_n",
+  "compression.summary_base_url",
+  "compression.summary_model",
+  "compression.summary_provider",
+  "compression.target_ratio",
+  "compression.threshold",
+  "delegation.api_key",
+  "delegation.base_url",
+  "delegation.model",
+  "delegation.provider",
+  "discord.auto_thread",
+  "discord.free_response_channels",
+  "discord.require_mention",
+  "display.bell_on_complete",
+  "display.compact",
+  "display.personality",
+  "display.resume_display",
+  "display.show_cost",
+  "display.show_reasoning",
+  "display.skin",
+  "display.streaming",
+  "honcho",
+  "human_delay.max_ms",
+  "human_delay.min_ms",
+  "human_delay.mode",
+  "memory.memory_char_limit",
+  "memory.memory_enabled",
+  "memory.user_char_limit",
+  "memory.user_profile_enabled",
+  "model",
+  "personalities",
+  "prefill_messages_file",
+  "privacy.redact_pii",
+  "quick_commands",
+  "security.redact_secrets",
+  "security.tirith_enabled",
+  "security.tirith_fail_open",
+  "security.tirith_path",
+  "security.tirith_timeout",
+  "security.website_blocklist.domains",
+  "security.website_blocklist.enabled",
+  "security.website_blocklist.shared_files",
+  "smart_model_routing.cheap_model",
+  "smart_model_routing.enabled",
+  "smart_model_routing.max_simple_chars",
+  "smart_model_routing.max_simple_words",
+  "stt.enabled",
+  "stt.local.model",
+  "stt.openai.model",
+  "stt.provider",
+  "terminal.backend",
+  "terminal.container_cpu",
+  "terminal.container_disk",
+  "terminal.container_memory",
+  "terminal.container_persistent",
+  "terminal.cwd",
+  "terminal.daytona_image",
+  "terminal.docker_forward_env",
+  "terminal.docker_image",
+  "terminal.docker_mount_cwd_to_workspace",
+  "terminal.docker_volumes",
+  "terminal.env_passthrough",
+  "terminal.modal_image",
+  "terminal.persistent_shell",
+  "terminal.singularity_image",
+  "terminal.timeout",
+  "timezone",
+  "toolsets",
+  "tts.edge.voice",
+  "tts.elevenlabs.model_id",
+  "tts.elevenlabs.voice_id",
+  "tts.neutts.device",
+  "tts.neutts.model",
+  "tts.neutts.ref_audio",
+  "tts.neutts.ref_text",
+  "tts.openai.model",
+  "tts.openai.voice",
+  "tts.provider",
+  "voice.auto_tts",
+  "voice.max_recording_seconds",
+  "voice.record_key",
+  "voice.silence_duration",
+  "voice.silence_threshold",
+  "whatsapp"
+]

rl_cli.py

@@ -53,7 +53,8 @@ else:
 
 # Import agent and tools
 from run_agent import AIAgent
-from tools.rl_training_tool import get_missing_keys
+from model_tools import get_tool_definitions, check_toolset_requirements
+from tools.rl_training_tool import check_rl_api_keys, get_missing_keys
 
 
 # ============================================================================

run_agent.py

@@ -65,6 +65,7 @@ from tools.terminal_tool import cleanup_vm
 from tools.interrupt import set_interrupt as _set_interrupt
 from tools.browser_tool import cleanup_browser
 
+import requests
 
 from hermes_constants import OPENROUTER_BASE_URL
 
@@ -161,15 +162,11 @@ def _install_safe_stdio() -> None:
 
 
 class IterationBudget:
-    """Thread-safe iteration counter for an agent.
+    """Thread-safe shared iteration counter for parent and child agents.
 
-    Each agent (parent or subagent) gets its own ``IterationBudget``.
-    The parent's budget is capped at ``max_iterations`` (default 90).
-    Each subagent gets an independent budget capped at
-    ``delegation.max_iterations`` (default 50) — this means total
-    iterations across parent + subagents can exceed the parent's cap.
-    Users control the per-subagent limit via ``delegation.max_iterations``
-    in config.yaml.
+    Tracks total LLM-call iterations consumed across a parent agent and all
+    its subagents.  A single ``IterationBudget`` is created by the parent
+    and passed to every child so they share the same cap.
 
     ``execute_code`` (programmatic tool calling) iterations are refunded via
     :meth:`refund` so they don't eat into the budget.
@@ -890,8 +887,7 @@ class AIAgent:
                     user_id=None,
                 )
             except Exception as e:
-                logger.warning("Session DB create_session failed — messages will NOT be indexed: %s", e)
-                self._session_db = None  # prevent silent data loss on every subsequent flush
+                logger.debug("Session DB create_session failed: %s", e)
         
         # In-memory todo list for task planning (one per agent/session)
         from tools.todo_tool import TodoStore
@@ -1325,24 +1321,6 @@ class AIAgent:
                     summary = detail.get('summary') or detail.get('content') or detail.get('text')
                     if summary and summary not in reasoning_parts:
                         reasoning_parts.append(summary)
-
-        # Some providers embed reasoning directly inside assistant content
-        # instead of returning structured reasoning fields.  Only fall back
-        # to inline extraction when no structured reasoning was found.
-        content = getattr(assistant_message, "content", None)
-        if not reasoning_parts and isinstance(content, str) and content:
-            inline_patterns = (
-                r"<think>(.*?)</think>",
-                r"<thinking>(.*?)</thinking>",
-                r"<reasoning>(.*?)</reasoning>",
-                r"<REASONING_SCRATCHPAD>(.*?)</REASONING_SCRATCHPAD>",
-            )
-            for pattern in inline_patterns:
-                flags = re.DOTALL | re.IGNORECASE
-                for block in re.findall(pattern, content, flags=flags):
-                    cleaned = block.strip()
-                    if cleaned and cleaned not in reasoning_parts:
-                        reasoning_parts.append(cleaned)
         
         # Combine all reasoning parts
         if reasoning_parts:
@@ -1562,13 +1540,10 @@ class AIAgent:
                     tool_calls=tool_calls_data,
                     tool_call_id=msg.get("tool_call_id"),
                     finish_reason=msg.get("finish_reason"),
-                    reasoning=msg.get("reasoning") if role == "assistant" else None,
-                    reasoning_details=msg.get("reasoning_details") if role == "assistant" else None,
-                    codex_reasoning_items=msg.get("codex_reasoning_items") if role == "assistant" else None,
                 )
             self._last_flushed_db_idx = len(messages)
         except Exception as e:
-            logger.warning("Session DB append_message failed: %s", e)
+            logger.debug("Session DB append_message failed: %s", e)
 
     def _get_messages_up_to_last_assistant(self, messages: List[Dict]) -> List[Dict]:
         """
@@ -3610,20 +3585,7 @@ class AIAgent:
 
         def _call_chat_completions():
             """Stream a chat completions response."""
-            import httpx as _httpx
-            _base_timeout = float(os.getenv("HERMES_API_TIMEOUT", 900.0))
-            _stream_read_timeout = float(os.getenv("HERMES_STREAM_READ_TIMEOUT", 60.0))
-            stream_kwargs = {
-                **api_kwargs,
-                "stream": True,
-                "stream_options": {"include_usage": True},
-                "timeout": _httpx.Timeout(
-                    connect=30.0,
-                    read=_stream_read_timeout,
-                    write=_base_timeout,
-                    pool=30.0,
-                ),
-            }
+            stream_kwargs = {**api_kwargs, "stream": True, "stream_options": {"include_usage": True}}
             request_client_holder["client"] = self._create_request_openai_client(
                 reason="chat_completion_stream_request"
             )
@@ -3678,7 +3640,6 @@ class AIAgent:
                                 "id": tc_delta.id or "",
                                 "type": "function",
                                 "function": {"name": "", "arguments": ""},
-                                "extra_content": None,
                             }
                         entry = tool_calls_acc[idx]
                         if tc_delta.id:
@@ -3688,18 +3649,10 @@ class AIAgent:
                                 entry["function"]["name"] += tc_delta.function.name
                             if tc_delta.function.arguments:
                                 entry["function"]["arguments"] += tc_delta.function.arguments
-                        extra = getattr(tc_delta, "extra_content", None)
-                        if extra is None and hasattr(tc_delta, "model_extra"):
-                            extra = (tc_delta.model_extra or {}).get("extra_content")
-                        if extra is not None:
-                            if hasattr(extra, "model_dump"):
-                                extra = extra.model_dump()
-                            entry["extra_content"] = extra
                         # Fire once per tool when the full name is available
                         name = entry["function"]["name"]
                         if name and idx not in tool_gen_notified:
                             tool_gen_notified.add(idx)
-                            _fire_first_delta()
                             self._fire_tool_gen_started(name)
 
                 if chunk.choices[0].finish_reason:
@@ -3719,7 +3672,6 @@ class AIAgent:
                     mock_tool_calls.append(SimpleNamespace(
                         id=tc["id"],
                         type=tc["type"],
-                        extra_content=tc.get("extra_content"),
                         function=SimpleNamespace(
                             name=tc["function"]["name"],
                             arguments=tc["function"]["arguments"],
@@ -3769,7 +3721,6 @@ class AIAgent:
                             has_tool_use = True
                             tool_name = getattr(block, "name", None)
                             if tool_name:
-                                _fire_first_delta()
                                 self._fire_tool_gen_started(tool_name)
 
                     elif event_type == "content_block_delta":
@@ -3791,86 +3742,29 @@ class AIAgent:
                 return stream.get_final_message()
 
         def _call():
-            import httpx as _httpx
-
-            _max_stream_retries = int(os.getenv("HERMES_STREAM_RETRIES", 2))
-
             try:
-                for _stream_attempt in range(_max_stream_retries + 1):
+                if self.api_mode == "anthropic_messages":
+                    self._try_refresh_anthropic_client_credentials()
+                    result["response"] = _call_anthropic()
+                else:
+                    result["response"] = _call_chat_completions()
+            except Exception as e:
+                if deltas_were_sent["yes"]:
+                    # Streaming failed AFTER some tokens were already delivered
+                    # to consumers. Don't fall back — that would cause
+                    # double-delivery (partial streamed + full non-streamed).
+                    # Let the error propagate; the partial content already
+                    # reached the user via the stream.
+                    logger.warning("Streaming failed after partial delivery, not falling back: %s", e)
+                    result["error"] = e
+                else:
+                    # Streaming failed before any tokens reached consumers.
+                    # Safe to fall back to the standard non-streaming path.
+                    logger.info("Streaming failed before delivery, falling back to non-streaming: %s", e)
                     try:
-                        if self.api_mode == "anthropic_messages":
-                            self._try_refresh_anthropic_client_credentials()
-                            result["response"] = _call_anthropic()
-                        else:
-                            result["response"] = _call_chat_completions()
-                        return  # success
-                    except Exception as e:
-                        if deltas_were_sent["yes"]:
-                            # Streaming failed AFTER some tokens were already
-                            # delivered.  Don't retry or fall back — partial
-                            # content already reached the user.
-                            logger.warning(
-                                "Streaming failed after partial delivery, not retrying: %s", e
-                            )
-                            result["error"] = e
-                            return
-
-                        _is_timeout = isinstance(
-                            e, (_httpx.ReadTimeout, _httpx.ConnectTimeout, _httpx.PoolTimeout)
-                        )
-                        _is_conn_err = isinstance(
-                            e, (_httpx.ConnectError, _httpx.RemoteProtocolError, ConnectionError)
-                        )
-
-                        if _is_timeout or _is_conn_err:
-                            # Transient network / timeout error. Retry the
-                            # streaming request with a fresh connection first.
-                            if _stream_attempt < _max_stream_retries:
-                                logger.info(
-                                    "Streaming attempt %s/%s failed (%s: %s), "
-                                    "retrying with fresh connection...",
-                                    _stream_attempt + 1,
-                                    _max_stream_retries + 1,
-                                    type(e).__name__,
-                                    e,
-                                )
-                                # Close the stale request client before retry
-                                stale = request_client_holder.get("client")
-                                if stale is not None:
-                                    self._close_request_openai_client(
-                                        stale, reason="stream_retry_cleanup"
-                                    )
-                                    request_client_holder["client"] = None
-                                continue
-                            logger.warning(
-                                "Streaming exhausted %s retries on transient error, "
-                                "falling back to non-streaming: %s",
-                                _max_stream_retries + 1,
-                                e,
-                            )
-                        else:
-                            _err_lower = str(e).lower()
-                            _is_stream_unsupported = (
-                                "stream" in _err_lower
-                                and "not supported" in _err_lower
-                            )
-                            if _is_stream_unsupported:
-                                self._safe_print(
-                                    "\n⚠  Streaming is not supported for this "
-                                    "model/provider. Falling back to non-streaming.\n"
-                                    "   To avoid this delay, set display.streaming: false "
-                                    "in config.yaml\n"
-                                )
-                            logger.info(
-                                "Streaming failed before delivery, falling back to non-streaming: %s",
-                                e,
-                            )
-
-                        try:
-                            result["response"] = self._interruptible_api_call(api_kwargs)
-                        except Exception as fallback_err:
-                            result["error"] = fallback_err
-                        return
+                        result["response"] = self._interruptible_api_call(api_kwargs)
+                    except Exception as fallback_err:
+                        result["error"] = fallback_err
             finally:
                 request_client = request_client_holder.get("client")
                 if request_client is not None:
@@ -4720,7 +4614,7 @@ class AIAgent:
                 # Reset flush cursor — new session starts with no messages written
                 self._last_flushed_db_idx = 0
             except Exception as e:
-                logger.warning("Session DB compression split failed — new session will NOT be indexed: %s", e)
+                logger.debug("Session DB compression split failed: %s", e)
 
         # Reset context pressure warning and token estimate — usage drops
         # after compaction.  Without this, the stale last_prompt_tokens from
@@ -4922,9 +4816,9 @@ class AIAgent:
             is_error, _ = _detect_tool_failure(function_name, result)
             results[index] = (function_name, function_args, result, duration, is_error)
 
-        # Start spinner for CLI mode (skip when TUI handles tool progress)
+        # Start spinner for CLI mode
         spinner = None
-        if self.quiet_mode and not self.tool_progress_callback:
+        if self.quiet_mode:
             face = random.choice(KawaiiSpinner.KAWAII_WAITING)
             spinner = KawaiiSpinner(f"{face} ⚡ running {num_tools} tools concurrently", spinner_type='dots')
             spinner.start()
@@ -5150,7 +5044,7 @@ class AIAgent:
                     goal_preview = (function_args.get("goal") or "")[:30]
                     spinner_label = f"🔀 {goal_preview}" if goal_preview else "🔀 delegating"
                 spinner = None
-                if self.quiet_mode and not self.tool_progress_callback:
+                if self.quiet_mode:
                     face = random.choice(KawaiiSpinner.KAWAII_WAITING)
                     spinner = KawaiiSpinner(f"{face} {spinner_label}", spinner_type='dots')
                     spinner.start()
@@ -5175,15 +5069,13 @@ class AIAgent:
                     elif self.quiet_mode:
                         self._vprint(f"  {cute_msg}")
             elif self.quiet_mode:
-                spinner = None
-                if not self.tool_progress_callback:
-                    face = random.choice(KawaiiSpinner.KAWAII_WAITING)
-                    emoji = _get_tool_emoji(function_name)
-                    preview = _build_tool_preview(function_name, function_args) or function_name
-                    if len(preview) > 30:
-                        preview = preview[:27] + "..."
-                    spinner = KawaiiSpinner(f"{face} {emoji} {preview}", spinner_type='dots')
-                    spinner.start()
+                face = random.choice(KawaiiSpinner.KAWAII_WAITING)
+                emoji = _get_tool_emoji(function_name)
+                preview = _build_tool_preview(function_name, function_args) or function_name
+                if len(preview) > 30:
+                    preview = preview[:27] + "..."
+                spinner = KawaiiSpinner(f"{face} {emoji} {preview}", spinner_type='dots')
+                spinner.start()
                 _spinner_result = None
                 try:
                     function_result = handle_function_call(
@@ -5199,10 +5091,7 @@ class AIAgent:
                 finally:
                     tool_duration = time.time() - tool_start_time
                     cute_msg = _get_cute_tool_message_impl(function_name, function_args, tool_duration, result=_spinner_result)
-                    if spinner:
-                        spinner.stop(cute_msg)
-                    else:
-                        self._vprint(f"  {cute_msg}")
+                    spinner.stop(cute_msg)
             else:
                 try:
                     function_result = handle_function_call(
@@ -5742,7 +5631,7 @@ class AIAgent:
             api_call_count += 1
             if not self.iteration_budget.consume():
                 if not self.quiet_mode:
-                    self._safe_print(f"\n⚠️  Iteration budget exhausted ({self.iteration_budget.used}/{self.iteration_budget.max_total} iterations used)")
+                    self._safe_print(f"\n⚠️  Session iteration budget exhausted ({self.iteration_budget.max_total} total across agent + subagents)")
                 break
 
             # Fire step_callback for gateway hooks (agent:step event)
@@ -6411,7 +6300,6 @@ class AIAgent:
                         'exceeds the limit', 'context window',
                         'request entity too large',  # OpenRouter/Nous 413 safety net
                         'prompt is too long',  # Anthropic: "prompt is too long: N tokens > M maximum"
-                        'prompt exceeds max length',  # Z.AI / GLM: generic 400 overflow wording
                     ])
 
                     # Fallback heuristic: Anthropic sometimes returns a generic
@@ -7202,7 +7090,7 @@ class AIAgent:
             or self.iteration_budget.remaining <= 0
         ):
             if self.iteration_budget.remaining <= 0 and not self.quiet_mode:
-                print(f"\n⚠️  Iteration budget exhausted ({self.iteration_budget.used}/{self.iteration_budget.max_total} iterations used)")
+                print(f"\n⚠️  Session iteration budget exhausted ({self.iteration_budget.used}/{self.iteration_budget.max_total} used, including subagents)")
             final_response = self._handle_max_iterations(messages, api_call_count)
         
         # Determine if conversation completed successfully

scripts/whatsapp-bridge/bridge.js

@@ -43,8 +43,6 @@ const WHATSAPP_DEBUG =
 const PORT = parseInt(getArg('port', '3000'), 10);
 const SESSION_DIR = getArg('session', path.join(process.env.HOME || '~', '.hermes', 'whatsapp', 'session'));
 const IMAGE_CACHE_DIR = path.join(process.env.HOME || '~', '.hermes', 'image_cache');
-const DOCUMENT_CACHE_DIR = path.join(process.env.HOME || '~', '.hermes', 'document_cache');
-const AUDIO_CACHE_DIR = path.join(process.env.HOME || '~', '.hermes', 'audio_cache');
 const PAIR_ONLY = args.includes('--pair-only');
 const WHATSAPP_MODE = getArg('mode', process.env.WHATSAPP_MODE || 'self-chat'); // "bot" or "self-chat"
 const ALLOWED_USERS = (process.env.WHATSAPP_ALLOWED_USERS || '').split(',').map(s => s.trim()).filter(Boolean);
@@ -226,47 +224,13 @@ async function startSocket() {
         body = msg.message.videoMessage.caption || '';
         hasMedia = true;
         mediaType = 'video';
-        try {
-          const buf = await downloadMediaMessage(msg, 'buffer', {}, { logger, reuploadRequest: sock.updateMediaMessage });
-          const mime = msg.message.videoMessage.mimetype || 'video/mp4';
-          const ext = mime.includes('mp4') ? '.mp4' : '.mkv';
-          mkdirSync(DOCUMENT_CACHE_DIR, { recursive: true });
-          const filePath = path.join(DOCUMENT_CACHE_DIR, `vid_${randomBytes(6).toString('hex')}${ext}`);
-          writeFileSync(filePath, buf);
-          mediaUrls.push(filePath);
-        } catch (err) {
-          console.error('[bridge] Failed to download video:', err.message);
-        }
       } else if (msg.message.audioMessage || msg.message.pttMessage) {
         hasMedia = true;
         mediaType = msg.message.pttMessage ? 'ptt' : 'audio';
-        try {
-          const audioMsg = msg.message.pttMessage || msg.message.audioMessage;
-          const buf = await downloadMediaMessage(msg, 'buffer', {}, { logger, reuploadRequest: sock.updateMediaMessage });
-          const mime = audioMsg.mimetype || 'audio/ogg';
-          const ext = mime.includes('ogg') ? '.ogg' : mime.includes('mp4') ? '.m4a' : '.ogg';
-          mkdirSync(AUDIO_CACHE_DIR, { recursive: true });
-          const filePath = path.join(AUDIO_CACHE_DIR, `aud_${randomBytes(6).toString('hex')}${ext}`);
-          writeFileSync(filePath, buf);
-          mediaUrls.push(filePath);
-        } catch (err) {
-          console.error('[bridge] Failed to download audio:', err.message);
-        }
       } else if (msg.message.documentMessage) {
-        body = msg.message.documentMessage.caption || '';
+        body = msg.message.documentMessage.caption || msg.message.documentMessage.fileName || '';
         hasMedia = true;
         mediaType = 'document';
-        const fileName = msg.message.documentMessage.fileName || 'document';
-        try {
-          const buf = await downloadMediaMessage(msg, 'buffer', {}, { logger, reuploadRequest: sock.updateMediaMessage });
-          mkdirSync(DOCUMENT_CACHE_DIR, { recursive: true });
-          const safeFileName = path.basename(fileName).replace(/[^a-zA-Z0-9._-]/g, '_');
-          const filePath = path.join(DOCUMENT_CACHE_DIR, `doc_${randomBytes(6).toString('hex')}_${safeFileName}`);
-          writeFileSync(filePath, buf);
-          mediaUrls.push(filePath);
-        } catch (err) {
-          console.error('[bridge] Failed to download document:', err.message);
-        }
       }
 
       // For media without caption, use a placeholder so the API message is never empty

tests/cron/test_scheduler.py

@@ -254,10 +254,6 @@ class TestRunJobSessionPersistence:
         assert kwargs["session_db"] is fake_db
         assert kwargs["platform"] == "cron"
         assert kwargs["session_id"].startswith("cron_test-job_")
-        fake_db.end_session.assert_called_once()
-        call_args = fake_db.end_session.call_args
-        assert call_args[0][0].startswith("cron_test-job_")
-        assert call_args[0][1] == "cron_complete"
         fake_db.close.assert_called_once()
 
     def test_run_job_empty_response_returns_empty_not_placeholder(self, tmp_path):

tests/gateway/test_api_server.py

@@ -355,54 +355,6 @@ class TestChatCompletionsEndpoint:
                 assert "[DONE]" in body
                 assert "Hello!" in body
 
-    @pytest.mark.asyncio
-    async def test_stream_survives_tool_call_none_sentinel(self, adapter):
-        """stream_delta_callback(None) mid-stream (tool calls) must NOT kill the SSE stream.
-
-        The agent fires stream_delta_callback(None) to tell the CLI display to
-        close its response box before executing tool calls.  The API server's
-        _on_delta must filter this out so the SSE response stays open and the
-        final answer (streamed after tool execution) reaches the client.
-        """
-        import asyncio
-
-        app = _create_app(adapter)
-        async with TestClient(TestServer(app)) as cli:
-            async def _mock_run_agent(**kwargs):
-                cb = kwargs.get("stream_delta_callback")
-                if cb:
-                    # Simulate: agent streams partial text, then fires None
-                    # (tool call box-close signal), then streams the final answer
-                    cb("Thinking")
-                    cb(None)          # mid-stream None from tool calls
-                    await asyncio.sleep(0.05)  # simulate tool execution delay
-                    cb(" about it...")
-                    cb(None)          # another None (possible second tool round)
-                    await asyncio.sleep(0.05)
-                    cb(" The answer is 42.")
-                return (
-                    {"final_response": "Thinking about it... The answer is 42.", "messages": [], "api_calls": 3},
-                    {"input_tokens": 20, "output_tokens": 15, "total_tokens": 35},
-                )
-
-            with patch.object(adapter, "_run_agent", side_effect=_mock_run_agent):
-                resp = await cli.post(
-                    "/v1/chat/completions",
-                    json={
-                        "model": "test",
-                        "messages": [{"role": "user", "content": "What is the answer?"}],
-                        "stream": True,
-                    },
-                )
-                assert resp.status == 200
-                body = await resp.text()
-                assert "[DONE]" in body
-                # The final answer text must appear in the SSE stream
-                assert "The answer is 42." in body
-                # All partial text must be present too
-                assert "Thinking" in body
-                assert " about it..." in body
-
     @pytest.mark.asyncio
     async def test_no_user_message_returns_400(self, adapter):
         app = _create_app(adapter)

tests/test_cli_background_tui_refresh.py

@@ -1,105 +0,0 @@
-"""Tests for CLI background command TUI refresh behavior.
-
-Ensures the TUI is properly refreshed before printing background task output
-to prevent spinner/status bar overlap (#2718).
-"""
-
-import threading
-from types import SimpleNamespace
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from cli import HermesCLI
-
-
-def _make_cli():
-    """Create a minimal HermesCLI instance for testing."""
-    cli_obj = HermesCLI.__new__(HermesCLI)
-    cli_obj.model = "test-model"
-    cli_obj._background_tasks = {}
-    cli_obj._background_task_counter = 0
-    cli_obj.conversation_history = []
-    cli_obj.agent = None
-    cli_obj._app = None
-    return cli_obj
-
-
-class TestBackgroundCommandTuiRefresh:
-    """Tests for TUI refresh in background command output."""
-
-    def test_invalidate_called_before_success_output(self):
-        """App.invalidate() is called before printing background success output."""
-        cli_obj = _make_cli()
-        mock_app = MagicMock()
-        cli_obj._app = mock_app
-
-        # Track call order
-        call_order = []
-        original_invalidate = mock_app.invalidate
-
-        def track_invalidate():
-            call_order.append("invalidate")
-            return original_invalidate()
-
-        mock_app.invalidate = track_invalidate
-
-        # Patch print to track when it's called
-        with patch("builtins.print") as mock_print:
-            mock_print.side_effect = lambda *args, **kwargs: call_order.append("print")
-
-            # Simulate the background task output code path
-            if cli_obj._app:
-                cli_obj._app.invalidate()
-                import time
-                time.sleep(0.01)  # reduced for test
-            print()
-
-        # Verify invalidate was called before print
-        assert call_order[0] == "invalidate"
-        assert "print" in call_order
-
-    def test_invalidate_called_before_error_output(self):
-        """App.invalidate() is called before printing background error output."""
-        cli_obj = _make_cli()
-        mock_app = MagicMock()
-        cli_obj._app = mock_app
-
-        call_order = []
-        mock_app.invalidate.side_effect = lambda: call_order.append("invalidate")
-
-        with patch("builtins.print") as mock_print:
-            mock_print.side_effect = lambda *args, **kwargs: call_order.append("print")
-
-            # Simulate error path
-            if cli_obj._app:
-                cli_obj._app.invalidate()
-                import time
-                time.sleep(0.01)
-            print()
-
-        assert call_order[0] == "invalidate"
-        assert "print" in call_order
-
-    def test_no_crash_when_app_is_none(self):
-        """No crash when _app is None (non-TUI mode)."""
-        cli_obj = _make_cli()
-        cli_obj._app = None
-
-        # This should not raise
-        if cli_obj._app:
-            cli_obj._app.invalidate()
-        # If we get here without exception, test passes
-
-    def test_background_task_thread_safety(self):
-        """Background task tracking is thread-safe."""
-        cli_obj = _make_cli()
-
-        # Simulate adding and removing background tasks
-        task_id = "test_task_1"
-        cli_obj._background_tasks[task_id] = MagicMock()
-        assert task_id in cli_obj._background_tasks
-
-        # Clean up
-        cli_obj._background_tasks.pop(task_id, None)
-        assert task_id not in cli_obj._background_tasks

tests/test_hermes_state.py

@@ -177,91 +177,6 @@ class TestMessageStorage:
         messages = db.get_messages("s1")
         assert messages[0]["finish_reason"] == "stop"
 
-    def test_reasoning_persisted_and_restored(self, db):
-        """Reasoning text is stored for assistant messages and restored by
-        get_messages_as_conversation() so providers receive coherent multi-turn
-        reasoning context."""
-        db.create_session(session_id="s1", source="telegram")
-        db.append_message("s1", role="user", content="create a cron job")
-        db.append_message(
-            "s1",
-            role="assistant",
-            content=None,
-            tool_calls=[{"function": {"name": "cronjob", "arguments": "{}"}, "id": "c1", "type": "function"}],
-            reasoning="I should call the cronjob tool to schedule this.",
-        )
-        db.append_message("s1", role="tool", content='{"job_id": "abc"}', tool_call_id="c1")
-
-        conv = db.get_messages_as_conversation("s1")
-        assert len(conv) == 3
-        # reasoning must be present on the assistant message
-        assistant = conv[1]
-        assert assistant["role"] == "assistant"
-        assert assistant.get("reasoning") == "I should call the cronjob tool to schedule this."
-        # user and tool messages must NOT carry reasoning
-        assert "reasoning" not in conv[0]
-        assert "reasoning" not in conv[2]
-
-    def test_reasoning_details_persisted_and_restored(self, db):
-        """reasoning_details (structured array) is round-tripped through JSON
-        serialization in the DB."""
-        db.create_session(session_id="s1", source="telegram")
-        details = [
-            {"type": "reasoning.summary", "summary": "Thinking about tools"},
-            {"type": "reasoning.encrypted_content", "encrypted_content": "abc123"},
-        ]
-        db.append_message(
-            "s1",
-            role="assistant",
-            content="Hello",
-            reasoning="Thinking about what to say",
-            reasoning_details=details,
-        )
-
-        conv = db.get_messages_as_conversation("s1")
-        assert len(conv) == 1
-        msg = conv[0]
-        assert msg["reasoning"] == "Thinking about what to say"
-        assert msg["reasoning_details"] == details
-
-    def test_reasoning_not_set_for_non_assistant(self, db):
-        """reasoning is never leaked onto user or tool messages."""
-        db.create_session(session_id="s1", source="telegram")
-        db.append_message("s1", role="user", content="hi")
-        db.append_message("s1", role="assistant", content="hello", reasoning=None)
-
-        conv = db.get_messages_as_conversation("s1")
-        assert "reasoning" not in conv[0]
-        assert "reasoning" not in conv[1]
-
-    def test_reasoning_empty_string_not_restored(self, db):
-        """Empty string reasoning is treated as absent."""
-        db.create_session(session_id="s1", source="cli")
-        db.append_message("s1", role="assistant", content="hi", reasoning="")
-
-        conv = db.get_messages_as_conversation("s1")
-        assert "reasoning" not in conv[0]
-
-    def test_codex_reasoning_items_persisted_and_restored(self, db):
-        """codex_reasoning_items (encrypted blobs for Codex Responses API) are
-        round-tripped through JSON serialization in the DB."""
-        db.create_session(session_id="s1", source="cli")
-        codex_items = [
-            {"type": "reasoning", "id": "rs_abc", "encrypted_content": "enc_blob_123"},
-            {"type": "reasoning", "id": "rs_def", "encrypted_content": "enc_blob_456"},
-        ]
-        db.append_message(
-            "s1",
-            role="assistant",
-            content="Done",
-            codex_reasoning_items=codex_items,
-        )
-
-        conv = db.get_messages_as_conversation("s1")
-        assert len(conv) == 1
-        assert conv[0]["codex_reasoning_items"] == codex_items
-        assert conv[0]["codex_reasoning_items"][0]["encrypted_content"] == "enc_blob_123"
-
 
 # =========================================================================
 # FTS5 search
@@ -822,7 +737,7 @@ class TestSchemaInit:
     def test_schema_version(self, db):
         cursor = db._conn.execute("SELECT version FROM schema_version")
         version = cursor.fetchone()[0]
-        assert version == 6
+        assert version == 5
 
     def test_title_column_exists(self, db):
         """Verify the title column was created in the sessions table."""
@@ -878,12 +793,12 @@ class TestSchemaInit:
         conn.commit()
         conn.close()
 
-        # Open with SessionDB — should migrate to v6
+        # Open with SessionDB — should migrate to v5
         migrated_db = SessionDB(db_path=db_path)
 
         # Verify migration
         cursor = migrated_db._conn.execute("SELECT version FROM schema_version")
-        assert cursor.fetchone()[0] == 6
+        assert cursor.fetchone()[0] == 5
 
         # Verify title column exists and is NULL for existing sessions
         session = migrated_db.get_session("existing")

tests/test_reasoning_command.py

@@ -11,7 +11,6 @@ Combines functionality from:
 import unittest
 from types import SimpleNamespace
 from unittest.mock import MagicMock, patch
-import re
 
 
 # ---------------------------------------------------------------------------
@@ -296,108 +295,6 @@ class TestReasoningCallback(unittest.TestCase):
         # No exception = pass
 
 
-class TestReasoningPreviewBuffering(unittest.TestCase):
-    def _make_cli(self):
-        from cli import HermesCLI
-
-        cli = HermesCLI.__new__(HermesCLI)
-        cli.verbose = True
-        cli._spinner_text = ""
-        cli._reasoning_preview_buf = ""
-        cli._invalidate = lambda *args, **kwargs: None
-        return cli
-
-    @patch("cli._cprint")
-    def test_streamed_reasoning_chunks_wait_for_boundary(self, mock_cprint):
-        cli = self._make_cli()
-
-        cli._on_reasoning("Let")
-        cli._on_reasoning(" me")
-        cli._on_reasoning(" think")
-
-        self.assertEqual(mock_cprint.call_count, 0)
-
-        cli._on_reasoning(" about this.\n")
-
-        self.assertEqual(mock_cprint.call_count, 1)
-        rendered = mock_cprint.call_args[0][0]
-        self.assertIn("[thinking] Let me think about this.", rendered)
-
-    @patch("cli._cprint")
-    def test_pending_reasoning_flushes_when_thinking_stops(self, mock_cprint):
-        cli = self._make_cli()
-
-        cli._on_reasoning("see")
-        cli._on_reasoning(" how")
-        cli._on_reasoning(" this")
-        cli._on_reasoning(" plays")
-        cli._on_reasoning(" out")
-
-        self.assertEqual(mock_cprint.call_count, 0)
-
-        cli._on_thinking("")
-
-        self.assertEqual(mock_cprint.call_count, 1)
-        rendered = mock_cprint.call_args[0][0]
-        self.assertIn("[thinking] see how this plays out", rendered)
-
-    @patch("cli._cprint")
-    @patch("cli.shutil.get_terminal_size", return_value=SimpleNamespace(columns=50))
-    def test_reasoning_preview_compacts_newlines_and_wraps_to_terminal(self, _mock_term, mock_cprint):
-        cli = self._make_cli()
-
-        cli._emit_reasoning_preview(
-            "First line\nstill same thought\n\n\nSecond paragraph with more detail here."
-        )
-
-        rendered = mock_cprint.call_args[0][0]
-        plain = re.sub(r"\x1b\[[0-9;]*m", "", rendered)
-        normalized = " ".join(plain.split())
-        self.assertIn("[thinking] First line still same thought", plain)
-        self.assertIn("Second paragraph with more detail here.", normalized)
-        self.assertNotIn("\n\n\n", plain)
-
-    @patch("cli.shutil.get_terminal_size", return_value=SimpleNamespace(columns=60))
-    def test_reasoning_flush_threshold_tracks_terminal_width(self, _mock_term):
-        cli = self._make_cli()
-
-        cli._reasoning_preview_buf = "a" * 30
-        cli._flush_reasoning_preview(force=False)
-        self.assertEqual(cli._reasoning_preview_buf, "a" * 30)
-
-
-class TestReasoningDisplayModeSelection(unittest.TestCase):
-    def _make_cli(self, *, show_reasoning=False, streaming_enabled=False, verbose=False):
-        from cli import HermesCLI
-
-        cli = HermesCLI.__new__(HermesCLI)
-        cli.show_reasoning = show_reasoning
-        cli.streaming_enabled = streaming_enabled
-        cli.verbose = verbose
-        cli._stream_reasoning_delta = lambda text: ("stream", text)
-        cli._on_reasoning = lambda text: ("preview", text)
-        return cli
-
-    def test_show_reasoning_non_streaming_uses_final_box_only(self):
-        cli = self._make_cli(show_reasoning=True, streaming_enabled=False, verbose=False)
-
-        self.assertIsNone(cli._current_reasoning_callback())
-
-    def test_show_reasoning_streaming_uses_live_reasoning_box(self):
-        cli = self._make_cli(show_reasoning=True, streaming_enabled=True, verbose=False)
-
-        callback = cli._current_reasoning_callback()
-        self.assertIsNotNone(callback)
-        self.assertEqual(callback("x"), ("stream", "x"))
-
-    def test_verbose_without_show_reasoning_uses_preview_callback(self):
-        cli = self._make_cli(show_reasoning=False, streaming_enabled=False, verbose=True)
-
-        callback = cli._current_reasoning_callback()
-        self.assertIsNotNone(callback)
-        self.assertEqual(callback("x"), ("preview", "x"))
-
-
 # ---------------------------------------------------------------------------
 # Real provider format extraction
 # ---------------------------------------------------------------------------

tests/test_run_agent.py

@@ -267,21 +267,6 @@ class TestExtractReasoning:
         result = agent._extract_reasoning(msg)
         assert result == "same text"
 
-    @pytest.mark.parametrize(
-        ("content", "expected"),
-        [
-            ("<think>thinking hard</think>", "thinking hard"),
-            ("<thinking>step by step</thinking>", "step by step"),
-            (
-                "<REASONING_SCRATCHPAD>scratch analysis</REASONING_SCRATCHPAD>",
-                "scratch analysis",
-            ),
-        ],
-    )
-    def test_inline_reasoning_blocks_fallback(self, agent, content, expected):
-        msg = _mock_assistant_msg(content=content)
-        assert agent._extract_reasoning(msg) == expected
-
 
 class TestCleanSessionContent:
     def test_none_passthrough(self):
@@ -1217,8 +1202,8 @@ class TestRunConversation:
         assert result["completed"] is True
         assert result["api_calls"] == 2
 
-    def test_empty_content_retry_uses_inline_reasoning_as_response(self, agent):
-        """Reasoning-only payloads should recover the inline reasoning text."""
+    def test_empty_content_retry_and_fallback(self, agent):
+        """Empty content (only think block) retries, then falls back to partial."""
         self._setup_agent(agent)
         empty_resp = _mock_response(
             content="<think>internal reasoning</think>",
@@ -1236,8 +1221,9 @@ class TestRunConversation:
             patch.object(agent, "_cleanup_task_resources"),
         ):
             result = agent.run_conversation("answer me")
-        assert result["completed"] is True
-        assert result["final_response"] == "internal reasoning"
+        # After 3 retries with no real content, should return partial
+        assert result["completed"] is False
+        assert result.get("partial") is True
 
     def test_nous_401_refreshes_after_remint_and_retries(self, agent):
         self._setup_agent(agent)
@@ -1310,36 +1296,6 @@ class TestRunConversation:
         assert result["final_response"] == "All done"
         assert result["completed"] is True
 
-    def test_glm_prompt_exceeds_max_length_triggers_compression(self, agent):
-        """GLM/Z.AI uses 'Prompt exceeds max length' for context overflow."""
-        self._setup_agent(agent)
-        err_400 = Exception(
-            "Error code: 400 - {'error': {'code': '1261', 'message': 'Prompt exceeds max length'}}"
-        )
-        err_400.status_code = 400
-        ok_resp = _mock_response(content="Recovered after compression", finish_reason="stop")
-        agent.client.chat.completions.create.side_effect = [err_400, ok_resp]
-        prefill = [
-            {"role": "user", "content": "previous question"},
-            {"role": "assistant", "content": "previous answer"},
-        ]
-
-        with (
-            patch.object(agent, "_compress_context") as mock_compress,
-            patch.object(agent, "_persist_session"),
-            patch.object(agent, "_save_trajectory"),
-            patch.object(agent, "_cleanup_task_resources"),
-        ):
-            mock_compress.return_value = (
-                [{"role": "user", "content": "hello"}],
-                "compressed system prompt",
-            )
-            result = agent.run_conversation("hello", conversation_history=prefill)
-
-        mock_compress.assert_called_once()
-        assert result["final_response"] == "Recovered after compression"
-        assert result["completed"] is True
-
     @pytest.mark.parametrize(
         ("first_content", "second_content", "expected_final"),
         [

tests/test_streaming.py

@@ -39,15 +39,10 @@ def _make_stream_chunk(
     return chunk
 
 
-def _make_tool_call_delta(index=0, tc_id=None, name=None, arguments=None, extra_content=None, model_extra=None):
+def _make_tool_call_delta(index=0, tc_id=None, name=None, arguments=None):
     """Build a mock tool call delta."""
     func = SimpleNamespace(name=name, arguments=arguments)
-    delta = SimpleNamespace(index=index, id=tc_id, function=func)
-    if extra_content is not None:
-        delta.extra_content = extra_content
-    if model_extra is not None:
-        delta.model_extra = model_extra
-    return delta
+    return SimpleNamespace(index=index, id=tc_id, function=func)
 
 
 def _make_empty_chunk(model=None, usage=None):
@@ -137,52 +132,6 @@ class TestStreamingAccumulator:
         assert tc[0].function.name == "terminal"
         assert tc[0].function.arguments == '{"command": "ls"}'
 
-    @patch("run_agent.AIAgent._create_request_openai_client")
-    @patch("run_agent.AIAgent._close_request_openai_client")
-    def test_tool_call_extra_content_preserved(self, mock_close, mock_create):
-        """Streamed tool calls preserve provider-specific extra_content metadata."""
-        from run_agent import AIAgent
-
-        chunks = [
-            _make_stream_chunk(tool_calls=[
-                _make_tool_call_delta(
-                    index=0,
-                    tc_id="call_gemini",
-                    name="cronjob",
-                    model_extra={
-                        "extra_content": {
-                            "google": {"thought_signature": "sig-123"}
-                        }
-                    },
-                )
-            ]),
-            _make_stream_chunk(tool_calls=[
-                _make_tool_call_delta(index=0, arguments='{"task": "deep index on ."}')
-            ]),
-            _make_stream_chunk(finish_reason="tool_calls"),
-        ]
-
-        mock_client = MagicMock()
-        mock_client.chat.completions.create.return_value = iter(chunks)
-        mock_create.return_value = mock_client
-
-        agent = AIAgent(
-            model="test/model",
-            quiet_mode=True,
-            skip_context_files=True,
-            skip_memory=True,
-        )
-        agent.api_mode = "chat_completions"
-        agent._interrupt_requested = False
-
-        response = agent._interruptible_streaming_api_call({})
-
-        tc = response.choices[0].message.tool_calls
-        assert tc is not None
-        assert tc[0].extra_content == {
-            "google": {"thought_signature": "sig-123"}
-        }
-
     @patch("run_agent.AIAgent._create_request_openai_client")
     @patch("run_agent.AIAgent._close_request_openai_client")
     def test_mixed_content_and_tool_calls(self, mock_close, mock_create):
@@ -487,51 +436,6 @@ class TestStreamingFallback:
         with pytest.raises(Exception, match="Rate limit exceeded"):
             agent._interruptible_streaming_api_call({})
 
-    @patch("run_agent.AIAgent._interruptible_api_call")
-    @patch("run_agent.AIAgent._create_request_openai_client")
-    @patch("run_agent.AIAgent._close_request_openai_client")
-    def test_exhausted_transient_stream_error_falls_back(self, mock_close, mock_create, mock_non_stream):
-        """Transient stream errors retry first, then fall back after retries are exhausted."""
-        from run_agent import AIAgent
-        import httpx
-
-        mock_client = MagicMock()
-        mock_client.chat.completions.create.side_effect = httpx.ConnectError("socket closed")
-        mock_create.return_value = mock_client
-
-        fallback_response = SimpleNamespace(
-            id="fallback",
-            model="test",
-            choices=[SimpleNamespace(
-                index=0,
-                message=SimpleNamespace(
-                    role="assistant",
-                    content="fallback after retries exhausted",
-                    tool_calls=None,
-                    reasoning_content=None,
-                ),
-                finish_reason="stop",
-            )],
-            usage=None,
-        )
-        mock_non_stream.return_value = fallback_response
-
-        agent = AIAgent(
-            model="test/model",
-            quiet_mode=True,
-            skip_context_files=True,
-            skip_memory=True,
-        )
-        agent.api_mode = "chat_completions"
-        agent._interrupt_requested = False
-
-        response = agent._interruptible_streaming_api_call({})
-
-        assert response.choices[0].message.content == "fallback after retries exhausted"
-        assert mock_client.chat.completions.create.call_count == 3
-        mock_non_stream.assert_called_once()
-        assert mock_close.call_count >= 1
-
 
 # ── Test: Reasoning Streaming ────────────────────────────────────────────
 

tests/tools/test_skills_hub.py

@@ -4,8 +4,6 @@ import json
 from pathlib import Path
 from unittest.mock import patch, MagicMock
 
-import httpx
-
 from tools.skills_hub import (
     GitHubAuth,
     GitHubSource,
@@ -307,154 +305,6 @@ class TestSkillsShSource:
         assert bundle.files["SKILL.md"] == "# react"
         assert mock_get.called
 
-    @patch("tools.skills_hub._write_index_cache")
-    @patch("tools.skills_hub._read_index_cache", return_value=None)
-    @patch("tools.skills_hub.httpx.get")
-    @patch.object(GitHubSource, "fetch")
-    def test_fetch_falls_back_to_tree_search_for_deeply_nested_skills(
-        self, mock_fetch, mock_get, _mock_read_cache, _mock_write_cache,
-    ):
-        """Skills in deeply nested dirs (e.g. cli-tool/components/skills/dev/my-skill/)
-        are found via the GitHub Trees API when candidate paths and shallow scan fail."""
-        tree_entries = [
-            {"path": "README.md", "type": "blob"},
-            {"path": "cli-tool/components/skills/development/my-skill/SKILL.md", "type": "blob"},
-            {"path": "cli-tool/components/skills/development/other-skill/SKILL.md", "type": "blob"},
-        ]
-
-        def _httpx_get_side_effect(url, **kwargs):
-            resp = MagicMock()
-            if "/api/search" in url:
-                resp.status_code = 404
-                return resp
-            if url.endswith("/contents/"):
-                # Root listing for shallow scan — return empty so it falls through
-                resp.status_code = 200
-                resp.json = lambda: []
-                return resp
-            if "/contents/" in url:
-                # All contents API calls fail (candidate paths miss)
-                resp.status_code = 404
-                return resp
-            if url.endswith("owner/repo"):
-                # Repo info → default branch
-                resp.status_code = 200
-                resp.json = lambda: {"default_branch": "main"}
-                return resp
-            if "/git/trees/main" in url:
-                resp.status_code = 200
-                resp.json = lambda: {"tree": tree_entries}
-                return resp
-            # skills.sh detail page
-            resp.status_code = 200
-            resp.text = "<h1>my-skill</h1>"
-            return resp
-
-        mock_get.side_effect = _httpx_get_side_effect
-
-        resolved_bundle = SkillBundle(
-            name="my-skill",
-            files={"SKILL.md": "# My Skill"},
-            source="github",
-            identifier="owner/repo/cli-tool/components/skills/development/my-skill",
-            trust_level="community",
-        )
-        mock_fetch.side_effect = lambda ident: resolved_bundle if "cli-tool/components" in ident else None
-
-        bundle = self._source().fetch("skills-sh/owner/repo/my-skill")
-
-        assert bundle is not None
-        assert bundle.source == "skills.sh"
-        assert bundle.files["SKILL.md"] == "# My Skill"
-        # Verify the tree-resolved identifier was used for the final GitHub fetch
-        mock_fetch.assert_any_call("owner/repo/cli-tool/components/skills/development/my-skill")
-
-
-class TestFindSkillInRepoTree:
-    """Tests for GitHubSource._find_skill_in_repo_tree."""
-
-    def _source(self):
-        auth = MagicMock(spec=GitHubAuth)
-        auth.get_headers.return_value = {"Accept": "application/vnd.github.v3+json"}
-        return GitHubSource(auth=auth)
-
-    @patch("tools.skills_hub.httpx.get")
-    def test_finds_deeply_nested_skill(self, mock_get):
-        tree_entries = [
-            {"path": "README.md", "type": "blob"},
-            {"path": "cli-tool/components/skills/development/senior-backend/SKILL.md", "type": "blob"},
-            {"path": "cli-tool/components/skills/development/other/SKILL.md", "type": "blob"},
-        ]
-
-        def _side_effect(url, **kwargs):
-            resp = MagicMock()
-            if url.endswith("/davila7/claude-code-templates"):
-                resp.status_code = 200
-                resp.json = lambda: {"default_branch": "main"}
-            elif "/git/trees/main" in url:
-                resp.status_code = 200
-                resp.json = lambda: {"tree": tree_entries}
-            else:
-                resp.status_code = 404
-            return resp
-
-        mock_get.side_effect = _side_effect
-
-        result = self._source()._find_skill_in_repo_tree("davila7/claude-code-templates", "senior-backend")
-        assert result == "davila7/claude-code-templates/cli-tool/components/skills/development/senior-backend"
-
-    @patch("tools.skills_hub.httpx.get")
-    def test_finds_root_level_skill(self, mock_get):
-        tree_entries = [
-            {"path": "my-skill/SKILL.md", "type": "blob"},
-        ]
-
-        def _side_effect(url, **kwargs):
-            resp = MagicMock()
-            if "/contents" not in url and "/git/" not in url:
-                resp.status_code = 200
-                resp.json = lambda: {"default_branch": "main"}
-            elif "/git/trees/main" in url:
-                resp.status_code = 200
-                resp.json = lambda: {"tree": tree_entries}
-            else:
-                resp.status_code = 404
-            return resp
-
-        mock_get.side_effect = _side_effect
-
-        result = self._source()._find_skill_in_repo_tree("owner/repo", "my-skill")
-        assert result == "owner/repo/my-skill"
-
-    @patch("tools.skills_hub.httpx.get")
-    def test_returns_none_when_skill_not_found(self, mock_get):
-        tree_entries = [
-            {"path": "other-skill/SKILL.md", "type": "blob"},
-        ]
-
-        def _side_effect(url, **kwargs):
-            resp = MagicMock()
-            if "/contents" not in url and "/git/" not in url:
-                resp.status_code = 200
-                resp.json = lambda: {"default_branch": "main"}
-            elif "/git/trees/main" in url:
-                resp.status_code = 200
-                resp.json = lambda: {"tree": tree_entries}
-            else:
-                resp.status_code = 404
-            return resp
-
-        mock_get.side_effect = _side_effect
-
-        result = self._source()._find_skill_in_repo_tree("owner/repo", "nonexistent")
-        assert result is None
-
-    @patch("tools.skills_hub.httpx.get")
-    def test_returns_none_when_repo_api_fails(self, mock_get):
-        mock_get.return_value = MagicMock(status_code=404)
-        result = self._source()._find_skill_in_repo_tree("owner/repo", "my-skill")
-        assert result is None
-
 
 class TestWellKnownSkillSource:
     def _source(self):
@@ -1041,151 +891,3 @@ class TestQuarantineBundleBinaryAssets:
 
         assert (q_path / "SKILL.md").read_text(encoding="utf-8").startswith("---")
         assert (q_path / "assets" / "neutts-cli" / "samples" / "jo.wav").read_bytes() == b"RIFF\x00\x01fakewav"
-
-
-# ---------------------------------------------------------------------------
-# GitHubSource._download_directory — tree API + fallback (#2940)
-# ---------------------------------------------------------------------------
-
-
-class TestDownloadDirectoryViaTree:
-    """Tests for the Git Trees API path in _download_directory."""
-
-    def _source(self):
-        auth = MagicMock(spec=GitHubAuth)
-        auth.get_headers.return_value = {}
-        return GitHubSource(auth=auth)
-
-    @patch.object(GitHubSource, "_fetch_file_content")
-    @patch("tools.skills_hub.httpx.get")
-    def test_tree_api_downloads_subdirectories(self, mock_get, mock_fetch):
-        """Tree API returns files from nested subdirectories."""
-        repo_resp = MagicMock(status_code=200, json=lambda: {"default_branch": "main"})
-        tree_resp = MagicMock(status_code=200, json=lambda: {
-            "truncated": False,
-            "tree": [
-                {"type": "blob", "path": "skills/my-skill/SKILL.md"},
-                {"type": "blob", "path": "skills/my-skill/scripts/run.py"},
-                {"type": "blob", "path": "skills/my-skill/references/api.md"},
-                {"type": "tree", "path": "skills/my-skill/scripts"},
-                {"type": "blob", "path": "other/file.txt"},
-            ],
-        })
-        mock_get.side_effect = [repo_resp, tree_resp]
-        mock_fetch.side_effect = lambda repo, path: f"content-of-{path}"
-
-        src = self._source()
-        files = src._download_directory("owner/repo", "skills/my-skill")
-
-        assert "SKILL.md" in files
-        assert "scripts/run.py" in files
-        assert "references/api.md" in files
-        assert "other/file.txt" not in files  # outside target path
-        assert len(files) == 3
-
-    @patch.object(GitHubSource, "_download_directory_recursive", return_value={"SKILL.md": "# ok"})
-    @patch("tools.skills_hub.httpx.get")
-    def test_falls_back_on_truncated_tree(self, mock_get, mock_fallback):
-        """When tree is truncated, fall back to recursive Contents API."""
-        repo_resp = MagicMock(status_code=200, json=lambda: {"default_branch": "main"})
-        tree_resp = MagicMock(status_code=200, json=lambda: {"truncated": True, "tree": []})
-        mock_get.side_effect = [repo_resp, tree_resp]
-
-        src = self._source()
-        files = src._download_directory("owner/repo", "skills/my-skill")
-
-        assert files == {"SKILL.md": "# ok"}
-        mock_fallback.assert_called_once_with("owner/repo", "skills/my-skill")
-
-    @patch.object(GitHubSource, "_download_directory_recursive", return_value={"SKILL.md": "# ok"})
-    @patch("tools.skills_hub.httpx.get")
-    def test_falls_back_on_repo_api_failure(self, mock_get, mock_fallback):
-        """When the repo endpoint returns non-200, fall back to Contents API."""
-        mock_get.return_value = MagicMock(status_code=404)
-
-        src = self._source()
-        files = src._download_directory("owner/repo", "skills/my-skill")
-
-        assert files == {"SKILL.md": "# ok"}
-        mock_fallback.assert_called_once()
-
-    @patch.object(GitHubSource, "_fetch_file_content")
-    @patch("tools.skills_hub.httpx.get")
-    def test_tree_api_skips_failed_file_fetches(self, mock_get, mock_fetch):
-        """Files that fail to fetch are skipped, not fatal."""
-        repo_resp = MagicMock(status_code=200, json=lambda: {"default_branch": "main"})
-        tree_resp = MagicMock(status_code=200, json=lambda: {
-            "truncated": False,
-            "tree": [
-                {"type": "blob", "path": "skills/my-skill/SKILL.md"},
-                {"type": "blob", "path": "skills/my-skill/scripts/run.py"},
-            ],
-        })
-        mock_get.side_effect = [repo_resp, tree_resp]
-        mock_fetch.side_effect = lambda repo, path: (
-            "# Skill" if path.endswith("SKILL.md") else None
-        )
-
-        src = self._source()
-        files = src._download_directory("owner/repo", "skills/my-skill")
-
-        assert "SKILL.md" in files
-        assert "scripts/run.py" not in files
-
-    @patch.object(GitHubSource, "_download_directory_recursive", return_value={})
-    @patch("tools.skills_hub.httpx.get")
-    def test_falls_back_on_network_error(self, mock_get, mock_fallback):
-        """Network errors in tree API trigger fallback."""
-        mock_get.side_effect = httpx.ConnectError("connection refused")
-
-        src = self._source()
-        src._download_directory("owner/repo", "skills/my-skill")
-
-        mock_fallback.assert_called_once()
-
-
-class TestDownloadDirectoryRecursive:
-    """Tests for the Contents API fallback path."""
-
-    def _source(self):
-        auth = MagicMock(spec=GitHubAuth)
-        auth.get_headers.return_value = {}
-        return GitHubSource(auth=auth)
-
-    @patch.object(GitHubSource, "_fetch_file_content")
-    @patch("tools.skills_hub.httpx.get")
-    def test_recursive_downloads_subdirectories(self, mock_get, mock_fetch):
-        """Contents API recursion includes subdirectories."""
-        root_resp = MagicMock(status_code=200, json=lambda: [
-            {"name": "SKILL.md", "type": "file", "path": "skill/SKILL.md"},
-            {"name": "scripts", "type": "dir", "path": "skill/scripts"},
-        ])
-        sub_resp = MagicMock(status_code=200, json=lambda: [
-            {"name": "run.py", "type": "file", "path": "skill/scripts/run.py"},
-        ])
-        mock_get.side_effect = [root_resp, sub_resp]
-        mock_fetch.side_effect = lambda repo, path: f"content-of-{path}"
-
-        src = self._source()
-        files = src._download_directory_recursive("owner/repo", "skill")
-
-        assert "SKILL.md" in files
-        assert "scripts/run.py" in files
-
-    @patch.object(GitHubSource, "_fetch_file_content")
-    @patch("tools.skills_hub.httpx.get")
-    def test_recursive_handles_subdir_failure(self, mock_get, mock_fetch):
-        """Subdirectory 403/rate-limit returns empty but doesn't crash."""
-        root_resp = MagicMock(status_code=200, json=lambda: [
-            {"name": "SKILL.md", "type": "file", "path": "skill/SKILL.md"},
-            {"name": "scripts", "type": "dir", "path": "skill/scripts"},
-        ])
-        sub_resp = MagicMock(status_code=403)
-        mock_get.side_effect = [root_resp, sub_resp]
-        mock_fetch.return_value = "content"
-
-        src = self._source()
-        files = src._download_directory_recursive("owner/repo", "skill")
-
-        assert "SKILL.md" in files
-        assert "scripts/run.py" not in files  # lost due to rate limit

tests/tools/test_website_policy.py

@@ -292,8 +292,6 @@ def test_check_website_access_blocks_scheme_less_urls(tmp_path):
 def test_browser_navigate_returns_policy_block(monkeypatch):
     from tools import browser_tool
 
-    # Allow SSRF check to pass so the policy check is reached
-    monkeypatch.setattr(browser_tool, "_is_safe_url", lambda url: True)
     monkeypatch.setattr(
         browser_tool,
         "check_website_access",

tools/browser_tool.py

@@ -70,11 +70,6 @@ try:
     from tools.website_policy import check_website_access
 except Exception:
     check_website_access = lambda url: None  # noqa: E731 — fail-open if policy module unavailable
-
-try:
-    from tools.url_safety import is_safe_url as _is_safe_url
-except Exception:
-    _is_safe_url = lambda url: False  # noqa: E731 — fail-closed: block all if safety module unavailable
 from tools.browser_providers.base import CloudBrowserProvider
 from tools.browser_providers.browserbase import BrowserbaseProvider
 from tools.browser_providers.browser_use import BrowserUseProvider
@@ -1030,13 +1025,6 @@ def browser_navigate(url: str, task_id: Optional[str] = None) -> str:
     Returns:
         JSON string with navigation result (includes stealth features info on first nav)
     """
-    # SSRF protection — block private/internal addresses before navigating
-    if not _is_safe_url(url):
-        return json.dumps({
-            "success": False,
-            "error": "Blocked: URL targets a private or internal address",
-        })
-
     # Website policy check — block before navigating
     blocked = check_website_access(url)
     if blocked:
@@ -1064,18 +1052,7 @@ def browser_navigate(url: str, task_id: Optional[str] = None) -> str:
         data = result.get("data", {})
         title = data.get("title", "")
         final_url = data.get("url", url)
-
-        # Post-redirect SSRF check — if the browser followed a redirect to a
-        # private/internal address, block the result so the model can't read
-        # internal content via subsequent browser_snapshot calls.
-        if final_url and final_url != url and not _is_safe_url(final_url):
-            # Navigate away to a blank page to prevent snapshot leaks
-            _run_browser_command(effective_task_id, "open", ["about:blank"], timeout=10)
-            return json.dumps({
-                "success": False,
-                "error": f"Blocked: redirect landed on a private/internal address",
-            })
-
+        
         response = {
             "success": True,
             "url": final_url,

tools/checkpoint_manager.py

@@ -23,6 +23,7 @@ import logging
 import os
 import shutil
 import subprocess
+import time
 from pathlib import Path
 from typing import Dict, List, Optional, Set
 

tools/clarify_tool.py

@@ -12,7 +12,7 @@ a thin dispatcher that delegates to a platform-provided callback.
 """
 
 import json
-from typing import List, Optional, Callable
+from typing import Dict, Any, List, Optional, Callable
 
 
 # Maximum number of predefined choices the agent can offer.

tools/delegate_tool.py

@@ -171,6 +171,7 @@ def _build_child_agent(
     model on OpenRouter while the parent runs on Nous Portal).
     """
     from run_agent import AIAgent
+    import model_tools
 
     # When no explicit toolsets given, inherit from parent's enabled toolsets
     # so disabled tools (e.g. web) don't leak to subagents.
@@ -190,10 +191,9 @@ def _build_child_agent(
     # Build progress callback to relay tool calls to parent display
     child_progress_cb = _build_child_progress_callback(task_index, parent_agent)
 
-    # Each subagent gets its own iteration budget capped at max_iterations
-    # (configurable via delegation.max_iterations, default 50).  This means
-    # total iterations across parent + subagents can exceed the parent's
-    # max_iterations.  The user controls the per-subagent cap in config.yaml.
+    # Share the parent's iteration budget so subagent tool calls
+    # count toward the session-wide limit.
+    shared_budget = getattr(parent_agent, "iteration_budget", None)
 
     # Resolve effective credentials: config override > parent inherit
     effective_model = model or parent_agent.model
@@ -230,7 +230,7 @@ def _build_child_agent(
         providers_order=parent_agent.providers_order,
         provider_sort=parent_agent.provider_sort,
         tool_progress_callback=child_progress_cb,
-        iteration_budget=None,  # fresh budget per subagent
+        iteration_budget=shared_budget,
     )
     # Set delegation depth so children can't spawn grandchildren
     child._delegate_depth = getattr(parent_agent, '_delegate_depth', 0) + 1

tools/environments/persistent_shell.py

@@ -40,8 +40,7 @@ class PersistentShellMixin:
     def _cleanup_temp_files(self): ...
 
     _session_id: str = ""
-    _poll_interval_start: float = 0.01  # initial poll interval (10ms)
-    _poll_interval_max: float = 0.25    # max poll interval (250ms) — reduces I/O for long commands
+    _poll_interval: float = 0.01
 
     @property
     def _temp_prefix(self) -> str:
@@ -225,7 +224,7 @@ class PersistentShellMixin:
         )
         self._send_to_shell(ipc_script)
         deadline = time.monotonic() + timeout
-        poll_interval = self._poll_interval_start  # starts at 10ms, backs off to 250ms
+        poll_interval = self._poll_interval
 
         while True:
             if is_interrupted():
@@ -257,10 +256,6 @@ class PersistentShellMixin:
                 break
 
             time.sleep(poll_interval)
-            # Exponential backoff: fast start (10ms) for quick commands,
-            # ramps up to 250ms for long-running commands — reduces I/O by 10-25x
-            # on WSL2 where polling keeps the VM hot and memory pressure high.
-            poll_interval = min(poll_interval * 1.5, self._poll_interval_max)
 
         output, exit_code, new_cwd = self._read_persistent_output()
         if new_cwd:

tools/environments/ssh.py

@@ -87,7 +87,7 @@ class SSHEnvironment(PersistentShellMixin, BaseEnvironment):
         except subprocess.TimeoutExpired:
             raise RuntimeError(f"SSH connection to {self.user}@{self.host} timed out")
 
-    _poll_interval_start: float = 0.15  # SSH: higher initial interval (150ms) for network latency
+    _poll_interval: float = 0.15
 
     @property
     def _temp_prefix(self) -> str:

tools/file_operations.py

@@ -27,10 +27,11 @@ Usage:
 
 import os
 import re
+import json
 import difflib
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import Optional, List, Dict, Any
+from typing import Optional, List, Dict, Any, Tuple
 from pathlib import Path
 
 

tools/file_tools.py

@@ -4,7 +4,9 @@
 import errno
 import json
 import logging
+import os
 import threading
+from typing import Optional
 from tools.file_operations import ShellFileOperations
 from agent.redact import redact_sensitive_text
 
@@ -48,8 +50,8 @@ def _get_file_ops(task_id: str = "default") -> ShellFileOperations:
     from tools.terminal_tool import (
         _active_environments, _env_lock, _create_environment,
         _get_env_config, _last_activity, _start_cleanup_thread,
-        _creation_locks,
-        _creation_locks_lock,
+        _check_disk_usage_warning,
+        _creation_locks, _creation_locks_lock,
     )
     import time
 

tools/image_generation_tool.py

@@ -416,7 +416,7 @@ def check_image_generation_requirements() -> bool:
             return False
         
         # Check if fal_client is available
-        import fal_client  # noqa: F401 — SDK presence check
+        import fal_client
         return True
         
     except ImportError:

tools/process_registry.py

@@ -34,6 +34,7 @@ import logging
 import os
 import platform
 import shlex
+import shutil
 import signal
 import subprocess
 import threading
@@ -43,6 +44,7 @@ import uuid
 _IS_WINDOWS = platform.system() == "Windows"
 from tools.environments.local import _find_shell, _sanitize_subprocess_env
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from hermes_cli.config import get_hermes_home

tools/registry.py

@@ -16,7 +16,7 @@ Import chain (circular-import safe):
 
 import json
 import logging
-from typing import Callable, Dict, List, Optional, Set
+from typing import Any, Callable, Dict, List, Optional, Set
 
 logger = logging.getLogger(__name__)
 

tools/rl_training_tool.py

@@ -40,7 +40,7 @@ import uuid
 import logging
 from datetime import datetime
 import yaml
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 

tools/send_message_tool.py

@@ -379,7 +379,7 @@ async def _send_telegram(token, chat_id, message, media_files=None, thread_id=No
         else:
             # Reuse the gateway adapter's format_message for markdown→MarkdownV2
             try:
-                from gateway.platforms.telegram import TelegramAdapter, _strip_mdv2
+                from gateway.platforms.telegram import TelegramAdapter, _escape_mdv2, _strip_mdv2
                 _adapter = TelegramAdapter.__new__(TelegramAdapter)
                 formatted = _adapter.format_message(message)
             except Exception:

tools/session_search_tool.py

@@ -18,6 +18,7 @@ Flow:
 import asyncio
 import concurrent.futures
 import json
+import os
 import logging
 from typing import Dict, Any, List, Optional, Union
 

tools/skills_hub.py

@@ -32,7 +32,7 @@ import httpx
 import yaml
 
 from tools.skills_guard import (
-    ScanResult, content_hash, TRUSTED_REPOS,
+    ScanResult, scan_skill, should_allow_install, content_hash, TRUSTED_REPOS,
 )
 
 logger = logging.getLogger(__name__)
@@ -404,75 +404,11 @@ class GitHubSource(SkillSource):
         return skills
 
     def _download_directory(self, repo: str, path: str) -> Dict[str, str]:
-        """Recursively download all text files from a GitHub directory.
-
-        Uses the Git Trees API first (single call for the entire tree) to
-        avoid per-directory rate limiting that causes silent subdirectory
-        loss.  Falls back to the recursive Contents API when the tree
-        endpoint is unavailable or the response is truncated.
-        """
-        files = self._download_directory_via_tree(repo, path)
-        if files is not None:
-            return files
-        logger.debug("Tree API unavailable for %s/%s, falling back to Contents API", repo, path)
-        return self._download_directory_recursive(repo, path)
-
-    def _download_directory_via_tree(self, repo: str, path: str) -> Optional[Dict[str, str]]:
-        """Download an entire directory using the Git Trees API (single request)."""
-        path = path.rstrip("/")
-        headers = self.auth.get_headers()
-
-        # Resolve the default branch via the repo endpoint
-        try:
-            repo_url = f"https://api.github.com/repos/{repo}"
-            resp = httpx.get(repo_url, headers=headers, timeout=15, follow_redirects=True)
-            if resp.status_code != 200:
-                return None
-            default_branch = resp.json().get("default_branch", "main")
-        except (httpx.HTTPError, ValueError):
-            return None
-
-        # Fetch the full recursive tree (branch name works as tree-ish)
-        try:
-            tree_url = f"https://api.github.com/repos/{repo}/git/trees/{default_branch}"
-            resp = httpx.get(
-                tree_url, params={"recursive": "1"},
-                headers=headers, timeout=30, follow_redirects=True,
-            )
-            if resp.status_code != 200:
-                return None
-            tree_data = resp.json()
-            if tree_data.get("truncated"):
-                logger.debug("Git tree truncated for %s, falling back to Contents API", repo)
-                return None
-        except (httpx.HTTPError, ValueError):
-            return None
-
-        # Filter to blobs under our target path and fetch content
-        prefix = f"{path}/"
-        files: Dict[str, str] = {}
-        for item in tree_data.get("tree", []):
-            if item.get("type") != "blob":
-                continue
-            item_path = item.get("path", "")
-            if not item_path.startswith(prefix):
-                continue
-            rel_path = item_path[len(prefix):]
-            content = self._fetch_file_content(repo, item_path)
-            if content is not None:
-                files[rel_path] = content
-            else:
-                logger.debug("Skipped file (fetch failed): %s/%s", repo, item_path)
-
-        return files if files else None
-
-    def _download_directory_recursive(self, repo: str, path: str) -> Dict[str, str]:
-        """Recursively download via Contents API (fallback)."""
+        """Recursively download all text files from a GitHub directory."""
         url = f"https://api.github.com/repos/{repo}/contents/{path.rstrip('/')}"
         try:
             resp = httpx.get(url, headers=self.auth.get_headers(), timeout=15, follow_redirects=True)
             if resp.status_code != 200:
-                logger.debug("Contents API returned %d for %s/%s", resp.status_code, repo, path)
                 return {}
         except httpx.HTTPError:
             return {}
@@ -492,64 +428,12 @@ class GitHubSource(SkillSource):
                     rel_path = name
                     files[rel_path] = content
             elif entry_type == "dir":
-                sub_files = self._download_directory_recursive(repo, entry.get("path", ""))
-                if not sub_files:
-                    logger.debug("Empty or failed subdirectory: %s/%s", repo, entry.get("path", ""))
+                sub_files = self._download_directory(repo, entry.get("path", ""))
                 for sub_name, sub_content in sub_files.items():
                     files[f"{name}/{sub_name}"] = sub_content
 
         return files
 
-    def _find_skill_in_repo_tree(self, repo: str, skill_name: str) -> Optional[str]:
-        """Use the GitHub Trees API to find a skill directory anywhere in the repo.
-
-        Returns the full identifier (``repo/path/to/skill``) or ``None``.
-        This is a single API call regardless of repo depth, so it efficiently
-        handles deeply nested directory structures like
-        ``cli-tool/components/skills/development/<skill>/SKILL.md``.
-        """
-        # Get default branch
-        try:
-            resp = httpx.get(
-                f"https://api.github.com/repos/{repo}",
-                headers=self.auth.get_headers(),
-                timeout=15,
-                follow_redirects=True,
-            )
-            if resp.status_code != 200:
-                return None
-            default_branch = resp.json().get("default_branch", "main")
-        except (httpx.HTTPError, json.JSONDecodeError):
-            return None
-
-        # Get recursive tree (single API call for the entire repo)
-        try:
-            resp = httpx.get(
-                f"https://api.github.com/repos/{repo}/git/trees/{default_branch}",
-                params={"recursive": "1"},
-                headers=self.auth.get_headers(),
-                timeout=30,
-                follow_redirects=True,
-            )
-            if resp.status_code != 200:
-                return None
-            tree_data = resp.json()
-        except (httpx.HTTPError, json.JSONDecodeError):
-            return None
-
-        # Look for SKILL.md files inside directories named <skill_name>
-        skill_md_suffix = f"/{skill_name}/SKILL.md"
-        for entry in tree_data.get("tree", []):
-            if entry.get("type") != "blob":
-                continue
-            path = entry.get("path", "")
-            if path.endswith(skill_md_suffix) or path == f"{skill_name}/SKILL.md":
-                # Strip /SKILL.md to get the skill directory path
-                skill_dir = path[: -len("/SKILL.md")]
-                return f"{repo}/{skill_dir}"
-
-        return None
-
     def _fetch_file_content(self, repo: str, path: str) -> Optional[str]:
         """Fetch a single file's content from GitHub."""
         url = f"https://api.github.com/repos/{repo}/contents/{path}"
@@ -1130,14 +1014,6 @@ class SkillsShSource(SkillSource):
         except Exception:
             pass
 
-        # Final fallback: use the GitHub Trees API to find the skill anywhere
-        # in the repo tree.  This handles deeply nested structures like
-        # cli-tool/components/skills/development/<skill>/ that the shallow
-        # scan above can't reach.
-        tree_result = self.github._find_skill_in_repo_tree(repo, skill_token)
-        if tree_result:
-            return tree_result
-
         return None
 
     def _finalize_inspect_meta(self, meta: SkillMeta, canonical: str, detail: Optional[dict]) -> SkillMeta:

tools/terminal_tool.py

@@ -31,6 +31,7 @@ import json
 import logging
 import os
 import platform
+import sys
 import time
 import threading
 import atexit
@@ -47,7 +48,7 @@ logger = logging.getLogger(__name__)
 # The terminal tool polls this during command execution so it can kill
 # long-running subprocesses immediately instead of blocking until timeout.
 # ---------------------------------------------------------------------------
-from tools.interrupt import is_interrupted, _interrupt_event  # noqa: F401 — re-exported
+from tools.interrupt import is_interrupted, _interrupt_event
 
 
 # =============================================================================
@@ -1231,7 +1232,7 @@ def check_terminal_requirements() -> bool:
             return True
 
         elif env_type == "daytona":
-            from daytona import Daytona  # noqa: F401 — SDK presence check
+            from daytona import Daytona
             return os.getenv("DAYTONA_API_KEY") is not None
 
         else:

tools/tts_tool.py

@@ -629,6 +629,7 @@ def stream_tts_to_speaker(
             if client is not None:
                 try:
                     sd = _import_sounddevice()
+                    import numpy as _np
                     output_stream = sd.OutputStream(
                         samplerate=24000, channels=1, dtype="int16",
                     )

tools/vision_tools.py

@@ -28,6 +28,7 @@ Usage:
     )
 """
 
+import asyncio
 import base64
 import json
 import logging

tools/voice_mode.py

@@ -19,6 +19,7 @@ import tempfile
 import threading
 import time
 import wave
+from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 logger = logging.getLogger(__name__)
@@ -709,7 +710,7 @@ def check_voice_requirements() -> Dict[str, Any]:
         ``missing_packages``, and ``details``.
     """
     # Determine STT provider availability
-    from tools.transcription_tools import _get_provider, _load_stt_config, is_stt_enabled
+    from tools.transcription_tools import _get_provider, _load_stt_config, is_stt_enabled, _HAS_FASTER_WHISPER
     stt_config = _load_stt_config()
     stt_enabled = is_stt_enabled(stt_config)
     stt_provider = _get_provider(stt_config)

website/docs/getting-started/nix-setup.md

@@ -196,7 +196,7 @@ Both are deep-merged at evaluation time. Nix-declared keys always win over keys
 :::
 
 :::tip Discovering available config keys
-Run `nix build .#configKeys && cat result` to see every leaf config key extracted from Python's `DEFAULT_CONFIG`. You can paste your existing `config.yaml` into the `settings` attrset — the structure maps 1:1.
+The full set of config keys is defined in [`nix/config-keys.json`](https://github.com/NousResearch/hermes-agent/blob/main/nix/config-keys.json) (127 leaf keys). You can paste your existing `config.yaml` into the `settings` attrset — the structure maps 1:1. The build-time `config-drift` check catches any drift between the reference and the Python source.
 :::
 
 <details>
@@ -607,6 +607,7 @@ nix build .#checks.x86_64-linux.entry-points-sync  # pyproject.toml ↔ Nix pack
 nix build .#checks.x86_64-linux.cli-commands        # gateway/config subcommands
 nix build .#checks.x86_64-linux.managed-guard       # HERMES_MANAGED blocks mutation
 nix build .#checks.x86_64-linux.bundled-skills      # skills present in package
+nix build .#checks.x86_64-linux.config-drift        # config keys match Python source
 nix build .#checks.x86_64-linux.config-roundtrip    # merge script preserves user keys
 ```
 
@@ -620,6 +621,7 @@ nix build .#checks.x86_64-linux.config-roundtrip    # merge script preserves use
 | `cli-commands` | `hermes --help` exposes `gateway` and `config` subcommands |
 | `managed-guard` | `HERMES_MANAGED=true hermes config set ...` prints the NixOS error |
 | `bundled-skills` | Skills directory exists, contains SKILL.md files, `HERMES_BUNDLED_SKILLS` is set in wrapper |
+| `config-drift` | Leaf keys extracted from Python's `DEFAULT_CONFIG` match the committed `nix/config-keys.json` reference |
 | `config-roundtrip` | 7 merge scenarios: fresh install, Nix override, user key preservation, mixed merge, MCP additive merge, nested deep merge, idempotency |
 
 </details>