fix: sync session_id after mid-run context compression

Critical bug: when the agent's context compressor fires during a tool
loop (_compress_context), it creates a new session_id and writes the
compressed messages there. But the gateway's session_entry still pointed
to the old session_id. On the next message, load_transcript() loaded
the stale pre-compression transcript, causing:

- Context bloat returning every turn
- Repeated compression cycles
- Loss of carefully compressed context

Fix: after run_conversation() returns, check if the agent's session_id
changed (compression split) and sync it back to the session store entry.
Also pass the effective session_id in the result dict so _handle_message
writes transcript entries to the correct session.

This affects ALL gateway adapters, not just webhook.

agent/auxiliary_client.py

@@ -439,37 +439,12 @@ def _try_nous() -> Tuple[Optional[OpenAI], Optional[str]]:
     )
 
 
-def _read_main_model() -> str:
-    """Read the user's configured main model from config/env.
-
-    Falls back through HERMES_MODEL → LLM_MODEL → config.yaml model.default
-    so the auxiliary client can use the same model as the main agent when no
-    dedicated auxiliary model is available.
-    """
-    from_env = os.getenv("OPENAI_MODEL") or os.getenv("HERMES_MODEL") or os.getenv("LLM_MODEL")
-    if from_env:
-        return from_env.strip()
-    try:
-        from hermes_cli.config import load_config
-        cfg = load_config()
-        model_cfg = cfg.get("model", {})
-        if isinstance(model_cfg, str) and model_cfg.strip():
-            return model_cfg.strip()
-        if isinstance(model_cfg, dict):
-            default = model_cfg.get("default", "")
-            if isinstance(default, str) and default.strip():
-                return default.strip()
-    except Exception:
-        pass
-    return ""
-
-
 def _try_custom_endpoint() -> Tuple[Optional[OpenAI], Optional[str]]:
     custom_base = os.getenv("OPENAI_BASE_URL")
     custom_key = os.getenv("OPENAI_API_KEY")
     if not custom_base or not custom_key:
         return None, None
-    model = _read_main_model() or "gpt-4o-mini"
+    model = os.getenv("OPENAI_MODEL") or "gpt-4o-mini"
     logger.debug("Auxiliary client: custom endpoint (%s)", model)
     return OpenAI(api_key=custom_key, base_url=custom_base), model
 
