fix: add gpt-5.4 and gpt-5.4-mini to openai-codex curated model list

The _PROVIDER_MODELS['openai-codex'] list was missing gpt-5.4 and gpt-5.4-mini,
causing them to not appear in the /model picker for ChatGPT OAuth users.
codex_models.py already had these models in DEFAULT_CODEX_MODELS, but the
curated list that feeds the Telegram/Discord /model picker was never updated.

Reported by @chongdashu

agent/model_metadata.py

@@ -113,10 +113,7 @@ DEFAULT_CONTEXT_LENGTHS = {
     "deepseek": 128000,
     # Meta
     "llama": 131072,
-    # Qwen — specific model families before the catch-all.
-    # Official docs: https://help.aliyun.com/zh/model-studio/developer-reference/
-    "qwen3-coder-plus": 1000000,  # 1M context
-    "qwen3-coder": 262144,        # 256K context
+    # Qwen
     "qwen": 131072,
     # MiniMax — official docs: 204,800 context for all models
     # https://platform.minimax.io/docs/api-reference/text-anthropic-api

cli.py

@@ -1171,45 +1171,6 @@ def _resolve_attachment_path(raw_path: str) -> Path | None:
     return resolved
 
 
-def _format_process_notification(evt: dict) -> "str | None":
-    """Format a process notification event into a [SYSTEM: ...] message.
-
-    Handles both completion events (notify_on_complete) and watch pattern
-    match events from the unified completion_queue.
-    """
-    evt_type = evt.get("type", "completion")
-    _sid = evt.get("session_id", "unknown")
-    _cmd = evt.get("command", "unknown")
-
-    if evt_type == "watch_disabled":
-        return f"[SYSTEM: {evt.get('message', '')}]"
-
-    if evt_type == "watch_match":
-        _pat = evt.get("pattern", "?")
-        _out = evt.get("output", "")
-        _sup = evt.get("suppressed", 0)
-        text = (
-            f"[SYSTEM: Background process {_sid} matched "
-            f"watch pattern \"{_pat}\".\n"
-            f"Command: {_cmd}\n"
-            f"Matched output:\n{_out}"
-        )
-        if _sup:
-            text += f"\n({_sup} earlier matches were suppressed by rate limit)"
-        text += "]"
-        return text
-
-    # Default: completion event
-    _exit = evt.get("exit_code", "?")
-    _out = evt.get("output", "")
-    return (
-        f"[SYSTEM: Background process {_sid} completed "
-        f"(exit code {_exit}).\n"
-        f"Command: {_cmd}\n"
-        f"Output:\n{_out}]"
-    )
-
-
 def _detect_file_drop(user_input: str) -> "dict | None":
     """Detect if *user_input* starts with a real local file path.
 
@@ -8909,15 +8870,23 @@ class HermesCLI:
                         # Periodic config watcher — auto-reload MCP on mcp_servers change
                         if not self._agent_running:
                             self._check_config_mcp_changes()
-                            # Check for background process notifications (completions
-                            # and watch pattern matches) while agent is idle.
+                            # Check for background process completion notifications
+                            # while the agent is idle (user hasn't typed anything yet).
                             try:
                                 from tools.process_registry import process_registry
                                 if not process_registry.completion_queue.empty():
-                                    evt = process_registry.completion_queue.get_nowait()
-                                    _synth = _format_process_notification(evt)
-                                    if _synth:
-                                        self._pending_input.put(_synth)
+                                    completion = process_registry.completion_queue.get_nowait()
+                                    _exit = completion.get("exit_code", "?")
+                                    _cmd = completion.get("command", "unknown")
+                                    _sid = completion.get("session_id", "unknown")
+                                    _out = completion.get("output", "")
+                                    _synth = (
+                                        f"[SYSTEM: Background process {_sid} completed "
+                                        f"(exit code {_exit}).\n"
+                                        f"Command: {_cmd}\n"
+                                        f"Output:\n{_out}]"
+                                    )
+                                    self._pending_input.put(_synth)
                             except Exception:
                                 pass
                         continue
@@ -9035,15 +9004,25 @@ class HermesCLI:
                                     _cprint(f"{_DIM}Voice auto-restart failed: {e}{_RST}")
                             threading.Thread(target=_restart_recording, daemon=True).start()
 
-                        # Drain process notifications (completions + watch matches)
-                        # that arrived while the agent was running.
+                        # Drain process completion notifications — any background
+                        # process that finished with notify_on_complete while the
+                        # agent was running (or before) gets auto-injected as a
+                        # new user message so the agent can react to it.
                         try:
                             from tools.process_registry import process_registry
                             while not process_registry.completion_queue.empty():
-                                evt = process_registry.completion_queue.get_nowait()
-                                _synth = _format_process_notification(evt)
-                                if _synth:
-                                    self._pending_input.put(_synth)
+                                completion = process_registry.completion_queue.get_nowait()
+                                _exit = completion.get("exit_code", "?")
+                                _cmd = completion.get("command", "unknown")
+                                _sid = completion.get("session_id", "unknown")
+                                _out = completion.get("output", "")
+                                _synth = (
+                                    f"[SYSTEM: Background process {_sid} completed "
+                                    f"(exit code {_exit}).\n"
+                                    f"Command: {_cmd}\n"
+                                    f"Output:\n{_out}]"
+                                )
+                                self._pending_input.put(_synth)
                         except Exception:
                             pass  # Non-fatal — don't break the main loop
 

gateway/platforms/matrix.py

@@ -352,16 +352,7 @@ class MatrixAdapter(BasePlatformAdapter):
                 from mautrix.crypto import OlmMachine
                 from mautrix.crypto.store import MemoryCryptoStore
 
-                # account_id and pickle_key are required by mautrix ≥0.21.
-                # Use the Matrix user ID as account_id for stable identity.
-                # pickle_key secures in-memory serialisation; derive from
-                # the same user_id:device_id pair used for the on-disk HMAC.
-                _acct_id = self._user_id or "hermes"
-                _pickle_key = f"{_acct_id}:{self._device_id}"
-                crypto_store = MemoryCryptoStore(
-                    account_id=_acct_id,
-                    pickle_key=_pickle_key,
-                )
+                crypto_store = MemoryCryptoStore()
 
                 # Restore persisted crypto state from a previous run.
                 # Uses HMAC to verify integrity before unpickling.

gateway/run.py

@@ -476,33 +476,6 @@ def _resolve_hermes_bin() -> Optional[list[str]]:
     return None
 
 
-def _format_gateway_process_notification(evt: dict) -> "str | None":
-    """Format a watch pattern event from completion_queue into a [SYSTEM:] message."""
-    evt_type = evt.get("type", "completion")
-    _sid = evt.get("session_id", "unknown")
-    _cmd = evt.get("command", "unknown")
-
-    if evt_type == "watch_disabled":
-        return f"[SYSTEM: {evt.get('message', '')}]"
-
-    if evt_type == "watch_match":
-        _pat = evt.get("pattern", "?")
-        _out = evt.get("output", "")
-        _sup = evt.get("suppressed", 0)
-        text = (
-            f"[SYSTEM: Background process {_sid} matched "
-            f"watch pattern \"{_pat}\".\n"
-            f"Command: {_cmd}\n"
-            f"Matched output:\n{_out}"
-        )
-        if _sup:
-            text += f"\n({_sup} earlier matches were suppressed by rate limit)"
-        text += "]"
-        return text
-
-    return None
-
-
 class GatewayRunner:
     """
     Main gateway controller.
@@ -694,7 +667,6 @@ class GatewayRunner:
     def _flush_memories_for_session(
         self,
         old_session_id: str,
-        session_key: Optional[str] = None,
     ):
         """Prompt the agent to save memories/skills before context is lost.
 
@@ -713,12 +685,15 @@ class GatewayRunner:
                 return
 
             from run_agent import AIAgent
-            model, runtime_kwargs = self._resolve_session_agent_runtime(
-                session_key=session_key,
-            )
+            runtime_kwargs = _resolve_runtime_agent_kwargs()
             if not runtime_kwargs.get("api_key"):
                 return
 
+            # Resolve model from config — AIAgent's default is OpenRouter-
+            # formatted ("anthropic/claude-opus-4.6") which fails when the
+            # active provider is openai-codex.
+            model = _resolve_gateway_model()
+
             tmp_agent = AIAgent(
                 **runtime_kwargs,
                 model=model,
@@ -798,7 +773,6 @@ class GatewayRunner:
     async def _async_flush_memories(
         self,
         old_session_id: str,
-        session_key: Optional[str] = None,
     ):
         """Run the sync memory flush in a thread pool so it won't block the event loop."""
         loop = asyncio.get_event_loop()
@@ -806,7 +780,6 @@ class GatewayRunner:
             None,
             self._flush_memories_for_session,
             old_session_id,
-            session_key,
         )
 
     @property
