{"repo":"NousResearch/hermes-agent","public_id":"1143","display_label":"Background task notifications routed to wrong session","summary":"These issues and fixes consistently address a problem where async delegate task results, background process notifications, and related events are delivered to the wrong session, thread, or channel. Several fixes involve replacing process-level environment state with context variables to correctly preserve session identity across concurrent operations.","subsystem":"agent","counts":{"members":44,"open_issues":1,"open_issues_distinct":1,"open_prs":4,"closed_issues":15,"merged_prs":9,"attempt_prs":19},"landed_fix":{"status":"merged_to_main","basis":"structural","pr":1706},"resolution":{"state":"partially_resolved","by":"pr-1706,pr-7454,pr-10460,pr-60869,pr-60871,pr-64593,pr-65419"},"freshness":{"state":"verified","last_verified_at":"2026-07-16T06:51:43+00:00","is_stale":false},"grouping":{"backbone":"STRUCTURAL_PARTIAL","link_density":0.04456659619450315},"fix_edges":[{"issue_number":1143,"pr_number":1706,"tier":"verified","basis":"closing_ref","confidence":0.95,"recoverable_from_timeline":true},{"issue_number":7358,"pr_number":7454,"tier":"verified","basis":"closing_ref","confidence":0.95,"recoverable_from_timeline":true},{"issue_number":7390,"pr_number":7454,"tier":"verified","basis":"closing_ref","confidence":0.95,"recoverable_from_timeline":true},{"issue_number":9532,"pr_number":10460,"tier":"verified","basis":"closing_ref","confidence":0.95,"recoverable_from_timeline":true},{"issue_number":35652,"pr_number":37099,"tier":"verified","basis":"superseded_ref","confidence":0.9,"recoverable_from_timeline":false},{"issue_number":35652,"pr_number":60863,"tier":"verified","basis":"superseded_ref","confidence":0.9,"recoverable_from_timeline":false},{"issue_number":35652,"pr_number":65419,"tier":"verified","basis":"closing_ref","confidence":0.95,"recoverable_from_timeline":true},{"issue_number":42674,"pr_number":65419,"tier":"verified","basis":"superseded_ref","confidence":0.9,"recoverable_from_timeline":false},{"issue_number":57498,"pr_number":60871,"tier":"verified","basis":"closing_ref","confidence":0.95,"recoverable_from_timeline":true},{"issue_number":57576,"pr_number":60863,"tier":"verified","basis":"superseded_ref","confidence":0.9,"recoverable_from_timeline":false},{"issue_number":58684,"pr_number":60869,"tier":"verified","basis":"closing_ref","confidence":0.95,"recoverable_from_timeline":true},{"issue_number":64484,"pr_number":64593,"tier":"verified","basis":"closing_ref","confidence":0.95,"recoverable_from_timeline":true}],"members":[{"kind":"issue","number":1143,"title":"Telegram background process notifications ignore forum topic and post to General","url":null,"state":"closed"},{"kind":"issue","number":7358,"title":"Bug: Concurrent gateway messages cause cross-thread misrouting of background task notifications (os.environ state leakage)","url":null,"state":"closed"},{"kind":"issue","number":9532,"title":"[Bug]: background process watch notifications can leak into the wrong threaded session","url":null,"state":"closed"},{"kind":"issue","number":9736,"title":"Bug: Background process completion notifications can route to the wrong session","url":null,"state":"closed"},{"kind":"issue","number":10411,"title":"[Bug]: Background watch_match notifications can be injected into the wrong Discord thread","url":null,"state":"closed"},{"kind":"issue","number":18101,"title":"[Bug]: Background process updates can leak into the wrong Slack thread","url":null,"state":"closed"},{"kind":"issue","number":35652,"title":"TUI: background process completion notifications can route to the wrong live session","url":null,"state":"closed"},{"kind":"issue","number":42674,"title":"[Bug]: Background process notify_on_complete leaks into wrong TUI session (cross-session bleed)","url":null,"state":"closed"},{"kind":"issue","number":52447,"title":"Background process notifications route to active session instead of originating session","url":null,"state":"closed"},{"kind":"issue","number":57498,"title":"delegate_task background results routed to wrong session (cross-channel contamination)","url":null,"state":"closed"},{"kind":"issue","number":57502,"title":"Bug: delegate_task sub-agent results routed to wrong session (parent session ID lost on write-back)","url":null,"state":"closed"},{"kind":"issue","number":57576,"title":"Async delegation result delivered to wrong TUI session after context compression","url":null,"state":"closed"},{"kind":"issue","number":58684,"title":"bug: delegate_task async results delivered to wrong session/thread","url":null,"state":"closed"},{"kind":"issue","number":60426,"title":"Background process notifications routed to wrong session","url":null,"state":"closed"},{"kind":"issue","number":64484,"title":"[Bug]: New CLI session adopts a dead session's async delegation completions (durable restore bypasses CLI drain ownership)","url":null,"state":"closed"},{"kind":"issue","number":65407,"title":"[Bug]: residual HERMES_SESSION_* readers prefer process env over task ContextVars","url":null,"state":"open"},{"kind":"pr","number":1573,"title":"fix(gateway): persist watcher metadata in checkpoint for crash recovery","url":null,"state":"closed","close_reason":{"refs":[{"kind":"pr","value":"#1706","number":1706}],"category":"merged_via","implication":"superseded"},"merged":false},{"kind":"pr","number":1706,"title":"fix(gateway): persist watcher metadata in checkpoint for crash recovery (salvaged #1573)","url":null,"state":"merged","close_reason":{"category":"merged","implication":"superseded"},"merged":true,"is_fix_pr":true,"fix_tier":"verified","files_changed":["gateway/run.py","tests/gateway/test_background_process_notifications.py","tests/tools/test_process_registry.py","tools/process_registry.py","tools/terminal_tool.py"]},{"kind":"pr","number":7391,"title":"fix(gateway): replace os.environ session state with contextvars to prevent concurrent message cross-contamination","url":null,"state":"closed","close_reason":{"refs":[{"kind":"pr","value":"#7454","number":7454}],"category":"merged_via","implication":"superseded"},"merged":false},{"kind":"pr","number":7454,"title":"fix(gateway): replace os.environ session state with contextvars + fix skill frontmatter truncation","url":null,"state":"merged","close_reason":{"category":"merged","implication":"superseded"},"merged":true,"is_fix_pr":true,"fix_tier":"verified","files_changed":["agent/prompt_builder.py","agent/skill_utils.py","gateway/run.py","gateway/session_context.py","tests/gateway/test_session_env.py","tools/cronjob_tools.py","tools/send_message_tool.py","tools/skills_tool.py","tools/terminal_tool.py","tools/tts_tool.py"],"fix_hunks":[{"file":"agent/prompt_builder.py","hunks":["@@ -487,7 +487,7 @@ def _parse_skill_file(skill_file: Path) -> tuple[bool, dict, str]:\n (True, {}, \"\") to err on the side of showing the skill.\n \"\"\"\n try:\n- raw = skill_file.read_text(encoding=\"utf-8\")[:2000]\n+ raw = skill_file.read_text(encoding=\"utf-8\")\n frontmatter, _ = parse_frontmatter(raw)\n \n if not skill_matches_platform(frontmatter):","@@ -495,7 +495,7 @@ def _parse_skill_file(skill_file: Path) -> tuple[bool, dict, str]:\n \n return True, frontmatter, extract_skill_description(frontmatter)\n except Exception as e:\n- logger.debug(\"Failed to parse skill file %s: %s\", skill_file, e)\n+ logger.warning(\"Failed to parse skill file %s: %s\", skill_file, e)\n return True, {}, \"\"\n \n ","@@ -558,9 +558,10 @@ def build_skills_system_prompt(\n # ── Layer 1: in-process LRU cache ─────────────────────────────────\n # Include the resolved platform so per-platform disabled-skill lists\n # produce distinct cache entries (gateway serves multiple platforms).\n+ from gateway.session_context import get_session_env\n _platform_hint = (\n os.environ.get(\"HERMES_PLATFORM\")\n- or os.environ.get(\"HERMES_SESSION_PLATFORM\")\n+ or get_session_env(\"HERMES_SESSION_PLATFORM\")\n or \"\"\n )\n cache_key = ("]},{"file":"agent/skill_utils.py","hunks":["@@ -145,10 +145,11 @@ def get_disabled_skill_names(platform: str | None = None) -> Set[str]:\n if not isinstance(skills_cfg, dict):\n return set()\n \n+ from gateway.session_context import get_session_env\n resolved_platform = (\n platform\n or os.getenv(\"HERMES_PLATFORM\")\n- or os.getenv(\"HERMES_SESSION_PLATFORM\")\n+ or get_session_env(\"HERMES_SESSION_PLATFORM\")\n )\n if resolved_platform:\n platform_disabled = (skills_cfg.get(\"platform_disabled\") or {}).get("]},{"file":"gateway/run.py","hunks":["@@ -2400,8 +2400,8 @@ async def _handle_message_with_agent(self, event, source, _quick_key: str):\n # Build session context\n context = build_session_context(source, self.config, session_entry)\n \n- # Set environment variables for tools\n- self._set_session_env(context)\n+ # Set session context variables for tools (task-local, concurrency-safe)\n+ _session_env_tokens = [redacted:secret-assignment]\n \n # Read privacy.redact_pii from config (re-read per message)\n _redact_pii = False","@@ -3234,8 +3234,8 @@ async def _handle_message_with_agent(self, event, source, _quick_key: str):\n \"Try again or use /reset to start a fresh session.\"\n )\n finally:\n- # Clear session env\n- self._clear_session_env()\n+ # Restore session context variables to their pre-handler state\n+ self._clear_session_env(_session_env_tokens)\n \n def _format_session_info(self) -> str:\n \"\"\"Resolve current model config and return a formatted info block.","@@ -6120,20 +6120,27 @@ async def _send_update_notification(self) -> bool:\n \n return True\n \n- def _set_session_env(self, context: SessionContext) -> None:\n- \"\"\"Set environment variables for the current session.\"\"\"\n- os.environ[\"HERMES_SESSION_PLATFORM\"] = context.source.platform.value\n- os.environ[\"HERMES_SESSION_CHAT_ID\"] = context.source.chat_id\n- if context.source.chat_name:\n- os.environ[\"HERMES_SESSION_CHAT_NAME\"] = context.source.chat_name\n- if context.source.thread_id:\n- os.environ[\"HERMES_SESSION_THREAD_ID\"] = str(context.source.thread_id)\n- \n- def _clear_session_env(self) -> None:\n- \"\"\"Clear session environment variables.\"\"\"\n- for var in [\"HERMES_SESSION_PLATFORM\", \"HERMES_SESSION_CHAT_ID\", \"HERMES_SESSION_CHAT_NAME\", \"HERMES_SESSION_THREAD_ID\"]:\n- if var in os.environ:\n- del os.environ[var]\n+ def _set_session_env(self, context: SessionContext) -> list:\n+ \"\"\"Set session context variables for the current async task.\n+\n+ Uses ``contextvars`` instead of ``os.environ`` so that concurrent\n+ gateway messages cannot overwrite each other's session state.\n+\n+ Returns a list of reset tokens; pass them to ``_clear_session_env``\n+ in a ``finally`` block.\n+ \"\"\"\n+ from gateway.session_context import set_session_vars\n+ return set_session_vars(\n+ platform=context.source.platform.value,\n+ chat_id=context.source.chat_id,\n+ chat_name=context.source.chat_name or \"\",\n+ thread_id=str(context.source.thread_id) if context.source.thread_id else \"\",\n+ )\n+\n+ def _clear_session_env(self, tokens: list) -> None:\n+ \"\"\"Restore session context variables to their pre-handler values.\"\"\"\n+ from gateway.session_context import clear_session_vars\n+ clear_session_vars(tokens)\n \n async def _enrich_message_with_vision(\n self,"]},{"file":"gateway/session_context.py","hunks":["@@ -0,0 +1,113 @@\n+\"\"\"\n+Session-scoped context variables for the Hermes gateway.\n+\n+Replaces the previous ``os.environ``-based session state\n+(``HERMES_SESSION_PLATFORM``, ``HERMES_SESSION_CHAT_ID``, etc.) with\n+Python's ``contextvars.ContextVar``.\n+\n+**Why this matters**\n+\n+The gateway processes messages concurrently via ``asyncio``. When two\n+messages arrive at the same time the old code did:\n+\n+ os.environ[\"HERMES_SESSION_THREAD_ID\"] = str(context.source.thread_id)\n+\n+Because ``os.environ`` is *process-global*, Message A's value was\n+silently overwritten by Message B before Message A's agent finished\n+running. Background-task notifications and tool calls therefore routed\n+to the wrong thread.\n+\n+``contextvars.ContextVar`` values are *task-local*: each ``asyncio``\n+task (and any ``run_in_executor`` thread it spawns) gets its own copy,\n+so concurrent messages never interfere.\n+\n+**Backward compatibility**\n+\n+The public helper ``get_session_env(name, default=\"\")`` mirrors the old\n+``os.getenv(\"HERMES_SESSION_*\", ...)`` calls. Existing tool code only\n+needs to replace the import + call site:\n+\n+ # before\n+ import os\n+ platform = os.getenv(\"HERMES_SESSION_PLATFORM\", \"\")\n+\n+ # after\n+ from gateway.session_context import get_session_env\n+ platform = get_session_env(\"HERMES_SESSION_PLATFORM\", \"\")\n+\"\"\"\n+\n+from contextvars import ContextVar\n+\n+# ---------------------------------------------------------------------------\n+# Per-task session variables\n+# ---------------------------------------------------------------------------\n+\n+_SESSION_PLATFORM: ContextVar[str] = ContextVar(\"HERMES_SESSION_PLATFORM\", default=\"\")\n+_SESSION_CHAT_ID: ContextVar[str] = ContextVar(\"HERMES_SESSION_CHAT_ID\", default=\"\")\n+_SESSION_CHAT_NAME: ContextVar[str] = ContextVar(\"HERMES_SESSION_CHAT_NAME\", default=\"\")\n+_SESSION_THREAD_ID: ContextVar[str] = ContextVar(\"HERMES_SESSION_THREAD_ID\", default=\"\")\n+\n+_VAR_MAP = {\n+ \"HERMES_SESSION_PLATFORM\": _SESSION_PLATFORM,\n+ \"HERMES_SESSION_CHAT_ID\": _SESSION_CHAT_ID,\n+ \"HERMES_SESSION_CHAT_NAME\": _SESSION_CHAT_NAME,\n+ \"HERMES_SESSION_THREAD_ID\": _SESSION_THREAD_ID,\n+}\n+\n+\n+def set_session_vars(\n+ platform: str = \"\",\n+ chat_id: str = \"\",\n+ chat_name: str = \"\",\n+ thread_id: str = \"\",\n+) -> list:\n+ \"\"\"Set all session context variables and return reset tokens.\n+\n+ Call ``clear_session_vars(tokens)`` in a ``finally`` block to restore\n+ the previous values when the handler exits.\n+\n+ Returns a list of ``Token`` objects (one per variable) that can be\n+ passed to ``clear_session_vars``.\n+ \"\"\"\n+ tokens = [\n+ _SESSION_PLATFORM.set(platform),\n+ _SESSION_CHAT_ID.set(chat_id),\n+ _SESSION_CHAT_NAME.set(chat_name),\n+ _SESSION_THREAD_ID.set(thread_id),\n+ ]\n+ return tokens\n+\n+\n+def clear_session_vars(tokens: list) -> None:\n+ \"\"\"Restore session context variables to their pre-handler values.\"\"\"\n+ if not tokens:\n+ return\n+ vars_in_order = [\n+ _SESSION_PLATFORM,\n+ _SESSION_CHAT_ID,\n+ _SESSION_CHAT_NAME,\n+ _SESSION_THREAD_ID,\n+ ]\n+ for var, token in zip(vars_in_order, tokens):\n+ var.reset(token)\n+\n+\n+def get_session_env(name: str, default: str = \"\") -> str:\n+ \"\"\"Read a session context variable by its legacy ``HERMES_SESSION_*`` name.\n+\n+ Drop-in replacement for ``os.getenv(\"HERMES_SESSION_*\", default)``.\n+\n+ Resolution order:\n+ 1. Context variable (set by the gateway for concurrency-safe access)\n+ 2. ``os.environ`` (used by CLI, cron scheduler, and tests)\n+ 3. *default*\n+ \"\"\"\n+ import os\n+\n+ var = _VAR_MAP.get(name)\n+ if var is not None:\n+ value = var.get()\n+ if value:\n+ return value\n+ # Fall back to os.environ for CLI, cron, and test compatibility\n+ return os.getenv(name, default)"]},{"file":"tests/gateway/test_session_env.py","hunks":["@@ -3,9 +3,15 @@\n from gateway.config import Platform\n from gateway.run import GatewayRunner\n from gateway.session import SessionContext, SessionSource\n+from gateway.session_context import (\n+ get_session_env,\n+ set_session_vars,\n+ clear_session_vars,\n+)\n \n \n-def test_set_session_env_includes_thread_id(monkeypatch):\n+def test_set_session_env_sets_contextvars(monkeypatch):\n+ \"\"\"_set_session_env should populate contextvars, not os.environ.\"\"\"\n runner = object.__new__(GatewayRunner)\n source = SessionSource(\n platform=Platform.TELEGRAM,","@@ -21,25 +27,93 @@ def test_set_session_env_includes_thread_id(monkeypatch):\n monkeypatch.delenv(\"HERMES_SESSION_CHAT_NAME\", raising=False)\n monkeypatch.delenv(\"HERMES_SESSION_THREAD_ID\", raising=False)\n \n- runner._set_session_env(context)\n+ tokens = [redacted:secret-assignment]\n \n- assert os.getenv(\"HERMES_SESSION_PLATFORM\") == \"telegram\"\n- assert os.getenv(\"HERMES_SESSION_CHAT_ID\") == \"-1001\"\n- assert os.getenv(\"HERMES_SESSION_CHAT_NAME\") == \"Group\"\n- assert os.getenv(\"HERMES_SESSION_THREAD_ID\") == \"17585\"\n+ # Values should be readable via get_session_env (contextvar path)\n+ assert get_session_env(\"HERMES_SESSION_PLATFORM\") == \"telegram\"\n+ assert get_session_env(\"HERMES_SESSION_CHAT_ID\") == \"-1001\"\n+ assert get_session_env(\"HERMES_SESSION_CHAT_NAME\") == \"Group\"\n+ assert get_session_env(\"HERMES_SESSION_THREAD_ID\") == \"17585\"\n \n+ # os.environ should NOT be touched\n+ assert os.getenv(\"HERMES_SESSION_PLATFORM\") is None\n+ assert os.getenv(\"HERMES_SESSION_THREAD_ID\") is None\n+\n+ # Clean up\n+ runner._clear_session_env(tokens)\n \n-def test_clear_session_env_removes_thread_id(monkeypatch):\n+\n+def test_clear_session_env_restores_previous_state(monkeypatch):\n+ \"\"\"_clear_session_env should restore contextvars to their pre-handler values.\"\"\"\n runner = object.__new__(GatewayRunner)\n \n- monkeypatch.setenv(\"HERMES_SESSION_PLATFORM\", \"telegram\")\n- monkeypatch.setenv(\"HERMES_SESSION_CHAT_ID\", \"-1001\")\n- monkeypatch.setenv(\"HERMES_SESSION_CHAT_NAME\", \"Group\")\n- monkeypatch.setenv(\"HERMES_SESSION_THREAD_ID\", \"17585\")\n+ monkeypatch.delenv(\"HERMES_SESSION_PLATFORM\", raising=False)\n+ monkeypatch.delenv(\"HERMES_SESSION_CHAT_ID\", raising=False)\n+ monkeypatch.delenv(\"HERMES_SESSION_CHAT_NAME\", raising=False)\n+ monkeypatch.delenv(\"HERMES_SESSION_THREAD_ID\", raising=False)\n+\n+ source = SessionSource(\n+ platform=Platform.TELEGRAM,\n+ chat_id=\"-1001\",\n+ chat_name=\"Group\",\n+ chat_type=\"group\",\n+ thread_id=\"17585\",\n+ )\n+ context = SessionContext(source=source, connected_platforms=[], home_channels={})\n+\n+ tokens = [redacted:secret-assignment]\n+ assert get_session_env(\"HERMES_SESSION_PLATFORM\") == \"telegram\"\n \n- runner._clear_session_env()\n+ runner._clear_session_env(tokens)\n \n- assert os.getenv(\"HERMES_SESSION_PLATFORM\") is None\n- assert os.getenv(\"HERMES_SESSION_CHAT_ID\") is None\n- assert os.getenv(\"HERMES_SESSION_CHAT_NAME\") is None\n- assert os.getenv(\"HERMES_SESSION_THREAD_ID\") is None\n+ # After clear, contextvars should return to defaults (empty)\n+ assert get_session_env(\"HERMES_SESSION_PLATFORM\") == \"\"\n+ assert get_session_env(\"HERMES_SESSION_CHAT_ID\") == \"\"\n+ assert get_session_env(\"HERMES_SESSION_CHAT_NAME\") == \"\"\n+ assert get_session_env(\"HERMES_SESSION_THREAD_ID\") == \"\"\n+\n+\n+def test_get_session_env_falls_back_to_os_environ(monkeypatch):\n+ \"\"\"get_session_env should fall back to os.environ when contextvar is unset.\"\"\"\n+ monkeypatch.setenv(\"HERMES_SESSION_PLATFORM\", \"discord\")\n+\n+ # No contextvar set — should read from os.environ\n+ assert get_session_env(\"HERMES_SESSION_PLATFORM\") == \"discord\"\n+\n+ # Now set a contextvar — should prefer it\n+ tokens = [redacted:secret-assignment]\"telegram\")\n+ assert get_session_env(\"HERMES_SESSION_PLATFORM\") == \"telegram\"\n+\n+ # Restore — should fall back to os.environ again\n+ clear_session_vars(tokens)\n+ assert get_session_env(\"HERMES_SESSION_PLATFORM\") == \"discord\"\n+\n+\n+def test_get_session_env_default_when_nothing_set(monkeypatch):\n+ \"\"\"get_session_env returns default when neither contextvar nor env is set.\"\"\"\n+ monkeypatch.delenv(\"HERMES_SESSION_PLATFORM\", raising=False)\n+\n+ assert get_session_env(\"HERMES_SESSION_PLATFORM\") == \"\"\n+ assert get_session_env(\"HERMES_SESSION_PLATFORM\", \"fallback\") == \"fallback\"\n+\n+\n+def test_set_session_env_handles_missing_optional_fields():\n+ \"\"\"_set_session_env should handle None chat_name and thread_id gracefully.\"\"\"\n+ runner = object.__new__(GatewayRunner)\n+ source = SessionSource(\n+ platform=Platform.TELEGRAM,\n+ chat_id=\"-1001\",\n+ chat_name=None,\n+ chat_type=\"private\",\n+ thread_id=None,\n+ )\n+ context = SessionContext(source=source, connected_platforms=[], home_channels={})\n+\n+ tokens = [redacted:secret-assignment]\n+\n+ assert get_session_env(\"HERMES_SESSION_PLATFORM\") == \"telegram\"\n+ assert get_session_env(\"HERMES_SESSION_CHAT_ID\") == \"-1001\"\n+ assert get_session_env(\"HERMES_SESSION_CHAT_NAME\") == \"\"\n+ assert get_session_env(\"HERMES_SESSION_THREAD_ID\") == \"\"\n+\n+ runner._clear_session_env(tokens)"]},{"file":"tools/cronjob_tools.py","hunks":["@@ -64,14 +64,15 @@ def _scan_cron_prompt(prompt: str) -> str:\n \n \n def _origin_from_env() -> Optional[Dict[str, str]]:\n- origin_platform = os.getenv(\"HERMES_SESSION_PLATFORM\")\n- origin_chat_id = os.getenv(\"HERMES_SESSION_CHAT_ID\")\n+ from gateway.session_context import get_session_env\n+ origin_platform = get_session_env(\"HERMES_SESSION_PLATFORM\")\n+ origin_chat_id = get_session_env(\"HERMES_SESSION_CHAT_ID\")\n if origin_platform and origin_chat_id:\n return {\n \"platform\": origin_platform,\n \"chat_id\": origin_chat_id,\n- \"chat_name\": os.getenv(\"HERMES_SESSION_CHAT_NAME\"),\n- \"thread_id\": os.getenv(\"HERMES_SESSION_THREAD_ID\"),\n+ \"chat_name\": get_session_env(\"HERMES_SESSION_CHAT_NAME\") or None,\n+ \"thread_id\": get_session_env(\"HERMES_SESSION_THREAD_ID\") or None,\n }\n return None\n "]},{"file":"tools/send_message_tool.py","hunks":["@@ -212,7 +212,8 @@ def _handle_send(args):\n if isinstance(result, dict) and result.get(\"success\") and mirror_text:\n try:\n from gateway.mirror import mirror_to_session\n- source_label = os.getenv(\"HERMES_SESSION_PLATFORM\", \"cli\")\n+ from gateway.session_context import get_session_env\n+ source_label = get_session_env(\"HERMES_SESSION_PLATFORM\", \"cli\")\n if mirror_to_session(platform_name, chat_id, mirror_text, source_label=source_label, thread_id=thread_id):\n result[\"mirrored\"] = True\n except Exception:","@@ -1020,7 +1021,8 @@ async def _send_feishu(pconfig, chat_id, message, media_files=None, thread_id=No\n \n def _check_send_message():\n \"\"\"Gate send_message on gateway running (always available on messaging platforms).\"\"\"\n- platform = os.getenv(\"HERMES_SESSION_PLATFORM\", \"\")\n+ from gateway.session_context import get_session_env\n+ platform = get_session_env(\"HERMES_SESSION_PLATFORM\", \"\")\n if platform and platform != \"local\":\n return True\n try:"]},{"file":"tools/skills_tool.py","hunks":["@@ -347,7 +347,8 @@ def _capture_required_environment_variables(\n def _is_gateway_surface() -> bool:\n if os.getenv(\"HERMES_GATEWAY_SESSION\"):\n return True\n- return bool(os.getenv(\"HERMES_SESSION_PLATFORM\"))\n+ from gateway.session_context import get_session_env\n+ return bool(get_session_env(\"HERMES_SESSION_PLATFORM\"))\n \n \n def _get_terminal_backend_name() -> str:"]},{"file":"tools/terminal_tool.py","hunks":["@@ -1420,10 +1420,11 @@ def terminal_tool(\n # In gateway mode, auto-register a fast watcher so the\n # gateway can detect completion and trigger a new agent\n # turn. CLI mode uses the completion_queue directly.\n- _gw_platform = os.getenv(\"HERMES_SESSION_PLATFORM\", \"\")\n+ from gateway.session_context import get_session_env as _gse\n+ _gw_platform = _gse(\"HERMES_SESSION_PLATFORM\", \"\")\n if _gw_platform and not check_interval:\n- _gw_chat_id = os.getenv(\"HERMES_SESSION_CHAT_ID\", \"\")\n- _gw_thread_id = os.getenv(\"HERMES_SESSION_THREAD_ID\", \"\")\n+ _gw_chat_id = _gse(\"HERMES_SESSION_CHAT_ID\", \"\")\n+ _gw_thread_id = _gse(\"HERMES_SESSION_THREAD_ID\", \"\")\n proc_session.watcher_platform = _gw_platform\n proc_session.watcher_chat_id = _gw_chat_id\n proc_session.watcher_thread_id = _gw_thread_id","@@ -1445,9 +1446,10 @@ def terminal_tool(\n result_data[\"check_interval_note\"] = (\n f\"Requested {check_interval}s raised to minimum 30s\"\n )\n- watcher_platform = os.getenv(\"HERMES_SESSION_PLATFORM\", \"\")\n- watcher_chat_id = os.getenv(\"HERMES_SESSION_CHAT_ID\", \"\")\n- watcher_thread_id = os.getenv(\"HERMES_SESSION_THREAD_ID\", \"\")\n+ from gateway.session_context import get_session_env as _gse2\n+ watcher_platform = _gse2(\"HERMES_SESSION_PLATFORM\", \"\")\n+ watcher_chat_id = _gse2(\"HERMES_SESSION_CHAT_ID\", \"\")\n+ watcher_thread_id = _gse2(\"HERMES_SESSION_THREAD_ID\", \"\")\n \n # Store on session for checkpoint persistence\n proc_session.watcher_platform = watcher_platform"]},{"file":"tools/tts_tool.py","hunks":["@@ -480,7 +480,8 @@ def text_to_speech_tool(\n # Telegram voice bubbles require Opus (.ogg); OpenAI and ElevenLabs can\n # produce Opus natively (no ffmpeg needed). Edge TTS always outputs MP3\n # and needs ffmpeg for conversion.\n- platform = os.getenv(\"HERMES_SESSION_PLATFORM\", \"\").lower()\n+ from gateway.session_context import get_session_env\n+ platform = get_session_env(\"HERMES_SESSION_PLATFORM\", \"\").lower()\n want_opus = (platform == \"telegram\")\n \n # Determine output path\n"]}]},{"kind":"pr","number":9537,"title":"fix(gateway): route synthetic background events to their originating session","url":null,"state":"closed","close_reason":{"refs":[{"kind":"pr","value":"#10460","number":10460},{"kind":"pr","value":"#10446","number":10446}],"category":"merged_via","implication":"superseded"},"merged":false},{"kind":"pr","number":10446,"title":"fix(gateway): route watch-pattern notifications to originating session","url":null,"state":"closed","close_reason":{"refs":[{"kind":"pr","value":"#10460","number":10460},{"kind":"pr","value":"#9537","number":9537}],"category":"merged_via","implication":"superseded"},"merged":false},{"kind":"pr","number":10460,"title":"fix(gateway): route watch-pattern notifications to originating session","url":null,"state":"merged","close_reason":{"category":"merged","implication":"superseded"},"merged":true,"is_fix_pr":true,"fix_tier":"verified","files_changed":["gateway/run.py","tests/gateway/test_background_process_notifications.py","tests/gateway/test_internal_event_bypass_pairing.py","tests/tools/test_watch_patterns.py","tools/process_registry.py","tools/terminal_tool.py"],"fix_hunks":[{"file":"gateway/run.py","hunks":["@@ -482,6 +482,27 @@ def _resolve_hermes_bin() -> Optional[list[str]]:\n return None\n \n \n+def _parse_session_key(session_key: str) -> \"dict | None\":\n+ \"\"\"Parse a session key into its component parts.\n+\n+ Session keys follow the format\n+ ``agent:main:{platform}:{chat_type}:{chat_id}[:{thread_id}[:{user_id}]]``.\n+ Returns a dict with ``platform``, ``chat_type``, ``chat_id``, and\n+ optionally ``thread_id`` keys, or None if the key doesn't match.\n+ \"\"\"\n+ parts = session_key.split(\":\")\n+ if len(parts) >= 5 and parts[0] == \"agent\" and parts[1] == \"main\":\n+ result = {\n+ \"platform\": parts[2],\n+ \"chat_type\": parts[3],\n+ \"chat_id\": parts[4],\n+ }\n+ if len(parts) > 5:\n+ result[\"thread_id\"] = parts[5]\n+ return result\n+ return None\n+\n+\n def _format_gateway_process_notification(evt: dict) -> \"str | None\":\n \"\"\"Format a watch pattern event from completion_queue into a [SYSTEM:] message.\"\"\"\n evt_type = evt.get(\"type\", \"completion\")","@@ -1489,12 +1510,11 @@ async def _notify_active_sessions_of_shutdown(self) -> None:\n notified: set = set()\n for session_key in active:\n # Parse platform + chat_id from the session key.\n- # Format: agent:main:{platform}:{chat_type}:{chat_id}[:{extra}...]\n- parts = session_key.split(\":\")\n- if len(parts) < 5:\n+ _parsed = _parse_session_key(session_key)\n+ if not _parsed:\n continue\n- platform_str = parts[2]\n- chat_id = parts[4]\n+ platform_str = _parsed[\"platform\"]\n+ chat_id = _parsed[\"chat_id\"]\n \n # Deduplicate: one notification per chat, even if multiple\n # sessions (different users/threads) share the same chat.","@@ -1510,7 +1530,7 @@ async def _notify_active_sessions_of_shutdown(self) -> None:\n \n # Include thread_id if present so the message lands in the\n # correct forum topic / thread.\n- thread_id = parts[5] if len(parts) > 5 else None\n+ thread_id = _parsed.get(\"thread_id\")\n metadata = {\"thread_id\": thread_id} if thread_id else None\n \n await adapter.send(chat_id, msg, metadata=metadata)","@@ -3958,7 +3978,7 @@ async def _handle_message_with_agent(self, event, source, _quick_key: str):\n synth_text = _format_gateway_process_notification(evt)\n if synth_text:\n try:\n- await self._inject_watch_notification(synth_text, event)\n+ await self._inject_watch_notification(synth_text, evt)\n except Exception as e2:\n logger.error(\"Watch notification injection error: %s\", e2)\n except Exception as e:","@@ -7452,14 +7472,75 @@ async def _enrich_message_with_transcription(\n return prefix\n return user_text\n \n- async def _inject_watch_notification(self, synth_text: str, original_event) -> None:\n+ def _build_process_event_source(self, evt: dict):\n+ \"\"\"Resolve the canonical source for a synthetic background-process event.\n+\n+ Prefer the persisted session-store origin for the event's session key.\n+ Falling back to the currently active foreground event is what causes\n+ cross-topic bleed, so don't do that.\n+ \"\"\"\n+ from gateway.session import SessionSource\n+\n+ session_key = str(evt.get(\"session_key\") or \"\").strip()\n+ derived_platform = \"\"\n+ derived_chat_type = \"\"\n+ derived_chat_id = \"\"\n+\n+ if session_key:\n+ try:\n+ self.session_store._ensure_loaded()\n+ entry = self.session_store._entries.get(session_key)\n+ if entry and getattr(entry, \"origin\", None):\n+ return entry.origin\n+ except Exception as exc:\n+ logger.debug(\n+ \"Synthetic process-event session-store lookup failed for %s: %s\",\n+ session_key,\n+ exc,\n+ )\n+\n+ _parsed = _parse_session_key(session_key)\n+ if _parsed:\n+ derived_platform = _parsed[\"platform\"]\n+ derived_chat_type = _parsed[\"chat_type\"]\n+ derived_chat_id = _parsed[\"chat_id\"]\n+\n+ platform_name = str(evt.get(\"platform\") or derived_platform or \"\").strip().lower()\n+ chat_type = str(evt.get(\"chat_type\") or derived_chat_type or \"\").strip().lower()\n+ chat_id = str(evt.get(\"chat_id\") or derived_chat_id or \"\").strip()\n+ if not platform_name or not chat_type or not chat_id:\n+ return None\n+\n+ try:\n+ platform = Platform(platform_name)\n+ except Exception:\n+ logger.warning(\n+ \"Synthetic process event has invalid platform metadata: %r\",\n+ platform_name,\n+ )\n+ return None\n+\n+ return SessionSource(\n+ platform=platform,\n+ chat_id=chat_id,\n+ chat_type=chat_type,\n+ thread_id=str(evt.get(\"thread_id\") or \"\").strip() or None,\n+ user_id=str(evt.get(\"user_id\") or \"\").strip() or None,\n+ user_name=str(evt.get(\"user_name\") or \"\").strip() or None,\n+ )\n+\n+ async def _inject_watch_notification(self, synth_text: str, evt: dict) -> None:\n \"\"\"Inject a watch-pattern notification as a synthetic message event.\n \n- Uses the source from the original user event to route the notification\n- back to the correct chat/adapter.\n+ Routing must come from the queued watch event itself, not from whatever\n+ foreground message happened to be active when the queue was drained.\n \"\"\"\n- source = getattr(original_event, \"source\", None)\n+ source = self._build_process_event_source(evt)\n if not source:\n+ logger.warning(\n+ \"Dropping watch notification with no routing metadata for process %s\",\n+ evt.get(\"session_id\", \"unknown\"),\n+ )\n return\n platform_name = source.platform.value if hasattr(source.platform, \"value\") else str(source.platform)\n adapter = None","@@ -7477,7 +7558,12 @@ async def _inject_watch_notification(self, synth_text: str, original_event) -> N\n source=source,\n internal=True,\n )\n- logger.info(\"Watch pattern notification — injecting for %s\", platform_name)\n+ logger.info(\n+ \"Watch pattern notification — injecting for %s chat=%s thread=%s\",\n+ platform_name,\n+ source.chat_id,\n+ source.thread_id,\n+ )\n await adapter.handle_message(synth_event)\n except Exception as e:\n logger.error(\"Watch notification injection error: %s\", e)","@@ -7547,33 +7633,42 @@ async def _run_process_watcher(self, watcher: dict) -> None:\n f\"Command: {session.command}\\n\"\n f\"Output:\\n{_out}]\"\n )\n+ source = self._build_process_event_source({\n+ \"session_id\": session_id,\n+ \"session_key\": session_key,\n+ \"platform\": platform_name,\n+ \"chat_id\": chat_id,\n+ \"thread_id\": thread_id,\n+ \"user_id\": user_id,\n+ \"user_name\": user_name,\n+ })\n+ if not source:\n+ logger.warning(\n+ \"Dropping completion notification with no routing metadata for process %s\",\n+ session_id,\n+ )\n+ break\n+\n adapter = None\n for p, a in self.adapters.items():\n- if p.value == platform_name:\n+ if p == source.platform:\n adapter = a\n break\n- if adapter and chat_id:\n+ if adapter and source.chat_id:\n try:\n from gateway.platforms.base import MessageEvent, MessageType\n- from gateway.session import SessionSource\n- from gateway.config import Platform\n- _platform_enum = Platform(platform_name)\n- _source = SessionSource(\n- platform=_platform_enum,\n- chat_id=chat_id,\n- thread_id=thread_id or None,\n- user_id=user_id or None,\n- user_name=user_name or None,\n- )\n synth_event = MessageEvent(\n text=synth_text,\n message_type=MessageType.TEXT,\n- source=_source,\n+ source=source,\n internal=True,\n )\n logger.info(\n- \"Process %s finished — injecting agent notification for session %s\",\n- session_id, session_key,\n+ \"Process %s finished — injecting agent notification for session %s chat=%s thread=%s\",\n+ session_id,\n+ session_key,\n+ source.chat_id,\n+ source.thread_id,\n )\n await adapter.handle_message(synth_event)\n except Exception as e:"]},{"file":"tests/gateway/test_background_process_notifications.py","hunks":["@@ -14,7 +14,7 @@\n import pytest\n \n from gateway.config import GatewayConfig, Platform\n-from gateway.run import GatewayRunner\n+from gateway.run import GatewayRunner, _parse_session_key\n \n \n # ---------------------------------------------------------------------------","@@ -45,7 +45,7 @@ def _build_runner(monkeypatch, tmp_path, mode: str) -> GatewayRunner:\n monkeypatch.setattr(gateway_run, \"_hermes_home\", tmp_path)\n \n runner = GatewayRunner(GatewayConfig())\n- adapter = SimpleNamespace(send=AsyncMock())\n+ adapter = SimpleNamespace(send=AsyncMock(), handle_message=AsyncMock())\n runner.adapters[Platform.TELEGRAM] = adapter\n return runner\n ","@@ -243,3 +243,162 @@ async def _instant_sleep(*_a, **_kw):\n assert adapter.send.await_count == 1\n _, kwargs = adapter.send.call_args\n assert kwargs[\"metadata\"] is None\n+\n+\n[redacted:email]\n+async def test_inject_watch_notification_routes_from_session_store_origin(monkeypatch, tmp_path):\n+ from gateway.session import SessionSource\n+\n+ runner = _build_runner(monkeypatch, tmp_path, \"all\")\n+ adapter = runner.adapters[Platform.TELEGRAM]\n+ runner.session_store._entries[\"agent:main:telegram:group:-100:42\"] = SimpleNamespace(\n+ origin=SessionSource(\n+ platform=Platform.TELEGRAM,\n+ chat_id=\"-100\",\n+ chat_type=\"group\",\n+ thread_id=\"42\",\n+ user_id=\"123\",\n+ user_name=\"Emiliyan\",\n+ )\n+ )\n+\n+ evt = {\n+ \"session_id\": \"proc_watch\",\n+ \"session_key\": \"agent:main:telegram:group:-100:42\",\n+ }\n+\n+ await runner._inject_watch_notification(\"[SYSTEM: Background process matched]\", evt)\n+\n+ adapter.handle_message.assert_awaited_once()\n+ synth_event = adapter.handle_message.await_args.args[0]\n+ assert synth_event.internal is True\n+ assert synth_event.source.platform == Platform.TELEGRAM\n+ assert synth_event.source.chat_id == \"-100\"\n+ assert synth_event.source.chat_type == \"group\"\n+ assert synth_event.source.thread_id == \"42\"\n+ assert synth_event.source.user_id == \"123\"\n+ assert synth_event.source.user_name == \"Emiliyan\"\n+\n+\n+def test_build_process_event_source_falls_back_to_session_key_chat_type(monkeypatch, tmp_path):\n+ runner = _build_runner(monkeypatch, tmp_path, \"all\")\n+\n+ evt = {\n+ \"session_id\": \"proc_watch\",\n+ \"session_key\": \"agent:main:telegram:group:-100:42\",\n+ \"platform\": \"telegram\",\n+ \"chat_id\": \"-100\",\n+ \"thread_id\": \"42\",\n+ \"user_id\": \"123\",\n+ \"user_name\": \"Emiliyan\",\n+ }\n+\n+ source = runner._build_process_event_source(evt)\n+\n+ assert source is not None\n+ assert source.platform == Platform.TELEGRAM\n+ assert source.chat_id == \"-100\"\n+ assert source.chat_type == \"group\"\n+ assert source.thread_id == \"42\"\n+ assert source.user_id == \"123\"\n+ assert source.user_name == \"Emiliyan\"\n+\n+\n[redacted:email]\n+async def test_inject_watch_notification_ignores_foreground_event_source(monkeypatch, tmp_path):\n+ \"\"\"Negative test: watch notification must NOT route to the foreground thread.\"\"\"\n+ from gateway.session import SessionSource\n+\n+ runner = _build_runner(monkeypatch, tmp_path, \"all\")\n+ adapter = runner.adapters[Platform.TELEGRAM]\n+\n+ # Session store has the process's original thread (thread 42)\n+ runner.session_store._entries[\"agent:main:telegram:group:-100:42\"] = SimpleNamespace(\n+ origin=SessionSource(\n+ platform=Platform.TELEGRAM,\n+ chat_id=\"-100\",\n+ chat_type=\"group\",\n+ thread_id=\"42\",\n+ user_id=\"proc_owner\",\n+ user_name=\"alice\",\n+ )\n+ )\n+\n+ # The evt dict carries the correct session_key — NOT a foreground event\n+ evt = {\n+ \"session_id\": \"proc_cross_thread\",\n+ \"session_key\": \"agent:main:telegram:group:-100:42\",\n+ }\n+\n+ await runner._inject_watch_notification(\"[SYSTEM: watch match]\", evt)\n+\n+ adapter.handle_message.assert_awaited_once()\n+ synth_event = adapter.handle_message.await_args.args[0]\n+ # Must route to thread 42 (process origin), NOT some other thread\n+ assert synth_event.source.thread_id == \"42\"\n+ assert synth_event.source.user_id == \"proc_owner\"\n+\n+\n+def test_build_process_event_source_returns_none_for_empty_evt(monkeypatch, tmp_path):\n+ \"\"\"Missing session_key and no platform metadata → None (drop notification).\"\"\"\n+ runner = _build_runner(monkeypatch, tmp_path, \"all\")\n+\n+ source = runner._build_process_event_source({\"session_id\": \"proc_orphan\"})\n+ assert source is None\n+\n+\n+def test_build_process_event_source_returns_none_for_invalid_platform(monkeypatch, tmp_path):\n+ \"\"\"Invalid platform string → None.\"\"\"\n+ runner = _build_runner(monkeypatch, tmp_path, \"all\")\n+\n+ evt = {\n+ \"session_id\": \"proc_bad\",\n+ \"platform\": \"not_a_real_platform\",\n+ \"chat_type\": \"dm\",\n+ \"chat_id\": \"123\",\n+ }\n+ source = runner._build_process_event_source(evt)\n+ assert source is None\n+\n+\n+def test_build_process_event_source_returns_none_for_short_session_key(monkeypatch, tmp_path):\n+ \"\"\"Session key with <5 parts doesn't parse, falls through to empty metadata → None.\"\"\"\n+ runner = _build_runner(monkeypatch, tmp_path, \"all\")\n+\n+ evt = {\n+ \"session_id\": \"proc_short\",\n+ \"session_key\": \"agent:main:telegram\", # Too few parts\n+ }\n+ source = runner._build_process_event_source(evt)\n+ assert source is None\n+\n+\n+# ---------------------------------------------------------------------------\n+# _parse_session_key helper\n+# ---------------------------------------------------------------------------\n+\n+def test_parse_session_key_valid():\n+ result = _parse_session_key(\"agent:main:telegram:group:-100\")\n+ assert result == {\"platform\": \"telegram\", \"chat_type\": \"group\", \"chat_id\": \"-100\"}\n+\n+\n+def test_parse_session_key_with_extra_parts():\n+ \"\"\"Thread ID (6th part) is extracted; further parts are ignored.\"\"\"\n+ result = _parse_session_key(\"agent:main:discord:group:chan123:thread456\")\n+ assert result == {\"platform\": \"discord\", \"chat_type\": \"group\", \"chat_id\": \"chan123\", \"thread_id\": \"thread456\"}\n+\n+\n+def test_parse_session_key_with_user_id_part():\n+ \"\"\"7th part (user_id) is ignored — only up to thread_id is extracted.\"\"\"\n+ result = _parse_session_key(\"agent:main:telegram:group:chat1:thread42:user99\")\n+ assert result == {\"platform\": \"telegram\", \"chat_type\": \"group\", \"chat_id\": \"chat1\", \"thread_id\": \"thread42\"}\n+\n+\n+def test_parse_session_key_too_short():\n+ assert _parse_session_key(\"agent:main:telegram\") is None\n+ assert _parse_session_key(\"\") is None\n+\n+\n+def test_parse_session_key_wrong_prefix():\n+ assert _parse_session_key(\"cron:main:telegram:dm:123\") is None\n+ assert _parse_session_key(\"agent:cron:telegram:dm:123\") is None"]},{"file":"tests/gateway/test_internal_event_bypass_pairing.py","hunks":["@@ -230,6 +230,59 @@ async def _instant_sleep(*_a, **_kw):\n assert event.source.user_name == \"alice\"\n \n \n[redacted:email]\n+async def test_notify_on_complete_uses_session_store_origin_for_group_topic(monkeypatch, tmp_path):\n+ import tools.process_registry as pr_module\n+ from gateway.session import SessionSource\n+\n+ sessions = [\n+ SimpleNamespace(\n+ output_buffer=\"done\\n\", exited=True, exit_code=0, command=\"echo test\"\n+ ),\n+ ]\n+ monkeypatch.setattr(pr_module, \"process_registry\", _FakeRegistry(sessions))\n+\n+ async def _instant_sleep(*_a, **_kw):\n+ pass\n+ monkeypatch.setattr(asyncio, \"sleep\", _instant_sleep)\n+\n+ runner = GatewayRunner(GatewayConfig())\n+ adapter = SimpleNamespace(send=AsyncMock(), handle_message=AsyncMock())\n+ runner.adapters[Platform.TELEGRAM] = adapter\n+ runner.session_store._entries[\"agent:main:telegram:group:-100:42\"] = SimpleNamespace(\n+ origin=SessionSource(\n+ platform=Platform.TELEGRAM,\n+ chat_id=\"-100\",\n+ chat_type=\"group\",\n+ thread_id=\"42\",\n+ user_id=\"user-42\",\n+ user_name=\"alice\",\n+ )\n+ )\n+\n+ watcher = {\n+ \"session_id\": \"proc_test_internal\",\n+ \"check_interval\": 0,\n+ \"session_key\": \"agent:main:telegram:group:-100:42\",\n+ \"platform\": \"telegram\",\n+ \"chat_id\": \"-100\",\n+ \"thread_id\": \"42\",\n+ \"notify_on_complete\": True,\n+ }\n+\n+ await runner._run_process_watcher(watcher)\n+\n+ assert adapter.handle_message.await_count == 1\n+ event = adapter.handle_message.await_args.args[0]\n+ assert event.internal is True\n+ assert event.source.platform == Platform.TELEGRAM\n+ assert event.source.chat_id == \"-100\"\n+ assert event.source.chat_type == \"group\"\n+ assert event.source.thread_id == \"42\"\n+ assert event.source.user_id == \"user-42\"\n+ assert event.source.user_name == \"alice\"\n+\n+\n @pytest.mark.asyncio\n async def test_none_user_id_skips_pairing(monkeypatch, tmp_path):\n \"\"\"A non-internal event with user_id=None should be silently dropped.\"\"\""]},{"file":"tests/tools/test_watch_patterns.py","hunks":["@@ -92,6 +92,25 @@ def test_basic_match(self, registry):\n assert \"disk full\" in evt[\"output\"]\n assert evt[\"session_id\"] == \"proc_test_watch\"\n \n+ def test_match_carries_session_key_and_watcher_routing_metadata(self, registry):\n+ session = _make_session(watch_patterns=[\"ERROR\"])\n+ session.session_key = \"agent:main:telegram:group:-100:42\"\n+ session.watcher_platform = \"telegram\"\n+ session.watcher_chat_id = \"-100\"\n+ session.watcher_user_id = \"u123\"\n+ session.watcher_user_name = \"alice\"\n+ session.watcher_thread_id = \"42\"\n+\n+ registry._check_watch_patterns(session, \"ERROR: disk full\\n\")\n+ evt = registry.completion_queue.get_nowait()\n+\n+ assert evt[\"session_key\"] == \"agent:main:telegram:group:-100:42\"\n+ assert evt[\"platform\"] == \"telegram\"\n+ assert evt[\"chat_id\"] == \"-100\"\n+ assert evt[\"user_id\"] == \"u123\"\n+ assert evt[\"user_name\"] == \"alice\"\n+ assert evt[\"thread_id\"] == \"42\"\n+\n def test_multiple_patterns(self, registry):\n \"\"\"First matching pattern is reported.\"\"\"\n session = _make_session(watch_patterns=[\"WARN\", \"ERROR\"])"]},{"file":"tools/process_registry.py","hunks":["@@ -191,9 +191,15 @@ def _check_watch_patterns(self, session: ProcessSession, new_text: str) -> None:\n session._watch_disabled = True\n self.completion_queue.put({\n \"session_id\": session.id,\n+ \"session_key\": session.session_key,\n \"command\": session.command,\n \"type\": \"watch_disabled\",\n \"suppressed\": session._watch_suppressed,\n+ \"platform\": session.watcher_platform,\n+ \"chat_id\": session.watcher_chat_id,\n+ \"user_id\": session.watcher_user_id,\n+ \"user_name\": session.watcher_user_name,\n+ \"thread_id\": session.watcher_thread_id,\n \"message\": (\n f\"Watch patterns disabled for process {session.id} — \"\n f\"too many matches ({session._watch_suppressed} suppressed). \"","@@ -219,11 +225,17 @@ def _check_watch_patterns(self, session: ProcessSession, new_text: str) -> None:\n \n self.completion_queue.put({\n \"session_id\": session.id,\n+ \"session_key\": session.session_key,\n \"command\": session.command,\n \"type\": \"watch_match\",\n \"pattern\": matched_pattern,\n \"output\": output,\n \"suppressed\": suppressed,\n+ \"platform\": session.watcher_platform,\n+ \"chat_id\": session.watcher_chat_id,\n+ \"user_id\": session.watcher_user_id,\n+ \"user_name\": session.watcher_user_name,\n+ \"thread_id\": session.watcher_thread_id,\n })\n \n @staticmethod"]},{"file":"tools/terminal_tool.py","hunks":["@@ -1384,14 +1384,10 @@ def terminal_tool(\n if pty_disabled_reason:\n result_data[\"pty_note\"] = pty_disabled_reason\n \n- # Mark for agent notification on completion\n- if notify_on_complete and background:\n- proc_session.notify_on_complete = True\n- result_data[\"notify_on_complete\"] = True\n-\n- # In gateway mode, auto-register a fast watcher so the\n- # gateway can detect completion and trigger a new agent\n- # turn. CLI mode uses the completion_queue directly.\n+ # Populate routing metadata on the session so that\n+ # watch-pattern and completion notifications can be\n+ # routed back to the correct chat/thread.\n+ if background and (notify_on_complete or watch_patterns):\n from gateway.session_context import get_session_env as _gse\n _gw_platform = _gse(\"HERMES_SESSION_PLATFORM\", \"\")\n if _gw_platform:","@@ -1404,16 +1400,26 @@ def terminal_tool(\n proc_session.watcher_user_id = _gw_user_id\n proc_session.watcher_user_name = _gw_user_name\n proc_session.watcher_thread_id = _gw_thread_id\n+\n+ # Mark for agent notification on completion\n+ if notify_on_complete and background:\n+ proc_session.notify_on_complete = True\n+ result_data[\"notify_on_complete\"] = True\n+\n+ # In gateway mode, auto-register a fast watcher so the\n+ # gateway can detect completion and trigger a new agent\n+ # turn. CLI mode uses the completion_queue directly.\n+ if proc_session.watcher_platform:\n proc_session.watcher_interval = 5\n process_registry.pending_watchers.append({\n \"session_id\": proc_session.id,\n \"check_interval\": 5,\n \"session_key\": session_key,\n- \"platform\": _gw_platform,\n- \"chat_id\": _gw_chat_id,\n- \"user_id\": _gw_user_id,\n- \"user_name\": _gw_user_name,\n- \"thread_id\": _gw_thread_id,\n+ \"platform\": proc_session.watcher_platform,\n+ \"chat_id\": proc_session.watcher_chat_id,\n+ \"user_id\": proc_session.watcher_user_id,\n+ \"user_name\": proc_session.watcher_user_name,\n+ \"thread_id\": proc_session.watcher_thread_id,\n \"notify_on_complete\": True,\n })\n \n"]}]},{"kind":"pr","number":12918,"title":"fix(gateway): route watch notifications to correct Discord thread (#10411)","url":null,"state":"open","close_reason":{"refs":[{"kind":"commit","value":"dee592a0b","number":0}],"category":"uncategorized","implication":"needs_llm"},"merged":false},{"kind":"pr","number":18337,"title":"fix: resolve 7 identified issues [automated]","url":null,"state":"open","close_reason":{"refs":[{"kind":"commit","value":"88bd1c01e","number":0},{"kind":"commit","value":"9caa12f4e","number":0}],"category":"implemented_elsewhere","implication":"superseded"},"merged":false},{"kind":"pr","number":26945,"title":"fix(telegram): preserve DM topic routing for synthetic background process events","url":null,"state":"closed","close_reason":{"refs":[{"kind":"pr","value":"#27212","number":27212},{"kind":"pr","value":"#9532","number":9532},{"kind":"pr","value":"#27212","number":27212},{"kind":"pr","value":"#27937","number":27937},{"kind":"pr","value":"#9532","number":9532},{"kind":"pr","value":"#27212","number":27212}],"category":"superseded_by_pr","implication":"superseded"},"merged":false},{"kind":"pr","number":27212,"title":"fix(telegram): reply-anchor background-process notifications into DM topics","url":null,"state":"closed","close_reason":{"refs":[{"kind":"pr","value":"#26945","number":26945}],"category":"merged_via","implication":"superseded"},"merged":false},{"kind":"pr","number":35667,"title":"fix(tui): route completion notifications to owner live session","url":null,"state":"closed","close_reason":{"refs":[{"kind":"pr","value":"#60863","number":60863}],"category":"superseded_by_pr","implication":"superseded"},"merged":false},{"kind":"pr","number":35672,"title":"fix(tui): route process notifications to owner session","url":null,"state":"closed","close_reason":{"refs":[{"kind":"commit","value":"85b65e29f","number":0},{"kind":"pr","value":"#37099","number":37099},{"kind":"pr","value":"#35667","number":35667}],"category":"implemented_elsewhere","implication":"superseded"},"merged":false},{"kind":"pr","number":37099,"title":"feat(desktop): session hygiene, archive, media streaming + connecting overlay","url":null,"state":"merged","close_reason":{"category":"merged","implication":"superseded"},"merged":true,"is_fix_pr":true,"fix_tier":"verified","files_changed":["apps/desktop/electron/main.cjs","apps/desktop/src/app/chat/index.tsx","apps/desktop/src/app/chat/sidebar/index.tsx","apps/desktop/src/app/chat/sidebar/session-actions-menu.tsx","apps/desktop/src/app/chat/sidebar/session-row.tsx","apps/desktop/src/app/chat/sidebar/virtual-session-list.tsx","apps/desktop/src/app/command-center/index.tsx","apps/desktop/src/app/desktop-controller.tsx","apps/desktop/src/app/session/hooks/use-session-actions.ts","apps/desktop/src/app/settings/constants.ts","apps/desktop/src/app/settings/index.tsx","apps/desktop/src/app/settings/sessions-settings.tsx","apps/desktop/src/app/settings/types.ts","apps/desktop/src/components/assistant-ui/markdown-text.tsx","apps/desktop/src/components/gateway-connecting-overlay.tsx","apps/desktop/src/hermes.ts","apps/desktop/src/lib/icons.ts","apps/desktop/src/lib/media.ts","apps/desktop/src/types/hermes.ts","hermes_cli/web_server.py","hermes_state.py","tests/hermes_cli/test_web_server.py","tests/test_hermes_state.py","tests/test_tui_gateway_server.py","tools/process_registry.py","tui_gateway/server.py"],"fix_hunks":[{"file":"apps/desktop/electron/main.cjs","hunks":["@@ -8,6 +8,8 @@ const {\n ipcMain,\n nativeImage,\n nativeTheme,\n+ net: electronNet,\n+ protocol,\n safeStorage,\n session,\n shell,","@@ -364,6 +366,66 @@ app.setAboutPanelOptions({\n copyright: 'Copyright © 2026 Nous Research'\n })\n \n+// Custom scheme for streaming local media (video/audio) into the renderer.\n+// Reading large media through `readFileDataUrl` failed: it base64-loads the\n+// whole file into memory and is hard-capped at DATA_URL_READ_MAX_BYTES (16 MB),\n+// so any non-trivial video silently refused to load. Streaming via a protocol\n+// handler removes the size cap and gives the