@@ -600,15 +575,6 @@ def resolve_provider_client(
         client, resolved = _resolve_auto()
         if client is None:
             return None, None
-        # When auto-detection lands on a non-OpenRouter provider (e.g. a
-        # local server), an OpenRouter-formatted model override like
-        # "google/gemini-3-flash-preview" won't work.  Drop it and use
-        # the provider's own default model instead.
-        if model and "/" in model and resolved and "/" not in resolved:
-            logger.debug(
-                "Dropping OpenRouter-format model %r for non-OpenRouter "
-                "auxiliary provider (using %r instead)", model, resolved)
-            model = None
         final_model = model or resolved
         return (_to_async_client(client, final_model) if async_mode
                 else (client, final_model))

agent/context_compressor.py

@@ -132,11 +132,7 @@ Write only the summary, starting with "[CONTEXT SUMMARY]:" prefix."""
             if self.summary_model:
                 call_kwargs["model"] = self.summary_model
             response = call_llm(**call_kwargs)
-            content = response.choices[0].message.content
-            # Handle cases where content is not a string (e.g., dict from llama.cpp)
-            if not isinstance(content, str):
-                content = str(content) if content else ""
-            summary = content.strip()
+            summary = response.choices[0].message.content.strip()
             if not summary.startswith("[CONTEXT SUMMARY]:"):
                 summary = "[CONTEXT SUMMARY]: " + summary
             return summary

cron/jobs.py

@@ -431,19 +431,8 @@ def save_job_output(job_id: str, output: str):
     timestamp = _hermes_now().strftime("%Y-%m-%d_%H-%M-%S")
     output_file = job_output_dir / f"{timestamp}.md"
     
-    fd, tmp_path = tempfile.mkstemp(dir=str(job_output_dir), suffix='.tmp', prefix='.output_')
-    try:
-        with os.fdopen(fd, 'w', encoding='utf-8') as f:
-            f.write(output)
-            f.flush()
-            os.fsync(f.fileno())
-        os.replace(tmp_path, output_file)
-        _secure_file(output_file)
-    except BaseException:
-        try:
-            os.unlink(tmp_path)
-        except OSError:
-            pass
-        raise
+    with open(output_file, 'w', encoding='utf-8') as f:
+        f.write(output)
+    _secure_file(output_file)
     
     return output_file

gateway/config.py

@@ -83,13 +83,10 @@ class SessionResetPolicy:
     
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "SessionResetPolicy":
-        # Handle both missing keys and explicit null values (YAML null → None)
-        at_hour = data.get("at_hour")
-        idle_minutes = data.get("idle_minutes")
         return cls(
             mode=data.get("mode", "both"),
-            at_hour=at_hour if at_hour is not None else 4,
-            idle_minutes=idle_minutes if idle_minutes is not None else 1440,
+            at_hour=data.get("at_hour", 4),
+            idle_minutes=data.get("idle_minutes", 1440),
         )
 
 
@@ -307,8 +304,6 @@ def load_gateway_config() -> GatewayConfig:
                     if isinstance(frc, list):
                         frc = ",".join(str(v) for v in frc)
                     os.environ["DISCORD_FREE_RESPONSE_CHANNELS"] = str(frc)
-                if "auto_thread" in discord_cfg and not os.getenv("DISCORD_AUTO_THREAD"):
-                    os.environ["DISCORD_AUTO_THREAD"] = str(discord_cfg["auto_thread"]).lower()
     except Exception:
         pass
 

gateway/platforms/discord.py

@@ -14,8 +14,6 @@ from typing import Dict, List, Optional, Any
 
 logger = logging.getLogger(__name__)
 
-VALID_THREAD_AUTO_ARCHIVE_MINUTES = {60, 1440, 4320, 10080}
-
 try:
     import discord
     from discord import Message as DiscordMessage, Intents
@@ -43,23 +41,6 @@ from gateway.platforms.base import (
 )
 
 
-def _clean_discord_id(entry: str) -> str:
-    """Strip common prefixes from a Discord user ID or username entry.
-
-    Users sometimes paste IDs with prefixes like ``user:123``, ``<@123>``,
-    or ``<@!123>`` from Discord's UI or other tools.  This normalises the
-    entry to just the bare ID or username.
-    """
-    entry = entry.strip()
-    # Strip Discord mention syntax: <@123> or <@!123>
-    if entry.startswith("<@") and entry.endswith(">"):
-        entry = entry.lstrip("<@!").rstrip(">")
-    # Strip "user:" prefix (seen in some Discord tools / onboarding pastes)
-    if entry.lower().startswith("user:"):
-        entry = entry[5:]
-    return entry.strip()
-
-
 def check_discord_requirements() -> bool:
     """Check if Discord dependencies are available."""
     return DISCORD_AVAILABLE
@@ -116,8 +97,7 @@ class DiscordAdapter(BasePlatformAdapter):
             allowed_env = os.getenv("DISCORD_ALLOWED_USERS", "")
             if allowed_env:
                 self._allowed_user_ids = {
-                    _clean_discord_id(uid) for uid in allowed_env.split(",")
-                    if uid.strip()
+                    uid.strip() for uid in allowed_env.split(",") if uid.strip()
                 }
             
             adapter_self = self  # capture for closure
@@ -271,7 +251,6 @@ class DiscordAdapter(BasePlatformAdapter):
         audio_path: str,
         caption: Optional[str] = None,
         reply_to: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
     ) -> SendResult:
         """Send audio as a Discord file attachment."""
         if not self._client:
@@ -310,7 +289,6 @@ class DiscordAdapter(BasePlatformAdapter):
         image_path: str,
         caption: Optional[str] = None,
         reply_to: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
     ) -> SendResult:
         """Send a local image file natively as a Discord file attachment."""
         if not self._client:
@@ -348,7 +326,6 @@ class DiscordAdapter(BasePlatformAdapter):
         image_url: str,
         caption: Optional[str] = None,
         reply_to: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
     ) -> SendResult:
         """Send an image natively as a Discord file attachment."""
         if not self._client:
@@ -734,21 +711,6 @@ class DiscordAdapter(BasePlatformAdapter):
             except Exception as e:
                 logger.debug("Discord followup failed: %s", e)
 
-        @tree.command(name="thread", description="Create a new thread and start a Hermes session in it")
-        @discord.app_commands.describe(
-            name="Thread name",
-            message="Optional first message to send to Hermes in the thread",
-            auto_archive_duration="Auto-archive in minutes (60, 1440, 4320, 10080)",
-        )
-        async def slash_thread(
-            interaction: discord.Interaction,
-            name: str,
-            message: str = "",
-            auto_archive_duration: int = 1440,
-        ):
-            await interaction.response.defer(ephemeral=True)
-            await self._handle_thread_create_slash(interaction, name, message, auto_archive_duration)
-
     def _build_slash_event(self, interaction: discord.Interaction, text: str) -> MessageEvent:
         """Build a MessageEvent from a Discord slash command interaction."""
         is_dm = isinstance(interaction.channel, discord.DMChannel)
@@ -779,188 +741,6 @@ class DiscordAdapter(BasePlatformAdapter):
             raw_message=interaction,
         )
 
-    # ------------------------------------------------------------------
-    # Thread creation helpers
-    # ------------------------------------------------------------------
-
-    async def _handle_thread_create_slash(
-        self,
-        interaction: discord.Interaction,
-        name: str,
-        message: str = "",
-        auto_archive_duration: int = 1440,
-    ) -> None:
-        """Create a Discord thread from a slash command and start a session in it."""
-        result = await self._create_thread(
-            interaction,
-            name=name,
-            message=message,
-            auto_archive_duration=auto_archive_duration,
-        )
-
-        if not result.get("success"):
-            error = result.get("error", "unknown error")
-            await interaction.followup.send(f"Failed to create thread: {error}", ephemeral=True)
-            return
-
-        thread_id = result.get("thread_id")
-        thread_name = result.get("thread_name") or name
-
-        # Tell the user where the thread is
-        link = f"<#{thread_id}>" if thread_id else f"**{thread_name}**"
-        await interaction.followup.send(f"Created thread {link}", ephemeral=True)
-
-        # If a message was provided, kick off a new Hermes session in the thread
-        starter = (message or "").strip()
-        if starter and thread_id:
-            await self._dispatch_thread_session(interaction, thread_id, thread_name, starter)
-
-    async def _dispatch_thread_session(
-        self,
-        interaction: discord.Interaction,
-        thread_id: str,
-        thread_name: str,
-        text: str,
-    ) -> None:
-        """Build a MessageEvent pointing at a thread and send it through handle_message."""
-        guild_name = ""
-        if hasattr(interaction, "guild") and interaction.guild:
-            guild_name = interaction.guild.name
-
-        chat_name = f"{guild_name} / {thread_name}" if guild_name else thread_name
-
-        source = self.build_source(
-            chat_id=thread_id,
-            chat_name=chat_name,
-            chat_type="thread",
-            user_id=str(interaction.user.id),
-            user_name=interaction.user.display_name,
-            thread_id=thread_id,
-        )
-
-        event = MessageEvent(
-            text=text,
-            message_type=MessageType.TEXT,
-            source=source,
-            raw_message=interaction,
-        )
-        await self.handle_message(event)
-
-    def _thread_parent_channel(self, channel: Any) -> Any:
-        """Return the parent text channel when invoked from a thread."""
-        return getattr(channel, "parent", None) or channel
-
-    async def _resolve_interaction_channel(self, interaction: discord.Interaction) -> Optional[Any]:
-        """Return the interaction channel, fetching it if the payload is partial."""
-        channel = getattr(interaction, "channel", None)
-        if channel is not None:
-            return channel
-        if not self._client:
-            return None
-        channel_id = getattr(interaction, "channel_id", None)
-        if channel_id is None:
-            return None
-        channel = self._client.get_channel(int(channel_id))
-        if channel is not None:
-            return channel
-        try:
-            return await self._client.fetch_channel(int(channel_id))
-        except Exception:
-            return None
-
-    async def _create_thread(
-        self,
-        interaction: discord.Interaction,
-        *,
-        name: str,
-        message: str = "",
-        auto_archive_duration: int = 1440,
-    ) -> Dict[str, Any]:
-        """Create a thread in the current Discord channel.
-
-        Tries ``parent_channel.create_thread()`` first.  If Discord rejects
-        that (e.g. permission issues), falls back to sending a seed message
-        and creating the thread from it.
-        """
-        name = (name or "").strip()
-        if not name:
-            return {"error": "Thread name is required."}
-
-        if auto_archive_duration not in VALID_THREAD_AUTO_ARCHIVE_MINUTES:
-            allowed = ", ".join(str(v) for v in sorted(VALID_THREAD_AUTO_ARCHIVE_MINUTES))
-            return {"error": f"auto_archive_duration must be one of: {allowed}."}
-
-        channel = await self._resolve_interaction_channel(interaction)
-        if channel is None:
-            return {"error": "Could not resolve the current Discord channel."}
-        if isinstance(channel, discord.DMChannel):
-            return {"error": "Discord threads can only be created inside server text channels, not DMs."}
-
-        parent_channel = self._thread_parent_channel(channel)
-        if parent_channel is None:
-            return {"error": "Could not determine a parent text channel for the new thread."}
-
-        display_name = getattr(getattr(interaction, "user", None), "display_name", None) or "unknown user"
-        reason = f"Requested by {display_name} via /thread"
-        starter_message = (message or "").strip()
-
-        try:
-            thread = await parent_channel.create_thread(
-                name=name,
-                auto_archive_duration=auto_archive_duration,
-                reason=reason,
-            )
-            if starter_message:
-                await thread.send(starter_message)
-            return {
-                "success": True,
-                "thread_id": str(thread.id),
-                "thread_name": getattr(thread, "name", None) or name,
-            }
-        except Exception as direct_error:
-            try:
-                seed_content = starter_message or f"\U0001f9f5 Thread created by Hermes: **{name}**"
-                seed_msg = await parent_channel.send(seed_content)
-                thread = await seed_msg.create_thread(
-                    name=name,
-                    auto_archive_duration=auto_archive_duration,
-                    reason=reason,
-                )
-                return {
-                    "success": True,
-                    "thread_id": str(thread.id),
-                    "thread_name": getattr(thread, "name", None) or name,
-                }
-            except Exception as fallback_error:
-                return {
-                    "error": (
-                        "Discord rejected direct thread creation and the fallback also failed. "
-                        f"Direct error: {direct_error}. Fallback error: {fallback_error}"
-                    )
-                }
-
-    # ------------------------------------------------------------------
-    # Auto-thread helpers
-    # ------------------------------------------------------------------
-
-    async def _auto_create_thread(self, message: 'DiscordMessage') -> Optional[Any]:
-        """Create a thread from a user message for auto-threading.
-
-        Returns the created thread object, or ``None`` on failure.
-        """
-        # Build a short thread name from the message
-        content = (message.content or "").strip()
-        thread_name = content[:80] if content else "Hermes"
-        if len(content) > 80:
-            thread_name = thread_name[:77] + "..."
-
-        try:
-            thread = await message.create_thread(name=thread_name, auto_archive_duration=1440)
-            return thread
-        except Exception as e:
-            logger.warning("[%s] Auto-thread creation failed: %s", self.name, e)
-            return None
-
     async def send_exec_approval(
         self, chat_id: str, command: str, approval_id: str
     ) -> SendResult:
@@ -1072,19 +852,6 @@ class DiscordAdapter(BasePlatformAdapter):
                 message.content = message.content.replace(f"<@{self._client.user.id}>", "").strip()
                 message.content = message.content.replace(f"<@!{self._client.user.id}>", "").strip()
 
-        # Auto-thread: when enabled, automatically create a thread for every
-        # new message in a text channel so each conversation is isolated.
-        # Messages already inside threads or DMs are unaffected.
-        auto_threaded_channel = None
-        if not is_thread and not isinstance(message.channel, discord.DMChannel):
-            auto_thread = os.getenv("DISCORD_AUTO_THREAD", "").lower() in ("true", "1", "yes")
-            if auto_thread:
-                thread = await self._auto_create_thread(message)
-                if thread:
-                    is_thread = True
-                    thread_id = str(thread.id)
-                    auto_threaded_channel = thread
-
         # Determine message type
         msg_type = MessageType.TEXT
         if message.content.startswith("/"):
@@ -1103,16 +870,13 @@ class DiscordAdapter(BasePlatformAdapter):
                         msg_type = MessageType.DOCUMENT
                     break
         
-        # When auto-threading kicked in, route responses to the new thread
-        effective_channel = auto_threaded_channel or message.channel
-
         # Determine chat type
         if isinstance(message.channel, discord.DMChannel):
             chat_type = "dm"
             chat_name = message.author.name
         elif is_thread:
             chat_type = "thread"
-            chat_name = self._format_thread_chat_name(effective_channel)
+            chat_name = self._format_thread_chat_name(message.channel)
         else:
             chat_type = "group"
             chat_name = getattr(message.channel, "name", str(message.channel.id))
@@ -1124,7 +888,7 @@ class DiscordAdapter(BasePlatformAdapter):
         
         # Build source
         source = self.build_source(
-            chat_id=str(effective_channel.id),
+            chat_id=str(message.channel.id),
             chat_name=chat_name,
             chat_type=chat_type,
             user_id=str(message.author.id),

gateway/platforms/homeassistant.py

@@ -83,7 +83,6 @@ class HomeAssistantAdapter(BasePlatformAdapter):
         self._watch_domains: Set[str] = set(extra.get("watch_domains", []))
         self._watch_entities: Set[str] = set(extra.get("watch_entities", []))
         self._ignore_entities: Set[str] = set(extra.get("ignore_entities", []))
-        self._watch_all: bool = bool(extra.get("watch_all", False))
         self._cooldown_seconds: int = int(extra.get("cooldown_seconds", 30))
 
         # Cooldown tracking: entity_id -> last_event_timestamp
@@ -116,15 +115,6 @@ class HomeAssistantAdapter(BasePlatformAdapter):
             # Dedicated REST session for send() calls
             self._rest_session = aiohttp.ClientSession()
 
-            # Warn if no event filters are configured
-            if not self._watch_domains and not self._watch_entities and not self._watch_all:
-                logger.warning(
-                    "[%s] No watch_domains, watch_entities, or watch_all configured. "
-                    "All state_changed events will be dropped. Configure filters in "
-                    "your HA platform config to receive events.",
-                    self.name,
-                )
-
             # Start background listener
             self._listen_task = asyncio.create_task(self._listen_loop())
             self._running = True
@@ -267,17 +257,13 @@ class HomeAssistantAdapter(BasePlatformAdapter):
         if entity_id in self._ignore_entities:
             return
 
-        # Apply domain/entity watch filters (closed by default — require
-        # explicit watch_domains, watch_entities, or watch_all to forward)
+        # Apply domain/entity watch filters
         domain = entity_id.split(".")[0] if "." in entity_id else ""
         if self._watch_domains or self._watch_entities:
             domain_match = domain in self._watch_domains if self._watch_domains else False
             entity_match = entity_id in self._watch_entities if self._watch_entities else False
             if not domain_match and not entity_match:
                 return
-        elif not self._watch_all:
-            # No filters configured and watch_all is off — drop the event
-            return
 
         # Apply cooldown
         now = time.time()

gateway/run.py

@@ -1125,16 +1125,10 @@ class GatewayRunner:
                 get_model_context_length,
             )
 
-            # Read model + compression config from config.yaml.
-            # NOTE: hygiene threshold is intentionally HIGHER than the agent's
-            # own compressor (0.85 vs 0.50).  Hygiene is a safety net for
-            # sessions that grew too large between turns — it fires pre-agent
-            # to prevent API failures.  The agent's own compressor handles
-            # normal context management during its tool loop with accurate
-            # real token counts.  Having hygiene at 0.50 caused premature
-            # compression on every turn in long gateway sessions.
+            # Read model + compression config from config.yaml — same
+            # source of truth the agent itself uses.
             _hyg_model = "anthropic/claude-sonnet-4.6"
-            _hyg_threshold_pct = 0.85
+            _hyg_threshold_pct = 0.50
             _hyg_compression_enabled = True
             try:
                 _hyg_cfg_path = _hermes_home / "config.yaml"
@@ -1150,18 +1144,22 @@ class GatewayRunner:
                     elif isinstance(_model_cfg, dict):
                         _hyg_model = _model_cfg.get("default", _hyg_model)
 
-                    # Read compression settings — only use enabled flag.
-                    # The threshold is intentionally separate from the agent's
-                    # compression.threshold (hygiene runs higher).
+                    # Read compression settings
                     _comp_cfg = _hyg_data.get("compression", {})
                     if isinstance(_comp_cfg, dict):
+                        _hyg_threshold_pct = float(
+                            _comp_cfg.get("threshold", _hyg_threshold_pct)
+                        )
                         _hyg_compression_enabled = str(
                             _comp_cfg.get("enabled", True)
                         ).lower() in ("true", "1", "yes")
             except Exception:
                 pass
 
-            # Check env override for disabling compression entirely
+            # Also check env overrides (same as run_agent.py)
+            _hyg_threshold_pct = float(
+                os.getenv("CONTEXT_COMPRESSION_THRESHOLD", str(_hyg_threshold_pct))
+            )
             if os.getenv("CONTEXT_COMPRESSION_ENABLED", "").lower() in ("false", "0", "no"):
                 _hyg_compression_enabled = False
 

gateway/session.py

@@ -177,26 +177,6 @@ def build_session_context_prompt(context: SessionContext) -> str:
     elif context.source.user_id:
         lines.append(f"**User ID:** {context.source.user_id}")
     
-    # Platform-specific behavioral notes
-    if context.source.platform == Platform.SLACK:
-        lines.append("")
-        lines.append(
-            "**Platform notes:** You are running inside Slack. "
-            "You do NOT have access to Slack-specific APIs — you cannot search "
-            "channel history, pin/unpin messages, manage channels, or list users. "
-            "Do not promise to perform these actions. If the user asks, explain "
-            "that you can only read messages sent directly to you and respond."
-        )
-    elif context.source.platform == Platform.DISCORD:
-        lines.append("")
-        lines.append(
-            "**Platform notes:** You are running inside Discord. "
-            "You do NOT have access to Discord-specific APIs — you cannot search "
-            "channel history, pin messages, manage roles, or list server members. "
-            "Do not promise to perform these actions. If the user asks, explain "
-            "that you can only read messages sent directly to you and respond."
-        )
-
     # Connected platforms
     platforms_list = ["local (files on this machine)"]
     for p in context.connected_platforms:

hermes_cli/auth.py

@@ -1541,20 +1541,8 @@ def detect_external_credentials() -> List[Dict[str, Any]]:
 # CLI Commands — login / logout
 # =============================================================================
 
-def _update_config_for_provider(
-    provider_id: str,
-    inference_base_url: str,
-    default_model: Optional[str] = None,
-) -> Path:
-    """Update config.yaml and auth.json to reflect the active provider.
-
-    When *default_model* is provided the function also writes it as the
-    ``model.default`` value.  This prevents a race condition where the
-    gateway (which re-reads config per-message) picks up the new provider
-    before the caller has finished model selection, resulting in a
-    mismatched model/provider (e.g. ``anthropic/claude-opus-4.6`` sent to
-    MiniMax's API).
-    """
+def _update_config_for_provider(provider_id: str, inference_base_url: str) -> Path:
+    """Update config.yaml and auth.json to reflect the active provider."""
     # Set active_provider in auth.json so auto-resolution picks this provider
     with _auth_store_lock():
         auth_store = _load_auth_store()
@@ -1588,15 +1576,6 @@ def _update_config_for_provider(
     else:
         # Clear stale base_url to prevent contamination when switching providers
         model_cfg.pop("base_url", None)
-
-    # When switching to a non-OpenRouter provider, ensure model.default is
-    # valid for the new provider.  An OpenRouter-formatted name like
-    # "anthropic/claude-opus-4.6" will fail on direct-API providers.
-    if default_model:
-        cur_default = model_cfg.get("default", "")
-        if not cur_default or "/" in cur_default:
-            model_cfg["default"] = default_model
-
     config["model"] = model_cfg
 
     config_path.write_text(yaml.safe_dump(config, sort_keys=False))

hermes_cli/config.py

@@ -194,13 +194,8 @@ DEFAULT_CONFIG = {
     },
     
     "stt": {
-        "provider": "local",  # "local" (free, faster-whisper) | "openai" (Whisper API)
-        "local": {
-            "model": "base",  # tiny, base, small, medium, large-v3
-        },
-        "openai": {
-            "model": "whisper-1",  # whisper-1, gpt-4o-mini-transcribe, gpt-4o-transcribe
-        },
+        "enabled": True,
+        "model": "whisper-1",
     },
     
     "human_delay": {

hermes_cli/doctor.py

@@ -97,10 +97,6 @@ def check_info(text: str):
 def run_doctor(args):
     """Run diagnostic checks."""
     should_fix = getattr(args, 'fix', False)
-
-    # Doctor runs from the interactive CLI, so CLI-gated tool availability
-    # checks (like cronjob management) should see the same context as `hermes`.
-    os.environ.setdefault("HERMES_INTERACTIVE", "1")
     
     issues = []
     manual_issues = []  # issues that can't be auto-fixed

hermes_cli/gateway.py

@@ -623,18 +623,6 @@ def _setup_standard_platform(platform: dict):
             value = prompt(f"  {var['prompt']}", password=False)
             if value:
                 cleaned = value.replace(" ", "")
-                # For Discord, strip common prefixes (user:123, <@123>, <@!123>)
-                if "DISCORD" in var["name"]:
-                    parts = []
-                    for uid in cleaned.split(","):
-                        uid = uid.strip()
-                        if uid.startswith("<@") and uid.endswith(">"):
-                            uid = uid.lstrip("<@!").rstrip(">")
-                        if uid.lower().startswith("user:"):
-                            uid = uid[5:]
-                        if uid:
-                            parts.append(uid)
-                    cleaned = ",".join(parts)
                 save_env_value(var["name"], cleaned)
                 print_success(f"  Saved — only these users can interact with the bot.")
                 allowed_val_set = cleaned

hermes_cli/setup.py

@@ -111,17 +111,7 @@ def _setup_provider_model_selection(config, provider_id, current_model, prompt_c
         custom = prompt_fn("Enter model name")
         if custom:
             _set_default_model(config, custom)
-    else:
-        # "Keep current" selected — validate it's compatible with the new
-        # provider.  OpenRouter-formatted names (containing "/") won't work
-        # on direct-API providers and would silently break the gateway.
-        if "/" in (current_model or "") and provider_models:
-            print_warning(
-                f"Current model \"{current_model}\" looks like an OpenRouter model "
-                f"and won't work with {pconfig.name}. "
-                f"Switching to {provider_models[0]}."
-            )
-            _set_default_model(config, provider_models[0])
+    # else: keep current
 
 
 def _sync_model_from_disk(config: Dict[str, Any]) -> None:
@@ -977,7 +967,7 @@ def setup_model_provider(config: dict):
         if existing_custom:
             save_env_value("OPENAI_BASE_URL", "")
             save_env_value("OPENAI_API_KEY", "")
-        _update_config_for_provider("zai", zai_base_url, default_model="glm-5")
+        _update_config_for_provider("zai", zai_base_url)
         _set_model_provider(config, "zai", zai_base_url)
 
     elif provider_idx == 5:  # Kimi / Moonshot
@@ -1010,7 +1000,7 @@ def setup_model_provider(config: dict):
         if existing_custom:
             save_env_value("OPENAI_BASE_URL", "")
             save_env_value("OPENAI_API_KEY", "")
-        _update_config_for_provider("kimi-coding", pconfig.inference_base_url, default_model="kimi-k2.5")
+        _update_config_for_provider("kimi-coding", pconfig.inference_base_url)
         _set_model_provider(config, "kimi-coding", pconfig.inference_base_url)
 
     elif provider_idx == 6:  # MiniMax
@@ -1043,7 +1033,7 @@ def setup_model_provider(config: dict):
         if existing_custom:
             save_env_value("OPENAI_BASE_URL", "")
             save_env_value("OPENAI_API_KEY", "")
-        _update_config_for_provider("minimax", pconfig.inference_base_url, default_model="MiniMax-M2.5")
+        _update_config_for_provider("minimax", pconfig.inference_base_url)
         _set_model_provider(config, "minimax", pconfig.inference_base_url)
 
     elif provider_idx == 7:  # MiniMax China
@@ -1076,7 +1066,7 @@ def setup_model_provider(config: dict):
         if existing_custom:
             save_env_value("OPENAI_BASE_URL", "")
             save_env_value("OPENAI_API_KEY", "")
-        _update_config_for_provider("minimax-cn", pconfig.inference_base_url, default_model="MiniMax-M2.5")
+        _update_config_for_provider("minimax-cn", pconfig.inference_base_url)
         _set_model_provider(config, "minimax-cn", pconfig.inference_base_url)
 
     elif provider_idx == 8:  # Anthropic
@@ -1180,7 +1170,7 @@ def setup_model_provider(config: dict):
             save_env_value("OPENAI_API_KEY", "")
         # Don't save base_url for Anthropic — resolve_runtime_provider()
         # always hardcodes it. Stale base_urls contaminate other providers.
-        _update_config_for_provider("anthropic", "", default_model="claude-opus-4-6")
+        _update_config_for_provider("anthropic", "")
         _set_model_provider(config, "anthropic")
 
     # else: provider_idx == 9 (Keep current) — only shown when a provider already exists
@@ -1935,17 +1925,7 @@ def setup_gateway(config: dict):
                 "Allowed user IDs or usernames (comma-separated, leave empty for open access)"
             )
             if allowed_users:
-                # Clean up common prefixes (user:123, <@123>, <@!123>)
-                cleaned_ids = []
-                for uid in allowed_users.replace(" ", "").split(","):
-                    uid = uid.strip()
-                    if uid.startswith("<@") and uid.endswith(">"):
-                        uid = uid.lstrip("<@!").rstrip(">")
-                    if uid.lower().startswith("user:"):
-                        uid = uid[5:]
-                    if uid:
-                        cleaned_ids.append(uid)
-                save_env_value("DISCORD_ALLOWED_USERS", ",".join(cleaned_ids))
+                save_env_value("DISCORD_ALLOWED_USERS", allowed_users.replace(" ", ""))
                 print_success("Discord allowlist configured")
             else:
                 print_info(
@@ -1980,18 +1960,8 @@ def setup_gateway(config: dict):
                 )
                 allowed_users = prompt("Allowed user IDs (comma-separated)")
                 if allowed_users:
-                    # Clean up common prefixes (user:123, <@123>, <@!123>)
-                    cleaned_ids = []
-                    for uid in allowed_users.replace(" ", "").split(","):
-                        uid = uid.strip()
-                        if uid.startswith("<@") and uid.endswith(">"):
-                            uid = uid.lstrip("<@!").rstrip(">")
-                        if uid.lower().startswith("user:"):
-                            uid = uid[5:]
-                        if uid:
-                            cleaned_ids.append(uid)
                     save_env_value(
-                        "DISCORD_ALLOWED_USERS", ",".join(cleaned_ids)
+                        "DISCORD_ALLOWED_USERS", allowed_users.replace(" ", "")
                     )
                     print_success("Discord allowlist configured")
 

landingpage/script.js

@@ -4,518 +4,339 @@
 
 // --- Platform install commands ---
 const PLATFORMS = {
-  linux: {
-    command:
-      "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash",
-    prompt: "$",
-    note: "Works on Linux, macOS & WSL2 · No prerequisites · Installs everything automatically",
-    stepNote:
-      "Installs uv, Python 3.11, clones the repo, sets up everything. No sudo needed.",
-  },
+    linux: {
+        command: 'curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash',
+        prompt: '$',
+        note: 'Works on Linux, macOS & WSL2 · No prerequisites · Installs everything automatically',
+        stepNote: 'Installs uv, Python 3.11, clones the repo, sets up everything. No sudo needed.',
+    },
 };
 
 function detectPlatform() {
-  return "linux";
+    return 'linux';
 }
 
 function switchPlatform(platform) {
-  const cfg = PLATFORMS[platform];
-  if (!cfg) return;
+    const cfg = PLATFORMS[platform];
+    if (!cfg) return;
 
-  // Update hero install widget
-  const commandEl = document.getElementById("install-command");
-  const promptEl = document.getElementById("install-prompt");
-  const noteEl = document.getElementById("install-note");
+    // Update hero install widget
+    const commandEl = document.getElementById('install-command');
+    const promptEl = document.getElementById('install-prompt');
+    const noteEl = document.getElementById('install-note');
 
-  if (commandEl) commandEl.textContent = cfg.command;
-  if (promptEl) promptEl.textContent = cfg.prompt;
-  if (noteEl) noteEl.textContent = cfg.note;
+    if (commandEl) commandEl.textContent = cfg.command;
+    if (promptEl) promptEl.textContent = cfg.prompt;
+    if (noteEl) noteEl.textContent = cfg.note;
 
-  // Update active tab in hero
-  document.querySelectorAll(".install-tab").forEach((tab) => {
-    tab.classList.toggle("active", tab.dataset.platform === platform);
-  });
+    // Update active tab in hero
+    document.querySelectorAll('.install-tab').forEach(tab => {
+        tab.classList.toggle('active', tab.dataset.platform === platform);
+    });
 
-  // Sync the step section tabs too
-  switchStepPlatform(platform);
+    // Sync the step section tabs too
+    switchStepPlatform(platform);
 }
 
 function switchStepPlatform(platform) {
-  const cfg = PLATFORMS[platform];
-  if (!cfg) return;
+    const cfg = PLATFORMS[platform];
+    if (!cfg) return;
 
-  const commandEl = document.getElementById("step1-command");
-  const copyBtn = document.getElementById("step1-copy");
-  const noteEl = document.getElementById("step1-note");
+    const commandEl = document.getElementById('step1-command');
+    const copyBtn = document.getElementById('step1-copy');
+    const noteEl = document.getElementById('step1-note');
 
-  if (commandEl) commandEl.textContent = cfg.command;
-  if (copyBtn) copyBtn.setAttribute("data-text", cfg.command);
-  if (noteEl) noteEl.textContent = cfg.stepNote;
+    if (commandEl) commandEl.textContent = cfg.command;
+    if (copyBtn) copyBtn.setAttribute('data-text', cfg.command);
+    if (noteEl) noteEl.textContent = cfg.stepNote;
 
-  // Update active tab in step section
-  document.querySelectorAll(".code-tab").forEach((tab) => {
-    tab.classList.toggle("active", tab.dataset.platform === platform);
-  });
-}
-
-function toggleMobileNav() {
-  document.getElementById("nav-mobile").classList.toggle("open");
-  document.getElementById("nav-hamburger").classList.toggle("open");
-}
-
-function toggleSpecs() {
-  const wrapper = document.getElementById("specs-wrapper");
-  const btn = document.getElementById("specs-toggle");
-  const label = btn.querySelector(".toggle-label");
-  const isOpen = wrapper.classList.contains("open");
-
-  if (isOpen) {
-    wrapper.style.maxHeight = wrapper.scrollHeight + "px";
-    requestAnimationFrame(() => {
-      wrapper.style.maxHeight = "0";
+    // Update active tab in step section
+    document.querySelectorAll('.code-tab').forEach(tab => {
+        tab.classList.toggle('active', tab.dataset.platform === platform);
     });
-    wrapper.classList.remove("open");
-    btn.classList.remove("open");
-    if (label) label.textContent = "More details";
-  } else {
-    wrapper.classList.add("open");
-    wrapper.style.maxHeight = wrapper.scrollHeight + "px";
-    btn.classList.add("open");
-    if (label) label.textContent = "Less";
-    wrapper.addEventListener(
-      "transitionend",
-      () => {
-        if (wrapper.classList.contains("open")) {
-          wrapper.style.maxHeight = "none";
-        }
-      },
-      { once: true }
-    );
-  }
 }
 
 // --- Copy to clipboard ---
 function copyInstall() {
-  const text = document.getElementById("install-command").textContent;
-  navigator.clipboard.writeText(text).then(() => {
-    const btn = document.querySelector(".install-widget-body .copy-btn");
-    const original = btn.querySelector(".copy-text").textContent;
-    btn.querySelector(".copy-text").textContent = "Copied!";
-    btn.style.color = "var(--primary-light)";
-    setTimeout(() => {
-      btn.querySelector(".copy-text").textContent = original;
-      btn.style.color = "";
-    }, 2000);
-  });
+    const text = document.getElementById('install-command').textContent;
+    navigator.clipboard.writeText(text).then(() => {
+        const btn = document.querySelector('.install-widget-body .copy-btn');
+        const original = btn.querySelector('.copy-text').textContent;
+        btn.querySelector('.copy-text').textContent = 'Copied!';
+        btn.style.color = 'var(--gold)';
+        setTimeout(() => {
+            btn.querySelector('.copy-text').textContent = original;
+            btn.style.color = '';
+        }, 2000);
+    });
 }
 
 function copyText(btn) {
-  const text = btn.getAttribute("data-text");
-  navigator.clipboard.writeText(text).then(() => {
-    const original = btn.textContent;
-    btn.textContent = "Copied!";
-    btn.style.color = "var(--primary-light)";
-    setTimeout(() => {
-      btn.textContent = original;
-      btn.style.color = "";
-    }, 2000);
-  });
+    const text = btn.getAttribute('data-text');
+    navigator.clipboard.writeText(text).then(() => {
+        const original = btn.textContent;
+        btn.textContent = 'Copied!';
+        btn.style.color = 'var(--gold)';
+        setTimeout(() => {
+            btn.textContent = original;
+            btn.style.color = '';
+        }, 2000);
+    });
 }
 
 // --- Scroll-triggered fade-in ---
 function initScrollAnimations() {
-  const elements = document.querySelectorAll(
-    ".feature-card, .install-step, " +
-      ".section-header, .terminal-window",
-  );
+    const elements = document.querySelectorAll(
+        '.feature-card, .tool-pill, .platform-group, .skill-category, ' +
+        '.install-step, .research-card, .footer-card, .section-header, ' +
+        '.lead-text, .section-desc, .terminal-window'
+    );
 
-  elements.forEach((el) => el.classList.add("fade-in"));
+    elements.forEach(el => el.classList.add('fade-in'));
 
-  const observer = new IntersectionObserver(
-    (entries) => {
-      entries.forEach((entry) => {
-        if (entry.isIntersecting) {
-          // Stagger children within grids
-          const parent = entry.target.parentElement;
-          if (parent) {
-            const siblings = parent.querySelectorAll(".fade-in");
-            let idx = Array.from(siblings).indexOf(entry.target);
-            if (idx < 0) idx = 0;
-            setTimeout(() => {
-              entry.target.classList.add("visible");
-            }, idx * 60);
-          } else {
-            entry.target.classList.add("visible");
-          }
-          observer.unobserve(entry.target);
-        }
-      });
-    },
-    { threshold: 0.1, rootMargin: "0px 0px -40px 0px" },
-  );
+    const observer = new IntersectionObserver((entries) => {
+        entries.forEach(entry => {
+            if (entry.isIntersecting) {
+                // Stagger children within grids
+                const parent = entry.target.parentElement;
+                if (parent) {
+                    const siblings = parent.querySelectorAll('.fade-in');
+                    let idx = Array.from(siblings).indexOf(entry.target);
+                    if (idx < 0) idx = 0;
+                    setTimeout(() => {
+                        entry.target.classList.add('visible');
+                    }, idx * 60);
+                } else {
+                    entry.target.classList.add('visible');
+                }
+                observer.unobserve(entry.target);
+            }
+        });
+    }, { threshold: 0.1, rootMargin: '0px 0px -40px 0px' });
 
-  elements.forEach((el) => observer.observe(el));
+    elements.forEach(el => observer.observe(el));
 }
 
 // --- Terminal Demo ---
-const CURSOR = '<span class="terminal-cursor">█</span>';
-
 const demoSequence = [
-  { type: "prompt", text: "❯ " },
-  {
-    type: "type",
-    text: "Research the latest approaches to GRPO training and write a summary",
-    delay: 30,
-  },
-  { type: "pause", ms: 600 },
-  {
-    type: "output",
-    lines: [
-      "",
-      '<span class="t-dim">  web_search "GRPO reinforcement learning 2026"       1.2s</span>',
-    ],
-  },
-  { type: "pause", ms: 400 },
-  {
-    type: "output",
-    lines: [
-      '<span class="t-dim">  web_extract arxiv.org/abs/2402.03300                3.1s</span>',
-    ],
-  },
-  { type: "pause", ms: 400 },
-  {
-    type: "output",
-    lines: [
-      '<span class="t-dim">  web_search "GRPO vs PPO ablation results"           0.9s</span>',
-    ],
-  },
-  { type: "pause", ms: 400 },
-  {
-    type: "output",
-    lines: [
-      '<span class="t-dim">  web_extract huggingface.co/blog/grpo                2.8s</span>',
-    ],
-  },
-  { type: "pause", ms: 400 },
-  {
-    type: "output",
-    lines: [
-      '<span class="t-dim">  write_file ~/research/grpo-summary.md               0.1s</span>',
-    ],
-  },
-  { type: "pause", ms: 500 },
-  {
-    type: "output",
-    lines: [
-      "",
-      '<span class="t-text">Done! I\'ve written a summary covering:</span>',
-      "",
-      '<span class="t-text">  <span class="t-green">✓</span> GRPO\'s group-relative advantage (no critic model needed)</span>',
-      '<span class="t-text">  <span class="t-green">✓</span> Comparison with PPO/DPO on reasoning benchmarks</span>',
-      '<span class="t-text">  <span class="t-green">✓</span> Implementation notes for Axolotl and TRL</span>',
-      "",
-      '<span class="t-text">Saved to</span> <span class="t-accent">~/research/grpo-summary.md</span>',
-    ],
-  },
-  { type: "pause", ms: 2500 },
+    // Scene 1: Research task with delegation
+    { type: 'prompt', text: '❯ ' },
+    { type: 'type', text: 'Research the latest approaches to GRPO training and write a summary', delay: 30 },
+    { type: 'pause', ms: 600 },
+    { type: 'output', lines: [
+        '',
+        '<span class="t-dim">┊ 🔍 web_search "GRPO reinforcement learning 2026"      1.2s</span>',
+    ]},
+    { type: 'pause', ms: 400 },
+    { type: 'output', lines: [
+        '<span class="t-dim">┊ 📄 web_extract arxiv.org/abs/2402.03300               3.1s</span>',
+    ]},
+    { type: 'pause', ms: 400 },
+    { type: 'output', lines: [
+        '<span class="t-dim">┊ 🔍 web_search "GRPO vs PPO ablation results"          0.9s</span>',
+    ]},
+    { type: 'pause', ms: 400 },
+    { type: 'output', lines: [
+        '<span class="t-dim">┊ 📄 web_extract huggingface.co/blog/grpo               2.8s</span>',
+    ]},
+    { type: 'pause', ms: 400 },
+    { type: 'output', lines: [
+        '<span class="t-dim">┊ ✍️  write_file ~/research/grpo-summary.md               0.1s</span>',
+    ]},
+    { type: 'pause', ms: 500 },
+    { type: 'output', lines: [
+        '',
+        '<span class="t-text">Done! I\'ve written a summary covering:</span>',
+        '',
+        '<span class="t-text">  <span class="t-green">✓</span> GRPO\'s group-relative advantage (no critic model needed)</span>',
+        '<span class="t-text">  <span class="t-green">✓</span> Comparison with PPO/DPO on reasoning benchmarks</span>',
+        '<span class="t-text">  <span class="t-green">✓</span> Implementation notes for Axolotl and TRL</span>',
+        '',
+        '<span class="t-text">Saved to</span> <span class="t-amber">~/research/grpo-summary.md</span>',
+    ]},
+    { type: 'pause', ms: 2500 },
 
-  { type: "clear" },
-  { type: "prompt", text: "❯ " },
-  {
-    type: "type",
-    text: "Review the PR at NousResearch/hermes-agent#42 and fix any issues",
-    delay: 30,
-  },
-  { type: "pause", ms: 600 },
-  {
-    type: "output",
-    lines: [
-      "",
-      '<span class="t-dim">  delegate_task "review PR #42 changes"                2.1s</span>',
-    ],
-  },
-  { type: "pause", ms: 500 },
-  {
-    type: "output",
-    lines: [
-      '<span class="t-dim">  git diff main..pr-42                                 0.4s</span>',
-    ],
-  },
-  { type: "pause", ms: 400 },
-  {
-    type: "output",
-    lines: [
-      '<span class="t-dim">  patch tools/registry.py                              0.1s</span>',
-    ],
-  },
-  { type: "pause", ms: 400 },
-  {
-    type: "output",
-    lines: [
-      '<span class="t-dim">  python -m pytest tests/ -x                           3.2s</span>',
-    ],
-  },
-  { type: "pause", ms: 400 },
-  {
-    type: "output",
-    lines: [
-      '<span class="t-dim">  git commit -m "fix: handle empty tool schemas"       0.3s</span>',
-    ],
-  },
-  { type: "pause", ms: 500 },
-  {
-    type: "output",
-    lines: [
-      "",
-      '<span class="t-text">Found 2 issues in the PR and fixed both:</span>',
-      "",
-      '<span class="t-text">  <span class="t-green">✓</span> Empty tool schema crash in registry.py — added guard</span>',
-      '<span class="t-text">  <span class="t-green">✓</span> Missing error handling in delegate_tool.py — added try/except</span>',
-      "",
-      '<span class="t-text">Tests pass. Committed the fix and pushed to the PR branch.</span>',
-      '<span class="t-text">I also saved a</span> <span class="t-accent">skill</span> <span class="t-text">for this PR review pattern.</span>',
-    ],
-  },
-  { type: "pause", ms: 2500 },
+    // Scene 2: Quick delegation
+    { type: 'clear' },
+    { type: 'prompt', text: '❯ ' },
+    { type: 'type', text: 'Review the PR at NousResearch/hermes-agent#42 and fix any issues', delay: 30 },
+    { type: 'pause', ms: 600 },
+    { type: 'output', lines: [
+        '',
+        '<span class="t-dim">┊ 🔀 delegate_task "review PR #42 changes"               2.1s</span>',
+    ]},
+    { type: 'pause', ms: 500 },
+    { type: 'output', lines: [
+        '<span class="t-dim">┊ 💻 git diff main..pr-42                                0.4s</span>',
+    ]},
+    { type: 'pause', ms: 400 },
+    { type: 'output', lines: [
+        '<span class="t-dim">┊ ✏️  patch tools/registry.py                             0.1s</span>',
+    ]},
+    { type: 'pause', ms: 400 },
+    { type: 'output', lines: [
+        '<span class="t-dim">┊ 💻 python -m pytest tests/ -x                          3.2s</span>',
+    ]},
+    { type: 'pause', ms: 400 },
+    { type: 'output', lines: [
+        '<span class="t-dim">┊ 💻 git commit -m "fix: handle empty tool schemas"      0.3s</span>',
+    ]},
+    { type: 'pause', ms: 500 },
+    { type: 'output', lines: [
+        '',
+        '<span class="t-text">Found 2 issues in the PR and fixed both:</span>',
+        '',
+        '<span class="t-text">  <span class="t-green">✓</span> Empty tool schema crash in registry.py — added guard</span>',
+        '<span class="t-text">  <span class="t-green">✓</span> Missing error handling in delegate_tool.py — added try/except</span>',
+        '',
+        '<span class="t-text">Tests pass. Committed the fix and pushed to the PR branch.</span>',
+        '<span class="t-text">I also saved a</span> <span class="t-amber">skill</span> <span class="t-text">for this PR review pattern.</span>',
+    ]},
+    { type: 'pause', ms: 2500 },
 
-  { type: "clear" },
-  { type: "prompt", text: "❯ " },
-  {
-    type: "type",
-    text: "How did we fix that Docker networking issue?",
-    delay: 35,
-  },
-  { type: "pause", ms: 500 },
-  {
-    type: "output",
-    lines: [
-      "",
-      '<span class="t-dim">  session_search "Docker networking"                   1.4s</span>',
-    ],
-  },
-  { type: "pause", ms: 500 },
-  {
-    type: "output",
-    lines: [
-      "",
-      '<span class="t-text">Found it — from a session on February 12th:</span>',
-      "",
-      '<span class="t-text">The containers couldn\'t reach each other because the compose</span>',
-      '<span class="t-text">file was using the default bridge network. We switched to a</span>',
-      '<span class="t-text">custom network with</span> <span class="t-accent">driver: overlay</span><span class="t-text">, added explicit</span>',
-      '<span class="t-text">aliases, and set</span> <span class="t-accent">dns: 8.8.8.8</span> <span class="t-text">as a fallback.</span>',
-      "",
-      '<span class="t-text">The fix was committed in</span> <span class="t-accent">docker-compose.prod.yml</span><span class="t-text">.</span>',
-    ],
-  },
-  { type: "pause", ms: 3000 },
+    // Scene 3: Session search by keyword
+    { type: 'clear' },
+    { type: 'prompt', text: '❯ ' },
+    { type: 'type', text: 'How did we fix that Docker networking issue?', delay: 35 },
+    { type: 'pause', ms: 500 },
+    { type: 'output', lines: [
+        '',
+        '<span class="t-dim">┊ 🔎 session_search "Docker networking"                  1.4s</span>',
+    ]},
+    { type: 'pause', ms: 500 },
+    { type: 'output', lines: [
+        '',
+        '<span class="t-text">Found it — from a session on February 12th:</span>',
+        '',
+        '<span class="t-text">The containers couldn\'t reach each other because the compose</span>',
+        '<span class="t-text">file was using the default bridge network. We switched to a</span>',
+        '<span class="t-text">custom network with</span> <span class="t-amber">driver: overlay</span><span class="t-text">, added explicit</span>',
+        '<span class="t-text">aliases, and set</span> <span class="t-amber">dns: 8.8.8.8</span> <span class="t-text">as a fallback.</span>',
+        '',
+        '<span class="t-text">The fix was committed in</span> <span class="t-amber">docker-compose.prod.yml</span><span class="t-text">.</span>',
+    ]},
+    { type: 'pause', ms: 3000 },
 ];
 
 class TerminalDemo {
-  constructor(container) {
-    this.container = container;
-    this.running = false;
-    this.content = "";
-  }
-
-  async start() {
-    if (this.running) return;
-    this.running = true;
-
-    while (this.running) {
-      for (const step of demoSequence) {
-        if (!this.running) return;
-        await this.execute(step);
-      }
-      this.clear();
-      await this.sleep(1000);
+    constructor(element, cursorElement) {
+        this.el = element;
+        this.cursor = cursorElement;
+        this.running = false;
+        this.content = '';
+        this.observer = null;
     }
-  }
 
-  stop() {
-    this.running = false;
-  }
-
-  async execute(step) {
-    switch (step.type) {
-      case "prompt":
-        this.append(`<span class="t-prompt">${step.text}</span>`);
-        break;
-      case "type":
-        for (const char of step.text) {
-          if (!this.running) return;
-          this.append(`<span class="t-cmd">${char}</span>`);
-          await this.sleep(step.delay || 30);
+    async start() {
+        if (this.running) return;
+        this.running = true;
+        
+        while (this.running) {
+            for (const step of demoSequence) {
+                if (!this.running) return;
+                await this.execute(step);
+            }
+            // Loop
+            this.clear();
+            await this.sleep(1000);
         }
-        break;
-      case "output":
-        for (const line of step.lines) {
-          if (!this.running) return;
-          this.append("\n" + line);
-          await this.sleep(50);
-        }
-        break;
-      case "pause":
-        await this.sleep(step.ms);
-        break;
-      case "clear":
-        this.clear();
-        break;
     }
-  }
 
-  append(html) {
-    this.content += html;
-    this.render();
-  }
+    stop() {
+        this.running = false;
+    }
 
-  render() {
-    this.container.innerHTML = this.content + CURSOR;
-    this.container.scrollTop = this.container.scrollHeight;
-  }
+    async execute(step) {
+        switch (step.type) {
+            case 'prompt':
+                this.append(`<span class="t-prompt">${step.text}</span>`);
+                break;
 
-  clear() {
-    this.content = "";
-    this.container.innerHTML = "";
-  }
+            case 'type':
+                for (const char of step.text) {
+                    if (!this.running) return;
+                    this.append(`<span class="t-cmd">${char}</span>`);
+                    await this.sleep(step.delay || 30);
+                }
+                break;
 
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-}
+            case 'output':
+                for (const line of step.lines) {
+                    if (!this.running) return;
+                    this.append('\n' + line);
+                    await this.sleep(50);
+                }
+                break;
 
-// --- Noise Overlay (ported from hermes-chat NoiseOverlay) ---
-function initNoiseOverlay() {
-  if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) return;
-  if (typeof THREE === "undefined") return;
+            case 'pause':
+                await this.sleep(step.ms);
+                break;
 
-  const canvas = document.getElementById("noise-overlay");
-  if (!canvas) return;
-
-  const vertexShader = `
-        varying vec2 vUv;
-        void main() {
-            vUv = uv;
-            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+            case 'clear':
+                this.clear();
+                break;
         }
-    `;
+    }
 
-  const fragmentShader = `
-        uniform vec2 uRes;
-        uniform float uDpr, uSize, uDensity, uOpacity;
-        uniform vec3 uColor;
-        varying vec2 vUv;
+    append(html) {
+        this.content += html;
+        this.el.innerHTML = this.content;
+        // Keep cursor at end
+        this.el.parentElement.scrollTop = this.el.parentElement.scrollHeight;
+    }
 
-        float hash(vec2 p) {
-            vec3 p3 = fract(vec3(p.xyx) * 0.1031);
-            p3 += dot(p3, p3.yzx + 33.33);
-            return fract((p3.x + p3.y) * p3.z);
-        }
+    clear() {
+        this.content = '';
+        this.el.innerHTML = '';
+    }
 
-        void main() {
-            float n = hash(floor(vUv * uRes / (uSize * uDpr)));
-            gl_FragColor = vec4(uColor, step(1.0 - uDensity, n)) * uOpacity;
-        }
-    `;
-
-  function hexToVec3(hex) {
-    const c = hex.replace("#", "");
-    return new THREE.Vector3(
-      parseInt(c.substring(0, 2), 16) / 255,
-      parseInt(c.substring(2, 4), 16) / 255,
-      parseInt(c.substring(4, 6), 16) / 255,
-    );
-  }
-
-  const renderer = new THREE.WebGLRenderer({
-    alpha: true,
-    canvas,
-    premultipliedAlpha: false,
-  });
-  renderer.setClearColor(0x000000, 0);
-
-  const scene = new THREE.Scene();
-  const camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
-  const geo = new THREE.PlaneGeometry(2, 2);
-
-  const mat = new THREE.ShaderMaterial({
-    vertexShader,
-    fragmentShader,
-    transparent: true,
-    uniforms: {
-      uColor: { value: hexToVec3("#8090BB") },
-      uDensity: { value: 0.1 },
-      uDpr: { value: 1 },
-      uOpacity: { value: 0.4 },
-      uRes: { value: new THREE.Vector2() },
-      uSize: { value: 1.0 },
-    },
-  });
-
-  scene.add(new THREE.Mesh(geo, mat));
-
-  function resize() {
-    const dpr = window.devicePixelRatio;
-    const w = window.innerWidth;
-    const h = window.innerHeight;
-    renderer.setSize(w, h);
-    renderer.setPixelRatio(dpr);
-    mat.uniforms.uRes.value.set(w * dpr, h * dpr);
-    mat.uniforms.uDpr.value = dpr;
-  }
-
-  resize();
-  window.addEventListener("resize", resize);
-
-  function loop() {
-    requestAnimationFrame(loop);
-    renderer.render(scene, camera);
-  }
-  loop();
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
 }
 
 // --- Initialize ---
-document.addEventListener("DOMContentLoaded", () => {
-  const detectedPlatform = detectPlatform();
-  switchPlatform(detectedPlatform);
+document.addEventListener('DOMContentLoaded', () => {
+    // Auto-detect platform and set the right install command
+    const detectedPlatform = detectPlatform();
+    switchPlatform(detectedPlatform);
 
-  initScrollAnimations();
-  initNoiseOverlay();
+    initScrollAnimations();
 
-  const terminalEl = document.getElementById("terminal-demo");
+    // Terminal demo - start when visible
+    const terminalEl = document.getElementById('terminal-content');
+    const cursorEl = document.getElementById('terminal-cursor');
+    
+    if (terminalEl && cursorEl) {
+        const demo = new TerminalDemo(terminalEl, cursorEl);
+        
+        const observer = new IntersectionObserver((entries) => {
+            entries.forEach(entry => {
+                if (entry.isIntersecting) {
+                    demo.start();
+                } else {
+                    demo.stop();
+                }
+            });
+        }, { threshold: 0.3 });
 
-  if (terminalEl) {
-    const demo = new TerminalDemo(terminalEl);
-
-    const observer = new IntersectionObserver(
-      (entries) => {
-        entries.forEach((entry) => {
-          if (entry.isIntersecting) {
-            demo.start();
-          } else {
-            demo.stop();
-          }
-        });
-      },
-      { threshold: 0.3 },
-    );
-
-    observer.observe(document.querySelector(".terminal-window"));
-  }
-
-  const nav = document.querySelector(".nav");
-  let ticking = false;
-  window.addEventListener("scroll", () => {
-    if (!ticking) {
-      requestAnimationFrame(() => {
-        if (window.scrollY > 50) {
-          nav.style.borderBottomColor = "rgba(48, 80, 255, 0.15)";
-        } else {
-          nav.style.borderBottomColor = "";
-        }
-        ticking = false;
-      });
-      ticking = true;
+        observer.observe(document.querySelector('.terminal-window'));
     }
-  });
+
+    // Smooth nav background on scroll
+    const nav = document.querySelector('.nav');
+    let ticking = false;
+    window.addEventListener('scroll', () => {
+        if (!ticking) {
+            requestAnimationFrame(() => {
+                if (window.scrollY > 50) {
+                    nav.style.borderBottomColor = 'rgba(255, 215, 0, 0.1)';
+                } else {
+                    nav.style.borderBottomColor = '';
+                }
+                ticking = false;
+            });
+            ticking = true;
+        }
+    });
 });

optional-skills/security/1password/SKILL.md

@@ -1,162 +0,0 @@
----
-name: 1password
-description: Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in, and reading/injecting secrets for commands.
-version: 1.0.0
-author: arceus77-7, enhanced by Hermes Agent
-license: MIT
-metadata:
-  hermes:
-    tags: [security, secrets, 1password, op, cli]
-    category: security
-setup:
-  help: "Create a service account at https://my.1password.com → Settings → Service Accounts"
-  collect_secrets:
-    - env_var: OP_SERVICE_ACCOUNT_TOKEN
-      prompt: "1Password Service Account Token"
-      provider_url: "https://developer.1password.com/docs/service-accounts/"
-      secret: true
----
-
-# 1Password CLI
-
-Use this skill when the user wants secrets managed through 1Password instead of plaintext env vars or files.
-
-## Requirements
-
-- 1Password account
-- 1Password CLI (`op`) installed
-- One of: desktop app integration, service account token (`OP_SERVICE_ACCOUNT_TOKEN`), or Connect server
-- `tmux` available for stable authenticated sessions during Hermes terminal calls (desktop app flow only)
-
-## When to Use
-
-- Install or configure 1Password CLI
-- Sign in with `op signin`
-- Read secret references like `op://Vault/Item/field`
-- Inject secrets into config/templates using `op inject`
-- Run commands with secret env vars via `op run`
-
-## Authentication Methods
-
-### Service Account (recommended for Hermes)
-
-Set `OP_SERVICE_ACCOUNT_TOKEN` in `~/.hermes/.env` (the skill will prompt for this on first load).
-No desktop app needed. Supports `op read`, `op inject`, `op run`.
-
-```bash
-export OP_SERVICE_ACCOUNT_TOKEN="your-token-here"
-op whoami  # verify — should show Type: SERVICE_ACCOUNT
-```
-
-### Desktop App Integration (interactive)
-
-1. Enable in 1Password desktop app: Settings → Developer → Integrate with 1Password CLI
-2. Ensure app is unlocked
-3. Run `op signin` and approve the biometric prompt
-
-### Connect Server (self-hosted)
-
-```bash
-export OP_CONNECT_HOST="http://localhost:8080"
-export OP_CONNECT_TOKEN="your-connect-token"
-```
-
-## Setup
-
-1. Install CLI:
-
-```bash
-# macOS
-brew install 1password-cli
-
-# Linux (official package/install docs)
-# See references/get-started.md for distro-specific links.
-
-# Windows (winget)
-winget install AgileBits.1Password.CLI
-```
-
-2. Verify:
-
-```bash
-op --version
-```
-
-3. Choose an auth method above and configure it.
-
-## Hermes Execution Pattern (desktop app flow)
-
-Hermes terminal commands are non-interactive by default and can lose auth context between calls.
-For reliable `op` use with desktop app integration, run sign-in and secret operations inside a dedicated tmux session.
-
-Note: This is NOT needed when using `OP_SERVICE_ACCOUNT_TOKEN` — the token persists across terminal calls automatically.
-
-```bash
-SOCKET_DIR="${TMPDIR:-/tmp}/hermes-tmux-sockets"
-mkdir -p "$SOCKET_DIR"
-SOCKET="$SOCKET_DIR/hermes-op.sock"
-SESSION="op-auth-$(date +%Y%m%d-%H%M%S)"
-
-tmux -S "$SOCKET" new -d -s "$SESSION" -n shell
-
-# Sign in (approve in desktop app when prompted)
-tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 -- "eval \"\$(op signin --account my.1password.com)\"" Enter
-
-# Verify auth
-tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 -- "op whoami" Enter
-
-# Example read
-tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 -- "op read 'op://Private/Npmjs/one-time password?attribute=otp'" Enter
-
-# Capture output when needed
-tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION":0.0 -S -200
-
-# Cleanup
-tmux -S "$SOCKET" kill-session -t "$SESSION"
-```
-
-## Common Operations
-
-### Read a secret
-
-```bash
-op read "op://app-prod/db/password"
-```
-
-### Get OTP
-
-```bash
-op read "op://app-prod/npm/one-time password?attribute=otp"
-```
-
-### Inject into template
-
-```bash
-echo "db_password: {{ op://app-prod/db/password }}" | op inject
-```
-
-### Run a command with secret env var
-
-```bash
-export DB_PASSWORD="op://app-prod/db/password"
-op run -- sh -c '[ -n "$DB_PASSWORD" ] && echo "DB_PASSWORD is set" || echo "DB_PASSWORD missing"'
-```
-
-## Guardrails
-
-- Never print raw secrets back to user unless they explicitly request the value.
-- Prefer `op run` / `op inject` instead of writing secrets into files.
-- If command fails with "account is not signed in", run `op signin` again in the same tmux session.
-- If desktop app integration is unavailable (headless/CI), use service account token flow.
-
-## CI / Headless note
-
-For non-interactive use, authenticate with `OP_SERVICE_ACCOUNT_TOKEN` and avoid interactive `op signin`.
-Service accounts require CLI v2.18.0+.
-
-## References
-
-- `references/get-started.md`
-- `references/cli-examples.md`
-- https://developer.1password.com/docs/cli/
-- https://developer.1password.com/docs/service-accounts/

optional-skills/security/1password/references/cli-examples.md

@@ -1,31 +0,0 @@
-# op CLI examples
-
-## Sign-in and identity
-
-```bash
-op signin
-op signin --account my.1password.com
-op whoami
-op account list
-```
-
-## Read secrets
-
-```bash
-op read "op://app-prod/db/password"
-op read "op://app-prod/npm/one-time password?attribute=otp"
-```
-
-## Inject secrets
-
-```bash
-echo "api_key: {{ op://app-prod/openai/api key }}" | op inject
-op inject -i config.tpl.yml -o config.yml
-```
-
-## Run command with secrets
-
-```bash
-export DB_PASSWORD="op://app-prod/db/password"
-op run -- sh -c '[ -n "$DB_PASSWORD" ] && echo "DB_PASSWORD is set"'
-```

optional-skills/security/1password/references/get-started.md

@@ -1,21 +0,0 @@
-# 1Password CLI get-started (summary)
-
-Official docs: https://developer.1password.com/docs/cli/get-started/
-
-## Core flow
-
-1. Install `op` CLI.
-2. Enable desktop app integration in 1Password app.
-3. Unlock app.
-4. Run `op signin` and approve prompt.
-5. Verify with `op whoami`.
-
-## Multiple accounts
-
-- Use `op signin --account <subdomain.1password.com>`
-- Or set `OP_ACCOUNT`
-
-## Non-interactive / automation
-
-- Use service accounts and `OP_SERVICE_ACCOUNT_TOKEN`
-- Prefer `op run` and `op inject` for runtime secret handling

optional-skills/security/DESCRIPTION.md

@@ -1,3 +0,0 @@
-# Security
-
-Skills for secrets management, credential handling, and security tooling integrations.

pyproject.toml

@@ -30,7 +30,6 @@ dependencies = [
   "fal-client",
   # Text-to-speech (Edge TTS is free, no API key needed)
   "edge-tts",
-  "faster-whisper>=1.0.0",
   # mini-swe-agent deps (terminal tool)
   "litellm>=1.75.5",
   "typer",

run_agent.py

@@ -202,32 +202,6 @@ _NEVER_PARALLEL_TOOLS = frozenset({"clarify"})
 _MAX_TOOL_WORKERS = 8
 
 
-def _inject_honcho_turn_context(content, turn_context: str):
-    """Append Honcho recall to the current-turn user message without mutating history.
-
-    The returned content is sent to the API for this turn only. Keeping Honcho
-    recall out of the system prompt preserves the stable cache prefix while
-    still giving the model continuity context.
-    """
-    if not turn_context:
-        return content
-
-    note = (
-        "[System note: The following Honcho memory was retrieved from prior "
-        "sessions. It is continuity context for this turn only, not new user "
-        "input.]\n\n"
-        f"{turn_context}"
-    )
-
-    if isinstance(content, list):
-        return list(content) + [{"type": "text", "text": note}]
-
-    text = "" if content is None else str(content)
-    if not text.strip():
-        return note
-    return f"{text}\n\n{note}"
-
-
 class AIAgent:
     """
     AI Agent with tool calling capabilities.
@@ -2755,7 +2729,7 @@ class AIAgent:
             "model": self.model,
             "messages": api_messages,
             "tools": self.tools if self.tools else None,
-            "timeout": float(os.getenv("HERMES_API_TIMEOUT", 900.0)),
+            "timeout": 900.0,
         }
 
         if self.max_tokens is not None:
@@ -3935,11 +3909,10 @@ class AIAgent:
 
         # Honcho prefetch consumption:
         # - First turn: bake into cached system prompt (stable for the session).
-        # - Later turns: attach recall to the current-turn user message at
-        #   API-call time only (never persisted to history / session DB).
+        # - Later turns: inject as ephemeral system context for this API call only.
         #
-        # This keeps the system-prefix cache stable while still allowing turn N
-        # to consume background prefetch results from turn N-1.
+        # This keeps the persisted/cached prompt stable while still allowing
+        # turn N to consume background prefetch results from turn N-1.
         self._honcho_context = ""
         self._honcho_turn_context = ""
         _recall_mode = (self._honcho_config.recall_mode if self._honcho_config else "hybrid")
@@ -3957,7 +3930,6 @@ class AIAgent:
         # Add user message
         user_msg = {"role": "user", "content": user_message}
         messages.append(user_msg)
-        current_turn_user_idx = len(messages) - 1
         
         if not self.quiet_mode:
             print(f"💬 Starting conversation: '{user_message[:60]}{'...' if len(user_message) > 60 else ''}'")
@@ -4107,14 +4079,9 @@ class AIAgent:
             # However, providers like Moonshot AI require a separate 'reasoning_content' field
             # on assistant messages with tool_calls. We handle both cases here.
             api_messages = []
-            for idx, msg in enumerate(messages):
+            for msg in messages:
                 api_msg = msg.copy()
 
-                if idx == current_turn_user_idx and msg.get("role") == "user" and self._honcho_turn_context:
-                    api_msg["content"] = _inject_honcho_turn_context(
-                        api_msg.get("content", ""), self._honcho_turn_context
-                    )
-
                 # For ALL assistant messages, pass reasoning back to the API
                 # This ensures multi-turn reasoning context is preserved
                 if msg.get("role") == "assistant":
@@ -4142,11 +4109,11 @@ class AIAgent:
 
             # Build the final system message: cached prompt + ephemeral system prompt.
             # Ephemeral additions are API-call-time only (not persisted to session DB).
-            # Honcho later-turn recall is intentionally kept OUT of the system prompt
-            # so the stable cache prefix remains unchanged.
             effective_system = active_system_prompt or ""
             if self.ephemeral_system_prompt:
                 effective_system = (effective_system + "\n\n" + self.ephemeral_system_prompt).strip()
+            if self._honcho_turn_context:
+                effective_system = (effective_system + "\n\n" + self._honcho_turn_context).strip()
             if effective_system:
                 api_messages = [{"role": "system", "content": effective_system}] + api_messages
 

skills/autonomous-ai-agents/opencode/SKILL.md

@@ -1,218 +0,0 @@
----
-name: opencode
-description: Delegate coding tasks to OpenCode CLI agent for feature implementation, refactoring, PR review, and long-running autonomous sessions. Requires the opencode CLI installed and authenticated.
-version: 1.2.0
-author: Hermes Agent
-license: MIT
-metadata:
-  hermes:
-    tags: [Coding-Agent, OpenCode, Autonomous, Refactoring, Code-Review]
-    related_skills: [claude-code, codex, hermes-agent]
----
-
-# OpenCode CLI
-
-Use [OpenCode](https://opencode.ai) as an autonomous coding worker orchestrated by Hermes terminal/process tools. OpenCode is a provider-agnostic, open-source AI coding agent with a TUI and CLI.
-
-## When to Use
-
-- User explicitly asks to use OpenCode
-- You want an external coding agent to implement/refactor/review code
-- You need long-running coding sessions with progress checks
-- You want parallel task execution in isolated workdirs/worktrees
-
-## Prerequisites
-
-- OpenCode installed: `npm i -g opencode-ai@latest` or `brew install anomalyco/tap/opencode`
-- Auth configured: `opencode auth login` or set provider env vars (OPENROUTER_API_KEY, etc.)
-- Verify: `opencode auth list` should show at least one provider
-- Git repository for code tasks (recommended)
-- `pty=true` for interactive TUI sessions
-
-## Binary Resolution (Important)
-
-Shell environments may resolve different OpenCode binaries. If behavior differs between your terminal and Hermes, check:
-
-```
-terminal(command="which -a opencode")
-terminal(command="opencode --version")
-```
-
-If needed, pin an explicit binary path:
-
-```
-terminal(command="$HOME/.opencode/bin/opencode run '...'", workdir="~/project", pty=true)
-```
-
-## One-Shot Tasks
-
-Use `opencode run` for bounded, non-interactive tasks:
-
-```
-terminal(command="opencode run 'Add retry logic to API calls and update tests'", workdir="~/project")
-```
-
-Attach context files with `-f`:
-
-```
-terminal(command="opencode run 'Review this config for security issues' -f config.yaml -f .env.example", workdir="~/project")
-```
-
-Show model thinking with `--thinking`:
-
-```
-terminal(command="opencode run 'Debug why tests fail in CI' --thinking", workdir="~/project")
-```
-
-Force a specific model:
-
-```
-terminal(command="opencode run 'Refactor auth module' --model openrouter/anthropic/claude-sonnet-4", workdir="~/project")
-```
-
-## Interactive Sessions (Background)
-
-For iterative work requiring multiple exchanges, start the TUI in background:
-
-```
-terminal(command="opencode", workdir="~/project", background=true, pty=true)
-# Returns session_id
-
-# Send a prompt
-process(action="submit", session_id="<id>", data="Implement OAuth refresh flow and add tests")
-
-# Monitor progress
-process(action="poll", session_id="<id>")
-process(action="log", session_id="<id>")
-
-# Send follow-up input
-process(action="submit", session_id="<id>", data="Now add error handling for token expiry")
-
-# Exit cleanly — Ctrl+C
-process(action="write", session_id="<id>", data="\x03")
-# Or just kill the process
-process(action="kill", session_id="<id>")
-```
-
-**Important:** Do NOT use `/exit` — it is not a valid OpenCode command and will open an agent selector dialog instead. Use Ctrl+C (`\x03`) or `process(action="kill")` to exit.
-
-### TUI Keybindings
-
-| Key | Action |
-|-----|--------|
-| `Enter` | Submit message (press twice if needed) |
-| `Tab` | Switch between agents (build/plan) |
-| `Ctrl+P` | Open command palette |
-| `Ctrl+X L` | Switch session |
-| `Ctrl+X M` | Switch model |
-| `Ctrl+X N` | New session |
-| `Ctrl+X E` | Open editor |
-| `Ctrl+C` | Exit OpenCode |
-
-### Resuming Sessions
-
-After exiting, OpenCode prints a session ID. Resume with:
-
-```
-terminal(command="opencode -c", workdir="~/project", background=true, pty=true)  # Continue last session
-terminal(command="opencode -s ses_abc123", workdir="~/project", background=true, pty=true)  # Specific session
-```
-
-## Common Flags
-
-| Flag | Use |
-|------|-----|
-| `run 'prompt'` | One-shot execution and exit |
-| `--continue` / `-c` | Continue the last OpenCode session |
-| `--session <id>` / `-s` | Continue a specific session |
-| `--agent <name>` | Choose OpenCode agent (build or plan) |
-| `--model provider/model` | Force specific model |
-| `--format json` | Machine-readable output/events |
-| `--file <path>` / `-f` | Attach file(s) to the message |
-| `--thinking` | Show model thinking blocks |
-| `--variant <level>` | Reasoning effort (high, max, minimal) |
-| `--title <name>` | Name the session |
-| `--attach <url>` | Connect to a running opencode server |
-
-## Procedure
-
-1. Verify tool readiness:
-   - `terminal(command="opencode --version")`
-   - `terminal(command="opencode auth list")`
-2. For bounded tasks, use `opencode run '...'` (no pty needed).
-3. For iterative tasks, start `opencode` with `background=true, pty=true`.
-4. Monitor long tasks with `process(action="poll"|"log")`.
-5. If OpenCode asks for input, respond via `process(action="submit", ...)`.
-6. Exit with `process(action="write", data="\x03")` or `process(action="kill")`.
-7. Summarize file changes, test results, and next steps back to user.
-
-## PR Review Workflow
-
-OpenCode has a built-in PR command:
-
-```
-terminal(command="opencode pr 42", workdir="~/project", pty=true)
-```
-
-Or review in a temporary clone for isolation:
-
-```
-terminal(command="REVIEW=$(mktemp -d) && git clone https://github.com/user/repo.git $REVIEW && cd $REVIEW && opencode run 'Review this PR vs main. Report bugs, security risks, test gaps, and style issues.' -f $(git diff origin/main --name-only | head -20 | tr '\n' ' ')", pty=true)
-```
-
-## Parallel Work Pattern
-
-Use separate workdirs/worktrees to avoid collisions:
-
-```
-terminal(command="opencode run 'Fix issue #101 and commit'", workdir="/tmp/issue-101", background=true, pty=true)
-terminal(command="opencode run 'Add parser regression tests and commit'", workdir="/tmp/issue-102", background=true, pty=true)
-process(action="list")
-```
-
-## Session & Cost Management
-
-List past sessions:
-
-```
-terminal(command="opencode session list")
-```
-
-Check token usage and costs:
-
-```
-terminal(command="opencode stats")
-terminal(command="opencode stats --days 7 --models anthropic/claude-sonnet-4")
-```
-
-## Pitfalls
-
-- Interactive `opencode` (TUI) sessions require `pty=true`. The `opencode run` command does NOT need pty.
-- `/exit` is NOT a valid command — it opens an agent selector. Use Ctrl+C to exit the TUI.
-- PATH mismatch can select the wrong OpenCode binary/model config.
-- If OpenCode appears stuck, inspect logs before killing:
-  - `process(action="log", session_id="<id>")`
-- Avoid sharing one working directory across parallel OpenCode sessions.
-- Enter may need to be pressed twice to submit in the TUI (once to finalize text, once to send).
-
-## Verification
-
-Smoke test:
-
-```
-terminal(command="opencode run 'Respond with exactly: OPENCODE_SMOKE_OK'")
-```
-
-Success criteria:
-- Output includes `OPENCODE_SMOKE_OK`
-- Command exits without provider/model errors
-- For code tasks: expected files changed and tests pass
-
-## Rules
-
-1. Prefer `opencode run` for one-shot automation — it's simpler and doesn't need pty.
-2. Use interactive background mode only when iteration is needed.
-3. Always scope OpenCode sessions to a single repo/workdir.
-4. For long tasks, provide progress updates from `process` logs.
-5. Report concrete outcomes (files changed, tests, remaining risks).
-6. Exit interactive sessions with Ctrl+C or kill, never `/exit`.

tests/agent/test_auxiliary_client.py

@@ -129,7 +129,6 @@ class TestGetTextAuxiliaryClient:
     def test_custom_endpoint_over_codex(self, monkeypatch, codex_auth_dir):
         monkeypatch.setenv("OPENAI_BASE_URL", "http://localhost:1234/v1")
         monkeypatch.setenv("OPENAI_API_KEY", "lm-studio-key")
-        monkeypatch.setenv("OPENAI_MODEL", "my-local-model")
         # Override the autouse monkeypatch for codex
         monkeypatch.setattr(
             "agent.auxiliary_client._read_codex_access_token",
@@ -138,7 +137,7 @@ class TestGetTextAuxiliaryClient:
         with patch("agent.auxiliary_client._read_nous_auth", return_value=None), \
              patch("agent.auxiliary_client.OpenAI") as mock_openai:
             client, model = get_text_auxiliary_client()
-        assert model == "my-local-model"
+        assert model == "gpt-4o-mini"
         call_kwargs = mock_openai.call_args
         assert call_kwargs.kwargs["base_url"] == "http://localhost:1234/v1"
 
@@ -151,13 +150,9 @@ class TestGetTextAuxiliaryClient:
         from agent.auxiliary_client import CodexAuxiliaryClient
         assert isinstance(client, CodexAuxiliaryClient)
 
-    def test_returns_none_when_nothing_available(self, monkeypatch):
-        monkeypatch.delenv("OPENAI_BASE_URL", raising=False)
-        monkeypatch.delenv("OPENAI_API_KEY", raising=False)
-        monkeypatch.delenv("OPENROUTER_API_KEY", raising=False)
+    def test_returns_none_when_nothing_available(self):
         with patch("agent.auxiliary_client._read_nous_auth", return_value=None), \
-             patch("agent.auxiliary_client._read_codex_access_token", return_value=None), \
-             patch("agent.auxiliary_client._resolve_api_key_provider", return_value=(None, None)):
+             patch("agent.auxiliary_client._read_codex_access_token", return_value=None):
             client, model = get_text_auxiliary_client()
         assert client is None
         assert model is None
@@ -214,21 +209,17 @@ class TestVisionClientFallback:
         monkeypatch.setenv("AUXILIARY_VISION_PROVIDER", "main")
         monkeypatch.setenv("OPENAI_BASE_URL", "http://localhost:1234/v1")
         monkeypatch.setenv("OPENAI_API_KEY", "local-key")
-        monkeypatch.setenv("OPENAI_MODEL", "my-local-model")
         with patch("agent.auxiliary_client._read_nous_auth", return_value=None), \
              patch("agent.auxiliary_client.OpenAI") as mock_openai:
             client, model = get_vision_auxiliary_client()
         assert client is not None
-        assert model == "my-local-model"
+        assert model == "gpt-4o-mini"
 
     def test_vision_forced_main_returns_none_without_creds(self, monkeypatch):
         """Forced main with no credentials still returns None."""
         monkeypatch.setenv("AUXILIARY_VISION_PROVIDER", "main")
-        monkeypatch.delenv("OPENAI_BASE_URL", raising=False)
-        monkeypatch.delenv("OPENAI_API_KEY", raising=False)
         with patch("agent.auxiliary_client._read_nous_auth", return_value=None), \
-             patch("agent.auxiliary_client._read_codex_access_token", return_value=None), \
-             patch("agent.auxiliary_client._resolve_api_key_provider", return_value=(None, None)):
+             patch("agent.auxiliary_client._read_codex_access_token", return_value=None):
             client, model = get_vision_auxiliary_client()
         assert client is None
         assert model is None
@@ -314,23 +305,21 @@ class TestResolveForcedProvider:
     def test_forced_main_uses_custom(self, monkeypatch):
         monkeypatch.setenv("OPENAI_BASE_URL", "http://local:8080/v1")
         monkeypatch.setenv("OPENAI_API_KEY", "local-key")
-        monkeypatch.setenv("OPENAI_MODEL", "my-local-model")
         with patch("agent.auxiliary_client._read_nous_auth", return_value=None), \
              patch("agent.auxiliary_client.OpenAI") as mock_openai:
             client, model = _resolve_forced_provider("main")
-        assert model == "my-local-model"
+        assert model == "gpt-4o-mini"
 
     def test_forced_main_skips_openrouter_nous(self, monkeypatch):
         """Even if OpenRouter key is set, 'main' skips it."""
         monkeypatch.setenv("OPENROUTER_API_KEY", "or-key")
         monkeypatch.setenv("OPENAI_BASE_URL", "http://local:8080/v1")
         monkeypatch.setenv("OPENAI_API_KEY", "local-key")
-        monkeypatch.setenv("OPENAI_MODEL", "my-local-model")
         with patch("agent.auxiliary_client._read_nous_auth", return_value=None), \
              patch("agent.auxiliary_client.OpenAI") as mock_openai:
             client, model = _resolve_forced_provider("main")
         # Should use custom endpoint, not OpenRouter
-        assert model == "my-local-model"
+        assert model == "gpt-4o-mini"
 
     def test_forced_main_falls_to_codex(self, codex_auth_dir, monkeypatch):
         with patch("agent.auxiliary_client._read_nous_auth", return_value=None), \

tests/agent/test_context_compressor.py

@@ -153,47 +153,6 @@ class TestGenerateSummaryNoneContent:
         assert len(result) < len(msgs)
 
 
-class TestNonStringContent:
-    """Regression: content as dict (e.g., llama.cpp tool calls) must not crash."""
-
-    def test_dict_content_coerced_to_string(self):
-        mock_response = MagicMock()
-        mock_response.choices = [MagicMock()]
-        mock_response.choices[0].message.content = {"text": "some summary"}
-
-        with patch("agent.context_compressor.get_model_context_length", return_value=100000):
-            c = ContextCompressor(model="test", quiet_mode=True)
-
-        messages = [
-            {"role": "user", "content": "do something"},
-            {"role": "assistant", "content": "ok"},
-        ]
-
-        with patch("agent.context_compressor.call_llm", return_value=mock_response):
-            summary = c._generate_summary(messages)
-        assert isinstance(summary, str)
-        assert "CONTEXT SUMMARY" in summary
-
-    def test_none_content_coerced_to_empty(self):
-        mock_response = MagicMock()
-        mock_response.choices = [MagicMock()]
-        mock_response.choices[0].message.content = None
-
-        with patch("agent.context_compressor.get_model_context_length", return_value=100000):
-            c = ContextCompressor(model="test", quiet_mode=True)
-
-        messages = [
-            {"role": "user", "content": "do something"},
-            {"role": "assistant", "content": "ok"},
-        ]
-
-        with patch("agent.context_compressor.call_llm", return_value=mock_response):
-            summary = c._generate_summary(messages)
-        # None content → empty string → "[CONTEXT SUMMARY]: " prefix added
-        assert summary is not None
-        assert "CONTEXT SUMMARY" in summary
-
-
 class TestCompressWithClient:
     def test_summarization_path(self):
         mock_client = MagicMock()

tests/gateway/test_discord_free_response.py

@@ -27,9 +27,6 @@ def _ensure_discord_mock():
     discord_mod.Color = SimpleNamespace(orange=lambda: 1, green=lambda: 2, blue=lambda: 3, red=lambda: 4)
     discord_mod.Interaction = object
     discord_mod.Embed = MagicMock
-    discord_mod.app_commands = SimpleNamespace(
-        describe=lambda **kwargs: (lambda fn: fn),
-    )
 
     ext_mod = MagicMock()
     commands_mod = MagicMock()

tests/gateway/test_discord_media_metadata.py

@@ -1,9 +0,0 @@
-import inspect
-
-from gateway.platforms.discord import DiscordAdapter
-
-
-def test_discord_media_methods_accept_metadata_kwarg():
-    for method_name in ("send_voice", "send_image_file", "send_image"):
-        signature = inspect.signature(getattr(DiscordAdapter, method_name))
-        assert "metadata" in signature.parameters, method_name

tests/gateway/test_discord_slash_commands.py

@@ -1,434 +0,0 @@
-"""Tests for native Discord slash command fast-paths (thread creation & auto-thread)."""
-
-from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock, patch
-import sys
-
-import pytest
-
-from gateway.config import PlatformConfig
-
-
-def _ensure_discord_mock():
-    if "discord" in sys.modules and hasattr(sys.modules["discord"], "__file__"):
-        return
-
-    discord_mod = MagicMock()
-    discord_mod.Intents.default.return_value = MagicMock()
-    discord_mod.DMChannel = type("DMChannel", (), {})
-    discord_mod.Thread = type("Thread", (), {})
-    discord_mod.ForumChannel = type("ForumChannel", (), {})
-    discord_mod.Interaction = object
-    discord_mod.app_commands = SimpleNamespace(
-        describe=lambda **kwargs: (lambda fn: fn),
-    )
-
-    ext_mod = MagicMock()
-    commands_mod = MagicMock()
-    commands_mod.Bot = MagicMock
-    ext_mod.commands = commands_mod
-
-    sys.modules.setdefault("discord", discord_mod)
-    sys.modules.setdefault("discord.ext", ext_mod)
-    sys.modules.setdefault("discord.ext.commands", commands_mod)
-
-
-_ensure_discord_mock()
-
-from gateway.platforms.discord import DiscordAdapter  # noqa: E402
-
-
-class FakeTree:
-    def __init__(self):
-        self.commands = {}
-
-    def command(self, *, name, description):
-        def decorator(fn):
-            self.commands[name] = fn
-            return fn
-
-        return decorator
-
-
-@pytest.fixture
-def adapter():
-    config = PlatformConfig(enabled=True, token="***")
-    adapter = DiscordAdapter(config)
-    adapter._client = SimpleNamespace(
-        tree=FakeTree(),
-        get_channel=lambda _id: None,
-        fetch_channel=AsyncMock(),
-        user=SimpleNamespace(id=99999, name="HermesBot"),
-    )
-    return adapter
-
-
-# ------------------------------------------------------------------
-# /thread slash command registration
-# ------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_registers_native_thread_slash_command(adapter):
-    adapter._handle_thread_create_slash = AsyncMock()
-    adapter._register_slash_commands()
-
-    command = adapter._client.tree.commands["thread"]
-    interaction = SimpleNamespace(
-        response=SimpleNamespace(defer=AsyncMock()),
-    )
-
-    await command(interaction, name="Planning", message="", auto_archive_duration=1440)
-
-    interaction.response.defer.assert_awaited_once_with(ephemeral=True)
-    adapter._handle_thread_create_slash.assert_awaited_once_with(interaction, "Planning", "", 1440)
-
-
-# ------------------------------------------------------------------
-# _handle_thread_create_slash — success, session dispatch, failure
-# ------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_handle_thread_create_slash_reports_success(adapter):
-    created_thread = SimpleNamespace(id=555, name="Planning", send=AsyncMock())
-    parent_channel = SimpleNamespace(create_thread=AsyncMock(return_value=created_thread), send=AsyncMock())
-    interaction_channel = SimpleNamespace(parent=parent_channel)
-    interaction = SimpleNamespace(
-        channel=interaction_channel,
-        channel_id=123,
-        user=SimpleNamespace(display_name="Jezza", id=42),
-        guild=SimpleNamespace(name="TestGuild"),
-        followup=SimpleNamespace(send=AsyncMock()),
-    )
-
-    await adapter._handle_thread_create_slash(interaction, "Planning", "Kickoff", 1440)
-
-    parent_channel.create_thread.assert_awaited_once_with(
-        name="Planning",
-        auto_archive_duration=1440,
-        reason="Requested by Jezza via /thread",
-    )
-    created_thread.send.assert_awaited_once_with("Kickoff")
-    # Thread link shown to user
-    interaction.followup.send.assert_awaited()
-    args, kwargs = interaction.followup.send.await_args
-    assert "<#555>" in args[0]
-    assert kwargs["ephemeral"] is True
-
-
-@pytest.mark.asyncio
-async def test_handle_thread_create_slash_dispatches_session_when_message_provided(adapter):
-    """When a message is given, _dispatch_thread_session should be called."""
-    created_thread = SimpleNamespace(id=555, name="Planning", send=AsyncMock())
-    parent_channel = SimpleNamespace(create_thread=AsyncMock(return_value=created_thread))
-    interaction = SimpleNamespace(
-        channel=SimpleNamespace(parent=parent_channel),
-        channel_id=123,
-        user=SimpleNamespace(display_name="Jezza", id=42),
-        guild=SimpleNamespace(name="TestGuild"),
-        followup=SimpleNamespace(send=AsyncMock()),
-    )
-
-    adapter._dispatch_thread_session = AsyncMock()
-
-    await adapter._handle_thread_create_slash(interaction, "Planning", "Hello Hermes", 1440)
-
-    adapter._dispatch_thread_session.assert_awaited_once_with(
-        interaction, "555", "Planning", "Hello Hermes",
-    )
-
-
-@pytest.mark.asyncio
-async def test_handle_thread_create_slash_no_dispatch_without_message(adapter):
-    """Without a message, no session dispatch should occur."""
-    created_thread = SimpleNamespace(id=555, name="Planning", send=AsyncMock())
-    parent_channel = SimpleNamespace(create_thread=AsyncMock(return_value=created_thread))
-    interaction = SimpleNamespace(
-        channel=SimpleNamespace(parent=parent_channel),
-        channel_id=123,
-        user=SimpleNamespace(display_name="Jezza", id=42),
-        guild=SimpleNamespace(name="TestGuild"),
-        followup=SimpleNamespace(send=AsyncMock()),
-    )
-
-    adapter._dispatch_thread_session = AsyncMock()
-
-    await adapter._handle_thread_create_slash(interaction, "Planning", "", 1440)
-
-    adapter._dispatch_thread_session.assert_not_awaited()
-
-
-@pytest.mark.asyncio
-async def test_handle_thread_create_slash_falls_back_to_seed_message(adapter):
-    created_thread = SimpleNamespace(id=555, name="Planning")
-    seed_message = SimpleNamespace(id=777, create_thread=AsyncMock(return_value=created_thread))
-    channel = SimpleNamespace(
-        create_thread=AsyncMock(side_effect=RuntimeError("direct failed")),
-        send=AsyncMock(return_value=seed_message),
-    )
-    interaction = SimpleNamespace(
-        channel=channel,
-        channel_id=123,
-        user=SimpleNamespace(display_name="Jezza", id=42),
-        guild=SimpleNamespace(name="TestGuild"),
-        followup=SimpleNamespace(send=AsyncMock()),
-    )
-
-    await adapter._handle_thread_create_slash(interaction, "Planning", "Kickoff", 1440)
-
-    channel.send.assert_awaited_once_with("Kickoff")
-    seed_message.create_thread.assert_awaited_once_with(
-        name="Planning",
-        auto_archive_duration=1440,
-        reason="Requested by Jezza via /thread",
-    )
-    interaction.followup.send.assert_awaited()
-
-
-@pytest.mark.asyncio
-async def test_handle_thread_create_slash_reports_failure(adapter):
-    channel = SimpleNamespace(
-        create_thread=AsyncMock(side_effect=RuntimeError("direct failed")),
-        send=AsyncMock(side_effect=RuntimeError("nope")),
-    )
-    interaction = SimpleNamespace(
-        channel=channel,
-        channel_id=123,
-        user=SimpleNamespace(display_name="Jezza", id=42),
-        followup=SimpleNamespace(send=AsyncMock()),
-    )
-
-    await adapter._handle_thread_create_slash(interaction, "Planning", "", 1440)
-
-    interaction.followup.send.assert_awaited_once()
-    args, kwargs = interaction.followup.send.await_args
-    assert "Failed to create thread:" in args[0]
-    assert "nope" in args[0]
-    assert kwargs["ephemeral"] is True
-
-
-# ------------------------------------------------------------------
-# _dispatch_thread_session — builds correct event and routes it
-# ------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_dispatch_thread_session_builds_thread_event(adapter):
-    """Dispatched event should have chat_type=thread and chat_id=thread_id."""
-    interaction = SimpleNamespace(
-        user=SimpleNamespace(display_name="Jezza", id=42),
-        guild=SimpleNamespace(name="TestGuild"),
-    )
-
-    captured_events = []
-
-    async def capture_handle(event):
-        captured_events.append(event)
-
-    adapter.handle_message = capture_handle
-
-    await adapter._dispatch_thread_session(interaction, "555", "Planning", "Hello!")
-
-    assert len(captured_events) == 1
-    event = captured_events[0]
-    assert event.text == "Hello!"
-    assert event.source.chat_id == "555"
-    assert event.source.chat_type == "thread"
-    assert event.source.thread_id == "555"
-    assert "TestGuild" in event.source.chat_name
-
-
-# ------------------------------------------------------------------
-# Auto-thread: _auto_create_thread
-# ------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_auto_create_thread_uses_message_content_as_name(adapter):
-    thread = SimpleNamespace(id=999, name="Hello world")
-    message = SimpleNamespace(
-        content="Hello world, how are you?",
-        create_thread=AsyncMock(return_value=thread),
-    )
-
-    result = await adapter._auto_create_thread(message)
-
-    assert result is thread
-    message.create_thread.assert_awaited_once()
-    call_kwargs = message.create_thread.await_args[1]
-    assert call_kwargs["name"] == "Hello world, how are you?"
-    assert call_kwargs["auto_archive_duration"] == 1440
-
-
-@pytest.mark.asyncio
-async def test_auto_create_thread_truncates_long_names(adapter):
-    long_text = "a" * 200
-    thread = SimpleNamespace(id=999, name="truncated")
-    message = SimpleNamespace(
-        content=long_text,
-        create_thread=AsyncMock(return_value=thread),
-    )
-
-    result = await adapter._auto_create_thread(message)
-
-    assert result is thread
-    call_kwargs = message.create_thread.await_args[1]
-    assert len(call_kwargs["name"]) <= 80
-    assert call_kwargs["name"].endswith("...")
-
-
-@pytest.mark.asyncio
-async def test_auto_create_thread_returns_none_on_failure(adapter):
-    message = SimpleNamespace(
-        content="Hello",
-        create_thread=AsyncMock(side_effect=RuntimeError("no perms")),
-    )
-
-    result = await adapter._auto_create_thread(message)
-    assert result is None
-
-
-# ------------------------------------------------------------------
-# Auto-thread integration in _handle_message
-# ------------------------------------------------------------------
-
-
-import discord as _discord_mod  # noqa: E402 — mock or real, used below
-
-
-class _FakeTextChannel:
-    """A channel that is NOT a discord.Thread or discord.DMChannel."""
-
-    def __init__(self, channel_id=100, name="general", guild_name="TestGuild"):
-        self.id = channel_id
-        self.name = name
-        self.guild = SimpleNamespace(name=guild_name, id=1)
-        self.topic = None
-
-
-class _FakeThreadChannel(_discord_mod.Thread):
-    """isinstance(ch, discord.Thread) → True."""
-
-    def __init__(self, channel_id=200, name="existing-thread", guild_name="TestGuild", parent_id=100):
-        # Don't call super().__init__ — mock Thread is just an empty type
-        self.id = channel_id
-        self.name = name
-        self.guild = SimpleNamespace(name=guild_name, id=1)
-        self.topic = None
-        self.parent = SimpleNamespace(id=parent_id, name="general", guild=SimpleNamespace(name=guild_name, id=1))
-
-
-def _fake_message(channel, *, content="Hello", author_id=42, display_name="Jezza"):
-    return SimpleNamespace(
-        author=SimpleNamespace(id=author_id, display_name=display_name, bot=False),
-        content=content,
-        channel=channel,
-        attachments=[],
-        mentions=[],
-        reference=None,
-        created_at=None,
-        id=12345,
-    )
-
-
-@pytest.mark.asyncio
-async def test_auto_thread_creates_thread_and_redirects(adapter, monkeypatch):
-    """When DISCORD_AUTO_THREAD=true, a new thread is created and the event routes there."""
-    monkeypatch.setenv("DISCORD_AUTO_THREAD", "true")
-    monkeypatch.setenv("DISCORD_REQUIRE_MENTION", "false")
-
-    thread = SimpleNamespace(id=999, name="Hello")
-    adapter._auto_create_thread = AsyncMock(return_value=thread)
-
-    captured_events = []
-
-    async def capture_handle(event):
-        captured_events.append(event)
-
-    adapter.handle_message = capture_handle
-
-    msg = _fake_message(_FakeTextChannel(), content="Hello world")
-
-    await adapter._handle_message(msg)
-
-    adapter._auto_create_thread.assert_awaited_once_with(msg)
-    assert len(captured_events) == 1
-    event = captured_events[0]
-    assert event.source.chat_id == "999"  # redirected to thread
-    assert event.source.chat_type == "thread"
-    assert event.source.thread_id == "999"
-
-
-@pytest.mark.asyncio
-async def test_auto_thread_disabled_by_default(adapter, monkeypatch):
-    """Without DISCORD_AUTO_THREAD, messages stay in the channel."""
-    monkeypatch.delenv("DISCORD_AUTO_THREAD", raising=False)
-    monkeypatch.setenv("DISCORD_REQUIRE_MENTION", "false")
-
-    adapter._auto_create_thread = AsyncMock()
-
-    captured_events = []
-
-    async def capture_handle(event):
-        captured_events.append(event)
-
-    adapter.handle_message = capture_handle
-
-    msg = _fake_message(_FakeTextChannel())
-
-    await adapter._handle_message(msg)
-
-    adapter._auto_create_thread.assert_not_awaited()
-    assert len(captured_events) == 1
-    assert captured_events[0].source.chat_id == "100"  # stays in channel
-
-
-@pytest.mark.asyncio
-async def test_auto_thread_skips_threads_and_dms(adapter, monkeypatch):
-    """Auto-thread should not create threads inside existing threads."""
-    monkeypatch.setenv("DISCORD_AUTO_THREAD", "true")
-    monkeypatch.setenv("DISCORD_REQUIRE_MENTION", "false")
-
-    adapter._auto_create_thread = AsyncMock()
-
-    captured_events = []
-
-    async def capture_handle(event):
-        captured_events.append(event)
-
-    adapter.handle_message = capture_handle
-
-    msg = _fake_message(_FakeThreadChannel())
-
-    await adapter._handle_message(msg)
-
-    adapter._auto_create_thread.assert_not_awaited()  # should NOT auto-thread
-
-
-# ------------------------------------------------------------------
-# Config bridge
-# ------------------------------------------------------------------
-
-
-def test_discord_auto_thread_config_bridge(monkeypatch, tmp_path):
-    """discord.auto_thread in config.yaml should be bridged to DISCORD_AUTO_THREAD env var."""
-    import yaml
-    from pathlib import Path
-
-    # Write a config.yaml the loader will find
-    hermes_dir = tmp_path / ".hermes"
-    hermes_dir.mkdir()
-    config_path = hermes_dir / "config.yaml"
-    config_path.write_text(yaml.dump({
-        "discord": {"auto_thread": True},
-    }))
-
-    monkeypatch.delenv("DISCORD_AUTO_THREAD", raising=False)
-    monkeypatch.setattr(Path, "home", lambda: tmp_path)
-
-    from gateway.config import load_gateway_config
-    load_gateway_config()
-
-    import os
-    assert os.getenv("DISCORD_AUTO_THREAD") == "true"

tests/gateway/test_homeassistant.py

@@ -208,7 +208,7 @@ class TestAdapterInit:
 
     def test_watch_filters_parsed(self):
         config = PlatformConfig(
-            enabled=True, token="***",
+            enabled=True, token="t",
             extra={
                 "watch_domains": ["climate", "binary_sensor"],
                 "watch_entities": ["sensor.special"],
@@ -220,25 +220,15 @@ class TestAdapterInit:
         assert adapter._watch_domains == {"climate", "binary_sensor"}
         assert adapter._watch_entities == {"sensor.special"}
         assert adapter._ignore_entities == {"sensor.uptime", "sensor.cpu"}
-        assert adapter._watch_all is False
         assert adapter._cooldown_seconds == 120
 
-    def test_watch_all_parsed(self):
-        config = PlatformConfig(
-            enabled=True, token="***",
-            extra={"watch_all": True},
-        )
-        adapter = HomeAssistantAdapter(config)
-        assert adapter._watch_all is True
-
     def test_defaults_when_no_extra(self, monkeypatch):
         monkeypatch.setenv("HASS_TOKEN", "tok")
-        config = PlatformConfig(enabled=True, token="***")
+        config = PlatformConfig(enabled=True, token="tok")
         adapter = HomeAssistantAdapter(config)
         assert adapter._watch_domains == set()
         assert adapter._watch_entities == set()
         assert adapter._ignore_entities == set()
-        assert adapter._watch_all is False
         assert adapter._cooldown_seconds == 30
 
 
@@ -270,7 +260,7 @@ def _make_event(entity_id, old_state, new_state, old_attrs=None, new_attrs=None)
 class TestEventFilteringPipeline:
     @pytest.mark.asyncio
     async def test_ignored_entity_not_forwarded(self):
-        adapter = _make_adapter(watch_all=True, ignore_entities=["sensor.uptime"])
+        adapter = _make_adapter(ignore_entities=["sensor.uptime"])
         await adapter._handle_ha_event(_make_event("sensor.uptime", "100", "101"))
         adapter.handle_message.assert_not_called()
 
@@ -308,34 +298,26 @@ class TestEventFilteringPipeline:
         assert "10W" in msg_event.text and "20W" in msg_event.text
 
     @pytest.mark.asyncio
-    async def test_no_filters_blocks_everything(self):
-        """Without watch_domains, watch_entities, or watch_all, events are dropped."""
+    async def test_no_filters_passes_everything(self):
         adapter = _make_adapter(cooldown_seconds=0)
         await adapter._handle_ha_event(_make_event("cover.blinds", "closed", "open"))
-        adapter.handle_message.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_watch_all_passes_everything(self):
-        """With watch_all=True and no specific filters, all events pass through."""
-        adapter = _make_adapter(watch_all=True, cooldown_seconds=0)
-        await adapter._handle_ha_event(_make_event("cover.blinds", "closed", "open"))
         adapter.handle_message.assert_called_once()
 
     @pytest.mark.asyncio
     async def test_same_state_not_forwarded(self):
-        adapter = _make_adapter(watch_all=True, cooldown_seconds=0)
+        adapter = _make_adapter(cooldown_seconds=0)
         await adapter._handle_ha_event(_make_event("light.x", "on", "on"))
         adapter.handle_message.assert_not_called()
 
     @pytest.mark.asyncio
     async def test_empty_entity_id_skipped(self):
-        adapter = _make_adapter(watch_all=True)
+        adapter = _make_adapter()
         await adapter._handle_ha_event({"data": {"entity_id": ""}})
         adapter.handle_message.assert_not_called()
 
     @pytest.mark.asyncio
     async def test_message_event_has_correct_source(self):
-        adapter = _make_adapter(watch_all=True, cooldown_seconds=0)
+        adapter = _make_adapter(cooldown_seconds=0)
         await adapter._handle_ha_event(
             _make_event("light.test", "off", "on",
                         new_attrs={"friendly_name": "Test Light"})
@@ -354,7 +336,7 @@ class TestEventFilteringPipeline:
 class TestCooldown:
     @pytest.mark.asyncio
     async def test_cooldown_blocks_rapid_events(self):
-        adapter = _make_adapter(watch_all=True, cooldown_seconds=60)
+        adapter = _make_adapter(cooldown_seconds=60)
 
         event = _make_event("sensor.temp", "20", "21",
                             new_attrs={"friendly_name": "Temp"})
@@ -369,7 +351,7 @@ class TestCooldown:
 
     @pytest.mark.asyncio
     async def test_cooldown_expires(self):
-        adapter = _make_adapter(watch_all=True, cooldown_seconds=1)
+        adapter = _make_adapter(cooldown_seconds=1)
 
         event = _make_event("sensor.temp", "20", "21",
                             new_attrs={"friendly_name": "Temp"})
@@ -386,7 +368,7 @@ class TestCooldown:
 
     @pytest.mark.asyncio
     async def test_different_entities_independent_cooldowns(self):
-        adapter = _make_adapter(watch_all=True, cooldown_seconds=60)
+        adapter = _make_adapter(cooldown_seconds=60)
 
         await adapter._handle_ha_event(
             _make_event("sensor.a", "1", "2", new_attrs={"friendly_name": "A"})
@@ -405,7 +387,7 @@ class TestCooldown:
 
     @pytest.mark.asyncio
     async def test_zero_cooldown_passes_all(self):
-        adapter = _make_adapter(watch_all=True, cooldown_seconds=0)
+        adapter = _make_adapter(cooldown_seconds=0)
 
         for i in range(5):
             await adapter._handle_ha_event(

tests/gateway/test_session.py

@@ -182,7 +182,7 @@ class TestBuildSessionContextPrompt:
             platforms={
                 Platform.DISCORD: PlatformConfig(
                     enabled=True,
-                    token="fake-d...oken",
+                    token="fake-discord-token",
                 ),
             },
         )
@@ -197,27 +197,6 @@ class TestBuildSessionContextPrompt:
         prompt = build_session_context_prompt(ctx)
 
         assert "Discord" in prompt
-        assert "cannot search" in prompt.lower() or "do not have access" in prompt.lower()
-
-    def test_slack_prompt_includes_platform_notes(self):
-        config = GatewayConfig(
-            platforms={
-                Platform.SLACK: PlatformConfig(enabled=True, token="fake"),
-            },
-        )
-        source = SessionSource(
-            platform=Platform.SLACK,
-            chat_id="C123",
-            chat_name="general",
-            chat_type="group",
-            user_name="bob",
-        )
-        ctx = build_session_context(source, config)
-        prompt = build_session_context_prompt(ctx)
-
-        assert "Slack" in prompt
-        assert "cannot search" in prompt.lower()
-        assert "pin" in prompt.lower()
 
     def test_discord_prompt_with_channel_topic(self):
         """Channel topic should appear in the session context prompt."""

tests/hermes_cli/test_doctor.py

@@ -1,21 +1,14 @@
-"""Tests for hermes_cli.doctor."""
+"""Tests for hermes doctor helpers."""
 
-import os
-import sys
-import types
-from argparse import Namespace
 from types import SimpleNamespace
 
-import pytest
-
 import hermes_cli.doctor as doctor
-from hermes_cli import doctor as doctor_mod
 from hermes_cli.doctor import _has_provider_env_config
 
 
 class TestProviderEnvDetection:
     def test_detects_openai_api_key(self):
-        content = "OPENAI_BASE_URL=http://localhost:1234/v1\nOPENAI_API_KEY=***"
+        content = "OPENAI_BASE_URL=http://localhost:1234/v1\nOPENAI_API_KEY=sk-test-key\n"
         assert _has_provider_env_config(content)
 
     def test_detects_custom_endpoint_without_openrouter_key(self):
@@ -54,7 +47,7 @@ class TestDoctorToolAvailabilityOverrides:
 
 class TestHonchoDoctorConfigDetection:
     def test_reports_configured_when_enabled_with_api_key(self, monkeypatch):
-        fake_config = SimpleNamespace(enabled=True, api_key="***")
+        fake_config = SimpleNamespace(enabled=True, api_key="honcho-test-key")
 
         monkeypatch.setattr(
             "honcho_integration.client.HonchoClientConfig.from_global_config",
@@ -64,7 +57,7 @@ class TestHonchoDoctorConfigDetection:
         assert doctor._honcho_is_configured_for_doctor()
 
     def test_reports_not_configured_without_api_key(self, monkeypatch):
-        fake_config = SimpleNamespace(enabled=True, api_key="")
+        fake_config = SimpleNamespace(enabled=True, api_key=None)
 
         monkeypatch.setattr(
             "honcho_integration.client.HonchoClientConfig.from_global_config",
@@ -72,32 +65,3 @@ class TestHonchoDoctorConfigDetection:
         )
 
         assert not doctor._honcho_is_configured_for_doctor()
-
-
-def test_run_doctor_sets_interactive_env_for_tool_checks(monkeypatch, tmp_path):
-    """Doctor should present CLI-gated tools as available in CLI context."""
-    project_root = tmp_path / "project"
-    hermes_home = tmp_path / ".hermes"
-    project_root.mkdir()
-    hermes_home.mkdir()
-
-    monkeypatch.setattr(doctor_mod, "PROJECT_ROOT", project_root)
-    monkeypatch.setattr(doctor_mod, "HERMES_HOME", hermes_home)
-    monkeypatch.delenv("HERMES_INTERACTIVE", raising=False)
-
-    seen = {}
-
-    def fake_check_tool_availability(*args, **kwargs):
-        seen["interactive"] = os.getenv("HERMES_INTERACTIVE")
-        raise SystemExit(0)
-
-    fake_model_tools = types.SimpleNamespace(
-        check_tool_availability=fake_check_tool_availability,
-        TOOLSET_REQUIREMENTS={},
-    )
-    monkeypatch.setitem(sys.modules, "model_tools", fake_model_tools)
-
-    with pytest.raises(SystemExit):
-        doctor_mod.run_doctor(Namespace(fix=False))
-
-    assert seen["interactive"] == "1"

tests/test_run_agent.py

@@ -14,7 +14,7 @@ from unittest.mock import MagicMock, patch
 import pytest
 
 from honcho_integration.client import HonchoClientConfig
-from run_agent import AIAgent, _inject_honcho_turn_context
+from run_agent import AIAgent
 from agent.prompt_builder import DEFAULT_AGENT_IDENTITY
 
 
@@ -1441,53 +1441,6 @@ class TestSystemPromptStability:
         should_prefetch = bool(conversation_history) and recall_mode != "tools"
         assert should_prefetch is True
 
-    def test_inject_honcho_turn_context_appends_system_note(self):
-        content = _inject_honcho_turn_context("hello", "## Honcho Memory\nprior context")
-        assert "hello" in content
-        assert "Honcho memory was retrieved from prior sessions" in content
-        assert "## Honcho Memory" in content
-
-    def test_honcho_continuing_session_keeps_turn_context_out_of_system_prompt(self, agent):
-        captured = {}
-
-        def _fake_api_call(api_kwargs):
-            captured.update(api_kwargs)
-            return _mock_response(content="done", finish_reason="stop")
-
-        agent._honcho = object()
-        agent._honcho_session_key = "session-1"
-        agent._honcho_config = SimpleNamespace(
-            ai_peer="hermes",
-            memory_mode="hybrid",
-            write_frequency="async",
-            recall_mode="hybrid",
-        )
-        agent._use_prompt_caching = False
-        conversation_history = [
-            {"role": "user", "content": "hello"},
-            {"role": "assistant", "content": "hi there"},
-        ]
-
-        with (
-            patch.object(agent, "_honcho_prefetch", return_value="## Honcho Memory\nprior context"),
-            patch.object(agent, "_queue_honcho_prefetch"),
-            patch.object(agent, "_persist_session"),
-            patch.object(agent, "_save_trajectory"),
-            patch.object(agent, "_cleanup_task_resources"),
-            patch.object(agent, "_interruptible_api_call", side_effect=_fake_api_call),
-        ):
-            result = agent.run_conversation("what were we doing?", conversation_history=conversation_history)
-
-        assert result["completed"] is True
-        api_messages = captured["messages"]
-        assert api_messages[0]["role"] == "system"
-        assert "prior context" not in api_messages[0]["content"]
-        current_user = api_messages[-1]
-        assert current_user["role"] == "user"
-        assert "what were we doing?" in current_user["content"]
-        assert "prior context" in current_user["content"]
-        assert "Honcho memory was retrieved from prior sessions" in current_user["content"]
-
     def test_honcho_prefetch_runs_on_first_turn(self):
         """Honcho prefetch should run when conversation_history is empty."""
         conversation_history = []

tests/tools/test_delegate.py

@@ -246,169 +246,6 @@ class TestDelegateTask(unittest.TestCase):
             self.assertEqual(kwargs["api_mode"], parent.api_mode)
 
 
-class TestDelegateObservability(unittest.TestCase):
-    """Tests for enriched metadata returned by _run_single_child."""
-
-    def test_observability_fields_present(self):
-        """Completed child should return tool_trace, tokens, model, exit_reason."""
-        parent = _make_mock_parent(depth=0)
-
-        with patch("run_agent.AIAgent") as MockAgent:
-            mock_child = MagicMock()
-            mock_child.model = "claude-sonnet-4-6"
-            mock_child.session_prompt_tokens = 5000
-            mock_child.session_completion_tokens = 1200
-            mock_child.run_conversation.return_value = {
-                "final_response": "done",
-                "completed": True,
-                "interrupted": False,
-                "api_calls": 3,
-                "messages": [
-                    {"role": "user", "content": "do something"},
-                    {"role": "assistant", "tool_calls": [
-                        {"id": "tc_1", "function": {"name": "web_search", "arguments": '{"query": "test"}'}}
-                    ]},
-                    {"role": "tool", "tool_call_id": "tc_1", "content": '{"results": [1,2,3]}'},
-                    {"role": "assistant", "content": "done"},
-                ],
-            }
-            MockAgent.return_value = mock_child
-
-            result = json.loads(delegate_task(goal="Test observability", parent_agent=parent))
-            entry = result["results"][0]
-
-            # Core observability fields
-            self.assertEqual(entry["model"], "claude-sonnet-4-6")
-            self.assertEqual(entry["exit_reason"], "completed")
-            self.assertEqual(entry["tokens"]["input"], 5000)
-            self.assertEqual(entry["tokens"]["output"], 1200)
-
-            # Tool trace
-            self.assertEqual(len(entry["tool_trace"]), 1)
-            self.assertEqual(entry["tool_trace"][0]["tool"], "web_search")
-            self.assertIn("args_bytes", entry["tool_trace"][0])
-            self.assertIn("result_bytes", entry["tool_trace"][0])
-            self.assertEqual(entry["tool_trace"][0]["status"], "ok")
-
-    def test_tool_trace_detects_error(self):
-        """Tool results containing 'error' should be marked as error status."""
-        parent = _make_mock_parent(depth=0)
-
-        with patch("run_agent.AIAgent") as MockAgent:
-            mock_child = MagicMock()
-            mock_child.model = "claude-sonnet-4-6"
-            mock_child.session_prompt_tokens = 0
-            mock_child.session_completion_tokens = 0
-            mock_child.run_conversation.return_value = {
-                "final_response": "failed",
-                "completed": True,
-                "interrupted": False,
-                "api_calls": 1,
-                "messages": [
-                    {"role": "assistant", "tool_calls": [
-                        {"id": "tc_1", "function": {"name": "terminal", "arguments": '{"cmd": "ls"}'}}
-                    ]},
-                    {"role": "tool", "tool_call_id": "tc_1", "content": "Error: command not found"},
-                ],
-            }
-            MockAgent.return_value = mock_child
-
-            result = json.loads(delegate_task(goal="Test error trace", parent_agent=parent))
-            trace = result["results"][0]["tool_trace"]
-            self.assertEqual(trace[0]["status"], "error")
-
-    def test_parallel_tool_calls_paired_correctly(self):
-        """Parallel tool calls should each get their own result via tool_call_id matching."""
-        parent = _make_mock_parent(depth=0)
-
-        with patch("run_agent.AIAgent") as MockAgent:
-            mock_child = MagicMock()
-            mock_child.model = "claude-sonnet-4-6"
-            mock_child.session_prompt_tokens = 3000
-            mock_child.session_completion_tokens = 800
-            mock_child.run_conversation.return_value = {
-                "final_response": "done",
-                "completed": True,
-                "interrupted": False,
-                "api_calls": 1,
-                "messages": [
-                    {"role": "assistant", "tool_calls": [
-                        {"id": "tc_a", "function": {"name": "web_search", "arguments": '{"q": "a"}'}},
-                        {"id": "tc_b", "function": {"name": "web_search", "arguments": '{"q": "b"}'}},
-                        {"id": "tc_c", "function": {"name": "terminal", "arguments": '{"cmd": "ls"}'}},
-                    ]},
-                    {"role": "tool", "tool_call_id": "tc_a", "content": '{"ok": true}'},
-                    {"role": "tool", "tool_call_id": "tc_b", "content": "Error: rate limited"},
-                    {"role": "tool", "tool_call_id": "tc_c", "content": "file1.txt\nfile2.txt"},
-                    {"role": "assistant", "content": "done"},
-                ],
-            }
-            MockAgent.return_value = mock_child
-
-            result = json.loads(delegate_task(goal="Test parallel", parent_agent=parent))
-            trace = result["results"][0]["tool_trace"]
-
-            # All three tool calls should have results
-            self.assertEqual(len(trace), 3)
-
-            # First: web_search → ok
-            self.assertEqual(trace[0]["tool"], "web_search")
-            self.assertEqual(trace[0]["status"], "ok")
-            self.assertIn("result_bytes", trace[0])
-
-            # Second: web_search → error
-            self.assertEqual(trace[1]["tool"], "web_search")
-            self.assertEqual(trace[1]["status"], "error")
-            self.assertIn("result_bytes", trace[1])
-
-            # Third: terminal → ok
-            self.assertEqual(trace[2]["tool"], "terminal")
-            self.assertEqual(trace[2]["status"], "ok")
-            self.assertIn("result_bytes", trace[2])
-
-    def test_exit_reason_interrupted(self):
-        """Interrupted child should report exit_reason='interrupted'."""
-        parent = _make_mock_parent(depth=0)
-
-        with patch("run_agent.AIAgent") as MockAgent:
-            mock_child = MagicMock()
-            mock_child.model = "claude-sonnet-4-6"
-            mock_child.session_prompt_tokens = 0
-            mock_child.session_completion_tokens = 0
-            mock_child.run_conversation.return_value = {
-                "final_response": "",
-                "completed": False,
-                "interrupted": True,
-                "api_calls": 2,
-                "messages": [],
-            }
-            MockAgent.return_value = mock_child
-
-            result = json.loads(delegate_task(goal="Test interrupt", parent_agent=parent))
-            self.assertEqual(result["results"][0]["exit_reason"], "interrupted")
-
-    def test_exit_reason_max_iterations(self):
-        """Child that didn't complete and wasn't interrupted hit max_iterations."""
-        parent = _make_mock_parent(depth=0)
-
-        with patch("run_agent.AIAgent") as MockAgent:
-            mock_child = MagicMock()
-            mock_child.model = "claude-sonnet-4-6"
-            mock_child.session_prompt_tokens = 0
-            mock_child.session_completion_tokens = 0
-            mock_child.run_conversation.return_value = {
-                "final_response": "",
-                "completed": False,
-                "interrupted": False,
-                "api_calls": 50,
-                "messages": [],
-            }
-            MockAgent.return_value = mock_child
-
-            result = json.loads(delegate_task(goal="Test max iter", parent_agent=parent))
-            self.assertEqual(result["results"][0]["exit_reason"], "max_iterations")
-
-
 class TestBlockedTools(unittest.TestCase):
     def test_blocked_tools_constant(self):
         for tool in ["delegate_task", "clarify", "memory", "send_message", "execute_code"]:

tests/tools/test_local_env_blocklist.py

@@ -1,173 +0,0 @@
-"""Tests for provider env var blocklist in LocalEnvironment.
-
-Verifies that Hermes-internal provider env vars (OPENAI_BASE_URL, etc.)
-are stripped from subprocess environments so external CLIs are not
-silently misrouted.
-
-See: https://github.com/NousResearch/hermes-agent/issues/1002
-"""
-
-import os
-import threading
-from unittest.mock import MagicMock, patch
-
-from tools.environments.local import (
-    LocalEnvironment,
-    _HERMES_PROVIDER_ENV_BLOCKLIST,
-    _HERMES_PROVIDER_ENV_FORCE_PREFIX,
-)
-
-
-def _make_fake_popen(captured: dict):
-    """Return a fake Popen constructor that records the env kwarg."""
-    def fake_popen(cmd, **kwargs):
-        captured["env"] = kwargs.get("env", {})
-        proc = MagicMock()
-        proc.poll.return_value = 0
-        proc.returncode = 0
-        proc.stdout = iter([])
-        proc.stdout.close = lambda: None
-        proc.stdin = MagicMock()
-        return proc
-    return fake_popen
-
-
-def _run_with_env(extra_os_env=None, self_env=None):
-    """Execute a command via LocalEnvironment with mocked Popen
-    and return the env dict passed to the subprocess."""
-    captured = {}
-    fake_interrupt = threading.Event()
-    test_environ = {
-        "PATH": "/usr/bin:/bin",
-        "HOME": "/home/user",
-        "USER": "testuser",
-    }
-    if extra_os_env:
-        test_environ.update(extra_os_env)
-
-    env = LocalEnvironment(cwd="/tmp", timeout=10, env=self_env)
-
-    with patch("tools.environments.local._find_bash", return_value="/bin/bash"), \
-         patch("subprocess.Popen", side_effect=_make_fake_popen(captured)), \
-         patch("tools.terminal_tool._interrupt_event", fake_interrupt), \
-         patch.dict(os.environ, test_environ, clear=True):
-        env.execute("echo hello")
-
-    return captured.get("env", {})
-
-
-class TestProviderEnvBlocklist:
-    """Provider env vars loaded from ~/.hermes/.env must not leak."""
-
-    def test_blocked_vars_are_stripped(self):
-        """OPENAI_BASE_URL and other provider vars must not appear in subprocess env."""
-        leaked_vars = {
-            "OPENAI_BASE_URL": "http://localhost:8000/v1",
-            "OPENAI_API_KEY": "sk-fake-key",
-            "OPENROUTER_API_KEY": "or-fake-key",
-            "ANTHROPIC_API_KEY": "ant-fake-key",
-            "LLM_MODEL": "anthropic/claude-opus-4-6",
-        }
-        result_env = _run_with_env(extra_os_env=leaked_vars)
-
-        for var in leaked_vars:
-            assert var not in result_env, f"{var} leaked into subprocess env"
-
-    def test_registry_derived_vars_are_stripped(self):
-        """Vars from the provider registry (ANTHROPIC_TOKEN, ZAI_API_KEY, etc.)
-        must also be blocked — not just the hand-written extras."""
-        registry_vars = {
-            "ANTHROPIC_TOKEN": "ant-tok",
-            "CLAUDE_CODE_OAUTH_TOKEN": "cc-tok",
-            "ZAI_API_KEY": "zai-key",
-            "Z_AI_API_KEY": "z-ai-key",
-            "GLM_API_KEY": "glm-key",
-            "KIMI_API_KEY": "kimi-key",
-            "MINIMAX_API_KEY": "mm-key",
-            "MINIMAX_CN_API_KEY": "mmcn-key",
-        }
-        result_env = _run_with_env(extra_os_env=registry_vars)
-
-        for var in registry_vars:
-            assert var not in result_env, f"{var} leaked into subprocess env"
-
-    def test_safe_vars_are_preserved(self):
-        """Standard env vars (PATH, HOME, USER) must still be passed through."""
-        result_env = _run_with_env()
-
-        assert "HOME" in result_env
-        assert result_env["HOME"] == "/home/user"
-        assert "USER" in result_env
-        assert "PATH" in result_env
-
-    def test_self_env_blocked_vars_also_stripped(self):
-        """Blocked vars in self.env are stripped; non-blocked vars pass through."""
-        result_env = _run_with_env(self_env={
-            "OPENAI_BASE_URL": "http://custom:9999/v1",
-            "MY_CUSTOM_VAR": "keep-this",
-        })
-
-        assert "OPENAI_BASE_URL" not in result_env
-        assert "MY_CUSTOM_VAR" in result_env
-        assert result_env["MY_CUSTOM_VAR"] == "keep-this"
-
-
-class TestForceEnvOptIn:
-    """Callers can opt in to passing a blocked var via _HERMES_FORCE_ prefix."""
-
-    def test_force_prefix_passes_blocked_var(self):
-        """_HERMES_FORCE_OPENAI_API_KEY in self.env should inject OPENAI_API_KEY."""
-        result_env = _run_with_env(self_env={
-            f"{_HERMES_PROVIDER_ENV_FORCE_PREFIX}OPENAI_API_KEY": "sk-explicit",
-        })
-
-        assert "OPENAI_API_KEY" in result_env
-        assert result_env["OPENAI_API_KEY"] == "sk-explicit"
-        # The force-prefixed key itself must not appear
-        assert f"{_HERMES_PROVIDER_ENV_FORCE_PREFIX}OPENAI_API_KEY" not in result_env
-
-    def test_force_prefix_overrides_os_environ_block(self):
-        """Force-prefix in self.env wins even when os.environ has the blocked var."""
-        result_env = _run_with_env(
-            extra_os_env={"OPENAI_BASE_URL": "http://leaked/v1"},
-            self_env={f"{_HERMES_PROVIDER_ENV_FORCE_PREFIX}OPENAI_BASE_URL": "http://intended/v1"},
-        )
-
-        assert result_env["OPENAI_BASE_URL"] == "http://intended/v1"
-
-
-class TestBlocklistCoverage:
-    """Sanity checks that the blocklist covers all known providers."""
-
-    def test_issue_1002_offenders(self):
-        """Blocklist includes the main offenders from issue #1002."""
-        must_block = {
-            "OPENAI_BASE_URL",
-            "OPENAI_API_KEY",
-            "OPENROUTER_API_KEY",
-            "ANTHROPIC_API_KEY",
-            "LLM_MODEL",
-        }
-        assert must_block.issubset(_HERMES_PROVIDER_ENV_BLOCKLIST)
-
-    def test_registry_vars_are_in_blocklist(self):
-        """Every api_key_env_var and base_url_env_var from PROVIDER_REGISTRY
-        must appear in the blocklist — ensures no drift."""
-        from hermes_cli.auth import PROVIDER_REGISTRY
-
-        for pconfig in PROVIDER_REGISTRY.values():
-            for var in pconfig.api_key_env_vars:
-                assert var in _HERMES_PROVIDER_ENV_BLOCKLIST, (
-                    f"Registry var {var} (provider={pconfig.id}) missing from blocklist"
-                )
-            if pconfig.base_url_env_var:
-                assert pconfig.base_url_env_var in _HERMES_PROVIDER_ENV_BLOCKLIST, (
-                    f"Registry base_url_env_var {pconfig.base_url_env_var} "
-                    f"(provider={pconfig.id}) missing from blocklist"
-                )
-
-    def test_extra_auth_vars_covered(self):
-        """Non-registry auth vars (ANTHROPIC_TOKEN, CLAUDE_CODE_OAUTH_TOKEN)
-        must also be in the blocklist."""
-        extras = {"ANTHROPIC_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN"}
-        assert extras.issubset(_HERMES_PROVIDER_ENV_BLOCKLIST)

tests/tools/test_transcription.py

@@ -1,223 +0,0 @@
-"""Tests for transcription_tools.py — local (faster-whisper) and OpenAI providers.
-
-Tests cover provider selection, config loading, validation, and transcription
-dispatch.  All external dependencies (faster_whisper, openai) are mocked.
-"""
-
-import json
-import os
-import tempfile
-from pathlib import Path
-from unittest.mock import MagicMock, patch, mock_open
-
-import pytest
-
-
-# ---------------------------------------------------------------------------
-# Provider selection
-# ---------------------------------------------------------------------------
-
-
-class TestGetProvider:
-    """_get_provider() picks the right backend based on config + availability."""
-
-    def test_local_when_available(self):
-        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", True):
-            from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "local"}) == "local"
-
-    def test_local_fallback_to_openai(self, monkeypatch):
-        monkeypatch.setenv("VOICE_TOOLS_OPENAI_KEY", "sk-test")
-        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
-             patch("tools.transcription_tools._HAS_OPENAI", True):
-            from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "local"}) == "openai"
-
-    def test_local_nothing_available(self, monkeypatch):
-        monkeypatch.delenv("VOICE_TOOLS_OPENAI_KEY", raising=False)
-        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False), \
-             patch("tools.transcription_tools._HAS_OPENAI", False):
-            from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "local"}) == "none"
-
-    def test_openai_when_key_set(self, monkeypatch):
-        monkeypatch.setenv("VOICE_TOOLS_OPENAI_KEY", "sk-test")
-        with patch("tools.transcription_tools._HAS_OPENAI", True):
-            from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "openai"}) == "openai"
-
-    def test_openai_fallback_to_local(self, monkeypatch):
-        monkeypatch.delenv("VOICE_TOOLS_OPENAI_KEY", raising=False)
-        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", True), \
-             patch("tools.transcription_tools._HAS_OPENAI", True):
-            from tools.transcription_tools import _get_provider
-            assert _get_provider({"provider": "openai"}) == "local"
-
-    def test_default_provider_is_local(self):
-        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", True):
-            from tools.transcription_tools import _get_provider
-            assert _get_provider({}) == "local"
-
-
-# ---------------------------------------------------------------------------
-# File validation
-# ---------------------------------------------------------------------------
-
-
-class TestValidateAudioFile:
-
-    def test_missing_file(self, tmp_path):
-        from tools.transcription_tools import _validate_audio_file
-        result = _validate_audio_file(str(tmp_path / "nope.ogg"))
-        assert result is not None
-        assert "not found" in result["error"]
-
-    def test_unsupported_format(self, tmp_path):
-        f = tmp_path / "test.xyz"
-        f.write_bytes(b"data")
-        from tools.transcription_tools import _validate_audio_file
-        result = _validate_audio_file(str(f))
-        assert result is not None
-        assert "Unsupported" in result["error"]
-
-    def test_valid_file_returns_none(self, tmp_path):
-        f = tmp_path / "test.ogg"
-        f.write_bytes(b"fake audio data")
-        from tools.transcription_tools import _validate_audio_file
-        assert _validate_audio_file(str(f)) is None
-
-    def test_too_large(self, tmp_path):
-        import stat as stat_mod
-        f = tmp_path / "big.ogg"
-        f.write_bytes(b"x")
-        from tools.transcription_tools import _validate_audio_file, MAX_FILE_SIZE
-        real_stat = f.stat()
-        with patch.object(type(f), "stat", return_value=os.stat_result((
-            real_stat.st_mode, real_stat.st_ino, real_stat.st_dev,
-            real_stat.st_nlink, real_stat.st_uid, real_stat.st_gid,
-            MAX_FILE_SIZE + 1,  # st_size
-            real_stat.st_atime, real_stat.st_mtime, real_stat.st_ctime,
-        ))):
-            result = _validate_audio_file(str(f))
-        assert result is not None
-        assert "too large" in result["error"]
-
-
-# ---------------------------------------------------------------------------
-# Local transcription
-# ---------------------------------------------------------------------------
-
-
-class TestTranscribeLocal:
-
-    def test_successful_transcription(self, tmp_path):
-        audio_file = tmp_path / "test.ogg"
-        audio_file.write_bytes(b"fake audio")
-
-        mock_segment = MagicMock()
-        mock_segment.text = "Hello world"
-        mock_info = MagicMock()
-        mock_info.language = "en"
-        mock_info.duration = 2.5
-
-        mock_model = MagicMock()
-        mock_model.transcribe.return_value = ([mock_segment], mock_info)
-
-        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", True), \
-             patch("tools.transcription_tools.WhisperModel", return_value=mock_model), \
-             patch("tools.transcription_tools._local_model", None):
-            from tools.transcription_tools import _transcribe_local
-            result = _transcribe_local(str(audio_file), "base")
-
-        assert result["success"] is True
-        assert result["transcript"] == "Hello world"
-
-    def test_not_installed(self):
-        with patch("tools.transcription_tools._HAS_FASTER_WHISPER", False):
-            from tools.transcription_tools import _transcribe_local
-            result = _transcribe_local("/tmp/test.ogg", "base")
-        assert result["success"] is False
-        assert "not installed" in result["error"]
-
-
-# ---------------------------------------------------------------------------
-# OpenAI transcription
-# ---------------------------------------------------------------------------
-
-
-class TestTranscribeOpenAI:
-
-    def test_no_key(self, monkeypatch):
-        monkeypatch.delenv("VOICE_TOOLS_OPENAI_KEY", raising=False)
-        from tools.transcription_tools import _transcribe_openai
-        result = _transcribe_openai("/tmp/test.ogg", "whisper-1")
-        assert result["success"] is False
-        assert "VOICE_TOOLS_OPENAI_KEY" in result["error"]
-
-    def test_successful_transcription(self, monkeypatch, tmp_path):
-        monkeypatch.setenv("VOICE_TOOLS_OPENAI_KEY", "sk-test")
-        audio_file = tmp_path / "test.ogg"
-        audio_file.write_bytes(b"fake audio")
-
-        mock_client = MagicMock()
-        mock_client.audio.transcriptions.create.return_value = "Hello from OpenAI"
-
-        with patch("tools.transcription_tools._HAS_OPENAI", True), \
-             patch("tools.transcription_tools.OpenAI", return_value=mock_client):
-            from tools.transcription_tools import _transcribe_openai
-            result = _transcribe_openai(str(audio_file), "whisper-1")
-
-        assert result["success"] is True
-        assert result["transcript"] == "Hello from OpenAI"
-
-
-# ---------------------------------------------------------------------------
-# Main transcribe_audio() dispatch
-# ---------------------------------------------------------------------------
-
-
-class TestTranscribeAudio:
-
-    def test_dispatches_to_local(self, tmp_path):
-        audio_file = tmp_path / "test.ogg"
-        audio_file.write_bytes(b"fake audio")
-
-        with patch("tools.transcription_tools._load_stt_config", return_value={"provider": "local"}), \
-             patch("tools.transcription_tools._get_provider", return_value="local"), \
-             patch("tools.transcription_tools._transcribe_local", return_value={"success": True, "transcript": "hi"}) as mock_local:
-            from tools.transcription_tools import transcribe_audio
-            result = transcribe_audio(str(audio_file))
-
-        assert result["success"] is True
-        mock_local.assert_called_once()
-
-    def test_dispatches_to_openai(self, tmp_path):
-        audio_file = tmp_path / "test.ogg"
-        audio_file.write_bytes(b"fake audio")
-
-        with patch("tools.transcription_tools._load_stt_config", return_value={"provider": "openai"}), \
-             patch("tools.transcription_tools._get_provider", return_value="openai"), \
-             patch("tools.transcription_tools._transcribe_openai", return_value={"success": True, "transcript": "hi"}) as mock_openai:
-            from tools.transcription_tools import transcribe_audio
-            result = transcribe_audio(str(audio_file))
-
-        assert result["success"] is True
-        mock_openai.assert_called_once()
-
-    def test_no_provider_returns_error(self, tmp_path):
-        audio_file = tmp_path / "test.ogg"
-        audio_file.write_bytes(b"fake audio")
-
-        with patch("tools.transcription_tools._load_stt_config", return_value={}), \
-             patch("tools.transcription_tools._get_provider", return_value="none"):
-            from tools.transcription_tools import transcribe_audio
-            result = transcribe_audio(str(audio_file))
-
-        assert result["success"] is False
-        assert "No STT provider" in result["error"]
-
-    def test_invalid_file_returns_error(self):
-        from tools.transcription_tools import transcribe_audio
-        result = transcribe_audio("/nonexistent/file.ogg")
-        assert result["success"] is False
-        assert "not found" in result["error"]