@@ -841,46 +814,6 @@ class GatewayRunner:
             thread_sessions_per_user=getattr(config, "thread_sessions_per_user", False),
         )
 
-    def _resolve_session_agent_runtime(
-        self,
-        *,
-        source: Optional[SessionSource] = None,
-        session_key: Optional[str] = None,
-        user_config: Optional[dict] = None,
-    ) -> tuple[str, dict]:
-        """Resolve model/runtime for a session, honoring session-scoped /model overrides.
-
-        If the session override already contains a complete provider bundle
-        (provider/api_key/base_url/api_mode), prefer it directly instead of
-        resolving fresh global runtime state first.
-        """
-        resolved_session_key = session_key
-        if not resolved_session_key and source is not None:
-            try:
-                resolved_session_key = self._session_key_for_source(source)
-            except Exception:
-                resolved_session_key = None
-
-        model = _resolve_gateway_model(user_config)
-        override = self._session_model_overrides.get(resolved_session_key) if resolved_session_key else None
-        if override:
-            override_model = override.get("model", model)
-            override_runtime = {
-                "provider": override.get("provider"),
-                "api_key": override.get("api_key"),
-                "base_url": override.get("base_url"),
-                "api_mode": override.get("api_mode"),
-            }
-            if override_runtime.get("api_key"):
-                return override_model, override_runtime
-
-        runtime_kwargs = _resolve_runtime_agent_kwargs()
-        if override and resolved_session_key:
-            model, runtime_kwargs = self._apply_session_model_override(
-                resolved_session_key, model, runtime_kwargs
-            )
-        return model, runtime_kwargs
-
     def _resolve_turn_agent_config(self, user_message: str, model: str, runtime_kwargs: dict) -> dict:
         from agent.smart_model_routing import resolve_turn_route
         from hermes_cli.models import resolve_fast_mode_overrides
@@ -1665,7 +1598,7 @@ class GatewayRunner:
 
                 for key, entry in _expired_entries:
                     try:
-                        await self._async_flush_memories(entry.session_id, key)
+                        await self._async_flush_memories(entry.session_id)
                         # Shut down memory provider and close tool resources
                         # on the cached agent.  Idle agents live in
                         # _agent_cache (not _running_agents), so look there.
@@ -2934,7 +2867,6 @@ class GatewayRunner:
             _hyg_provider = None
             _hyg_base_url = None
             _hyg_api_key = None
-            _hyg_data = {}
             try:
                 _hyg_cfg_path = _hermes_home / "config.yaml"
                 if _hyg_cfg_path.exists():
@@ -2969,17 +2901,15 @@ class GatewayRunner:
                             _comp_cfg.get("enabled", True)
                         ).lower() in ("true", "1", "yes")
 
-                try:
-                    _hyg_model, _hyg_runtime = self._resolve_session_agent_runtime(
-                        source=source,
-                        session_key=session_key,
-                        user_config=_hyg_data if isinstance(_hyg_data, dict) else None,
-                    )
-                    _hyg_provider = _hyg_runtime.get("provider") or _hyg_provider
-                    _hyg_base_url = _hyg_runtime.get("base_url") or _hyg_base_url
-                    _hyg_api_key = _hyg_runtime.get("api_key") or _hyg_api_key
-                except Exception:
-                    pass
+                # Resolve provider/base_url from runtime if not in config
+                if not _hyg_provider or not _hyg_base_url:
+                    try:
+                        _hyg_runtime = _resolve_runtime_agent_kwargs()
+                        _hyg_provider = _hyg_provider or _hyg_runtime.get("provider")
+                        _hyg_base_url = _hyg_base_url or _hyg_runtime.get("base_url")
+                        _hyg_api_key = _hyg_runtime.get("api_key")
+                    except Exception:
+                        pass
 
                 # Check custom_providers per-model context_length
                 # (same fallback as run_agent.py lines 1171-1189).
@@ -3066,11 +2996,7 @@ class GatewayRunner:
                     try:
                         from run_agent import AIAgent
 