tools/delegate_tool.py

@@ -276,70 +276,12 @@ def _run_single_child(
         else:
             status = "failed"
 
-        # Build tool trace from conversation messages (already in memory).
-        # Uses tool_call_id to correctly pair parallel tool calls with results.
-        tool_trace: list[Dict[str, Any]] = []
-        trace_by_id: Dict[str, Dict[str, Any]] = {}
-        messages = result.get("messages") or []
-        if isinstance(messages, list):
-            for msg in messages:
-                if not isinstance(msg, dict):
-                    continue
-                if msg.get("role") == "assistant":
-                    for tc in (msg.get("tool_calls") or []):
-                        fn = tc.get("function", {})
-                        entry_t = {
-                            "tool": fn.get("name", "unknown"),
-                            "args_bytes": len(fn.get("arguments", "")),
-                        }
-                        tool_trace.append(entry_t)
-                        tc_id = tc.get("id")
-                        if tc_id:
-                            trace_by_id[tc_id] = entry_t
-                elif msg.get("role") == "tool":
-                    content = msg.get("content", "")
-                    is_error = bool(
-                        content and "error" in content[:80].lower()
-                    )
-                    result_meta = {
-                        "result_bytes": len(content),
-                        "status": "error" if is_error else "ok",
-                    }
-                    # Match by tool_call_id for parallel calls
-                    tc_id = msg.get("tool_call_id")
-                    target = trace_by_id.get(tc_id) if tc_id else None
-                    if target is not None:
-                        target.update(result_meta)
-                    elif tool_trace:
-                        # Fallback for messages without tool_call_id
-                        tool_trace[-1].update(result_meta)
-
-        # Determine exit reason
-        if interrupted:
-            exit_reason = "interrupted"
-        elif completed:
-            exit_reason = "completed"
-        else:
-            exit_reason = "max_iterations"
-
-        # Extract token counts (safe for mock objects)
-        _input_tokens = getattr(child, "session_prompt_tokens", 0)
-        _output_tokens = getattr(child, "session_completion_tokens", 0)
-        _model = getattr(child, "model", None)
-
         entry: Dict[str, Any] = {
             "task_index": task_index,
             "status": status,
             "summary": summary,
             "api_calls": api_calls,
             "duration_seconds": duration,
-            "model": _model if isinstance(_model, str) else None,
-            "exit_reason": exit_reason,
-            "tokens": {
-                "input": _input_tokens if isinstance(_input_tokens, (int, float)) else 0,
-                "output": _output_tokens if isinstance(_output_tokens, (int, float)) else 0,
-            },
-            "tool_trace": tool_trace,
         }
         if status == "failed":
             entry["error"] = result.get("error", "Subagent did not produce a response.")

tools/environments/local.py

@@ -16,52 +16,6 @@ from tools.environments.base import BaseEnvironment
 # printf (no trailing newline) keeps the boundaries clean for splitting.
 _OUTPUT_FENCE = "__HERMES_FENCE_a9f7b3__"
 
-# Hermes-internal env vars that should NOT leak into terminal subprocesses.
-# These are loaded from ~/.hermes/.env for Hermes' own LLM/provider calls
-# but can break external CLIs (e.g. codex) that also honor them.
-# See: https://github.com/NousResearch/hermes-agent/issues/1002
-#
-# Built dynamically from the provider registry so new providers are
-# automatically covered without manual blocklist maintenance.
-_HERMES_PROVIDER_ENV_FORCE_PREFIX = "_HERMES_FORCE_"
-
-
-def _build_provider_env_blocklist() -> frozenset:
-    """Derive the blocklist from the provider registry + known extras.
-
-    Automatically picks up api_key_env_vars and base_url_env_var from
-    every registered provider, so adding a new provider to auth.py is
-    enough — no manual list to keep in sync.
-    """
-    blocked: set[str] = set()
-
-    try:
-        from hermes_cli.auth import PROVIDER_REGISTRY
-        for pconfig in PROVIDER_REGISTRY.values():
-            blocked.update(pconfig.api_key_env_vars)
-            if pconfig.base_url_env_var:
-                blocked.add(pconfig.base_url_env_var)
-    except ImportError:
-        pass
-
-    # Vars not in the registry but still Hermes-internal / conflict-prone
-    blocked.update({
-        "OPENAI_BASE_URL",
-        "OPENAI_API_KEY",
-        "OPENAI_API_BASE",         # legacy alias
-        "OPENAI_ORG_ID",
-        "OPENAI_ORGANIZATION",
-        "OPENROUTER_API_KEY",
-        "ANTHROPIC_BASE_URL",
-        "ANTHROPIC_TOKEN",         # OAuth token (not in registry as env var)
-        "CLAUDE_CODE_OAUTH_TOKEN",
-        "LLM_MODEL",
-    })
-    return frozenset(blocked)
-
-
-_HERMES_PROVIDER_ENV_BLOCKLIST = _build_provider_env_blocklist()
-
 
 def _find_bash() -> str:
     """Find bash for command execution.
@@ -238,18 +192,7 @@ class LocalEnvironment(BaseEnvironment):
             # Ensure PATH always includes standard dirs — systemd services
             # and some terminal multiplexers inherit a minimal PATH.
             _SANE_PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
-            # Strip Hermes-internal provider vars so external CLIs
-            # (e.g. codex) are not silently misrouted.  Callers that
-            # truly need a blocked var can opt in by prefixing the key
-            # with _HERMES_FORCE_ in self.env (e.g. _HERMES_FORCE_OPENAI_API_KEY).
-            merged = dict(os.environ | self.env)
-            run_env = {}
-            for k, v in merged.items():
-                if k.startswith(_HERMES_PROVIDER_ENV_FORCE_PREFIX):
-                    real_key = k[len(_HERMES_PROVIDER_ENV_FORCE_PREFIX):]
-                    run_env[real_key] = v
-                elif k not in _HERMES_PROVIDER_ENV_BLOCKLIST:
-                    run_env[k] = v
+            run_env = dict(os.environ | self.env)
             existing_path = run_env.get("PATH", "")
             if "/usr/bin" not in existing_path.split(":"):
                 run_env["PATH"] = f"{existing_path}:{_SANE_PATH}" if existing_path else _SANE_PATH

tools/process_registry.py

@@ -42,7 +42,7 @@ import time
 import uuid
 
 _IS_WINDOWS = platform.system() == "Windows"
-from tools.environments.local import _find_shell, _HERMES_PROVIDER_ENV_BLOCKLIST
+from tools.environments.local import _find_shell
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional
@@ -153,9 +153,7 @@ class ProcessRegistry:
                 else:
                     from ptyprocess import PtyProcess as _PtyProcessCls
                 user_shell = _find_shell()
-                pty_env = {k: v for k, v in os.environ.items()
-                           if k not in _HERMES_PROVIDER_ENV_BLOCKLIST}
-                pty_env.update(env_vars or {})
+                pty_env = os.environ | (env_vars or {})
                 pty_env["PYTHONUNBUFFERED"] = "1"
                 pty_proc = _PtyProcessCls.spawn(
                     [user_shell, "-lic", command],
@@ -196,9 +194,7 @@ class ProcessRegistry:
         # Force unbuffered output for Python scripts so progress is visible
         # during background execution (libraries like tqdm/datasets buffer when
         # stdout is a pipe, hiding output from process(action="poll")).
-        bg_env = {k: v for k, v in os.environ.items()
-                  if k not in _HERMES_PROVIDER_ENV_BLOCKLIST}
-        bg_env.update(env_vars or {})
+        bg_env = os.environ | (env_vars or {})
         bg_env["PYTHONUNBUFFERED"] = "1"
         proc = subprocess.Popen(
             [user_shell, "-lic", command],

tools/transcription_tools.py

@@ -2,19 +2,18 @@
 """
 Transcription Tools Module
 
-Provides speech-to-text transcription with two providers:
-
-  - **local** (default, free) — faster-whisper running locally, no API key needed.
-    Auto-downloads the model (~150 MB for ``base``) on first use.
-  - **openai** — OpenAI Whisper API, requires ``VOICE_TOOLS_OPENAI_KEY``.
-
+Provides speech-to-text transcription using OpenAI's Whisper API.
 Used by the messaging gateway to automatically transcribe voice messages
-sent by users on Telegram, Discord, WhatsApp, Slack, and Signal.
+sent by users on Telegram, Discord, WhatsApp, and Slack.
+
+Supported models:
+  - whisper-1        (cheapest, good quality)
+  - gpt-4o-mini-transcribe  (better quality, higher cost)
+  - gpt-4o-transcribe       (best quality, highest cost)
 
 Supported input formats: mp3, mp4, mpeg, mpga, m4a, wav, webm, ogg
 
-Usage::
-
+Usage:
     from tools.transcription_tools import transcribe_audio
 
     result = transcribe_audio("/path/to/audio.ogg")
@@ -29,205 +28,27 @@ from typing import Optional, Dict, Any
 
 logger = logging.getLogger(__name__)
 
-# ---------------------------------------------------------------------------
-# Optional imports — graceful degradation
-# ---------------------------------------------------------------------------
 
-try:
-    from faster_whisper import WhisperModel
-    _HAS_FASTER_WHISPER = True
-except ImportError:
-    _HAS_FASTER_WHISPER = False
-    WhisperModel = None  # type: ignore[assignment,misc]
-
-try:
-    from openai import OpenAI, APIError, APIConnectionError, APITimeoutError
-    _HAS_OPENAI = True
-except ImportError:
-    _HAS_OPENAI = False
-
-# ---------------------------------------------------------------------------
-# Constants
-# ---------------------------------------------------------------------------
-
-DEFAULT_PROVIDER = "local"
-DEFAULT_LOCAL_MODEL = "base"
-DEFAULT_OPENAI_MODEL = "whisper-1"
+# Default STT model -- cheapest and widely available
+DEFAULT_STT_MODEL = "whisper-1"
 
+# Supported audio formats
 SUPPORTED_FORMATS = {".mp3", ".mp4", ".mpeg", ".mpga", ".m4a", ".wav", ".webm", ".ogg"}
-MAX_FILE_SIZE = 25 * 1024 * 1024  # 25 MB
 
-# Singleton for the local model — loaded once, reused across calls
-_local_model: Optional["WhisperModel"] = None
-_local_model_name: Optional[str] = None
-
-# ---------------------------------------------------------------------------
-# Config helpers
-# ---------------------------------------------------------------------------
-
-
-def _load_stt_config() -> dict:
-    """Load the ``stt`` section from user config, falling back to defaults."""
-    try:
-        from hermes_cli.config import load_config
-        return load_config().get("stt", {})
-    except Exception:
-        return {}
-
-
-def _get_provider(stt_config: dict) -> str:
-    """Determine which STT provider to use.
-
-    Priority:
-      1. Explicit config value  (``stt.provider``)
-      2. Auto-detect: local if faster-whisper available, else openai if key set
-      3. Disabled (returns "none")
-    """
-    provider = stt_config.get("provider", DEFAULT_PROVIDER)
-
-    if provider == "local":
-        if _HAS_FASTER_WHISPER:
-            return "local"
-        # Local requested but not available — fall back to openai if possible
-        if _HAS_OPENAI and os.getenv("VOICE_TOOLS_OPENAI_KEY"):
-            logger.info("faster-whisper not installed, falling back to OpenAI Whisper API")
-            return "openai"
-        return "none"
-
-    if provider == "openai":
-        if _HAS_OPENAI and os.getenv("VOICE_TOOLS_OPENAI_KEY"):
-            return "openai"
-        # OpenAI requested but no key — fall back to local if possible
-        if _HAS_FASTER_WHISPER:
-            logger.info("VOICE_TOOLS_OPENAI_KEY not set, falling back to local faster-whisper")
-            return "local"
-        return "none"
-
-    return provider  # Unknown — let it fail downstream
-
-# ---------------------------------------------------------------------------
-# Shared validation
-# ---------------------------------------------------------------------------
-
-
-def _validate_audio_file(file_path: str) -> Optional[Dict[str, Any]]:
-    """Validate the audio file.  Returns an error dict or None if OK."""
-    audio_path = Path(file_path)
-
-    if not audio_path.exists():
-        return {"success": False, "transcript": "", "error": f"Audio file not found: {file_path}"}
-    if not audio_path.is_file():
-        return {"success": False, "transcript": "", "error": f"Path is not a file: {file_path}"}
-    if audio_path.suffix.lower() not in SUPPORTED_FORMATS:
-        return {
-            "success": False,
-            "transcript": "",
-            "error": f"Unsupported format: {audio_path.suffix}. Supported: {', '.join(sorted(SUPPORTED_FORMATS))}",
-        }
-    try:
-        file_size = audio_path.stat().st_size
-        if file_size > MAX_FILE_SIZE:
-            return {
-                "success": False,
-                "transcript": "",
-                "error": f"File too large: {file_size / (1024*1024):.1f}MB (max {MAX_FILE_SIZE / (1024*1024):.0f}MB)",
-            }
-    except OSError as e:
-        return {"success": False, "transcript": "", "error": f"Failed to access file: {e}"}
-
-    return None
-
-# ---------------------------------------------------------------------------
-# Provider: local (faster-whisper)
-# ---------------------------------------------------------------------------
-
-
-def _transcribe_local(file_path: str, model_name: str) -> Dict[str, Any]:
-    """Transcribe using faster-whisper (local, free)."""
-    global _local_model, _local_model_name
-
-    if not _HAS_FASTER_WHISPER:
-        return {"success": False, "transcript": "", "error": "faster-whisper not installed"}
-
-    try:
-        # Lazy-load the model (downloads on first use, ~150 MB for 'base')
-        if _local_model is None or _local_model_name != model_name:
-            logger.info("Loading faster-whisper model '%s' (first load downloads the model)...", model_name)
-            _local_model = WhisperModel(model_name, device="auto", compute_type="auto")
-            _local_model_name = model_name
-
-        segments, info = _local_model.transcribe(file_path, beam_size=5)
-        transcript = " ".join(segment.text.strip() for segment in segments)
-
-        logger.info(
-            "Transcribed %s via local whisper (%s, lang=%s, %.1fs audio)",
-            Path(file_path).name, model_name, info.language, info.duration,
-        )
-
-        return {"success": True, "transcript": transcript}
-
-    except Exception as e:
-        logger.error("Local transcription failed: %s", e, exc_info=True)
-        return {"success": False, "transcript": "", "error": f"Local transcription failed: {e}"}
-
-# ---------------------------------------------------------------------------
-# Provider: openai (Whisper API)
-# ---------------------------------------------------------------------------
-
-
-def _transcribe_openai(file_path: str, model_name: str) -> Dict[str, Any]:
-    """Transcribe using OpenAI Whisper API (paid)."""
-    api_key = os.getenv("VOICE_TOOLS_OPENAI_KEY")
-    if not api_key:
-        return {"success": False, "transcript": "", "error": "VOICE_TOOLS_OPENAI_KEY not set"}
-
-    if not _HAS_OPENAI:
-        return {"success": False, "transcript": "", "error": "openai package not installed"}
-
-    try:
-        client = OpenAI(api_key=api_key, base_url="https://api.openai.com/v1")
-
-        with open(file_path, "rb") as audio_file:
-            transcription = client.audio.transcriptions.create(
-                model=model_name,
-                file=audio_file,
-                response_format="text",
-            )
-
-        transcript_text = str(transcription).strip()
-        logger.info("Transcribed %s via OpenAI API (%s, %d chars)",
-                     Path(file_path).name, model_name, len(transcript_text))
-
-        return {"success": True, "transcript": transcript_text}
-
-    except PermissionError:
-        return {"success": False, "transcript": "", "error": f"Permission denied: {file_path}"}
-    except APIConnectionError as e:
-        return {"success": False, "transcript": "", "error": f"Connection error: {e}"}
-    except APITimeoutError as e:
-        return {"success": False, "transcript": "", "error": f"Request timeout: {e}"}
-    except APIError as e:
-        return {"success": False, "transcript": "", "error": f"API error: {e}"}
-    except Exception as e:
-        logger.error("OpenAI transcription failed: %s", e, exc_info=True)
-        return {"success": False, "transcript": "", "error": f"Transcription failed: {e}"}
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
+# Maximum file size (25MB - OpenAI limit)
+MAX_FILE_SIZE = 25 * 1024 * 1024
 
 
 def transcribe_audio(file_path: str, model: Optional[str] = None) -> Dict[str, Any]:
     """
-    Transcribe an audio file using the configured STT provider.
+    Transcribe an audio file using OpenAI's Whisper API.
 
-    Provider priority:
-      1. User config (``stt.provider`` in config.yaml)
-      2. Auto-detect: local faster-whisper if available, else OpenAI API
+    This function calls the OpenAI Audio Transcriptions endpoint directly
+    (not via OpenRouter, since Whisper isn't available there).
 
     Args:
         file_path: Absolute path to the audio file to transcribe.
-        model:     Override the model. If None, uses config or provider default.
+        model:     Whisper model to use. Defaults to config or "whisper-1".
 
     Returns:
         dict with keys:
@@ -235,31 +56,114 @@ def transcribe_audio(file_path: str, model: Optional[str] = None) -> Dict[str, A
           - "transcript" (str): The transcribed text (empty on failure)
           - "error" (str, optional): Error message if success is False
     """
-    # Validate input
-    error = _validate_audio_file(file_path)
-    if error:
-        return error
+    api_key = os.getenv("VOICE_TOOLS_OPENAI_KEY")
+    if not api_key:
+        return {
+            "success": False,
+            "transcript": "",
+            "error": "VOICE_TOOLS_OPENAI_KEY not set",
+        }
 
-    # Load config and determine provider
-    stt_config = _load_stt_config()
-    provider = _get_provider(stt_config)
+    audio_path = Path(file_path)
+    
+    # Validate file exists
+    if not audio_path.exists():
+        return {
+            "success": False,
+            "transcript": "",
+            "error": f"Audio file not found: {file_path}",
+        }
+    
+    if not audio_path.is_file():
+        return {
+            "success": False,
+            "transcript": "",
+            "error": f"Path is not a file: {file_path}",
+        }
+    
+    # Validate file extension
+    if audio_path.suffix.lower() not in SUPPORTED_FORMATS:
+        return {
+            "success": False,
+            "transcript": "",
+            "error": f"Unsupported file format: {audio_path.suffix}. Supported formats: {', '.join(sorted(SUPPORTED_FORMATS))}",
+        }
+    
+    # Validate file size
+    try:
+        file_size = audio_path.stat().st_size
+        if file_size > MAX_FILE_SIZE:
+            return {
+                "success": False,
+                "transcript": "",
+                "error": f"File too large: {file_size / (1024*1024):.1f}MB (max {MAX_FILE_SIZE / (1024*1024)}MB)",
+            }
+    except OSError as e:
+        logger.error("Failed to get file size for %s: %s", file_path, e, exc_info=True)
+        return {
+            "success": False,
+            "transcript": "",
+            "error": f"Failed to access file: {e}",
+        }
 
-    if provider == "local":
-        local_cfg = stt_config.get("local", {})
-        model_name = model or local_cfg.get("model", DEFAULT_LOCAL_MODEL)
-        return _transcribe_local(file_path, model_name)
+    # Use provided model, or fall back to default
+    if model is None:
+        model = DEFAULT_STT_MODEL
 
-    if provider == "openai":
-        openai_cfg = stt_config.get("openai", {})
-        model_name = model or openai_cfg.get("model", DEFAULT_OPENAI_MODEL)
-        return _transcribe_openai(file_path, model_name)
+    try:
+        from openai import OpenAI, APIError, APIConnectionError, APITimeoutError
 
-    # No provider available
-    return {
-        "success": False,
-        "transcript": "",
-        "error": (
-            "No STT provider available. Install faster-whisper for free local "
-            "transcription, or set VOICE_TOOLS_OPENAI_KEY for the OpenAI Whisper API."
-        ),
-    }
+        client = OpenAI(api_key=api_key, base_url="https://api.openai.com/v1")
+
+        with open(file_path, "rb") as audio_file:
+            transcription = client.audio.transcriptions.create(
+                model=model,
+                file=audio_file,
+                response_format="text",
+            )
+
+        # The response is a plain string when response_format="text"
+        transcript_text = str(transcription).strip()
+
+        logger.info("Transcribed %s (%d chars)", audio_path.name, len(transcript_text))
+
+        return {
+            "success": True,
+            "transcript": transcript_text,
+        }
+
+    except PermissionError:
+        logger.error("Permission denied accessing file: %s", file_path, exc_info=True)
+        return {
+            "success": False,
+            "transcript": "",
+            "error": f"Permission denied: {file_path}",
+        }
+    except APIConnectionError as e:
+        logger.error("API connection error during transcription: %s", e, exc_info=True)
+        return {
+            "success": False,
+            "transcript": "",
+            "error": f"Connection error: {e}",
+        }
+    except APITimeoutError as e:
+        logger.error("API timeout during transcription: %s", e, exc_info=True)
+        return {
+            "success": False,
+            "transcript": "",
+            "error": f"Request timeout: {e}",
+        }
+    except APIError as e:
+        logger.error("OpenAI API error during transcription: %s", e, exc_info=True)
+        return {
+            "success": False,
+            "transcript": "",
+            "error": f"API error: {e}",
+        }
+    except Exception as e:
+        logger.error("Unexpected error during transcription: %s", e, exc_info=True)
+        return {
+            "success": False,
+            "transcript": "",
+            "error": f"Transcription failed: {e}",
+        }

website/docs/reference/environment-variables.md

@@ -114,8 +114,6 @@ All variables go in `~/.hermes/.env`. You can also set them with `hermes config
 | `SIGNAL_ACCOUNT` | Bot phone number in E.164 format (e.g., `+15551234567`) |
 | `SIGNAL_ALLOWED_USERS` | Comma-separated E.164 phone numbers or UUIDs |
 | `SIGNAL_GROUP_ALLOWED_USERS` | Comma-separated group IDs, or `*` for all groups (omit to disable groups) |
-| `HASS_TOKEN` | Home Assistant Long-Lived Access Token (enables HA platform + tools) |
-| `HASS_URL` | Home Assistant URL (default: `http://homeassistant.local:8123`) |
 | `MESSAGING_CWD` | Working directory for terminal in messaging (default: `~`) |
 | `GATEWAY_ALLOWED_USERS` | Comma-separated user IDs allowed across all platforms |
 | `GATEWAY_ALLOW_ALL_USERS` | Allow all users without allowlist (`true`/`false`, default: `false`) |
@@ -131,7 +129,6 @@ All variables go in `~/.hermes/.env`. You can also set them with `hermes config
 | `HERMES_HUMAN_DELAY_MIN_MS` | Custom delay range minimum (ms) |
 | `HERMES_HUMAN_DELAY_MAX_MS` | Custom delay range maximum (ms) |
 | `HERMES_QUIET` | Suppress non-essential output (`true`/`false`) |
-| `HERMES_API_TIMEOUT` | LLM API call timeout in seconds (default: `900`) |
 | `HERMES_EXEC_ASK` | Enable execution approval prompts in gateway mode (`true`/`false`) |
 
 ## Session Settings

website/docs/user-guide/features/tts.md

@@ -67,48 +67,23 @@ Without ffmpeg, Edge TTS audio is sent as a regular audio file (playable, but sh
 If you want voice bubbles without installing ffmpeg, switch to the OpenAI or ElevenLabs provider.
 :::
 
-## Voice Message Transcription (STT)
+## Voice Message Transcription
 
-Voice messages sent on Telegram, Discord, WhatsApp, Slack, or Signal are automatically transcribed and injected as text into the conversation. The agent sees the transcript as normal text.
+Voice messages sent on Telegram, Discord, WhatsApp, or Slack are automatically transcribed and injected as text into the conversation. The agent sees the transcript as normal text.
 
-| Provider | Quality | Cost | API Key |
-|----------|---------|------|---------| 
-| **Local Whisper** (default) | Good | Free | None needed |
-| **OpenAI Whisper API** | Good–Best | Paid | `VOICE_TOOLS_OPENAI_KEY` |
+| Provider | Model | Quality | Cost |
+|----------|-------|---------|------|
+| **OpenAI Whisper** | `whisper-1` (default) | Good | Low |
+| **OpenAI GPT-4o** | `gpt-4o-mini-transcribe` | Better | Medium |
+| **OpenAI GPT-4o** | `gpt-4o-transcribe` | Best | Higher |
 
-:::info Zero Config
-Local transcription works out of the box — no API key needed. The `faster-whisper` model (~150 MB for `base`) is auto-downloaded on first voice message.
-:::
+Requires `VOICE_TOOLS_OPENAI_KEY` in `~/.hermes/.env`.
 
 ### Configuration
 
 ```yaml
 # In ~/.hermes/config.yaml
 stt:
-  provider: "local"           # "local" (free, faster-whisper) | "openai" (API)
-  local:
-    model: "base"             # tiny, base, small, medium, large-v3
-  openai:
-    model: "whisper-1"        # whisper-1, gpt-4o-mini-transcribe, gpt-4o-transcribe
+  enabled: true
+  model: "whisper-1"
 ```
-
-### Provider Details
-
-**Local (faster-whisper)** — Runs Whisper locally via [faster-whisper](https://github.com/SYSTRAN/faster-whisper). Uses CPU by default, GPU if available. Model sizes:
-
-| Model | Size | Speed | Quality |
-|-------|------|-------|---------|
-| `tiny` | ~75 MB | Fastest | Basic |
-| `base` | ~150 MB | Fast | Good (default) |
-| `small` | ~500 MB | Medium | Better |
-| `medium` | ~1.5 GB | Slower | Great |
-| `large-v3` | ~3 GB | Slowest | Best |
-
-**OpenAI API** — Requires `VOICE_TOOLS_OPENAI_KEY`. Supports `whisper-1`, `gpt-4o-mini-transcribe`, and `gpt-4o-transcribe`.
-
-### Fallback Behavior
-
-If your configured provider isn't available, Hermes automatically falls back:
-- **Local not installed** → Falls back to OpenAI API (if key is set)
-- **OpenAI key not set** → Falls back to local Whisper (if installed)
-- **Neither available** → Voice messages pass through with a note to the user

website/docs/user-guide/messaging/homeassistant.md

@@ -122,53 +122,31 @@ Set living room lights to blue at 50% brightness
 
 ## Gateway Platform: Real-Time Events
 
-The Home Assistant gateway adapter connects via WebSocket and subscribes to `state_changed` events. When a device state changes and matches your filters, it's forwarded to the agent as a message.
+The Home Assistant gateway adapter connects via WebSocket and subscribes to `state_changed` events. When a device state changes, it's forwarded to the agent as a message.
 
 ### Event Filtering
 
-:::warning Required Configuration
-By default, **no events are forwarded**. You must configure at least one of `watch_domains`, `watch_entities`, or `watch_all` to receive events. Without filters, a warning is logged at startup and all state changes are silently dropped.
-:::
+Configure which events the agent sees via platform config in the gateway:
 
-Configure which events the agent sees in `~/.hermes/config.yaml` under the Home Assistant platform's `extra` section:
-
-```yaml
-# ~/.hermes/config.yaml
-messaging:
-  platforms:
-    homeassistant:
-      extra:
-        # Watch specific domains (recommended)
-        watch_domains:
-          - climate
-          - binary_sensor
-          - alarm_control_panel
-          - light
-
-        # Watch specific entities (in addition to domains)
-        watch_entities:
-          - sensor.front_door_battery
-
-        # Ignore noisy entities
-        ignore_entities:
-          - sensor.uptime
-          - sensor.cpu_usage
-          - sensor.memory_usage
-
-        # Per-entity cooldown (seconds)
-        cooldown_seconds: 30
+```python
+# In platform extra config
+{
+    "watch_domains": ["climate", "binary_sensor", "alarm_control_panel"],
+    "watch_entities": ["sensor.front_door"],
+    "ignore_entities": ["sensor.uptime", "sensor.cpu_usage"],
+    "cooldown_seconds": 30
+}
 ```
 
 | Setting | Default | Description |
 |---------|---------|-------------|
-| `watch_domains` | *(none)* | Only watch these entity domains (e.g., `climate`, `light`, `binary_sensor`) |
-| `watch_entities` | *(none)* | Only watch these specific entity IDs |
-| `watch_all` | `false` | Set to `true` to receive **all** state changes (not recommended for most setups) |
-| `ignore_entities` | *(none)* | Always ignore these entities (applied before domain/entity filters) |
+| `watch_domains` | *(all)* | Only watch these entity domains |
+| `watch_entities` | *(all)* | Only watch these specific entities |
+| `ignore_entities` | *(none)* | Always ignore these entities |
 | `cooldown_seconds` | `30` | Minimum seconds between events for the same entity |
 
 :::tip
-Start with a focused set of domains — `climate`, `binary_sensor`, and `alarm_control_panel` cover the most useful automations. Add more as needed. Use `ignore_entities` to suppress noisy sensors like CPU temperature or uptime counters.
+Without any filters, the agent receives **all** state changes, which can be noisy. For practical use, set `watch_domains` to the domains you care about (e.g., `climate`, `binary_sensor`, `alarm_control_panel`).
 :::
 
 ### Event Formatting

website/docs/user-guide/messaging/index.md

@@ -1,38 +1,38 @@
 ---
 sidebar_position: 1
 title: "Messaging Gateway"
-description: "Chat with Hermes from Telegram, Discord, Slack, WhatsApp, Signal, Email, or Home Assistant — architecture and setup overview"
+description: "Chat with Hermes from Telegram, Discord, Slack, WhatsApp, Signal, or Email — architecture and setup overview"
 ---
 
 # Messaging Gateway
 
-Chat with Hermes from Telegram, Discord, Slack, WhatsApp, Signal, Email, or Home Assistant. The gateway is a single background process that connects to all your configured platforms, handles sessions, runs cron jobs, and delivers voice messages.
+Chat with Hermes from Telegram, Discord, Slack, WhatsApp, Signal, or Email. The gateway is a single background process that connects to all your configured platforms, handles sessions, runs cron jobs, and delivers voice messages.
 
 ## Architecture
 
 ```text
-┌───────────────────────────────────────────────────────────────────────────────┐
-│                              Hermes Gateway                                   │
-├───────────────────────────────────────────────────────────────────────────────┤
-│                                                                               │
-│  ┌──────────┐ ┌─────────┐ ┌──────────┐ ┌───────┐ ┌───────┐ ┌───────┐ ┌────┐│
-│  │ Telegram │ │ Discord │ │ WhatsApp │ │ Slack │ │Signal │ │ Email │ │ HA ││
-│  │ Adapter  │ │ Adapter │ │ Adapter  │ │Adapter│ │Adapter│ │Adapter│ │Adpt││
-│  └────┬─────┘ └────┬────┘ └────┬─────┘ └──┬────┘ └──┬────┘ └──┬────┘ └─┬──┘│
-│       │             │           │           │         │         │        │    │
-│       └─────────────┴───────────┴───────────┴─────────┴─────────┴────────┘    │
-│                                     │                                         │
-│                            ┌────────▼────────┐                                │
-│                            │  Session Store  │                                │
-│                            │  (per-chat)     │                                │
-│                            └────────┬────────┘                                │
-│                                     │                                         │
-│                            ┌────────▼────────┐                                │
-│                            │   AIAgent       │                                │
-│                            │   (run_agent)   │                                │
-│                            └─────────────────┘                                │
-│                                                                               │
-└───────────────────────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────────┐
+│                      Hermes Gateway                             │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                 │
+│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌────────┐ ┌────────┐ ┌───────┐│
+│  │ Telegram │ │ Discord  │ │ WhatsApp │ │ Slack  │ │ Signal │ │ Email ││
+│  │ Adapter  │ │ Adapter  │ │ Adapter  │ │Adapter │ │Adapter │ │Adapter││
+│  └────┬─────┘ └────┬─────┘ └────┬─────┘ └───┬────┘ └───┬────┘ └──┬────┘│
+│       │             │            │            │          │         │     │
+│       └─────────────┼────────────┼────────────┼──────────┼─────────┘     │
+│                           │                                     │
+│                  ┌────────▼────────┐                            │
+│                  │  Session Store  │                            │
+│                  │  (per-chat)     │                            │
+│                  └────────┬────────┘                            │
+│                           │                                     │
+│                  ┌────────▼────────┐                            │
+│                  │   AIAgent       │                            │
+│                  │   (run_agent)   │                            │
+│                  └─────────────────┘                            │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
 ```
 
 Each platform adapter receives messages, routes them through a per-chat session store, and dispatches them to the AIAgent for processing. The gateway also runs the cron scheduler, ticking every 60 seconds to execute any due jobs.
@@ -204,7 +204,6 @@ Each platform has its own toolset:
 | Slack | `hermes-slack` | Full tools including terminal |
 | Signal | `hermes-signal` | Full tools including terminal |
 | Email | `hermes-email` | Full tools including terminal |
-| Home Assistant | `hermes-gateway` | Full tools + HA device control (ha_list_entities, ha_get_state, ha_call_service, ha_list_services) |
 
 ## Next Steps
 
@@ -214,4 +213,3 @@ Each platform has its own toolset:
 - [WhatsApp Setup](whatsapp.md)
 - [Signal Setup](signal.md)
 - [Email Setup](email.md)
-- [Home Assistant Integration](homeassistant.md)