-                        _hyg_model, _hyg_runtime = self._resolve_session_agent_runtime(
-                            source=source,
-                            session_key=session_key,
-                            user_config=_hyg_data if isinstance(_hyg_data, dict) else None,
-                        )
+                        _hyg_runtime = _resolve_runtime_agent_kwargs()
                         if _hyg_runtime.get("api_key"):
                             _hyg_msgs = [
                                 {"role": m.get("role"), "content": m.get("content")}
@@ -3457,29 +3383,6 @@ class GatewayRunner:
             except Exception as e:
                 logger.error("Process watcher setup error: %s", e)
 
-            # Drain watch pattern notifications that arrived during the agent run.
-            # Watch events and completions share the same queue; completions are
-            # already handled by the per-process watcher task above, so we only
-            # inject watch-type events here.
-            try:
-                from tools.process_registry import process_registry as _pr
-                _watch_events = []
-                while not _pr.completion_queue.empty():
-                    evt = _pr.completion_queue.get_nowait()
-                    evt_type = evt.get("type", "completion")
-                    if evt_type in ("watch_match", "watch_disabled"):
-                        _watch_events.append(evt)
-                    # else: completion events are handled by the watcher task
-                for evt in _watch_events:
-                    synth_text = _format_gateway_process_notification(evt)
-                    if synth_text:
-                        try:
-                            await self._inject_watch_notification(synth_text, event)
-                        except Exception as e2:
-                            logger.error("Watch notification injection error: %s", e2)
-            except Exception as e:
-                logger.debug("Watch queue drain error: %s", e)
-
             # NOTE: Dangerous command approvals are now handled inline by the
             # blocking gateway approval mechanism in tools/approval.py.  The agent
             # thread blocks until the user responds with /approve or /deny, so by
@@ -3749,7 +3652,7 @@ class GatewayRunner:
             old_entry = self.session_store._entries.get(session_key)
             if old_entry:
                 _flush_task = asyncio.create_task(
-                    self._async_flush_memories(old_entry.session_id, session_key)
+                    self._async_flush_memories(old_entry.session_id)
                 )
                 self._background_tasks.add(_flush_task)
                 _flush_task.add_done_callback(self._background_tasks.discard)
@@ -5070,11 +4973,7 @@ class GatewayRunner:
         _thread_metadata = {"thread_id": source.thread_id} if source.thread_id else None
 
         try:
-            user_config = _load_gateway_config()
-            model, runtime_kwargs = self._resolve_session_agent_runtime(
-                source=source,
-                user_config=user_config,
-            )
+            runtime_kwargs = _resolve_runtime_agent_kwargs()
             if not runtime_kwargs.get("api_key"):
                 await adapter.send(
                     source.chat_id,
@@ -5083,6 +4982,8 @@ class GatewayRunner:
                 )
                 return
 
+            user_config = _load_gateway_config()
+            model = _resolve_gateway_model(user_config)
             platform_key = _platform_config_key(source.platform)
 
             from hermes_cli.tools_config import _get_platform_tools
@@ -5242,12 +5143,7 @@ class GatewayRunner:
         _thread_meta = {"thread_id": source.thread_id} if source.thread_id else None
 
         try:
-            user_config = _load_gateway_config()
-            model, runtime_kwargs = self._resolve_session_agent_runtime(
-                source=source,
-                session_key=session_key,
-                user_config=user_config,
-            )
+            runtime_kwargs = _resolve_runtime_agent_kwargs()
             if not runtime_kwargs.get("api_key"):
                 await adapter.send(
                     source.chat_id,
@@ -5256,6 +5152,8 @@ class GatewayRunner:
                 )
                 return
 
+            user_config = _load_gateway_config()
+            model = _resolve_gateway_model(user_config)
             platform_key = _platform_config_key(source.platform)
             reasoning_config = self._load_reasoning_config()
             self._service_tier = self._load_service_tier()
@@ -5592,14 +5490,13 @@ class GatewayRunner:
             from agent.manual_compression_feedback import summarize_manual_compression
             from agent.model_metadata import estimate_messages_tokens_rough
 
-            session_key = self._session_key_for_source(source)
-            model, runtime_kwargs = self._resolve_session_agent_runtime(
-                source=source,
-                session_key=session_key,
-            )
+            runtime_kwargs = _resolve_runtime_agent_kwargs()
             if not runtime_kwargs.get("api_key"):
                 return "No provider configured -- cannot compress."
 
+            # Resolve model from config (same reason as memory flush above).
+            model = _resolve_gateway_model()
+
             msgs = [
                 {"role": m.get("role"), "content": m.get("content")}
                 for m in history
@@ -5759,7 +5656,7 @@ class GatewayRunner:
         # Flush memories for current session before switching
         try:
             _flush_task = asyncio.create_task(
-                self._async_flush_memories(current_entry.session_id, session_key)
+                self._async_flush_memories(current_entry.session_id)
             )
             self._background_tasks.add(_flush_task)
             _flush_task.add_done_callback(self._background_tasks.discard)
@@ -6758,36 +6655,6 @@ class GatewayRunner:
             return prefix
         return user_text
 
-    async def _inject_watch_notification(self, synth_text: str, original_event) -> None:
-        """Inject a watch-pattern notification as a synthetic message event.
-
-        Uses the source from the original user event to route the notification
-        back to the correct chat/adapter.
-        """
-        source = getattr(original_event, "source", None)
-        if not source:
-            return
-        platform_name = source.platform.value if hasattr(source.platform, "value") else str(source.platform)
-        adapter = None
-        for p, a in self.adapters.items():
-            if p.value == platform_name:
-                adapter = a
-                break
-        if not adapter:
-            return
-        try:
-            from gateway.platforms.base import MessageEvent, MessageType
-            synth_event = MessageEvent(
-                text=synth_text,
-                message_type=MessageType.TEXT,
-                source=source,
-                internal=True,
-            )
-            logger.info("Watch pattern notification — injecting for %s", platform_name)
-            await adapter.handle_message(synth_event)
-        except Exception as e:
-            logger.error("Watch notification injection error: %s", e)
-
     async def _run_process_watcher(self, watcher: dict) -> None:
         """
         Periodically check a background process and push updates to the user.
@@ -7360,12 +7227,10 @@ class GatewayRunner:
             except Exception:
                 pass
 
+            model = _resolve_gateway_model(user_config)
+
             try:
-                model, runtime_kwargs = self._resolve_session_agent_runtime(
-                    source=source,
-                    session_key=session_key,
-                    user_config=user_config,
-                )
+                runtime_kwargs = _resolve_runtime_agent_kwargs()
             except Exception as exc:
                 return {
                     "final_response": f"⚠️ Provider authentication failed: {exc}",
@@ -7374,6 +7239,11 @@ class GatewayRunner:
                     "tools": [],
                 }
 
+            # /model overrides take precedence over config.yaml defaults.
+            model, runtime_kwargs = self._apply_session_model_override(
+                session_key, model, runtime_kwargs
+            )
+
             pr = self._provider_routing
             reasoning_config = self._load_reasoning_config()
             self._reasoning_config = reasoning_config

run_agent.py

@@ -5888,16 +5888,8 @@ class AIAgent:
             api_kwargs["tools"] = self.tools
 
         if self.max_tokens is not None:
-            api_kwargs.update(self._max_tokens_param(self.max_tokens))
-        elif self._is_qwen_portal():
-            # Qwen Portal defaults to a very low max_tokens when omitted.
-            # Reasoning models (qwen3-coder-plus) exhaust that budget on
-            # thinking tokens alone, causing the portal to return
-            # finish_reason="stop" with truncated output — the agent sees
-            # this as an intentional stop and exits the loop.  Send 65536
-            # (the documented max output for qwen3-coder models) so the
-            # model has adequate output budget for tool calls.
-            api_kwargs.update(self._max_tokens_param(65536))
+            if not self._is_qwen_portal():
+                api_kwargs.update(self._max_tokens_param(self.max_tokens))
         elif (self._is_openrouter_url() or "nousresearch" in self._base_url_lower) and "claude" in (self.model or "").lower():
             # OpenRouter and Nous Portal translate requests to Anthropic's
             # Messages API, which requires max_tokens as a mandatory field.

tests/agent/test_model_metadata.py

@@ -222,24 +222,6 @@ class TestGetModelContextLength:
         mock_fetch.return_value = {}
         assert get_model_context_length("openai/gpt-4o") == 128000
 
-    @patch("agent.model_metadata.fetch_model_metadata")
-    def test_qwen3_coder_plus_context_length(self, mock_fetch):
-        """qwen3-coder-plus has a 1M context window, not the generic 128K Qwen default."""
-        mock_fetch.return_value = {}
-        assert get_model_context_length("qwen3-coder-plus") == 1000000
-
-    @patch("agent.model_metadata.fetch_model_metadata")
-    def test_qwen3_coder_context_length(self, mock_fetch):
-        """qwen3-coder has a 256K context window, not the generic 128K Qwen default."""
-        mock_fetch.return_value = {}
-        assert get_model_context_length("qwen3-coder") == 262144
-
-    @patch("agent.model_metadata.fetch_model_metadata")
-    def test_qwen_generic_context_length(self, mock_fetch):
-        """Generic qwen models still get the 128K default."""
-        mock_fetch.return_value = {}
-        assert get_model_context_length("qwen3-plus") == 131072
-
     @patch("agent.model_metadata.fetch_model_metadata")
     def test_api_missing_context_length_key(self, mock_fetch):
         """Model in API but without context_length → defaults to 128000."""

tests/gateway/test_matrix.py

@@ -157,9 +157,7 @@ def _make_fake_mautrix():
     mautrix_crypto_store = types.ModuleType("mautrix.crypto.store")
 
     class MemoryCryptoStore:
-        def __init__(self, account_id="", pickle_key=""):
-            self.account_id = account_id
-            self.pickle_key = pickle_key
+        pass
 
     mautrix_crypto_store.MemoryCryptoStore = MemoryCryptoStore
 

tests/gateway/test_resume_command.py

@@ -221,6 +221,5 @@ class TestHandleResumeCommand:
 
         runner._async_flush_memories.assert_called_once_with(
             "current_session_001",
-            "agent:main:telegram:dm:67890",
         )
         db.close()

tests/gateway/test_session_model_override_routing.py

@@ -1,160 +0,0 @@
-"""Regression tests for session-scoped model/provider overrides in gateway agents.
-
-These cover the bug where `/model ...` stored a session override, but fresh
-agent constructions still resolved model/provider from global config/runtime.
-That let helper agents (and cache-miss main agents) route GPT-5.4 to the wrong
-provider, e.g. Nous instead of OpenAI Codex.
-"""
-
-import asyncio
-import sys
-import threading
-import types
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-import gateway.run as gateway_run
-from gateway.config import Platform
-from gateway.session import SessionSource
-
-
-class _CapturingAgent:
-    """Fake agent that records init kwargs for assertions."""
-
-    last_init = None
-
-    def __init__(self, *args, **kwargs):
-        type(self).last_init = dict(kwargs)
-        self.tools = []
-
-    def run_conversation(self, user_message: str, conversation_history=None, task_id=None):
-        return {
-            "final_response": "ok",
-            "messages": [],
-            "api_calls": 1,
-        }
-
-
-def _make_runner():
-    runner = object.__new__(gateway_run.GatewayRunner)
-    runner.adapters = {}
-    runner.session_store = None
-    runner.config = None
-    runner._voice_mode = {}
-    runner._ephemeral_system_prompt = ""
-    runner._prefill_messages = []
-    runner._reasoning_config = None
-    runner._show_reasoning = False
-    runner._provider_routing = {}
-    runner._fallback_model = None
-    runner._service_tier = None
-    runner._running_agents = {}
-    runner._running_agents_ts = {}
-    runner._background_tasks = set()
-    runner._session_db = None
-    runner._session_model_overrides = {}
-    runner._pending_model_notes = {}
-    runner._pending_approvals = {}
-    runner._agent_cache = {}
-    runner._agent_cache_lock = threading.Lock()
-    runner._get_or_create_gateway_honcho = lambda session_key: (None, None)
-    runner.hooks = MagicMock()
-    runner.hooks.emit = AsyncMock()
-    runner.hooks.loaded_hooks = []
-    return runner
-
-
-def _codex_override():
-    return {
-        "model": "gpt-5.4",
-        "provider": "openai-codex",
-        "api_key": "***",
-        "base_url": "https://chatgpt.com/backend-api/codex",
-        "api_mode": "codex_responses",
-    }
-
-
-def _explode_runtime_resolution():
-    raise AssertionError(
-        "global runtime resolution should not run when a complete session override exists"
-    )
-
-
-def test_run_agent_prefers_session_override_over_global_runtime(monkeypatch):
-    monkeypatch.setattr(gateway_run, "_load_gateway_config", lambda: {})
-    monkeypatch.setattr(gateway_run, "load_dotenv", lambda *args, **kwargs: None)
-    monkeypatch.setattr(gateway_run, "_resolve_runtime_agent_kwargs", _explode_runtime_resolution)
-
-    fake_run_agent = types.ModuleType("run_agent")
-    fake_run_agent.AIAgent = _CapturingAgent
-    monkeypatch.setitem(sys.modules, "run_agent", fake_run_agent)
-
-    _CapturingAgent.last_init = None
-    runner = _make_runner()
-
-    source = SessionSource(
-        platform=Platform.LOCAL,
-        chat_id="cli",
-        chat_name="CLI",
-        chat_type="dm",
-        user_id="user-1",
-    )
-    session_key = "agent:main:local:dm"
-    runner._session_model_overrides[session_key] = _codex_override()
-
-    result = asyncio.run(
-        runner._run_agent(
-            message="ping",
-            context_prompt="",
-            history=[],
-            source=source,
-            session_id="session-1",
-            session_key=session_key,
-        )
-    )
-
-    assert result["final_response"] == "ok"
-    assert _CapturingAgent.last_init is not None
-    assert _CapturingAgent.last_init["model"] == "gpt-5.4"
-    assert _CapturingAgent.last_init["provider"] == "openai-codex"
-    assert _CapturingAgent.last_init["api_mode"] == "codex_responses"
-    assert _CapturingAgent.last_init["base_url"] == "https://chatgpt.com/backend-api/codex"
-    assert _CapturingAgent.last_init["api_key"] == "***"
-
-
-@pytest.mark.asyncio
-async def test_background_task_prefers_session_override_over_global_runtime(monkeypatch):
-    monkeypatch.setattr(gateway_run, "_load_gateway_config", lambda: {})
-    monkeypatch.setattr(gateway_run, "_resolve_runtime_agent_kwargs", _explode_runtime_resolution)
-
-    fake_run_agent = types.ModuleType("run_agent")
-    fake_run_agent.AIAgent = _CapturingAgent
-    monkeypatch.setitem(sys.modules, "run_agent", fake_run_agent)
-
-    _CapturingAgent.last_init = None
-    runner = _make_runner()
-
-    adapter = AsyncMock()
-    adapter.send = AsyncMock()
-    adapter.extract_media = MagicMock(return_value=([], "ok"))
-    adapter.extract_images = MagicMock(return_value=([], "ok"))
-    runner.adapters[Platform.TELEGRAM] = adapter
-
-    source = SessionSource(
-        platform=Platform.TELEGRAM,
-        user_id="12345",
-        chat_id="67890",
-        user_name="testuser",
-    )
-    session_key = runner._session_key_for_source(source)
-    runner._session_model_overrides[session_key] = _codex_override()
-
-    await runner._run_background_task("say hello", source, "bg_test")
-
-    assert _CapturingAgent.last_init is not None
-    assert _CapturingAgent.last_init["model"] == "gpt-5.4"
-    assert _CapturingAgent.last_init["provider"] == "openai-codex"
-    assert _CapturingAgent.last_init["api_mode"] == "codex_responses"
-    assert _CapturingAgent.last_init["base_url"] == "https://chatgpt.com/backend-api/codex"
-    assert _CapturingAgent.last_init["api_key"] == "***"

tests/run_agent/test_run_agent.py

@@ -953,24 +953,14 @@ class TestBuildApiKwargs:
         assert kwargs["messages"][0]["content"][0]["text"] == "hi"
         assert "cache_control" not in kwargs["messages"][0]["content"][0]
 
-    def test_qwen_portal_sends_explicit_max_tokens(self, agent):
-        """When the user explicitly sets max_tokens, it should be sent to Qwen Portal."""
+    def test_qwen_portal_omits_max_tokens(self, agent):
         agent.base_url = "https://portal.qwen.ai/v1"
         agent._base_url_lower = agent.base_url.lower()
         agent.max_tokens = 4096
         messages = [{"role": "system", "content": "sys"}, {"role": "user", "content": "hi"}]
         kwargs = agent._build_api_kwargs(messages)
-        assert kwargs["max_tokens"] == 4096
-
-    def test_qwen_portal_default_max_tokens(self, agent):
-        """When max_tokens is None, Qwen Portal gets a default of 65536
-        to prevent reasoning models from exhausting their output budget."""
-        agent.base_url = "https://portal.qwen.ai/v1"
-        agent._base_url_lower = agent.base_url.lower()
-        agent.max_tokens = None
-        messages = [{"role": "system", "content": "sys"}, {"role": "user", "content": "hi"}]
-        kwargs = agent._build_api_kwargs(messages)
-        assert kwargs["max_tokens"] == 65536
+        assert "max_tokens" not in kwargs
+        assert "max_completion_tokens" not in kwargs
 
 
 class TestBuildAssistantMessage:

tests/tools/test_watch_patterns.py

@@ -1,304 +0,0 @@
-"""Tests for watch_patterns background process monitoring feature.
-
-Covers:
-  - ProcessSession.watch_patterns field
-  - ProcessRegistry._check_watch_patterns() matching + notification
-  - Rate limiting (WATCH_MAX_PER_WINDOW) and overload kill switch
-  - watch_queue population
-  - Checkpoint persistence of watch_patterns
-  - Terminal tool schema includes watch_patterns
-  - Terminal tool handler passes watch_patterns through
-"""
-
-import json
-import queue
-import time
-import pytest
-from unittest.mock import patch
-
-from tools.process_registry import (
-    ProcessRegistry,
-    ProcessSession,
-    WATCH_MAX_PER_WINDOW,
-    WATCH_WINDOW_SECONDS,
-    WATCH_OVERLOAD_KILL_SECONDS,
-)
-
-
-@pytest.fixture()
-def registry():
-    """Create a fresh ProcessRegistry."""
-    return ProcessRegistry()
-
-
-def _make_session(
-    sid="proc_test_watch",
-    command="tail -f app.log",
-    task_id="t1",
-    watch_patterns=None,
-) -> ProcessSession:
-    s = ProcessSession(
-        id=sid,
-        command=command,
-        task_id=task_id,
-        started_at=time.time(),
-        watch_patterns=watch_patterns or [],
-    )
-    return s
-
-
-# =========================================================================
-# ProcessSession field defaults
-# =========================================================================
-
-class TestProcessSessionField:
-    def test_default_empty(self):
-        s = ProcessSession(id="proc_1", command="echo hi")
-        assert s.watch_patterns == []
-        assert s._watch_disabled is False
-        assert s._watch_hits == 0
-        assert s._watch_suppressed == 0
-
-    def test_can_set_patterns(self):
-        s = _make_session(watch_patterns=["ERROR", "WARN"])
-        assert s.watch_patterns == ["ERROR", "WARN"]
-
-
-# =========================================================================
-# Pattern matching + queue population
-# =========================================================================
-
-class TestCheckWatchPatterns:
-    def test_no_patterns_no_notification(self, registry):
-        """No watch_patterns → no notifications."""
-        session = _make_session(watch_patterns=[])
-        registry._check_watch_patterns(session, "ERROR: something broke\n")
-        assert registry.completion_queue.empty()
-
-    def test_no_match_no_notification(self, registry):
-        """Output that doesn't match any pattern → no notification."""
-        session = _make_session(watch_patterns=["ERROR", "FAIL"])
-        registry._check_watch_patterns(session, "INFO: all good\nDEBUG: fine\n")
-        assert registry.completion_queue.empty()
-
-    def test_basic_match(self, registry):
-        """Single matching line triggers a notification."""
-        session = _make_session(watch_patterns=["ERROR"])
-        registry._check_watch_patterns(session, "INFO: ok\nERROR: disk full\n")
-        assert not registry.completion_queue.empty()
-        evt = registry.completion_queue.get_nowait()
-        assert evt["type"] == "watch_match"
-        assert evt["pattern"] == "ERROR"
-        assert "disk full" in evt["output"]
-        assert evt["session_id"] == "proc_test_watch"
-
-    def test_multiple_patterns(self, registry):
-        """First matching pattern is reported."""
-        session = _make_session(watch_patterns=["WARN", "ERROR"])
-        registry._check_watch_patterns(session, "ERROR: bad\nWARN: hmm\n")
-        evt = registry.completion_queue.get_nowait()
-        # ERROR appears first in the output, and we check patterns in order
-        # so "WARN" won't match "ERROR: bad" but "ERROR" will
-        assert evt["pattern"] == "ERROR"
-        assert "bad" in evt["output"]
-
-    def test_disabled_skips(self, registry):
-        """Disabled watch produces no notifications."""
-        session = _make_session(watch_patterns=["ERROR"])
-        session._watch_disabled = True
-        registry._check_watch_patterns(session, "ERROR: boom\n")
-        assert registry.completion_queue.empty()
-
-    def test_hit_counter_increments(self, registry):
-        """Each delivered notification increments _watch_hits."""
-        session = _make_session(watch_patterns=["X"])
-        registry._check_watch_patterns(session, "X\n")
-        assert session._watch_hits == 1
-        registry._check_watch_patterns(session, "X\n")
-        assert session._watch_hits == 2
-
-    def test_output_truncation(self, registry):
-        """Very long matched output is truncated."""
-        session = _make_session(watch_patterns=["X"])
-        # Generate 30 matching lines (more than the 20-line cap)
-        text = "\n".join(f"X line {i}" for i in range(30)) + "\n"
-        registry._check_watch_patterns(session, text)
-        evt = registry.completion_queue.get_nowait()
-        # Should only have 20 lines max
-        assert evt["output"].count("\n") <= 20
-
-
-# =========================================================================
-# Rate limiting
-# =========================================================================
-
-class TestRateLimiting:
-    def test_within_window_limit(self, registry):
-        """Notifications within the rate limit all get delivered."""
-        session = _make_session(watch_patterns=["E"])
-        for i in range(WATCH_MAX_PER_WINDOW):
-            registry._check_watch_patterns(session, f"E {i}\n")
-        assert registry.completion_queue.qsize() == WATCH_MAX_PER_WINDOW
-
-    def test_exceeds_window_limit(self, registry):
-        """Notifications beyond the rate limit are suppressed."""
-        session = _make_session(watch_patterns=["E"])
-        for i in range(WATCH_MAX_PER_WINDOW + 5):
-            registry._check_watch_patterns(session, f"E {i}\n")
-        # Only WATCH_MAX_PER_WINDOW should be in the queue
-        assert registry.completion_queue.qsize() == WATCH_MAX_PER_WINDOW
-        assert session._watch_suppressed == 5
-
-    def test_window_resets(self, registry):
-        """After the window expires, notifications can flow again."""
-        session = _make_session(watch_patterns=["E"])
-        # Fill the window
-        for i in range(WATCH_MAX_PER_WINDOW):
-            registry._check_watch_patterns(session, f"E {i}\n")
-        # One more should be suppressed
-        registry._check_watch_patterns(session, "E extra\n")
-        assert session._watch_suppressed == 1
-
-        # Fast-forward past window
-        session._watch_window_start = time.time() - WATCH_WINDOW_SECONDS - 1
-        registry._check_watch_patterns(session, "E after reset\n")
-        # Should deliver now (window reset)
-        assert registry.completion_queue.qsize() == WATCH_MAX_PER_WINDOW + 1
-
-    def test_suppressed_count_in_next_delivery(self, registry):
-        """Suppressed count is reported in the next successful delivery."""
-        session = _make_session(watch_patterns=["E"])
-        for i in range(WATCH_MAX_PER_WINDOW):
-            registry._check_watch_patterns(session, f"E {i}\n")
-        # Suppress 3 more
-        for i in range(3):
-            registry._check_watch_patterns(session, f"E suppressed {i}\n")
-        assert session._watch_suppressed == 3
-
-        # Fast-forward past window to allow delivery
-        session._watch_window_start = time.time() - WATCH_WINDOW_SECONDS - 1
-        registry._check_watch_patterns(session, "E back\n")
-        # Drain to the last event
-        last_evt = None
-        while not registry.completion_queue.empty():
-            last_evt = registry.completion_queue.get_nowait()
-        assert last_evt["suppressed"] == 3
-        assert session._watch_suppressed == 0  # reset after delivery
-
-
-# =========================================================================
-# Overload kill switch
-# =========================================================================
-
-class TestOverloadKillSwitch:
-    def test_sustained_overload_disables(self, registry):
-        """Sustained overload beyond threshold permanently disables watching."""
-        session = _make_session(watch_patterns=["E"])
-        # Fill the window to trigger rate limit
-        for i in range(WATCH_MAX_PER_WINDOW):
-            registry._check_watch_patterns(session, f"E {i}\n")
-
-        # Simulate sustained overload: set overload_since to past threshold
-        session._watch_overload_since = time.time() - WATCH_OVERLOAD_KILL_SECONDS - 1
-        # Force another suppressed hit
-        registry._check_watch_patterns(session, "E overload\n")
-        registry._check_watch_patterns(session, "E overload2\n")
-
-        assert session._watch_disabled is True
-        # Should have a watch_disabled event in the queue
-        disabled_evts = []
-        while not registry.completion_queue.empty():
-            evt = registry.completion_queue.get_nowait()
-            if evt.get("type") == "watch_disabled":
-                disabled_evts.append(evt)
-        assert len(disabled_evts) == 1
-        assert "too many matches" in disabled_evts[0]["message"]
-
-    def test_overload_resets_on_delivery(self, registry):
-        """Overload timer resets when a notification gets through."""
-        session = _make_session(watch_patterns=["E"])
-        # Start overload tracking
-        session._watch_overload_since = time.time() - 10
-        # But window allows delivery → overload should reset
-        registry._check_watch_patterns(session, "E ok\n")
-        assert session._watch_overload_since == 0.0
-        assert session._watch_disabled is False
-
-
-# =========================================================================
-# Checkpoint persistence
-# =========================================================================
-
-class TestCheckpointPersistence:
-    def test_watch_patterns_in_checkpoint(self, registry):
-        """watch_patterns is included in checkpoint data."""
-        session = _make_session(watch_patterns=["ERROR", "FAIL"])
-        with registry._lock:
-            registry._running[session.id] = session
-
-        with patch("utils.atomic_json_write") as mock_write:
-            registry._write_checkpoint()
-            args = mock_write.call_args
-            entries = args[0][1]  # second positional arg
-            assert len(entries) == 1
-            assert entries[0]["watch_patterns"] == ["ERROR", "FAIL"]
-
-    def test_watch_patterns_recovery(self, registry, tmp_path, monkeypatch):
-        """watch_patterns survives checkpoint recovery."""
-        import tools.process_registry as pr_mod
-        checkpoint = tmp_path / "processes.json"
-        checkpoint.write_text(json.dumps([{
-            "session_id": "proc_recovered",
-            "command": "tail -f log",
-            "pid": 99999999,  # non-existent
-            "pid_scope": "host",
-            "started_at": time.time(),
-            "task_id": "",
-            "session_key": "",
-            "watcher_platform": "",
-            "watcher_chat_id": "",
-            "watcher_thread_id": "",
-            "watcher_interval": 0,
-            "notify_on_complete": False,
-            "watch_patterns": ["PANIC", "OOM"],
-        }]))
-        monkeypatch.setattr(pr_mod, "CHECKPOINT_PATH", checkpoint)
-        # PID doesn't exist, so nothing will be recovered
-        count = registry.recover_from_checkpoint()
-        # Won't recover since PID is fake, but verify the code path doesn't crash
-        assert count == 0
-
-
-# =========================================================================
-# Terminal tool schema + handler
-# =========================================================================
-
-class TestTerminalToolSchema:
-    def test_schema_includes_watch_patterns(self):
-        from tools.terminal_tool import TERMINAL_SCHEMA
-        props = TERMINAL_SCHEMA["parameters"]["properties"]
-        assert "watch_patterns" in props
-        assert props["watch_patterns"]["type"] == "array"
-        assert props["watch_patterns"]["items"] == {"type": "string"}
-
-    def test_handler_passes_watch_patterns(self):
-        """_handle_terminal passes watch_patterns to terminal_tool."""
-        from tools.terminal_tool import _handle_terminal
-        with patch("tools.terminal_tool.terminal_tool") as mock_tt:
-            mock_tt.return_value = json.dumps({"output": "ok", "exit_code": 0})
-            _handle_terminal(
-                {"command": "echo hi", "watch_patterns": ["ERR"]},
-                task_id="t1",
-            )
-            _, kwargs = mock_tt.call_args
-            assert kwargs.get("watch_patterns") == ["ERR"]
-
-
-# =========================================================================
-# Code execution tool blocked params
-# =========================================================================
-
-class TestCodeExecutionBlocked:
-    def test_watch_patterns_blocked(self):
-        from tools.code_execution_tool import _TERMINAL_BLOCKED_PARAMS
-        assert "watch_patterns" in _TERMINAL_BLOCKED_PARAMS

tools/code_execution_tool.py

@@ -301,7 +301,7 @@ def _call(tool_name, args):
 # ---------------------------------------------------------------------------
 
 # Terminal parameters that must not be used from ephemeral sandbox scripts
-_TERMINAL_BLOCKED_PARAMS = {"background", "check_interval", "pty", "notify_on_complete", "watch_patterns"}
+_TERMINAL_BLOCKED_PARAMS = {"background", "check_interval", "pty", "notify_on_complete"}
 
 
 def _rpc_server_loop(

tools/process_registry.py

@@ -58,11 +58,6 @@ MAX_OUTPUT_CHARS = 200_000      # 200KB rolling output buffer
 FINISHED_TTL_SECONDS = 1800     # Keep finished processes for 30 minutes
 MAX_PROCESSES = 64              # Max concurrent tracked processes (LRU pruning)
 
-# Watch pattern rate limiting
-WATCH_MAX_PER_WINDOW = 8        # Max notifications delivered per window
-WATCH_WINDOW_SECONDS = 10       # Rolling window length
-WATCH_OVERLOAD_KILL_SECONDS = 45  # Sustained overload duration before disabling watch
-
 
 @dataclass
 class ProcessSession:
@@ -88,14 +83,6 @@ class ProcessSession:
     watcher_thread_id: str = ""
     watcher_interval: int = 0                   # 0 = no watcher configured
     notify_on_complete: bool = False             # Queue agent notification on exit
-    # Watch patterns — trigger agent notification when output matches any pattern
-    watch_patterns: List[str] = field(default_factory=list)
-    _watch_hits: int = field(default=0, repr=False)          # total matches delivered
-    _watch_suppressed: int = field(default=0, repr=False)    # matches dropped by rate limit
-    _watch_overload_since: float = field(default=0.0, repr=False)  # when sustained overload began
-    _watch_disabled: bool = field(default=False, repr=False) # permanently killed by overload
-    _watch_window_hits: int = field(default=0, repr=False)   # hits in current rate window
-    _watch_window_start: float = field(default=0.0, repr=False)
     _lock: threading.Lock = field(default_factory=threading.Lock)
     _reader_thread: Optional[threading.Thread] = field(default=None, repr=False)
     _pty: Any = field(default=None, repr=False)  # ptyprocess handle (when use_pty=True)
@@ -127,10 +114,9 @@ class ProcessRegistry:
         # Side-channel for check_interval watchers (gateway reads after agent run)
         self.pending_watchers: List[Dict[str, Any]] = []
 
-        # Notification queue — unified queue for all background process events.
-        # Completion notifications (notify_on_complete) and watch pattern matches
-        # both land here, distinguished by "type" field.  CLI process_loop and
-        # gateway drain this after each agent turn to auto-trigger new turns.
+        # Completion notifications — processes with notify_on_complete push here
+        # on exit.  CLI process_loop and gateway drain this after each agent turn
+        # to auto-trigger a new agent turn with the process results.
         import queue as _queue_mod
         self.completion_queue: _queue_mod.Queue = _queue_mod.Queue()
 
@@ -142,84 +128,6 @@ class ProcessRegistry:
             lines.pop(0)
         return "\n".join(lines)
 
-    def _check_watch_patterns(self, session: ProcessSession, new_text: str) -> None:
-        """Scan new output for watch patterns and queue notifications.
-
-        Called from reader threads with new_text being the freshly-read chunk.
-        Rate-limited: max WATCH_MAX_PER_WINDOW notifications per WATCH_WINDOW_SECONDS.
-        If sustained overload exceeds WATCH_OVERLOAD_KILL_SECONDS, watching is
-        disabled permanently for this process.
-        """
-        if not session.watch_patterns or session._watch_disabled:
-            return
-
-        # Scan new text line-by-line for pattern matches
-        matched_lines = []
-        matched_pattern = None
-        for line in new_text.splitlines():
-            for pat in session.watch_patterns:
-                if pat in line:
-                    matched_lines.append(line.rstrip())
-                    if matched_pattern is None:
-                        matched_pattern = pat
-                    break  # one match per line is enough
-
-        if not matched_lines:
-            return
-
-        now = time.time()
-        with session._lock:
-            # Reset window if it's expired
-            if now - session._watch_window_start >= WATCH_WINDOW_SECONDS:
-                session._watch_window_hits = 0
-                session._watch_window_start = now
-
-            # Check rate limit
-            if session._watch_window_hits >= WATCH_MAX_PER_WINDOW:
-                session._watch_suppressed += len(matched_lines)
-
-                # Track sustained overload for kill switch
-                if session._watch_overload_since == 0.0:
-                    session._watch_overload_since = now
-                elif now - session._watch_overload_since > WATCH_OVERLOAD_KILL_SECONDS:
-                    session._watch_disabled = True
-                    self.completion_queue.put({
-                        "session_id": session.id,
-                        "command": session.command,
-                        "type": "watch_disabled",
-                        "suppressed": session._watch_suppressed,
-                        "message": (
-                            f"Watch patterns disabled for process {session.id} — "
-                            f"too many matches ({session._watch_suppressed} suppressed). "
-                            f"Use process(action='poll') to check output manually."
-                        ),
-                    })
-                return
-
-            # Under the rate limit — deliver notification
-            session._watch_window_hits += 1
-            session._watch_hits += 1
-            # Clear overload tracker since we got a delivery through
-            session._watch_overload_since = 0.0
-
-            # Include suppressed count if any events were dropped
-            suppressed = session._watch_suppressed
-            session._watch_suppressed = 0
-
-        # Trim matched output to a reasonable size
-        output = "\n".join(matched_lines[:20])
-        if len(output) > 2000:
-            output = output[:2000] + "\n...(truncated)"
-
-        self.completion_queue.put({
-            "session_id": session.id,
-            "command": session.command,
-            "type": "watch_match",
-            "pattern": matched_pattern,
-            "output": output,
-            "suppressed": suppressed,
-        })
-
     @staticmethod
     def _is_host_pid_alive(pid: Optional[int]) -> bool:
         """Best-effort liveness check for host-visible PIDs."""
@@ -486,7 +394,6 @@ class ProcessRegistry:
                     session.output_buffer += chunk
                     if len(session.output_buffer) > session.max_output_chars:
                         session.output_buffer = session.output_buffer[-session.max_output_chars:]
-                self._check_watch_patterns(session, chunk)
         except Exception as e:
             logger.debug("Process stdout reader ended: %s", e)
         finally:
@@ -506,7 +413,6 @@ class ProcessRegistry:
         quoted_log_path = shlex.quote(log_path)
         quoted_pid_path = shlex.quote(pid_path)
         quoted_exit_path = shlex.quote(exit_path)
-        prev_output_len = 0  # track delta for watch pattern scanning
         while not session.exited:
             time.sleep(2)  # Poll every 2 seconds
             try:
@@ -514,15 +420,10 @@ class ProcessRegistry:
                 result = env.execute(f"cat {quoted_log_path} 2>/dev/null", timeout=10)
                 new_output = result.get("output", "")
                 if new_output:
-                    # Compute delta for watch pattern scanning
-                    delta = new_output[prev_output_len:] if len(new_output) > prev_output_len else ""
-                    prev_output_len = len(new_output)
                     with session._lock:
                         session.output_buffer = new_output
                         if len(session.output_buffer) > session.max_output_chars:
                             session.output_buffer = session.output_buffer[-session.max_output_chars:]
-                    if delta:
-                        self._check_watch_patterns(session, delta)
 
                 # Check if process is still running
                 check = env.execute(
@@ -566,7 +467,6 @@ class ProcessRegistry:
                             session.output_buffer += text
                             if len(session.output_buffer) > session.max_output_chars:
                                 session.output_buffer = session.output_buffer[-session.max_output_chars:]
-                        self._check_watch_patterns(session, text)
                 except EOFError:
                     break
                 except Exception:
@@ -602,7 +502,6 @@ class ProcessRegistry:
             from tools.ansi_strip import strip_ansi
             output_tail = strip_ansi(session.output_buffer[-2000:]) if session.output_buffer else ""
             self.completion_queue.put({
-                "type": "completion",
                 "session_id": session.id,
                 "command": session.command,
                 "exit_code": session.exit_code,
@@ -973,7 +872,6 @@ class ProcessRegistry:
                             "watcher_thread_id": s.watcher_thread_id,
                             "watcher_interval": s.watcher_interval,
                             "notify_on_complete": s.notify_on_complete,
-                            "watch_patterns": s.watch_patterns,
                         })
             
             # Atomic write to avoid corruption on crash
@@ -1034,7 +932,6 @@ class ProcessRegistry:
                     watcher_thread_id=entry.get("watcher_thread_id", ""),
                     watcher_interval=entry.get("watcher_interval", 0),
                     notify_on_complete=entry.get("notify_on_complete", False),
-                    watch_patterns=entry.get("watch_patterns", []),
                 )
                 with self._lock:
                     self._running[session.id] = session

tools/terminal_tool.py

@@ -42,7 +42,7 @@ import atexit
 import shutil
 import subprocess
 from pathlib import Path
-from typing import Optional, Dict, Any, List
+from typing import Optional, Dict, Any
 
 logger = logging.getLogger(__name__)
 
@@ -1140,7 +1140,6 @@ def terminal_tool(
     check_interval: Optional[int] = None,
     pty: bool = False,
     notify_on_complete: bool = False,
-    watch_patterns: Optional[List[str]] = None,
 ) -> str:
     """
     Execute a command in the configured terminal environment.
@@ -1155,7 +1154,6 @@ def terminal_tool(
         check_interval: Seconds between auto-checks for background processes (gateway only, min 30)
         pty: If True, use pseudo-terminal for interactive CLI tools (local backend only)
         notify_on_complete: If True and background=True, auto-notify the agent when the process exits
-        watch_patterns: List of strings to watch for in background output; triggers notification on match
 
     Returns:
         str: JSON string with output, exit_code, and error fields
@@ -1441,11 +1439,6 @@ def terminal_tool(
                             "notify_on_complete": True,
                         })
 
-                # Set watch patterns for output monitoring
-                if watch_patterns and background:
-                    proc_session.watch_patterns = list(watch_patterns)
-                    result_data["watch_patterns"] = proc_session.watch_patterns
-
                 # Register check_interval watcher (gateway picks this up after agent run)
                 if check_interval and background:
                     effective_interval = max(30, check_interval)
@@ -1769,11 +1762,6 @@ TERMINAL_SCHEMA = {
                 "type": "boolean",
                 "description": "When true (and background=true), you'll be automatically notified when the process finishes — no polling needed. Use this for tasks that take a while (tests, builds, deployments) so you can keep working on other things in the meantime.",
                 "default": False
-            },
-            "watch_patterns": {
-                "type": "array",
-                "items": {"type": "string"},
-                "description": "List of strings to watch for in background process output. When any pattern matches a line of output, you'll be notified with the matching text — like notify_on_complete but triggers mid-process on specific output. Use for monitoring logs, watching for errors, or waiting for specific events (e.g. [\"ERROR\", \"FAIL\", \"listening on port\"])."
             }
         },
         "required": ["command"]
@@ -1791,7 +1779,6 @@ def _handle_terminal(args, **kw):
         check_interval=args.get("check_interval"),
         pty=args.get("pty", False),
         notify_on_complete=args.get("notify_on_complete", False),
-        watch_patterns=args.get("watch_patterns"),
     )